diff --git a/CHANGELOG.md b/CHANGELOG.md index 67823fa9..e8ad6c57 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,34 @@ All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. +## [4.1.0-beta.0](https://github.com/DTStack/dt-sql-parser/compare/v4.0.1...v4.1.0-beta.0) (2024-08-27) + + +### Features + +* add alter table stmt ([#312](https://github.com/DTStack/dt-sql-parser/issues/312)) ([5aade9e](https://github.com/DTStack/dt-sql-parser/commit/5aade9e6daafc2c6e70c5202d7ef06572ec37f6e)) +* add benchmark test suite ([#273](https://github.com/DTStack/dt-sql-parser/issues/273)) ([de1bd9d](https://github.com/DTStack/dt-sql-parser/commit/de1bd9de4cb7c3b42d51bedd79635eb91afba9ed)) +* **basicSql:** remove judge splitListener/collectListener, all sqlParser implements it ([#316](https://github.com/DTStack/dt-sql-parser/issues/316)) ([eb2e920](https://github.com/DTStack/dt-sql-parser/commit/eb2e920e345aef98285ba261c2060db61d1d56b8)) +* collect entity's attribute([#333](https://github.com/DTStack/dt-sql-parser/issues/333)) ([a3b6b7e](https://github.com/DTStack/dt-sql-parser/commit/a3b6b7eb8bad2444b16481985278461c35360570)) +* **flinksql:** collect comment, type attribute for entity ([#319](https://github.com/DTStack/dt-sql-parser/issues/319)) ([ae52ebd](https://github.com/DTStack/dt-sql-parser/commit/ae52ebdd6b6d1511cf92eb09521b06bdec66ba0d)), closes [#305](https://github.com/DTStack/dt-sql-parser/issues/305) +* improve errorListener msg ([#281](https://github.com/DTStack/dt-sql-parser/issues/281)) ([deef123](https://github.com/DTStack/dt-sql-parser/commit/deef1238bb25d5bfee80ddaf1fea5ad48178d17b)) +* sync some useful syntax from antlr/grammars-v4 ([95a1087](https://github.com/DTStack/dt-sql-parser/commit/95a108744bb40e418056faaf86bd97b85dd191f8)) +* upgrade trino to 450 ([#323](https://github.com/DTStack/dt-sql-parser/issues/323)) ([2b0de6a](https://github.com/DTStack/dt-sql-parser/commit/2b0de6a3da16561ec52b0c69d4e052226d54a553)) +* use common sql to run benchmark ([#326](https://github.com/DTStack/dt-sql-parser/issues/326)) ([76d0900](https://github.com/DTStack/dt-sql-parser/commit/76d090040e7af26227727673a82f77cda08b3f9e)) + + +### Bug Fixes + +* alert to alterView ([#346](https://github.com/DTStack/dt-sql-parser/issues/346)) ([9ba5100](https://github.com/DTStack/dt-sql-parser/commit/9ba51007e2f21ab8bc42623596ee281801904cfa)) +* **benchmark:** add reports dir judge and remove plsql and include pgsql ([9c534c2](https://github.com/DTStack/dt-sql-parser/commit/9c534c25cacba3cfba6bd234c68e8f27bd90b2e2)) +* build mysql ([5d6ff46](https://github.com/DTStack/dt-sql-parser/commit/5d6ff4662a11acf9f16b1f18c41c204922890df9)) +* createFunction and createFunctionLoadable ([e83449a](https://github.com/DTStack/dt-sql-parser/commit/e83449a0cc0a50be510c7b4a3337597b1890fc92)) +* flinksql function params add more time functions ([#347](https://github.com/DTStack/dt-sql-parser/issues/347)) ([b835c4b](https://github.com/DTStack/dt-sql-parser/commit/b835c4b5b506c8e4bf0bd9c99fe66c15e53a179b)) +* **impala:** fix alter table change statement ([#332](https://github.com/DTStack/dt-sql-parser/issues/332)) ([4a9681e](https://github.com/DTStack/dt-sql-parser/commit/4a9681ed3bd188e41c30a6d7be39d6e77df7f61b)) +* mysql case when ([#317](https://github.com/DTStack/dt-sql-parser/issues/317)) ([fea1ad1](https://github.com/DTStack/dt-sql-parser/commit/fea1ad1a357b70291a240eca6d2058bab9b49469)) +* **postgresql:** combine plsql_unreserved_keyword to unreserved_keyword and remove unused rules ([7884cbe](https://github.com/DTStack/dt-sql-parser/commit/7884cbe37844c057fa41fde4d0716af43c4023af)) +* spell check ([#337](https://github.com/DTStack/dt-sql-parser/issues/337)) ([694b0cd](https://github.com/DTStack/dt-sql-parser/commit/694b0cdf15943d02a9402a748155a1b06508af95)) + ### [4.0.2](https://github.com/DTStack/dt-sql-parser/compare/v4.0.1...v4.0.2) (2024-06-19) @@ -61,7 +89,7 @@ All notable changes to this project will be documented in this file. See [standa ### Features -* add toMatchUnorderedArrary matcher and apply it ([#271](https://github.com/DTStack/dt-sql-parser/issues/271)) ([a05f099](https://github.com/DTStack/dt-sql-parser/commit/a05f099aa1ad555c408bc2018240fb4611ec09b8)) +* add toMatchUnorderedArray matcher and apply it ([#271](https://github.com/DTStack/dt-sql-parser/issues/271)) ([a05f099](https://github.com/DTStack/dt-sql-parser/commit/a05f099aa1ad555c408bc2018240fb4611ec09b8)) * collect entity ([#265](https://github.com/DTStack/dt-sql-parser/issues/265)) ([a997211](https://github.com/DTStack/dt-sql-parser/commit/a99721162be0d463b513f53bb13ada6d10168548)), closes [#256](https://github.com/DTStack/dt-sql-parser/issues/256) [#263](https://github.com/DTStack/dt-sql-parser/issues/263) [#268](https://github.com/DTStack/dt-sql-parser/issues/268) * migrate to antlr4ng ([#267](https://github.com/DTStack/dt-sql-parser/issues/267)) ([195878d](https://github.com/DTStack/dt-sql-parser/commit/195878da9bb1ff8011b5d60c02389fa66d2bc0b8)) * **spark:** support materialized view for spark sql ([#262](https://github.com/DTStack/dt-sql-parser/issues/262)) ([5ce89cb](https://github.com/DTStack/dt-sql-parser/commit/5ce89cb421de18330d56e23a4ab5b658b2130a0b)) diff --git a/package.json b/package.json index 6c000cad..96771c33 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "dt-sql-parser", - "version": "4.0.2", + "version": "4.1.0-beta.0", "authors": "DTStack Corporation", "description": "SQL Parsers for BigData, built with antlr4", "keywords": [ @@ -70,7 +70,7 @@ }, "repository": { "type": "git", - "url": "https://github.com/DTStack/dt-sql-parser.git" + "url": "https://github.com/DTStack/dt-sql-parser.git" }, "publishConfig": { "registry": "https://registry.npmjs.org/" @@ -89,6 +89,8 @@ "*": [ "prettier --write --ignore-unknown" ], - "*.g4": ["antlr-format -c ./antlr.format.json -v"] + "*.g4": [ + "antlr-format -c ./antlr.format.json -v" + ] } } diff --git a/src/grammar/flink/FlinkSqlParser.g4 b/src/grammar/flink/FlinkSqlParser.g4 index 9691f5a6..8b5a191f 100644 --- a/src/grammar/flink/FlinkSqlParser.g4 +++ b/src/grammar/flink/FlinkSqlParser.g4 @@ -156,8 +156,9 @@ createTable simpleCreateTable : KW_CREATE KW_TEMPORARY? KW_TABLE ifNotExists? tablePathCreate LR_BRACKET columnOptionDefinition ( COMMA columnOptionDefinition - )* (COMMA watermarkDefinition)? (COMMA tableConstraint)? (COMMA selfDefinitionClause)? RR_BRACKET commentSpec? partitionDefinition? withOption - likeDefinition? + )* (COMMA watermarkDefinition)? (COMMA tableConstraint)? (COMMA selfDefinitionClause)? RR_BRACKET ( + KW_COMMENT comment=STRING_LITERAL + )? partitionDefinition? withOption likeDefinition? ; /* @@ -175,7 +176,7 @@ columnOptionDefinition ; physicalColumnDefinition - : columnNameCreate columnType columnConstraint? commentSpec? + : columnNameCreate columnType columnConstraint? (KW_COMMENT comment=STRING_LITERAL)? ; columnNameCreate @@ -193,8 +194,8 @@ columnNameList ; columnType - : typeName=(KW_DATE | KW_BOOLEAN | KW_NULL) - | typeName=( + : colType=(KW_DATE | KW_BOOLEAN | KW_NULL) + | colType=( KW_CHAR | KW_VARCHAR | KW_STRING @@ -210,12 +211,12 @@ columnType | KW_TIMESTAMP_LTZ | KW_DATETIME ) lengthOneDimension? - | typeName=KW_TIMESTAMP lengthOneDimension? ((KW_WITHOUT | KW_WITH) KW_LOCAL? KW_TIME KW_ZONE)? - | typeName=(KW_DECIMAL | KW_DEC | KW_NUMERIC | KW_FLOAT | KW_DOUBLE) lengthTwoOptionalDimension? - | type=(KW_ARRAY | KW_MULTISET) lengthOneTypeDimension? - | type=KW_MAP mapTypeDimension? - | type=KW_ROW rowTypeDimension? - | type=KW_RAW lengthTwoStringDimension? + | colType=KW_TIMESTAMP lengthOneDimension? ((KW_WITHOUT | KW_WITH) KW_LOCAL? KW_TIME KW_ZONE)? + | colType=(KW_DECIMAL | KW_DEC | KW_NUMERIC | KW_FLOAT | KW_DOUBLE) lengthTwoOptionalDimension? + | colType=(KW_ARRAY | KW_MULTISET) lengthOneTypeDimension? + | colType=KW_MAP mapTypeDimension? + | colType=KW_ROW rowTypeDimension? + | colType=KW_RAW lengthTwoStringDimension? ; lengthOneDimension @@ -247,10 +248,6 @@ columnConstraint | KW_NOT? KW_NULL ; -commentSpec - : KW_COMMENT STRING_LITERAL - ; - metadataColumnDefinition : columnNameCreate columnType KW_METADATA (KW_FROM metadataKey)? KW_VIRTUAL? ; @@ -260,7 +257,7 @@ metadataKey ; computedColumnDefinition - : columnNameCreate KW_AS computedColumnExpression commentSpec? + : columnNameCreate KW_AS computedColumnExpression (KW_COMMENT comment=STRING_LITERAL)? ; // 计算表达式 @@ -316,11 +313,13 @@ createCatalog ; createDatabase - : KW_CREATE KW_DATABASE ifNotExists? databasePathCreate commentSpec? withOption + : KW_CREATE KW_DATABASE ifNotExists? databasePathCreate (KW_COMMENT comment=STRING_LITERAL)? withOption ; createView - : KW_CREATE KW_TEMPORARY? KW_VIEW ifNotExists? viewPathCreate columnNameList? commentSpec? KW_AS queryStatement + : KW_CREATE KW_TEMPORARY? KW_VIEW ifNotExists? viewPathCreate columnNameList? ( + KW_COMMENT comment=STRING_LITERAL + )? KW_AS queryStatement ; createFunction @@ -513,8 +512,8 @@ tableReference ; tablePrimary - : KW_TABLE? tablePath systemTimePeriod? (KW_AS? correlationName)? - | viewPath systemTimePeriod? (KW_AS? correlationName)? + : KW_TABLE? tablePath systemTimePeriod? + | viewPath systemTimePeriod? | KW_LATERAL KW_TABLE LR_BRACKET functionName LR_BRACKET functionParam (COMMA functionParam)* RR_BRACKET RR_BRACKET | KW_LATERAL? LR_BRACKET queryStatement RR_BRACKET | KW_UNNEST LR_BRACKET expression RR_BRACKET @@ -834,7 +833,7 @@ intervalValue ; tableAlias - : KW_AS? identifier identifierList? + : KW_AS? alias=identifier identifierList? ; errorCapturingIdentifier diff --git a/src/grammar/hive/HiveSqlParser.g4 b/src/grammar/hive/HiveSqlParser.g4 index ec50fa3c..80e949fe 100644 --- a/src/grammar/hive/HiveSqlParser.g4 +++ b/src/grammar/hive/HiveSqlParser.g4 @@ -887,7 +887,9 @@ tableConstraint ; columnNameTypeConstraint - : colName=columnNameCreate columnType columnConstraint? (KW_COMMENT comment=StringLiteral)? + : colName=columnNameCreate colType=columnType columnConstraint? ( + KW_COMMENT comment=StringLiteral + )? ; columnConstraint @@ -1363,10 +1365,12 @@ joinToken ; lateralView - : KW_LATERAL KW_VIEW KW_OUTER function_ tableAlias (KW_AS id_ (COMMA id_)*)? + : KW_LATERAL KW_VIEW KW_OUTER function_ alias=tableAlias (KW_AS id_ (COMMA id_)*)? | COMMA? KW_LATERAL ( - KW_VIEW function_ tableAlias (KW_AS id_ (COMMA id_)*)? - | KW_TABLE LPAREN valuesClause RPAREN KW_AS? tableAlias (LPAREN id_ (COMMA id_)* RPAREN)? + KW_VIEW function_ alias=tableAlias (KW_AS id_ (COMMA id_)*)? + | KW_TABLE LPAREN valuesClause RPAREN KW_AS? alias=tableAlias ( + LPAREN id_ (COMMA id_)* RPAREN + )? ) ; diff --git a/src/grammar/impala/ImpalaSqlParser.g4 b/src/grammar/impala/ImpalaSqlParser.g4 index 198db2b3..75cb5889 100644 --- a/src/grammar/impala/ImpalaSqlParser.g4 +++ b/src/grammar/impala/ImpalaSqlParser.g4 @@ -96,20 +96,20 @@ createKuduTableAsSelect : KW_CREATE KW_EXTERNAL? KW_TABLE ifNotExists? tableNameCreate ( LPAREN kuduTableElement (COMMA kuduTableElement)* (COMMA KW_PRIMARY KW_KEY columnAliases)? RPAREN )? (KW_PRIMARY KW_KEY columnAliases?)? (KW_PARTITION KW_BY kuduPartitionClause)? ( - KW_COMMENT stringLiteral + commentClause )? KW_STORED KW_AS KW_KUDU (KW_TBLPROPERTIES tblProp=properties)? (KW_AS queryStatement)? ; createView - : KW_CREATE KW_VIEW ifNotExists? viewNameCreate viewColumns? (KW_COMMENT stringLiteral)? ( + : KW_CREATE KW_VIEW ifNotExists? viewNameCreate viewColumns? commentClause? ( KW_TBLPROPERTIES tblProp=properties )? KW_AS queryStatement ; createSchema - : KW_CREATE (KW_SCHEMA | KW_DATABASE) ifNotExists? databaseNameCreate ( - KW_COMMENT comment=stringLiteral - )? (KW_LOCATION location=stringLiteral)? + : KW_CREATE (KW_SCHEMA | KW_DATABASE) ifNotExists? databaseNameCreate (commentClause)? ( + KW_LOCATION location=stringLiteral + )? ; createRole @@ -119,14 +119,14 @@ createRole createAggregateFunction : KW_CREATE KW_AGGREGATE? KW_FUNCTION ifNotExists? functionNameCreate ( LPAREN (type (COMMA type)*)? RPAREN - )? KW_RETURNS type (KW_INTERMEDIATE type)? KW_LOCATION STRING (KW_INIT_FN EQ STRING)? KW_UPDATE_FN EQ STRING KW_MERGE_FN EQ STRING ( + )? KW_RETURNS returnType=type (KW_INTERMEDIATE type)? KW_LOCATION STRING (KW_INIT_FN EQ STRING)? KW_UPDATE_FN EQ STRING KW_MERGE_FN EQ STRING ( KW_PREPARE_FN EQ STRING )? (KW_CLOSEFN EQ STRING)? (KW_SERIALIZE_FN EQ STRING)? (KW_FINALIZE_FN EQ STRING)? ; createFunction : KW_CREATE KW_FUNCTION ifNotExists? functionNameCreate (LPAREN (type (COMMA type)*)? RPAREN)? ( - KW_RETURNS type + KW_RETURNS returnType=type )? KW_LOCATION STRING KW_SYMBOL EQ symbol=stringLiteral ; @@ -569,11 +569,9 @@ tableOrViewPath ; createCommonItem - : (KW_SORT KW_BY columnAliases)? (KW_COMMENT comment=stringLiteral)? ( - KW_ROW KW_FORMAT rowFormat - )? (KW_WITH KW_SERDEPROPERTIES serdProp=properties)? (KW_STORED KW_AS fileFormat)? ( - KW_LOCATION location=stringLiteral - )? ( + : (KW_SORT KW_BY columnAliases)? commentClause? (KW_ROW KW_FORMAT rowFormat)? ( + KW_WITH KW_SERDEPROPERTIES serdProp=properties + )? (KW_STORED KW_AS fileFormat)? (KW_LOCATION location=stringLiteral)? ( KW_CACHED KW_IN cacheName=qualifiedName (KW_WITH KW_REPLICATION EQ INTEGER_VALUE)? | KW_UNCACHED )? (KW_TBLPROPERTIES tblProp=properties)? @@ -588,9 +586,11 @@ assignmentItem ; viewColumns - : LPAREN columnNamePathCreate (KW_COMMENT stringLiteral)? ( - COMMA columnNamePathCreate (KW_COMMENT stringLiteral)? - )* RPAREN + : LPAREN viewColumnItem? (COMMA viewColumnItem?)* RPAREN + ; + +viewColumnItem + : columnNamePathCreate commentClause? ; queryStatement @@ -621,7 +621,7 @@ columnSpec ; columnDefinition - : columnNamePathCreate type (KW_COMMENT stringLiteral)? + : columnNamePathCreate colType=type commentClause? ; kuduTableElement @@ -629,11 +629,15 @@ kuduTableElement ; kuduColumnDefinition - : columnNamePathCreate type (kuduAttributes kuduAttributes*?)? (KW_COMMENT stringLiteral)? ( + : columnNamePathCreate colType=type (kuduAttributes kuduAttributes*?)? commentClause? ( KW_PRIMARY KW_KEY )? ; +commentClause + : KW_COMMENT comment=stringLiteral + ; + columnSpecWithKudu : columnSpec (kuduAttributes kuduAttributes*?)? ; @@ -838,7 +842,7 @@ sampleType ; aliasedRelation - : relationPrimary (KW_AS? identifier columnAliases?)? + : relationPrimary (KW_AS? alias=identifier columnAliases?)? ; columnAliases diff --git a/src/grammar/mysql/MySqlParser.g4 b/src/grammar/mysql/MySqlParser.g4 index 328a5589..bc299c29 100644 --- a/src/grammar/mysql/MySqlParser.g4 +++ b/src/grammar/mysql/MySqlParser.g4 @@ -442,7 +442,7 @@ functionParameter ; routineOption - : KW_COMMENT STRING_LITERAL # routineComment + : KW_COMMENT comment=STRING_LITERAL # routineComment | KW_LANGUAGE KW_SQL # routineLanguage | KW_NOT? KW_DETERMINISTIC # routineBehavior | (KW_CONTAINS KW_SQL | KW_NO KW_SQL | KW_READS KW_SQL KW_DATA | KW_MODIFIES KW_SQL KW_DATA) # routineData @@ -483,7 +483,7 @@ constraintSymbol ; columnDefinition - : dataType columnConstraint* + : colType=dataType columnConstraint* ; columnConstraint @@ -494,7 +494,7 @@ columnConstraint | (KW_AUTO_INCREMENT | KW_ON KW_UPDATE currentTimestamp) # autoIncrementColumnConstraint | KW_PRIMARY? KW_KEY # primaryKeyColumnConstraint | KW_UNIQUE KW_KEY? # uniqueKeyColumnConstraint - | KW_COMMENT STRING_LITERAL # commentColumnConstraint + | KW_COMMENT comment=STRING_LITERAL # commentColumnConstraint | KW_COLUMN_FORMAT colformat=(KW_FIXED | KW_DYNAMIC | KW_DEFAULT) # formatColumnConstraint | KW_STORAGE storageval=(KW_DISK | KW_MEMORY | KW_DEFAULT) # storageColumnConstraint | referenceDefinition # referenceColumnConstraint @@ -536,7 +536,7 @@ tableOption | KW_DEFAULT? charSet '='? (charsetName | KW_DEFAULT) # tableOptionCharset | (KW_CHECKSUM | KW_PAGE_CHECKSUM) '='? boolValue=('0' | '1') # tableOptionChecksum | KW_DEFAULT? KW_COLLATE '='? collationName # tableOptionCollate - | KW_COMMENT '='? STRING_LITERAL # tableOptionComment + | KW_COMMENT '='? comment=STRING_LITERAL # tableOptionComment | KW_COMPRESSION '='? (STRING_LITERAL | ID) # tableOptionCompression | KW_CONNECTION '='? STRING_LITERAL # tableOptionConnection | (KW_DATA | KW_INDEX) KW_DIRECTORY '='? STRING_LITERAL # tableOptionDataDirectory diff --git a/src/grammar/postgresql/PostgreSqlParser.g4 b/src/grammar/postgresql/PostgreSqlParser.g4 index 9ba5bdfe..31c18e07 100644 --- a/src/grammar/postgresql/PostgreSqlParser.g4 +++ b/src/grammar/postgresql/PostgreSqlParser.g4 @@ -620,7 +620,7 @@ typedtableelement ; column_def - : column_name_create typename create_generic_options? ( + : column_name_create colType=typename create_generic_options? ( KW_STORAGE (KW_PLAIN | KW_EXTERNAL | KW_EXTENDED | KW_MAIN | KW_DEFAULT | colid) )? (KW_COMPRESSION colid)? (opt_collate_clause)? (KW_WITH KW_OPTIONS)? colconstraint* ; @@ -2163,12 +2163,12 @@ table_ref ; alias_clause - : KW_AS? colid (OPEN_PAREN name_list CLOSE_PAREN)? + : KW_AS? alias=colid (OPEN_PAREN name_list CLOSE_PAREN)? ; func_alias_clause : alias_clause - | (KW_AS colid? | colid) OPEN_PAREN tablefuncelementlist CLOSE_PAREN + | (KW_AS alias=colid? | alias=colid) OPEN_PAREN tablefuncelementlist CLOSE_PAREN ; join_type @@ -2598,7 +2598,7 @@ func_arg_list func_arg_expr : column_name | expression - | type_function_name (COLON_EQUALS | EQUALS_GREATER) expression + | type_function_name ((COLON_EQUALS | EQUALS_GREATER) expression)? ; array_expr diff --git a/src/grammar/spark/SparkSqlParser.g4 b/src/grammar/spark/SparkSqlParser.g4 index f87e0f23..b57f65b6 100644 --- a/src/grammar/spark/SparkSqlParser.g4 +++ b/src/grammar/spark/SparkSqlParser.g4 @@ -85,7 +85,7 @@ statement | KW_ALTER (KW_TABLE tableName | KW_VIEW viewName) KW_SET KW_TBLPROPERTIES propertyList # setTableProperties | KW_ALTER (KW_TABLE tableName | KW_VIEW viewName) KW_UNSET KW_TBLPROPERTIES (ifExists)? propertyList # unsetTableProperties | KW_ALTER KW_TABLE table=tableName (KW_ALTER | KW_CHANGE) KW_COLUMN? column=columnName alterColumnAction? # alterTableAlterColumn - | KW_ALTER KW_TABLE table=tableName partitionSpec? KW_CHANGE KW_COLUMN? colName=columnName colType colPosition? # hiveChangeColumn + | KW_ALTER KW_TABLE table=tableName partitionSpec? KW_CHANGE KW_COLUMN? colName=columnName columnType colPosition? # hiveChangeColumn | KW_ALTER KW_TABLE table=tableName partitionSpec? KW_REPLACE KW_COLUMNS LEFT_PAREN qualifiedColTypeWithPositionSeqForReplace RIGHT_PAREN # hiveReplaceColumns | KW_ALTER KW_TABLE tableName (partitionSpec)? KW_SET KW_SERDE stringLit ( @@ -153,8 +153,8 @@ statement | (KW_DESC | KW_DESCRIBE) KW_DATABASE KW_EXTENDED? namespaceName # describeNamespace | (KW_DESC | KW_DESCRIBE) KW_TABLE? option=(KW_EXTENDED | KW_FORMATTED)? tableName partitionSpec? describeColName? # describeRelation | (KW_DESC | KW_DESCRIBE) KW_QUERY? query # describeQuery - | KW_COMMENT KW_ON namespace namespaceName KW_IS comment # commentNamespace - | KW_COMMENT KW_ON KW_TABLE tableName KW_IS comment # commentTable + | KW_COMMENT KW_ON namespace namespaceName KW_IS commentStr # commentNamespace + | KW_COMMENT KW_ON KW_TABLE tableName KW_IS commentStr # commentTable | KW_REFRESH KW_TABLE tableName # refreshTable | KW_REFRESH KW_FUNCTION functionName # refreshFunction | KW_REFRESH (stringLit | .*?) # refreshResource @@ -269,7 +269,7 @@ locationSpec ; commentSpec - : KW_COMMENT stringLit + : KW_COMMENT comment=stringLit ; query @@ -851,7 +851,7 @@ functionTable ; tableAlias - : (KW_AS? strictIdentifier identifierList?)? + : (KW_AS? alias=strictIdentifier identifierList?)? ; rowFormat @@ -905,7 +905,7 @@ partitionFieldList partitionField : transform - | colType + | columnType ; transform @@ -1227,10 +1227,10 @@ variableDefaultExpression ; colTypeList - : colType (COMMA colType)* + : columnType (COMMA columnType)* ; -colType +columnType : colName=errorCapturingIdentifier dataType (KW_NOT KW_NULL)? commentSpec? ; @@ -1239,7 +1239,7 @@ createOrReplaceTableColTypeList ; createOrReplaceTableColType - : colName=columnNameCreate dataType colDefinitionOption* + : colName=columnNameCreate colType=dataType colDefinitionOption* ; colDefinitionOption @@ -1388,7 +1388,7 @@ stringLit | DOUBLEQUOTED_STRING ; -comment +commentStr : stringLit | KW_NULL ; diff --git a/src/grammar/sql/README.md b/src/grammar/sql/README.md new file mode 100644 index 00000000..8c062c4c --- /dev/null +++ b/src/grammar/sql/README.md @@ -0,0 +1,3 @@ +# Generic SQL + +Grammar file from: diff --git a/src/grammar/sql/SqlLexer.g4 b/src/grammar/sql/SqlLexer.g4 new file mode 100644 index 00000000..c8a6174f --- /dev/null +++ b/src/grammar/sql/SqlLexer.g4 @@ -0,0 +1,488 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/** + * This file is an adaptation of spark's spark/sql/api/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBaseLexer.g4 grammar. + * Reference: https://github.com/apache/spark/blob/v3.5.0/sql/api/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBaseLexer.g4 + */ + +// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons none, alignColons trailing +// $antlr-format singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true +// $antlr-format spaceBeforeAssignmentOperators false, groupedAlignments true + +lexer grammar SqlLexer; + +options { + caseInsensitive= true; +} + +@members { + /** + * When true, parser should throw ParseException for unclosed bracketed comment. + */ + public has_unclosed_bracketed_comment = false; + + /** + * This method will be called when the character stream ends and try to find out the + * unclosed bracketed comment. + * If the method be called, it means the end of the entire character stream match, + * and we set the flag and fail later. + */ + public markUnclosedComment() { + this.has_unclosed_bracketed_comment = true; + } +} + +SEMICOLON: ';'; + +LEFT_PAREN : '('; +RIGHT_PAREN : ')'; +COMMA : ','; +DOT : '.'; +LEFT_BRACKET : '['; +RIGHT_BRACKET : ']'; + +// NOTE: If you add a new token in the list below, you should update the list of keywords +// and reserved tag in `docs/sql-ref-ansi-compliance.md#sql-keywords`, and +// modify `ParserUtils.toExprAlias()` which assumes all keywords are between `ADD` and `ZONE`. + +//============================ +// Start of the keywords list +//============================ +//--KEYWORD-LIST-START +KW_ADD : 'ADD'; +KW_AFTER : 'AFTER'; +KW_ALL : 'ALL'; +KW_ALTER : 'ALTER'; +KW_ALWAYS : 'ALWAYS'; +KW_ANALYZE : 'ANALYZE'; +KW_AND : 'AND'; +KW_ANTI : 'ANTI'; +KW_ANY : 'ANY'; +KW_ANY_VALUE : 'ANY_VALUE'; +KW_ARCHIVE : 'ARCHIVE'; +KW_ARRAY : 'ARRAY'; +KW_AS : 'AS'; +KW_ASC : 'ASC'; +KW_AT : 'AT'; +KW_AUTHORIZATION : 'AUTHORIZATION'; +KW_BETWEEN : 'BETWEEN'; +KW_BIGINT : 'BIGINT'; +KW_BINARY : 'BINARY'; +KW_BOOLEAN : 'BOOLEAN'; +KW_BOTH : 'BOTH'; +KW_BUCKET : 'BUCKET'; +KW_BUCKETS : 'BUCKETS'; +KW_BY : 'BY'; +KW_BYTE : 'BYTE'; +KW_CACHE : 'CACHE'; +KW_CASCADE : 'CASCADE'; +KW_CASE : 'CASE'; +KW_CAST : 'CAST'; +KW_CATALOG : 'CATALOG'; +KW_CATALOGS : 'CATALOGS'; +KW_CHANGE : 'CHANGE'; +KW_CHAR : 'CHAR'; +KW_CHARACTER : 'CHARACTER'; +KW_CHECK : 'CHECK'; +KW_CLEAR : 'CLEAR'; +KW_CLUSTER : 'CLUSTER'; +KW_CLUSTERED : 'CLUSTERED'; +KW_CODEGEN : 'CODEGEN'; +KW_COLLATE : 'COLLATE'; +KW_COLLECTION : 'COLLECTION'; +KW_COLUMN : 'COLUMN'; +KW_COLUMNS : 'COLUMNS'; +KW_COMMENT : 'COMMENT'; +KW_COMMIT : 'COMMIT'; +KW_COMPACT : 'COMPACT'; +KW_COMPACTIONS : 'COMPACTIONS'; +KW_COMPUTE : 'COMPUTE'; +KW_CONCATENATE : 'CONCATENATE'; +KW_CONSTRAINT : 'CONSTRAINT'; +KW_COST : 'COST'; +KW_CREATE : 'CREATE'; +KW_CROSS : 'CROSS'; +KW_CUBE : 'CUBE'; +KW_CURRENT : 'CURRENT'; +KW_CURRENT_DATE : 'CURRENT_DATE'; +KW_CURRENT_TIME : 'CURRENT_TIME'; +KW_CURRENT_TIMESTAMP : 'CURRENT_TIMESTAMP'; +KW_CURRENT_USER : 'CURRENT_USER'; +KW_DAY : 'DAY'; +KW_DAYS : 'DAYS'; +KW_DAYOFYEAR : 'DAYOFYEAR'; +KW_DATA : 'DATA'; +KW_DATE : 'DATE'; +KW_DATABASE : 'DATABASE'; +KW_DATABASES : 'DATABASES'; +KW_DATEADD : 'DATEADD'; +KW_DATE_ADD : 'DATE_ADD'; +KW_DATEDIFF : 'DATEDIFF'; +KW_DATE_DIFF : 'DATE_DIFF'; +KW_DBPROPERTIES : 'DBPROPERTIES'; +KW_DEC : 'DEC'; +KW_DECIMAL : 'DECIMAL'; +KW_DECLARE : 'DECLARE'; +KW_DEFAULT : 'DEFAULT'; +KW_DEFINED : 'DEFINED'; +KW_DELETE : 'DELETE'; +KW_DELIMITED : 'DELIMITED'; +KW_DESC : 'DESC'; +KW_DESCRIBE : 'DESCRIBE'; +KW_DFS : 'DFS'; +KW_DIRECTORIES : 'DIRECTORIES'; +KW_DIRECTORY : 'DIRECTORY'; +KW_DISABLE : 'DISABLE'; +KW_DISTINCT : 'DISTINCT'; +KW_DISTRIBUTE : 'DISTRIBUTE'; +KW_DIV : 'DIV'; +KW_DOUBLE : 'DOUBLE'; +KW_DROP : 'DROP'; +KW_ELSE : 'ELSE'; +KW_ENABLE : 'ENABLE'; +KW_END : 'END'; +KW_ESCAPE : 'ESCAPE'; +KW_ESCAPED : 'ESCAPED'; +KW_EXCEPT : 'EXCEPT'; +KW_EXCHANGE : 'EXCHANGE'; +KW_EXCLUDE : 'EXCLUDE'; +KW_EXISTS : 'EXISTS'; +KW_EXPLAIN : 'EXPLAIN'; +KW_EXPORT : 'EXPORT'; +KW_EXTENDED : 'EXTENDED'; +KW_EXTERNAL : 'EXTERNAL'; +KW_EXTRACT : 'EXTRACT'; +KW_FALSE : 'FALSE'; +KW_FETCH : 'FETCH'; +KW_FIELDS : 'FIELDS'; +KW_FILTER : 'FILTER'; +KW_FILEFORMAT : 'FILEFORMAT'; +KW_FIRST : 'FIRST'; +KW_FLOAT : 'FLOAT'; +KW_FOLLOWING : 'FOLLOWING'; +KW_FOR : 'FOR'; +KW_FOREIGN : 'FOREIGN'; +KW_FORMAT : 'FORMAT'; +KW_FORMATTED : 'FORMATTED'; +KW_FROM : 'FROM'; +KW_FULL : 'FULL'; +KW_FUNCTION : 'FUNCTION'; +KW_FUNCTIONS : 'FUNCTIONS'; +KW_GENERATED : 'GENERATED'; +KW_GLOBAL : 'GLOBAL'; +KW_GRANT : 'GRANT'; +KW_GROUP : 'GROUP'; +KW_GROUPING : 'GROUPING'; +KW_HAVING : 'HAVING'; +KW_BINARY_HEX : 'X'; +KW_HOUR : 'HOUR'; +KW_HOURS : 'HOURS'; +KW_IDENTIFIER : 'IDENTIFIER'; +KW_IF : 'IF'; +KW_IGNORE : 'IGNORE'; +KW_IMPORT : 'IMPORT'; +KW_IN : 'IN'; +KW_INCLUDE : 'INCLUDE'; +KW_INDEX : 'INDEX'; +KW_INDEXES : 'INDEXES'; +KW_INNER : 'INNER'; +KW_INPATH : 'INPATH'; +KW_INPUTFORMAT : 'INPUTFORMAT'; +KW_INSERT : 'INSERT'; +KW_INTERSECT : 'INTERSECT'; +KW_INTERVAL : 'INTERVAL'; +KW_INT : 'INT'; +KW_INTEGER : 'INTEGER'; +KW_INTO : 'INTO'; +KW_IS : 'IS'; +KW_ITEMS : 'ITEMS'; +KW_JOIN : 'JOIN'; +KW_KEYS : 'KEYS'; +KW_LAST : 'LAST'; +KW_LATERAL : 'LATERAL'; +KW_LAZY : 'LAZY'; +KW_LEADING : 'LEADING'; +KW_LEFT : 'LEFT'; +KW_LIFECYCLE : 'LIFECYCLE'; +KW_LIKE : 'LIKE'; +KW_ILIKE : 'ILIKE'; +KW_LIMIT : 'LIMIT'; +KW_LINES : 'LINES'; +KW_LIST : 'LIST'; +KW_LOAD : 'LOAD'; +KW_LOCAL : 'LOCAL'; +KW_LOCATION : 'LOCATION'; +KW_LOCK : 'LOCK'; +KW_LOCKS : 'LOCKS'; +KW_LOGICAL : 'LOGICAL'; +KW_LONG : 'LONG'; +KW_MACRO : 'MACRO'; +KW_MAP : 'MAP'; +KW_MATCHED : 'MATCHED'; +KW_MERGE : 'MERGE'; +KW_MICROSECOND : 'MICROSECOND'; +KW_MICROSECONDS : 'MICROSECONDS'; +KW_MILLISECOND : 'MILLISECOND'; +KW_MILLISECONDS : 'MILLISECONDS'; +KW_MINUTE : 'MINUTE'; +KW_MINUTES : 'MINUTES'; +KW_MONTH : 'MONTH'; +KW_MONTHS : 'MONTHS'; +KW_MSCK : 'MSCK'; +KW_NAME : 'NAME'; +KW_NAMESPACE : 'NAMESPACE'; +KW_NAMESPACES : 'NAMESPACES'; +KW_NANOSECOND : 'NANOSECOND'; +KW_NANOSECONDS : 'NANOSECONDS'; +KW_NATURAL : 'NATURAL'; +KW_NO : 'NO'; +KW_NOSCAN : 'NOSCAN'; +KW_NOT : 'NOT'; +KW_NULL : 'NULL'; +KW_NULLS : 'NULLS'; +KW_NUMERIC : 'NUMERIC'; +KW_OF : 'OF'; +KW_OFFSET : 'OFFSET'; +KW_ON : 'ON'; +KW_ONLY : 'ONLY'; +KW_OPTIMIZE : 'OPTIMIZE'; +KW_OPTION : 'OPTION'; +KW_OPTIONS : 'OPTIONS'; +KW_OR : 'OR'; +KW_ORDER : 'ORDER'; +KW_OUT : 'OUT'; +KW_OUTER : 'OUTER'; +KW_OUTPUTFORMAT : 'OUTPUTFORMAT'; +KW_OVER : 'OVER'; +KW_OVERLAPS : 'OVERLAPS'; +KW_OVERLAY : 'OVERLAY'; +KW_OVERWRITE : 'OVERWRITE'; +KW_PARTITION : 'PARTITION'; +KW_PARTITIONED : 'PARTITIONED'; +KW_PARTITIONS : 'PARTITIONS'; +KW_PERCENTILE_CONT : 'PERCENTILE_CONT'; +KW_PERCENTILE_DISC : 'PERCENTILE_DISC'; +KW_PERCENTLIT : 'PERCENT'; +KW_PIVOT : 'PIVOT'; +KW_PLACING : 'PLACING'; +KW_POSITION : 'POSITION'; +KW_PRECEDING : 'PRECEDING'; +KW_PRIMARY : 'PRIMARY'; +KW_PRINCIPALS : 'PRINCIPALS'; +KW_PROPERTIES : 'PROPERTIES'; +KW_PURGE : 'PURGE'; +KW_QUARTER : 'QUARTER'; +KW_QUERY : 'QUERY'; +KW_RANGE : 'RANGE'; +KW_REAL : 'REAL'; +KW_RECORDREADER : 'RECORDREADER'; +KW_RECORDWRITER : 'RECORDWRITER'; +KW_RECOVER : 'RECOVER'; +KW_REDUCE : 'REDUCE'; +KW_REFERENCES : 'REFERENCES'; +KW_REFRESH : 'REFRESH'; +KW_RENAME : 'RENAME'; +KW_REPAIR : 'REPAIR'; +KW_REPEATABLE : 'REPEATABLE'; +KW_REPLACE : 'REPLACE'; +KW_RESET : 'RESET'; +KW_RESPECT : 'RESPECT'; +KW_RESTRICT : 'RESTRICT'; +KW_REWRITE : 'REWRITE'; +KW_REVOKE : 'REVOKE'; +KW_RIGHT : 'RIGHT'; +KW_RLIKE : 'RLIKE'; +KW_REGEXP : 'REGEXP'; +KW_ROLE : 'ROLE'; +KW_ROLES : 'ROLES'; +KW_ROLLBACK : 'ROLLBACK'; +KW_ROLLUP : 'ROLLUP'; +KW_ROW : 'ROW'; +KW_ROWS : 'ROWS'; +KW_SECOND : 'SECOND'; +KW_SECONDS : 'SECONDS'; +KW_SCHEMA : 'SCHEMA'; +KW_SCHEMAS : 'SCHEMAS'; +KW_SELECT : 'SELECT'; +KW_SEMI : 'SEMI'; +KW_SEPARATED : 'SEPARATED'; +KW_SERDE : 'SERDE'; +KW_SERDEPROPERTIES : 'SERDEPROPERTIES'; +KW_SESSION_USER : 'SESSION_USER'; +KW_SET : 'SET'; +KW_MINUS : 'MINUS'; +KW_SETS : 'SETS'; +KW_SHORT : 'SHORT'; +KW_SHOW : 'SHOW'; +KW_SINGLE : 'SINGLE'; +KW_SKEWED : 'SKEWED'; +KW_SMALLINT : 'SMALLINT'; +KW_SOME : 'SOME'; +KW_SORT : 'SORT'; +KW_SORTED : 'SORTED'; +KW_SOURCE : 'SOURCE'; +KW_START : 'START'; +KW_STATISTICS : 'STATISTICS'; +KW_STORED : 'STORED'; +KW_STRATIFY : 'STRATIFY'; +KW_STRING : 'STRING'; +KW_STRUCT : 'STRUCT'; +KW_SUBSTR : 'SUBSTR'; +KW_SUBSTRING : 'SUBSTRING'; +KW_SYNC : 'SYNC'; +KW_SYSTEM : 'SYSTEM'; +KW_SYSTEM_TIME : 'SYSTEM_TIME'; +KW_SYSTEM_VERSION : 'SYSTEM_VERSION'; +KW_TABLE : 'TABLE'; +KW_TABLES : 'TABLES'; +KW_TABLESAMPLE : 'TABLESAMPLE'; +KW_TARGET : 'TARGET'; +KW_TBLPROPERTIES : 'TBLPROPERTIES'; +KW_TEMPORARY : 'TEMPORARY'; +KW_TERMINATED : 'TERMINATED'; +KW_THEN : 'THEN'; +KW_TIME : 'TIME'; +KW_TIMEDIFF : 'TIMEDIFF'; +KW_TIMESTAMP : 'TIMESTAMP'; +KW_TIMESTAMP_LTZ : 'TIMESTAMP_LTZ'; +KW_TIMESTAMP_NTZ : 'TIMESTAMP_NTZ'; +KW_TIMESTAMPADD : 'TIMESTAMPADD'; +KW_TIMESTAMPDIFF : 'TIMESTAMPDIFF'; +KW_TINYINT : 'TINYINT'; +KW_TO : 'TO'; +KW_TOUCH : 'TOUCH'; +KW_TRAILING : 'TRAILING'; +KW_TRANSACTION : 'TRANSACTION'; +KW_TRANSACTIONS : 'TRANSACTIONS'; +KW_TRANSFORM : 'TRANSFORM'; +KW_TRIM : 'TRIM'; +KW_TRUE : 'TRUE'; +KW_TRUNCATE : 'TRUNCATE'; +KW_TRY_CAST : 'TRY_CAST'; +KW_TYPE : 'TYPE'; +KW_UNARCHIVE : 'UNARCHIVE'; +KW_UNBOUNDED : 'UNBOUNDED'; +KW_UNCACHE : 'UNCACHE'; +KW_UNION : 'UNION'; +KW_UNIQUE : 'UNIQUE'; +KW_UNKNOWN : 'UNKNOWN'; +KW_UNLOCK : 'UNLOCK'; +KW_UNPIVOT : 'UNPIVOT'; +KW_UNSET : 'UNSET'; +KW_UPDATE : 'UPDATE'; +KW_USE : 'USE'; +KW_USER : 'USER'; +KW_USING : 'USING'; +KW_VALUES : 'VALUES'; +KW_VARCHAR : 'VARCHAR'; +KW_VAR : 'VAR'; +KW_VARIABLE : 'VARIABLE'; +KW_VERSION : 'VERSION'; +KW_VIEW : 'VIEW'; +KW_VIEWS : 'VIEWS'; +KW_VOID : 'VOID'; +KW_WEEK : 'WEEK'; +KW_WEEKS : 'WEEKS'; +KW_WHEN : 'WHEN'; +KW_WHERE : 'WHERE'; +KW_WINDOW : 'WINDOW'; +KW_WITH : 'WITH'; +KW_WITHIN : 'WITHIN'; +KW_YEAR : 'YEAR'; +KW_YEARS : 'YEARS'; +KW_ZONE : 'ZONE'; +KW_ZORDER : 'ZORDER'; +//--KEYWORD-LIST-END +//============================ +// End of the keywords list +//============================ + +EQ : '=' | '=='; +NSEQ : '<=>'; +NEQ : '<>'; +NEQJ : '!='; +LT : '<'; +LTE : '<=' | '!>'; +GT : '>'; +GTE : '>=' | '!<'; + +NOT : '!'; +PLUS : '+'; +MINUS : '-'; +ASTERISK : '*'; +SLASH : '/'; +PERCENT : '%'; +TILDE : '~'; +AMPERSAND : '&'; +PIPE : '|'; +CONCAT_PIPE : '||'; +HAT : '^'; +COLON : ':'; +ARROW : '->'; +FAT_ARROW : '=>'; +HENT_START : '/*+'; +HENT_END : '*/'; +QUESTION : '?'; + +STRING_LITERAL: '\'' ( ~('\'' | '\\') | ('\\' .))* '\'' | 'R\'' (~'\'')* '\'' | 'R"' (~'"')* '"'; + +DOUBLEQUOTED_STRING: '"' ( ~('"' | '\\') | ('\\' .))* '"'; + +// NOTE: If you move a numeric literal, you should modify `ParserUtils.toExprAlias()` +// which assumes all numeric literals are between `BIGINT_LITERAL` and `BIGDECIMAL_LITERAL`. + +BIGINT_LITERAL: DIGIT+ 'L'; + +SMALLINT_LITERAL: DIGIT+ 'S'; + +TINYINT_LITERAL: DIGIT+ 'Y'; + +INTEGER_VALUE: DIGIT+; + +EXPONENT_VALUE: DIGIT+ EXPONENT | DECIMAL_DIGITS EXPONENT; + +DECIMAL_VALUE: DECIMAL_DIGITS; + +FLOAT_LITERAL: DIGIT+ EXPONENT? 'F' | DECIMAL_DIGITS EXPONENT? 'F'; + +DOUBLE_LITERAL: DIGIT+ EXPONENT? 'D' | DECIMAL_DIGITS EXPONENT? 'D'; + +BIGDECIMAL_LITERAL: DIGIT+ EXPONENT? 'BD' | DECIMAL_DIGITS EXPONENT? 'BD'; + +IDENTIFIER: (LETTER | DIGIT | '_')+; + +BACKQUOTED_IDENTIFIER: '`' ( ~'`' | '``')* '`'; + +fragment DECIMAL_DIGITS: DIGIT+ '.' DIGIT* | '.' DIGIT+; + +fragment EXPONENT: 'E' [+-]? DIGIT+; + +fragment DIGIT: [0-9]; + +fragment LETTER: [A-Z]; + +SIMPLE_COMMENT: '--' ('\\\n' | ~[\r\n])* '\r'? '\n'? -> channel(HIDDEN); + +BRACKETED_COMMENT: + '/*' (BRACKETED_COMMENT | .)*? ('*/' | {this.markUnclosedComment();} EOF) -> channel(HIDDEN); + +WS: [ \r\n\t]+ -> channel(HIDDEN); + +// Catch-all for anything we can't recognize. +// We use this to be able to ignore and recover all the text +// when splitting statements with DelimiterLexer +UNRECOGNIZED: .; \ No newline at end of file diff --git a/src/grammar/sql/SqlParser.g4 b/src/grammar/sql/SqlParser.g4 new file mode 100644 index 00000000..74e4904e --- /dev/null +++ b/src/grammar/sql/SqlParser.g4 @@ -0,0 +1,1898 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/** + * This file is an adaptation of spark's spark/sql/api/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBaseParser.g4 grammar. + * Reference: https://github.com/apache/spark/blob/v3.5.0/sql/api/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBaseParser.g4 + */ + +// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging +// $antlr-format spaceBeforeAssignmentOperators false, keepEmptyLinesAtTheStartOfBlocks true + +parser grammar SqlParser; + +options { + tokenVocab=SqlLexer; + caseInsensitive= true; + superClass=SQLParserBase; +} + +@header { +import { SQLParserBase } from '../SQLParserBase'; +} + +program + : singleStatement* EOF + ; + +singleStatement + : statement SEMICOLON? + ; + +statement + : query # statementDefault + | ctes? dmlStatementNoWith # dmlStatement + | KW_USE namespace? namespaceName # useNamespace + | alterStatement # alter + | createStatement # create + | dropStatement # drop + | showStatement # show + | KW_TRUNCATE KW_TABLE tableName partitionSpec? # truncateTable + | KW_ANALYZE KW_TABLE tableName partitionSpec? KW_COMPUTE KW_STATISTICS ( + KW_NOSCAN + | KW_FOR KW_COLUMNS columnNameSeq + | KW_FOR KW_ALL KW_COLUMNS + )? # analyze + | KW_ANALYZE KW_TABLES ((KW_FROM | KW_IN) namespaceName)? KW_COMPUTE KW_STATISTICS (KW_NOSCAN)? # analyzeTables + | KW_DECLARE (KW_OR KW_REPLACE)? KW_VARIABLE? functionName dataType? variableDefaultExpression? # declareVariable + | KW_EXPLAIN (KW_LOGICAL | KW_FORMATTED | KW_EXTENDED | KW_CODEGEN | KW_COST)? statement # explainStatement + | (KW_DESC | KW_DESCRIBE) KW_FUNCTION KW_EXTENDED? describeFuncName # describeFunction + | (KW_DESC | KW_DESCRIBE) KW_DATABASE KW_EXTENDED? namespaceName # describeNamespace + | (KW_DESC | KW_DESCRIBE) KW_QUERY? query # describeQuery + | (KW_DESC | KW_DESCRIBE) KW_TABLE? option=(KW_EXTENDED | KW_FORMATTED)? tableName partitionSpec? describeColName? # describeRelation + | KW_COMMENT KW_ON ((namespace namespaceName) | (KW_TABLE tableName)) KW_IS ( + stringLit + | KW_NULL + ) # commentNamespace + | KW_REFRESH KW_TABLE tableName # refreshTable + | KW_REFRESH KW_FUNCTION functionName # refreshFunction + | KW_REFRESH (stringLit | .*?) # refreshResource + | KW_CACHE KW_LAZY? KW_TABLE tableName (KW_OPTIONS options=propertyList)? (KW_AS? query)? # cacheTable + | KW_UNCACHE KW_TABLE (ifExists)? tableName # unCacheTable + | KW_CLEAR KW_CACHE # clearCache + | KW_LOAD KW_DATA KW_LOCAL? KW_INPATH path=stringLit KW_OVERWRITE? KW_INTO KW_TABLE tableName partitionSpec? # loadData + | (KW_MSCK)? KW_REPAIR KW_TABLE tableName (option=(KW_ADD | KW_DROP | KW_SYNC) KW_PARTITIONS)? # repairTable + | op=(KW_ADD | KW_LIST) identifier .*? # manageResource + | KW_SET .*? # setAny + | KW_RESET .*? # resetAny + | KW_OPTIMIZE tableName whereClause? KW_ZORDER KW_BY columnNameSeq # optimizeTable + | unsupportedCommands .*? # unsupportHiveCommands + ; + +alterStatement + : KW_ALTER namespace namespaceName KW_SET ( + ((KW_DBPROPERTIES | KW_PROPERTIES) propertyList) + | KW_LOCATION stringLit + ) + | KW_ALTER KW_TABLE tableName KW_ADD (KW_COLUMN | KW_COLUMNS) LEFT_PAREN? ( + qualifiedColTypeWithPositionForAdd + | qualifiedColTypeWithPositionSeqForAdd + ) RIGHT_PAREN? + | KW_ALTER KW_TABLE tableName KW_DROP (KW_COLUMN | KW_COLUMNS) (ifExists)? LEFT_PAREN? ( + columnName + | columnNameSeq + ) RIGHT_PAREN? + | KW_ALTER (KW_TABLE tableName | KW_VIEW viewName) KW_RENAME (KW_COLUMN columnName)? KW_TO ( + columnNameCreate + | multipartIdentifier + ) + | KW_ALTER (KW_TABLE tableName | KW_VIEW viewName) (KW_SET | KW_UNSET) KW_TBLPROPERTIES ( + ifExists + )? propertyList + | KW_ALTER KW_TABLE table=tableName (KW_ALTER | KW_CHANGE) KW_COLUMN? column=columnName alterColumnAction? + | KW_ALTER KW_TABLE table=tableName partitionSpec? ( + (KW_CHANGE KW_COLUMN?) + | (KW_REPLACE KW_COLUMNS) + ) ( + (colName=columnName columnType colPosition?) + | (LEFT_PAREN qualifiedColTypeWithPositionSeqForReplace RIGHT_PAREN) + ) + | KW_ALTER (KW_TABLE tableName | KW_VIEW viewName) (KW_ADD | KW_DROP) (ifNotExists | ifExists)? ( + partitionSpecLocation+ + | partitionSpec + ) (COMMA partitionSpec)* KW_PURGE? + | KW_ALTER KW_VIEW viewName KW_AS? query + | KW_ALTER KW_TABLE tableName partitionSpec? KW_CHANGE KW_COLUMN? columnName columnType colPosition? + | KW_ALTER KW_TABLE tableName partitionSpec? KW_REPLACE KW_COLUMNS LEFT_PAREN qualifiedColTypeWithPositionSeqForReplace RIGHT_PAREN + | KW_ALTER KW_TABLE tableName partitionSpec? KW_SET (KW_LOCATION stringLit)? KW_SERDE? stringLit? KW_WITH? KW_SERDEPROPERTIES? propertyList? + | KW_ALTER KW_TABLE tableName partitionSpec KW_RENAME KW_TO partitionSpec + | KW_ALTER (KW_TABLE tableName | KW_VIEW viewName) KW_ADD (ifNotExists)? partitionSpecLocation + | KW_ALTER (KW_TABLE tableName | KW_VIEW viewName) KW_DROP (ifExists)? partitionSpec ( + COMMA partitionSpec + )* KW_PURGE? + | KW_ALTER KW_TABLE tableName KW_RECOVER KW_PARTITIONS + | KW_ALTER KW_INDEX .*? + | KW_ALTER KW_TABLE tableName (KW_CLUSTERED | KW_SKEWED | KW_TOUCH) KW_BY? .*? + | KW_ALTER KW_TABLE tableName (KW_NOT | KW_SET) ( + KW_CLUSTERED + | KW_SORTED + | KW_STORED + | KW_SKEWED + ) KW_LOCATION? KW_AS? KW_DIRECTORIES? .*? + | KW_ALTER KW_TABLE tableName (KW_EXCHANGE | KW_ARCHIVE | KW_UNARCHIVE) KW_PARTITION .*? + | KW_ALTER KW_TABLE tableName partitionSpec? ( + KW_COMPACT + | KW_CONCATENATE + | (KW_SET KW_FILEFORMAT) + | (KW_REPLACE KW_COLUMNS) + ) .*? + ; + +createStatement + : KW_CREATE namespace (ifNotExists)? namespaceNameCreate ( + (KW_COMMENT comment=stringLit) + | (KW_LOCATION stringLit) + | (KW_WITH (KW_DBPROPERTIES | KW_PROPERTIES) propertyList) + )* # createNamespace + | KW_CREATE KW_TEMPORARY? KW_EXTERNAL? KW_TABLE (ifNotExists)? tableNameCreate ( + LEFT_PAREN createOrReplaceTableColTypeList RIGHT_PAREN + )? tableProvider? createTableClauses (KW_AS? query)? # createTable + | (KW_CREATE KW_OR)? KW_REPLACE KW_TABLE tableNameCreate ( + LEFT_PAREN createOrReplaceTableColTypeList RIGHT_PAREN + )? tableProvider? createTableClauses (KW_AS? query)? # replaceTable + | KW_CREATE KW_TABLE (ifNotExists)? target=tableNameCreate KW_LIKE source=tableName ( + tableProvider + | rowFormat + | createFileFormat + | (KW_LOCATION stringLit) + | (KW_TBLPROPERTIES tableProps=propertyList) + | tableLifecycle + )* # createTableLike + | KW_CREATE (KW_OR KW_REPLACE)? (KW_GLOBAL? KW_TEMPORARY)? KW_VIEW (ifNotExists)? viewNameCreate identifierCommentList? ( + (KW_COMMENT comment=stringLit) + | (KW_PARTITIONED KW_ON identifierList) + | (KW_TBLPROPERTIES propertyList) + )* KW_AS query # createView + | KW_CREATE (KW_OR KW_REPLACE)? KW_GLOBAL? KW_TEMPORARY KW_VIEW viewNameCreate ( + LEFT_PAREN colTypeList RIGHT_PAREN + )? tableProvider (KW_OPTIONS propertyList)? # createTempViewUsing + | KW_CREATE (KW_OR KW_REPLACE)? KW_TEMPORARY? KW_FUNCTION (ifNotExists)? functionNameCreate KW_AS className=stringLit ( + KW_USING (identifier stringLit) (COMMA (identifier stringLit))* + )? # createFunction + | KW_CREATE KW_INDEX (ifNotExists)? identifier KW_ON KW_TABLE? tableName ( + KW_USING indexType=identifier + )? LEFT_PAREN multipartIdentifierPropertyList RIGHT_PAREN (KW_OPTIONS options=propertyList)? # createIndex + | KW_CREATE (KW_ROLE | KW_INDEX | (KW_TEMPORARY KW_MACRO)) .*? # createRole + ; + +dropStatement + : KW_DROP namespace (ifExists)? namespaceName (KW_RESTRICT | KW_CASCADE)? # dropNamespace + | KW_DROP KW_TABLE (ifExists)? tableName KW_PURGE? # dropTable + | KW_DROP KW_VIEW (ifExists)? viewName # dropView + | KW_DROP KW_TEMPORARY? KW_FUNCTION (ifExists)? functionName # dropFunction + | KW_DROP KW_TEMPORARY KW_VARIABLE (ifExists)? (tableName | viewName | functionName) # dropVariable + | KW_DROP KW_INDEX (ifExists)? identifier KW_ON KW_TABLE? tableName # dropIndex + | KW_DROP (KW_ROLE | KW_INDEX | KW_TEMPORARY) KW_MACRO? .*? # dropRole + ; + +dmlStatementNoWith + : insertInto query # insertFromQuery + | fromClause (insertInto fromStatementBody)+ # multipleInsert + | KW_DELETE KW_FROM tableName tableAlias whereClause? # deleteFromTable + | KW_UPDATE tableName tableAlias setClause whereClause? # updateTable + | KW_MERGE KW_INTO target=tableName targetAlias=tableAlias KW_USING ( + source=identifierReference + | LEFT_PAREN sourceQuery=query RIGHT_PAREN + ) sourceAlias=tableAlias KW_ON mergeCondition=booleanExpression matchedClause* notMatchedClause* notMatchedBySourceClause* # mergeIntoTable + ; + +insertInto + : KW_INSERT KW_INTO KW_TABLE? tableName partitionSpec? (ifNotExists)? ( + (KW_BY KW_NAME) + | (LEFT_PAREN columnNameSeq RIGHT_PAREN) + )? + | KW_INSERT KW_INTO KW_TABLE? tableName KW_REPLACE whereClause + | KW_INSERT KW_OVERWRITE KW_TABLE? tableName (partitionSpec (ifNotExists)?)? ( + (KW_BY KW_NAME) + | (LEFT_PAREN columnNameSeq RIGHT_PAREN) + )? + | KW_INSERT KW_OVERWRITE KW_LOCAL? KW_DIRECTORY (path=stringLit)? rowFormat? createFileFormat? tableProvider? ( + KW_OPTIONS options=propertyList + )? + ; + +showStatement + : KW_SHOW (KW_NAMESPACES | KW_DATABASES | KW_SCHEMAS) ((KW_FROM | KW_IN) multipartIdentifier)? ( + KW_LIKE? pattern=stringLit + )? # showNamespaces + | KW_SHOW KW_TABLES ((KW_FROM | KW_IN) namespaceName)? (KW_LIKE? pattern=stringLit)? # showTables + | KW_SHOW KW_TABLE KW_EXTENDED ((KW_FROM | KW_IN) ns=namespaceName)? KW_LIKE pattern=stringLit partitionSpec? # showTableExtended + | KW_SHOW KW_TBLPROPERTIES table=tableName (LEFT_PAREN key=propertyKey RIGHT_PAREN)? # showTblProperties + | KW_SHOW KW_COLUMNS (KW_FROM | KW_IN) table=tableName ((KW_FROM | KW_IN) namespaceName)? # showColumns + | KW_SHOW KW_VIEWS ((KW_FROM | KW_IN) namespaceName)? (KW_LIKE? pattern=stringLit)? # showViews + | KW_SHOW KW_PARTITIONS tableName partitionSpec? # showPartitions + | KW_SHOW (KW_USER | KW_SYSTEM | KW_ALL)? KW_FUNCTIONS ((KW_FROM | KW_IN) ns=namespaceName)? ( + KW_LIKE? (legacy=multipartIdentifier | pattern=stringLit) + )? # showFunctions + | KW_SHOW KW_CREATE KW_TABLE tableName (KW_AS KW_SERDE)? # showCreateTable + | KW_SHOW KW_CURRENT namespace # showCurrentNamespace + | KW_SHOW KW_CATALOGS (KW_LIKE? pattern=stringLit)? # showCatalogs + | KW_SHOW ( + KW_GRANT + | KW_PRINCIPALS + | KW_ROLES + | KW_COMPACTIONS + | KW_TRANSACTIONS + | KW_INDEXES + | KW_LOCKS + | (KW_ROLE KW_GRANT?) + | (KW_CURRENT KW_ROLES) + | (KW_CREATE KW_TABLE) + ) .*? # showOther + ; + +unsupportedCommands + : (KW_GRANT | KW_REVOKE) KW_ROLE? + | (KW_EXPORT | KW_IMPORT | KW_LOCK | KW_UNLOCK) KW_TABLE + | (KW_LOCK | KW_UNLOCK) KW_DATABASE + | KW_START KW_TRANSACTION + | KW_COMMIT + | KW_ROLLBACK + | KW_DFS + ; + +bucketSpec + : KW_CLUSTERED KW_BY identifierList (KW_SORTED KW_BY orderedIdentifierList)? KW_INTO INTEGER_VALUE KW_BUCKETS + ; + +skewSpec + : KW_SKEWED KW_BY identifierList KW_ON (constantList | nestedConstantList) ( + KW_STORED KW_AS KW_DIRECTORIES + )? + ; + +query + : ctes? queryTerm queryOrganization # queryStatement + ; + +partitionSpecLocation + : partitionSpec (KW_LOCATION stringLit)? + ; + +partitionSpec + : KW_PARTITION LEFT_PAREN partitionVal (COMMA partitionVal)* RIGHT_PAREN + ; + +partitionVal + : identifier (EQ constant)? + | identifier EQ KW_DEFAULT + ; + +namespace + : KW_NAMESPACE + | KW_DATABASE + | KW_SCHEMA + ; + +describeFuncName + : identifierReference + | stringLit + | comparisonOperator + | arithmeticOperator + | predicateOperator + ; + +describeColName + : nameParts+=identifier (DOT nameParts+=identifier)* + ; + +ctes + : KW_WITH namedQuery (COMMA namedQuery)* + ; + +namedQuery + : name=errorCapturingIdentifier (columnAliases=identifierList)? KW_AS? LEFT_PAREN query RIGHT_PAREN + ; + +tableProvider + : KW_USING multipartIdentifier + ; + +createTableClauses + : ( + (KW_OPTIONS options=expressionPropertyList) + | (KW_PARTITIONED KW_BY partitioning=partitionFieldList) + | skewSpec + | bucketSpec + | rowFormat + | createFileFormat + | (KW_LOCATION stringLit) + | (KW_COMMENT comment=stringLit) + | (KW_TBLPROPERTIES tableProps=propertyList) + | tableLifecycle + )* + ; + +// dtstack SparkSQL/HiveSQL lifecycle +tableLifecycle + : KW_LIFECYCLE INTEGER_VALUE + ; + +propertyList + : LEFT_PAREN property (COMMA property)* RIGHT_PAREN + ; + +property + : key=propertyKey (EQ? value=propertyValue)? + ; + +propertyKey + : identifier (DOT identifier)* + | stringLit + ; + +propertyValue + : INTEGER_VALUE + | DECIMAL_VALUE + | booleanValue + | stringLit + ; + +expressionPropertyList + : LEFT_PAREN expressionProperty (COMMA expressionProperty)* RIGHT_PAREN + ; + +expressionProperty + : key=propertyKey (EQ? value=expression)? + ; + +constantList + : LEFT_PAREN constant (COMMA constant)* RIGHT_PAREN + ; + +nestedConstantList + : LEFT_PAREN constantList (COMMA constantList)* RIGHT_PAREN + ; + +createFileFormat + : KW_STORED KW_AS fileFormat + | KW_STORED KW_BY storageHandler + ; + +fileFormat + : KW_INPUTFORMAT inFmt=stringLit KW_OUTPUTFORMAT outFmt=stringLit + | identifier + ; + +storageHandler + : stringLit (KW_WITH KW_SERDEPROPERTIES propertyList)? + ; + +namespaceName + : identifierReference + ; + +namespaceNameCreate + : identifierReference + ; + +tableNameCreate + : tableIdentifier + ; + +tableName + : tableIdentifier + ; + +viewNameCreate + : viewIdentifier + ; + +viewName + : viewIdentifier + ; + +columnName + : multipartIdentifier + | {this.shouldMatchEmpty()}? + ; + +columnNameSeq + : columnName (COMMA columnName)* + ; + +columnNameCreate + : errorCapturingIdentifier + ; + +identifierReference + : KW_IDENTIFIER LEFT_PAREN expression RIGHT_PAREN + | multipartIdentifier + ; + +queryOrganization + : (KW_ORDER KW_BY order+=sortItem (COMMA order+=sortItem)*)? ( + KW_CLUSTER KW_BY clusterBy+=expression (COMMA clusterBy+=expression)* + )? (KW_DISTRIBUTE KW_BY distributeBy+=expression (COMMA distributeBy+=expression)*)? ( + KW_SORT KW_BY sort+=sortItem (COMMA sort+=sortItem)* + )? windowClause? (KW_LIMIT (KW_ALL | limit=expression))? (KW_OFFSET offset=expression)? + ; + +queryTerm + : queryPrimary + | left=queryTerm operator=(KW_INTERSECT | KW_UNION | KW_EXCEPT | KW_MINUS) setQuantifier? right=queryTerm + | left=queryTerm operator=KW_INTERSECT setQuantifier? right=queryTerm + | left=queryTerm operator=(KW_UNION | KW_EXCEPT | KW_MINUS) setQuantifier? right=queryTerm + ; + +queryPrimary + : querySpecification + | fromClause fromStatementBody+ + | KW_TABLE tableName + | KW_VALUES expression (COMMA expression)* tableAlias + | LEFT_PAREN query RIGHT_PAREN + ; + +sortItem + : (columnName | expression) ordering=(KW_ASC | KW_DESC)? ( + KW_NULLS nullOrder=(KW_LAST | KW_FIRST) + )? + ; + +fromStatementBody + : transformClause whereClause? queryOrganization + | selectClause lateralView* whereClause? aggregationClause? havingClause? windowClause? queryOrganization + ; + +querySpecification + : transformClause fromClause? lateralView* whereClause? aggregationClause? havingClause? windowClause? + | selectClause fromClause? lateralView* whereClause? aggregationClause? havingClause? windowClause? + ; + +transformClause + : ( + KW_SELECT kind=KW_TRANSFORM LEFT_PAREN setQuantifier? expressionSeq RIGHT_PAREN + | kind=KW_MAP setQuantifier? expressionSeq + | kind=KW_REDUCE setQuantifier? expressionSeq + ) inRowFormat=rowFormat? (KW_RECORDWRITER recordWriter=stringLit)? KW_USING script=stringLit ( + KW_AS ( + identifierSeq + | colTypeList + | (LEFT_PAREN (identifierSeq | colTypeList) RIGHT_PAREN) + ) + )? outRowFormat=rowFormat? (KW_RECORDREADER recordReader=stringLit)? + ; + +selectClause + : KW_SELECT (hints+=hint)* setQuantifier? namedExpressionSeq + ; + +setClause + : KW_SET assignmentList + ; + +matchedClause + : KW_WHEN KW_MATCHED (KW_AND matchedCond=booleanExpression)? KW_THEN ( + KW_DELETE + | KW_UPDATE KW_SET (ASTERISK | assignmentList) + ) + ; + +notMatchedClause + : KW_WHEN KW_NOT KW_MATCHED (KW_BY KW_TARGET)? (KW_AND notMatchedCond=booleanExpression)? KW_THEN notMatchedAction + ; + +notMatchedBySourceClause + : KW_WHEN KW_NOT KW_MATCHED KW_BY KW_SOURCE (KW_AND notMatchedBySourceCond=booleanExpression)? KW_THEN ( + KW_DELETE + | KW_UPDATE KW_SET assignmentList + ) + ; + +notMatchedAction + : KW_INSERT ASTERISK + | KW_INSERT LEFT_PAREN multipartIdentifierList RIGHT_PAREN KW_VALUES LEFT_PAREN expression ( + COMMA expression + )* RIGHT_PAREN + ; + +assignmentList + : assignment (COMMA assignment)* + ; + +assignment + : key=multipartIdentifier EQ value=expression + ; + +whereClause + : KW_WHERE booleanExpression + ; + +havingClause + : KW_HAVING booleanExpression + ; + +hint + : HENT_START hintStatements+=hintStatement (COMMA? hintStatements+=hintStatement)* HENT_END + ; + +hintStatement + : hintName=identifier + | hintName=identifier LEFT_PAREN parameters+=primaryExpression ( + COMMA parameters+=primaryExpression + )* RIGHT_PAREN + ; + +fromClause + : KW_FROM relation (COMMA relation)* lateralView* pivotClause? unpivotClause? + ; + +temporalClause + : KW_FOR? (KW_SYSTEM_VERSION | KW_VERSION) KW_AS KW_OF (INTEGER_VALUE | stringLit) + | KW_FOR? (KW_SYSTEM_TIME | KW_TIMESTAMP) KW_AS KW_OF timestamp=valueExpression + ; + +aggregationClause + : KW_GROUP KW_BY groupingExpressionsWithGroupingAnalytics+=groupByClause ( + COMMA groupingExpressionsWithGroupingAnalytics+=groupByClause + )* + | KW_GROUP KW_BY groupingExpressions+=expression (COMMA groupingExpressions+=expression)* ( + KW_WITH kind=KW_ROLLUP + | KW_WITH kind=KW_CUBE + | kind=KW_GROUPING KW_SETS LEFT_PAREN groupingSet (COMMA groupingSet)* RIGHT_PAREN + )? + ; + +groupByClause + : columnName + | groupingAnalytics + | expression + ; + +groupingAnalytics + : (KW_ROLLUP | KW_CUBE) LEFT_PAREN groupingSet (COMMA groupingSet)* RIGHT_PAREN + | KW_GROUPING KW_SETS LEFT_PAREN (groupingAnalytics | groupingSet) ( + COMMA (groupingAnalytics | groupingSet) + )* RIGHT_PAREN + ; + +groupingSet + : columnName + | expression + | LEFT_PAREN ((columnName | expression) (COMMA (columnName | expression))*)? RIGHT_PAREN + ; + +pivotClause + : KW_PIVOT LEFT_PAREN aggregates=namedExpressionSeq KW_FOR pivotColumn KW_IN LEFT_PAREN pivotValues+=pivotValue ( + COMMA pivotValues+=pivotValue + )* RIGHT_PAREN RIGHT_PAREN + ; + +pivotColumn + : identifiers+=identifier + | LEFT_PAREN identifiers+=identifier (COMMA identifiers+=identifier)* RIGHT_PAREN + ; + +pivotValue + : expression (KW_AS? identifier)? + ; + +unpivotClause + : KW_UNPIVOT ((KW_INCLUDE | KW_EXCLUDE) KW_NULLS)? LEFT_PAREN ( + unpivotSingleValueColumnClause + | unpivotMultiValueColumnClause + ) RIGHT_PAREN (KW_AS? identifier)? + ; + +unpivotSingleValueColumnClause + : identifier KW_FOR identifier KW_IN LEFT_PAREN unpivotColumns+=unpivotColumnAndAlias ( + COMMA unpivotColumns+=unpivotColumnAndAlias + )* RIGHT_PAREN + ; + +unpivotMultiValueColumnClause + : LEFT_PAREN unpivotValueColumns+=identifier (COMMA unpivotValueColumns+=identifier)* RIGHT_PAREN KW_FOR identifier KW_IN LEFT_PAREN + unpivotColumnSets+=unpivotColumnSet (COMMA unpivotColumnSets+=unpivotColumnSet)* RIGHT_PAREN + ; + +unpivotColumnSet + : LEFT_PAREN unpivotColumns+=multipartIdentifier (COMMA unpivotColumns+=multipartIdentifier)* RIGHT_PAREN ( + KW_AS? identifier + )? + ; + +unpivotColumnAndAlias + : multipartIdentifier (KW_AS? identifier)? + ; + +ifNotExists + : KW_IF KW_NOT KW_EXISTS + ; + +ifExists + : KW_IF KW_EXISTS + ; + +lateralView + : KW_LATERAL KW_VIEW (KW_OUTER)? viewName LEFT_PAREN (expression (COMMA expression)*)? RIGHT_PAREN tableAlias ( + KW_AS? colName+=identifier (COMMA colName+=identifier)* + )? + ; + +setQuantifier + : KW_DISTINCT + | KW_ALL + ; + +relation + : tableName + | KW_LATERAL? relationPrimary (joinRelation | pivotClause | unpivotClause)* + ; + +joinRelation + : (joinType) KW_JOIN KW_LATERAL? right=relationPrimary joinCriteria? + | KW_NATURAL joinType KW_JOIN KW_LATERAL? right=relationPrimary + ; + +joinType + : KW_INNER? + | KW_CROSS + | KW_LEFT KW_OUTER? + | KW_LEFT? (KW_SEMI | KW_ANTI) + | (KW_RIGHT | KW_FULL) KW_OUTER? + ; + +joinCriteria + : KW_ON booleanExpression + | KW_USING identifierList + ; + +sample + : KW_TABLESAMPLE LEFT_PAREN sampleMethod? RIGHT_PAREN ( + KW_REPEATABLE LEFT_PAREN seed=INTEGER_VALUE RIGHT_PAREN + )? + ; + +sampleMethod + : negativeSign=MINUS? percentage=(INTEGER_VALUE | DECIMAL_VALUE) KW_PERCENTLIT + | expression KW_ROWS + | sampleType=KW_BUCKET numerator=INTEGER_VALUE KW_OUT KW_OF denominator=INTEGER_VALUE ( + KW_ON (identifier | qualifiedName LEFT_PAREN RIGHT_PAREN) + )? + | bytes=expression + ; + +identifierList + : LEFT_PAREN identifierSeq RIGHT_PAREN + ; + +identifierSeq + : ident+=errorCapturingIdentifier (COMMA ident+=errorCapturingIdentifier)* + ; + +orderedIdentifierList + : LEFT_PAREN orderedIdentifier (COMMA orderedIdentifier)* RIGHT_PAREN + ; + +orderedIdentifier + : ident=errorCapturingIdentifier ordering=(KW_ASC | KW_DESC)? + ; + +identifierCommentList + : LEFT_PAREN identifierComment (COMMA identifierComment)* RIGHT_PAREN + ; + +identifierComment + : columnNameCreate (KW_COMMENT comment=stringLit)? + ; + +relationPrimary + : (tableName | viewName | identifierReference) temporalClause? sample? tableAlias + | LEFT_PAREN query RIGHT_PAREN sample? tableAlias + | LEFT_PAREN relation RIGHT_PAREN sample? tableAlias + | KW_VALUES expression (COMMA expression)* tableAlias + | functionName LEFT_PAREN (functionTableArgument (COMMA functionTableArgument)*)? RIGHT_PAREN tableAlias + ; + +functionTableSubqueryArgument + : KW_TABLE tableName tableArgumentPartitioning? + | KW_TABLE LEFT_PAREN tableName RIGHT_PAREN tableArgumentPartitioning? + | KW_TABLE LEFT_PAREN query RIGHT_PAREN tableArgumentPartitioning? + ; + +tableArgumentPartitioning + : ( + (KW_WITH KW_SINGLE KW_PARTITION) + | ( + (KW_PARTITION | KW_DISTRIBUTE) KW_BY ( + ((LEFT_PAREN partition+=expression (COMMA partition+=expression)* RIGHT_PAREN)) + | partition+=expression + ) + ) + ) ( + (KW_ORDER | KW_SORT) KW_BY ( + ((LEFT_PAREN sortItem (COMMA sortItem)* RIGHT_PAREN) | sortItem) + ) + )? + ; + +functionTableNamedArgumentExpression + : key=identifier FAT_ARROW table=functionTableSubqueryArgument + ; + +functionTableReferenceArgument + : functionTableSubqueryArgument + | functionTableNamedArgumentExpression + ; + +functionTableArgument + : functionTableReferenceArgument + | functionArgument + ; + +tableAlias + : (KW_AS? alias=strictIdentifier identifierList?)? + ; + +rowFormat + : KW_ROW KW_FORMAT KW_SERDE name=stringLit (KW_WITH KW_SERDEPROPERTIES props=propertyList)? + | KW_ROW KW_FORMAT KW_DELIMITED ( + KW_FIELDS KW_TERMINATED KW_BY fieldsTerminatedBy=stringLit ( + KW_ESCAPED KW_BY escapedBy=stringLit + )? + )? (KW_COLLECTION KW_ITEMS KW_TERMINATED KW_BY collectionItemsTerminatedBy=stringLit)? ( + KW_MAP KW_KEYS KW_TERMINATED KW_BY keysTerminatedBy=stringLit + )? (KW_LINES KW_TERMINATED KW_BY linesSeparatedBy=stringLit)? ( + KW_NULL KW_DEFINED KW_AS nullDefinedAs=stringLit + )? + ; + +multipartIdentifierList + : multipartIdentifier (COMMA multipartIdentifier)* + ; + +multipartIdentifier + : parts+=errorCapturingIdentifier (DOT parts+=errorCapturingIdentifier)* + ; + +multipartIdentifierPropertyList + : multipartIdentifierProperty (COMMA multipartIdentifierProperty)* + ; + +multipartIdentifierProperty + : multipartIdentifier (KW_OPTIONS options=propertyList)? + ; + +tableIdentifier + : (db=errorCapturingIdentifier DOT)? table=errorCapturingIdentifier + ; + +viewIdentifier + : (db=errorCapturingIdentifier DOT)? view=errorCapturingIdentifier + ; + +namedExpression + : (columnName | expression) (KW_AS? (name=errorCapturingIdentifier | identifierList))? + ; + +namedExpressionSeq + : namedExpression (COMMA namedExpression)* + ; + +partitionFieldList + : LEFT_PAREN fields+=partitionField (COMMA fields+=partitionField)* RIGHT_PAREN + ; + +partitionField + : transform + | columnType + ; + +transform + : qualifiedName + | transformName=identifier LEFT_PAREN transformArgument (COMMA transformArgument)* RIGHT_PAREN + ; + +transformArgument + : qualifiedName + | constant + ; + +expression + : booleanExpression + ; + +namedArgumentExpression + : key=identifier FAT_ARROW value=expression + ; + +functionArgument + : expression + | namedArgumentExpression + ; + +expressionSeq + : expression (COMMA expression)* + ; + +booleanExpression + : (KW_NOT | NOT) booleanExpression + | KW_EXISTS LEFT_PAREN query RIGHT_PAREN + | valueExpression predicate? + | left=booleanExpression operator=KW_AND right=booleanExpression + | left=booleanExpression operator=KW_OR right=booleanExpression + ; + +predicate + : KW_NOT? kind=KW_BETWEEN lower=valueExpression KW_AND upper=valueExpression + | KW_NOT? kind=KW_IN LEFT_PAREN expression (COMMA expression)* RIGHT_PAREN + | KW_NOT? kind=KW_IN LEFT_PAREN query RIGHT_PAREN + | KW_NOT? kind=(KW_RLIKE | KW_REGEXP) pattern=valueExpression + | KW_NOT? kind=(KW_LIKE | KW_ILIKE) quantifier=(KW_ANY | KW_SOME | KW_ALL) ( + LEFT_PAREN RIGHT_PAREN + | LEFT_PAREN expression (COMMA expression)* RIGHT_PAREN + ) + | KW_NOT? kind=(KW_LIKE | KW_ILIKE) pattern=valueExpression (KW_ESCAPE escapeChar=stringLit)? + | KW_IS KW_NOT? kind=KW_NULL + | KW_IS KW_NOT? kind=(KW_TRUE | KW_FALSE | KW_UNKNOWN) + | KW_IS KW_NOT? kind=KW_DISTINCT KW_FROM right=valueExpression + ; + +valueExpression + : primaryExpression + | operator=(MINUS | PLUS | TILDE) valueExpression + | left=valueExpression operator=(ASTERISK | SLASH | PERCENT | KW_DIV) right=valueExpression + | left=valueExpression operator=(PLUS | MINUS | CONCAT_PIPE) right=valueExpression + | left=valueExpression operator=AMPERSAND right=valueExpression + | left=valueExpression operator=HAT right=valueExpression + | left=valueExpression operator=PIPE right=valueExpression + | left=valueExpression comparisonOperator right=valueExpression + ; + +datetimeUnit + : KW_YEAR + | KW_QUARTER + | KW_MONTH + | KW_WEEK + | KW_DAY + | KW_DAYOFYEAR + | KW_HOUR + | KW_MINUTE + | KW_SECOND + | KW_MILLISECOND + | KW_MICROSECOND + ; + +primaryExpression + : name=(KW_CURRENT_DATE | KW_CURRENT_TIMESTAMP | KW_CURRENT_USER | KW_USER | KW_SESSION_USER) + | name=(KW_TIMESTAMPADD | KW_DATEADD | KW_DATE_ADD) LEFT_PAREN ( + unit=datetimeUnit + | invalidUnit=stringLit + ) COMMA unitsAmount=valueExpression COMMA timestamp=valueExpression RIGHT_PAREN + | name=(KW_TIMESTAMPDIFF | KW_DATEDIFF | KW_DATE_DIFF | KW_TIMEDIFF) LEFT_PAREN ( + unit=datetimeUnit + | invalidUnit=stringLit + ) COMMA startTimestamp=valueExpression COMMA endTimestamp=valueExpression RIGHT_PAREN + | KW_CASE whenClause+ (KW_ELSE elseExpression=expression)? KW_END + | KW_CASE expression whenClause+ (KW_ELSE elseExpression=expression)? KW_END + | name=(KW_CAST | KW_TRY_CAST) LEFT_PAREN expression KW_AS dataType RIGHT_PAREN + | KW_STRUCT LEFT_PAREN (namedExpression (COMMA namedExpression)*)? RIGHT_PAREN + | KW_FIRST LEFT_PAREN expression (KW_IGNORE KW_NULLS)? RIGHT_PAREN + | KW_ANY_VALUE LEFT_PAREN expression (KW_IGNORE KW_NULLS)? RIGHT_PAREN + | KW_LAST LEFT_PAREN expression (KW_IGNORE KW_NULLS)? RIGHT_PAREN + | KW_POSITION LEFT_PAREN substr=valueExpression KW_IN str=valueExpression RIGHT_PAREN + | constant + | ASTERISK + | qualifiedName DOT ASTERISK + | LEFT_PAREN namedExpression (COMMA namedExpression)+ RIGHT_PAREN + | LEFT_PAREN query RIGHT_PAREN + | KW_IDENTIFIER LEFT_PAREN expression RIGHT_PAREN + | functionName LEFT_PAREN (setQuantifier? functionArgument (COMMA functionArgument)*)? RIGHT_PAREN ( + KW_FILTER LEFT_PAREN KW_WHERE where=booleanExpression RIGHT_PAREN + )? (nullsOption=(KW_IGNORE | KW_RESPECT) KW_NULLS)? (KW_OVER windowSpec)? + | identifier ARROW expression + | LEFT_PAREN identifier (COMMA identifier)+ RIGHT_PAREN ARROW expression + | value=primaryExpression LEFT_BRACKET index=valueExpression RIGHT_BRACKET + | identifier + | base=primaryExpression DOT fieldName=identifier + | LEFT_PAREN expression RIGHT_PAREN + | KW_EXTRACT LEFT_PAREN field=identifier KW_FROM source=valueExpression RIGHT_PAREN + | (KW_SUBSTR | KW_SUBSTRING) LEFT_PAREN str=valueExpression (KW_FROM | COMMA) pos=valueExpression ( + (KW_FOR | COMMA) len=valueExpression + )? RIGHT_PAREN + | KW_TRIM LEFT_PAREN trimOption=(KW_BOTH | KW_LEADING | KW_TRAILING)? ( + trimStr=valueExpression + )? KW_FROM srcStr=valueExpression RIGHT_PAREN + | KW_OVERLAY LEFT_PAREN input=valueExpression KW_PLACING replace=valueExpression KW_FROM position=valueExpression ( + KW_FOR length=valueExpression + )? RIGHT_PAREN + | name=(KW_PERCENTILE_CONT | KW_PERCENTILE_DISC) LEFT_PAREN percentage=valueExpression RIGHT_PAREN KW_WITHIN KW_GROUP LEFT_PAREN KW_ORDER KW_BY + sortItem RIGHT_PAREN (KW_FILTER LEFT_PAREN KW_WHERE where=booleanExpression RIGHT_PAREN)? ( + KW_OVER windowSpec + )? + ; + +literalType + : KW_DATE + | KW_TIMESTAMP + | KW_TIMESTAMP_LTZ + | KW_TIMESTAMP_NTZ + | KW_INTERVAL + | KW_BINARY_HEX + | unsupportedType=identifier + ; + +constant + : KW_NULL + | QUESTION + | COLON identifier + | interval + | literalType stringLit + | number + | booleanValue + | stringLit+ + ; + +comparisonOperator + : EQ + | NEQ + | NEQJ + | LT + | LTE + | GT + | GTE + | NSEQ + ; + +arithmeticOperator + : PLUS + | MINUS + | ASTERISK + | SLASH + | PERCENT + | KW_DIV + | TILDE + | AMPERSAND + | PIPE + | CONCAT_PIPE + | HAT + ; + +predicateOperator + : KW_OR + | KW_AND + | KW_IN + | KW_NOT + ; + +booleanValue + : KW_TRUE + | KW_FALSE + ; + +interval + : KW_INTERVAL (errorCapturingMultiUnitsInterval | errorCapturingUnitToUnitInterval) + ; + +errorCapturingMultiUnitsInterval + : body=multiUnitsInterval unitToUnitInterval? + ; + +errorCapturingUnitToUnitInterval + : body=unitToUnitInterval (error1=multiUnitsInterval | error2=unitToUnitInterval)? + ; + +multiUnitsInterval + : (intervalValue unit+=unitInMultiUnits)+ + ; + +unitToUnitInterval + : value=intervalValue unitInUnitToUnit KW_TO unitInUnitToUnit + ; + +intervalValue + : (PLUS | MINUS)? (INTEGER_VALUE | DECIMAL_VALUE | stringLit) + ; + +unitInMultiUnits + : KW_NANOSECOND + | KW_NANOSECONDS + | KW_MICROSECOND + | KW_MICROSECONDS + | KW_MILLISECOND + | KW_MILLISECONDS + | KW_SECOND + | KW_SECONDS + | KW_MINUTE + | KW_MINUTES + | KW_HOUR + | KW_HOURS + | KW_DAY + | KW_DAYS + | KW_WEEK + | KW_WEEKS + | KW_MONTH + | KW_MONTHS + | KW_YEAR + | KW_YEARS + ; + +unitInUnitToUnit + : KW_SECOND + | KW_MINUTE + | KW_HOUR + | KW_DAY + | KW_MONTH + | KW_YEAR + ; + +colPosition + : position=KW_FIRST + | position=KW_AFTER afterCol=errorCapturingIdentifier + ; + +type + : KW_BOOLEAN + | KW_TINYINT + | KW_BYTE + | KW_SMALLINT + | KW_SHORT + | KW_INT + | KW_INTEGER + | KW_BIGINT + | KW_LONG + | KW_FLOAT + | KW_REAL + | KW_DOUBLE + | KW_DATE + | KW_TIMESTAMP + | KW_TIMESTAMP_NTZ + | KW_TIMESTAMP_LTZ + | KW_STRING + | KW_CHARACTER + | KW_CHAR + | KW_VARCHAR + | KW_BINARY + | KW_DECIMAL + | KW_DEC + | KW_NUMERIC + | KW_VOID + | KW_INTERVAL + | KW_ARRAY + | KW_STRUCT + | KW_MAP + | unsupportedType=identifier + ; + +dataType + : complex=KW_ARRAY LT dataType GT + | complex=KW_MAP LT dataType COMMA dataType GT + | complex=KW_STRUCT (LT (complexColType (COMMA complexColType)*)? GT | NEQ) + | KW_INTERVAL (KW_YEAR | KW_MONTH) (KW_TO KW_MONTH)? + | KW_INTERVAL (KW_DAY | KW_HOUR | KW_MINUTE | KW_SECOND) ( + KW_TO (KW_HOUR | KW_MINUTE | KW_SECOND) + )? + | type (LEFT_PAREN INTEGER_VALUE (COMMA INTEGER_VALUE)* RIGHT_PAREN)? + ; + +qualifiedColTypeWithPositionSeqForAdd + : qualifiedColTypeWithPositionForAdd (COMMA qualifiedColTypeWithPositionForAdd)* + ; + +qualifiedColTypeWithPositionForAdd + : name=columnNameCreate dataType colDefinitionDescriptorWithPosition* + ; + +qualifiedColTypeWithPositionSeqForReplace + : qualifiedColTypeWithPositionForReplace (COMMA qualifiedColTypeWithPositionForReplace)* + ; + +qualifiedColTypeWithPositionForReplace + : name=columnName dataType colDefinitionDescriptorWithPosition* + ; + +colDefinitionDescriptorWithPosition + : KW_NOT KW_NULL + | KW_DEFAULT expression + | KW_COMMENT comment=stringLit + | colPosition + ; + +variableDefaultExpression + : (KW_DEFAULT | EQ) expression + ; + +colTypeList + : columnType (COMMA columnType)* + ; + +columnType + : colName=errorCapturingIdentifier dataType (KW_NOT KW_NULL)? (KW_COMMENT comment=stringLit)? + ; + +createOrReplaceTableColTypeList + : createOrReplaceTableColType (COMMA createOrReplaceTableColType)* + ; + +createOrReplaceTableColType + : colName=columnNameCreate colType=dataType colDefinitionOption* + ; + +colDefinitionOption + : KW_NOT KW_NULL + | KW_DEFAULT expression + | KW_GENERATED KW_ALWAYS KW_AS LEFT_PAREN expression RIGHT_PAREN + | KW_COMMENT comment=stringLit + ; + +complexColType + : identifier COLON? dataType (KW_NOT KW_NULL)? (KW_COMMENT comment=stringLit)? + ; + +whenClause + : KW_WHEN condition=expression KW_THEN result=expression + ; + +windowClause + : KW_WINDOW name=errorCapturingIdentifier KW_AS windowSpec ( + COMMA name=errorCapturingIdentifier KW_AS windowSpec + )* + ; + +windowSpec + : name=errorCapturingIdentifier + | LEFT_PAREN name=errorCapturingIdentifier RIGHT_PAREN + | LEFT_PAREN ( + KW_CLUSTER KW_BY partition+=expression (COMMA partition+=expression)* + | ( + (KW_PARTITION | KW_DISTRIBUTE) KW_BY partition+=expression ( + COMMA partition+=expression + )* + )? ((KW_ORDER | KW_SORT) KW_BY sortItem (COMMA sortItem)*)? + ) windowFrame? RIGHT_PAREN + ; + +/** +* replace start identifier with start_ in grammar. +* https://github.com/tunnelvisionlabs/antlr4ts/issues/417 +*/ +windowFrame + : frameType=(KW_RANGE | KW_ROWS) start_=frameBound + | frameType=(KW_RANGE | KW_ROWS) KW_BETWEEN start_=frameBound KW_AND end=frameBound + ; + +frameBound + : KW_UNBOUNDED boundType=(KW_PRECEDING | KW_FOLLOWING) + | boundType=KW_CURRENT KW_ROW + | expression boundType=(KW_PRECEDING | KW_FOLLOWING) + ; + +qualifiedNameList + : qualifiedName (COMMA qualifiedName)* + ; + +functionName + : KW_IDENTIFIER LEFT_PAREN expression RIGHT_PAREN + | qualifiedName + | KW_FILTER + | KW_LEFT + | KW_RIGHT + ; + +functionNameCreate + : qualifiedName + ; + +qualifiedName + : identifier (DOT identifier)* + ; + +// this rule is used for explicitly capturing wrong identifiers such as test-table, which should actually be `test-table` +// replace identifier with errorCapturingIdentifier where the immediate follow symbol is not an expression, otherwise +// valid expressions such as "a-b" can be recognized as an identifier +errorCapturingIdentifier + : identifier errorCapturingIdentifierExtra + ; + +// extra left-factoring grammar +errorCapturingIdentifierExtra + : (MINUS identifier)+ + | + ; + +identifier + : strictIdentifier + | strictNonReserved + ; + +strictIdentifier + : IDENTIFIER + | BACKQUOTED_IDENTIFIER + | DOUBLEQUOTED_STRING + | ansiNonReserved + | nonReserved + ; + +number + : MINUS? ( + EXPONENT_VALUE + | DECIMAL_VALUE + | EXPONENT_VALUE + | DECIMAL_VALUE + | INTEGER_VALUE + | BIGINT_LITERAL + | SMALLINT_LITERAL + | TINYINT_LITERAL + | DOUBLE_LITERAL + | FLOAT_LITERAL + | BIGDECIMAL_LITERAL + ) + ; + +alterColumnAction + : KW_TYPE dataType + | (KW_COMMENT comment=stringLit) + | colPosition + | setOrDrop=(KW_SET | KW_DROP) KW_NOT KW_NULL + | KW_SET KW_DEFAULT expression + | dropDefault=KW_DROP KW_DEFAULT + ; + +stringLit + : STRING_LITERAL + | DOUBLEQUOTED_STRING + ; + +// When `SQL_standard_keyword_behavior=true`, there are 2 kinds of keywords in sql. +// - Reserved keywords: +// Keywords that are reserved and can't be used as identifiers for table, view, column, +// function, alias, etc. +// - Non-reserved keywords: +// Keywords that have a special meaning only in particular contexts and can be used as +// identifiers in other contexts. For example, `EXPLAIN SELECT ...` is a command, but EXPLAIN +// can be used as identifiers in other places. +// You can find the full keywords list by searching "Start of the keywords list" in this file. +// The non-reserved keywords are listed below. Keywords not in this list are reserved keywords. +ansiNonReserved + //--ANSI-NON-RESERVED-START + : KW_ADD + | KW_AFTER + | KW_ALTER + | KW_ALWAYS + | KW_ANALYZE + | KW_ANTI + | KW_ANY_VALUE + | KW_ARCHIVE + | KW_ARRAY + | KW_ASC + | KW_AT + | KW_BETWEEN + | KW_BIGINT + | KW_BINARY + | KW_BINARY_HEX + | KW_BOOLEAN + | KW_BUCKET + | KW_BUCKETS + | KW_BY + | KW_BYTE + | KW_CACHE + | KW_CASCADE + | KW_CATALOG + | KW_CATALOGS + | KW_CHANGE + | KW_CHAR + | KW_CHARACTER + | KW_CLEAR + | KW_CLUSTER + | KW_CLUSTERED + | KW_CODEGEN + | KW_COLLECTION + | KW_COLUMNS + | KW_COMMENT + | KW_COMMIT + | KW_COMPACT + | KW_COMPACTIONS + | KW_COMPUTE + | KW_CONCATENATE + | KW_COST + | KW_CUBE + | KW_CURRENT + | KW_DATA + | KW_DATABASE + | KW_DATABASES + | KW_DATE + | KW_DATEADD + | KW_DATE_ADD + | KW_DATEDIFF + | KW_DATE_DIFF + | KW_DAY + | KW_DAYS + | KW_DAYOFYEAR + | KW_DBPROPERTIES + | KW_DEC + | KW_DECIMAL + | KW_DECLARE + | KW_DEFAULT + | KW_DEFINED + | KW_DELETE + | KW_DELIMITED + | KW_DESC + | KW_DESCRIBE + | KW_DFS + | KW_DIRECTORIES + | KW_DIRECTORY + | KW_DISABLE + | KW_DISTRIBUTE + | KW_DIV + | KW_DOUBLE + | KW_DROP + | KW_ENABLE + | KW_ESCAPED + | KW_EXCHANGE + | KW_EXCLUDE + | KW_EXISTS + | KW_EXPLAIN + | KW_EXPORT + | KW_EXTENDED + | KW_EXTERNAL + | KW_EXTRACT + | KW_FIELDS + | KW_FILEFORMAT + | KW_FIRST + | KW_FLOAT + | KW_FOLLOWING + | KW_FORMAT + | KW_FORMATTED + | KW_FUNCTION + | KW_FUNCTIONS + | KW_GENERATED + | KW_GLOBAL + | KW_GROUPING + | KW_HOUR + | KW_HOURS + | KW_IDENTIFIER + | KW_IF + | KW_IGNORE + | KW_IMPORT + | KW_INCLUDE + | KW_INDEX + | KW_INDEXES + | KW_INPATH + | KW_INPUTFORMAT + | KW_INSERT + | KW_INT + | KW_INTEGER + | KW_INTERVAL + | KW_ITEMS + | KW_KEYS + | KW_LAST + | KW_LAZY + | KW_LIKE + | KW_ILIKE + | KW_LIMIT + | KW_LINES + | KW_LIST + | KW_LOAD + | KW_LOCAL + | KW_LOCATION + | KW_LOCK + | KW_LOCKS + | KW_LOGICAL + | KW_LONG + | KW_MACRO + | KW_MAP + | KW_MATCHED + | KW_MERGE + | KW_MICROSECOND + | KW_MICROSECONDS + | KW_MILLISECOND + | KW_MILLISECONDS + | KW_MINUTE + | KW_MINUTES + | KW_MONTH + | KW_MONTHS + | KW_MSCK + | KW_NAME + | KW_NAMESPACE + | KW_NAMESPACES + | KW_NANOSECOND + | KW_NANOSECONDS + | KW_NO + | KW_NULLS + | KW_NUMERIC + | KW_OF + | KW_OPTIMIZE + | KW_OPTION + | KW_OPTIONS + | KW_OUT + | KW_OUTPUTFORMAT + | KW_OVER + | KW_OVERLAY + | KW_OVERWRITE + | KW_PARTITION + | KW_PARTITIONED + | KW_PARTITIONS + | KW_PERCENTLIT + | KW_PIVOT + | KW_PLACING + | KW_POSITION + | KW_PRECEDING + | KW_PRINCIPALS + | KW_PROPERTIES + | KW_PURGE + | KW_QUARTER + | KW_QUERY + | KW_RANGE + | KW_REAL + | KW_RECORDREADER + | KW_RECORDWRITER + | KW_RECOVER + | KW_REDUCE + | KW_REFRESH + | KW_RENAME + | KW_REPAIR + | KW_REPEATABLE + | KW_REPLACE + | KW_RESET + | KW_RESPECT + | KW_RESTRICT + | KW_REVOKE + | KW_REWRITE + | KW_RLIKE + | KW_REGEXP + | KW_ROLE + | KW_ROLES + | KW_ROLLBACK + | KW_ROLLUP + | KW_ROW + | KW_ROWS + | KW_SCHEMA + | KW_SCHEMAS + | KW_SECOND + | KW_SECONDS + | KW_SEMI + | KW_SEPARATED + | KW_SERDE + | KW_SERDEPROPERTIES + | KW_SET + | KW_MINUS + | KW_SETS + | KW_SHORT + | KW_SHOW + | KW_SINGLE + | KW_SKEWED + | KW_SMALLINT + | KW_SORT + | KW_SORTED + | KW_SOURCE + | KW_START + | KW_STATISTICS + | KW_STORED + | KW_STRATIFY + | KW_STRING + | KW_STRUCT + | KW_SUBSTR + | KW_SUBSTRING + | KW_SYNC + | KW_SYSTEM + | KW_SYSTEM_TIME + | KW_SYSTEM_VERSION + | KW_TABLES + | KW_TABLESAMPLE + | KW_TARGET + | KW_TBLPROPERTIES + | KW_TEMPORARY + | KW_TERMINATED + | KW_TIMEDIFF + | KW_TIMESTAMP + | KW_TIMESTAMP_LTZ + | KW_TIMESTAMP_NTZ + | KW_TIMESTAMPADD + | KW_TIMESTAMPDIFF + | KW_TINYINT + | KW_TOUCH + | KW_TRANSACTION + | KW_TRANSACTIONS + | KW_TRANSFORM + | KW_TRIM + | KW_TRUE + | KW_TRUNCATE + | KW_TRY_CAST + | KW_TYPE + | KW_UNARCHIVE + | KW_UNBOUNDED + | KW_UNCACHE + | KW_UNLOCK + | KW_UNPIVOT + | KW_UNSET + | KW_UPDATE + | KW_USE + | KW_VALUES + | KW_VARCHAR + | KW_VAR + | KW_VARIABLE + | KW_VERSION + | KW_VIEW + | KW_VIEWS + | KW_VOID + | KW_WEEK + | KW_WEEKS + | KW_WINDOW + | KW_YEAR + | KW_YEARS + | KW_ZONE + | KW_ZORDER + //--ANSI-NON-RESERVED-END + ; + +// When `SQL_standard_keyword_behavior=false`, there are 2 kinds of keywords in sql. +// - Non-reserved keywords: +// Same definition as the one when `SQL_standard_keyword_behavior=true`. +// - Strict-non-reserved keywords: +// A strict version of non-reserved keywords, which can not be used as table alias. +// You can find the full keywords list by searching "Start of the keywords list" in this file. +// The strict-non-reserved keywords are listed in `strictNonReserved`. +// The non-reserved keywords are listed in `nonReserved`. +// These 2 together contain all the keywords. +strictNonReserved + : KW_ANTI + | KW_CROSS + | KW_EXCEPT + | KW_FULL + | KW_INNER + | KW_INTERSECT + | KW_JOIN + | KW_LATERAL + | KW_LEFT + | KW_NATURAL + | KW_ON + | KW_RIGHT + | KW_SEMI + | KW_MINUS + | KW_UNION + | KW_USING + ; + +nonReserved + //--DEFAULT-NON-RESERVED-START + : KW_ADD + | KW_AFTER + | KW_ALL + | KW_ALTER + | KW_ALWAYS + | KW_ANALYZE + | KW_AND + | KW_ANY + | KW_ANY_VALUE + | KW_ARCHIVE + | KW_ARRAY + | KW_AS + | KW_ASC + | KW_AT + | KW_AUTHORIZATION + | KW_BETWEEN + | KW_BIGINT + | KW_BINARY + | KW_BINARY_HEX + | KW_BOOLEAN + | KW_BOTH + | KW_BUCKET + | KW_BUCKETS + | KW_BY + | KW_BYTE + | KW_CACHE + | KW_CASCADE + | KW_CASE + | KW_CAST + | KW_CATALOG + | KW_CATALOGS + | KW_CHANGE + | KW_CHAR + | KW_CHARACTER + | KW_CHECK + | KW_CLEAR + | KW_CLUSTER + | KW_CLUSTERED + | KW_CODEGEN + | KW_COLLATE + | KW_COLLECTION + | KW_COLUMN + | KW_COLUMNS + | KW_COMMENT + | KW_COMMIT + | KW_COMPACT + | KW_COMPACTIONS + | KW_COMPUTE + | KW_CONCATENATE + | KW_CONSTRAINT + | KW_COST + | KW_CREATE + | KW_CUBE + | KW_CURRENT + | KW_CURRENT_DATE + | KW_CURRENT_TIME + | KW_CURRENT_TIMESTAMP + | KW_CURRENT_USER + | KW_DATA + | KW_DATABASE + | KW_DATABASES + | KW_DATE + | KW_DATEADD + | KW_DATE_ADD + | KW_DATEDIFF + | KW_DATE_DIFF + | KW_DAY + | KW_DAYS + | KW_DAYOFYEAR + | KW_DBPROPERTIES + | KW_DEC + | KW_DECIMAL + | KW_DECLARE + | KW_DEFAULT + | KW_DEFINED + | KW_DELETE + | KW_DELIMITED + | KW_DESC + | KW_DESCRIBE + | KW_DFS + | KW_DIRECTORIES + | KW_DIRECTORY + | KW_DISABLE + | KW_DISTINCT + | KW_DISTRIBUTE + | KW_DIV + | KW_DOUBLE + | KW_DROP + | KW_ELSE + | KW_ENABLE + | KW_END + | KW_ESCAPE + | KW_ESCAPED + | KW_EXCHANGE + | KW_EXCLUDE + | KW_EXISTS + | KW_EXPLAIN + | KW_EXPORT + | KW_EXTENDED + | KW_EXTERNAL + | KW_EXTRACT + | KW_FALSE + | KW_FETCH + | KW_FILTER + | KW_FIELDS + | KW_FILEFORMAT + | KW_FIRST + | KW_FLOAT + | KW_FOLLOWING + | KW_FOR + | KW_FOREIGN + | KW_FORMAT + | KW_FORMATTED + // | KW_FROM + | KW_FUNCTION + | KW_FUNCTIONS + | KW_GENERATED + | KW_GLOBAL + | KW_GRANT + | KW_GROUP + | KW_GROUPING + | KW_HAVING + | KW_HOUR + | KW_HOURS + | KW_IDENTIFIER + | KW_IF + | KW_IGNORE + | KW_IMPORT + | KW_IN + | KW_INCLUDE + | KW_INDEX + | KW_INDEXES + | KW_INPATH + | KW_INPUTFORMAT + | KW_INSERT + | KW_INT + | KW_INTEGER + | KW_INTERVAL + | KW_INTO + | KW_IS + | KW_ITEMS + | KW_KEYS + | KW_LAST + | KW_LAZY + | KW_LEADING + | KW_LIFECYCLE + | KW_LIKE + | KW_LONG + | KW_ILIKE + | KW_LIMIT + | KW_LINES + | KW_LIST + | KW_LOAD + | KW_LOCAL + | KW_LOCATION + | KW_LOCK + | KW_LOCKS + | KW_LOGICAL + | KW_LONG + | KW_MACRO + | KW_MAP + | KW_MATCHED + | KW_MERGE + | KW_MICROSECOND + | KW_MICROSECONDS + | KW_MILLISECOND + | KW_MILLISECONDS + | KW_MINUTE + | KW_MINUTES + | KW_MONTH + | KW_MONTHS + | KW_MSCK + | KW_NAME + | KW_NAMESPACE + | KW_NAMESPACES + | KW_NANOSECOND + | KW_NANOSECONDS + | KW_NO + | KW_NOT + | KW_NULL + | KW_NULLS + | KW_NUMERIC + | KW_OF + | KW_OFFSET + | KW_ONLY + | KW_OPTIMIZE + | KW_OPTION + | KW_OPTIONS + | KW_OR + | KW_ORDER + | KW_OUT + | KW_OUTER + | KW_OUTPUTFORMAT + | KW_OVER + | KW_OVERLAPS + | KW_OVERLAY + | KW_OVERWRITE + | KW_PARTITION + | KW_PARTITIONED + | KW_PARTITIONS + | KW_PERCENTILE_CONT + | KW_PERCENTILE_DISC + | KW_PERCENTLIT + | KW_PIVOT + | KW_PLACING + | KW_POSITION + | KW_PRECEDING + | KW_PRIMARY + | KW_PRINCIPALS + | KW_PROPERTIES + | KW_PURGE + | KW_QUARTER + | KW_QUERY + | KW_RANGE + | KW_REAL + | KW_RECORDREADER + | KW_RECORDWRITER + | KW_RECOVER + | KW_REDUCE + | KW_REFERENCES + | KW_REFRESH + | KW_RENAME + | KW_REPAIR + | KW_REPEATABLE + | KW_REPLACE + | KW_RESET + | KW_RESPECT + | KW_RESTRICT + | KW_REVOKE + | KW_REWRITE + | KW_RLIKE + | KW_REGEXP + | KW_ROLE + | KW_ROLES + | KW_ROLLBACK + | KW_ROLLUP + | KW_ROW + | KW_ROWS + | KW_SCHEMA + | KW_SCHEMAS + | KW_SECOND + | KW_SECONDS + | KW_SEPARATED + | KW_SERDE + | KW_SERDEPROPERTIES + | KW_SESSION_USER + | KW_SET + | KW_SETS + | KW_SHORT + | KW_SHOW + | KW_SINGLE + | KW_SKEWED + | KW_SMALLINT + | KW_SOME + | KW_SORT + | KW_SORTED + | KW_SOURCE + | KW_START + | KW_STATISTICS + | KW_STORED + | KW_STRATIFY + | KW_STRING + | KW_STRUCT + | KW_SUBSTR + | KW_SUBSTRING + | KW_SYNC + | KW_SYSTEM + | KW_SYSTEM_TIME + | KW_SYSTEM_VERSION + // | KW_TABLE + | KW_TABLES + | KW_TABLESAMPLE + | KW_TARGET + | KW_TBLPROPERTIES + | KW_TEMPORARY + | KW_TERMINATED + | KW_THEN + | KW_TIME + | KW_TIMEDIFF + | KW_TIMESTAMP + | KW_TIMESTAMP_LTZ + | KW_TIMESTAMP_NTZ + | KW_TIMESTAMPADD + | KW_TIMESTAMPDIFF + | KW_TINYINT + | KW_TO + | KW_TOUCH + | KW_TRAILING + | KW_TRANSACTION + | KW_TRANSACTIONS + | KW_TRANSFORM + | KW_TRIM + | KW_TRUE + | KW_TRUNCATE + | KW_TRY_CAST + | KW_TYPE + | KW_UNARCHIVE + | KW_UNBOUNDED + | KW_UNCACHE + | KW_UNIQUE + | KW_UNKNOWN + | KW_UNLOCK + | KW_UNPIVOT + | KW_UNSET + | KW_UPDATE + | KW_USE + | KW_USER + | KW_VALUES + | KW_VARCHAR + | KW_VAR + | KW_VARIABLE + | KW_VERSION + | KW_VIEW + | KW_VIEWS + | KW_VOID + | KW_WEEK + | KW_WEEKS + | KW_WHEN + | KW_WHERE + | KW_WINDOW + | KW_WITH + | KW_WITHIN + | KW_YEAR + | KW_YEARS + | KW_ZONE + | KW_ZORDER + //--DEFAULT-NON-RESERVED-END + ; \ No newline at end of file diff --git a/src/grammar/trino/TrinoSql.g4 b/src/grammar/trino/TrinoSql.g4 index ed74b529..bebc0464 100644 --- a/src/grammar/trino/TrinoSql.g4 +++ b/src/grammar/trino/TrinoSql.g4 @@ -84,11 +84,11 @@ statement | KW_ALTER KW_SCHEMA schemaRef KW_RENAME KW_TO schemaNameCreate # renameSchema | KW_ALTER KW_SCHEMA schemaRef KW_SET KW_AUTHORIZATION principal # setSchemaAuthorization | KW_CREATE (KW_OR KW_REPLACE)? KW_TABLE (KW_IF KW_NOT KW_EXISTS)? tableNameCreate columnListCreate? ( - KW_COMMENT string + KW_COMMENT comment=string )? (KW_WITH properties)? KW_AS (rootQuery | '(' rootQuery ')') (KW_WITH (KW_NO)? KW_DATA)? # createTableAsSelect | KW_CREATE (KW_OR KW_REPLACE)? KW_TABLE (KW_IF KW_NOT KW_EXISTS)? tableNameCreate '(' tableElement ( ',' tableElement - )* ')' (KW_COMMENT string)? (KW_WITH properties)? # createTable + )* ')' (KW_COMMENT comment=string)? (KW_WITH properties)? # createTable | KW_DROP KW_TABLE (KW_IF KW_EXISTS)? tableRef # dropTable | KW_INSERT KW_INTO tableRef columnList? rootQuery # insertInto | KW_DELETE KW_FROM tableRef (KW_WHERE booleanExpression)? # delete @@ -110,8 +110,8 @@ statement | KW_ANALYZE tableRef (KW_WITH properties)? # analyze | KW_CREATE (KW_OR KW_REPLACE)? KW_MATERIALIZED KW_VIEW (KW_IF KW_NOT KW_EXISTS)? viewNameCreate ( KW_GRACE KW_PERIOD interval - )? (KW_COMMENT string)? (KW_WITH properties)? KW_AS rootQuery # createMaterializedView - | KW_CREATE (KW_OR KW_REPLACE)? KW_VIEW viewNameCreate (KW_COMMENT string)? ( + )? (KW_COMMENT comment=string)? (KW_WITH properties)? KW_AS rootQuery # createMaterializedView + | KW_CREATE (KW_OR KW_REPLACE)? KW_VIEW viewNameCreate (KW_COMMENT comment=string)? ( KW_SECURITY (KW_DEFINER | KW_INVOKER) )? (KW_WITH properties)? KW_AS rootQuery # createView | KW_REFRESH KW_MATERIALIZED KW_VIEW viewRef # refreshMaterializedView @@ -214,7 +214,7 @@ tableElement ; columnDefinition - : columnNameCreate type (KW_NOT KW_NULL)? (KW_COMMENT string)? (KW_WITH properties)? + : columnNameCreate colType=type (KW_NOT KW_NULL)? (KW_COMMENT comment=string)? (KW_WITH properties)? ; likeClause @@ -330,7 +330,7 @@ setQuantifier ; selectItem - : (columnRef | expression) (KW_AS? identifier)? # selectSingle + : (columnRef | expression) (KW_AS? alias=identifier)? # selectSingle | primaryExpression '.' ASTERISK (KW_AS columnAliases)? # selectAll | ASTERISK # selectAll ; @@ -425,7 +425,7 @@ variableDefinition ; aliasedRelation - : relationPrimary (KW_AS? identifier columnAliases?)? + : relationPrimary (KW_AS? alias=identifier columnAliases?)? ; columnListCreate diff --git a/src/index.ts b/src/index.ts index 315aa589..d307b69d 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,4 +1,4 @@ -export { MySQL, FlinkSQL, SparkSQL, HiveSQL, PostgreSQL, TrinoSQL, ImpalaSQL } from './parser'; +export { MySQL, FlinkSQL, SparkSQL, HiveSQL, PostgreSQL, TrinoSQL, ImpalaSQL, Sql } from './parser'; export { MySqlParserListener, @@ -15,6 +15,8 @@ export { TrinoSqlVisitor, ImpalaSqlParserListener, ImpalaSqlParserVisitor, + SqlParserListener, + SqlParserVisitor, } from './lib'; export { EntityContextType } from './parser/common/types'; diff --git a/src/lib/flink/FlinkSqlParser.interp b/src/lib/flink/FlinkSqlParser.interp index 23ac5c46..2ae21016 100644 --- a/src/lib/flink/FlinkSqlParser.interp +++ b/src/lib/flink/FlinkSqlParser.interp @@ -1123,7 +1123,6 @@ lengthOneTypeDimension mapTypeDimension rowTypeDimension columnConstraint -commentSpec metadataColumnDefinition metadataKey computedColumnDefinition @@ -1151,7 +1150,7 @@ addConstraint dropConstraint addUnique notForced -alertView +alterView alterDatabase alterFunction dropCatalog @@ -1278,4 +1277,4 @@ nonReservedKeywords atn: -[4, 1, 541, 2272, 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, 1, 0, 5, 0, 378, 8, 0, 10, 0, 12, 0, 381, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 387, 8, 1, 1, 1, 3, 1, 390, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 404, 8, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 422, 8, 4, 1, 5, 1, 5, 3, 5, 426, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 435, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 440, 8, 7, 1, 8, 1, 8, 1, 8, 5, 8, 445, 8, 8, 10, 8, 12, 8, 448, 9, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 458, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 465, 8, 11, 10, 11, 12, 11, 468, 9, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 479, 8, 12, 1, 12, 3, 12, 482, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 489, 8, 12, 1, 12, 3, 12, 492, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 500, 8, 12, 1, 12, 1, 12, 3, 12, 504, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 509, 8, 12, 1, 12, 3, 12, 512, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 519, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 3, 15, 527, 8, 15, 1, 16, 1, 16, 3, 16, 531, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 543, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 551, 8, 18, 1, 18, 1, 18, 3, 18, 555, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 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, 587, 8, 18, 1, 19, 3, 19, 590, 8, 19, 1, 19, 4, 19, 593, 8, 19, 11, 19, 12, 19, 594, 1, 20, 1, 20, 3, 20, 599, 8, 20, 1, 21, 1, 21, 3, 21, 603, 8, 21, 1, 21, 1, 21, 3, 21, 607, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 5, 21, 614, 8, 21, 10, 21, 12, 21, 617, 9, 21, 1, 21, 1, 21, 3, 21, 621, 8, 21, 1, 21, 1, 21, 3, 21, 625, 8, 21, 1, 21, 1, 21, 3, 21, 629, 8, 21, 1, 21, 1, 21, 3, 21, 633, 8, 21, 1, 21, 3, 21, 636, 8, 21, 1, 21, 1, 21, 3, 21, 640, 8, 21, 1, 22, 1, 22, 1, 22, 3, 22, 645, 8, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 651, 8, 22, 1, 23, 1, 23, 1, 23, 3, 23, 656, 8, 23, 1, 24, 1, 24, 1, 24, 3, 24, 661, 8, 24, 1, 24, 3, 24, 664, 8, 24, 1, 25, 1, 25, 3, 25, 668, 8, 25, 1, 26, 1, 26, 3, 26, 672, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 678, 8, 27, 10, 27, 12, 27, 681, 9, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 3, 28, 688, 8, 28, 1, 28, 1, 28, 3, 28, 692, 8, 28, 1, 28, 1, 28, 3, 28, 696, 8, 28, 1, 28, 1, 28, 3, 28, 700, 8, 28, 1, 28, 1, 28, 3, 28, 704, 8, 28, 1, 28, 1, 28, 3, 28, 708, 8, 28, 1, 28, 1, 28, 3, 28, 712, 8, 28, 1, 28, 1, 28, 3, 28, 716, 8, 28, 1, 28, 1, 28, 3, 28, 720, 8, 28, 3, 28, 722, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 732, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 740, 8, 31, 1, 31, 1, 31, 1, 32, 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, 5, 34, 762, 8, 34, 10, 34, 12, 34, 765, 9, 34, 1, 34, 1, 34, 1, 35, 1, 35, 3, 35, 771, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 777, 8, 35, 1, 35, 3, 35, 780, 8, 35, 1, 35, 3, 35, 783, 8, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 793, 8, 37, 1, 37, 3, 37, 796, 8, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 804, 8, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 3, 42, 816, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 5, 46, 838, 8, 46, 10, 46, 12, 46, 841, 9, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 5, 47, 850, 8, 47, 10, 47, 12, 47, 853, 9, 47, 1, 47, 1, 47, 3, 47, 857, 8, 47, 1, 48, 1, 48, 3, 48, 861, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 5, 49, 867, 8, 49, 10, 49, 12, 49, 870, 9, 49, 1, 49, 3, 49, 873, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 879, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 3, 52, 889, 8, 52, 1, 52, 1, 52, 3, 52, 893, 8, 52, 1, 52, 1, 52, 1, 53, 1, 53, 3, 53, 899, 8, 53, 1, 53, 1, 53, 3, 53, 903, 8, 53, 1, 53, 1, 53, 3, 53, 907, 8, 53, 1, 53, 3, 53, 910, 8, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 919, 8, 54, 1, 54, 1, 54, 3, 54, 923, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 930, 8, 54, 1, 54, 3, 54, 933, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 941, 8, 55, 10, 55, 12, 55, 944, 9, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 3, 57, 951, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 959, 8, 57, 1, 58, 1, 58, 3, 58, 963, 8, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 978, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 997, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1008, 8, 66, 1, 66, 1, 66, 3, 66, 1012, 8, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1019, 8, 66, 1, 67, 1, 67, 1, 67, 3, 67, 1024, 8, 67, 1, 67, 1, 67, 1, 68, 1, 68, 3, 68, 1030, 8, 68, 1, 68, 1, 68, 3, 68, 1034, 8, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 3, 69, 1041, 8, 69, 1, 69, 1, 69, 3, 69, 1045, 8, 69, 1, 70, 1, 70, 3, 70, 1049, 8, 70, 1, 70, 1, 70, 3, 70, 1053, 8, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1061, 8, 71, 1, 71, 1, 71, 3, 71, 1065, 8, 71, 1, 71, 1, 71, 1, 72, 3, 72, 1070, 8, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1076, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1082, 8, 73, 1, 73, 3, 73, 1085, 8, 73, 1, 73, 1, 73, 3, 73, 1089, 8, 73, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 5, 75, 1098, 8, 75, 10, 75, 12, 75, 1101, 9, 75, 1, 76, 1, 76, 1, 76, 1, 76, 5, 76, 1107, 8, 76, 10, 76, 12, 76, 1110, 9, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 4, 77, 1121, 8, 77, 11, 77, 12, 77, 1122, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 4, 78, 1133, 8, 78, 11, 78, 12, 78, 1134, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1150, 8, 79, 1, 79, 3, 79, 1153, 8, 79, 1, 79, 1, 79, 3, 79, 1157, 8, 79, 1, 79, 3, 79, 1160, 8, 79, 3, 79, 1162, 8, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1167, 8, 79, 1, 79, 1, 79, 3, 79, 1171, 8, 79, 1, 79, 3, 79, 1174, 8, 79, 5, 79, 1176, 8, 79, 10, 79, 12, 79, 1179, 9, 79, 1, 80, 1, 80, 1, 80, 1, 80, 5, 80, 1185, 8, 80, 10, 80, 12, 80, 1188, 9, 80, 1, 81, 1, 81, 1, 81, 1, 81, 5, 81, 1194, 8, 81, 10, 81, 12, 81, 1197, 9, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 5, 82, 1204, 8, 82, 10, 82, 12, 82, 1207, 9, 82, 1, 82, 1, 82, 3, 82, 1211, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 84, 1, 84, 3, 84, 1222, 8, 84, 1, 84, 3, 84, 1225, 8, 84, 1, 84, 3, 84, 1228, 8, 84, 1, 84, 3, 84, 1231, 8, 84, 1, 84, 3, 84, 1234, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1240, 8, 84, 1, 85, 1, 85, 3, 85, 1244, 8, 85, 1, 85, 1, 85, 1, 85, 1, 85, 5, 85, 1250, 8, 85, 10, 85, 12, 85, 1253, 9, 85, 3, 85, 1255, 8, 85, 1, 86, 1, 86, 1, 86, 3, 86, 1260, 8, 86, 1, 86, 3, 86, 1263, 8, 86, 1, 86, 1, 86, 3, 86, 1267, 8, 86, 1, 86, 3, 86, 1270, 8, 86, 3, 86, 1272, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1286, 8, 87, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 5, 89, 1295, 8, 89, 10, 89, 12, 89, 1298, 9, 89, 1, 89, 1, 89, 3, 89, 1302, 8, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1310, 8, 89, 1, 89, 3, 89, 1313, 8, 89, 1, 89, 3, 89, 1316, 8, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1321, 8, 89, 5, 89, 1323, 8, 89, 10, 89, 12, 89, 1326, 9, 89, 1, 90, 1, 90, 3, 90, 1330, 8, 90, 1, 91, 3, 91, 1333, 8, 91, 1, 91, 1, 91, 3, 91, 1337, 8, 91, 1, 91, 3, 91, 1340, 8, 91, 1, 91, 3, 91, 1343, 8, 91, 1, 91, 1, 91, 3, 91, 1347, 8, 91, 1, 91, 3, 91, 1350, 8, 91, 1, 91, 3, 91, 1353, 8, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 5, 91, 1363, 8, 91, 10, 91, 12, 91, 1366, 9, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1372, 8, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1383, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 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, 96, 5, 96, 1408, 8, 96, 10, 96, 12, 96, 1411, 9, 96, 1, 96, 1, 96, 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, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1432, 8, 98, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1445, 8, 101, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 1455, 8, 103, 10, 103, 12, 103, 1458, 9, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 5, 104, 1468, 8, 104, 10, 104, 12, 104, 1471, 9, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 5, 104, 1480, 8, 104, 10, 104, 12, 104, 1483, 9, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 5, 104, 1492, 8, 104, 10, 104, 12, 104, 1495, 9, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1500, 8, 104, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 1525, 8, 111, 10, 111, 12, 111, 1528, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 3, 113, 1535, 8, 113, 1, 113, 1, 113, 3, 113, 1539, 8, 113, 1, 113, 3, 113, 1542, 8, 113, 1, 113, 3, 113, 1545, 8, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 3, 114, 1552, 8, 114, 1, 114, 3, 114, 1555, 8, 114, 1, 114, 3, 114, 1558, 8, 114, 1, 114, 3, 114, 1561, 8, 114, 1, 114, 3, 114, 1564, 8, 114, 1, 114, 3, 114, 1567, 8, 114, 1, 114, 1, 114, 1, 114, 3, 114, 1572, 8, 114, 1, 114, 3, 114, 1575, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 5, 115, 1582, 8, 115, 10, 115, 12, 115, 1585, 9, 115, 1, 116, 1, 116, 3, 116, 1589, 8, 116, 1, 116, 1, 116, 3, 116, 1593, 8, 116, 1, 117, 1, 117, 1, 117, 3, 117, 1598, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 5, 118, 1605, 8, 118, 10, 118, 12, 118, 1608, 9, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 1626, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 5, 120, 1632, 8, 120, 10, 120, 12, 120, 1635, 9, 120, 1, 121, 1, 121, 1, 121, 4, 121, 1640, 8, 121, 11, 121, 12, 121, 1641, 1, 121, 1, 121, 3, 121, 1646, 8, 121, 1, 122, 1, 122, 3, 122, 1650, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 1660, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 1686, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 1692, 8, 125, 10, 125, 12, 125, 1695, 9, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 1706, 8, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1728, 8, 130, 3, 130, 1730, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1741, 8, 130, 1, 130, 5, 130, 1744, 8, 130, 10, 130, 12, 130, 1747, 9, 130, 1, 131, 3, 131, 1750, 8, 131, 1, 131, 1, 131, 3, 131, 1754, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1761, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 5, 131, 1768, 8, 131, 10, 131, 12, 131, 1771, 9, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1776, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1789, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1796, 8, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1801, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1807, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1814, 8, 131, 3, 131, 1816, 8, 131, 1, 132, 3, 132, 1819, 8, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 5, 132, 1829, 8, 132, 10, 132, 12, 132, 1832, 9, 132, 1, 132, 1, 132, 3, 132, 1836, 8, 132, 1, 132, 3, 132, 1839, 8, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 1845, 8, 132, 3, 132, 1847, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1853, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 5, 133, 1874, 8, 133, 10, 133, 12, 133, 1877, 9, 133, 1, 134, 1, 134, 1, 134, 4, 134, 1882, 8, 134, 11, 134, 12, 134, 1883, 1, 134, 1, 134, 3, 134, 1888, 8, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 4, 134, 1895, 8, 134, 11, 134, 12, 134, 1896, 1, 134, 1, 134, 3, 134, 1901, 8, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 1917, 8, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 1926, 8, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 1950, 8, 134, 1, 134, 1, 134, 1, 134, 5, 134, 1955, 8, 134, 10, 134, 12, 134, 1958, 9, 134, 3, 134, 1960, 8, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 1971, 8, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 5, 134, 1978, 8, 134, 10, 134, 12, 134, 1981, 9, 134, 1, 135, 1, 135, 1, 136, 1, 136, 3, 136, 1987, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 1993, 8, 137, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 3, 140, 2001, 8, 140, 1, 141, 1, 141, 1, 141, 3, 141, 2006, 8, 141, 1, 142, 1, 142, 3, 142, 2010, 8, 142, 1, 143, 1, 143, 1, 143, 4, 143, 2015, 8, 143, 11, 143, 12, 143, 2016, 1, 144, 1, 144, 1, 144, 3, 144, 2022, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 3, 146, 2030, 8, 146, 1, 146, 1, 146, 3, 146, 2034, 8, 146, 1, 147, 3, 147, 2037, 8, 147, 1, 147, 1, 147, 3, 147, 2041, 8, 147, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 4, 149, 2048, 8, 149, 11, 149, 12, 149, 2049, 1, 149, 3, 149, 2053, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 5, 151, 2062, 8, 151, 10, 151, 12, 151, 2065, 9, 151, 1, 152, 1, 152, 1, 152, 3, 152, 2070, 8, 152, 1, 153, 1, 153, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 3, 158, 2088, 8, 158, 1, 159, 1, 159, 1, 159, 3, 159, 2093, 8, 159, 1, 160, 1, 160, 1, 160, 3, 160, 2098, 8, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 2105, 8, 160, 3, 160, 2107, 8, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2112, 8, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 2119, 8, 161, 3, 161, 2121, 8, 161, 1, 162, 1, 162, 1, 162, 3, 162, 2126, 8, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2133, 8, 162, 3, 162, 2135, 8, 162, 1, 163, 1, 163, 1, 163, 3, 163, 2140, 8, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2147, 8, 163, 3, 163, 2149, 8, 163, 1, 164, 1, 164, 1, 164, 5, 164, 2154, 8, 164, 10, 164, 12, 164, 2157, 9, 164, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 5, 168, 2173, 8, 168, 10, 168, 12, 168, 2176, 9, 168, 1, 168, 1, 168, 1, 169, 1, 169, 3, 169, 2182, 8, 169, 1, 169, 3, 169, 2185, 8, 169, 1, 170, 1, 170, 1, 170, 3, 170, 2190, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2196, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2204, 8, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 2220, 8, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2229, 8, 174, 1, 175, 1, 175, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 2239, 8, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 2246, 8, 177, 1, 177, 3, 177, 2249, 8, 177, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 180, 1, 180, 1, 181, 1, 181, 1, 182, 1, 182, 1, 183, 1, 183, 1, 184, 1, 184, 1, 185, 1, 185, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 2155, 5, 158, 178, 260, 266, 268, 188, 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, 0, 45, 2, 0, 109, 109, 450, 450, 3, 0, 45, 45, 128, 128, 188, 188, 4, 0, 42, 42, 90, 90, 422, 422, 464, 464, 2, 0, 441, 441, 447, 447, 2, 0, 151, 151, 170, 170, 2, 0, 437, 437, 489, 489, 2, 0, 482, 485, 487, 487, 3, 0, 32, 32, 91, 91, 244, 244, 11, 0, 28, 29, 35, 35, 46, 46, 92, 92, 178, 179, 344, 344, 360, 360, 378, 378, 381, 381, 387, 387, 416, 417, 2, 0, 433, 433, 435, 435, 4, 0, 101, 102, 115, 115, 144, 144, 246, 246, 2, 0, 13, 13, 231, 231, 2, 0, 455, 455, 462, 462, 3, 0, 5, 5, 270, 270, 444, 444, 3, 0, 266, 266, 455, 455, 462, 462, 3, 0, 425, 425, 458, 458, 477, 477, 3, 0, 330, 330, 465, 465, 481, 481, 2, 0, 440, 440, 490, 490, 2, 0, 183, 183, 265, 265, 3, 0, 130, 130, 180, 180, 402, 402, 4, 0, 152, 152, 174, 174, 201, 201, 317, 317, 3, 0, 445, 445, 459, 459, 499, 499, 4, 0, 250, 250, 446, 446, 494, 496, 498, 498, 2, 0, 74, 74, 320, 320, 3, 0, 459, 459, 492, 492, 499, 499, 2, 0, 439, 439, 450, 450, 2, 0, 457, 457, 467, 467, 4, 0, 140, 140, 244, 244, 397, 397, 404, 404, 2, 0, 19, 19, 369, 369, 2, 0, 5, 5, 11, 11, 2, 0, 509, 509, 529, 530, 4, 0, 452, 452, 527, 527, 531, 531, 534, 534, 2, 0, 529, 530, 532, 532, 1, 0, 529, 530, 1, 0, 538, 539, 2, 0, 538, 538, 541, 541, 4, 0, 452, 452, 527, 527, 529, 531, 533, 534, 3, 0, 241, 241, 508, 509, 529, 530, 2, 0, 140, 140, 397, 397, 2, 0, 5, 5, 113, 113, 10, 0, 97, 97, 165, 165, 222, 222, 229, 229, 334, 334, 436, 436, 470, 470, 472, 472, 488, 488, 502, 502, 15, 0, 97, 97, 165, 165, 222, 222, 229, 229, 334, 334, 427, 427, 436, 436, 442, 442, 448, 449, 454, 454, 460, 460, 470, 475, 488, 488, 491, 491, 502, 503, 11, 0, 5, 5, 13, 13, 33, 33, 78, 78, 84, 85, 113, 113, 200, 200, 207, 208, 389, 389, 413, 413, 527, 527, 55, 0, 4, 4, 13, 13, 23, 23, 38, 38, 41, 41, 43, 44, 54, 54, 56, 56, 69, 69, 75, 75, 78, 78, 84, 85, 91, 91, 98, 99, 107, 107, 119, 119, 134, 134, 139, 139, 143, 143, 145, 145, 160, 160, 165, 165, 167, 167, 194, 194, 197, 197, 199, 199, 201, 201, 205, 205, 207, 209, 214, 214, 220, 220, 222, 223, 229, 229, 243, 243, 245, 245, 264, 264, 276, 276, 281, 281, 283, 283, 293, 293, 317, 317, 321, 323, 334, 334, 357, 358, 364, 364, 367, 367, 378, 380, 395, 395, 398, 399, 408, 408, 419, 420, 436, 436, 469, 469, 488, 488, 502, 502, 1, 0, 437, 504, 2475, 0, 379, 1, 0, 0, 0, 2, 389, 1, 0, 0, 0, 4, 403, 1, 0, 0, 0, 6, 405, 1, 0, 0, 0, 8, 421, 1, 0, 0, 0, 10, 425, 1, 0, 0, 0, 12, 427, 1, 0, 0, 0, 14, 430, 1, 0, 0, 0, 16, 441, 1, 0, 0, 0, 18, 449, 1, 0, 0, 0, 20, 457, 1, 0, 0, 0, 22, 459, 1, 0, 0, 0, 24, 511, 1, 0, 0, 0, 26, 513, 1, 0, 0, 0, 28, 520, 1, 0, 0, 0, 30, 524, 1, 0, 0, 0, 32, 528, 1, 0, 0, 0, 34, 532, 1, 0, 0, 0, 36, 586, 1, 0, 0, 0, 38, 592, 1, 0, 0, 0, 40, 598, 1, 0, 0, 0, 42, 600, 1, 0, 0, 0, 44, 641, 1, 0, 0, 0, 46, 655, 1, 0, 0, 0, 48, 657, 1, 0, 0, 0, 50, 667, 1, 0, 0, 0, 52, 671, 1, 0, 0, 0, 54, 673, 1, 0, 0, 0, 56, 721, 1, 0, 0, 0, 58, 723, 1, 0, 0, 0, 60, 727, 1, 0, 0, 0, 62, 735, 1, 0, 0, 0, 64, 743, 1, 0, 0, 0, 66, 747, 1, 0, 0, 0, 68, 754, 1, 0, 0, 0, 70, 782, 1, 0, 0, 0, 72, 784, 1, 0, 0, 0, 74, 787, 1, 0, 0, 0, 76, 797, 1, 0, 0, 0, 78, 799, 1, 0, 0, 0, 80, 805, 1, 0, 0, 0, 82, 807, 1, 0, 0, 0, 84, 815, 1, 0, 0, 0, 86, 823, 1, 0, 0, 0, 88, 825, 1, 0, 0, 0, 90, 829, 1, 0, 0, 0, 92, 833, 1, 0, 0, 0, 94, 856, 1, 0, 0, 0, 96, 860, 1, 0, 0, 0, 98, 862, 1, 0, 0, 0, 100, 878, 1, 0, 0, 0, 102, 880, 1, 0, 0, 0, 104, 885, 1, 0, 0, 0, 106, 896, 1, 0, 0, 0, 108, 914, 1, 0, 0, 0, 110, 934, 1, 0, 0, 0, 112, 945, 1, 0, 0, 0, 114, 947, 1, 0, 0, 0, 116, 960, 1, 0, 0, 0, 118, 967, 1, 0, 0, 0, 120, 970, 1, 0, 0, 0, 122, 979, 1, 0, 0, 0, 124, 983, 1, 0, 0, 0, 126, 987, 1, 0, 0, 0, 128, 990, 1, 0, 0, 0, 130, 998, 1, 0, 0, 0, 132, 1003, 1, 0, 0, 0, 134, 1020, 1, 0, 0, 0, 136, 1027, 1, 0, 0, 0, 138, 1037, 1, 0, 0, 0, 140, 1046, 1, 0, 0, 0, 142, 1056, 1, 0, 0, 0, 144, 1075, 1, 0, 0, 0, 146, 1077, 1, 0, 0, 0, 148, 1090, 1, 0, 0, 0, 150, 1093, 1, 0, 0, 0, 152, 1102, 1, 0, 0, 0, 154, 1113, 1, 0, 0, 0, 156, 1126, 1, 0, 0, 0, 158, 1161, 1, 0, 0, 0, 160, 1180, 1, 0, 0, 0, 162, 1189, 1, 0, 0, 0, 164, 1198, 1, 0, 0, 0, 166, 1217, 1, 0, 0, 0, 168, 1239, 1, 0, 0, 0, 170, 1241, 1, 0, 0, 0, 172, 1271, 1, 0, 0, 0, 174, 1285, 1, 0, 0, 0, 176, 1287, 1, 0, 0, 0, 178, 1301, 1, 0, 0, 0, 180, 1327, 1, 0, 0, 0, 182, 1382, 1, 0, 0, 0, 184, 1384, 1, 0, 0, 0, 186, 1390, 1, 0, 0, 0, 188, 1392, 1, 0, 0, 0, 190, 1397, 1, 0, 0, 0, 192, 1402, 1, 0, 0, 0, 194, 1414, 1, 0, 0, 0, 196, 1431, 1, 0, 0, 0, 198, 1433, 1, 0, 0, 0, 200, 1435, 1, 0, 0, 0, 202, 1444, 1, 0, 0, 0, 204, 1446, 1, 0, 0, 0, 206, 1449, 1, 0, 0, 0, 208, 1499, 1, 0, 0, 0, 210, 1501, 1, 0, 0, 0, 212, 1504, 1, 0, 0, 0, 214, 1506, 1, 0, 0, 0, 216, 1513, 1, 0, 0, 0, 218, 1515, 1, 0, 0, 0, 220, 1517, 1, 0, 0, 0, 222, 1520, 1, 0, 0, 0, 224, 1529, 1, 0, 0, 0, 226, 1534, 1, 0, 0, 0, 228, 1548, 1, 0, 0, 0, 230, 1576, 1, 0, 0, 0, 232, 1586, 1, 0, 0, 0, 234, 1594, 1, 0, 0, 0, 236, 1599, 1, 0, 0, 0, 238, 1625, 1, 0, 0, 0, 240, 1627, 1, 0, 0, 0, 242, 1636, 1, 0, 0, 0, 244, 1647, 1, 0, 0, 0, 246, 1659, 1, 0, 0, 0, 248, 1685, 1, 0, 0, 0, 250, 1687, 1, 0, 0, 0, 252, 1705, 1, 0, 0, 0, 254, 1707, 1, 0, 0, 0, 256, 1712, 1, 0, 0, 0, 258, 1715, 1, 0, 0, 0, 260, 1729, 1, 0, 0, 0, 262, 1815, 1, 0, 0, 0, 264, 1846, 1, 0, 0, 0, 266, 1852, 1, 0, 0, 0, 268, 1970, 1, 0, 0, 0, 270, 1982, 1, 0, 0, 0, 272, 1986, 1, 0, 0, 0, 274, 1992, 1, 0, 0, 0, 276, 1994, 1, 0, 0, 0, 278, 1996, 1, 0, 0, 0, 280, 2000, 1, 0, 0, 0, 282, 2002, 1, 0, 0, 0, 284, 2007, 1, 0, 0, 0, 286, 2014, 1, 0, 0, 0, 288, 2018, 1, 0, 0, 0, 290, 2023, 1, 0, 0, 0, 292, 2033, 1, 0, 0, 0, 294, 2036, 1, 0, 0, 0, 296, 2042, 1, 0, 0, 0, 298, 2052, 1, 0, 0, 0, 300, 2054, 1, 0, 0, 0, 302, 2058, 1, 0, 0, 0, 304, 2069, 1, 0, 0, 0, 306, 2071, 1, 0, 0, 0, 308, 2073, 1, 0, 0, 0, 310, 2075, 1, 0, 0, 0, 312, 2080, 1, 0, 0, 0, 314, 2082, 1, 0, 0, 0, 316, 2084, 1, 0, 0, 0, 318, 2089, 1, 0, 0, 0, 320, 2106, 1, 0, 0, 0, 322, 2120, 1, 0, 0, 0, 324, 2134, 1, 0, 0, 0, 326, 2148, 1, 0, 0, 0, 328, 2150, 1, 0, 0, 0, 330, 2158, 1, 0, 0, 0, 332, 2161, 1, 0, 0, 0, 334, 2165, 1, 0, 0, 0, 336, 2168, 1, 0, 0, 0, 338, 2179, 1, 0, 0, 0, 340, 2189, 1, 0, 0, 0, 342, 2195, 1, 0, 0, 0, 344, 2203, 1, 0, 0, 0, 346, 2219, 1, 0, 0, 0, 348, 2228, 1, 0, 0, 0, 350, 2230, 1, 0, 0, 0, 352, 2232, 1, 0, 0, 0, 354, 2248, 1, 0, 0, 0, 356, 2250, 1, 0, 0, 0, 358, 2253, 1, 0, 0, 0, 360, 2255, 1, 0, 0, 0, 362, 2257, 1, 0, 0, 0, 364, 2259, 1, 0, 0, 0, 366, 2261, 1, 0, 0, 0, 368, 2263, 1, 0, 0, 0, 370, 2265, 1, 0, 0, 0, 372, 2267, 1, 0, 0, 0, 374, 2269, 1, 0, 0, 0, 376, 378, 3, 2, 1, 0, 377, 376, 1, 0, 0, 0, 378, 381, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 379, 380, 1, 0, 0, 0, 380, 382, 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 382, 383, 5, 0, 0, 1, 383, 1, 1, 0, 0, 0, 384, 386, 3, 4, 2, 0, 385, 387, 5, 521, 0, 0, 386, 385, 1, 0, 0, 0, 386, 387, 1, 0, 0, 0, 387, 390, 1, 0, 0, 0, 388, 390, 3, 6, 3, 0, 389, 384, 1, 0, 0, 0, 389, 388, 1, 0, 0, 0, 390, 3, 1, 0, 0, 0, 391, 404, 3, 8, 4, 0, 392, 404, 3, 10, 5, 0, 393, 404, 3, 12, 6, 0, 394, 404, 3, 14, 7, 0, 395, 404, 3, 20, 10, 0, 396, 404, 3, 24, 12, 0, 397, 404, 3, 26, 13, 0, 398, 404, 3, 28, 14, 0, 399, 404, 3, 30, 15, 0, 400, 404, 3, 32, 16, 0, 401, 404, 3, 34, 17, 0, 402, 404, 3, 36, 18, 0, 403, 391, 1, 0, 0, 0, 403, 392, 1, 0, 0, 0, 403, 393, 1, 0, 0, 0, 403, 394, 1, 0, 0, 0, 403, 395, 1, 0, 0, 0, 403, 396, 1, 0, 0, 0, 403, 397, 1, 0, 0, 0, 403, 398, 1, 0, 0, 0, 403, 399, 1, 0, 0, 0, 403, 400, 1, 0, 0, 0, 403, 401, 1, 0, 0, 0, 403, 402, 1, 0, 0, 0, 404, 5, 1, 0, 0, 0, 405, 406, 5, 521, 0, 0, 406, 7, 1, 0, 0, 0, 407, 422, 3, 40, 20, 0, 408, 422, 3, 104, 52, 0, 409, 422, 3, 106, 53, 0, 410, 422, 3, 108, 54, 0, 411, 422, 3, 102, 51, 0, 412, 422, 3, 114, 57, 0, 413, 422, 3, 128, 64, 0, 414, 422, 3, 130, 65, 0, 415, 422, 3, 132, 66, 0, 416, 422, 3, 134, 67, 0, 417, 422, 3, 136, 68, 0, 418, 422, 3, 138, 69, 0, 419, 422, 3, 140, 70, 0, 420, 422, 3, 142, 71, 0, 421, 407, 1, 0, 0, 0, 421, 408, 1, 0, 0, 0, 421, 409, 1, 0, 0, 0, 421, 410, 1, 0, 0, 0, 421, 411, 1, 0, 0, 0, 421, 412, 1, 0, 0, 0, 421, 413, 1, 0, 0, 0, 421, 414, 1, 0, 0, 0, 421, 415, 1, 0, 0, 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, 9, 1, 0, 0, 0, 423, 426, 3, 158, 79, 0, 424, 426, 3, 144, 72, 0, 425, 423, 1, 0, 0, 0, 425, 424, 1, 0, 0, 0, 426, 11, 1, 0, 0, 0, 427, 428, 7, 0, 0, 0, 428, 429, 3, 322, 161, 0, 429, 13, 1, 0, 0, 0, 430, 434, 5, 135, 0, 0, 431, 435, 3, 16, 8, 0, 432, 433, 5, 479, 0, 0, 433, 435, 5, 146, 0, 0, 434, 431, 1, 0, 0, 0, 434, 432, 1, 0, 0, 0, 434, 435, 1, 0, 0, 0, 435, 439, 1, 0, 0, 0, 436, 440, 3, 10, 5, 0, 437, 440, 3, 146, 73, 0, 438, 440, 3, 156, 78, 0, 439, 436, 1, 0, 0, 0, 439, 437, 1, 0, 0, 0, 439, 438, 1, 0, 0, 0, 440, 15, 1, 0, 0, 0, 441, 446, 3, 18, 9, 0, 442, 443, 5, 520, 0, 0, 443, 445, 3, 18, 9, 0, 444, 442, 1, 0, 0, 0, 445, 448, 1, 0, 0, 0, 446, 444, 1, 0, 0, 0, 446, 447, 1, 0, 0, 0, 447, 17, 1, 0, 0, 0, 448, 446, 1, 0, 0, 0, 449, 450, 7, 1, 0, 0, 450, 19, 1, 0, 0, 0, 451, 452, 5, 410, 0, 0, 452, 453, 5, 441, 0, 0, 453, 458, 3, 312, 156, 0, 454, 455, 5, 410, 0, 0, 455, 458, 3, 316, 158, 0, 456, 458, 3, 22, 11, 0, 457, 451, 1, 0, 0, 0, 457, 454, 1, 0, 0, 0, 457, 456, 1, 0, 0, 0, 458, 21, 1, 0, 0, 0, 459, 460, 5, 410, 0, 0, 460, 461, 5, 227, 0, 0, 461, 466, 3, 328, 164, 0, 462, 463, 5, 520, 0, 0, 463, 465, 3, 328, 164, 0, 464, 462, 1, 0, 0, 0, 465, 468, 1, 0, 0, 0, 466, 464, 1, 0, 0, 0, 466, 467, 1, 0, 0, 0, 467, 23, 1, 0, 0, 0, 468, 466, 1, 0, 0, 0, 469, 470, 5, 341, 0, 0, 470, 512, 7, 2, 0, 0, 471, 472, 5, 341, 0, 0, 472, 473, 5, 76, 0, 0, 473, 512, 7, 3, 0, 0, 474, 475, 5, 341, 0, 0, 475, 478, 5, 374, 0, 0, 476, 477, 7, 4, 0, 0, 477, 479, 3, 316, 158, 0, 478, 476, 1, 0, 0, 0, 478, 479, 1, 0, 0, 0, 479, 481, 1, 0, 0, 0, 480, 482, 3, 264, 132, 0, 481, 480, 1, 0, 0, 0, 481, 482, 1, 0, 0, 0, 482, 512, 1, 0, 0, 0, 483, 484, 5, 341, 0, 0, 484, 485, 5, 58, 0, 0, 485, 488, 7, 4, 0, 0, 486, 489, 3, 324, 162, 0, 487, 489, 3, 322, 161, 0, 488, 486, 1, 0, 0, 0, 488, 487, 1, 0, 0, 0, 489, 491, 1, 0, 0, 0, 490, 492, 3, 264, 132, 0, 491, 490, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 512, 1, 0, 0, 0, 493, 494, 5, 341, 0, 0, 494, 499, 5, 72, 0, 0, 495, 496, 5, 373, 0, 0, 496, 500, 3, 322, 161, 0, 497, 498, 5, 501, 0, 0, 498, 500, 3, 324, 162, 0, 499, 495, 1, 0, 0, 0, 499, 497, 1, 0, 0, 0, 500, 512, 1, 0, 0, 0, 501, 503, 5, 341, 0, 0, 502, 504, 5, 411, 0, 0, 503, 502, 1, 0, 0, 0, 503, 504, 1, 0, 0, 0, 504, 505, 1, 0, 0, 0, 505, 512, 5, 154, 0, 0, 506, 508, 5, 341, 0, 0, 507, 509, 5, 152, 0, 0, 508, 507, 1, 0, 0, 0, 508, 509, 1, 0, 0, 0, 509, 510, 1, 0, 0, 0, 510, 512, 5, 227, 0, 0, 511, 469, 1, 0, 0, 0, 511, 471, 1, 0, 0, 0, 511, 474, 1, 0, 0, 0, 511, 483, 1, 0, 0, 0, 511, 493, 1, 0, 0, 0, 511, 501, 1, 0, 0, 0, 511, 506, 1, 0, 0, 0, 512, 25, 1, 0, 0, 0, 513, 514, 5, 468, 0, 0, 514, 515, 5, 226, 0, 0, 515, 518, 3, 328, 164, 0, 516, 517, 5, 433, 0, 0, 517, 519, 3, 336, 168, 0, 518, 516, 1, 0, 0, 0, 518, 519, 1, 0, 0, 0, 519, 27, 1, 0, 0, 0, 520, 521, 5, 500, 0, 0, 521, 522, 5, 226, 0, 0, 522, 523, 3, 328, 164, 0, 523, 29, 1, 0, 0, 0, 524, 526, 5, 340, 0, 0, 525, 527, 3, 338, 169, 0, 526, 525, 1, 0, 0, 0, 526, 527, 1, 0, 0, 0, 527, 31, 1, 0, 0, 0, 528, 530, 5, 312, 0, 0, 529, 531, 3, 340, 170, 0, 530, 529, 1, 0, 0, 0, 530, 531, 1, 0, 0, 0, 531, 33, 1, 0, 0, 0, 532, 533, 7, 5, 0, 0, 533, 534, 5, 463, 0, 0, 534, 535, 3, 112, 56, 0, 535, 35, 1, 0, 0, 0, 536, 537, 5, 437, 0, 0, 537, 538, 5, 463, 0, 0, 538, 539, 5, 433, 0, 0, 539, 542, 3, 38, 19, 0, 540, 541, 5, 17, 0, 0, 541, 543, 3, 328, 164, 0, 542, 540, 1, 0, 0, 0, 542, 543, 1, 0, 0, 0, 543, 587, 1, 0, 0, 0, 544, 545, 5, 437, 0, 0, 545, 546, 5, 456, 0, 0, 546, 547, 5, 433, 0, 0, 547, 550, 3, 38, 19, 0, 548, 549, 5, 17, 0, 0, 549, 551, 3, 328, 164, 0, 550, 548, 1, 0, 0, 0, 550, 551, 1, 0, 0, 0, 551, 554, 1, 0, 0, 0, 552, 553, 5, 311, 0, 0, 553, 555, 3, 328, 164, 0, 554, 552, 1, 0, 0, 0, 554, 555, 1, 0, 0, 0, 555, 587, 1, 0, 0, 0, 556, 557, 5, 437, 0, 0, 557, 558, 7, 6, 0, 0, 558, 559, 5, 433, 0, 0, 559, 560, 3, 38, 19, 0, 560, 561, 5, 311, 0, 0, 561, 562, 3, 328, 164, 0, 562, 587, 1, 0, 0, 0, 563, 564, 5, 437, 0, 0, 564, 565, 5, 486, 0, 0, 565, 587, 3, 38, 19, 0, 566, 567, 5, 437, 0, 0, 567, 568, 5, 453, 0, 0, 568, 569, 5, 456, 0, 0, 569, 570, 5, 433, 0, 0, 570, 571, 3, 38, 19, 0, 571, 572, 5, 311, 0, 0, 572, 573, 3, 328, 164, 0, 573, 574, 5, 466, 0, 0, 574, 575, 3, 328, 164, 0, 575, 587, 1, 0, 0, 0, 576, 577, 5, 437, 0, 0, 577, 578, 5, 443, 0, 0, 578, 579, 5, 456, 0, 0, 579, 580, 5, 433, 0, 0, 580, 581, 3, 38, 19, 0, 581, 582, 5, 146, 0, 0, 582, 583, 3, 328, 164, 0, 583, 584, 5, 17, 0, 0, 584, 585, 3, 328, 164, 0, 585, 587, 1, 0, 0, 0, 586, 536, 1, 0, 0, 0, 586, 544, 1, 0, 0, 0, 586, 556, 1, 0, 0, 0, 586, 563, 1, 0, 0, 0, 586, 566, 1, 0, 0, 0, 586, 576, 1, 0, 0, 0, 587, 37, 1, 0, 0, 0, 588, 590, 5, 534, 0, 0, 589, 588, 1, 0, 0, 0, 589, 590, 1, 0, 0, 0, 590, 591, 1, 0, 0, 0, 591, 593, 3, 328, 164, 0, 592, 589, 1, 0, 0, 0, 593, 594, 1, 0, 0, 0, 594, 592, 1, 0, 0, 0, 594, 595, 1, 0, 0, 0, 595, 39, 1, 0, 0, 0, 596, 599, 3, 42, 21, 0, 597, 599, 3, 44, 22, 0, 598, 596, 1, 0, 0, 0, 598, 597, 1, 0, 0, 0, 599, 41, 1, 0, 0, 0, 600, 602, 5, 72, 0, 0, 601, 603, 5, 497, 0, 0, 602, 601, 1, 0, 0, 0, 602, 603, 1, 0, 0, 0, 603, 604, 1, 0, 0, 0, 604, 606, 5, 373, 0, 0, 605, 607, 3, 332, 166, 0, 606, 605, 1, 0, 0, 0, 606, 607, 1, 0, 0, 0, 607, 608, 1, 0, 0, 0, 608, 609, 3, 320, 160, 0, 609, 610, 5, 516, 0, 0, 610, 615, 3, 46, 23, 0, 611, 612, 5, 520, 0, 0, 612, 614, 3, 46, 23, 0, 613, 611, 1, 0, 0, 0, 614, 617, 1, 0, 0, 0, 615, 613, 1, 0, 0, 0, 615, 616, 1, 0, 0, 0, 616, 620, 1, 0, 0, 0, 617, 615, 1, 0, 0, 0, 618, 619, 5, 520, 0, 0, 619, 621, 3, 82, 41, 0, 620, 618, 1, 0, 0, 0, 620, 621, 1, 0, 0, 0, 621, 624, 1, 0, 0, 0, 622, 623, 5, 520, 0, 0, 623, 625, 3, 84, 42, 0, 624, 622, 1, 0, 0, 0, 624, 625, 1, 0, 0, 0, 625, 628, 1, 0, 0, 0, 626, 627, 5, 520, 0, 0, 627, 629, 3, 88, 44, 0, 628, 626, 1, 0, 0, 0, 628, 629, 1, 0, 0, 0, 629, 630, 1, 0, 0, 0, 630, 632, 5, 517, 0, 0, 631, 633, 3, 72, 36, 0, 632, 631, 1, 0, 0, 0, 632, 633, 1, 0, 0, 0, 633, 635, 1, 0, 0, 0, 634, 636, 3, 90, 45, 0, 635, 634, 1, 0, 0, 0, 635, 636, 1, 0, 0, 0, 636, 637, 1, 0, 0, 0, 637, 639, 3, 330, 165, 0, 638, 640, 3, 98, 49, 0, 639, 638, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, 640, 43, 1, 0, 0, 0, 641, 642, 5, 72, 0, 0, 642, 644, 5, 373, 0, 0, 643, 645, 3, 332, 166, 0, 644, 643, 1, 0, 0, 0, 644, 645, 1, 0, 0, 0, 645, 646, 1, 0, 0, 0, 646, 647, 3, 320, 160, 0, 647, 650, 3, 330, 165, 0, 648, 649, 5, 17, 0, 0, 649, 651, 3, 158, 79, 0, 650, 648, 1, 0, 0, 0, 650, 651, 1, 0, 0, 0, 651, 45, 1, 0, 0, 0, 652, 656, 3, 48, 24, 0, 653, 656, 3, 74, 37, 0, 654, 656, 3, 78, 39, 0, 655, 652, 1, 0, 0, 0, 655, 653, 1, 0, 0, 0, 655, 654, 1, 0, 0, 0, 656, 47, 1, 0, 0, 0, 657, 658, 3, 50, 25, 0, 658, 660, 3, 56, 28, 0, 659, 661, 3, 70, 35, 0, 660, 659, 1, 0, 0, 0, 660, 661, 1, 0, 0, 0, 661, 663, 1, 0, 0, 0, 662, 664, 3, 72, 36, 0, 663, 662, 1, 0, 0, 0, 663, 664, 1, 0, 0, 0, 664, 49, 1, 0, 0, 0, 665, 668, 3, 328, 164, 0, 666, 668, 3, 258, 129, 0, 667, 665, 1, 0, 0, 0, 667, 666, 1, 0, 0, 0, 668, 51, 1, 0, 0, 0, 669, 672, 3, 328, 164, 0, 670, 672, 4, 26, 0, 0, 671, 669, 1, 0, 0, 0, 671, 670, 1, 0, 0, 0, 672, 53, 1, 0, 0, 0, 673, 674, 5, 516, 0, 0, 674, 679, 3, 52, 26, 0, 675, 676, 5, 520, 0, 0, 676, 678, 3, 52, 26, 0, 677, 675, 1, 0, 0, 0, 678, 681, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 679, 680, 1, 0, 0, 0, 680, 682, 1, 0, 0, 0, 681, 679, 1, 0, 0, 0, 682, 683, 5, 517, 0, 0, 683, 55, 1, 0, 0, 0, 684, 722, 7, 7, 0, 0, 685, 687, 7, 8, 0, 0, 686, 688, 3, 58, 29, 0, 687, 686, 1, 0, 0, 0, 687, 688, 1, 0, 0, 0, 688, 722, 1, 0, 0, 0, 689, 691, 5, 379, 0, 0, 690, 692, 3, 58, 29, 0, 691, 690, 1, 0, 0, 0, 691, 692, 1, 0, 0, 0, 692, 699, 1, 0, 0, 0, 693, 695, 7, 9, 0, 0, 694, 696, 5, 206, 0, 0, 695, 694, 1, 0, 0, 0, 695, 696, 1, 0, 0, 0, 696, 697, 1, 0, 0, 0, 697, 698, 5, 378, 0, 0, 698, 700, 5, 504, 0, 0, 699, 693, 1, 0, 0, 0, 699, 700, 1, 0, 0, 0, 700, 722, 1, 0, 0, 0, 701, 703, 7, 10, 0, 0, 702, 704, 3, 60, 30, 0, 703, 702, 1, 0, 0, 0, 703, 704, 1, 0, 0, 0, 704, 722, 1, 0, 0, 0, 705, 707, 7, 11, 0, 0, 706, 708, 3, 64, 32, 0, 707, 706, 1, 0, 0, 0, 707, 708, 1, 0, 0, 0, 708, 722, 1, 0, 0, 0, 709, 711, 5, 469, 0, 0, 710, 712, 3, 66, 33, 0, 711, 710, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 722, 1, 0, 0, 0, 713, 715, 5, 321, 0, 0, 714, 716, 3, 68, 34, 0, 715, 714, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 722, 1, 0, 0, 0, 717, 719, 5, 294, 0, 0, 718, 720, 3, 62, 31, 0, 719, 718, 1, 0, 0, 0, 719, 720, 1, 0, 0, 0, 720, 722, 1, 0, 0, 0, 721, 684, 1, 0, 0, 0, 721, 685, 1, 0, 0, 0, 721, 689, 1, 0, 0, 0, 721, 701, 1, 0, 0, 0, 721, 705, 1, 0, 0, 0, 721, 709, 1, 0, 0, 0, 721, 713, 1, 0, 0, 0, 721, 717, 1, 0, 0, 0, 722, 57, 1, 0, 0, 0, 723, 724, 5, 516, 0, 0, 724, 725, 3, 360, 180, 0, 725, 726, 5, 517, 0, 0, 726, 59, 1, 0, 0, 0, 727, 728, 5, 516, 0, 0, 728, 731, 3, 360, 180, 0, 729, 730, 5, 520, 0, 0, 730, 732, 3, 360, 180, 0, 731, 729, 1, 0, 0, 0, 731, 732, 1, 0, 0, 0, 732, 733, 1, 0, 0, 0, 733, 734, 5, 517, 0, 0, 734, 61, 1, 0, 0, 0, 735, 736, 5, 516, 0, 0, 736, 739, 3, 358, 179, 0, 737, 738, 5, 520, 0, 0, 738, 740, 3, 358, 179, 0, 739, 737, 1, 0, 0, 0, 739, 740, 1, 0, 0, 0, 740, 741, 1, 0, 0, 0, 741, 742, 5, 517, 0, 0, 742, 63, 1, 0, 0, 0, 743, 744, 5, 507, 0, 0, 744, 745, 3, 56, 28, 0, 745, 746, 5, 506, 0, 0, 746, 65, 1, 0, 0, 0, 747, 748, 5, 507, 0, 0, 748, 749, 3, 56, 28, 0, 749, 750, 5, 520, 0, 0, 750, 751, 3, 56, 28, 0, 751, 752, 1, 0, 0, 0, 752, 753, 5, 506, 0, 0, 753, 67, 1, 0, 0, 0, 754, 755, 5, 507, 0, 0, 755, 756, 3, 52, 26, 0, 756, 763, 3, 56, 28, 0, 757, 758, 5, 520, 0, 0, 758, 759, 3, 52, 26, 0, 759, 760, 3, 56, 28, 0, 760, 762, 1, 0, 0, 0, 761, 757, 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, 767, 5, 506, 0, 0, 767, 69, 1, 0, 0, 0, 768, 769, 5, 64, 0, 0, 769, 771, 3, 86, 43, 0, 770, 768, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, 771, 772, 1, 0, 0, 0, 772, 773, 5, 288, 0, 0, 773, 776, 5, 466, 0, 0, 774, 775, 5, 241, 0, 0, 775, 777, 5, 125, 0, 0, 776, 774, 1, 0, 0, 0, 776, 777, 1, 0, 0, 0, 777, 783, 1, 0, 0, 0, 778, 780, 5, 241, 0, 0, 779, 778, 1, 0, 0, 0, 779, 780, 1, 0, 0, 0, 780, 781, 1, 0, 0, 0, 781, 783, 5, 244, 0, 0, 782, 770, 1, 0, 0, 0, 782, 779, 1, 0, 0, 0, 783, 71, 1, 0, 0, 0, 784, 785, 5, 59, 0, 0, 785, 786, 5, 537, 0, 0, 786, 73, 1, 0, 0, 0, 787, 788, 3, 50, 25, 0, 788, 789, 3, 56, 28, 0, 789, 792, 5, 218, 0, 0, 790, 791, 5, 151, 0, 0, 791, 793, 3, 76, 38, 0, 792, 790, 1, 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 795, 1, 0, 0, 0, 794, 796, 5, 423, 0, 0, 795, 794, 1, 0, 0, 0, 795, 796, 1, 0, 0, 0, 796, 75, 1, 0, 0, 0, 797, 798, 5, 537, 0, 0, 798, 77, 1, 0, 0, 0, 799, 800, 3, 50, 25, 0, 800, 801, 5, 17, 0, 0, 801, 803, 3, 80, 40, 0, 802, 804, 3, 72, 36, 0, 803, 802, 1, 0, 0, 0, 803, 804, 1, 0, 0, 0, 804, 79, 1, 0, 0, 0, 805, 806, 3, 258, 129, 0, 806, 81, 1, 0, 0, 0, 807, 808, 5, 424, 0, 0, 808, 809, 5, 146, 0, 0, 809, 810, 3, 52, 26, 0, 810, 811, 5, 17, 0, 0, 811, 812, 3, 258, 129, 0, 812, 83, 1, 0, 0, 0, 813, 814, 5, 64, 0, 0, 814, 816, 3, 86, 43, 0, 815, 813, 1, 0, 0, 0, 815, 816, 1, 0, 0, 0, 816, 817, 1, 0, 0, 0, 817, 818, 5, 288, 0, 0, 818, 819, 5, 466, 0, 0, 819, 820, 3, 54, 27, 0, 820, 821, 5, 241, 0, 0, 821, 822, 5, 125, 0, 0, 822, 85, 1, 0, 0, 0, 823, 824, 3, 304, 152, 0, 824, 87, 1, 0, 0, 0, 825, 826, 5, 277, 0, 0, 826, 827, 5, 146, 0, 0, 827, 828, 5, 371, 0, 0, 828, 89, 1, 0, 0, 0, 829, 830, 5, 269, 0, 0, 830, 831, 5, 34, 0, 0, 831, 832, 3, 92, 46, 0, 832, 91, 1, 0, 0, 0, 833, 834, 5, 516, 0, 0, 834, 839, 3, 94, 47, 0, 835, 836, 5, 520, 0, 0, 836, 838, 3, 94, 47, 0, 837, 835, 1, 0, 0, 0, 838, 841, 1, 0, 0, 0, 839, 837, 1, 0, 0, 0, 839, 840, 1, 0, 0, 0, 840, 842, 1, 0, 0, 0, 841, 839, 1, 0, 0, 0, 842, 843, 5, 517, 0, 0, 843, 93, 1, 0, 0, 0, 844, 857, 3, 52, 26, 0, 845, 846, 5, 516, 0, 0, 846, 851, 3, 96, 48, 0, 847, 848, 5, 520, 0, 0, 848, 850, 3, 96, 48, 0, 849, 847, 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, 855, 5, 517, 0, 0, 855, 857, 1, 0, 0, 0, 856, 844, 1, 0, 0, 0, 856, 845, 1, 0, 0, 0, 857, 95, 1, 0, 0, 0, 858, 861, 3, 280, 140, 0, 859, 861, 3, 354, 177, 0, 860, 858, 1, 0, 0, 0, 860, 859, 1, 0, 0, 0, 861, 97, 1, 0, 0, 0, 862, 863, 5, 202, 0, 0, 863, 872, 3, 322, 161, 0, 864, 868, 5, 516, 0, 0, 865, 867, 3, 100, 50, 0, 866, 865, 1, 0, 0, 0, 867, 870, 1, 0, 0, 0, 868, 866, 1, 0, 0, 0, 868, 869, 1, 0, 0, 0, 869, 871, 1, 0, 0, 0, 870, 868, 1, 0, 0, 0, 871, 873, 5, 517, 0, 0, 872, 864, 1, 0, 0, 0, 872, 873, 1, 0, 0, 0, 873, 99, 1, 0, 0, 0, 874, 875, 7, 12, 0, 0, 875, 879, 7, 13, 0, 0, 876, 877, 7, 14, 0, 0, 877, 879, 7, 15, 0, 0, 878, 874, 1, 0, 0, 0, 878, 876, 1, 0, 0, 0, 879, 101, 1, 0, 0, 0, 880, 881, 5, 72, 0, 0, 881, 882, 5, 441, 0, 0, 882, 883, 3, 314, 157, 0, 883, 884, 3, 330, 165, 0, 884, 103, 1, 0, 0, 0, 885, 886, 5, 72, 0, 0, 886, 888, 5, 447, 0, 0, 887, 889, 3, 332, 166, 0, 888, 887, 1, 0, 0, 0, 888, 889, 1, 0, 0, 0, 889, 890, 1, 0, 0, 0, 890, 892, 3, 318, 159, 0, 891, 893, 3, 72, 36, 0, 892, 891, 1, 0, 0, 0, 892, 893, 1, 0, 0, 0, 893, 894, 1, 0, 0, 0, 894, 895, 3, 330, 165, 0, 895, 105, 1, 0, 0, 0, 896, 898, 5, 72, 0, 0, 897, 899, 5, 497, 0, 0, 898, 897, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 900, 1, 0, 0, 0, 900, 902, 5, 501, 0, 0, 901, 903, 3, 332, 166, 0, 902, 901, 1, 0, 0, 0, 902, 903, 1, 0, 0, 0, 903, 904, 1, 0, 0, 0, 904, 906, 3, 326, 163, 0, 905, 907, 3, 54, 27, 0, 906, 905, 1, 0, 0, 0, 906, 907, 1, 0, 0, 0, 907, 909, 1, 0, 0, 0, 908, 910, 3, 72, 36, 0, 909, 908, 1, 0, 0, 0, 909, 910, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 912, 5, 17, 0, 0, 912, 913, 3, 158, 79, 0, 913, 107, 1, 0, 0, 0, 914, 918, 5, 72, 0, 0, 915, 919, 5, 497, 0, 0, 916, 917, 5, 497, 0, 0, 917, 919, 5, 370, 0, 0, 918, 915, 1, 0, 0, 0, 918, 916, 1, 0, 0, 0, 918, 919, 1, 0, 0, 0, 919, 920, 1, 0, 0, 0, 920, 922, 5, 153, 0, 0, 921, 923, 3, 332, 166, 0, 922, 921, 1, 0, 0, 0, 922, 923, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 925, 3, 270, 135, 0, 925, 926, 5, 17, 0, 0, 926, 929, 3, 304, 152, 0, 927, 928, 5, 195, 0, 0, 928, 930, 7, 16, 0, 0, 929, 927, 1, 0, 0, 0, 929, 930, 1, 0, 0, 0, 930, 932, 1, 0, 0, 0, 931, 933, 3, 110, 55, 0, 932, 931, 1, 0, 0, 0, 932, 933, 1, 0, 0, 0, 933, 109, 1, 0, 0, 0, 934, 935, 5, 412, 0, 0, 935, 936, 5, 463, 0, 0, 936, 942, 3, 112, 56, 0, 937, 938, 5, 520, 0, 0, 938, 939, 5, 463, 0, 0, 939, 941, 3, 112, 56, 0, 940, 937, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 940, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 111, 1, 0, 0, 0, 944, 942, 1, 0, 0, 0, 945, 946, 5, 537, 0, 0, 946, 113, 1, 0, 0, 0, 947, 948, 5, 8, 0, 0, 948, 950, 5, 373, 0, 0, 949, 951, 3, 334, 167, 0, 950, 949, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 958, 3, 322, 161, 0, 953, 959, 3, 116, 58, 0, 954, 959, 3, 118, 59, 0, 955, 959, 3, 120, 60, 0, 956, 959, 3, 122, 61, 0, 957, 959, 3, 124, 62, 0, 958, 953, 1, 0, 0, 0, 958, 954, 1, 0, 0, 0, 958, 955, 1, 0, 0, 0, 958, 956, 1, 0, 0, 0, 958, 957, 1, 0, 0, 0, 959, 115, 1, 0, 0, 0, 960, 962, 5, 311, 0, 0, 961, 963, 3, 328, 164, 0, 962, 961, 1, 0, 0, 0, 962, 963, 1, 0, 0, 0, 963, 964, 1, 0, 0, 0, 964, 965, 5, 388, 0, 0, 965, 966, 3, 328, 164, 0, 966, 117, 1, 0, 0, 0, 967, 968, 5, 340, 0, 0, 968, 969, 3, 336, 168, 0, 969, 119, 1, 0, 0, 0, 970, 971, 5, 437, 0, 0, 971, 972, 5, 64, 0, 0, 972, 973, 3, 86, 43, 0, 973, 974, 5, 288, 0, 0, 974, 975, 5, 466, 0, 0, 975, 977, 3, 54, 27, 0, 976, 978, 3, 126, 63, 0, 977, 976, 1, 0, 0, 0, 977, 978, 1, 0, 0, 0, 978, 121, 1, 0, 0, 0, 979, 980, 5, 116, 0, 0, 980, 981, 5, 64, 0, 0, 981, 982, 3, 86, 43, 0, 982, 123, 1, 0, 0, 0, 983, 984, 5, 437, 0, 0, 984, 985, 5, 403, 0, 0, 985, 986, 3, 54, 27, 0, 986, 125, 1, 0, 0, 0, 987, 988, 5, 241, 0, 0, 988, 989, 5, 125, 0, 0, 989, 127, 1, 0, 0, 0, 990, 991, 5, 8, 0, 0, 991, 992, 5, 501, 0, 0, 992, 996, 3, 324, 162, 0, 993, 997, 3, 116, 58, 0, 994, 995, 5, 17, 0, 0, 995, 997, 3, 158, 79, 0, 996, 993, 1, 0, 0, 0, 996, 994, 1, 0, 0, 0, 997, 129, 1, 0, 0, 0, 998, 999, 5, 8, 0, 0, 999, 1000, 5, 447, 0, 0, 1000, 1001, 3, 316, 158, 0, 1001, 1002, 3, 118, 59, 0, 1002, 131, 1, 0, 0, 0, 1003, 1007, 5, 8, 0, 0, 1004, 1008, 5, 497, 0, 0, 1005, 1006, 5, 497, 0, 0, 1006, 1008, 5, 370, 0, 0, 1007, 1004, 1, 0, 0, 0, 1007, 1005, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1011, 5, 153, 0, 0, 1010, 1012, 3, 334, 167, 0, 1011, 1010, 1, 0, 0, 0, 1011, 1012, 1, 0, 0, 0, 1012, 1013, 1, 0, 0, 0, 1013, 1014, 3, 272, 136, 0, 1014, 1015, 5, 17, 0, 0, 1015, 1018, 3, 304, 152, 0, 1016, 1017, 5, 195, 0, 0, 1017, 1019, 7, 16, 0, 0, 1018, 1016, 1, 0, 0, 0, 1018, 1019, 1, 0, 0, 0, 1019, 133, 1, 0, 0, 0, 1020, 1021, 5, 116, 0, 0, 1021, 1023, 5, 441, 0, 0, 1022, 1024, 3, 334, 167, 0, 1023, 1022, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1026, 3, 312, 156, 0, 1026, 135, 1, 0, 0, 0, 1027, 1029, 5, 116, 0, 0, 1028, 1030, 5, 497, 0, 0, 1029, 1028, 1, 0, 0, 0, 1029, 1030, 1, 0, 0, 0, 1030, 1031, 1, 0, 0, 0, 1031, 1033, 5, 373, 0, 0, 1032, 1034, 3, 334, 167, 0, 1033, 1032, 1, 0, 0, 0, 1033, 1034, 1, 0, 0, 0, 1034, 1035, 1, 0, 0, 0, 1035, 1036, 3, 322, 161, 0, 1036, 137, 1, 0, 0, 0, 1037, 1038, 5, 116, 0, 0, 1038, 1040, 5, 447, 0, 0, 1039, 1041, 3, 334, 167, 0, 1040, 1039, 1, 0, 0, 0, 1040, 1041, 1, 0, 0, 0, 1041, 1042, 1, 0, 0, 0, 1042, 1044, 3, 316, 158, 0, 1043, 1045, 7, 17, 0, 0, 1044, 1043, 1, 0, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 139, 1, 0, 0, 0, 1046, 1048, 5, 116, 0, 0, 1047, 1049, 5, 497, 0, 0, 1048, 1047, 1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1050, 1, 0, 0, 0, 1050, 1052, 5, 501, 0, 0, 1051, 1053, 3, 334, 167, 0, 1052, 1051, 1, 0, 0, 0, 1052, 1053, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1054, 1055, 3, 324, 162, 0, 1055, 141, 1, 0, 0, 0, 1056, 1060, 5, 116, 0, 0, 1057, 1061, 5, 497, 0, 0, 1058, 1059, 5, 497, 0, 0, 1059, 1061, 5, 370, 0, 0, 1060, 1057, 1, 0, 0, 0, 1060, 1058, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 1062, 1, 0, 0, 0, 1062, 1064, 5, 153, 0, 0, 1063, 1065, 3, 334, 167, 0, 1064, 1063, 1, 0, 0, 0, 1064, 1065, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1067, 3, 272, 136, 0, 1067, 143, 1, 0, 0, 0, 1068, 1070, 5, 132, 0, 0, 1069, 1068, 1, 0, 0, 0, 1069, 1070, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1076, 3, 146, 73, 0, 1072, 1076, 3, 154, 77, 0, 1073, 1074, 5, 132, 0, 0, 1074, 1076, 3, 156, 78, 0, 1075, 1069, 1, 0, 0, 0, 1075, 1072, 1, 0, 0, 0, 1075, 1073, 1, 0, 0, 0, 1076, 145, 1, 0, 0, 0, 1077, 1078, 5, 177, 0, 0, 1078, 1079, 7, 18, 0, 0, 1079, 1088, 3, 322, 161, 0, 1080, 1082, 3, 148, 74, 0, 1081, 1080, 1, 0, 0, 0, 1081, 1082, 1, 0, 0, 0, 1082, 1084, 1, 0, 0, 0, 1083, 1085, 3, 54, 27, 0, 1084, 1083, 1, 0, 0, 0, 1084, 1085, 1, 0, 0, 0, 1085, 1086, 1, 0, 0, 0, 1086, 1089, 3, 158, 79, 0, 1087, 1089, 3, 150, 75, 0, 1088, 1081, 1, 0, 0, 0, 1088, 1087, 1, 0, 0, 0, 1089, 147, 1, 0, 0, 0, 1090, 1091, 5, 268, 0, 0, 1091, 1092, 3, 336, 168, 0, 1092, 149, 1, 0, 0, 0, 1093, 1094, 5, 414, 0, 0, 1094, 1099, 3, 152, 76, 0, 1095, 1096, 5, 520, 0, 0, 1096, 1098, 3, 152, 76, 0, 1097, 1095, 1, 0, 0, 0, 1098, 1101, 1, 0, 0, 0, 1099, 1097, 1, 0, 0, 0, 1099, 1100, 1, 0, 0, 0, 1100, 151, 1, 0, 0, 0, 1101, 1099, 1, 0, 0, 0, 1102, 1103, 5, 516, 0, 0, 1103, 1108, 3, 354, 177, 0, 1104, 1105, 5, 520, 0, 0, 1105, 1107, 3, 354, 177, 0, 1106, 1104, 1, 0, 0, 0, 1107, 1110, 1, 0, 0, 0, 1108, 1106, 1, 0, 0, 0, 1108, 1109, 1, 0, 0, 0, 1109, 1111, 1, 0, 0, 0, 1110, 1108, 1, 0, 0, 0, 1111, 1112, 5, 517, 0, 0, 1112, 153, 1, 0, 0, 0, 1113, 1114, 5, 24, 0, 0, 1114, 1115, 5, 354, 0, 0, 1115, 1116, 5, 340, 0, 0, 1116, 1120, 5, 521, 0, 0, 1117, 1118, 3, 146, 73, 0, 1118, 1119, 5, 521, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1117, 1, 0, 0, 0, 1121, 1122, 1, 0, 0, 0, 1122, 1120, 1, 0, 0, 0, 1122, 1123, 1, 0, 0, 0, 1123, 1124, 1, 0, 0, 0, 1124, 1125, 5, 122, 0, 0, 1125, 155, 1, 0, 0, 0, 1126, 1127, 5, 354, 0, 0, 1127, 1128, 5, 340, 0, 0, 1128, 1132, 5, 24, 0, 0, 1129, 1130, 3, 146, 73, 0, 1130, 1131, 5, 521, 0, 0, 1131, 1133, 1, 0, 0, 0, 1132, 1129, 1, 0, 0, 0, 1133, 1134, 1, 0, 0, 0, 1134, 1132, 1, 0, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1137, 5, 122, 0, 0, 1137, 157, 1, 0, 0, 0, 1138, 1139, 6, 79, -1, 0, 1139, 1162, 3, 160, 80, 0, 1140, 1141, 3, 162, 81, 0, 1141, 1142, 3, 158, 79, 5, 1142, 1162, 1, 0, 0, 0, 1143, 1144, 5, 516, 0, 0, 1144, 1145, 3, 158, 79, 0, 1145, 1146, 5, 517, 0, 0, 1146, 1162, 1, 0, 0, 0, 1147, 1149, 3, 170, 85, 0, 1148, 1150, 3, 230, 115, 0, 1149, 1148, 1, 0, 0, 0, 1149, 1150, 1, 0, 0, 0, 1150, 1152, 1, 0, 0, 0, 1151, 1153, 3, 234, 117, 0, 1152, 1151, 1, 0, 0, 0, 1152, 1153, 1, 0, 0, 0, 1153, 1162, 1, 0, 0, 0, 1154, 1156, 3, 168, 84, 0, 1155, 1157, 3, 230, 115, 0, 1156, 1155, 1, 0, 0, 0, 1156, 1157, 1, 0, 0, 0, 1157, 1159, 1, 0, 0, 0, 1158, 1160, 3, 234, 117, 0, 1159, 1158, 1, 0, 0, 0, 1159, 1160, 1, 0, 0, 0, 1160, 1162, 1, 0, 0, 0, 1161, 1138, 1, 0, 0, 0, 1161, 1140, 1, 0, 0, 0, 1161, 1143, 1, 0, 0, 0, 1161, 1147, 1, 0, 0, 0, 1161, 1154, 1, 0, 0, 0, 1162, 1177, 1, 0, 0, 0, 1163, 1164, 10, 3, 0, 0, 1164, 1166, 7, 19, 0, 0, 1165, 1167, 5, 5, 0, 0, 1166, 1165, 1, 0, 0, 0, 1166, 1167, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1170, 3, 158, 79, 0, 1169, 1171, 3, 230, 115, 0, 1170, 1169, 1, 0, 0, 0, 1170, 1171, 1, 0, 0, 0, 1171, 1173, 1, 0, 0, 0, 1172, 1174, 3, 234, 117, 0, 1173, 1172, 1, 0, 0, 0, 1173, 1174, 1, 0, 0, 0, 1174, 1176, 1, 0, 0, 0, 1175, 1163, 1, 0, 0, 0, 1176, 1179, 1, 0, 0, 0, 1177, 1175, 1, 0, 0, 0, 1177, 1178, 1, 0, 0, 0, 1178, 159, 1, 0, 0, 0, 1179, 1177, 1, 0, 0, 0, 1180, 1181, 5, 414, 0, 0, 1181, 1186, 3, 258, 129, 0, 1182, 1183, 5, 520, 0, 0, 1183, 1185, 3, 258, 129, 0, 1184, 1182, 1, 0, 0, 0, 1185, 1188, 1, 0, 0, 0, 1186, 1184, 1, 0, 0, 0, 1186, 1187, 1, 0, 0, 0, 1187, 161, 1, 0, 0, 0, 1188, 1186, 1, 0, 0, 0, 1189, 1190, 5, 433, 0, 0, 1190, 1195, 3, 164, 82, 0, 1191, 1192, 5, 520, 0, 0, 1192, 1194, 3, 164, 82, 0, 1193, 1191, 1, 0, 0, 0, 1194, 1197, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 163, 1, 0, 0, 0, 1197, 1195, 1, 0, 0, 0, 1198, 1210, 3, 166, 83, 0, 1199, 1200, 5, 516, 0, 0, 1200, 1205, 3, 52, 26, 0, 1201, 1202, 5, 520, 0, 0, 1202, 1204, 3, 52, 26, 0, 1203, 1201, 1, 0, 0, 0, 1204, 1207, 1, 0, 0, 0, 1205, 1203, 1, 0, 0, 0, 1205, 1206, 1, 0, 0, 0, 1206, 1208, 1, 0, 0, 0, 1207, 1205, 1, 0, 0, 0, 1208, 1209, 5, 517, 0, 0, 1209, 1211, 1, 0, 0, 0, 1210, 1199, 1, 0, 0, 0, 1210, 1211, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1213, 5, 17, 0, 0, 1213, 1214, 5, 516, 0, 0, 1214, 1215, 3, 158, 79, 0, 1215, 1216, 5, 517, 0, 0, 1216, 165, 1, 0, 0, 0, 1217, 1218, 3, 304, 152, 0, 1218, 167, 1, 0, 0, 0, 1219, 1221, 3, 170, 85, 0, 1220, 1222, 3, 176, 88, 0, 1221, 1220, 1, 0, 0, 0, 1221, 1222, 1, 0, 0, 0, 1222, 1224, 1, 0, 0, 0, 1223, 1225, 3, 204, 102, 0, 1224, 1223, 1, 0, 0, 0, 1224, 1225, 1, 0, 0, 0, 1225, 1227, 1, 0, 0, 0, 1226, 1228, 3, 206, 103, 0, 1227, 1226, 1, 0, 0, 0, 1227, 1228, 1, 0, 0, 0, 1228, 1230, 1, 0, 0, 0, 1229, 1231, 3, 220, 110, 0, 1230, 1229, 1, 0, 0, 0, 1230, 1231, 1, 0, 0, 0, 1231, 1233, 1, 0, 0, 0, 1232, 1234, 3, 222, 111, 0, 1233, 1232, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1240, 1, 0, 0, 0, 1235, 1236, 3, 170, 85, 0, 1236, 1237, 3, 176, 88, 0, 1237, 1238, 3, 228, 114, 0, 1238, 1240, 1, 0, 0, 0, 1239, 1219, 1, 0, 0, 0, 1239, 1235, 1, 0, 0, 0, 1240, 169, 1, 0, 0, 0, 1241, 1243, 5, 336, 0, 0, 1242, 1244, 3, 364, 182, 0, 1243, 1242, 1, 0, 0, 0, 1243, 1244, 1, 0, 0, 0, 1244, 1254, 1, 0, 0, 0, 1245, 1255, 5, 527, 0, 0, 1246, 1251, 3, 172, 86, 0, 1247, 1248, 5, 520, 0, 0, 1248, 1250, 3, 172, 86, 0, 1249, 1247, 1, 0, 0, 0, 1250, 1253, 1, 0, 0, 0, 1251, 1249, 1, 0, 0, 0, 1251, 1252, 1, 0, 0, 0, 1252, 1255, 1, 0, 0, 0, 1253, 1251, 1, 0, 0, 0, 1254, 1245, 1, 0, 0, 0, 1254, 1246, 1, 0, 0, 0, 1255, 171, 1, 0, 0, 0, 1256, 1272, 3, 174, 87, 0, 1257, 1262, 3, 52, 26, 0, 1258, 1260, 5, 17, 0, 0, 1259, 1258, 1, 0, 0, 0, 1259, 1260, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 1263, 3, 258, 129, 0, 1262, 1259, 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 1272, 1, 0, 0, 0, 1264, 1269, 3, 258, 129, 0, 1265, 1267, 5, 17, 0, 0, 1266, 1265, 1, 0, 0, 0, 1266, 1267, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1270, 3, 52, 26, 0, 1269, 1266, 1, 0, 0, 0, 1269, 1270, 1, 0, 0, 0, 1270, 1272, 1, 0, 0, 0, 1271, 1256, 1, 0, 0, 0, 1271, 1257, 1, 0, 0, 0, 1271, 1264, 1, 0, 0, 0, 1272, 173, 1, 0, 0, 0, 1273, 1274, 3, 268, 134, 0, 1274, 1275, 5, 262, 0, 0, 1275, 1276, 3, 226, 113, 0, 1276, 1277, 5, 17, 0, 0, 1277, 1278, 3, 304, 152, 0, 1278, 1286, 1, 0, 0, 0, 1279, 1280, 3, 268, 134, 0, 1280, 1281, 5, 262, 0, 0, 1281, 1282, 3, 296, 148, 0, 1282, 1283, 5, 17, 0, 0, 1283, 1284, 3, 304, 152, 0, 1284, 1286, 1, 0, 0, 0, 1285, 1273, 1, 0, 0, 0, 1285, 1279, 1, 0, 0, 0, 1286, 175, 1, 0, 0, 0, 1287, 1288, 5, 151, 0, 0, 1288, 1289, 3, 178, 89, 0, 1289, 177, 1, 0, 0, 0, 1290, 1291, 6, 89, -1, 0, 1291, 1296, 3, 180, 90, 0, 1292, 1293, 5, 520, 0, 0, 1293, 1295, 3, 180, 90, 0, 1294, 1292, 1, 0, 0, 0, 1295, 1298, 1, 0, 0, 0, 1296, 1294, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 1302, 1, 0, 0, 0, 1298, 1296, 1, 0, 0, 0, 1299, 1302, 3, 188, 94, 0, 1300, 1302, 3, 190, 95, 0, 1301, 1290, 1, 0, 0, 0, 1301, 1299, 1, 0, 0, 0, 1301, 1300, 1, 0, 0, 0, 1302, 1324, 1, 0, 0, 0, 1303, 1304, 10, 3, 0, 0, 1304, 1305, 5, 73, 0, 0, 1305, 1306, 5, 185, 0, 0, 1306, 1323, 3, 178, 89, 4, 1307, 1309, 10, 4, 0, 0, 1308, 1310, 5, 233, 0, 0, 1309, 1308, 1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 1312, 1, 0, 0, 0, 1311, 1313, 7, 20, 0, 0, 1312, 1311, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1315, 1, 0, 0, 0, 1314, 1316, 5, 261, 0, 0, 1315, 1314, 1, 0, 0, 0, 1315, 1316, 1, 0, 0, 0, 1316, 1317, 1, 0, 0, 0, 1317, 1318, 5, 185, 0, 0, 1318, 1320, 3, 178, 89, 0, 1319, 1321, 3, 202, 101, 0, 1320, 1319, 1, 0, 0, 0, 1320, 1321, 1, 0, 0, 0, 1321, 1323, 1, 0, 0, 0, 1322, 1303, 1, 0, 0, 0, 1322, 1307, 1, 0, 0, 0, 1323, 1326, 1, 0, 0, 0, 1324, 1322, 1, 0, 0, 0, 1324, 1325, 1, 0, 0, 0, 1325, 179, 1, 0, 0, 0, 1326, 1324, 1, 0, 0, 0, 1327, 1329, 3, 182, 91, 0, 1328, 1330, 3, 294, 147, 0, 1329, 1328, 1, 0, 0, 0, 1329, 1330, 1, 0, 0, 0, 1330, 181, 1, 0, 0, 0, 1331, 1333, 5, 373, 0, 0, 1332, 1331, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 1336, 3, 322, 161, 0, 1335, 1337, 3, 184, 92, 0, 1336, 1335, 1, 0, 0, 0, 1336, 1337, 1, 0, 0, 0, 1337, 1342, 1, 0, 0, 0, 1338, 1340, 5, 17, 0, 0, 1339, 1338, 1, 0, 0, 0, 1339, 1340, 1, 0, 0, 0, 1340, 1341, 1, 0, 0, 0, 1341, 1343, 3, 278, 139, 0, 1342, 1339, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 1383, 1, 0, 0, 0, 1344, 1346, 3, 324, 162, 0, 1345, 1347, 3, 184, 92, 0, 1346, 1345, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1352, 1, 0, 0, 0, 1348, 1350, 5, 17, 0, 0, 1349, 1348, 1, 0, 0, 0, 1349, 1350, 1, 0, 0, 0, 1350, 1351, 1, 0, 0, 0, 1351, 1353, 3, 278, 139, 0, 1352, 1349, 1, 0, 0, 0, 1352, 1353, 1, 0, 0, 0, 1353, 1383, 1, 0, 0, 0, 1354, 1355, 5, 198, 0, 0, 1355, 1356, 5, 373, 0, 0, 1356, 1357, 5, 516, 0, 0, 1357, 1358, 3, 272, 136, 0, 1358, 1359, 5, 516, 0, 0, 1359, 1364, 3, 274, 137, 0, 1360, 1361, 5, 520, 0, 0, 1361, 1363, 3, 274, 137, 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, 1367, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1367, 1368, 5, 517, 0, 0, 1368, 1369, 5, 517, 0, 0, 1369, 1383, 1, 0, 0, 0, 1370, 1372, 5, 198, 0, 0, 1371, 1370, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1373, 1, 0, 0, 0, 1373, 1374, 5, 516, 0, 0, 1374, 1375, 3, 158, 79, 0, 1375, 1376, 5, 517, 0, 0, 1376, 1383, 1, 0, 0, 0, 1377, 1378, 5, 405, 0, 0, 1378, 1379, 5, 516, 0, 0, 1379, 1380, 3, 258, 129, 0, 1380, 1381, 5, 517, 0, 0, 1381, 1383, 1, 0, 0, 0, 1382, 1332, 1, 0, 0, 0, 1382, 1344, 1, 0, 0, 0, 1382, 1354, 1, 0, 0, 0, 1382, 1371, 1, 0, 0, 0, 1382, 1377, 1, 0, 0, 0, 1383, 183, 1, 0, 0, 0, 1384, 1385, 5, 146, 0, 0, 1385, 1386, 5, 371, 0, 0, 1386, 1387, 5, 17, 0, 0, 1387, 1388, 5, 249, 0, 0, 1388, 1389, 3, 186, 93, 0, 1389, 185, 1, 0, 0, 0, 1390, 1391, 3, 258, 129, 0, 1391, 187, 1, 0, 0, 0, 1392, 1393, 5, 516, 0, 0, 1393, 1394, 3, 150, 75, 0, 1394, 1395, 5, 517, 0, 0, 1395, 1396, 3, 294, 147, 0, 1396, 189, 1, 0, 0, 0, 1397, 1398, 5, 373, 0, 0, 1398, 1399, 5, 516, 0, 0, 1399, 1400, 3, 192, 96, 0, 1400, 1401, 5, 517, 0, 0, 1401, 191, 1, 0, 0, 0, 1402, 1403, 3, 194, 97, 0, 1403, 1404, 5, 516, 0, 0, 1404, 1409, 3, 196, 98, 0, 1405, 1406, 5, 520, 0, 0, 1406, 1408, 3, 196, 98, 0, 1407, 1405, 1, 0, 0, 0, 1408, 1411, 1, 0, 0, 0, 1409, 1407, 1, 0, 0, 0, 1409, 1410, 1, 0, 0, 0, 1410, 1412, 1, 0, 0, 0, 1411, 1409, 1, 0, 0, 0, 1412, 1413, 5, 517, 0, 0, 1413, 193, 1, 0, 0, 0, 1414, 1415, 7, 21, 0, 0, 1415, 195, 1, 0, 0, 0, 1416, 1417, 5, 373, 0, 0, 1417, 1432, 3, 218, 109, 0, 1418, 1432, 3, 200, 100, 0, 1419, 1432, 3, 282, 141, 0, 1420, 1421, 5, 446, 0, 0, 1421, 1422, 5, 536, 0, 0, 1422, 1423, 5, 373, 0, 0, 1423, 1432, 3, 218, 109, 0, 1424, 1425, 5, 498, 0, 0, 1425, 1426, 5, 536, 0, 0, 1426, 1432, 3, 200, 100, 0, 1427, 1428, 3, 198, 99, 0, 1428, 1429, 5, 536, 0, 0, 1429, 1430, 3, 282, 141, 0, 1430, 1432, 1, 0, 0, 0, 1431, 1416, 1, 0, 0, 0, 1431, 1418, 1, 0, 0, 0, 1431, 1419, 1, 0, 0, 0, 1431, 1420, 1, 0, 0, 0, 1431, 1424, 1, 0, 0, 0, 1431, 1427, 1, 0, 0, 0, 1432, 197, 1, 0, 0, 0, 1433, 1434, 7, 22, 0, 0, 1434, 199, 1, 0, 0, 0, 1435, 1436, 5, 451, 0, 0, 1436, 1437, 5, 516, 0, 0, 1437, 1438, 3, 52, 26, 0, 1438, 1439, 5, 517, 0, 0, 1439, 201, 1, 0, 0, 0, 1440, 1441, 5, 253, 0, 0, 1441, 1445, 3, 260, 130, 0, 1442, 1443, 5, 412, 0, 0, 1443, 1445, 3, 54, 27, 0, 1444, 1440, 1, 0, 0, 0, 1444, 1442, 1, 0, 0, 0, 1445, 203, 1, 0, 0, 0, 1446, 1447, 5, 430, 0, 0, 1447, 1448, 3, 260, 130, 0, 1448, 205, 1, 0, 0, 0, 1449, 1450, 5, 159, 0, 0, 1450, 1451, 5, 34, 0, 0, 1451, 1456, 3, 208, 104, 0, 1452, 1453, 5, 520, 0, 0, 1453, 1455, 3, 208, 104, 0, 1454, 1452, 1, 0, 0, 0, 1455, 1458, 1, 0, 0, 0, 1456, 1454, 1, 0, 0, 0, 1456, 1457, 1, 0, 0, 0, 1457, 207, 1, 0, 0, 0, 1458, 1456, 1, 0, 0, 0, 1459, 1500, 3, 52, 26, 0, 1460, 1500, 3, 214, 107, 0, 1461, 1462, 5, 516, 0, 0, 1462, 1500, 5, 517, 0, 0, 1463, 1464, 5, 516, 0, 0, 1464, 1469, 3, 258, 129, 0, 1465, 1466, 5, 520, 0, 0, 1466, 1468, 3, 258, 129, 0, 1467, 1465, 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, 1473, 5, 517, 0, 0, 1473, 1500, 1, 0, 0, 0, 1474, 1475, 3, 212, 106, 0, 1475, 1476, 5, 516, 0, 0, 1476, 1481, 3, 258, 129, 0, 1477, 1478, 5, 520, 0, 0, 1478, 1480, 3, 258, 129, 0, 1479, 1477, 1, 0, 0, 0, 1480, 1483, 1, 0, 0, 0, 1481, 1479, 1, 0, 0, 0, 1481, 1482, 1, 0, 0, 0, 1482, 1484, 1, 0, 0, 0, 1483, 1481, 1, 0, 0, 0, 1484, 1485, 5, 517, 0, 0, 1485, 1500, 1, 0, 0, 0, 1486, 1487, 3, 210, 105, 0, 1487, 1488, 5, 516, 0, 0, 1488, 1493, 3, 208, 104, 0, 1489, 1490, 5, 520, 0, 0, 1490, 1492, 3, 208, 104, 0, 1491, 1489, 1, 0, 0, 0, 1492, 1495, 1, 0, 0, 0, 1493, 1491, 1, 0, 0, 0, 1493, 1494, 1, 0, 0, 0, 1494, 1496, 1, 0, 0, 0, 1495, 1493, 1, 0, 0, 0, 1496, 1497, 5, 517, 0, 0, 1497, 1500, 1, 0, 0, 0, 1498, 1500, 3, 258, 129, 0, 1499, 1459, 1, 0, 0, 0, 1499, 1460, 1, 0, 0, 0, 1499, 1461, 1, 0, 0, 0, 1499, 1463, 1, 0, 0, 0, 1499, 1474, 1, 0, 0, 0, 1499, 1486, 1, 0, 0, 0, 1499, 1498, 1, 0, 0, 0, 1500, 209, 1, 0, 0, 0, 1501, 1502, 5, 160, 0, 0, 1502, 1503, 5, 493, 0, 0, 1503, 211, 1, 0, 0, 0, 1504, 1505, 7, 23, 0, 0, 1505, 213, 1, 0, 0, 0, 1506, 1507, 3, 216, 108, 0, 1507, 1508, 5, 516, 0, 0, 1508, 1509, 3, 218, 109, 0, 1509, 1510, 5, 520, 0, 0, 1510, 1511, 3, 282, 141, 0, 1511, 1512, 5, 517, 0, 0, 1512, 215, 1, 0, 0, 0, 1513, 1514, 7, 24, 0, 0, 1514, 217, 1, 0, 0, 0, 1515, 1516, 3, 328, 164, 0, 1516, 219, 1, 0, 0, 0, 1517, 1518, 5, 163, 0, 0, 1518, 1519, 3, 260, 130, 0, 1519, 221, 1, 0, 0, 0, 1520, 1521, 5, 432, 0, 0, 1521, 1526, 3, 224, 112, 0, 1522, 1523, 5, 520, 0, 0, 1523, 1525, 3, 224, 112, 0, 1524, 1522, 1, 0, 0, 0, 1525, 1528, 1, 0, 0, 0, 1526, 1524, 1, 0, 0, 0, 1526, 1527, 1, 0, 0, 0, 1527, 223, 1, 0, 0, 0, 1528, 1526, 1, 0, 0, 0, 1529, 1530, 3, 296, 148, 0, 1530, 1531, 5, 17, 0, 0, 1531, 1532, 3, 226, 113, 0, 1532, 225, 1, 0, 0, 0, 1533, 1535, 3, 296, 148, 0, 1534, 1533, 1, 0, 0, 0, 1534, 1535, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, 1538, 5, 516, 0, 0, 1537, 1539, 3, 236, 118, 0, 1538, 1537, 1, 0, 0, 0, 1538, 1539, 1, 0, 0, 0, 1539, 1541, 1, 0, 0, 0, 1540, 1542, 3, 230, 115, 0, 1541, 1540, 1, 0, 0, 0, 1541, 1542, 1, 0, 0, 0, 1542, 1544, 1, 0, 0, 0, 1543, 1545, 3, 252, 126, 0, 1544, 1543, 1, 0, 0, 0, 1544, 1545, 1, 0, 0, 0, 1545, 1546, 1, 0, 0, 0, 1546, 1547, 5, 517, 0, 0, 1547, 227, 1, 0, 0, 0, 1548, 1549, 5, 213, 0, 0, 1549, 1551, 5, 516, 0, 0, 1550, 1552, 3, 236, 118, 0, 1551, 1550, 1, 0, 0, 0, 1551, 1552, 1, 0, 0, 0, 1552, 1554, 1, 0, 0, 0, 1553, 1555, 3, 230, 115, 0, 1554, 1553, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1557, 1, 0, 0, 0, 1556, 1558, 3, 240, 120, 0, 1557, 1556, 1, 0, 0, 0, 1557, 1558, 1, 0, 0, 0, 1558, 1560, 1, 0, 0, 0, 1559, 1561, 3, 246, 123, 0, 1560, 1559, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 1563, 1, 0, 0, 0, 1562, 1564, 3, 248, 124, 0, 1563, 1562, 1, 0, 0, 0, 1563, 1564, 1, 0, 0, 0, 1564, 1566, 1, 0, 0, 0, 1565, 1567, 3, 242, 121, 0, 1566, 1565, 1, 0, 0, 0, 1566, 1567, 1, 0, 0, 0, 1567, 1568, 1, 0, 0, 0, 1568, 1569, 3, 250, 125, 0, 1569, 1574, 5, 517, 0, 0, 1570, 1572, 5, 17, 0, 0, 1571, 1570, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 1573, 1, 0, 0, 0, 1573, 1575, 3, 304, 152, 0, 1574, 1571, 1, 0, 0, 0, 1574, 1575, 1, 0, 0, 0, 1575, 229, 1, 0, 0, 0, 1576, 1577, 5, 258, 0, 0, 1577, 1578, 5, 34, 0, 0, 1578, 1583, 3, 232, 116, 0, 1579, 1580, 5, 520, 0, 0, 1580, 1582, 3, 232, 116, 0, 1581, 1579, 1, 0, 0, 0, 1582, 1585, 1, 0, 0, 0, 1583, 1581, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 231, 1, 0, 0, 0, 1585, 1583, 1, 0, 0, 0, 1586, 1588, 3, 52, 26, 0, 1587, 1589, 7, 25, 0, 0, 1588, 1587, 1, 0, 0, 0, 1588, 1589, 1, 0, 0, 0, 1589, 1592, 1, 0, 0, 0, 1590, 1591, 5, 476, 0, 0, 1591, 1593, 7, 26, 0, 0, 1592, 1590, 1, 0, 0, 0, 1592, 1593, 1, 0, 0, 0, 1593, 233, 1, 0, 0, 0, 1594, 1597, 5, 204, 0, 0, 1595, 1598, 5, 5, 0, 0, 1596, 1598, 3, 258, 129, 0, 1597, 1595, 1, 0, 0, 0, 1597, 1596, 1, 0, 0, 0, 1598, 235, 1, 0, 0, 0, 1599, 1600, 5, 268, 0, 0, 1600, 1601, 5, 34, 0, 0, 1601, 1606, 3, 52, 26, 0, 1602, 1603, 5, 520, 0, 0, 1603, 1605, 3, 52, 26, 0, 1604, 1602, 1, 0, 0, 0, 1605, 1608, 1, 0, 0, 0, 1606, 1604, 1, 0, 0, 0, 1606, 1607, 1, 0, 0, 0, 1607, 237, 1, 0, 0, 0, 1608, 1606, 1, 0, 0, 0, 1609, 1626, 5, 527, 0, 0, 1610, 1626, 5, 530, 0, 0, 1611, 1626, 5, 535, 0, 0, 1612, 1613, 5, 518, 0, 0, 1613, 1614, 5, 538, 0, 0, 1614, 1615, 5, 520, 0, 0, 1615, 1616, 5, 538, 0, 0, 1616, 1626, 5, 519, 0, 0, 1617, 1618, 5, 518, 0, 0, 1618, 1619, 5, 538, 0, 0, 1619, 1620, 5, 520, 0, 0, 1620, 1626, 5, 519, 0, 0, 1621, 1622, 5, 518, 0, 0, 1622, 1623, 5, 520, 0, 0, 1623, 1624, 5, 538, 0, 0, 1624, 1626, 5, 519, 0, 0, 1625, 1609, 1, 0, 0, 0, 1625, 1610, 1, 0, 0, 0, 1625, 1611, 1, 0, 0, 0, 1625, 1612, 1, 0, 0, 0, 1625, 1617, 1, 0, 0, 0, 1625, 1621, 1, 0, 0, 0, 1626, 239, 1, 0, 0, 0, 1627, 1628, 5, 215, 0, 0, 1628, 1633, 3, 172, 86, 0, 1629, 1630, 5, 520, 0, 0, 1630, 1632, 3, 172, 86, 0, 1631, 1629, 1, 0, 0, 0, 1632, 1635, 1, 0, 0, 0, 1633, 1631, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 241, 1, 0, 0, 0, 1635, 1633, 1, 0, 0, 0, 1636, 1637, 5, 271, 0, 0, 1637, 1639, 5, 516, 0, 0, 1638, 1640, 3, 244, 122, 0, 1639, 1638, 1, 0, 0, 0, 1640, 1641, 1, 0, 0, 0, 1641, 1639, 1, 0, 0, 0, 1641, 1642, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, 0, 1643, 1645, 5, 517, 0, 0, 1644, 1646, 3, 256, 128, 0, 1645, 1644, 1, 0, 0, 0, 1645, 1646, 1, 0, 0, 0, 1646, 243, 1, 0, 0, 0, 1647, 1649, 3, 306, 153, 0, 1648, 1650, 3, 238, 119, 0, 1649, 1648, 1, 0, 0, 0, 1649, 1650, 1, 0, 0, 0, 1650, 245, 1, 0, 0, 0, 1651, 1652, 5, 5, 0, 0, 1652, 1653, 5, 322, 0, 0, 1653, 1654, 5, 272, 0, 0, 1654, 1660, 5, 210, 0, 0, 1655, 1656, 5, 254, 0, 0, 1656, 1657, 5, 321, 0, 0, 1657, 1658, 5, 272, 0, 0, 1658, 1660, 5, 210, 0, 0, 1659, 1651, 1, 0, 0, 0, 1659, 1655, 1, 0, 0, 0, 1660, 247, 1, 0, 0, 0, 1661, 1662, 5, 438, 0, 0, 1662, 1663, 5, 210, 0, 0, 1663, 1664, 5, 343, 0, 0, 1664, 1665, 5, 478, 0, 0, 1665, 1666, 5, 467, 0, 0, 1666, 1686, 5, 321, 0, 0, 1667, 1668, 5, 438, 0, 0, 1668, 1669, 5, 210, 0, 0, 1669, 1670, 5, 343, 0, 0, 1670, 1671, 5, 388, 0, 0, 1671, 1672, 5, 237, 0, 0, 1672, 1686, 5, 321, 0, 0, 1673, 1674, 5, 438, 0, 0, 1674, 1675, 5, 210, 0, 0, 1675, 1676, 5, 343, 0, 0, 1676, 1677, 5, 388, 0, 0, 1677, 1678, 5, 467, 0, 0, 1678, 1686, 3, 306, 153, 0, 1679, 1680, 5, 438, 0, 0, 1680, 1681, 5, 210, 0, 0, 1681, 1682, 5, 343, 0, 0, 1682, 1683, 5, 388, 0, 0, 1683, 1684, 5, 457, 0, 0, 1684, 1686, 3, 306, 153, 0, 1685, 1661, 1, 0, 0, 0, 1685, 1667, 1, 0, 0, 0, 1685, 1673, 1, 0, 0, 0, 1685, 1679, 1, 0, 0, 0, 1686, 249, 1, 0, 0, 0, 1687, 1688, 5, 105, 0, 0, 1688, 1693, 3, 172, 86, 0, 1689, 1690, 5, 520, 0, 0, 1690, 1692, 3, 172, 86, 0, 1691, 1689, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 1691, 1, 0, 0, 0, 1693, 1694, 1, 0, 0, 0, 1694, 251, 1, 0, 0, 0, 1695, 1693, 1, 0, 0, 0, 1696, 1697, 5, 292, 0, 0, 1697, 1698, 5, 27, 0, 0, 1698, 1699, 3, 282, 141, 0, 1699, 1700, 3, 254, 127, 0, 1700, 1706, 1, 0, 0, 0, 1701, 1702, 5, 322, 0, 0, 1702, 1703, 5, 27, 0, 0, 1703, 1704, 5, 538, 0, 0, 1704, 1706, 3, 254, 127, 0, 1705, 1696, 1, 0, 0, 0, 1705, 1701, 1, 0, 0, 0, 1706, 253, 1, 0, 0, 0, 1707, 1708, 5, 480, 0, 0, 1708, 1709, 5, 10, 0, 0, 1709, 1710, 5, 76, 0, 0, 1710, 1711, 5, 321, 0, 0, 1711, 255, 1, 0, 0, 0, 1712, 1713, 5, 434, 0, 0, 1713, 1714, 3, 282, 141, 0, 1714, 257, 1, 0, 0, 0, 1715, 1716, 3, 260, 130, 0, 1716, 259, 1, 0, 0, 0, 1717, 1718, 6, 130, -1, 0, 1718, 1719, 5, 241, 0, 0, 1719, 1730, 3, 260, 130, 6, 1720, 1721, 5, 133, 0, 0, 1721, 1722, 5, 516, 0, 0, 1722, 1723, 3, 158, 79, 0, 1723, 1724, 5, 517, 0, 0, 1724, 1730, 1, 0, 0, 0, 1725, 1727, 3, 266, 133, 0, 1726, 1728, 3, 262, 131, 0, 1727, 1726, 1, 0, 0, 0, 1727, 1728, 1, 0, 0, 0, 1728, 1730, 1, 0, 0, 0, 1729, 1717, 1, 0, 0, 0, 1729, 1720, 1, 0, 0, 0, 1729, 1725, 1, 0, 0, 0, 1730, 1745, 1, 0, 0, 0, 1731, 1732, 10, 3, 0, 0, 1732, 1733, 5, 10, 0, 0, 1733, 1744, 3, 260, 130, 4, 1734, 1735, 10, 2, 0, 0, 1735, 1736, 5, 257, 0, 0, 1736, 1744, 3, 260, 130, 3, 1737, 1738, 10, 1, 0, 0, 1738, 1740, 5, 184, 0, 0, 1739, 1741, 5, 241, 0, 0, 1740, 1739, 1, 0, 0, 0, 1740, 1741, 1, 0, 0, 0, 1741, 1742, 1, 0, 0, 0, 1742, 1744, 7, 27, 0, 0, 1743, 1731, 1, 0, 0, 0, 1743, 1734, 1, 0, 0, 0, 1743, 1737, 1, 0, 0, 0, 1744, 1747, 1, 0, 0, 0, 1745, 1743, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 261, 1, 0, 0, 0, 1747, 1745, 1, 0, 0, 0, 1748, 1750, 5, 241, 0, 0, 1749, 1748, 1, 0, 0, 0, 1749, 1750, 1, 0, 0, 0, 1750, 1751, 1, 0, 0, 0, 1751, 1753, 5, 27, 0, 0, 1752, 1754, 7, 28, 0, 0, 1753, 1752, 1, 0, 0, 0, 1753, 1754, 1, 0, 0, 0, 1754, 1755, 1, 0, 0, 0, 1755, 1756, 3, 266, 133, 0, 1756, 1757, 5, 10, 0, 0, 1757, 1758, 3, 266, 133, 0, 1758, 1816, 1, 0, 0, 0, 1759, 1761, 5, 241, 0, 0, 1760, 1759, 1, 0, 0, 0, 1760, 1761, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762, 1763, 5, 170, 0, 0, 1763, 1764, 5, 516, 0, 0, 1764, 1769, 3, 258, 129, 0, 1765, 1766, 5, 520, 0, 0, 1766, 1768, 3, 258, 129, 0, 1767, 1765, 1, 0, 0, 0, 1768, 1771, 1, 0, 0, 0, 1769, 1767, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 1772, 1, 0, 0, 0, 1771, 1769, 1, 0, 0, 0, 1772, 1773, 5, 517, 0, 0, 1773, 1816, 1, 0, 0, 0, 1774, 1776, 5, 241, 0, 0, 1775, 1774, 1, 0, 0, 0, 1775, 1776, 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1778, 5, 170, 0, 0, 1778, 1779, 5, 516, 0, 0, 1779, 1780, 3, 158, 79, 0, 1780, 1781, 5, 517, 0, 0, 1781, 1816, 1, 0, 0, 0, 1782, 1783, 5, 133, 0, 0, 1783, 1784, 5, 516, 0, 0, 1784, 1785, 3, 158, 79, 0, 1785, 1786, 5, 517, 0, 0, 1786, 1816, 1, 0, 0, 0, 1787, 1789, 5, 241, 0, 0, 1788, 1787, 1, 0, 0, 0, 1788, 1789, 1, 0, 0, 0, 1789, 1790, 1, 0, 0, 0, 1790, 1791, 5, 318, 0, 0, 1791, 1816, 3, 266, 133, 0, 1792, 1816, 3, 264, 132, 0, 1793, 1795, 5, 184, 0, 0, 1794, 1796, 5, 241, 0, 0, 1795, 1794, 1, 0, 0, 0, 1795, 1796, 1, 0, 0, 0, 1796, 1797, 1, 0, 0, 0, 1797, 1816, 7, 27, 0, 0, 1798, 1800, 5, 184, 0, 0, 1799, 1801, 5, 241, 0, 0, 1800, 1799, 1, 0, 0, 0, 1800, 1801, 1, 0, 0, 0, 1801, 1802, 1, 0, 0, 0, 1802, 1803, 5, 113, 0, 0, 1803, 1804, 5, 151, 0, 0, 1804, 1816, 3, 266, 133, 0, 1805, 1807, 5, 241, 0, 0, 1806, 1805, 1, 0, 0, 0, 1806, 1807, 1, 0, 0, 0, 1807, 1808, 1, 0, 0, 0, 1808, 1809, 5, 342, 0, 0, 1809, 1810, 5, 388, 0, 0, 1810, 1813, 3, 266, 133, 0, 1811, 1812, 5, 127, 0, 0, 1812, 1814, 3, 358, 179, 0, 1813, 1811, 1, 0, 0, 0, 1813, 1814, 1, 0, 0, 0, 1814, 1816, 1, 0, 0, 0, 1815, 1749, 1, 0, 0, 0, 1815, 1760, 1, 0, 0, 0, 1815, 1775, 1, 0, 0, 0, 1815, 1782, 1, 0, 0, 0, 1815, 1788, 1, 0, 0, 0, 1815, 1792, 1, 0, 0, 0, 1815, 1793, 1, 0, 0, 0, 1815, 1798, 1, 0, 0, 0, 1815, 1806, 1, 0, 0, 0, 1816, 263, 1, 0, 0, 0, 1817, 1819, 5, 241, 0, 0, 1818, 1817, 1, 0, 0, 0, 1818, 1819, 1, 0, 0, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1821, 5, 202, 0, 0, 1821, 1835, 7, 29, 0, 0, 1822, 1823, 5, 516, 0, 0, 1823, 1836, 5, 517, 0, 0, 1824, 1825, 5, 516, 0, 0, 1825, 1830, 3, 258, 129, 0, 1826, 1827, 5, 520, 0, 0, 1827, 1829, 3, 258, 129, 0, 1828, 1826, 1, 0, 0, 0, 1829, 1832, 1, 0, 0, 0, 1830, 1828, 1, 0, 0, 0, 1830, 1831, 1, 0, 0, 0, 1831, 1833, 1, 0, 0, 0, 1832, 1830, 1, 0, 0, 0, 1833, 1834, 5, 517, 0, 0, 1834, 1836, 1, 0, 0, 0, 1835, 1822, 1, 0, 0, 0, 1835, 1824, 1, 0, 0, 0, 1836, 1847, 1, 0, 0, 0, 1837, 1839, 5, 241, 0, 0, 1838, 1837, 1, 0, 0, 0, 1838, 1839, 1, 0, 0, 0, 1839, 1840, 1, 0, 0, 0, 1840, 1841, 5, 202, 0, 0, 1841, 1844, 3, 266, 133, 0, 1842, 1843, 5, 127, 0, 0, 1843, 1845, 3, 358, 179, 0, 1844, 1842, 1, 0, 0, 0, 1844, 1845, 1, 0, 0, 0, 1845, 1847, 1, 0, 0, 0, 1846, 1818, 1, 0, 0, 0, 1846, 1838, 1, 0, 0, 0, 1847, 265, 1, 0, 0, 0, 1848, 1849, 6, 133, -1, 0, 1849, 1853, 3, 268, 134, 0, 1850, 1851, 7, 30, 0, 0, 1851, 1853, 3, 266, 133, 7, 1852, 1848, 1, 0, 0, 0, 1852, 1850, 1, 0, 0, 0, 1853, 1875, 1, 0, 0, 0, 1854, 1855, 10, 6, 0, 0, 1855, 1856, 7, 31, 0, 0, 1856, 1874, 3, 266, 133, 7, 1857, 1858, 10, 5, 0, 0, 1858, 1859, 7, 32, 0, 0, 1859, 1874, 3, 266, 133, 6, 1860, 1861, 10, 4, 0, 0, 1861, 1862, 5, 511, 0, 0, 1862, 1874, 3, 266, 133, 5, 1863, 1864, 10, 3, 0, 0, 1864, 1865, 5, 512, 0, 0, 1865, 1874, 3, 266, 133, 4, 1866, 1867, 10, 2, 0, 0, 1867, 1868, 5, 510, 0, 0, 1868, 1874, 3, 266, 133, 3, 1869, 1870, 10, 1, 0, 0, 1870, 1871, 3, 346, 173, 0, 1871, 1872, 3, 266, 133, 2, 1872, 1874, 1, 0, 0, 0, 1873, 1854, 1, 0, 0, 0, 1873, 1857, 1, 0, 0, 0, 1873, 1860, 1, 0, 0, 0, 1873, 1863, 1, 0, 0, 0, 1873, 1866, 1, 0, 0, 0, 1873, 1869, 1, 0, 0, 0, 1874, 1877, 1, 0, 0, 0, 1875, 1873, 1, 0, 0, 0, 1875, 1876, 1, 0, 0, 0, 1876, 267, 1, 0, 0, 0, 1877, 1875, 1, 0, 0, 0, 1878, 1879, 6, 134, -1, 0, 1879, 1881, 5, 40, 0, 0, 1880, 1882, 3, 310, 155, 0, 1881, 1880, 1, 0, 0, 0, 1882, 1883, 1, 0, 0, 0, 1883, 1881, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 1887, 1, 0, 0, 0, 1885, 1886, 5, 120, 0, 0, 1886, 1888, 3, 258, 129, 0, 1887, 1885, 1, 0, 0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1889, 1, 0, 0, 0, 1889, 1890, 5, 122, 0, 0, 1890, 1971, 1, 0, 0, 0, 1891, 1892, 5, 40, 0, 0, 1892, 1894, 3, 258, 129, 0, 1893, 1895, 3, 310, 155, 0, 1894, 1893, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 1894, 1, 0, 0, 0, 1896, 1897, 1, 0, 0, 0, 1897, 1900, 1, 0, 0, 0, 1898, 1899, 5, 120, 0, 0, 1899, 1901, 3, 258, 129, 0, 1900, 1898, 1, 0, 0, 0, 1900, 1901, 1, 0, 0, 0, 1901, 1902, 1, 0, 0, 0, 1902, 1903, 5, 122, 0, 0, 1903, 1971, 1, 0, 0, 0, 1904, 1905, 5, 41, 0, 0, 1905, 1906, 5, 516, 0, 0, 1906, 1907, 3, 258, 129, 0, 1907, 1908, 5, 17, 0, 0, 1908, 1909, 3, 56, 28, 0, 1909, 1910, 5, 517, 0, 0, 1910, 1971, 1, 0, 0, 0, 1911, 1912, 5, 457, 0, 0, 1912, 1913, 5, 516, 0, 0, 1913, 1916, 3, 258, 129, 0, 1914, 1915, 5, 461, 0, 0, 1915, 1917, 5, 476, 0, 0, 1916, 1914, 1, 0, 0, 0, 1916, 1917, 1, 0, 0, 0, 1917, 1918, 1, 0, 0, 0, 1918, 1919, 5, 517, 0, 0, 1919, 1971, 1, 0, 0, 0, 1920, 1921, 5, 467, 0, 0, 1921, 1922, 5, 516, 0, 0, 1922, 1925, 3, 258, 129, 0, 1923, 1924, 5, 461, 0, 0, 1924, 1926, 5, 476, 0, 0, 1925, 1923, 1, 0, 0, 0, 1925, 1926, 1, 0, 0, 0, 1926, 1927, 1, 0, 0, 0, 1927, 1928, 5, 517, 0, 0, 1928, 1971, 1, 0, 0, 0, 1929, 1930, 5, 281, 0, 0, 1930, 1931, 5, 516, 0, 0, 1931, 1932, 3, 266, 133, 0, 1932, 1933, 5, 170, 0, 0, 1933, 1934, 3, 266, 133, 0, 1934, 1935, 5, 517, 0, 0, 1935, 1971, 1, 0, 0, 0, 1936, 1971, 3, 354, 177, 0, 1937, 1971, 5, 527, 0, 0, 1938, 1939, 3, 328, 164, 0, 1939, 1940, 5, 513, 0, 0, 1940, 1941, 5, 527, 0, 0, 1941, 1971, 1, 0, 0, 0, 1942, 1943, 5, 516, 0, 0, 1943, 1944, 3, 158, 79, 0, 1944, 1945, 5, 517, 0, 0, 1945, 1971, 1, 0, 0, 0, 1946, 1947, 3, 272, 136, 0, 1947, 1959, 5, 516, 0, 0, 1948, 1950, 3, 364, 182, 0, 1949, 1948, 1, 0, 0, 0, 1949, 1950, 1, 0, 0, 0, 1950, 1951, 1, 0, 0, 0, 1951, 1956, 3, 274, 137, 0, 1952, 1953, 5, 520, 0, 0, 1953, 1955, 3, 274, 137, 0, 1954, 1952, 1, 0, 0, 0, 1955, 1958, 1, 0, 0, 0, 1956, 1954, 1, 0, 0, 0, 1956, 1957, 1, 0, 0, 0, 1957, 1960, 1, 0, 0, 0, 1958, 1956, 1, 0, 0, 0, 1959, 1949, 1, 0, 0, 0, 1959, 1960, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1962, 5, 517, 0, 0, 1962, 1971, 1, 0, 0, 0, 1963, 1971, 3, 304, 152, 0, 1964, 1971, 3, 276, 138, 0, 1965, 1966, 5, 516, 0, 0, 1966, 1967, 3, 258, 129, 0, 1967, 1968, 5, 517, 0, 0, 1968, 1971, 1, 0, 0, 0, 1969, 1971, 5, 85, 0, 0, 1970, 1878, 1, 0, 0, 0, 1970, 1891, 1, 0, 0, 0, 1970, 1904, 1, 0, 0, 0, 1970, 1911, 1, 0, 0, 0, 1970, 1920, 1, 0, 0, 0, 1970, 1929, 1, 0, 0, 0, 1970, 1936, 1, 0, 0, 0, 1970, 1937, 1, 0, 0, 0, 1970, 1938, 1, 0, 0, 0, 1970, 1942, 1, 0, 0, 0, 1970, 1946, 1, 0, 0, 0, 1970, 1963, 1, 0, 0, 0, 1970, 1964, 1, 0, 0, 0, 1970, 1965, 1, 0, 0, 0, 1970, 1969, 1, 0, 0, 0, 1971, 1979, 1, 0, 0, 0, 1972, 1973, 10, 5, 0, 0, 1973, 1974, 5, 514, 0, 0, 1974, 1975, 3, 266, 133, 0, 1975, 1976, 5, 515, 0, 0, 1976, 1978, 1, 0, 0, 0, 1977, 1972, 1, 0, 0, 0, 1978, 1981, 1, 0, 0, 0, 1979, 1977, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 269, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1982, 1983, 3, 328, 164, 0, 1983, 271, 1, 0, 0, 0, 1984, 1987, 3, 372, 186, 0, 1985, 1987, 3, 328, 164, 0, 1986, 1984, 1, 0, 0, 0, 1986, 1985, 1, 0, 0, 0, 1987, 273, 1, 0, 0, 0, 1988, 1993, 3, 370, 185, 0, 1989, 1993, 3, 368, 184, 0, 1990, 1993, 3, 366, 183, 0, 1991, 1993, 3, 258, 129, 0, 1992, 1988, 1, 0, 0, 0, 1992, 1989, 1, 0, 0, 0, 1992, 1990, 1, 0, 0, 0, 1992, 1991, 1, 0, 0, 0, 1993, 275, 1, 0, 0, 0, 1994, 1995, 3, 328, 164, 0, 1995, 277, 1, 0, 0, 0, 1996, 1997, 3, 304, 152, 0, 1997, 279, 1, 0, 0, 0, 1998, 2001, 3, 304, 152, 0, 1999, 2001, 3, 276, 138, 0, 2000, 1998, 1, 0, 0, 0, 2000, 1999, 1, 0, 0, 0, 2001, 281, 1, 0, 0, 0, 2002, 2005, 5, 182, 0, 0, 2003, 2006, 3, 284, 142, 0, 2004, 2006, 3, 288, 144, 0, 2005, 2003, 1, 0, 0, 0, 2005, 2004, 1, 0, 0, 0, 2005, 2006, 1, 0, 0, 0, 2006, 283, 1, 0, 0, 0, 2007, 2009, 3, 286, 143, 0, 2008, 2010, 3, 290, 145, 0, 2009, 2008, 1, 0, 0, 0, 2009, 2010, 1, 0, 0, 0, 2010, 285, 1, 0, 0, 0, 2011, 2012, 3, 292, 146, 0, 2012, 2013, 3, 368, 184, 0, 2013, 2015, 1, 0, 0, 0, 2014, 2011, 1, 0, 0, 0, 2015, 2016, 1, 0, 0, 0, 2016, 2014, 1, 0, 0, 0, 2016, 2017, 1, 0, 0, 0, 2017, 287, 1, 0, 0, 0, 2018, 2021, 3, 290, 145, 0, 2019, 2022, 3, 286, 143, 0, 2020, 2022, 3, 290, 145, 0, 2021, 2019, 1, 0, 0, 0, 2021, 2020, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, 2022, 289, 1, 0, 0, 0, 2023, 2024, 3, 292, 146, 0, 2024, 2025, 3, 368, 184, 0, 2025, 2026, 5, 388, 0, 0, 2026, 2027, 3, 368, 184, 0, 2027, 291, 1, 0, 0, 0, 2028, 2030, 7, 33, 0, 0, 2029, 2028, 1, 0, 0, 0, 2029, 2030, 1, 0, 0, 0, 2030, 2031, 1, 0, 0, 0, 2031, 2034, 7, 34, 0, 0, 2032, 2034, 5, 537, 0, 0, 2033, 2029, 1, 0, 0, 0, 2033, 2032, 1, 0, 0, 0, 2034, 293, 1, 0, 0, 0, 2035, 2037, 5, 17, 0, 0, 2036, 2035, 1, 0, 0, 0, 2036, 2037, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 2040, 3, 304, 152, 0, 2039, 2041, 3, 300, 150, 0, 2040, 2039, 1, 0, 0, 0, 2040, 2041, 1, 0, 0, 0, 2041, 295, 1, 0, 0, 0, 2042, 2043, 3, 304, 152, 0, 2043, 2044, 3, 298, 149, 0, 2044, 297, 1, 0, 0, 0, 2045, 2046, 5, 221, 0, 0, 2046, 2048, 3, 304, 152, 0, 2047, 2045, 1, 0, 0, 0, 2048, 2049, 1, 0, 0, 0, 2049, 2047, 1, 0, 0, 0, 2049, 2050, 1, 0, 0, 0, 2050, 2053, 1, 0, 0, 0, 2051, 2053, 1, 0, 0, 0, 2052, 2047, 1, 0, 0, 0, 2052, 2051, 1, 0, 0, 0, 2053, 299, 1, 0, 0, 0, 2054, 2055, 5, 516, 0, 0, 2055, 2056, 3, 302, 151, 0, 2056, 2057, 5, 517, 0, 0, 2057, 301, 1, 0, 0, 0, 2058, 2063, 3, 304, 152, 0, 2059, 2060, 5, 520, 0, 0, 2060, 2062, 3, 304, 152, 0, 2061, 2059, 1, 0, 0, 0, 2062, 2065, 1, 0, 0, 0, 2063, 2061, 1, 0, 0, 0, 2063, 2064, 1, 0, 0, 0, 2064, 303, 1, 0, 0, 0, 2065, 2063, 1, 0, 0, 0, 2066, 2070, 3, 306, 153, 0, 2067, 2070, 3, 308, 154, 0, 2068, 2070, 3, 374, 187, 0, 2069, 2066, 1, 0, 0, 0, 2069, 2067, 1, 0, 0, 0, 2069, 2068, 1, 0, 0, 0, 2070, 305, 1, 0, 0, 0, 2071, 2072, 7, 35, 0, 0, 2072, 307, 1, 0, 0, 0, 2073, 2074, 5, 537, 0, 0, 2074, 309, 1, 0, 0, 0, 2075, 2076, 5, 428, 0, 0, 2076, 2077, 3, 258, 129, 0, 2077, 2078, 5, 376, 0, 0, 2078, 2079, 3, 258, 129, 0, 2079, 311, 1, 0, 0, 0, 2080, 2081, 3, 304, 152, 0, 2081, 313, 1, 0, 0, 0, 2082, 2083, 3, 304, 152, 0, 2083, 315, 1, 0, 0, 0, 2084, 2087, 3, 304, 152, 0, 2085, 2086, 5, 513, 0, 0, 2086, 2088, 3, 304, 152, 0, 2087, 2085, 1, 0, 0, 0, 2087, 2088, 1, 0, 0, 0, 2088, 317, 1, 0, 0, 0, 2089, 2092, 3, 304, 152, 0, 2090, 2091, 5, 513, 0, 0, 2091, 2093, 3, 304, 152, 0, 2092, 2090, 1, 0, 0, 0, 2092, 2093, 1, 0, 0, 0, 2093, 319, 1, 0, 0, 0, 2094, 2097, 3, 304, 152, 0, 2095, 2096, 5, 513, 0, 0, 2096, 2098, 3, 304, 152, 0, 2097, 2095, 1, 0, 0, 0, 2097, 2098, 1, 0, 0, 0, 2098, 2107, 1, 0, 0, 0, 2099, 2100, 3, 304, 152, 0, 2100, 2101, 5, 513, 0, 0, 2101, 2104, 3, 304, 152, 0, 2102, 2103, 5, 513, 0, 0, 2103, 2105, 3, 304, 152, 0, 2104, 2102, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2107, 1, 0, 0, 0, 2106, 2094, 1, 0, 0, 0, 2106, 2099, 1, 0, 0, 0, 2107, 321, 1, 0, 0, 0, 2108, 2111, 3, 304, 152, 0, 2109, 2110, 5, 513, 0, 0, 2110, 2112, 3, 304, 152, 0, 2111, 2109, 1, 0, 0, 0, 2111, 2112, 1, 0, 0, 0, 2112, 2121, 1, 0, 0, 0, 2113, 2114, 3, 304, 152, 0, 2114, 2115, 5, 513, 0, 0, 2115, 2118, 3, 304, 152, 0, 2116, 2117, 5, 513, 0, 0, 2117, 2119, 3, 304, 152, 0, 2118, 2116, 1, 0, 0, 0, 2118, 2119, 1, 0, 0, 0, 2119, 2121, 1, 0, 0, 0, 2120, 2108, 1, 0, 0, 0, 2120, 2113, 1, 0, 0, 0, 2121, 323, 1, 0, 0, 0, 2122, 2125, 3, 304, 152, 0, 2123, 2124, 5, 513, 0, 0, 2124, 2126, 3, 304, 152, 0, 2125, 2123, 1, 0, 0, 0, 2125, 2126, 1, 0, 0, 0, 2126, 2135, 1, 0, 0, 0, 2127, 2128, 3, 304, 152, 0, 2128, 2129, 5, 513, 0, 0, 2129, 2132, 3, 304, 152, 0, 2130, 2131, 5, 513, 0, 0, 2131, 2133, 3, 304, 152, 0, 2132, 2130, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 2135, 1, 0, 0, 0, 2134, 2122, 1, 0, 0, 0, 2134, 2127, 1, 0, 0, 0, 2135, 325, 1, 0, 0, 0, 2136, 2139, 3, 304, 152, 0, 2137, 2138, 5, 513, 0, 0, 2138, 2140, 3, 304, 152, 0, 2139, 2137, 1, 0, 0, 0, 2139, 2140, 1, 0, 0, 0, 2140, 2149, 1, 0, 0, 0, 2141, 2142, 3, 304, 152, 0, 2142, 2143, 5, 513, 0, 0, 2143, 2146, 3, 304, 152, 0, 2144, 2145, 5, 513, 0, 0, 2145, 2147, 3, 304, 152, 0, 2146, 2144, 1, 0, 0, 0, 2146, 2147, 1, 0, 0, 0, 2147, 2149, 1, 0, 0, 0, 2148, 2136, 1, 0, 0, 0, 2148, 2141, 1, 0, 0, 0, 2149, 327, 1, 0, 0, 0, 2150, 2155, 3, 304, 152, 0, 2151, 2152, 5, 513, 0, 0, 2152, 2154, 3, 304, 152, 0, 2153, 2151, 1, 0, 0, 0, 2154, 2157, 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2155, 2153, 1, 0, 0, 0, 2156, 329, 1, 0, 0, 0, 2157, 2155, 1, 0, 0, 0, 2158, 2159, 5, 433, 0, 0, 2159, 2160, 3, 336, 168, 0, 2160, 331, 1, 0, 0, 0, 2161, 2162, 5, 167, 0, 0, 2162, 2163, 5, 241, 0, 0, 2163, 2164, 5, 133, 0, 0, 2164, 333, 1, 0, 0, 0, 2165, 2166, 5, 167, 0, 0, 2166, 2167, 5, 133, 0, 0, 2167, 335, 1, 0, 0, 0, 2168, 2169, 5, 516, 0, 0, 2169, 2174, 3, 338, 169, 0, 2170, 2171, 5, 520, 0, 0, 2171, 2173, 3, 338, 169, 0, 2172, 2170, 1, 0, 0, 0, 2173, 2176, 1, 0, 0, 0, 2174, 2172, 1, 0, 0, 0, 2174, 2175, 1, 0, 0, 0, 2175, 2177, 1, 0, 0, 0, 2176, 2174, 1, 0, 0, 0, 2177, 2178, 5, 517, 0, 0, 2178, 337, 1, 0, 0, 0, 2179, 2184, 3, 340, 170, 0, 2180, 2182, 5, 505, 0, 0, 2181, 2180, 1, 0, 0, 0, 2181, 2182, 1, 0, 0, 0, 2182, 2183, 1, 0, 0, 0, 2183, 2185, 3, 342, 171, 0, 2184, 2181, 1, 0, 0, 0, 2184, 2185, 1, 0, 0, 0, 2185, 339, 1, 0, 0, 0, 2186, 2190, 3, 304, 152, 0, 2187, 2190, 3, 276, 138, 0, 2188, 2190, 5, 537, 0, 0, 2189, 2186, 1, 0, 0, 0, 2189, 2187, 1, 0, 0, 0, 2189, 2188, 1, 0, 0, 0, 2190, 341, 1, 0, 0, 0, 2191, 2196, 5, 538, 0, 0, 2192, 2196, 5, 539, 0, 0, 2193, 2196, 3, 362, 181, 0, 2194, 2196, 5, 537, 0, 0, 2195, 2191, 1, 0, 0, 0, 2195, 2192, 1, 0, 0, 0, 2195, 2193, 1, 0, 0, 0, 2195, 2194, 1, 0, 0, 0, 2196, 343, 1, 0, 0, 0, 2197, 2204, 5, 10, 0, 0, 2198, 2199, 5, 511, 0, 0, 2199, 2204, 5, 511, 0, 0, 2200, 2204, 5, 257, 0, 0, 2201, 2202, 5, 510, 0, 0, 2202, 2204, 5, 510, 0, 0, 2203, 2197, 1, 0, 0, 0, 2203, 2198, 1, 0, 0, 0, 2203, 2200, 1, 0, 0, 0, 2203, 2201, 1, 0, 0, 0, 2204, 345, 1, 0, 0, 0, 2205, 2220, 5, 505, 0, 0, 2206, 2220, 5, 506, 0, 0, 2207, 2220, 5, 507, 0, 0, 2208, 2209, 5, 507, 0, 0, 2209, 2220, 5, 505, 0, 0, 2210, 2211, 5, 506, 0, 0, 2211, 2220, 5, 505, 0, 0, 2212, 2213, 5, 507, 0, 0, 2213, 2220, 5, 506, 0, 0, 2214, 2215, 5, 508, 0, 0, 2215, 2220, 5, 505, 0, 0, 2216, 2217, 5, 507, 0, 0, 2217, 2218, 5, 505, 0, 0, 2218, 2220, 5, 506, 0, 0, 2219, 2205, 1, 0, 0, 0, 2219, 2206, 1, 0, 0, 0, 2219, 2207, 1, 0, 0, 0, 2219, 2208, 1, 0, 0, 0, 2219, 2210, 1, 0, 0, 0, 2219, 2212, 1, 0, 0, 0, 2219, 2214, 1, 0, 0, 0, 2219, 2216, 1, 0, 0, 0, 2220, 347, 1, 0, 0, 0, 2221, 2222, 5, 507, 0, 0, 2222, 2229, 5, 507, 0, 0, 2223, 2224, 5, 506, 0, 0, 2224, 2229, 5, 506, 0, 0, 2225, 2229, 5, 511, 0, 0, 2226, 2229, 5, 512, 0, 0, 2227, 2229, 5, 510, 0, 0, 2228, 2221, 1, 0, 0, 0, 2228, 2223, 1, 0, 0, 0, 2228, 2225, 1, 0, 0, 0, 2228, 2226, 1, 0, 0, 0, 2228, 2227, 1, 0, 0, 0, 2229, 349, 1, 0, 0, 0, 2230, 2231, 7, 36, 0, 0, 2231, 351, 1, 0, 0, 0, 2232, 2233, 7, 37, 0, 0, 2233, 353, 1, 0, 0, 0, 2234, 2249, 3, 282, 141, 0, 2235, 2249, 3, 356, 178, 0, 2236, 2249, 3, 358, 179, 0, 2237, 2239, 5, 529, 0, 0, 2238, 2237, 1, 0, 0, 0, 2238, 2239, 1, 0, 0, 0, 2239, 2240, 1, 0, 0, 0, 2240, 2249, 3, 360, 180, 0, 2241, 2249, 3, 362, 181, 0, 2242, 2249, 5, 539, 0, 0, 2243, 2249, 5, 540, 0, 0, 2244, 2246, 5, 241, 0, 0, 2245, 2244, 1, 0, 0, 0, 2245, 2246, 1, 0, 0, 0, 2246, 2247, 1, 0, 0, 0, 2247, 2249, 5, 244, 0, 0, 2248, 2234, 1, 0, 0, 0, 2248, 2235, 1, 0, 0, 0, 2248, 2236, 1, 0, 0, 0, 2248, 2238, 1, 0, 0, 0, 2248, 2241, 1, 0, 0, 0, 2248, 2242, 1, 0, 0, 0, 2248, 2243, 1, 0, 0, 0, 2248, 2245, 1, 0, 0, 0, 2249, 355, 1, 0, 0, 0, 2250, 2251, 3, 366, 183, 0, 2251, 2252, 3, 358, 179, 0, 2252, 357, 1, 0, 0, 0, 2253, 2254, 5, 537, 0, 0, 2254, 359, 1, 0, 0, 0, 2255, 2256, 5, 538, 0, 0, 2256, 361, 1, 0, 0, 0, 2257, 2258, 7, 38, 0, 0, 2258, 363, 1, 0, 0, 0, 2259, 2260, 7, 39, 0, 0, 2260, 365, 1, 0, 0, 0, 2261, 2262, 7, 40, 0, 0, 2262, 367, 1, 0, 0, 0, 2263, 2264, 7, 41, 0, 0, 2264, 369, 1, 0, 0, 0, 2265, 2266, 7, 42, 0, 0, 2266, 371, 1, 0, 0, 0, 2267, 2268, 7, 43, 0, 0, 2268, 373, 1, 0, 0, 0, 2269, 2270, 7, 44, 0, 0, 2270, 375, 1, 0, 0, 0, 270, 379, 386, 389, 403, 421, 425, 434, 439, 446, 457, 466, 478, 481, 488, 491, 499, 503, 508, 511, 518, 526, 530, 542, 550, 554, 586, 589, 594, 598, 602, 606, 615, 620, 624, 628, 632, 635, 639, 644, 650, 655, 660, 663, 667, 671, 679, 687, 691, 695, 699, 703, 707, 711, 715, 719, 721, 731, 739, 763, 770, 776, 779, 782, 792, 795, 803, 815, 839, 851, 856, 860, 868, 872, 878, 888, 892, 898, 902, 906, 909, 918, 922, 929, 932, 942, 950, 958, 962, 977, 996, 1007, 1011, 1018, 1023, 1029, 1033, 1040, 1044, 1048, 1052, 1060, 1064, 1069, 1075, 1081, 1084, 1088, 1099, 1108, 1122, 1134, 1149, 1152, 1156, 1159, 1161, 1166, 1170, 1173, 1177, 1186, 1195, 1205, 1210, 1221, 1224, 1227, 1230, 1233, 1239, 1243, 1251, 1254, 1259, 1262, 1266, 1269, 1271, 1285, 1296, 1301, 1309, 1312, 1315, 1320, 1322, 1324, 1329, 1332, 1336, 1339, 1342, 1346, 1349, 1352, 1364, 1371, 1382, 1409, 1431, 1444, 1456, 1469, 1481, 1493, 1499, 1526, 1534, 1538, 1541, 1544, 1551, 1554, 1557, 1560, 1563, 1566, 1571, 1574, 1583, 1588, 1592, 1597, 1606, 1625, 1633, 1641, 1645, 1649, 1659, 1685, 1693, 1705, 1727, 1729, 1740, 1743, 1745, 1749, 1753, 1760, 1769, 1775, 1788, 1795, 1800, 1806, 1813, 1815, 1818, 1830, 1835, 1838, 1844, 1846, 1852, 1873, 1875, 1883, 1887, 1896, 1900, 1916, 1925, 1949, 1956, 1959, 1970, 1979, 1986, 1992, 2000, 2005, 2009, 2016, 2021, 2029, 2033, 2036, 2040, 2049, 2052, 2063, 2069, 2087, 2092, 2097, 2104, 2106, 2111, 2118, 2120, 2125, 2132, 2134, 2139, 2146, 2148, 2155, 2174, 2181, 2184, 2189, 2195, 2203, 2219, 2228, 2238, 2245, 2248] \ No newline at end of file +[4, 1, 541, 2260, 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, 1, 0, 5, 0, 376, 8, 0, 10, 0, 12, 0, 379, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 385, 8, 1, 1, 1, 3, 1, 388, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 402, 8, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 420, 8, 4, 1, 5, 1, 5, 3, 5, 424, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 433, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 438, 8, 7, 1, 8, 1, 8, 1, 8, 5, 8, 443, 8, 8, 10, 8, 12, 8, 446, 9, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 456, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 463, 8, 11, 10, 11, 12, 11, 466, 9, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 477, 8, 12, 1, 12, 3, 12, 480, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 487, 8, 12, 1, 12, 3, 12, 490, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 498, 8, 12, 1, 12, 1, 12, 3, 12, 502, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 507, 8, 12, 1, 12, 3, 12, 510, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 517, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 3, 15, 525, 8, 15, 1, 16, 1, 16, 3, 16, 529, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 541, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 549, 8, 18, 1, 18, 1, 18, 3, 18, 553, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 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, 585, 8, 18, 1, 19, 3, 19, 588, 8, 19, 1, 19, 4, 19, 591, 8, 19, 11, 19, 12, 19, 592, 1, 20, 1, 20, 3, 20, 597, 8, 20, 1, 21, 1, 21, 3, 21, 601, 8, 21, 1, 21, 1, 21, 3, 21, 605, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 5, 21, 612, 8, 21, 10, 21, 12, 21, 615, 9, 21, 1, 21, 1, 21, 3, 21, 619, 8, 21, 1, 21, 1, 21, 3, 21, 623, 8, 21, 1, 21, 1, 21, 3, 21, 627, 8, 21, 1, 21, 1, 21, 1, 21, 3, 21, 632, 8, 21, 1, 21, 3, 21, 635, 8, 21, 1, 21, 1, 21, 3, 21, 639, 8, 21, 1, 22, 1, 22, 1, 22, 3, 22, 644, 8, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 650, 8, 22, 1, 23, 1, 23, 1, 23, 3, 23, 655, 8, 23, 1, 24, 1, 24, 1, 24, 3, 24, 660, 8, 24, 1, 24, 1, 24, 3, 24, 664, 8, 24, 1, 25, 1, 25, 3, 25, 668, 8, 25, 1, 26, 1, 26, 3, 26, 672, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 678, 8, 27, 10, 27, 12, 27, 681, 9, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 3, 28, 688, 8, 28, 1, 28, 1, 28, 3, 28, 692, 8, 28, 1, 28, 1, 28, 3, 28, 696, 8, 28, 1, 28, 1, 28, 3, 28, 700, 8, 28, 1, 28, 1, 28, 3, 28, 704, 8, 28, 1, 28, 1, 28, 3, 28, 708, 8, 28, 1, 28, 1, 28, 3, 28, 712, 8, 28, 1, 28, 1, 28, 3, 28, 716, 8, 28, 1, 28, 1, 28, 3, 28, 720, 8, 28, 3, 28, 722, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 732, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 740, 8, 31, 1, 31, 1, 31, 1, 32, 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, 5, 34, 762, 8, 34, 10, 34, 12, 34, 765, 9, 34, 1, 34, 1, 34, 1, 35, 1, 35, 3, 35, 771, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 777, 8, 35, 1, 35, 3, 35, 780, 8, 35, 1, 35, 3, 35, 783, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 790, 8, 36, 1, 36, 3, 36, 793, 8, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 802, 8, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 3, 41, 814, 8, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 836, 8, 45, 10, 45, 12, 45, 839, 9, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 5, 46, 848, 8, 46, 10, 46, 12, 46, 851, 9, 46, 1, 46, 1, 46, 3, 46, 855, 8, 46, 1, 47, 1, 47, 3, 47, 859, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 5, 48, 865, 8, 48, 10, 48, 12, 48, 868, 9, 48, 1, 48, 3, 48, 871, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 877, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 3, 51, 887, 8, 51, 1, 51, 1, 51, 1, 51, 3, 51, 892, 8, 51, 1, 51, 1, 51, 1, 52, 1, 52, 3, 52, 898, 8, 52, 1, 52, 1, 52, 3, 52, 902, 8, 52, 1, 52, 1, 52, 3, 52, 906, 8, 52, 1, 52, 1, 52, 3, 52, 910, 8, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 919, 8, 53, 1, 53, 1, 53, 3, 53, 923, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 930, 8, 53, 1, 53, 3, 53, 933, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 941, 8, 54, 10, 54, 12, 54, 944, 9, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 3, 56, 951, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 959, 8, 56, 1, 57, 1, 57, 3, 57, 963, 8, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 978, 8, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 997, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1008, 8, 65, 1, 65, 1, 65, 3, 65, 1012, 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1019, 8, 65, 1, 66, 1, 66, 1, 66, 3, 66, 1024, 8, 66, 1, 66, 1, 66, 1, 67, 1, 67, 3, 67, 1030, 8, 67, 1, 67, 1, 67, 3, 67, 1034, 8, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 3, 68, 1041, 8, 68, 1, 68, 1, 68, 3, 68, 1045, 8, 68, 1, 69, 1, 69, 3, 69, 1049, 8, 69, 1, 69, 1, 69, 3, 69, 1053, 8, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1061, 8, 70, 1, 70, 1, 70, 3, 70, 1065, 8, 70, 1, 70, 1, 70, 1, 71, 3, 71, 1070, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1076, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1082, 8, 72, 1, 72, 3, 72, 1085, 8, 72, 1, 72, 1, 72, 3, 72, 1089, 8, 72, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 5, 74, 1098, 8, 74, 10, 74, 12, 74, 1101, 9, 74, 1, 75, 1, 75, 1, 75, 1, 75, 5, 75, 1107, 8, 75, 10, 75, 12, 75, 1110, 9, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 4, 76, 1121, 8, 76, 11, 76, 12, 76, 1122, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 4, 77, 1133, 8, 77, 11, 77, 12, 77, 1134, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1150, 8, 78, 1, 78, 3, 78, 1153, 8, 78, 1, 78, 1, 78, 3, 78, 1157, 8, 78, 1, 78, 3, 78, 1160, 8, 78, 3, 78, 1162, 8, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1167, 8, 78, 1, 78, 1, 78, 3, 78, 1171, 8, 78, 1, 78, 3, 78, 1174, 8, 78, 5, 78, 1176, 8, 78, 10, 78, 12, 78, 1179, 9, 78, 1, 79, 1, 79, 1, 79, 1, 79, 5, 79, 1185, 8, 79, 10, 79, 12, 79, 1188, 9, 79, 1, 80, 1, 80, 1, 80, 1, 80, 5, 80, 1194, 8, 80, 10, 80, 12, 80, 1197, 9, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 5, 81, 1204, 8, 81, 10, 81, 12, 81, 1207, 9, 81, 1, 81, 1, 81, 3, 81, 1211, 8, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 83, 1, 83, 3, 83, 1222, 8, 83, 1, 83, 3, 83, 1225, 8, 83, 1, 83, 3, 83, 1228, 8, 83, 1, 83, 3, 83, 1231, 8, 83, 1, 83, 3, 83, 1234, 8, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1240, 8, 83, 1, 84, 1, 84, 3, 84, 1244, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 5, 84, 1250, 8, 84, 10, 84, 12, 84, 1253, 9, 84, 3, 84, 1255, 8, 84, 1, 85, 1, 85, 1, 85, 3, 85, 1260, 8, 85, 1, 85, 3, 85, 1263, 8, 85, 1, 85, 1, 85, 3, 85, 1267, 8, 85, 1, 85, 3, 85, 1270, 8, 85, 3, 85, 1272, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1286, 8, 86, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 5, 88, 1295, 8, 88, 10, 88, 12, 88, 1298, 9, 88, 1, 88, 1, 88, 3, 88, 1302, 8, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1310, 8, 88, 1, 88, 3, 88, 1313, 8, 88, 1, 88, 3, 88, 1316, 8, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1321, 8, 88, 5, 88, 1323, 8, 88, 10, 88, 12, 88, 1326, 9, 88, 1, 89, 1, 89, 3, 89, 1330, 8, 89, 1, 90, 3, 90, 1333, 8, 90, 1, 90, 1, 90, 3, 90, 1337, 8, 90, 1, 90, 1, 90, 3, 90, 1341, 8, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 1351, 8, 90, 10, 90, 12, 90, 1354, 9, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1360, 8, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1371, 8, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 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, 95, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 1396, 8, 95, 10, 95, 12, 95, 1399, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 1420, 8, 97, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 1433, 8, 100, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 5, 102, 1443, 8, 102, 10, 102, 12, 102, 1446, 9, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 1456, 8, 103, 10, 103, 12, 103, 1459, 9, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 1468, 8, 103, 10, 103, 12, 103, 1471, 9, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 1480, 8, 103, 10, 103, 12, 103, 1483, 9, 103, 1, 103, 1, 103, 1, 103, 3, 103, 1488, 8, 103, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1513, 8, 110, 10, 110, 12, 110, 1516, 9, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 3, 112, 1523, 8, 112, 1, 112, 1, 112, 3, 112, 1527, 8, 112, 1, 112, 3, 112, 1530, 8, 112, 1, 112, 3, 112, 1533, 8, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 3, 113, 1540, 8, 113, 1, 113, 3, 113, 1543, 8, 113, 1, 113, 3, 113, 1546, 8, 113, 1, 113, 3, 113, 1549, 8, 113, 1, 113, 3, 113, 1552, 8, 113, 1, 113, 3, 113, 1555, 8, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1560, 8, 113, 1, 113, 3, 113, 1563, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 5, 114, 1570, 8, 114, 10, 114, 12, 114, 1573, 9, 114, 1, 115, 1, 115, 3, 115, 1577, 8, 115, 1, 115, 1, 115, 3, 115, 1581, 8, 115, 1, 116, 1, 116, 1, 116, 3, 116, 1586, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 1593, 8, 117, 10, 117, 12, 117, 1596, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 1614, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 5, 119, 1620, 8, 119, 10, 119, 12, 119, 1623, 9, 119, 1, 120, 1, 120, 1, 120, 4, 120, 1628, 8, 120, 11, 120, 12, 120, 1629, 1, 120, 1, 120, 3, 120, 1634, 8, 120, 1, 121, 1, 121, 3, 121, 1638, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 1648, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 1674, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 5, 124, 1680, 8, 124, 10, 124, 12, 124, 1683, 9, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 1694, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 1716, 8, 129, 3, 129, 1718, 8, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 1729, 8, 129, 1, 129, 5, 129, 1732, 8, 129, 10, 129, 12, 129, 1735, 9, 129, 1, 130, 3, 130, 1738, 8, 130, 1, 130, 1, 130, 3, 130, 1742, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1749, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 1756, 8, 130, 10, 130, 12, 130, 1759, 9, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1764, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1777, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1784, 8, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1789, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1795, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1802, 8, 130, 3, 130, 1804, 8, 130, 1, 131, 3, 131, 1807, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 5, 131, 1817, 8, 131, 10, 131, 12, 131, 1820, 9, 131, 1, 131, 1, 131, 3, 131, 1824, 8, 131, 1, 131, 3, 131, 1827, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1833, 8, 131, 3, 131, 1835, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 1841, 8, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 5, 132, 1862, 8, 132, 10, 132, 12, 132, 1865, 9, 132, 1, 133, 1, 133, 1, 133, 4, 133, 1870, 8, 133, 11, 133, 12, 133, 1871, 1, 133, 1, 133, 3, 133, 1876, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 4, 133, 1883, 8, 133, 11, 133, 12, 133, 1884, 1, 133, 1, 133, 3, 133, 1889, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1905, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1914, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1938, 8, 133, 1, 133, 1, 133, 1, 133, 5, 133, 1943, 8, 133, 10, 133, 12, 133, 1946, 9, 133, 3, 133, 1948, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1959, 8, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 5, 133, 1966, 8, 133, 10, 133, 12, 133, 1969, 9, 133, 1, 134, 1, 134, 1, 135, 1, 135, 3, 135, 1975, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 1981, 8, 136, 1, 137, 1, 137, 1, 138, 1, 138, 1, 139, 1, 139, 3, 139, 1989, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 1994, 8, 140, 1, 141, 1, 141, 3, 141, 1998, 8, 141, 1, 142, 1, 142, 1, 142, 4, 142, 2003, 8, 142, 11, 142, 12, 142, 2004, 1, 143, 1, 143, 1, 143, 3, 143, 2010, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 3, 145, 2018, 8, 145, 1, 145, 1, 145, 3, 145, 2022, 8, 145, 1, 146, 3, 146, 2025, 8, 146, 1, 146, 1, 146, 3, 146, 2029, 8, 146, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 4, 148, 2036, 8, 148, 11, 148, 12, 148, 2037, 1, 148, 3, 148, 2041, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 5, 150, 2050, 8, 150, 10, 150, 12, 150, 2053, 9, 150, 1, 151, 1, 151, 1, 151, 3, 151, 2058, 8, 151, 1, 152, 1, 152, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 3, 157, 2076, 8, 157, 1, 158, 1, 158, 1, 158, 3, 158, 2081, 8, 158, 1, 159, 1, 159, 1, 159, 3, 159, 2086, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2093, 8, 159, 3, 159, 2095, 8, 159, 1, 160, 1, 160, 1, 160, 3, 160, 2100, 8, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 2107, 8, 160, 3, 160, 2109, 8, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2114, 8, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 2121, 8, 161, 3, 161, 2123, 8, 161, 1, 162, 1, 162, 1, 162, 3, 162, 2128, 8, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2135, 8, 162, 3, 162, 2137, 8, 162, 1, 163, 1, 163, 1, 163, 5, 163, 2142, 8, 163, 10, 163, 12, 163, 2145, 9, 163, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 5, 167, 2161, 8, 167, 10, 167, 12, 167, 2164, 9, 167, 1, 167, 1, 167, 1, 168, 1, 168, 3, 168, 2170, 8, 168, 1, 168, 3, 168, 2173, 8, 168, 1, 169, 1, 169, 1, 169, 3, 169, 2178, 8, 169, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2184, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2192, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2208, 8, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 2217, 8, 173, 1, 174, 1, 174, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 2227, 8, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 2234, 8, 176, 1, 176, 3, 176, 2237, 8, 176, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 179, 1, 179, 1, 180, 1, 180, 1, 181, 1, 181, 1, 182, 1, 182, 1, 183, 1, 183, 1, 184, 1, 184, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 2143, 5, 156, 176, 258, 264, 266, 187, 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, 0, 45, 2, 0, 109, 109, 450, 450, 3, 0, 45, 45, 128, 128, 188, 188, 4, 0, 42, 42, 90, 90, 422, 422, 464, 464, 2, 0, 441, 441, 447, 447, 2, 0, 151, 151, 170, 170, 2, 0, 437, 437, 489, 489, 2, 0, 482, 485, 487, 487, 3, 0, 32, 32, 91, 91, 244, 244, 11, 0, 28, 29, 35, 35, 46, 46, 92, 92, 178, 179, 344, 344, 360, 360, 378, 378, 381, 381, 387, 387, 416, 417, 2, 0, 433, 433, 435, 435, 4, 0, 101, 102, 115, 115, 144, 144, 246, 246, 2, 0, 13, 13, 231, 231, 2, 0, 455, 455, 462, 462, 3, 0, 5, 5, 270, 270, 444, 444, 3, 0, 266, 266, 455, 455, 462, 462, 3, 0, 425, 425, 458, 458, 477, 477, 3, 0, 330, 330, 465, 465, 481, 481, 2, 0, 440, 440, 490, 490, 2, 0, 183, 183, 265, 265, 3, 0, 130, 130, 180, 180, 402, 402, 4, 0, 152, 152, 174, 174, 201, 201, 317, 317, 3, 0, 445, 445, 459, 459, 499, 499, 4, 0, 250, 250, 446, 446, 494, 496, 498, 498, 2, 0, 74, 74, 320, 320, 3, 0, 459, 459, 492, 492, 499, 499, 2, 0, 439, 439, 450, 450, 2, 0, 457, 457, 467, 467, 4, 0, 140, 140, 244, 244, 397, 397, 404, 404, 2, 0, 19, 19, 369, 369, 2, 0, 5, 5, 11, 11, 2, 0, 509, 509, 529, 530, 4, 0, 452, 452, 527, 527, 531, 531, 534, 534, 2, 0, 529, 530, 532, 532, 1, 0, 529, 530, 1, 0, 538, 539, 2, 0, 538, 538, 541, 541, 4, 0, 452, 452, 527, 527, 529, 531, 533, 534, 3, 0, 241, 241, 508, 509, 529, 530, 2, 0, 140, 140, 397, 397, 2, 0, 5, 5, 113, 113, 10, 0, 97, 97, 165, 165, 222, 222, 229, 229, 334, 334, 436, 436, 470, 470, 472, 472, 488, 488, 502, 502, 15, 0, 97, 97, 165, 165, 222, 222, 229, 229, 334, 334, 427, 427, 436, 436, 442, 442, 448, 449, 454, 454, 460, 460, 470, 475, 488, 488, 491, 491, 502, 503, 11, 0, 5, 5, 13, 13, 33, 33, 78, 78, 84, 85, 113, 113, 200, 200, 207, 208, 389, 389, 413, 413, 527, 527, 55, 0, 4, 4, 13, 13, 23, 23, 38, 38, 41, 41, 43, 44, 54, 54, 56, 56, 69, 69, 75, 75, 78, 78, 84, 85, 91, 91, 98, 99, 107, 107, 119, 119, 134, 134, 139, 139, 143, 143, 145, 145, 160, 160, 165, 165, 167, 167, 194, 194, 197, 197, 199, 199, 201, 201, 205, 205, 207, 209, 214, 214, 220, 220, 222, 223, 229, 229, 243, 243, 245, 245, 264, 264, 276, 276, 281, 281, 283, 283, 293, 293, 317, 317, 321, 323, 334, 334, 357, 358, 364, 364, 367, 367, 378, 380, 395, 395, 398, 399, 408, 408, 419, 420, 436, 436, 469, 469, 488, 488, 502, 502, 1, 0, 437, 504, 2460, 0, 377, 1, 0, 0, 0, 2, 387, 1, 0, 0, 0, 4, 401, 1, 0, 0, 0, 6, 403, 1, 0, 0, 0, 8, 419, 1, 0, 0, 0, 10, 423, 1, 0, 0, 0, 12, 425, 1, 0, 0, 0, 14, 428, 1, 0, 0, 0, 16, 439, 1, 0, 0, 0, 18, 447, 1, 0, 0, 0, 20, 455, 1, 0, 0, 0, 22, 457, 1, 0, 0, 0, 24, 509, 1, 0, 0, 0, 26, 511, 1, 0, 0, 0, 28, 518, 1, 0, 0, 0, 30, 522, 1, 0, 0, 0, 32, 526, 1, 0, 0, 0, 34, 530, 1, 0, 0, 0, 36, 584, 1, 0, 0, 0, 38, 590, 1, 0, 0, 0, 40, 596, 1, 0, 0, 0, 42, 598, 1, 0, 0, 0, 44, 640, 1, 0, 0, 0, 46, 654, 1, 0, 0, 0, 48, 656, 1, 0, 0, 0, 50, 667, 1, 0, 0, 0, 52, 671, 1, 0, 0, 0, 54, 673, 1, 0, 0, 0, 56, 721, 1, 0, 0, 0, 58, 723, 1, 0, 0, 0, 60, 727, 1, 0, 0, 0, 62, 735, 1, 0, 0, 0, 64, 743, 1, 0, 0, 0, 66, 747, 1, 0, 0, 0, 68, 754, 1, 0, 0, 0, 70, 782, 1, 0, 0, 0, 72, 784, 1, 0, 0, 0, 74, 794, 1, 0, 0, 0, 76, 796, 1, 0, 0, 0, 78, 803, 1, 0, 0, 0, 80, 805, 1, 0, 0, 0, 82, 813, 1, 0, 0, 0, 84, 821, 1, 0, 0, 0, 86, 823, 1, 0, 0, 0, 88, 827, 1, 0, 0, 0, 90, 831, 1, 0, 0, 0, 92, 854, 1, 0, 0, 0, 94, 858, 1, 0, 0, 0, 96, 860, 1, 0, 0, 0, 98, 876, 1, 0, 0, 0, 100, 878, 1, 0, 0, 0, 102, 883, 1, 0, 0, 0, 104, 895, 1, 0, 0, 0, 106, 914, 1, 0, 0, 0, 108, 934, 1, 0, 0, 0, 110, 945, 1, 0, 0, 0, 112, 947, 1, 0, 0, 0, 114, 960, 1, 0, 0, 0, 116, 967, 1, 0, 0, 0, 118, 970, 1, 0, 0, 0, 120, 979, 1, 0, 0, 0, 122, 983, 1, 0, 0, 0, 124, 987, 1, 0, 0, 0, 126, 990, 1, 0, 0, 0, 128, 998, 1, 0, 0, 0, 130, 1003, 1, 0, 0, 0, 132, 1020, 1, 0, 0, 0, 134, 1027, 1, 0, 0, 0, 136, 1037, 1, 0, 0, 0, 138, 1046, 1, 0, 0, 0, 140, 1056, 1, 0, 0, 0, 142, 1075, 1, 0, 0, 0, 144, 1077, 1, 0, 0, 0, 146, 1090, 1, 0, 0, 0, 148, 1093, 1, 0, 0, 0, 150, 1102, 1, 0, 0, 0, 152, 1113, 1, 0, 0, 0, 154, 1126, 1, 0, 0, 0, 156, 1161, 1, 0, 0, 0, 158, 1180, 1, 0, 0, 0, 160, 1189, 1, 0, 0, 0, 162, 1198, 1, 0, 0, 0, 164, 1217, 1, 0, 0, 0, 166, 1239, 1, 0, 0, 0, 168, 1241, 1, 0, 0, 0, 170, 1271, 1, 0, 0, 0, 172, 1285, 1, 0, 0, 0, 174, 1287, 1, 0, 0, 0, 176, 1301, 1, 0, 0, 0, 178, 1327, 1, 0, 0, 0, 180, 1370, 1, 0, 0, 0, 182, 1372, 1, 0, 0, 0, 184, 1378, 1, 0, 0, 0, 186, 1380, 1, 0, 0, 0, 188, 1385, 1, 0, 0, 0, 190, 1390, 1, 0, 0, 0, 192, 1402, 1, 0, 0, 0, 194, 1419, 1, 0, 0, 0, 196, 1421, 1, 0, 0, 0, 198, 1423, 1, 0, 0, 0, 200, 1432, 1, 0, 0, 0, 202, 1434, 1, 0, 0, 0, 204, 1437, 1, 0, 0, 0, 206, 1487, 1, 0, 0, 0, 208, 1489, 1, 0, 0, 0, 210, 1492, 1, 0, 0, 0, 212, 1494, 1, 0, 0, 0, 214, 1501, 1, 0, 0, 0, 216, 1503, 1, 0, 0, 0, 218, 1505, 1, 0, 0, 0, 220, 1508, 1, 0, 0, 0, 222, 1517, 1, 0, 0, 0, 224, 1522, 1, 0, 0, 0, 226, 1536, 1, 0, 0, 0, 228, 1564, 1, 0, 0, 0, 230, 1574, 1, 0, 0, 0, 232, 1582, 1, 0, 0, 0, 234, 1587, 1, 0, 0, 0, 236, 1613, 1, 0, 0, 0, 238, 1615, 1, 0, 0, 0, 240, 1624, 1, 0, 0, 0, 242, 1635, 1, 0, 0, 0, 244, 1647, 1, 0, 0, 0, 246, 1673, 1, 0, 0, 0, 248, 1675, 1, 0, 0, 0, 250, 1693, 1, 0, 0, 0, 252, 1695, 1, 0, 0, 0, 254, 1700, 1, 0, 0, 0, 256, 1703, 1, 0, 0, 0, 258, 1717, 1, 0, 0, 0, 260, 1803, 1, 0, 0, 0, 262, 1834, 1, 0, 0, 0, 264, 1840, 1, 0, 0, 0, 266, 1958, 1, 0, 0, 0, 268, 1970, 1, 0, 0, 0, 270, 1974, 1, 0, 0, 0, 272, 1980, 1, 0, 0, 0, 274, 1982, 1, 0, 0, 0, 276, 1984, 1, 0, 0, 0, 278, 1988, 1, 0, 0, 0, 280, 1990, 1, 0, 0, 0, 282, 1995, 1, 0, 0, 0, 284, 2002, 1, 0, 0, 0, 286, 2006, 1, 0, 0, 0, 288, 2011, 1, 0, 0, 0, 290, 2021, 1, 0, 0, 0, 292, 2024, 1, 0, 0, 0, 294, 2030, 1, 0, 0, 0, 296, 2040, 1, 0, 0, 0, 298, 2042, 1, 0, 0, 0, 300, 2046, 1, 0, 0, 0, 302, 2057, 1, 0, 0, 0, 304, 2059, 1, 0, 0, 0, 306, 2061, 1, 0, 0, 0, 308, 2063, 1, 0, 0, 0, 310, 2068, 1, 0, 0, 0, 312, 2070, 1, 0, 0, 0, 314, 2072, 1, 0, 0, 0, 316, 2077, 1, 0, 0, 0, 318, 2094, 1, 0, 0, 0, 320, 2108, 1, 0, 0, 0, 322, 2122, 1, 0, 0, 0, 324, 2136, 1, 0, 0, 0, 326, 2138, 1, 0, 0, 0, 328, 2146, 1, 0, 0, 0, 330, 2149, 1, 0, 0, 0, 332, 2153, 1, 0, 0, 0, 334, 2156, 1, 0, 0, 0, 336, 2167, 1, 0, 0, 0, 338, 2177, 1, 0, 0, 0, 340, 2183, 1, 0, 0, 0, 342, 2191, 1, 0, 0, 0, 344, 2207, 1, 0, 0, 0, 346, 2216, 1, 0, 0, 0, 348, 2218, 1, 0, 0, 0, 350, 2220, 1, 0, 0, 0, 352, 2236, 1, 0, 0, 0, 354, 2238, 1, 0, 0, 0, 356, 2241, 1, 0, 0, 0, 358, 2243, 1, 0, 0, 0, 360, 2245, 1, 0, 0, 0, 362, 2247, 1, 0, 0, 0, 364, 2249, 1, 0, 0, 0, 366, 2251, 1, 0, 0, 0, 368, 2253, 1, 0, 0, 0, 370, 2255, 1, 0, 0, 0, 372, 2257, 1, 0, 0, 0, 374, 376, 3, 2, 1, 0, 375, 374, 1, 0, 0, 0, 376, 379, 1, 0, 0, 0, 377, 375, 1, 0, 0, 0, 377, 378, 1, 0, 0, 0, 378, 380, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 380, 381, 5, 0, 0, 1, 381, 1, 1, 0, 0, 0, 382, 384, 3, 4, 2, 0, 383, 385, 5, 521, 0, 0, 384, 383, 1, 0, 0, 0, 384, 385, 1, 0, 0, 0, 385, 388, 1, 0, 0, 0, 386, 388, 3, 6, 3, 0, 387, 382, 1, 0, 0, 0, 387, 386, 1, 0, 0, 0, 388, 3, 1, 0, 0, 0, 389, 402, 3, 8, 4, 0, 390, 402, 3, 10, 5, 0, 391, 402, 3, 12, 6, 0, 392, 402, 3, 14, 7, 0, 393, 402, 3, 20, 10, 0, 394, 402, 3, 24, 12, 0, 395, 402, 3, 26, 13, 0, 396, 402, 3, 28, 14, 0, 397, 402, 3, 30, 15, 0, 398, 402, 3, 32, 16, 0, 399, 402, 3, 34, 17, 0, 400, 402, 3, 36, 18, 0, 401, 389, 1, 0, 0, 0, 401, 390, 1, 0, 0, 0, 401, 391, 1, 0, 0, 0, 401, 392, 1, 0, 0, 0, 401, 393, 1, 0, 0, 0, 401, 394, 1, 0, 0, 0, 401, 395, 1, 0, 0, 0, 401, 396, 1, 0, 0, 0, 401, 397, 1, 0, 0, 0, 401, 398, 1, 0, 0, 0, 401, 399, 1, 0, 0, 0, 401, 400, 1, 0, 0, 0, 402, 5, 1, 0, 0, 0, 403, 404, 5, 521, 0, 0, 404, 7, 1, 0, 0, 0, 405, 420, 3, 40, 20, 0, 406, 420, 3, 102, 51, 0, 407, 420, 3, 104, 52, 0, 408, 420, 3, 106, 53, 0, 409, 420, 3, 100, 50, 0, 410, 420, 3, 112, 56, 0, 411, 420, 3, 126, 63, 0, 412, 420, 3, 128, 64, 0, 413, 420, 3, 130, 65, 0, 414, 420, 3, 132, 66, 0, 415, 420, 3, 134, 67, 0, 416, 420, 3, 136, 68, 0, 417, 420, 3, 138, 69, 0, 418, 420, 3, 140, 70, 0, 419, 405, 1, 0, 0, 0, 419, 406, 1, 0, 0, 0, 419, 407, 1, 0, 0, 0, 419, 408, 1, 0, 0, 0, 419, 409, 1, 0, 0, 0, 419, 410, 1, 0, 0, 0, 419, 411, 1, 0, 0, 0, 419, 412, 1, 0, 0, 0, 419, 413, 1, 0, 0, 0, 419, 414, 1, 0, 0, 0, 419, 415, 1, 0, 0, 0, 419, 416, 1, 0, 0, 0, 419, 417, 1, 0, 0, 0, 419, 418, 1, 0, 0, 0, 420, 9, 1, 0, 0, 0, 421, 424, 3, 156, 78, 0, 422, 424, 3, 142, 71, 0, 423, 421, 1, 0, 0, 0, 423, 422, 1, 0, 0, 0, 424, 11, 1, 0, 0, 0, 425, 426, 7, 0, 0, 0, 426, 427, 3, 320, 160, 0, 427, 13, 1, 0, 0, 0, 428, 432, 5, 135, 0, 0, 429, 433, 3, 16, 8, 0, 430, 431, 5, 479, 0, 0, 431, 433, 5, 146, 0, 0, 432, 429, 1, 0, 0, 0, 432, 430, 1, 0, 0, 0, 432, 433, 1, 0, 0, 0, 433, 437, 1, 0, 0, 0, 434, 438, 3, 10, 5, 0, 435, 438, 3, 144, 72, 0, 436, 438, 3, 154, 77, 0, 437, 434, 1, 0, 0, 0, 437, 435, 1, 0, 0, 0, 437, 436, 1, 0, 0, 0, 438, 15, 1, 0, 0, 0, 439, 444, 3, 18, 9, 0, 440, 441, 5, 520, 0, 0, 441, 443, 3, 18, 9, 0, 442, 440, 1, 0, 0, 0, 443, 446, 1, 0, 0, 0, 444, 442, 1, 0, 0, 0, 444, 445, 1, 0, 0, 0, 445, 17, 1, 0, 0, 0, 446, 444, 1, 0, 0, 0, 447, 448, 7, 1, 0, 0, 448, 19, 1, 0, 0, 0, 449, 450, 5, 410, 0, 0, 450, 451, 5, 441, 0, 0, 451, 456, 3, 310, 155, 0, 452, 453, 5, 410, 0, 0, 453, 456, 3, 314, 157, 0, 454, 456, 3, 22, 11, 0, 455, 449, 1, 0, 0, 0, 455, 452, 1, 0, 0, 0, 455, 454, 1, 0, 0, 0, 456, 21, 1, 0, 0, 0, 457, 458, 5, 410, 0, 0, 458, 459, 5, 227, 0, 0, 459, 464, 3, 326, 163, 0, 460, 461, 5, 520, 0, 0, 461, 463, 3, 326, 163, 0, 462, 460, 1, 0, 0, 0, 463, 466, 1, 0, 0, 0, 464, 462, 1, 0, 0, 0, 464, 465, 1, 0, 0, 0, 465, 23, 1, 0, 0, 0, 466, 464, 1, 0, 0, 0, 467, 468, 5, 341, 0, 0, 468, 510, 7, 2, 0, 0, 469, 470, 5, 341, 0, 0, 470, 471, 5, 76, 0, 0, 471, 510, 7, 3, 0, 0, 472, 473, 5, 341, 0, 0, 473, 476, 5, 374, 0, 0, 474, 475, 7, 4, 0, 0, 475, 477, 3, 314, 157, 0, 476, 474, 1, 0, 0, 0, 476, 477, 1, 0, 0, 0, 477, 479, 1, 0, 0, 0, 478, 480, 3, 262, 131, 0, 479, 478, 1, 0, 0, 0, 479, 480, 1, 0, 0, 0, 480, 510, 1, 0, 0, 0, 481, 482, 5, 341, 0, 0, 482, 483, 5, 58, 0, 0, 483, 486, 7, 4, 0, 0, 484, 487, 3, 322, 161, 0, 485, 487, 3, 320, 160, 0, 486, 484, 1, 0, 0, 0, 486, 485, 1, 0, 0, 0, 487, 489, 1, 0, 0, 0, 488, 490, 3, 262, 131, 0, 489, 488, 1, 0, 0, 0, 489, 490, 1, 0, 0, 0, 490, 510, 1, 0, 0, 0, 491, 492, 5, 341, 0, 0, 492, 497, 5, 72, 0, 0, 493, 494, 5, 373, 0, 0, 494, 498, 3, 320, 160, 0, 495, 496, 5, 501, 0, 0, 496, 498, 3, 322, 161, 0, 497, 493, 1, 0, 0, 0, 497, 495, 1, 0, 0, 0, 498, 510, 1, 0, 0, 0, 499, 501, 5, 341, 0, 0, 500, 502, 5, 411, 0, 0, 501, 500, 1, 0, 0, 0, 501, 502, 1, 0, 0, 0, 502, 503, 1, 0, 0, 0, 503, 510, 5, 154, 0, 0, 504, 506, 5, 341, 0, 0, 505, 507, 5, 152, 0, 0, 506, 505, 1, 0, 0, 0, 506, 507, 1, 0, 0, 0, 507, 508, 1, 0, 0, 0, 508, 510, 5, 227, 0, 0, 509, 467, 1, 0, 0, 0, 509, 469, 1, 0, 0, 0, 509, 472, 1, 0, 0, 0, 509, 481, 1, 0, 0, 0, 509, 491, 1, 0, 0, 0, 509, 499, 1, 0, 0, 0, 509, 504, 1, 0, 0, 0, 510, 25, 1, 0, 0, 0, 511, 512, 5, 468, 0, 0, 512, 513, 5, 226, 0, 0, 513, 516, 3, 326, 163, 0, 514, 515, 5, 433, 0, 0, 515, 517, 3, 334, 167, 0, 516, 514, 1, 0, 0, 0, 516, 517, 1, 0, 0, 0, 517, 27, 1, 0, 0, 0, 518, 519, 5, 500, 0, 0, 519, 520, 5, 226, 0, 0, 520, 521, 3, 326, 163, 0, 521, 29, 1, 0, 0, 0, 522, 524, 5, 340, 0, 0, 523, 525, 3, 336, 168, 0, 524, 523, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525, 31, 1, 0, 0, 0, 526, 528, 5, 312, 0, 0, 527, 529, 3, 338, 169, 0, 528, 527, 1, 0, 0, 0, 528, 529, 1, 0, 0, 0, 529, 33, 1, 0, 0, 0, 530, 531, 7, 5, 0, 0, 531, 532, 5, 463, 0, 0, 532, 533, 3, 110, 55, 0, 533, 35, 1, 0, 0, 0, 534, 535, 5, 437, 0, 0, 535, 536, 5, 463, 0, 0, 536, 537, 5, 433, 0, 0, 537, 540, 3, 38, 19, 0, 538, 539, 5, 17, 0, 0, 539, 541, 3, 326, 163, 0, 540, 538, 1, 0, 0, 0, 540, 541, 1, 0, 0, 0, 541, 585, 1, 0, 0, 0, 542, 543, 5, 437, 0, 0, 543, 544, 5, 456, 0, 0, 544, 545, 5, 433, 0, 0, 545, 548, 3, 38, 19, 0, 546, 547, 5, 17, 0, 0, 547, 549, 3, 326, 163, 0, 548, 546, 1, 0, 0, 0, 548, 549, 1, 0, 0, 0, 549, 552, 1, 0, 0, 0, 550, 551, 5, 311, 0, 0, 551, 553, 3, 326, 163, 0, 552, 550, 1, 0, 0, 0, 552, 553, 1, 0, 0, 0, 553, 585, 1, 0, 0, 0, 554, 555, 5, 437, 0, 0, 555, 556, 7, 6, 0, 0, 556, 557, 5, 433, 0, 0, 557, 558, 3, 38, 19, 0, 558, 559, 5, 311, 0, 0, 559, 560, 3, 326, 163, 0, 560, 585, 1, 0, 0, 0, 561, 562, 5, 437, 0, 0, 562, 563, 5, 486, 0, 0, 563, 585, 3, 38, 19, 0, 564, 565, 5, 437, 0, 0, 565, 566, 5, 453, 0, 0, 566, 567, 5, 456, 0, 0, 567, 568, 5, 433, 0, 0, 568, 569, 3, 38, 19, 0, 569, 570, 5, 311, 0, 0, 570, 571, 3, 326, 163, 0, 571, 572, 5, 466, 0, 0, 572, 573, 3, 326, 163, 0, 573, 585, 1, 0, 0, 0, 574, 575, 5, 437, 0, 0, 575, 576, 5, 443, 0, 0, 576, 577, 5, 456, 0, 0, 577, 578, 5, 433, 0, 0, 578, 579, 3, 38, 19, 0, 579, 580, 5, 146, 0, 0, 580, 581, 3, 326, 163, 0, 581, 582, 5, 17, 0, 0, 582, 583, 3, 326, 163, 0, 583, 585, 1, 0, 0, 0, 584, 534, 1, 0, 0, 0, 584, 542, 1, 0, 0, 0, 584, 554, 1, 0, 0, 0, 584, 561, 1, 0, 0, 0, 584, 564, 1, 0, 0, 0, 584, 574, 1, 0, 0, 0, 585, 37, 1, 0, 0, 0, 586, 588, 5, 534, 0, 0, 587, 586, 1, 0, 0, 0, 587, 588, 1, 0, 0, 0, 588, 589, 1, 0, 0, 0, 589, 591, 3, 326, 163, 0, 590, 587, 1, 0, 0, 0, 591, 592, 1, 0, 0, 0, 592, 590, 1, 0, 0, 0, 592, 593, 1, 0, 0, 0, 593, 39, 1, 0, 0, 0, 594, 597, 3, 42, 21, 0, 595, 597, 3, 44, 22, 0, 596, 594, 1, 0, 0, 0, 596, 595, 1, 0, 0, 0, 597, 41, 1, 0, 0, 0, 598, 600, 5, 72, 0, 0, 599, 601, 5, 497, 0, 0, 600, 599, 1, 0, 0, 0, 600, 601, 1, 0, 0, 0, 601, 602, 1, 0, 0, 0, 602, 604, 5, 373, 0, 0, 603, 605, 3, 330, 165, 0, 604, 603, 1, 0, 0, 0, 604, 605, 1, 0, 0, 0, 605, 606, 1, 0, 0, 0, 606, 607, 3, 318, 159, 0, 607, 608, 5, 516, 0, 0, 608, 613, 3, 46, 23, 0, 609, 610, 5, 520, 0, 0, 610, 612, 3, 46, 23, 0, 611, 609, 1, 0, 0, 0, 612, 615, 1, 0, 0, 0, 613, 611, 1, 0, 0, 0, 613, 614, 1, 0, 0, 0, 614, 618, 1, 0, 0, 0, 615, 613, 1, 0, 0, 0, 616, 617, 5, 520, 0, 0, 617, 619, 3, 80, 40, 0, 618, 616, 1, 0, 0, 0, 618, 619, 1, 0, 0, 0, 619, 622, 1, 0, 0, 0, 620, 621, 5, 520, 0, 0, 621, 623, 3, 82, 41, 0, 622, 620, 1, 0, 0, 0, 622, 623, 1, 0, 0, 0, 623, 626, 1, 0, 0, 0, 624, 625, 5, 520, 0, 0, 625, 627, 3, 86, 43, 0, 626, 624, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 628, 1, 0, 0, 0, 628, 631, 5, 517, 0, 0, 629, 630, 5, 59, 0, 0, 630, 632, 5, 537, 0, 0, 631, 629, 1, 0, 0, 0, 631, 632, 1, 0, 0, 0, 632, 634, 1, 0, 0, 0, 633, 635, 3, 88, 44, 0, 634, 633, 1, 0, 0, 0, 634, 635, 1, 0, 0, 0, 635, 636, 1, 0, 0, 0, 636, 638, 3, 328, 164, 0, 637, 639, 3, 96, 48, 0, 638, 637, 1, 0, 0, 0, 638, 639, 1, 0, 0, 0, 639, 43, 1, 0, 0, 0, 640, 641, 5, 72, 0, 0, 641, 643, 5, 373, 0, 0, 642, 644, 3, 330, 165, 0, 643, 642, 1, 0, 0, 0, 643, 644, 1, 0, 0, 0, 644, 645, 1, 0, 0, 0, 645, 646, 3, 318, 159, 0, 646, 649, 3, 328, 164, 0, 647, 648, 5, 17, 0, 0, 648, 650, 3, 156, 78, 0, 649, 647, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 45, 1, 0, 0, 0, 651, 655, 3, 48, 24, 0, 652, 655, 3, 72, 36, 0, 653, 655, 3, 76, 38, 0, 654, 651, 1, 0, 0, 0, 654, 652, 1, 0, 0, 0, 654, 653, 1, 0, 0, 0, 655, 47, 1, 0, 0, 0, 656, 657, 3, 50, 25, 0, 657, 659, 3, 56, 28, 0, 658, 660, 3, 70, 35, 0, 659, 658, 1, 0, 0, 0, 659, 660, 1, 0, 0, 0, 660, 663, 1, 0, 0, 0, 661, 662, 5, 59, 0, 0, 662, 664, 5, 537, 0, 0, 663, 661, 1, 0, 0, 0, 663, 664, 1, 0, 0, 0, 664, 49, 1, 0, 0, 0, 665, 668, 3, 326, 163, 0, 666, 668, 3, 256, 128, 0, 667, 665, 1, 0, 0, 0, 667, 666, 1, 0, 0, 0, 668, 51, 1, 0, 0, 0, 669, 672, 3, 326, 163, 0, 670, 672, 4, 26, 0, 0, 671, 669, 1, 0, 0, 0, 671, 670, 1, 0, 0, 0, 672, 53, 1, 0, 0, 0, 673, 674, 5, 516, 0, 0, 674, 679, 3, 52, 26, 0, 675, 676, 5, 520, 0, 0, 676, 678, 3, 52, 26, 0, 677, 675, 1, 0, 0, 0, 678, 681, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 679, 680, 1, 0, 0, 0, 680, 682, 1, 0, 0, 0, 681, 679, 1, 0, 0, 0, 682, 683, 5, 517, 0, 0, 683, 55, 1, 0, 0, 0, 684, 722, 7, 7, 0, 0, 685, 687, 7, 8, 0, 0, 686, 688, 3, 58, 29, 0, 687, 686, 1, 0, 0, 0, 687, 688, 1, 0, 0, 0, 688, 722, 1, 0, 0, 0, 689, 691, 5, 379, 0, 0, 690, 692, 3, 58, 29, 0, 691, 690, 1, 0, 0, 0, 691, 692, 1, 0, 0, 0, 692, 699, 1, 0, 0, 0, 693, 695, 7, 9, 0, 0, 694, 696, 5, 206, 0, 0, 695, 694, 1, 0, 0, 0, 695, 696, 1, 0, 0, 0, 696, 697, 1, 0, 0, 0, 697, 698, 5, 378, 0, 0, 698, 700, 5, 504, 0, 0, 699, 693, 1, 0, 0, 0, 699, 700, 1, 0, 0, 0, 700, 722, 1, 0, 0, 0, 701, 703, 7, 10, 0, 0, 702, 704, 3, 60, 30, 0, 703, 702, 1, 0, 0, 0, 703, 704, 1, 0, 0, 0, 704, 722, 1, 0, 0, 0, 705, 707, 7, 11, 0, 0, 706, 708, 3, 64, 32, 0, 707, 706, 1, 0, 0, 0, 707, 708, 1, 0, 0, 0, 708, 722, 1, 0, 0, 0, 709, 711, 5, 469, 0, 0, 710, 712, 3, 66, 33, 0, 711, 710, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 722, 1, 0, 0, 0, 713, 715, 5, 321, 0, 0, 714, 716, 3, 68, 34, 0, 715, 714, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 722, 1, 0, 0, 0, 717, 719, 5, 294, 0, 0, 718, 720, 3, 62, 31, 0, 719, 718, 1, 0, 0, 0, 719, 720, 1, 0, 0, 0, 720, 722, 1, 0, 0, 0, 721, 684, 1, 0, 0, 0, 721, 685, 1, 0, 0, 0, 721, 689, 1, 0, 0, 0, 721, 701, 1, 0, 0, 0, 721, 705, 1, 0, 0, 0, 721, 709, 1, 0, 0, 0, 721, 713, 1, 0, 0, 0, 721, 717, 1, 0, 0, 0, 722, 57, 1, 0, 0, 0, 723, 724, 5, 516, 0, 0, 724, 725, 3, 358, 179, 0, 725, 726, 5, 517, 0, 0, 726, 59, 1, 0, 0, 0, 727, 728, 5, 516, 0, 0, 728, 731, 3, 358, 179, 0, 729, 730, 5, 520, 0, 0, 730, 732, 3, 358, 179, 0, 731, 729, 1, 0, 0, 0, 731, 732, 1, 0, 0, 0, 732, 733, 1, 0, 0, 0, 733, 734, 5, 517, 0, 0, 734, 61, 1, 0, 0, 0, 735, 736, 5, 516, 0, 0, 736, 739, 3, 356, 178, 0, 737, 738, 5, 520, 0, 0, 738, 740, 3, 356, 178, 0, 739, 737, 1, 0, 0, 0, 739, 740, 1, 0, 0, 0, 740, 741, 1, 0, 0, 0, 741, 742, 5, 517, 0, 0, 742, 63, 1, 0, 0, 0, 743, 744, 5, 507, 0, 0, 744, 745, 3, 56, 28, 0, 745, 746, 5, 506, 0, 0, 746, 65, 1, 0, 0, 0, 747, 748, 5, 507, 0, 0, 748, 749, 3, 56, 28, 0, 749, 750, 5, 520, 0, 0, 750, 751, 3, 56, 28, 0, 751, 752, 1, 0, 0, 0, 752, 753, 5, 506, 0, 0, 753, 67, 1, 0, 0, 0, 754, 755, 5, 507, 0, 0, 755, 756, 3, 52, 26, 0, 756, 763, 3, 56, 28, 0, 757, 758, 5, 520, 0, 0, 758, 759, 3, 52, 26, 0, 759, 760, 3, 56, 28, 0, 760, 762, 1, 0, 0, 0, 761, 757, 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, 767, 5, 506, 0, 0, 767, 69, 1, 0, 0, 0, 768, 769, 5, 64, 0, 0, 769, 771, 3, 84, 42, 0, 770, 768, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, 771, 772, 1, 0, 0, 0, 772, 773, 5, 288, 0, 0, 773, 776, 5, 466, 0, 0, 774, 775, 5, 241, 0, 0, 775, 777, 5, 125, 0, 0, 776, 774, 1, 0, 0, 0, 776, 777, 1, 0, 0, 0, 777, 783, 1, 0, 0, 0, 778, 780, 5, 241, 0, 0, 779, 778, 1, 0, 0, 0, 779, 780, 1, 0, 0, 0, 780, 781, 1, 0, 0, 0, 781, 783, 5, 244, 0, 0, 782, 770, 1, 0, 0, 0, 782, 779, 1, 0, 0, 0, 783, 71, 1, 0, 0, 0, 784, 785, 3, 50, 25, 0, 785, 786, 3, 56, 28, 0, 786, 789, 5, 218, 0, 0, 787, 788, 5, 151, 0, 0, 788, 790, 3, 74, 37, 0, 789, 787, 1, 0, 0, 0, 789, 790, 1, 0, 0, 0, 790, 792, 1, 0, 0, 0, 791, 793, 5, 423, 0, 0, 792, 791, 1, 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 73, 1, 0, 0, 0, 794, 795, 5, 537, 0, 0, 795, 75, 1, 0, 0, 0, 796, 797, 3, 50, 25, 0, 797, 798, 5, 17, 0, 0, 798, 801, 3, 78, 39, 0, 799, 800, 5, 59, 0, 0, 800, 802, 5, 537, 0, 0, 801, 799, 1, 0, 0, 0, 801, 802, 1, 0, 0, 0, 802, 77, 1, 0, 0, 0, 803, 804, 3, 256, 128, 0, 804, 79, 1, 0, 0, 0, 805, 806, 5, 424, 0, 0, 806, 807, 5, 146, 0, 0, 807, 808, 3, 52, 26, 0, 808, 809, 5, 17, 0, 0, 809, 810, 3, 256, 128, 0, 810, 81, 1, 0, 0, 0, 811, 812, 5, 64, 0, 0, 812, 814, 3, 84, 42, 0, 813, 811, 1, 0, 0, 0, 813, 814, 1, 0, 0, 0, 814, 815, 1, 0, 0, 0, 815, 816, 5, 288, 0, 0, 816, 817, 5, 466, 0, 0, 817, 818, 3, 54, 27, 0, 818, 819, 5, 241, 0, 0, 819, 820, 5, 125, 0, 0, 820, 83, 1, 0, 0, 0, 821, 822, 3, 302, 151, 0, 822, 85, 1, 0, 0, 0, 823, 824, 5, 277, 0, 0, 824, 825, 5, 146, 0, 0, 825, 826, 5, 371, 0, 0, 826, 87, 1, 0, 0, 0, 827, 828, 5, 269, 0, 0, 828, 829, 5, 34, 0, 0, 829, 830, 3, 90, 45, 0, 830, 89, 1, 0, 0, 0, 831, 832, 5, 516, 0, 0, 832, 837, 3, 92, 46, 0, 833, 834, 5, 520, 0, 0, 834, 836, 3, 92, 46, 0, 835, 833, 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, 841, 5, 517, 0, 0, 841, 91, 1, 0, 0, 0, 842, 855, 3, 52, 26, 0, 843, 844, 5, 516, 0, 0, 844, 849, 3, 94, 47, 0, 845, 846, 5, 520, 0, 0, 846, 848, 3, 94, 47, 0, 847, 845, 1, 0, 0, 0, 848, 851, 1, 0, 0, 0, 849, 847, 1, 0, 0, 0, 849, 850, 1, 0, 0, 0, 850, 852, 1, 0, 0, 0, 851, 849, 1, 0, 0, 0, 852, 853, 5, 517, 0, 0, 853, 855, 1, 0, 0, 0, 854, 842, 1, 0, 0, 0, 854, 843, 1, 0, 0, 0, 855, 93, 1, 0, 0, 0, 856, 859, 3, 278, 139, 0, 857, 859, 3, 352, 176, 0, 858, 856, 1, 0, 0, 0, 858, 857, 1, 0, 0, 0, 859, 95, 1, 0, 0, 0, 860, 861, 5, 202, 0, 0, 861, 870, 3, 320, 160, 0, 862, 866, 5, 516, 0, 0, 863, 865, 3, 98, 49, 0, 864, 863, 1, 0, 0, 0, 865, 868, 1, 0, 0, 0, 866, 864, 1, 0, 0, 0, 866, 867, 1, 0, 0, 0, 867, 869, 1, 0, 0, 0, 868, 866, 1, 0, 0, 0, 869, 871, 5, 517, 0, 0, 870, 862, 1, 0, 0, 0, 870, 871, 1, 0, 0, 0, 871, 97, 1, 0, 0, 0, 872, 873, 7, 12, 0, 0, 873, 877, 7, 13, 0, 0, 874, 875, 7, 14, 0, 0, 875, 877, 7, 15, 0, 0, 876, 872, 1, 0, 0, 0, 876, 874, 1, 0, 0, 0, 877, 99, 1, 0, 0, 0, 878, 879, 5, 72, 0, 0, 879, 880, 5, 441, 0, 0, 880, 881, 3, 312, 156, 0, 881, 882, 3, 328, 164, 0, 882, 101, 1, 0, 0, 0, 883, 884, 5, 72, 0, 0, 884, 886, 5, 447, 0, 0, 885, 887, 3, 330, 165, 0, 886, 885, 1, 0, 0, 0, 886, 887, 1, 0, 0, 0, 887, 888, 1, 0, 0, 0, 888, 891, 3, 316, 158, 0, 889, 890, 5, 59, 0, 0, 890, 892, 5, 537, 0, 0, 891, 889, 1, 0, 0, 0, 891, 892, 1, 0, 0, 0, 892, 893, 1, 0, 0, 0, 893, 894, 3, 328, 164, 0, 894, 103, 1, 0, 0, 0, 895, 897, 5, 72, 0, 0, 896, 898, 5, 497, 0, 0, 897, 896, 1, 0, 0, 0, 897, 898, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 901, 5, 501, 0, 0, 900, 902, 3, 330, 165, 0, 901, 900, 1, 0, 0, 0, 901, 902, 1, 0, 0, 0, 902, 903, 1, 0, 0, 0, 903, 905, 3, 324, 162, 0, 904, 906, 3, 54, 27, 0, 905, 904, 1, 0, 0, 0, 905, 906, 1, 0, 0, 0, 906, 909, 1, 0, 0, 0, 907, 908, 5, 59, 0, 0, 908, 910, 5, 537, 0, 0, 909, 907, 1, 0, 0, 0, 909, 910, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 912, 5, 17, 0, 0, 912, 913, 3, 156, 78, 0, 913, 105, 1, 0, 0, 0, 914, 918, 5, 72, 0, 0, 915, 919, 5, 497, 0, 0, 916, 917, 5, 497, 0, 0, 917, 919, 5, 370, 0, 0, 918, 915, 1, 0, 0, 0, 918, 916, 1, 0, 0, 0, 918, 919, 1, 0, 0, 0, 919, 920, 1, 0, 0, 0, 920, 922, 5, 153, 0, 0, 921, 923, 3, 330, 165, 0, 922, 921, 1, 0, 0, 0, 922, 923, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 925, 3, 268, 134, 0, 925, 926, 5, 17, 0, 0, 926, 929, 3, 302, 151, 0, 927, 928, 5, 195, 0, 0, 928, 930, 7, 16, 0, 0, 929, 927, 1, 0, 0, 0, 929, 930, 1, 0, 0, 0, 930, 932, 1, 0, 0, 0, 931, 933, 3, 108, 54, 0, 932, 931, 1, 0, 0, 0, 932, 933, 1, 0, 0, 0, 933, 107, 1, 0, 0, 0, 934, 935, 5, 412, 0, 0, 935, 936, 5, 463, 0, 0, 936, 942, 3, 110, 55, 0, 937, 938, 5, 520, 0, 0, 938, 939, 5, 463, 0, 0, 939, 941, 3, 110, 55, 0, 940, 937, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 940, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 109, 1, 0, 0, 0, 944, 942, 1, 0, 0, 0, 945, 946, 5, 537, 0, 0, 946, 111, 1, 0, 0, 0, 947, 948, 5, 8, 0, 0, 948, 950, 5, 373, 0, 0, 949, 951, 3, 332, 166, 0, 950, 949, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 958, 3, 320, 160, 0, 953, 959, 3, 114, 57, 0, 954, 959, 3, 116, 58, 0, 955, 959, 3, 118, 59, 0, 956, 959, 3, 120, 60, 0, 957, 959, 3, 122, 61, 0, 958, 953, 1, 0, 0, 0, 958, 954, 1, 0, 0, 0, 958, 955, 1, 0, 0, 0, 958, 956, 1, 0, 0, 0, 958, 957, 1, 0, 0, 0, 959, 113, 1, 0, 0, 0, 960, 962, 5, 311, 0, 0, 961, 963, 3, 326, 163, 0, 962, 961, 1, 0, 0, 0, 962, 963, 1, 0, 0, 0, 963, 964, 1, 0, 0, 0, 964, 965, 5, 388, 0, 0, 965, 966, 3, 326, 163, 0, 966, 115, 1, 0, 0, 0, 967, 968, 5, 340, 0, 0, 968, 969, 3, 334, 167, 0, 969, 117, 1, 0, 0, 0, 970, 971, 5, 437, 0, 0, 971, 972, 5, 64, 0, 0, 972, 973, 3, 84, 42, 0, 973, 974, 5, 288, 0, 0, 974, 975, 5, 466, 0, 0, 975, 977, 3, 54, 27, 0, 976, 978, 3, 124, 62, 0, 977, 976, 1, 0, 0, 0, 977, 978, 1, 0, 0, 0, 978, 119, 1, 0, 0, 0, 979, 980, 5, 116, 0, 0, 980, 981, 5, 64, 0, 0, 981, 982, 3, 84, 42, 0, 982, 121, 1, 0, 0, 0, 983, 984, 5, 437, 0, 0, 984, 985, 5, 403, 0, 0, 985, 986, 3, 54, 27, 0, 986, 123, 1, 0, 0, 0, 987, 988, 5, 241, 0, 0, 988, 989, 5, 125, 0, 0, 989, 125, 1, 0, 0, 0, 990, 991, 5, 8, 0, 0, 991, 992, 5, 501, 0, 0, 992, 996, 3, 322, 161, 0, 993, 997, 3, 114, 57, 0, 994, 995, 5, 17, 0, 0, 995, 997, 3, 156, 78, 0, 996, 993, 1, 0, 0, 0, 996, 994, 1, 0, 0, 0, 997, 127, 1, 0, 0, 0, 998, 999, 5, 8, 0, 0, 999, 1000, 5, 447, 0, 0, 1000, 1001, 3, 314, 157, 0, 1001, 1002, 3, 116, 58, 0, 1002, 129, 1, 0, 0, 0, 1003, 1007, 5, 8, 0, 0, 1004, 1008, 5, 497, 0, 0, 1005, 1006, 5, 497, 0, 0, 1006, 1008, 5, 370, 0, 0, 1007, 1004, 1, 0, 0, 0, 1007, 1005, 1, 0, 0, 0, 1007, 1008, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1011, 5, 153, 0, 0, 1010, 1012, 3, 332, 166, 0, 1011, 1010, 1, 0, 0, 0, 1011, 1012, 1, 0, 0, 0, 1012, 1013, 1, 0, 0, 0, 1013, 1014, 3, 270, 135, 0, 1014, 1015, 5, 17, 0, 0, 1015, 1018, 3, 302, 151, 0, 1016, 1017, 5, 195, 0, 0, 1017, 1019, 7, 16, 0, 0, 1018, 1016, 1, 0, 0, 0, 1018, 1019, 1, 0, 0, 0, 1019, 131, 1, 0, 0, 0, 1020, 1021, 5, 116, 0, 0, 1021, 1023, 5, 441, 0, 0, 1022, 1024, 3, 332, 166, 0, 1023, 1022, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1026, 3, 310, 155, 0, 1026, 133, 1, 0, 0, 0, 1027, 1029, 5, 116, 0, 0, 1028, 1030, 5, 497, 0, 0, 1029, 1028, 1, 0, 0, 0, 1029, 1030, 1, 0, 0, 0, 1030, 1031, 1, 0, 0, 0, 1031, 1033, 5, 373, 0, 0, 1032, 1034, 3, 332, 166, 0, 1033, 1032, 1, 0, 0, 0, 1033, 1034, 1, 0, 0, 0, 1034, 1035, 1, 0, 0, 0, 1035, 1036, 3, 320, 160, 0, 1036, 135, 1, 0, 0, 0, 1037, 1038, 5, 116, 0, 0, 1038, 1040, 5, 447, 0, 0, 1039, 1041, 3, 332, 166, 0, 1040, 1039, 1, 0, 0, 0, 1040, 1041, 1, 0, 0, 0, 1041, 1042, 1, 0, 0, 0, 1042, 1044, 3, 314, 157, 0, 1043, 1045, 7, 17, 0, 0, 1044, 1043, 1, 0, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 137, 1, 0, 0, 0, 1046, 1048, 5, 116, 0, 0, 1047, 1049, 5, 497, 0, 0, 1048, 1047, 1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1050, 1, 0, 0, 0, 1050, 1052, 5, 501, 0, 0, 1051, 1053, 3, 332, 166, 0, 1052, 1051, 1, 0, 0, 0, 1052, 1053, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1054, 1055, 3, 322, 161, 0, 1055, 139, 1, 0, 0, 0, 1056, 1060, 5, 116, 0, 0, 1057, 1061, 5, 497, 0, 0, 1058, 1059, 5, 497, 0, 0, 1059, 1061, 5, 370, 0, 0, 1060, 1057, 1, 0, 0, 0, 1060, 1058, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 1062, 1, 0, 0, 0, 1062, 1064, 5, 153, 0, 0, 1063, 1065, 3, 332, 166, 0, 1064, 1063, 1, 0, 0, 0, 1064, 1065, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1067, 3, 270, 135, 0, 1067, 141, 1, 0, 0, 0, 1068, 1070, 5, 132, 0, 0, 1069, 1068, 1, 0, 0, 0, 1069, 1070, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1076, 3, 144, 72, 0, 1072, 1076, 3, 152, 76, 0, 1073, 1074, 5, 132, 0, 0, 1074, 1076, 3, 154, 77, 0, 1075, 1069, 1, 0, 0, 0, 1075, 1072, 1, 0, 0, 0, 1075, 1073, 1, 0, 0, 0, 1076, 143, 1, 0, 0, 0, 1077, 1078, 5, 177, 0, 0, 1078, 1079, 7, 18, 0, 0, 1079, 1088, 3, 320, 160, 0, 1080, 1082, 3, 146, 73, 0, 1081, 1080, 1, 0, 0, 0, 1081, 1082, 1, 0, 0, 0, 1082, 1084, 1, 0, 0, 0, 1083, 1085, 3, 54, 27, 0, 1084, 1083, 1, 0, 0, 0, 1084, 1085, 1, 0, 0, 0, 1085, 1086, 1, 0, 0, 0, 1086, 1089, 3, 156, 78, 0, 1087, 1089, 3, 148, 74, 0, 1088, 1081, 1, 0, 0, 0, 1088, 1087, 1, 0, 0, 0, 1089, 145, 1, 0, 0, 0, 1090, 1091, 5, 268, 0, 0, 1091, 1092, 3, 334, 167, 0, 1092, 147, 1, 0, 0, 0, 1093, 1094, 5, 414, 0, 0, 1094, 1099, 3, 150, 75, 0, 1095, 1096, 5, 520, 0, 0, 1096, 1098, 3, 150, 75, 0, 1097, 1095, 1, 0, 0, 0, 1098, 1101, 1, 0, 0, 0, 1099, 1097, 1, 0, 0, 0, 1099, 1100, 1, 0, 0, 0, 1100, 149, 1, 0, 0, 0, 1101, 1099, 1, 0, 0, 0, 1102, 1103, 5, 516, 0, 0, 1103, 1108, 3, 352, 176, 0, 1104, 1105, 5, 520, 0, 0, 1105, 1107, 3, 352, 176, 0, 1106, 1104, 1, 0, 0, 0, 1107, 1110, 1, 0, 0, 0, 1108, 1106, 1, 0, 0, 0, 1108, 1109, 1, 0, 0, 0, 1109, 1111, 1, 0, 0, 0, 1110, 1108, 1, 0, 0, 0, 1111, 1112, 5, 517, 0, 0, 1112, 151, 1, 0, 0, 0, 1113, 1114, 5, 24, 0, 0, 1114, 1115, 5, 354, 0, 0, 1115, 1116, 5, 340, 0, 0, 1116, 1120, 5, 521, 0, 0, 1117, 1118, 3, 144, 72, 0, 1118, 1119, 5, 521, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1117, 1, 0, 0, 0, 1121, 1122, 1, 0, 0, 0, 1122, 1120, 1, 0, 0, 0, 1122, 1123, 1, 0, 0, 0, 1123, 1124, 1, 0, 0, 0, 1124, 1125, 5, 122, 0, 0, 1125, 153, 1, 0, 0, 0, 1126, 1127, 5, 354, 0, 0, 1127, 1128, 5, 340, 0, 0, 1128, 1132, 5, 24, 0, 0, 1129, 1130, 3, 144, 72, 0, 1130, 1131, 5, 521, 0, 0, 1131, 1133, 1, 0, 0, 0, 1132, 1129, 1, 0, 0, 0, 1133, 1134, 1, 0, 0, 0, 1134, 1132, 1, 0, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1137, 5, 122, 0, 0, 1137, 155, 1, 0, 0, 0, 1138, 1139, 6, 78, -1, 0, 1139, 1162, 3, 158, 79, 0, 1140, 1141, 3, 160, 80, 0, 1141, 1142, 3, 156, 78, 5, 1142, 1162, 1, 0, 0, 0, 1143, 1144, 5, 516, 0, 0, 1144, 1145, 3, 156, 78, 0, 1145, 1146, 5, 517, 0, 0, 1146, 1162, 1, 0, 0, 0, 1147, 1149, 3, 168, 84, 0, 1148, 1150, 3, 228, 114, 0, 1149, 1148, 1, 0, 0, 0, 1149, 1150, 1, 0, 0, 0, 1150, 1152, 1, 0, 0, 0, 1151, 1153, 3, 232, 116, 0, 1152, 1151, 1, 0, 0, 0, 1152, 1153, 1, 0, 0, 0, 1153, 1162, 1, 0, 0, 0, 1154, 1156, 3, 166, 83, 0, 1155, 1157, 3, 228, 114, 0, 1156, 1155, 1, 0, 0, 0, 1156, 1157, 1, 0, 0, 0, 1157, 1159, 1, 0, 0, 0, 1158, 1160, 3, 232, 116, 0, 1159, 1158, 1, 0, 0, 0, 1159, 1160, 1, 0, 0, 0, 1160, 1162, 1, 0, 0, 0, 1161, 1138, 1, 0, 0, 0, 1161, 1140, 1, 0, 0, 0, 1161, 1143, 1, 0, 0, 0, 1161, 1147, 1, 0, 0, 0, 1161, 1154, 1, 0, 0, 0, 1162, 1177, 1, 0, 0, 0, 1163, 1164, 10, 3, 0, 0, 1164, 1166, 7, 19, 0, 0, 1165, 1167, 5, 5, 0, 0, 1166, 1165, 1, 0, 0, 0, 1166, 1167, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1170, 3, 156, 78, 0, 1169, 1171, 3, 228, 114, 0, 1170, 1169, 1, 0, 0, 0, 1170, 1171, 1, 0, 0, 0, 1171, 1173, 1, 0, 0, 0, 1172, 1174, 3, 232, 116, 0, 1173, 1172, 1, 0, 0, 0, 1173, 1174, 1, 0, 0, 0, 1174, 1176, 1, 0, 0, 0, 1175, 1163, 1, 0, 0, 0, 1176, 1179, 1, 0, 0, 0, 1177, 1175, 1, 0, 0, 0, 1177, 1178, 1, 0, 0, 0, 1178, 157, 1, 0, 0, 0, 1179, 1177, 1, 0, 0, 0, 1180, 1181, 5, 414, 0, 0, 1181, 1186, 3, 256, 128, 0, 1182, 1183, 5, 520, 0, 0, 1183, 1185, 3, 256, 128, 0, 1184, 1182, 1, 0, 0, 0, 1185, 1188, 1, 0, 0, 0, 1186, 1184, 1, 0, 0, 0, 1186, 1187, 1, 0, 0, 0, 1187, 159, 1, 0, 0, 0, 1188, 1186, 1, 0, 0, 0, 1189, 1190, 5, 433, 0, 0, 1190, 1195, 3, 162, 81, 0, 1191, 1192, 5, 520, 0, 0, 1192, 1194, 3, 162, 81, 0, 1193, 1191, 1, 0, 0, 0, 1194, 1197, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 161, 1, 0, 0, 0, 1197, 1195, 1, 0, 0, 0, 1198, 1210, 3, 164, 82, 0, 1199, 1200, 5, 516, 0, 0, 1200, 1205, 3, 52, 26, 0, 1201, 1202, 5, 520, 0, 0, 1202, 1204, 3, 52, 26, 0, 1203, 1201, 1, 0, 0, 0, 1204, 1207, 1, 0, 0, 0, 1205, 1203, 1, 0, 0, 0, 1205, 1206, 1, 0, 0, 0, 1206, 1208, 1, 0, 0, 0, 1207, 1205, 1, 0, 0, 0, 1208, 1209, 5, 517, 0, 0, 1209, 1211, 1, 0, 0, 0, 1210, 1199, 1, 0, 0, 0, 1210, 1211, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1213, 5, 17, 0, 0, 1213, 1214, 5, 516, 0, 0, 1214, 1215, 3, 156, 78, 0, 1215, 1216, 5, 517, 0, 0, 1216, 163, 1, 0, 0, 0, 1217, 1218, 3, 302, 151, 0, 1218, 165, 1, 0, 0, 0, 1219, 1221, 3, 168, 84, 0, 1220, 1222, 3, 174, 87, 0, 1221, 1220, 1, 0, 0, 0, 1221, 1222, 1, 0, 0, 0, 1222, 1224, 1, 0, 0, 0, 1223, 1225, 3, 202, 101, 0, 1224, 1223, 1, 0, 0, 0, 1224, 1225, 1, 0, 0, 0, 1225, 1227, 1, 0, 0, 0, 1226, 1228, 3, 204, 102, 0, 1227, 1226, 1, 0, 0, 0, 1227, 1228, 1, 0, 0, 0, 1228, 1230, 1, 0, 0, 0, 1229, 1231, 3, 218, 109, 0, 1230, 1229, 1, 0, 0, 0, 1230, 1231, 1, 0, 0, 0, 1231, 1233, 1, 0, 0, 0, 1232, 1234, 3, 220, 110, 0, 1233, 1232, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1240, 1, 0, 0, 0, 1235, 1236, 3, 168, 84, 0, 1236, 1237, 3, 174, 87, 0, 1237, 1238, 3, 226, 113, 0, 1238, 1240, 1, 0, 0, 0, 1239, 1219, 1, 0, 0, 0, 1239, 1235, 1, 0, 0, 0, 1240, 167, 1, 0, 0, 0, 1241, 1243, 5, 336, 0, 0, 1242, 1244, 3, 362, 181, 0, 1243, 1242, 1, 0, 0, 0, 1243, 1244, 1, 0, 0, 0, 1244, 1254, 1, 0, 0, 0, 1245, 1255, 5, 527, 0, 0, 1246, 1251, 3, 170, 85, 0, 1247, 1248, 5, 520, 0, 0, 1248, 1250, 3, 170, 85, 0, 1249, 1247, 1, 0, 0, 0, 1250, 1253, 1, 0, 0, 0, 1251, 1249, 1, 0, 0, 0, 1251, 1252, 1, 0, 0, 0, 1252, 1255, 1, 0, 0, 0, 1253, 1251, 1, 0, 0, 0, 1254, 1245, 1, 0, 0, 0, 1254, 1246, 1, 0, 0, 0, 1255, 169, 1, 0, 0, 0, 1256, 1272, 3, 172, 86, 0, 1257, 1262, 3, 52, 26, 0, 1258, 1260, 5, 17, 0, 0, 1259, 1258, 1, 0, 0, 0, 1259, 1260, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 1263, 3, 256, 128, 0, 1262, 1259, 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 1272, 1, 0, 0, 0, 1264, 1269, 3, 256, 128, 0, 1265, 1267, 5, 17, 0, 0, 1266, 1265, 1, 0, 0, 0, 1266, 1267, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1270, 3, 52, 26, 0, 1269, 1266, 1, 0, 0, 0, 1269, 1270, 1, 0, 0, 0, 1270, 1272, 1, 0, 0, 0, 1271, 1256, 1, 0, 0, 0, 1271, 1257, 1, 0, 0, 0, 1271, 1264, 1, 0, 0, 0, 1272, 171, 1, 0, 0, 0, 1273, 1274, 3, 266, 133, 0, 1274, 1275, 5, 262, 0, 0, 1275, 1276, 3, 224, 112, 0, 1276, 1277, 5, 17, 0, 0, 1277, 1278, 3, 302, 151, 0, 1278, 1286, 1, 0, 0, 0, 1279, 1280, 3, 266, 133, 0, 1280, 1281, 5, 262, 0, 0, 1281, 1282, 3, 294, 147, 0, 1282, 1283, 5, 17, 0, 0, 1283, 1284, 3, 302, 151, 0, 1284, 1286, 1, 0, 0, 0, 1285, 1273, 1, 0, 0, 0, 1285, 1279, 1, 0, 0, 0, 1286, 173, 1, 0, 0, 0, 1287, 1288, 5, 151, 0, 0, 1288, 1289, 3, 176, 88, 0, 1289, 175, 1, 0, 0, 0, 1290, 1291, 6, 88, -1, 0, 1291, 1296, 3, 178, 89, 0, 1292, 1293, 5, 520, 0, 0, 1293, 1295, 3, 178, 89, 0, 1294, 1292, 1, 0, 0, 0, 1295, 1298, 1, 0, 0, 0, 1296, 1294, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 1302, 1, 0, 0, 0, 1298, 1296, 1, 0, 0, 0, 1299, 1302, 3, 186, 93, 0, 1300, 1302, 3, 188, 94, 0, 1301, 1290, 1, 0, 0, 0, 1301, 1299, 1, 0, 0, 0, 1301, 1300, 1, 0, 0, 0, 1302, 1324, 1, 0, 0, 0, 1303, 1304, 10, 3, 0, 0, 1304, 1305, 5, 73, 0, 0, 1305, 1306, 5, 185, 0, 0, 1306, 1323, 3, 176, 88, 4, 1307, 1309, 10, 4, 0, 0, 1308, 1310, 5, 233, 0, 0, 1309, 1308, 1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 1312, 1, 0, 0, 0, 1311, 1313, 7, 20, 0, 0, 1312, 1311, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1315, 1, 0, 0, 0, 1314, 1316, 5, 261, 0, 0, 1315, 1314, 1, 0, 0, 0, 1315, 1316, 1, 0, 0, 0, 1316, 1317, 1, 0, 0, 0, 1317, 1318, 5, 185, 0, 0, 1318, 1320, 3, 176, 88, 0, 1319, 1321, 3, 200, 100, 0, 1320, 1319, 1, 0, 0, 0, 1320, 1321, 1, 0, 0, 0, 1321, 1323, 1, 0, 0, 0, 1322, 1303, 1, 0, 0, 0, 1322, 1307, 1, 0, 0, 0, 1323, 1326, 1, 0, 0, 0, 1324, 1322, 1, 0, 0, 0, 1324, 1325, 1, 0, 0, 0, 1325, 177, 1, 0, 0, 0, 1326, 1324, 1, 0, 0, 0, 1327, 1329, 3, 180, 90, 0, 1328, 1330, 3, 292, 146, 0, 1329, 1328, 1, 0, 0, 0, 1329, 1330, 1, 0, 0, 0, 1330, 179, 1, 0, 0, 0, 1331, 1333, 5, 373, 0, 0, 1332, 1331, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 1336, 3, 320, 160, 0, 1335, 1337, 3, 182, 91, 0, 1336, 1335, 1, 0, 0, 0, 1336, 1337, 1, 0, 0, 0, 1337, 1371, 1, 0, 0, 0, 1338, 1340, 3, 322, 161, 0, 1339, 1341, 3, 182, 91, 0, 1340, 1339, 1, 0, 0, 0, 1340, 1341, 1, 0, 0, 0, 1341, 1371, 1, 0, 0, 0, 1342, 1343, 5, 198, 0, 0, 1343, 1344, 5, 373, 0, 0, 1344, 1345, 5, 516, 0, 0, 1345, 1346, 3, 270, 135, 0, 1346, 1347, 5, 516, 0, 0, 1347, 1352, 3, 272, 136, 0, 1348, 1349, 5, 520, 0, 0, 1349, 1351, 3, 272, 136, 0, 1350, 1348, 1, 0, 0, 0, 1351, 1354, 1, 0, 0, 0, 1352, 1350, 1, 0, 0, 0, 1352, 1353, 1, 0, 0, 0, 1353, 1355, 1, 0, 0, 0, 1354, 1352, 1, 0, 0, 0, 1355, 1356, 5, 517, 0, 0, 1356, 1357, 5, 517, 0, 0, 1357, 1371, 1, 0, 0, 0, 1358, 1360, 5, 198, 0, 0, 1359, 1358, 1, 0, 0, 0, 1359, 1360, 1, 0, 0, 0, 1360, 1361, 1, 0, 0, 0, 1361, 1362, 5, 516, 0, 0, 1362, 1363, 3, 156, 78, 0, 1363, 1364, 5, 517, 0, 0, 1364, 1371, 1, 0, 0, 0, 1365, 1366, 5, 405, 0, 0, 1366, 1367, 5, 516, 0, 0, 1367, 1368, 3, 256, 128, 0, 1368, 1369, 5, 517, 0, 0, 1369, 1371, 1, 0, 0, 0, 1370, 1332, 1, 0, 0, 0, 1370, 1338, 1, 0, 0, 0, 1370, 1342, 1, 0, 0, 0, 1370, 1359, 1, 0, 0, 0, 1370, 1365, 1, 0, 0, 0, 1371, 181, 1, 0, 0, 0, 1372, 1373, 5, 146, 0, 0, 1373, 1374, 5, 371, 0, 0, 1374, 1375, 5, 17, 0, 0, 1375, 1376, 5, 249, 0, 0, 1376, 1377, 3, 184, 92, 0, 1377, 183, 1, 0, 0, 0, 1378, 1379, 3, 256, 128, 0, 1379, 185, 1, 0, 0, 0, 1380, 1381, 5, 516, 0, 0, 1381, 1382, 3, 148, 74, 0, 1382, 1383, 5, 517, 0, 0, 1383, 1384, 3, 292, 146, 0, 1384, 187, 1, 0, 0, 0, 1385, 1386, 5, 373, 0, 0, 1386, 1387, 5, 516, 0, 0, 1387, 1388, 3, 190, 95, 0, 1388, 1389, 5, 517, 0, 0, 1389, 189, 1, 0, 0, 0, 1390, 1391, 3, 192, 96, 0, 1391, 1392, 5, 516, 0, 0, 1392, 1397, 3, 194, 97, 0, 1393, 1394, 5, 520, 0, 0, 1394, 1396, 3, 194, 97, 0, 1395, 1393, 1, 0, 0, 0, 1396, 1399, 1, 0, 0, 0, 1397, 1395, 1, 0, 0, 0, 1397, 1398, 1, 0, 0, 0, 1398, 1400, 1, 0, 0, 0, 1399, 1397, 1, 0, 0, 0, 1400, 1401, 5, 517, 0, 0, 1401, 191, 1, 0, 0, 0, 1402, 1403, 7, 21, 0, 0, 1403, 193, 1, 0, 0, 0, 1404, 1405, 5, 373, 0, 0, 1405, 1420, 3, 216, 108, 0, 1406, 1420, 3, 198, 99, 0, 1407, 1420, 3, 280, 140, 0, 1408, 1409, 5, 446, 0, 0, 1409, 1410, 5, 536, 0, 0, 1410, 1411, 5, 373, 0, 0, 1411, 1420, 3, 216, 108, 0, 1412, 1413, 5, 498, 0, 0, 1413, 1414, 5, 536, 0, 0, 1414, 1420, 3, 198, 99, 0, 1415, 1416, 3, 196, 98, 0, 1416, 1417, 5, 536, 0, 0, 1417, 1418, 3, 280, 140, 0, 1418, 1420, 1, 0, 0, 0, 1419, 1404, 1, 0, 0, 0, 1419, 1406, 1, 0, 0, 0, 1419, 1407, 1, 0, 0, 0, 1419, 1408, 1, 0, 0, 0, 1419, 1412, 1, 0, 0, 0, 1419, 1415, 1, 0, 0, 0, 1420, 195, 1, 0, 0, 0, 1421, 1422, 7, 22, 0, 0, 1422, 197, 1, 0, 0, 0, 1423, 1424, 5, 451, 0, 0, 1424, 1425, 5, 516, 0, 0, 1425, 1426, 3, 52, 26, 0, 1426, 1427, 5, 517, 0, 0, 1427, 199, 1, 0, 0, 0, 1428, 1429, 5, 253, 0, 0, 1429, 1433, 3, 258, 129, 0, 1430, 1431, 5, 412, 0, 0, 1431, 1433, 3, 54, 27, 0, 1432, 1428, 1, 0, 0, 0, 1432, 1430, 1, 0, 0, 0, 1433, 201, 1, 0, 0, 0, 1434, 1435, 5, 430, 0, 0, 1435, 1436, 3, 258, 129, 0, 1436, 203, 1, 0, 0, 0, 1437, 1438, 5, 159, 0, 0, 1438, 1439, 5, 34, 0, 0, 1439, 1444, 3, 206, 103, 0, 1440, 1441, 5, 520, 0, 0, 1441, 1443, 3, 206, 103, 0, 1442, 1440, 1, 0, 0, 0, 1443, 1446, 1, 0, 0, 0, 1444, 1442, 1, 0, 0, 0, 1444, 1445, 1, 0, 0, 0, 1445, 205, 1, 0, 0, 0, 1446, 1444, 1, 0, 0, 0, 1447, 1488, 3, 52, 26, 0, 1448, 1488, 3, 212, 106, 0, 1449, 1450, 5, 516, 0, 0, 1450, 1488, 5, 517, 0, 0, 1451, 1452, 5, 516, 0, 0, 1452, 1457, 3, 256, 128, 0, 1453, 1454, 5, 520, 0, 0, 1454, 1456, 3, 256, 128, 0, 1455, 1453, 1, 0, 0, 0, 1456, 1459, 1, 0, 0, 0, 1457, 1455, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1460, 1, 0, 0, 0, 1459, 1457, 1, 0, 0, 0, 1460, 1461, 5, 517, 0, 0, 1461, 1488, 1, 0, 0, 0, 1462, 1463, 3, 210, 105, 0, 1463, 1464, 5, 516, 0, 0, 1464, 1469, 3, 256, 128, 0, 1465, 1466, 5, 520, 0, 0, 1466, 1468, 3, 256, 128, 0, 1467, 1465, 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, 1473, 5, 517, 0, 0, 1473, 1488, 1, 0, 0, 0, 1474, 1475, 3, 208, 104, 0, 1475, 1476, 5, 516, 0, 0, 1476, 1481, 3, 206, 103, 0, 1477, 1478, 5, 520, 0, 0, 1478, 1480, 3, 206, 103, 0, 1479, 1477, 1, 0, 0, 0, 1480, 1483, 1, 0, 0, 0, 1481, 1479, 1, 0, 0, 0, 1481, 1482, 1, 0, 0, 0, 1482, 1484, 1, 0, 0, 0, 1483, 1481, 1, 0, 0, 0, 1484, 1485, 5, 517, 0, 0, 1485, 1488, 1, 0, 0, 0, 1486, 1488, 3, 256, 128, 0, 1487, 1447, 1, 0, 0, 0, 1487, 1448, 1, 0, 0, 0, 1487, 1449, 1, 0, 0, 0, 1487, 1451, 1, 0, 0, 0, 1487, 1462, 1, 0, 0, 0, 1487, 1474, 1, 0, 0, 0, 1487, 1486, 1, 0, 0, 0, 1488, 207, 1, 0, 0, 0, 1489, 1490, 5, 160, 0, 0, 1490, 1491, 5, 493, 0, 0, 1491, 209, 1, 0, 0, 0, 1492, 1493, 7, 23, 0, 0, 1493, 211, 1, 0, 0, 0, 1494, 1495, 3, 214, 107, 0, 1495, 1496, 5, 516, 0, 0, 1496, 1497, 3, 216, 108, 0, 1497, 1498, 5, 520, 0, 0, 1498, 1499, 3, 280, 140, 0, 1499, 1500, 5, 517, 0, 0, 1500, 213, 1, 0, 0, 0, 1501, 1502, 7, 24, 0, 0, 1502, 215, 1, 0, 0, 0, 1503, 1504, 3, 326, 163, 0, 1504, 217, 1, 0, 0, 0, 1505, 1506, 5, 163, 0, 0, 1506, 1507, 3, 258, 129, 0, 1507, 219, 1, 0, 0, 0, 1508, 1509, 5, 432, 0, 0, 1509, 1514, 3, 222, 111, 0, 1510, 1511, 5, 520, 0, 0, 1511, 1513, 3, 222, 111, 0, 1512, 1510, 1, 0, 0, 0, 1513, 1516, 1, 0, 0, 0, 1514, 1512, 1, 0, 0, 0, 1514, 1515, 1, 0, 0, 0, 1515, 221, 1, 0, 0, 0, 1516, 1514, 1, 0, 0, 0, 1517, 1518, 3, 294, 147, 0, 1518, 1519, 5, 17, 0, 0, 1519, 1520, 3, 224, 112, 0, 1520, 223, 1, 0, 0, 0, 1521, 1523, 3, 294, 147, 0, 1522, 1521, 1, 0, 0, 0, 1522, 1523, 1, 0, 0, 0, 1523, 1524, 1, 0, 0, 0, 1524, 1526, 5, 516, 0, 0, 1525, 1527, 3, 234, 117, 0, 1526, 1525, 1, 0, 0, 0, 1526, 1527, 1, 0, 0, 0, 1527, 1529, 1, 0, 0, 0, 1528, 1530, 3, 228, 114, 0, 1529, 1528, 1, 0, 0, 0, 1529, 1530, 1, 0, 0, 0, 1530, 1532, 1, 0, 0, 0, 1531, 1533, 3, 250, 125, 0, 1532, 1531, 1, 0, 0, 0, 1532, 1533, 1, 0, 0, 0, 1533, 1534, 1, 0, 0, 0, 1534, 1535, 5, 517, 0, 0, 1535, 225, 1, 0, 0, 0, 1536, 1537, 5, 213, 0, 0, 1537, 1539, 5, 516, 0, 0, 1538, 1540, 3, 234, 117, 0, 1539, 1538, 1, 0, 0, 0, 1539, 1540, 1, 0, 0, 0, 1540, 1542, 1, 0, 0, 0, 1541, 1543, 3, 228, 114, 0, 1542, 1541, 1, 0, 0, 0, 1542, 1543, 1, 0, 0, 0, 1543, 1545, 1, 0, 0, 0, 1544, 1546, 3, 238, 119, 0, 1545, 1544, 1, 0, 0, 0, 1545, 1546, 1, 0, 0, 0, 1546, 1548, 1, 0, 0, 0, 1547, 1549, 3, 244, 122, 0, 1548, 1547, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1551, 1, 0, 0, 0, 1550, 1552, 3, 246, 123, 0, 1551, 1550, 1, 0, 0, 0, 1551, 1552, 1, 0, 0, 0, 1552, 1554, 1, 0, 0, 0, 1553, 1555, 3, 240, 120, 0, 1554, 1553, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1556, 1, 0, 0, 0, 1556, 1557, 3, 248, 124, 0, 1557, 1562, 5, 517, 0, 0, 1558, 1560, 5, 17, 0, 0, 1559, 1558, 1, 0, 0, 0, 1559, 1560, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 1563, 3, 302, 151, 0, 1562, 1559, 1, 0, 0, 0, 1562, 1563, 1, 0, 0, 0, 1563, 227, 1, 0, 0, 0, 1564, 1565, 5, 258, 0, 0, 1565, 1566, 5, 34, 0, 0, 1566, 1571, 3, 230, 115, 0, 1567, 1568, 5, 520, 0, 0, 1568, 1570, 3, 230, 115, 0, 1569, 1567, 1, 0, 0, 0, 1570, 1573, 1, 0, 0, 0, 1571, 1569, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 229, 1, 0, 0, 0, 1573, 1571, 1, 0, 0, 0, 1574, 1576, 3, 52, 26, 0, 1575, 1577, 7, 25, 0, 0, 1576, 1575, 1, 0, 0, 0, 1576, 1577, 1, 0, 0, 0, 1577, 1580, 1, 0, 0, 0, 1578, 1579, 5, 476, 0, 0, 1579, 1581, 7, 26, 0, 0, 1580, 1578, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, 231, 1, 0, 0, 0, 1582, 1585, 5, 204, 0, 0, 1583, 1586, 5, 5, 0, 0, 1584, 1586, 3, 256, 128, 0, 1585, 1583, 1, 0, 0, 0, 1585, 1584, 1, 0, 0, 0, 1586, 233, 1, 0, 0, 0, 1587, 1588, 5, 268, 0, 0, 1588, 1589, 5, 34, 0, 0, 1589, 1594, 3, 52, 26, 0, 1590, 1591, 5, 520, 0, 0, 1591, 1593, 3, 52, 26, 0, 1592, 1590, 1, 0, 0, 0, 1593, 1596, 1, 0, 0, 0, 1594, 1592, 1, 0, 0, 0, 1594, 1595, 1, 0, 0, 0, 1595, 235, 1, 0, 0, 0, 1596, 1594, 1, 0, 0, 0, 1597, 1614, 5, 527, 0, 0, 1598, 1614, 5, 530, 0, 0, 1599, 1614, 5, 535, 0, 0, 1600, 1601, 5, 518, 0, 0, 1601, 1602, 5, 538, 0, 0, 1602, 1603, 5, 520, 0, 0, 1603, 1604, 5, 538, 0, 0, 1604, 1614, 5, 519, 0, 0, 1605, 1606, 5, 518, 0, 0, 1606, 1607, 5, 538, 0, 0, 1607, 1608, 5, 520, 0, 0, 1608, 1614, 5, 519, 0, 0, 1609, 1610, 5, 518, 0, 0, 1610, 1611, 5, 520, 0, 0, 1611, 1612, 5, 538, 0, 0, 1612, 1614, 5, 519, 0, 0, 1613, 1597, 1, 0, 0, 0, 1613, 1598, 1, 0, 0, 0, 1613, 1599, 1, 0, 0, 0, 1613, 1600, 1, 0, 0, 0, 1613, 1605, 1, 0, 0, 0, 1613, 1609, 1, 0, 0, 0, 1614, 237, 1, 0, 0, 0, 1615, 1616, 5, 215, 0, 0, 1616, 1621, 3, 170, 85, 0, 1617, 1618, 5, 520, 0, 0, 1618, 1620, 3, 170, 85, 0, 1619, 1617, 1, 0, 0, 0, 1620, 1623, 1, 0, 0, 0, 1621, 1619, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 239, 1, 0, 0, 0, 1623, 1621, 1, 0, 0, 0, 1624, 1625, 5, 271, 0, 0, 1625, 1627, 5, 516, 0, 0, 1626, 1628, 3, 242, 121, 0, 1627, 1626, 1, 0, 0, 0, 1628, 1629, 1, 0, 0, 0, 1629, 1627, 1, 0, 0, 0, 1629, 1630, 1, 0, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 1633, 5, 517, 0, 0, 1632, 1634, 3, 254, 127, 0, 1633, 1632, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 241, 1, 0, 0, 0, 1635, 1637, 3, 304, 152, 0, 1636, 1638, 3, 236, 118, 0, 1637, 1636, 1, 0, 0, 0, 1637, 1638, 1, 0, 0, 0, 1638, 243, 1, 0, 0, 0, 1639, 1640, 5, 5, 0, 0, 1640, 1641, 5, 322, 0, 0, 1641, 1642, 5, 272, 0, 0, 1642, 1648, 5, 210, 0, 0, 1643, 1644, 5, 254, 0, 0, 1644, 1645, 5, 321, 0, 0, 1645, 1646, 5, 272, 0, 0, 1646, 1648, 5, 210, 0, 0, 1647, 1639, 1, 0, 0, 0, 1647, 1643, 1, 0, 0, 0, 1648, 245, 1, 0, 0, 0, 1649, 1650, 5, 438, 0, 0, 1650, 1651, 5, 210, 0, 0, 1651, 1652, 5, 343, 0, 0, 1652, 1653, 5, 478, 0, 0, 1653, 1654, 5, 467, 0, 0, 1654, 1674, 5, 321, 0, 0, 1655, 1656, 5, 438, 0, 0, 1656, 1657, 5, 210, 0, 0, 1657, 1658, 5, 343, 0, 0, 1658, 1659, 5, 388, 0, 0, 1659, 1660, 5, 237, 0, 0, 1660, 1674, 5, 321, 0, 0, 1661, 1662, 5, 438, 0, 0, 1662, 1663, 5, 210, 0, 0, 1663, 1664, 5, 343, 0, 0, 1664, 1665, 5, 388, 0, 0, 1665, 1666, 5, 467, 0, 0, 1666, 1674, 3, 304, 152, 0, 1667, 1668, 5, 438, 0, 0, 1668, 1669, 5, 210, 0, 0, 1669, 1670, 5, 343, 0, 0, 1670, 1671, 5, 388, 0, 0, 1671, 1672, 5, 457, 0, 0, 1672, 1674, 3, 304, 152, 0, 1673, 1649, 1, 0, 0, 0, 1673, 1655, 1, 0, 0, 0, 1673, 1661, 1, 0, 0, 0, 1673, 1667, 1, 0, 0, 0, 1674, 247, 1, 0, 0, 0, 1675, 1676, 5, 105, 0, 0, 1676, 1681, 3, 170, 85, 0, 1677, 1678, 5, 520, 0, 0, 1678, 1680, 3, 170, 85, 0, 1679, 1677, 1, 0, 0, 0, 1680, 1683, 1, 0, 0, 0, 1681, 1679, 1, 0, 0, 0, 1681, 1682, 1, 0, 0, 0, 1682, 249, 1, 0, 0, 0, 1683, 1681, 1, 0, 0, 0, 1684, 1685, 5, 292, 0, 0, 1685, 1686, 5, 27, 0, 0, 1686, 1687, 3, 280, 140, 0, 1687, 1688, 3, 252, 126, 0, 1688, 1694, 1, 0, 0, 0, 1689, 1690, 5, 322, 0, 0, 1690, 1691, 5, 27, 0, 0, 1691, 1692, 5, 538, 0, 0, 1692, 1694, 3, 252, 126, 0, 1693, 1684, 1, 0, 0, 0, 1693, 1689, 1, 0, 0, 0, 1694, 251, 1, 0, 0, 0, 1695, 1696, 5, 480, 0, 0, 1696, 1697, 5, 10, 0, 0, 1697, 1698, 5, 76, 0, 0, 1698, 1699, 5, 321, 0, 0, 1699, 253, 1, 0, 0, 0, 1700, 1701, 5, 434, 0, 0, 1701, 1702, 3, 280, 140, 0, 1702, 255, 1, 0, 0, 0, 1703, 1704, 3, 258, 129, 0, 1704, 257, 1, 0, 0, 0, 1705, 1706, 6, 129, -1, 0, 1706, 1707, 5, 241, 0, 0, 1707, 1718, 3, 258, 129, 6, 1708, 1709, 5, 133, 0, 0, 1709, 1710, 5, 516, 0, 0, 1710, 1711, 3, 156, 78, 0, 1711, 1712, 5, 517, 0, 0, 1712, 1718, 1, 0, 0, 0, 1713, 1715, 3, 264, 132, 0, 1714, 1716, 3, 260, 130, 0, 1715, 1714, 1, 0, 0, 0, 1715, 1716, 1, 0, 0, 0, 1716, 1718, 1, 0, 0, 0, 1717, 1705, 1, 0, 0, 0, 1717, 1708, 1, 0, 0, 0, 1717, 1713, 1, 0, 0, 0, 1718, 1733, 1, 0, 0, 0, 1719, 1720, 10, 3, 0, 0, 1720, 1721, 5, 10, 0, 0, 1721, 1732, 3, 258, 129, 4, 1722, 1723, 10, 2, 0, 0, 1723, 1724, 5, 257, 0, 0, 1724, 1732, 3, 258, 129, 3, 1725, 1726, 10, 1, 0, 0, 1726, 1728, 5, 184, 0, 0, 1727, 1729, 5, 241, 0, 0, 1728, 1727, 1, 0, 0, 0, 1728, 1729, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, 1732, 7, 27, 0, 0, 1731, 1719, 1, 0, 0, 0, 1731, 1722, 1, 0, 0, 0, 1731, 1725, 1, 0, 0, 0, 1732, 1735, 1, 0, 0, 0, 1733, 1731, 1, 0, 0, 0, 1733, 1734, 1, 0, 0, 0, 1734, 259, 1, 0, 0, 0, 1735, 1733, 1, 0, 0, 0, 1736, 1738, 5, 241, 0, 0, 1737, 1736, 1, 0, 0, 0, 1737, 1738, 1, 0, 0, 0, 1738, 1739, 1, 0, 0, 0, 1739, 1741, 5, 27, 0, 0, 1740, 1742, 7, 28, 0, 0, 1741, 1740, 1, 0, 0, 0, 1741, 1742, 1, 0, 0, 0, 1742, 1743, 1, 0, 0, 0, 1743, 1744, 3, 264, 132, 0, 1744, 1745, 5, 10, 0, 0, 1745, 1746, 3, 264, 132, 0, 1746, 1804, 1, 0, 0, 0, 1747, 1749, 5, 241, 0, 0, 1748, 1747, 1, 0, 0, 0, 1748, 1749, 1, 0, 0, 0, 1749, 1750, 1, 0, 0, 0, 1750, 1751, 5, 170, 0, 0, 1751, 1752, 5, 516, 0, 0, 1752, 1757, 3, 256, 128, 0, 1753, 1754, 5, 520, 0, 0, 1754, 1756, 3, 256, 128, 0, 1755, 1753, 1, 0, 0, 0, 1756, 1759, 1, 0, 0, 0, 1757, 1755, 1, 0, 0, 0, 1757, 1758, 1, 0, 0, 0, 1758, 1760, 1, 0, 0, 0, 1759, 1757, 1, 0, 0, 0, 1760, 1761, 5, 517, 0, 0, 1761, 1804, 1, 0, 0, 0, 1762, 1764, 5, 241, 0, 0, 1763, 1762, 1, 0, 0, 0, 1763, 1764, 1, 0, 0, 0, 1764, 1765, 1, 0, 0, 0, 1765, 1766, 5, 170, 0, 0, 1766, 1767, 5, 516, 0, 0, 1767, 1768, 3, 156, 78, 0, 1768, 1769, 5, 517, 0, 0, 1769, 1804, 1, 0, 0, 0, 1770, 1771, 5, 133, 0, 0, 1771, 1772, 5, 516, 0, 0, 1772, 1773, 3, 156, 78, 0, 1773, 1774, 5, 517, 0, 0, 1774, 1804, 1, 0, 0, 0, 1775, 1777, 5, 241, 0, 0, 1776, 1775, 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1778, 1, 0, 0, 0, 1778, 1779, 5, 318, 0, 0, 1779, 1804, 3, 264, 132, 0, 1780, 1804, 3, 262, 131, 0, 1781, 1783, 5, 184, 0, 0, 1782, 1784, 5, 241, 0, 0, 1783, 1782, 1, 0, 0, 0, 1783, 1784, 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1804, 7, 27, 0, 0, 1786, 1788, 5, 184, 0, 0, 1787, 1789, 5, 241, 0, 0, 1788, 1787, 1, 0, 0, 0, 1788, 1789, 1, 0, 0, 0, 1789, 1790, 1, 0, 0, 0, 1790, 1791, 5, 113, 0, 0, 1791, 1792, 5, 151, 0, 0, 1792, 1804, 3, 264, 132, 0, 1793, 1795, 5, 241, 0, 0, 1794, 1793, 1, 0, 0, 0, 1794, 1795, 1, 0, 0, 0, 1795, 1796, 1, 0, 0, 0, 1796, 1797, 5, 342, 0, 0, 1797, 1798, 5, 388, 0, 0, 1798, 1801, 3, 264, 132, 0, 1799, 1800, 5, 127, 0, 0, 1800, 1802, 3, 356, 178, 0, 1801, 1799, 1, 0, 0, 0, 1801, 1802, 1, 0, 0, 0, 1802, 1804, 1, 0, 0, 0, 1803, 1737, 1, 0, 0, 0, 1803, 1748, 1, 0, 0, 0, 1803, 1763, 1, 0, 0, 0, 1803, 1770, 1, 0, 0, 0, 1803, 1776, 1, 0, 0, 0, 1803, 1780, 1, 0, 0, 0, 1803, 1781, 1, 0, 0, 0, 1803, 1786, 1, 0, 0, 0, 1803, 1794, 1, 0, 0, 0, 1804, 261, 1, 0, 0, 0, 1805, 1807, 5, 241, 0, 0, 1806, 1805, 1, 0, 0, 0, 1806, 1807, 1, 0, 0, 0, 1807, 1808, 1, 0, 0, 0, 1808, 1809, 5, 202, 0, 0, 1809, 1823, 7, 29, 0, 0, 1810, 1811, 5, 516, 0, 0, 1811, 1824, 5, 517, 0, 0, 1812, 1813, 5, 516, 0, 0, 1813, 1818, 3, 256, 128, 0, 1814, 1815, 5, 520, 0, 0, 1815, 1817, 3, 256, 128, 0, 1816, 1814, 1, 0, 0, 0, 1817, 1820, 1, 0, 0, 0, 1818, 1816, 1, 0, 0, 0, 1818, 1819, 1, 0, 0, 0, 1819, 1821, 1, 0, 0, 0, 1820, 1818, 1, 0, 0, 0, 1821, 1822, 5, 517, 0, 0, 1822, 1824, 1, 0, 0, 0, 1823, 1810, 1, 0, 0, 0, 1823, 1812, 1, 0, 0, 0, 1824, 1835, 1, 0, 0, 0, 1825, 1827, 5, 241, 0, 0, 1826, 1825, 1, 0, 0, 0, 1826, 1827, 1, 0, 0, 0, 1827, 1828, 1, 0, 0, 0, 1828, 1829, 5, 202, 0, 0, 1829, 1832, 3, 264, 132, 0, 1830, 1831, 5, 127, 0, 0, 1831, 1833, 3, 356, 178, 0, 1832, 1830, 1, 0, 0, 0, 1832, 1833, 1, 0, 0, 0, 1833, 1835, 1, 0, 0, 0, 1834, 1806, 1, 0, 0, 0, 1834, 1826, 1, 0, 0, 0, 1835, 263, 1, 0, 0, 0, 1836, 1837, 6, 132, -1, 0, 1837, 1841, 3, 266, 133, 0, 1838, 1839, 7, 30, 0, 0, 1839, 1841, 3, 264, 132, 7, 1840, 1836, 1, 0, 0, 0, 1840, 1838, 1, 0, 0, 0, 1841, 1863, 1, 0, 0, 0, 1842, 1843, 10, 6, 0, 0, 1843, 1844, 7, 31, 0, 0, 1844, 1862, 3, 264, 132, 7, 1845, 1846, 10, 5, 0, 0, 1846, 1847, 7, 32, 0, 0, 1847, 1862, 3, 264, 132, 6, 1848, 1849, 10, 4, 0, 0, 1849, 1850, 5, 511, 0, 0, 1850, 1862, 3, 264, 132, 5, 1851, 1852, 10, 3, 0, 0, 1852, 1853, 5, 512, 0, 0, 1853, 1862, 3, 264, 132, 4, 1854, 1855, 10, 2, 0, 0, 1855, 1856, 5, 510, 0, 0, 1856, 1862, 3, 264, 132, 3, 1857, 1858, 10, 1, 0, 0, 1858, 1859, 3, 344, 172, 0, 1859, 1860, 3, 264, 132, 2, 1860, 1862, 1, 0, 0, 0, 1861, 1842, 1, 0, 0, 0, 1861, 1845, 1, 0, 0, 0, 1861, 1848, 1, 0, 0, 0, 1861, 1851, 1, 0, 0, 0, 1861, 1854, 1, 0, 0, 0, 1861, 1857, 1, 0, 0, 0, 1862, 1865, 1, 0, 0, 0, 1863, 1861, 1, 0, 0, 0, 1863, 1864, 1, 0, 0, 0, 1864, 265, 1, 0, 0, 0, 1865, 1863, 1, 0, 0, 0, 1866, 1867, 6, 133, -1, 0, 1867, 1869, 5, 40, 0, 0, 1868, 1870, 3, 308, 154, 0, 1869, 1868, 1, 0, 0, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1869, 1, 0, 0, 0, 1871, 1872, 1, 0, 0, 0, 1872, 1875, 1, 0, 0, 0, 1873, 1874, 5, 120, 0, 0, 1874, 1876, 3, 256, 128, 0, 1875, 1873, 1, 0, 0, 0, 1875, 1876, 1, 0, 0, 0, 1876, 1877, 1, 0, 0, 0, 1877, 1878, 5, 122, 0, 0, 1878, 1959, 1, 0, 0, 0, 1879, 1880, 5, 40, 0, 0, 1880, 1882, 3, 256, 128, 0, 1881, 1883, 3, 308, 154, 0, 1882, 1881, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 1882, 1, 0, 0, 0, 1884, 1885, 1, 0, 0, 0, 1885, 1888, 1, 0, 0, 0, 1886, 1887, 5, 120, 0, 0, 1887, 1889, 3, 256, 128, 0, 1888, 1886, 1, 0, 0, 0, 1888, 1889, 1, 0, 0, 0, 1889, 1890, 1, 0, 0, 0, 1890, 1891, 5, 122, 0, 0, 1891, 1959, 1, 0, 0, 0, 1892, 1893, 5, 41, 0, 0, 1893, 1894, 5, 516, 0, 0, 1894, 1895, 3, 256, 128, 0, 1895, 1896, 5, 17, 0, 0, 1896, 1897, 3, 56, 28, 0, 1897, 1898, 5, 517, 0, 0, 1898, 1959, 1, 0, 0, 0, 1899, 1900, 5, 457, 0, 0, 1900, 1901, 5, 516, 0, 0, 1901, 1904, 3, 256, 128, 0, 1902, 1903, 5, 461, 0, 0, 1903, 1905, 5, 476, 0, 0, 1904, 1902, 1, 0, 0, 0, 1904, 1905, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 1907, 5, 517, 0, 0, 1907, 1959, 1, 0, 0, 0, 1908, 1909, 5, 467, 0, 0, 1909, 1910, 5, 516, 0, 0, 1910, 1913, 3, 256, 128, 0, 1911, 1912, 5, 461, 0, 0, 1912, 1914, 5, 476, 0, 0, 1913, 1911, 1, 0, 0, 0, 1913, 1914, 1, 0, 0, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1916, 5, 517, 0, 0, 1916, 1959, 1, 0, 0, 0, 1917, 1918, 5, 281, 0, 0, 1918, 1919, 5, 516, 0, 0, 1919, 1920, 3, 264, 132, 0, 1920, 1921, 5, 170, 0, 0, 1921, 1922, 3, 264, 132, 0, 1922, 1923, 5, 517, 0, 0, 1923, 1959, 1, 0, 0, 0, 1924, 1959, 3, 352, 176, 0, 1925, 1959, 5, 527, 0, 0, 1926, 1927, 3, 326, 163, 0, 1927, 1928, 5, 513, 0, 0, 1928, 1929, 5, 527, 0, 0, 1929, 1959, 1, 0, 0, 0, 1930, 1931, 5, 516, 0, 0, 1931, 1932, 3, 156, 78, 0, 1932, 1933, 5, 517, 0, 0, 1933, 1959, 1, 0, 0, 0, 1934, 1935, 3, 270, 135, 0, 1935, 1947, 5, 516, 0, 0, 1936, 1938, 3, 362, 181, 0, 1937, 1936, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1944, 3, 272, 136, 0, 1940, 1941, 5, 520, 0, 0, 1941, 1943, 3, 272, 136, 0, 1942, 1940, 1, 0, 0, 0, 1943, 1946, 1, 0, 0, 0, 1944, 1942, 1, 0, 0, 0, 1944, 1945, 1, 0, 0, 0, 1945, 1948, 1, 0, 0, 0, 1946, 1944, 1, 0, 0, 0, 1947, 1937, 1, 0, 0, 0, 1947, 1948, 1, 0, 0, 0, 1948, 1949, 1, 0, 0, 0, 1949, 1950, 5, 517, 0, 0, 1950, 1959, 1, 0, 0, 0, 1951, 1959, 3, 302, 151, 0, 1952, 1959, 3, 274, 137, 0, 1953, 1954, 5, 516, 0, 0, 1954, 1955, 3, 256, 128, 0, 1955, 1956, 5, 517, 0, 0, 1956, 1959, 1, 0, 0, 0, 1957, 1959, 5, 85, 0, 0, 1958, 1866, 1, 0, 0, 0, 1958, 1879, 1, 0, 0, 0, 1958, 1892, 1, 0, 0, 0, 1958, 1899, 1, 0, 0, 0, 1958, 1908, 1, 0, 0, 0, 1958, 1917, 1, 0, 0, 0, 1958, 1924, 1, 0, 0, 0, 1958, 1925, 1, 0, 0, 0, 1958, 1926, 1, 0, 0, 0, 1958, 1930, 1, 0, 0, 0, 1958, 1934, 1, 0, 0, 0, 1958, 1951, 1, 0, 0, 0, 1958, 1952, 1, 0, 0, 0, 1958, 1953, 1, 0, 0, 0, 1958, 1957, 1, 0, 0, 0, 1959, 1967, 1, 0, 0, 0, 1960, 1961, 10, 5, 0, 0, 1961, 1962, 5, 514, 0, 0, 1962, 1963, 3, 264, 132, 0, 1963, 1964, 5, 515, 0, 0, 1964, 1966, 1, 0, 0, 0, 1965, 1960, 1, 0, 0, 0, 1966, 1969, 1, 0, 0, 0, 1967, 1965, 1, 0, 0, 0, 1967, 1968, 1, 0, 0, 0, 1968, 267, 1, 0, 0, 0, 1969, 1967, 1, 0, 0, 0, 1970, 1971, 3, 326, 163, 0, 1971, 269, 1, 0, 0, 0, 1972, 1975, 3, 370, 185, 0, 1973, 1975, 3, 326, 163, 0, 1974, 1972, 1, 0, 0, 0, 1974, 1973, 1, 0, 0, 0, 1975, 271, 1, 0, 0, 0, 1976, 1981, 3, 368, 184, 0, 1977, 1981, 3, 366, 183, 0, 1978, 1981, 3, 364, 182, 0, 1979, 1981, 3, 256, 128, 0, 1980, 1976, 1, 0, 0, 0, 1980, 1977, 1, 0, 0, 0, 1980, 1978, 1, 0, 0, 0, 1980, 1979, 1, 0, 0, 0, 1981, 273, 1, 0, 0, 0, 1982, 1983, 3, 326, 163, 0, 1983, 275, 1, 0, 0, 0, 1984, 1985, 3, 302, 151, 0, 1985, 277, 1, 0, 0, 0, 1986, 1989, 3, 302, 151, 0, 1987, 1989, 3, 274, 137, 0, 1988, 1986, 1, 0, 0, 0, 1988, 1987, 1, 0, 0, 0, 1989, 279, 1, 0, 0, 0, 1990, 1993, 5, 182, 0, 0, 1991, 1994, 3, 282, 141, 0, 1992, 1994, 3, 286, 143, 0, 1993, 1991, 1, 0, 0, 0, 1993, 1992, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 281, 1, 0, 0, 0, 1995, 1997, 3, 284, 142, 0, 1996, 1998, 3, 288, 144, 0, 1997, 1996, 1, 0, 0, 0, 1997, 1998, 1, 0, 0, 0, 1998, 283, 1, 0, 0, 0, 1999, 2000, 3, 290, 145, 0, 2000, 2001, 3, 366, 183, 0, 2001, 2003, 1, 0, 0, 0, 2002, 1999, 1, 0, 0, 0, 2003, 2004, 1, 0, 0, 0, 2004, 2002, 1, 0, 0, 0, 2004, 2005, 1, 0, 0, 0, 2005, 285, 1, 0, 0, 0, 2006, 2009, 3, 288, 144, 0, 2007, 2010, 3, 284, 142, 0, 2008, 2010, 3, 288, 144, 0, 2009, 2007, 1, 0, 0, 0, 2009, 2008, 1, 0, 0, 0, 2009, 2010, 1, 0, 0, 0, 2010, 287, 1, 0, 0, 0, 2011, 2012, 3, 290, 145, 0, 2012, 2013, 3, 366, 183, 0, 2013, 2014, 5, 388, 0, 0, 2014, 2015, 3, 366, 183, 0, 2015, 289, 1, 0, 0, 0, 2016, 2018, 7, 33, 0, 0, 2017, 2016, 1, 0, 0, 0, 2017, 2018, 1, 0, 0, 0, 2018, 2019, 1, 0, 0, 0, 2019, 2022, 7, 34, 0, 0, 2020, 2022, 5, 537, 0, 0, 2021, 2017, 1, 0, 0, 0, 2021, 2020, 1, 0, 0, 0, 2022, 291, 1, 0, 0, 0, 2023, 2025, 5, 17, 0, 0, 2024, 2023, 1, 0, 0, 0, 2024, 2025, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, 2028, 3, 302, 151, 0, 2027, 2029, 3, 298, 149, 0, 2028, 2027, 1, 0, 0, 0, 2028, 2029, 1, 0, 0, 0, 2029, 293, 1, 0, 0, 0, 2030, 2031, 3, 302, 151, 0, 2031, 2032, 3, 296, 148, 0, 2032, 295, 1, 0, 0, 0, 2033, 2034, 5, 221, 0, 0, 2034, 2036, 3, 302, 151, 0, 2035, 2033, 1, 0, 0, 0, 2036, 2037, 1, 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 2041, 1, 0, 0, 0, 2039, 2041, 1, 0, 0, 0, 2040, 2035, 1, 0, 0, 0, 2040, 2039, 1, 0, 0, 0, 2041, 297, 1, 0, 0, 0, 2042, 2043, 5, 516, 0, 0, 2043, 2044, 3, 300, 150, 0, 2044, 2045, 5, 517, 0, 0, 2045, 299, 1, 0, 0, 0, 2046, 2051, 3, 302, 151, 0, 2047, 2048, 5, 520, 0, 0, 2048, 2050, 3, 302, 151, 0, 2049, 2047, 1, 0, 0, 0, 2050, 2053, 1, 0, 0, 0, 2051, 2049, 1, 0, 0, 0, 2051, 2052, 1, 0, 0, 0, 2052, 301, 1, 0, 0, 0, 2053, 2051, 1, 0, 0, 0, 2054, 2058, 3, 304, 152, 0, 2055, 2058, 3, 306, 153, 0, 2056, 2058, 3, 372, 186, 0, 2057, 2054, 1, 0, 0, 0, 2057, 2055, 1, 0, 0, 0, 2057, 2056, 1, 0, 0, 0, 2058, 303, 1, 0, 0, 0, 2059, 2060, 7, 35, 0, 0, 2060, 305, 1, 0, 0, 0, 2061, 2062, 5, 537, 0, 0, 2062, 307, 1, 0, 0, 0, 2063, 2064, 5, 428, 0, 0, 2064, 2065, 3, 256, 128, 0, 2065, 2066, 5, 376, 0, 0, 2066, 2067, 3, 256, 128, 0, 2067, 309, 1, 0, 0, 0, 2068, 2069, 3, 302, 151, 0, 2069, 311, 1, 0, 0, 0, 2070, 2071, 3, 302, 151, 0, 2071, 313, 1, 0, 0, 0, 2072, 2075, 3, 302, 151, 0, 2073, 2074, 5, 513, 0, 0, 2074, 2076, 3, 302, 151, 0, 2075, 2073, 1, 0, 0, 0, 2075, 2076, 1, 0, 0, 0, 2076, 315, 1, 0, 0, 0, 2077, 2080, 3, 302, 151, 0, 2078, 2079, 5, 513, 0, 0, 2079, 2081, 3, 302, 151, 0, 2080, 2078, 1, 0, 0, 0, 2080, 2081, 1, 0, 0, 0, 2081, 317, 1, 0, 0, 0, 2082, 2085, 3, 302, 151, 0, 2083, 2084, 5, 513, 0, 0, 2084, 2086, 3, 302, 151, 0, 2085, 2083, 1, 0, 0, 0, 2085, 2086, 1, 0, 0, 0, 2086, 2095, 1, 0, 0, 0, 2087, 2088, 3, 302, 151, 0, 2088, 2089, 5, 513, 0, 0, 2089, 2092, 3, 302, 151, 0, 2090, 2091, 5, 513, 0, 0, 2091, 2093, 3, 302, 151, 0, 2092, 2090, 1, 0, 0, 0, 2092, 2093, 1, 0, 0, 0, 2093, 2095, 1, 0, 0, 0, 2094, 2082, 1, 0, 0, 0, 2094, 2087, 1, 0, 0, 0, 2095, 319, 1, 0, 0, 0, 2096, 2099, 3, 302, 151, 0, 2097, 2098, 5, 513, 0, 0, 2098, 2100, 3, 302, 151, 0, 2099, 2097, 1, 0, 0, 0, 2099, 2100, 1, 0, 0, 0, 2100, 2109, 1, 0, 0, 0, 2101, 2102, 3, 302, 151, 0, 2102, 2103, 5, 513, 0, 0, 2103, 2106, 3, 302, 151, 0, 2104, 2105, 5, 513, 0, 0, 2105, 2107, 3, 302, 151, 0, 2106, 2104, 1, 0, 0, 0, 2106, 2107, 1, 0, 0, 0, 2107, 2109, 1, 0, 0, 0, 2108, 2096, 1, 0, 0, 0, 2108, 2101, 1, 0, 0, 0, 2109, 321, 1, 0, 0, 0, 2110, 2113, 3, 302, 151, 0, 2111, 2112, 5, 513, 0, 0, 2112, 2114, 3, 302, 151, 0, 2113, 2111, 1, 0, 0, 0, 2113, 2114, 1, 0, 0, 0, 2114, 2123, 1, 0, 0, 0, 2115, 2116, 3, 302, 151, 0, 2116, 2117, 5, 513, 0, 0, 2117, 2120, 3, 302, 151, 0, 2118, 2119, 5, 513, 0, 0, 2119, 2121, 3, 302, 151, 0, 2120, 2118, 1, 0, 0, 0, 2120, 2121, 1, 0, 0, 0, 2121, 2123, 1, 0, 0, 0, 2122, 2110, 1, 0, 0, 0, 2122, 2115, 1, 0, 0, 0, 2123, 323, 1, 0, 0, 0, 2124, 2127, 3, 302, 151, 0, 2125, 2126, 5, 513, 0, 0, 2126, 2128, 3, 302, 151, 0, 2127, 2125, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 2137, 1, 0, 0, 0, 2129, 2130, 3, 302, 151, 0, 2130, 2131, 5, 513, 0, 0, 2131, 2134, 3, 302, 151, 0, 2132, 2133, 5, 513, 0, 0, 2133, 2135, 3, 302, 151, 0, 2134, 2132, 1, 0, 0, 0, 2134, 2135, 1, 0, 0, 0, 2135, 2137, 1, 0, 0, 0, 2136, 2124, 1, 0, 0, 0, 2136, 2129, 1, 0, 0, 0, 2137, 325, 1, 0, 0, 0, 2138, 2143, 3, 302, 151, 0, 2139, 2140, 5, 513, 0, 0, 2140, 2142, 3, 302, 151, 0, 2141, 2139, 1, 0, 0, 0, 2142, 2145, 1, 0, 0, 0, 2143, 2144, 1, 0, 0, 0, 2143, 2141, 1, 0, 0, 0, 2144, 327, 1, 0, 0, 0, 2145, 2143, 1, 0, 0, 0, 2146, 2147, 5, 433, 0, 0, 2147, 2148, 3, 334, 167, 0, 2148, 329, 1, 0, 0, 0, 2149, 2150, 5, 167, 0, 0, 2150, 2151, 5, 241, 0, 0, 2151, 2152, 5, 133, 0, 0, 2152, 331, 1, 0, 0, 0, 2153, 2154, 5, 167, 0, 0, 2154, 2155, 5, 133, 0, 0, 2155, 333, 1, 0, 0, 0, 2156, 2157, 5, 516, 0, 0, 2157, 2162, 3, 336, 168, 0, 2158, 2159, 5, 520, 0, 0, 2159, 2161, 3, 336, 168, 0, 2160, 2158, 1, 0, 0, 0, 2161, 2164, 1, 0, 0, 0, 2162, 2160, 1, 0, 0, 0, 2162, 2163, 1, 0, 0, 0, 2163, 2165, 1, 0, 0, 0, 2164, 2162, 1, 0, 0, 0, 2165, 2166, 5, 517, 0, 0, 2166, 335, 1, 0, 0, 0, 2167, 2172, 3, 338, 169, 0, 2168, 2170, 5, 505, 0, 0, 2169, 2168, 1, 0, 0, 0, 2169, 2170, 1, 0, 0, 0, 2170, 2171, 1, 0, 0, 0, 2171, 2173, 3, 340, 170, 0, 2172, 2169, 1, 0, 0, 0, 2172, 2173, 1, 0, 0, 0, 2173, 337, 1, 0, 0, 0, 2174, 2178, 3, 302, 151, 0, 2175, 2178, 3, 274, 137, 0, 2176, 2178, 5, 537, 0, 0, 2177, 2174, 1, 0, 0, 0, 2177, 2175, 1, 0, 0, 0, 2177, 2176, 1, 0, 0, 0, 2178, 339, 1, 0, 0, 0, 2179, 2184, 5, 538, 0, 0, 2180, 2184, 5, 539, 0, 0, 2181, 2184, 3, 360, 180, 0, 2182, 2184, 5, 537, 0, 0, 2183, 2179, 1, 0, 0, 0, 2183, 2180, 1, 0, 0, 0, 2183, 2181, 1, 0, 0, 0, 2183, 2182, 1, 0, 0, 0, 2184, 341, 1, 0, 0, 0, 2185, 2192, 5, 10, 0, 0, 2186, 2187, 5, 511, 0, 0, 2187, 2192, 5, 511, 0, 0, 2188, 2192, 5, 257, 0, 0, 2189, 2190, 5, 510, 0, 0, 2190, 2192, 5, 510, 0, 0, 2191, 2185, 1, 0, 0, 0, 2191, 2186, 1, 0, 0, 0, 2191, 2188, 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2192, 343, 1, 0, 0, 0, 2193, 2208, 5, 505, 0, 0, 2194, 2208, 5, 506, 0, 0, 2195, 2208, 5, 507, 0, 0, 2196, 2197, 5, 507, 0, 0, 2197, 2208, 5, 505, 0, 0, 2198, 2199, 5, 506, 0, 0, 2199, 2208, 5, 505, 0, 0, 2200, 2201, 5, 507, 0, 0, 2201, 2208, 5, 506, 0, 0, 2202, 2203, 5, 508, 0, 0, 2203, 2208, 5, 505, 0, 0, 2204, 2205, 5, 507, 0, 0, 2205, 2206, 5, 505, 0, 0, 2206, 2208, 5, 506, 0, 0, 2207, 2193, 1, 0, 0, 0, 2207, 2194, 1, 0, 0, 0, 2207, 2195, 1, 0, 0, 0, 2207, 2196, 1, 0, 0, 0, 2207, 2198, 1, 0, 0, 0, 2207, 2200, 1, 0, 0, 0, 2207, 2202, 1, 0, 0, 0, 2207, 2204, 1, 0, 0, 0, 2208, 345, 1, 0, 0, 0, 2209, 2210, 5, 507, 0, 0, 2210, 2217, 5, 507, 0, 0, 2211, 2212, 5, 506, 0, 0, 2212, 2217, 5, 506, 0, 0, 2213, 2217, 5, 511, 0, 0, 2214, 2217, 5, 512, 0, 0, 2215, 2217, 5, 510, 0, 0, 2216, 2209, 1, 0, 0, 0, 2216, 2211, 1, 0, 0, 0, 2216, 2213, 1, 0, 0, 0, 2216, 2214, 1, 0, 0, 0, 2216, 2215, 1, 0, 0, 0, 2217, 347, 1, 0, 0, 0, 2218, 2219, 7, 36, 0, 0, 2219, 349, 1, 0, 0, 0, 2220, 2221, 7, 37, 0, 0, 2221, 351, 1, 0, 0, 0, 2222, 2237, 3, 280, 140, 0, 2223, 2237, 3, 354, 177, 0, 2224, 2237, 3, 356, 178, 0, 2225, 2227, 5, 529, 0, 0, 2226, 2225, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2228, 1, 0, 0, 0, 2228, 2237, 3, 358, 179, 0, 2229, 2237, 3, 360, 180, 0, 2230, 2237, 5, 539, 0, 0, 2231, 2237, 5, 540, 0, 0, 2232, 2234, 5, 241, 0, 0, 2233, 2232, 1, 0, 0, 0, 2233, 2234, 1, 0, 0, 0, 2234, 2235, 1, 0, 0, 0, 2235, 2237, 5, 244, 0, 0, 2236, 2222, 1, 0, 0, 0, 2236, 2223, 1, 0, 0, 0, 2236, 2224, 1, 0, 0, 0, 2236, 2226, 1, 0, 0, 0, 2236, 2229, 1, 0, 0, 0, 2236, 2230, 1, 0, 0, 0, 2236, 2231, 1, 0, 0, 0, 2236, 2233, 1, 0, 0, 0, 2237, 353, 1, 0, 0, 0, 2238, 2239, 3, 364, 182, 0, 2239, 2240, 3, 356, 178, 0, 2240, 355, 1, 0, 0, 0, 2241, 2242, 5, 537, 0, 0, 2242, 357, 1, 0, 0, 0, 2243, 2244, 5, 538, 0, 0, 2244, 359, 1, 0, 0, 0, 2245, 2246, 7, 38, 0, 0, 2246, 361, 1, 0, 0, 0, 2247, 2248, 7, 39, 0, 0, 2248, 363, 1, 0, 0, 0, 2249, 2250, 7, 40, 0, 0, 2250, 365, 1, 0, 0, 0, 2251, 2252, 7, 41, 0, 0, 2252, 367, 1, 0, 0, 0, 2253, 2254, 7, 42, 0, 0, 2254, 369, 1, 0, 0, 0, 2255, 2256, 7, 43, 0, 0, 2256, 371, 1, 0, 0, 0, 2257, 2258, 7, 44, 0, 0, 2258, 373, 1, 0, 0, 0, 266, 377, 384, 387, 401, 419, 423, 432, 437, 444, 455, 464, 476, 479, 486, 489, 497, 501, 506, 509, 516, 524, 528, 540, 548, 552, 584, 587, 592, 596, 600, 604, 613, 618, 622, 626, 631, 634, 638, 643, 649, 654, 659, 663, 667, 671, 679, 687, 691, 695, 699, 703, 707, 711, 715, 719, 721, 731, 739, 763, 770, 776, 779, 782, 789, 792, 801, 813, 837, 849, 854, 858, 866, 870, 876, 886, 891, 897, 901, 905, 909, 918, 922, 929, 932, 942, 950, 958, 962, 977, 996, 1007, 1011, 1018, 1023, 1029, 1033, 1040, 1044, 1048, 1052, 1060, 1064, 1069, 1075, 1081, 1084, 1088, 1099, 1108, 1122, 1134, 1149, 1152, 1156, 1159, 1161, 1166, 1170, 1173, 1177, 1186, 1195, 1205, 1210, 1221, 1224, 1227, 1230, 1233, 1239, 1243, 1251, 1254, 1259, 1262, 1266, 1269, 1271, 1285, 1296, 1301, 1309, 1312, 1315, 1320, 1322, 1324, 1329, 1332, 1336, 1340, 1352, 1359, 1370, 1397, 1419, 1432, 1444, 1457, 1469, 1481, 1487, 1514, 1522, 1526, 1529, 1532, 1539, 1542, 1545, 1548, 1551, 1554, 1559, 1562, 1571, 1576, 1580, 1585, 1594, 1613, 1621, 1629, 1633, 1637, 1647, 1673, 1681, 1693, 1715, 1717, 1728, 1731, 1733, 1737, 1741, 1748, 1757, 1763, 1776, 1783, 1788, 1794, 1801, 1803, 1806, 1818, 1823, 1826, 1832, 1834, 1840, 1861, 1863, 1871, 1875, 1884, 1888, 1904, 1913, 1937, 1944, 1947, 1958, 1967, 1974, 1980, 1988, 1993, 1997, 2004, 2009, 2017, 2021, 2024, 2028, 2037, 2040, 2051, 2057, 2075, 2080, 2085, 2092, 2094, 2099, 2106, 2108, 2113, 2120, 2122, 2127, 2134, 2136, 2143, 2162, 2169, 2172, 2177, 2183, 2191, 2207, 2216, 2226, 2233, 2236] \ No newline at end of file diff --git a/src/lib/flink/FlinkSqlParser.ts b/src/lib/flink/FlinkSqlParser.ts index e178b1c5..63d3c347 100644 --- a/src/lib/flink/FlinkSqlParser.ts +++ b/src/lib/flink/FlinkSqlParser.ts @@ -594,158 +594,157 @@ export class FlinkSqlParser extends SQLParserBase { public static readonly RULE_mapTypeDimension = 33; public static readonly RULE_rowTypeDimension = 34; public static readonly RULE_columnConstraint = 35; - public static readonly RULE_commentSpec = 36; - public static readonly RULE_metadataColumnDefinition = 37; - public static readonly RULE_metadataKey = 38; - public static readonly RULE_computedColumnDefinition = 39; - public static readonly RULE_computedColumnExpression = 40; - public static readonly RULE_watermarkDefinition = 41; - public static readonly RULE_tableConstraint = 42; - public static readonly RULE_constraintName = 43; - public static readonly RULE_selfDefinitionClause = 44; - public static readonly RULE_partitionDefinition = 45; - public static readonly RULE_transformList = 46; - public static readonly RULE_transform = 47; - public static readonly RULE_transformArgument = 48; - public static readonly RULE_likeDefinition = 49; - public static readonly RULE_likeOption = 50; - public static readonly RULE_createCatalog = 51; - public static readonly RULE_createDatabase = 52; - public static readonly RULE_createView = 53; - public static readonly RULE_createFunction = 54; - public static readonly RULE_usingClause = 55; - public static readonly RULE_jarFileName = 56; - public static readonly RULE_alterTable = 57; - public static readonly RULE_renameDefinition = 58; - public static readonly RULE_setKeyValueDefinition = 59; - public static readonly RULE_addConstraint = 60; - public static readonly RULE_dropConstraint = 61; - public static readonly RULE_addUnique = 62; - public static readonly RULE_notForced = 63; - public static readonly RULE_alertView = 64; - public static readonly RULE_alterDatabase = 65; - public static readonly RULE_alterFunction = 66; - public static readonly RULE_dropCatalog = 67; - public static readonly RULE_dropTable = 68; - public static readonly RULE_dropDatabase = 69; - public static readonly RULE_dropView = 70; - public static readonly RULE_dropFunction = 71; - public static readonly RULE_insertStatement = 72; - public static readonly RULE_insertSimpleStatement = 73; - public static readonly RULE_insertPartitionDefinition = 74; - public static readonly RULE_valuesDefinition = 75; - public static readonly RULE_valuesRowDefinition = 76; - public static readonly RULE_insertMulStatementCompatibility = 77; - public static readonly RULE_insertMulStatement = 78; - public static readonly RULE_queryStatement = 79; - public static readonly RULE_valuesCaluse = 80; - public static readonly RULE_withClause = 81; - public static readonly RULE_withItem = 82; - public static readonly RULE_withItemName = 83; - public static readonly RULE_selectStatement = 84; - public static readonly RULE_selectClause = 85; - public static readonly RULE_projectItemDefinition = 86; - public static readonly RULE_overWindowItem = 87; - public static readonly RULE_fromClause = 88; - public static readonly RULE_tableExpression = 89; - public static readonly RULE_tableReference = 90; - public static readonly RULE_tablePrimary = 91; - public static readonly RULE_systemTimePeriod = 92; - public static readonly RULE_dateTimeExpression = 93; - public static readonly RULE_inlineDataValueClause = 94; - public static readonly RULE_windoTVFClause = 95; - public static readonly RULE_windowTVFExression = 96; - public static readonly RULE_windoTVFName = 97; - public static readonly RULE_windowTVFParam = 98; - public static readonly RULE_timeIntervalParamName = 99; - public static readonly RULE_columnDescriptor = 100; - public static readonly RULE_joinCondition = 101; - public static readonly RULE_whereClause = 102; - public static readonly RULE_groupByClause = 103; - public static readonly RULE_groupItemDefinition = 104; - public static readonly RULE_groupingSets = 105; - public static readonly RULE_groupingSetsNotaionName = 106; - public static readonly RULE_groupWindowFunction = 107; - public static readonly RULE_groupWindowFunctionName = 108; - public static readonly RULE_timeAttrColumn = 109; - public static readonly RULE_havingClause = 110; - public static readonly RULE_windowClause = 111; - public static readonly RULE_namedWindow = 112; - public static readonly RULE_windowSpec = 113; - public static readonly RULE_matchRecognizeClause = 114; - public static readonly RULE_orderByCaluse = 115; - public static readonly RULE_orderItemDefition = 116; - public static readonly RULE_limitClause = 117; - public static readonly RULE_partitionByClause = 118; - public static readonly RULE_quantifiers = 119; - public static readonly RULE_measuresClause = 120; - public static readonly RULE_patternDefination = 121; - public static readonly RULE_patternVariable = 122; - public static readonly RULE_outputMode = 123; - public static readonly RULE_afterMatchStrategy = 124; - public static readonly RULE_patternVariablesDefination = 125; - public static readonly RULE_windowFrame = 126; - public static readonly RULE_frameBound = 127; - public static readonly RULE_withinClause = 128; - public static readonly RULE_expression = 129; - public static readonly RULE_booleanExpression = 130; - public static readonly RULE_predicate = 131; - public static readonly RULE_likePredicate = 132; - public static readonly RULE_valueExpression = 133; - public static readonly RULE_primaryExpression = 134; - public static readonly RULE_functionNameCreate = 135; - public static readonly RULE_functionName = 136; - public static readonly RULE_functionParam = 137; - public static readonly RULE_dereferenceDefinition = 138; - public static readonly RULE_correlationName = 139; - public static readonly RULE_qualifiedName = 140; - public static readonly RULE_timeIntervalExpression = 141; - public static readonly RULE_errorCapturingMultiUnitsInterval = 142; - public static readonly RULE_multiUnitsInterval = 143; - public static readonly RULE_errorCapturingUnitToUnitInterval = 144; - public static readonly RULE_unitToUnitInterval = 145; - public static readonly RULE_intervalValue = 146; - public static readonly RULE_tableAlias = 147; - public static readonly RULE_errorCapturingIdentifier = 148; - public static readonly RULE_errorCapturingIdentifierExtra = 149; - public static readonly RULE_identifierList = 150; - public static readonly RULE_identifierSeq = 151; - public static readonly RULE_identifier = 152; - public static readonly RULE_unquotedIdentifier = 153; - public static readonly RULE_quotedIdentifier = 154; - public static readonly RULE_whenClause = 155; - public static readonly RULE_catalogPath = 156; - public static readonly RULE_catalogPathCreate = 157; - public static readonly RULE_databasePath = 158; - public static readonly RULE_databasePathCreate = 159; - public static readonly RULE_tablePathCreate = 160; - public static readonly RULE_tablePath = 161; - public static readonly RULE_viewPath = 162; - public static readonly RULE_viewPathCreate = 163; - public static readonly RULE_uid = 164; - public static readonly RULE_withOption = 165; - public static readonly RULE_ifNotExists = 166; - public static readonly RULE_ifExists = 167; - public static readonly RULE_tablePropertyList = 168; - public static readonly RULE_tableProperty = 169; - public static readonly RULE_tablePropertyKey = 170; - public static readonly RULE_tablePropertyValue = 171; - public static readonly RULE_logicalOperator = 172; - public static readonly RULE_comparisonOperator = 173; - public static readonly RULE_bitOperator = 174; - public static readonly RULE_mathOperator = 175; - public static readonly RULE_unaryOperator = 176; - public static readonly RULE_constant = 177; - public static readonly RULE_timePointLiteral = 178; - public static readonly RULE_stringLiteral = 179; - public static readonly RULE_decimalLiteral = 180; - public static readonly RULE_booleanLiteral = 181; - public static readonly RULE_setQuantifier = 182; - public static readonly RULE_timePointUnit = 183; - public static readonly RULE_timeIntervalUnit = 184; - public static readonly RULE_reservedKeywordsUsedAsFuncParam = 185; - public static readonly RULE_reservedKeywordsUsedAsFuncName = 186; - public static readonly RULE_nonReservedKeywords = 187; + public static readonly RULE_metadataColumnDefinition = 36; + public static readonly RULE_metadataKey = 37; + public static readonly RULE_computedColumnDefinition = 38; + public static readonly RULE_computedColumnExpression = 39; + public static readonly RULE_watermarkDefinition = 40; + public static readonly RULE_tableConstraint = 41; + public static readonly RULE_constraintName = 42; + public static readonly RULE_selfDefinitionClause = 43; + public static readonly RULE_partitionDefinition = 44; + public static readonly RULE_transformList = 45; + public static readonly RULE_transform = 46; + public static readonly RULE_transformArgument = 47; + public static readonly RULE_likeDefinition = 48; + public static readonly RULE_likeOption = 49; + public static readonly RULE_createCatalog = 50; + public static readonly RULE_createDatabase = 51; + public static readonly RULE_createView = 52; + public static readonly RULE_createFunction = 53; + public static readonly RULE_usingClause = 54; + public static readonly RULE_jarFileName = 55; + public static readonly RULE_alterTable = 56; + public static readonly RULE_renameDefinition = 57; + public static readonly RULE_setKeyValueDefinition = 58; + public static readonly RULE_addConstraint = 59; + public static readonly RULE_dropConstraint = 60; + public static readonly RULE_addUnique = 61; + public static readonly RULE_notForced = 62; + public static readonly RULE_alterView = 63; + public static readonly RULE_alterDatabase = 64; + public static readonly RULE_alterFunction = 65; + public static readonly RULE_dropCatalog = 66; + public static readonly RULE_dropTable = 67; + public static readonly RULE_dropDatabase = 68; + public static readonly RULE_dropView = 69; + public static readonly RULE_dropFunction = 70; + public static readonly RULE_insertStatement = 71; + public static readonly RULE_insertSimpleStatement = 72; + public static readonly RULE_insertPartitionDefinition = 73; + public static readonly RULE_valuesDefinition = 74; + public static readonly RULE_valuesRowDefinition = 75; + public static readonly RULE_insertMulStatementCompatibility = 76; + public static readonly RULE_insertMulStatement = 77; + public static readonly RULE_queryStatement = 78; + public static readonly RULE_valuesCaluse = 79; + public static readonly RULE_withClause = 80; + public static readonly RULE_withItem = 81; + public static readonly RULE_withItemName = 82; + public static readonly RULE_selectStatement = 83; + public static readonly RULE_selectClause = 84; + public static readonly RULE_projectItemDefinition = 85; + public static readonly RULE_overWindowItem = 86; + public static readonly RULE_fromClause = 87; + public static readonly RULE_tableExpression = 88; + public static readonly RULE_tableReference = 89; + public static readonly RULE_tablePrimary = 90; + public static readonly RULE_systemTimePeriod = 91; + public static readonly RULE_dateTimeExpression = 92; + public static readonly RULE_inlineDataValueClause = 93; + public static readonly RULE_windoTVFClause = 94; + public static readonly RULE_windowTVFExression = 95; + public static readonly RULE_windoTVFName = 96; + public static readonly RULE_windowTVFParam = 97; + public static readonly RULE_timeIntervalParamName = 98; + public static readonly RULE_columnDescriptor = 99; + public static readonly RULE_joinCondition = 100; + public static readonly RULE_whereClause = 101; + public static readonly RULE_groupByClause = 102; + public static readonly RULE_groupItemDefinition = 103; + public static readonly RULE_groupingSets = 104; + public static readonly RULE_groupingSetsNotaionName = 105; + public static readonly RULE_groupWindowFunction = 106; + public static readonly RULE_groupWindowFunctionName = 107; + public static readonly RULE_timeAttrColumn = 108; + public static readonly RULE_havingClause = 109; + public static readonly RULE_windowClause = 110; + public static readonly RULE_namedWindow = 111; + public static readonly RULE_windowSpec = 112; + public static readonly RULE_matchRecognizeClause = 113; + public static readonly RULE_orderByCaluse = 114; + public static readonly RULE_orderItemDefition = 115; + public static readonly RULE_limitClause = 116; + public static readonly RULE_partitionByClause = 117; + public static readonly RULE_quantifiers = 118; + public static readonly RULE_measuresClause = 119; + public static readonly RULE_patternDefination = 120; + public static readonly RULE_patternVariable = 121; + public static readonly RULE_outputMode = 122; + public static readonly RULE_afterMatchStrategy = 123; + public static readonly RULE_patternVariablesDefination = 124; + public static readonly RULE_windowFrame = 125; + public static readonly RULE_frameBound = 126; + public static readonly RULE_withinClause = 127; + public static readonly RULE_expression = 128; + public static readonly RULE_booleanExpression = 129; + public static readonly RULE_predicate = 130; + public static readonly RULE_likePredicate = 131; + public static readonly RULE_valueExpression = 132; + public static readonly RULE_primaryExpression = 133; + public static readonly RULE_functionNameCreate = 134; + public static readonly RULE_functionName = 135; + public static readonly RULE_functionParam = 136; + public static readonly RULE_dereferenceDefinition = 137; + public static readonly RULE_correlationName = 138; + public static readonly RULE_qualifiedName = 139; + public static readonly RULE_timeIntervalExpression = 140; + public static readonly RULE_errorCapturingMultiUnitsInterval = 141; + public static readonly RULE_multiUnitsInterval = 142; + public static readonly RULE_errorCapturingUnitToUnitInterval = 143; + public static readonly RULE_unitToUnitInterval = 144; + public static readonly RULE_intervalValue = 145; + public static readonly RULE_tableAlias = 146; + public static readonly RULE_errorCapturingIdentifier = 147; + public static readonly RULE_errorCapturingIdentifierExtra = 148; + public static readonly RULE_identifierList = 149; + public static readonly RULE_identifierSeq = 150; + public static readonly RULE_identifier = 151; + public static readonly RULE_unquotedIdentifier = 152; + public static readonly RULE_quotedIdentifier = 153; + public static readonly RULE_whenClause = 154; + public static readonly RULE_catalogPath = 155; + public static readonly RULE_catalogPathCreate = 156; + public static readonly RULE_databasePath = 157; + public static readonly RULE_databasePathCreate = 158; + public static readonly RULE_tablePathCreate = 159; + public static readonly RULE_tablePath = 160; + public static readonly RULE_viewPath = 161; + public static readonly RULE_viewPathCreate = 162; + public static readonly RULE_uid = 163; + public static readonly RULE_withOption = 164; + public static readonly RULE_ifNotExists = 165; + public static readonly RULE_ifExists = 166; + public static readonly RULE_tablePropertyList = 167; + public static readonly RULE_tableProperty = 168; + public static readonly RULE_tablePropertyKey = 169; + public static readonly RULE_tablePropertyValue = 170; + public static readonly RULE_logicalOperator = 171; + public static readonly RULE_comparisonOperator = 172; + public static readonly RULE_bitOperator = 173; + public static readonly RULE_mathOperator = 174; + public static readonly RULE_unaryOperator = 175; + public static readonly RULE_constant = 176; + public static readonly RULE_timePointLiteral = 177; + public static readonly RULE_stringLiteral = 178; + public static readonly RULE_decimalLiteral = 179; + public static readonly RULE_booleanLiteral = 180; + public static readonly RULE_setQuantifier = 181; + public static readonly RULE_timePointUnit = 182; + public static readonly RULE_timeIntervalUnit = 183; + public static readonly RULE_reservedKeywordsUsedAsFuncParam = 184; + public static readonly RULE_reservedKeywordsUsedAsFuncName = 185; + public static readonly RULE_nonReservedKeywords = 186; public static readonly literalNames = [ null, null, null, null, "'ABS'", "'ALL'", "'ALLOCATE'", "'ALLOW'", @@ -968,14 +967,14 @@ export class FlinkSqlParser extends SQLParserBase { "physicalColumnDefinition", "columnNameCreate", "columnName", "columnNameList", "columnType", "lengthOneDimension", "lengthTwoOptionalDimension", "lengthTwoStringDimension", "lengthOneTypeDimension", "mapTypeDimension", - "rowTypeDimension", "columnConstraint", "commentSpec", "metadataColumnDefinition", + "rowTypeDimension", "columnConstraint", "metadataColumnDefinition", "metadataKey", "computedColumnDefinition", "computedColumnExpression", "watermarkDefinition", "tableConstraint", "constraintName", "selfDefinitionClause", "partitionDefinition", "transformList", "transform", "transformArgument", "likeDefinition", "likeOption", "createCatalog", "createDatabase", "createView", "createFunction", "usingClause", "jarFileName", "alterTable", "renameDefinition", "setKeyValueDefinition", "addConstraint", "dropConstraint", - "addUnique", "notForced", "alertView", "alterDatabase", "alterFunction", + "addUnique", "notForced", "alterView", "alterDatabase", "alterFunction", "dropCatalog", "dropTable", "dropDatabase", "dropView", "dropFunction", "insertStatement", "insertSimpleStatement", "insertPartitionDefinition", "valuesDefinition", "valuesRowDefinition", "insertMulStatementCompatibility", @@ -1030,21 +1029,21 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 379; + this.state = 377; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 8 || _la === 24 || _la === 72 || ((((_la - 109)) & ~0x1F) === 0 && ((1 << (_la - 109)) & 75497601) !== 0) || _la === 177 || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & 822083585) !== 0) || ((((_la - 410)) & ~0x1F) === 0 && ((1 << (_la - 410)) & 142606353) !== 0) || _la === 450 || _la === 468 || ((((_la - 489)) & ~0x1F) === 0 && ((1 << (_la - 489)) & 134219777) !== 0) || _la === 521) { { { - this.state = 376; + this.state = 374; this.singleStatement(); } } - this.state = 381; + this.state = 379; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 382; + this.state = 380; this.match(FlinkSqlParser.EOF); } } @@ -1066,7 +1065,7 @@ export class FlinkSqlParser extends SQLParserBase { let localContext = new SingleStatementContext(this.context, this.state); this.enterRule(localContext, 2, FlinkSqlParser.RULE_singleStatement); try { - this.state = 389; + this.state = 387; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_ALTER: @@ -1092,14 +1091,14 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.LR_BRACKET: this.enterOuterAlt(localContext, 1); { - this.state = 384; + this.state = 382; this.sqlStatement(); - this.state = 386; + this.state = 384; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 1, this.context) ) { case 1: { - this.state = 385; + this.state = 383; this.match(FlinkSqlParser.SEMICOLON); } break; @@ -1109,7 +1108,7 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.SEMICOLON: this.enterOuterAlt(localContext, 2); { - this.state = 388; + this.state = 386; this.emptyStatement(); } break; @@ -1135,90 +1134,90 @@ export class FlinkSqlParser extends SQLParserBase { let localContext = new SqlStatementContext(this.context, this.state); this.enterRule(localContext, 4, FlinkSqlParser.RULE_sqlStatement); try { - this.state = 403; + this.state = 401; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 391; + this.state = 389; this.ddlStatement(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 392; + this.state = 390; this.dmlStatement(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 393; + this.state = 391; this.describeStatement(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 394; + this.state = 392; this.explainStatement(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 395; + this.state = 393; this.useStatement(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 396; + this.state = 394; this.showStatememt(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 397; + this.state = 395; this.loadStatement(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 398; + this.state = 396; this.unloadStatememt(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 399; + this.state = 397; this.setStatememt(); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 400; + this.state = 398; this.resetStatememt(); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 401; + this.state = 399; this.jarStatememt(); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 402; + this.state = 400; this.dtAddStatement(); } break; @@ -1244,7 +1243,7 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 405; + this.state = 403; this.match(FlinkSqlParser.SEMICOLON); } } @@ -1266,104 +1265,104 @@ export class FlinkSqlParser extends SQLParserBase { let localContext = new DdlStatementContext(this.context, this.state); this.enterRule(localContext, 8, FlinkSqlParser.RULE_ddlStatement); try { - this.state = 421; + this.state = 419; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 407; + this.state = 405; this.createTable(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 408; + this.state = 406; this.createDatabase(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 409; + this.state = 407; this.createView(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 410; + this.state = 408; this.createFunction(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 411; + this.state = 409; this.createCatalog(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 412; + this.state = 410; this.alterTable(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 413; - this.alertView(); + this.state = 411; + this.alterView(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 414; + this.state = 412; this.alterDatabase(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 415; + this.state = 413; this.alterFunction(); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 416; + this.state = 414; this.dropCatalog(); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 417; + this.state = 415; this.dropTable(); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 418; + this.state = 416; this.dropDatabase(); } break; case 13: this.enterOuterAlt(localContext, 13); { - this.state = 419; + this.state = 417; this.dropView(); } break; case 14: this.enterOuterAlt(localContext, 14); { - this.state = 420; + this.state = 418; this.dropFunction(); } break; @@ -1387,7 +1386,7 @@ export class FlinkSqlParser extends SQLParserBase { let localContext = new DmlStatementContext(this.context, this.state); this.enterRule(localContext, 10, FlinkSqlParser.RULE_dmlStatement); try { - this.state = 425; + this.state = 423; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_SELECT: @@ -1396,7 +1395,7 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.LR_BRACKET: this.enterOuterAlt(localContext, 1); { - this.state = 423; + this.state = 421; this.queryStatement(0); } break; @@ -1405,7 +1404,7 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.KW_INSERT: this.enterOuterAlt(localContext, 2); { - this.state = 424; + this.state = 422; this.insertStatement(); } break; @@ -1434,7 +1433,7 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 427; + this.state = 425; _la = this.tokenStream.LA(1); if(!(_la === 109 || _la === 450)) { this.errorHandler.recoverInline(this); @@ -1443,7 +1442,7 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 428; + this.state = 426; this.tablePath(); } } @@ -1467,24 +1466,24 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 430; + this.state = 428; this.match(FlinkSqlParser.KW_EXPLAIN); - this.state = 434; + this.state = 432; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_CHANGELOG_MODE: case FlinkSqlParser.KW_ESTIMATED_COST: case FlinkSqlParser.KW_JSON_EXECUTION_PLAN: { - this.state = 431; + this.state = 429; this.explainDetails(); } break; case FlinkSqlParser.KW_PLAN: { - this.state = 432; + this.state = 430; this.match(FlinkSqlParser.KW_PLAN); - this.state = 433; + this.state = 431; this.match(FlinkSqlParser.KW_FOR); } break; @@ -1500,24 +1499,24 @@ export class FlinkSqlParser extends SQLParserBase { default: break; } - this.state = 439; + this.state = 437; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 7, this.context) ) { case 1: { - this.state = 436; + this.state = 434; this.dmlStatement(); } break; case 2: { - this.state = 437; + this.state = 435; this.insertSimpleStatement(); } break; case 3: { - this.state = 438; + this.state = 436; this.insertMulStatement(); } break; @@ -1545,21 +1544,21 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 441; + this.state = 439; this.explainDetail(); - this.state = 446; + this.state = 444; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 442; + this.state = 440; this.match(FlinkSqlParser.COMMA); - this.state = 443; + this.state = 441; this.explainDetail(); } } - this.state = 448; + this.state = 446; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -1586,7 +1585,7 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 449; + this.state = 447; _la = this.tokenStream.LA(1); if(!(_la === 45 || _la === 128 || _la === 188)) { this.errorHandler.recoverInline(this); @@ -1615,33 +1614,33 @@ export class FlinkSqlParser extends SQLParserBase { let localContext = new UseStatementContext(this.context, this.state); this.enterRule(localContext, 20, FlinkSqlParser.RULE_useStatement); try { - this.state = 457; + this.state = 455; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 9, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 451; + this.state = 449; this.match(FlinkSqlParser.KW_USE); - this.state = 452; + this.state = 450; this.match(FlinkSqlParser.KW_CATALOG); - this.state = 453; + this.state = 451; this.catalogPath(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 454; + this.state = 452; this.match(FlinkSqlParser.KW_USE); - this.state = 455; + this.state = 453; this.databasePath(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 456; + this.state = 454; this.useModuleStatement(); } break; @@ -1668,25 +1667,25 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 459; + this.state = 457; this.match(FlinkSqlParser.KW_USE); - this.state = 460; + this.state = 458; this.match(FlinkSqlParser.KW_MODULES); - this.state = 461; + this.state = 459; this.uid(); - this.state = 466; + this.state = 464; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 462; + this.state = 460; this.match(FlinkSqlParser.COMMA); - this.state = 463; + this.state = 461; this.uid(); } } - this.state = 468; + this.state = 466; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -1711,15 +1710,15 @@ export class FlinkSqlParser extends SQLParserBase { this.enterRule(localContext, 24, FlinkSqlParser.RULE_showStatememt); let _la: number; try { - this.state = 511; + this.state = 509; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 18, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 469; + this.state = 467; this.match(FlinkSqlParser.KW_SHOW); - this.state = 470; + this.state = 468; _la = this.tokenStream.LA(1); if(!(_la === 42 || _la === 90 || _la === 422 || _la === 464)) { this.errorHandler.recoverInline(this); @@ -1733,11 +1732,11 @@ export class FlinkSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 471; + this.state = 469; this.match(FlinkSqlParser.KW_SHOW); - this.state = 472; + this.state = 470; this.match(FlinkSqlParser.KW_CURRENT); - this.state = 473; + this.state = 471; _la = this.tokenStream.LA(1); if(!(_la === 441 || _la === 447)) { this.errorHandler.recoverInline(this); @@ -1751,16 +1750,16 @@ export class FlinkSqlParser extends SQLParserBase { case 3: this.enterOuterAlt(localContext, 3); { - this.state = 474; + this.state = 472; this.match(FlinkSqlParser.KW_SHOW); - this.state = 475; + this.state = 473; this.match(FlinkSqlParser.KW_TABLES); - this.state = 478; + this.state = 476; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 151 || _la === 170) { { - this.state = 476; + this.state = 474; _la = this.tokenStream.LA(1); if(!(_la === 151 || _la === 170)) { this.errorHandler.recoverInline(this); @@ -1769,17 +1768,17 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 477; + this.state = 475; this.databasePath(); } } - this.state = 481; + this.state = 479; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 202 || _la === 241) { { - this.state = 480; + this.state = 478; this.likePredicate(); } } @@ -1789,11 +1788,11 @@ export class FlinkSqlParser extends SQLParserBase { case 4: this.enterOuterAlt(localContext, 4); { - this.state = 483; + this.state = 481; this.match(FlinkSqlParser.KW_SHOW); - this.state = 484; + this.state = 482; this.match(FlinkSqlParser.KW_COLUMNS); - this.state = 485; + this.state = 483; _la = this.tokenStream.LA(1); if(!(_la === 151 || _la === 170)) { this.errorHandler.recoverInline(this); @@ -1802,28 +1801,28 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 488; + this.state = 486; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 13, this.context) ) { case 1: { - this.state = 486; + this.state = 484; this.viewPath(); } break; case 2: { - this.state = 487; + this.state = 485; this.tablePath(); } break; } - this.state = 491; + this.state = 489; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 202 || _la === 241) { { - this.state = 490; + this.state = 488; this.likePredicate(); } } @@ -1833,26 +1832,26 @@ export class FlinkSqlParser extends SQLParserBase { case 5: this.enterOuterAlt(localContext, 5); { - this.state = 493; + this.state = 491; this.match(FlinkSqlParser.KW_SHOW); - this.state = 494; + this.state = 492; this.match(FlinkSqlParser.KW_CREATE); - this.state = 499; + this.state = 497; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_TABLE: { - this.state = 495; + this.state = 493; this.match(FlinkSqlParser.KW_TABLE); - this.state = 496; + this.state = 494; this.tablePath(); } break; case FlinkSqlParser.KW_VIEW: { - this.state = 497; + this.state = 495; this.match(FlinkSqlParser.KW_VIEW); - this.state = 498; + this.state = 496; this.viewPath(); } break; @@ -1864,38 +1863,38 @@ export class FlinkSqlParser extends SQLParserBase { case 6: this.enterOuterAlt(localContext, 6); { - this.state = 501; + this.state = 499; this.match(FlinkSqlParser.KW_SHOW); - this.state = 503; + this.state = 501; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 411) { { - this.state = 502; + this.state = 500; this.match(FlinkSqlParser.KW_USER); } } - this.state = 505; + this.state = 503; this.match(FlinkSqlParser.KW_FUNCTIONS); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 506; + this.state = 504; this.match(FlinkSqlParser.KW_SHOW); - this.state = 508; + this.state = 506; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 152) { { - this.state = 507; + this.state = 505; this.match(FlinkSqlParser.KW_FULL); } } - this.state = 510; + this.state = 508; this.match(FlinkSqlParser.KW_MODULES); } break; @@ -1921,20 +1920,20 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 513; + this.state = 511; this.match(FlinkSqlParser.KW_LOAD); - this.state = 514; + this.state = 512; this.match(FlinkSqlParser.KW_MODULE); - this.state = 515; + this.state = 513; this.uid(); - this.state = 518; + this.state = 516; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 19, this.context) ) { case 1: { - this.state = 516; + this.state = 514; this.match(FlinkSqlParser.KW_WITH); - this.state = 517; + this.state = 515; this.tablePropertyList(); } break; @@ -1961,11 +1960,11 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 520; + this.state = 518; this.match(FlinkSqlParser.KW_UNLOAD); - this.state = 521; + this.state = 519; this.match(FlinkSqlParser.KW_MODULE); - this.state = 522; + this.state = 520; this.uid(); } } @@ -1989,14 +1988,14 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 524; + this.state = 522; this.match(FlinkSqlParser.KW_SET); - this.state = 526; + this.state = 524; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 20, this.context) ) { case 1: { - this.state = 525; + this.state = 523; this.tableProperty(); } break; @@ -2023,14 +2022,14 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 528; + this.state = 526; this.match(FlinkSqlParser.KW_RESET); - this.state = 530; + this.state = 528; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 21, this.context) ) { case 1: { - this.state = 529; + this.state = 527; this.tablePropertyKey(); } break; @@ -2058,7 +2057,7 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 532; + this.state = 530; _la = this.tokenStream.LA(1); if(!(_la === 437 || _la === 489)) { this.errorHandler.recoverInline(this); @@ -2067,9 +2066,9 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 533; + this.state = 531; this.match(FlinkSqlParser.KW_JAR); - this.state = 534; + this.state = 532; this.jarFileName(); } } @@ -2092,28 +2091,28 @@ export class FlinkSqlParser extends SQLParserBase { this.enterRule(localContext, 36, FlinkSqlParser.RULE_dtAddStatement); let _la: number; try { - this.state = 586; + this.state = 584; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 25, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 536; + this.state = 534; this.match(FlinkSqlParser.KW_ADD); - this.state = 537; + this.state = 535; this.match(FlinkSqlParser.KW_JAR); - this.state = 538; + this.state = 536; this.match(FlinkSqlParser.KW_WITH); - this.state = 539; + this.state = 537; this.dtFilePath(); - this.state = 542; + this.state = 540; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 17) { { - this.state = 540; + this.state = 538; this.match(FlinkSqlParser.KW_AS); - this.state = 541; + this.state = 539; this.uid(); } } @@ -2123,34 +2122,34 @@ export class FlinkSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 544; + this.state = 542; this.match(FlinkSqlParser.KW_ADD); - this.state = 545; + this.state = 543; this.match(FlinkSqlParser.KW_FILE); - this.state = 546; + this.state = 544; this.match(FlinkSqlParser.KW_WITH); - this.state = 547; + this.state = 545; this.dtFilePath(); - this.state = 550; + this.state = 548; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 17) { { - this.state = 548; + this.state = 546; this.match(FlinkSqlParser.KW_AS); - this.state = 549; + this.state = 547; this.uid(); } } - this.state = 554; + this.state = 552; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 311) { { - this.state = 552; + this.state = 550; this.match(FlinkSqlParser.KW_RENAME); - this.state = 553; + this.state = 551; this.uid(); } } @@ -2160,9 +2159,9 @@ export class FlinkSqlParser extends SQLParserBase { case 3: this.enterOuterAlt(localContext, 3); { - this.state = 556; + this.state = 554; this.match(FlinkSqlParser.KW_ADD); - this.state = 557; + this.state = 555; _la = this.tokenStream.LA(1); if(!(((((_la - 482)) & ~0x1F) === 0 && ((1 << (_la - 482)) & 47) !== 0))) { this.errorHandler.recoverInline(this); @@ -2171,70 +2170,70 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 558; + this.state = 556; this.match(FlinkSqlParser.KW_WITH); - this.state = 559; + this.state = 557; this.dtFilePath(); - this.state = 560; + this.state = 558; this.match(FlinkSqlParser.KW_RENAME); - this.state = 561; + this.state = 559; this.uid(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 563; + this.state = 561; this.match(FlinkSqlParser.KW_ADD); - this.state = 564; + this.state = 562; this.match(FlinkSqlParser.KW_PYTHON_PARAMETER); - this.state = 565; + this.state = 563; this.dtFilePath(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 566; + this.state = 564; this.match(FlinkSqlParser.KW_ADD); - this.state = 567; + this.state = 565; this.match(FlinkSqlParser.KW_ENGINE); - this.state = 568; + this.state = 566; this.match(FlinkSqlParser.KW_FILE); - this.state = 569; + this.state = 567; this.match(FlinkSqlParser.KW_WITH); - this.state = 570; + this.state = 568; this.dtFilePath(); - this.state = 571; + this.state = 569; this.match(FlinkSqlParser.KW_RENAME); - this.state = 572; + this.state = 570; this.uid(); - this.state = 573; + this.state = 571; this.match(FlinkSqlParser.KW_KEY); - this.state = 574; + this.state = 572; this.uid(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 576; + this.state = 574; this.match(FlinkSqlParser.KW_ADD); - this.state = 577; + this.state = 575; this.match(FlinkSqlParser.KW_CONFIG); - this.state = 578; + this.state = 576; this.match(FlinkSqlParser.KW_FILE); - this.state = 579; + this.state = 577; this.match(FlinkSqlParser.KW_WITH); - this.state = 580; + this.state = 578; this.dtFilePath(); - this.state = 581; + this.state = 579; this.match(FlinkSqlParser.KW_FOR); - this.state = 582; + this.state = 580; this.uid(); - this.state = 583; + this.state = 581; this.match(FlinkSqlParser.KW_AS); - this.state = 584; + this.state = 582; this.uid(); } break; @@ -2262,7 +2261,7 @@ export class FlinkSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 592; + this.state = 590; this.errorHandler.sync(this); alternative = 1; do { @@ -2270,17 +2269,17 @@ export class FlinkSqlParser extends SQLParserBase { case 1: { { - this.state = 589; + this.state = 587; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 534) { { - this.state = 588; + this.state = 586; this.match(FlinkSqlParser.SLASH_SIGN); } } - this.state = 591; + this.state = 589; this.uid(); } } @@ -2288,7 +2287,7 @@ export class FlinkSqlParser extends SQLParserBase { default: throw new antlr.NoViableAltException(this); } - this.state = 594; + this.state = 592; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 27, this.context); } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); @@ -2314,18 +2313,18 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 598; + this.state = 596; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 28, this.context) ) { case 1: { - this.state = 596; + this.state = 594; this.simpleCreateTable(); } break; case 2: { - this.state = 597; + this.state = 595; this.createTableAsSelect(); } break; @@ -2354,120 +2353,122 @@ export class FlinkSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 600; + this.state = 598; this.match(FlinkSqlParser.KW_CREATE); - this.state = 602; + this.state = 600; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 497) { { - this.state = 601; + this.state = 599; this.match(FlinkSqlParser.KW_TEMPORARY); } } - this.state = 604; + this.state = 602; this.match(FlinkSqlParser.KW_TABLE); - this.state = 606; + this.state = 604; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 167) { { - this.state = 605; + this.state = 603; this.ifNotExists(); } } - this.state = 608; + this.state = 606; this.tablePathCreate(); - this.state = 609; + this.state = 607; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 610; + this.state = 608; this.columnOptionDefinition(); - this.state = 615; + this.state = 613; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 31, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 611; + this.state = 609; this.match(FlinkSqlParser.COMMA); - this.state = 612; + this.state = 610; this.columnOptionDefinition(); } } } - this.state = 617; + this.state = 615; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 31, this.context); } - this.state = 620; + this.state = 618; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 32, this.context) ) { case 1: { - this.state = 618; + this.state = 616; this.match(FlinkSqlParser.COMMA); - this.state = 619; + this.state = 617; this.watermarkDefinition(); } break; } - this.state = 624; + this.state = 622; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 33, this.context) ) { case 1: { - this.state = 622; + this.state = 620; this.match(FlinkSqlParser.COMMA); - this.state = 623; + this.state = 621; this.tableConstraint(); } break; } - this.state = 628; + this.state = 626; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 520) { { - this.state = 626; + this.state = 624; this.match(FlinkSqlParser.COMMA); - this.state = 627; + this.state = 625; this.selfDefinitionClause(); } } - this.state = 630; + this.state = 628; this.match(FlinkSqlParser.RR_BRACKET); - this.state = 632; + this.state = 631; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 59) { { - this.state = 631; - this.commentSpec(); + this.state = 629; + this.match(FlinkSqlParser.KW_COMMENT); + this.state = 630; + localContext._comment = this.match(FlinkSqlParser.STRING_LITERAL); } } - this.state = 635; + this.state = 634; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 269) { { - this.state = 634; + this.state = 633; this.partitionDefinition(); } } - this.state = 637; + this.state = 636; this.withOption(); - this.state = 639; + this.state = 638; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 202) { { - this.state = 638; + this.state = 637; this.likeDefinition(); } } @@ -2495,32 +2496,32 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 641; + this.state = 640; this.match(FlinkSqlParser.KW_CREATE); - this.state = 642; + this.state = 641; this.match(FlinkSqlParser.KW_TABLE); - this.state = 644; + this.state = 643; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 167) { { - this.state = 643; + this.state = 642; this.ifNotExists(); } } - this.state = 646; + this.state = 645; this.tablePathCreate(); - this.state = 647; + this.state = 646; this.withOption(); - this.state = 650; + this.state = 649; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 17) { { - this.state = 648; + this.state = 647; this.match(FlinkSqlParser.KW_AS); - this.state = 649; + this.state = 648; this.queryStatement(0); } } @@ -2545,27 +2546,27 @@ export class FlinkSqlParser extends SQLParserBase { let localContext = new ColumnOptionDefinitionContext(this.context, this.state); this.enterRule(localContext, 46, FlinkSqlParser.RULE_columnOptionDefinition); try { - this.state = 655; + this.state = 654; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 40, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 652; + this.state = 651; this.physicalColumnDefinition(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 653; + this.state = 652; this.metadataColumnDefinition(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 654; + this.state = 653; this.computedColumnDefinition(); } break; @@ -2592,16 +2593,16 @@ export class FlinkSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 657; + this.state = 656; this.columnNameCreate(); - this.state = 658; + this.state = 657; this.columnType(); - this.state = 660; + this.state = 659; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64 || _la === 241 || _la === 244 || _la === 288) { { - this.state = 659; + this.state = 658; this.columnConstraint(); } } @@ -2611,8 +2612,10 @@ export class FlinkSqlParser extends SQLParserBase { _la = this.tokenStream.LA(1); if (_la === 59) { { + this.state = 661; + this.match(FlinkSqlParser.KW_COMMENT); this.state = 662; - this.commentSpec(); + localContext._comment = this.match(FlinkSqlParser.STRING_LITERAL); } } @@ -2767,10 +2770,10 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 1); { this.state = 684; - localContext._typeName = this.tokenStream.LT(1); + localContext._colType = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 32 || _la === 91 || _la === 244)) { - localContext._typeName = this.errorHandler.recoverInline(this); + localContext._colType = this.errorHandler.recoverInline(this); } else { this.errorHandler.reportMatch(this); @@ -2795,10 +2798,10 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 2); { this.state = 685; - localContext._typeName = this.tokenStream.LT(1); + localContext._colType = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(((((_la - 28)) & ~0x1F) === 0 && ((1 << (_la - 28)) & 262275) !== 0) || _la === 92 || _la === 178 || _la === 179 || _la === 344 || _la === 360 || ((((_la - 378)) & ~0x1F) === 0 && ((1 << (_la - 378)) & 521) !== 0) || _la === 416 || _la === 417)) { - localContext._typeName = this.errorHandler.recoverInline(this); + localContext._colType = this.errorHandler.recoverInline(this); } else { this.errorHandler.reportMatch(this); @@ -2820,7 +2823,7 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 3); { this.state = 689; - localContext._typeName = this.match(FlinkSqlParser.KW_TIMESTAMP); + localContext._colType = this.match(FlinkSqlParser.KW_TIMESTAMP); this.state = 691; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -2872,10 +2875,10 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 4); { this.state = 701; - localContext._typeName = this.tokenStream.LT(1); + localContext._colType = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & 16387) !== 0) || _la === 144 || _la === 246)) { - localContext._typeName = this.errorHandler.recoverInline(this); + localContext._colType = this.errorHandler.recoverInline(this); } else { this.errorHandler.reportMatch(this); @@ -2898,10 +2901,10 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 5); { this.state = 705; - localContext._type_ = this.tokenStream.LT(1); + localContext._colType = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 13 || _la === 231)) { - localContext._type_ = this.errorHandler.recoverInline(this); + localContext._colType = this.errorHandler.recoverInline(this); } else { this.errorHandler.reportMatch(this); @@ -2923,7 +2926,7 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 6); { this.state = 709; - localContext._type_ = this.match(FlinkSqlParser.KW_MAP); + localContext._colType = this.match(FlinkSqlParser.KW_MAP); this.state = 711; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -2940,7 +2943,7 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 7); { this.state = 713; - localContext._type_ = this.match(FlinkSqlParser.KW_ROW); + localContext._colType = this.match(FlinkSqlParser.KW_ROW); this.state = 715; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -2957,7 +2960,7 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 8); { this.state = 717; - localContext._type_ = this.match(FlinkSqlParser.KW_RAW); + localContext._colType = this.match(FlinkSqlParser.KW_RAW); this.state = 719; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -3287,63 +3290,37 @@ export class FlinkSqlParser extends SQLParserBase { } return localContext; } - public commentSpec(): CommentSpecContext { - let localContext = new CommentSpecContext(this.context, this.state); - this.enterRule(localContext, 72, FlinkSqlParser.RULE_commentSpec); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 784; - this.match(FlinkSqlParser.KW_COMMENT); - this.state = 785; - this.match(FlinkSqlParser.STRING_LITERAL); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public metadataColumnDefinition(): MetadataColumnDefinitionContext { let localContext = new MetadataColumnDefinitionContext(this.context, this.state); - this.enterRule(localContext, 74, FlinkSqlParser.RULE_metadataColumnDefinition); + this.enterRule(localContext, 72, FlinkSqlParser.RULE_metadataColumnDefinition); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 787; + this.state = 784; this.columnNameCreate(); - this.state = 788; + this.state = 785; this.columnType(); - this.state = 789; + this.state = 786; this.match(FlinkSqlParser.KW_METADATA); - this.state = 792; + this.state = 789; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 151) { { - this.state = 790; + this.state = 787; this.match(FlinkSqlParser.KW_FROM); - this.state = 791; + this.state = 788; this.metadataKey(); } } - this.state = 795; + this.state = 792; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 423) { { - this.state = 794; + this.state = 791; this.match(FlinkSqlParser.KW_VIRTUAL); } } @@ -3366,11 +3343,11 @@ export class FlinkSqlParser extends SQLParserBase { } public metadataKey(): MetadataKeyContext { let localContext = new MetadataKeyContext(this.context, this.state); - this.enterRule(localContext, 76, FlinkSqlParser.RULE_metadataKey); + this.enterRule(localContext, 74, FlinkSqlParser.RULE_metadataKey); try { this.enterOuterAlt(localContext, 1); { - this.state = 797; + this.state = 794; this.match(FlinkSqlParser.STRING_LITERAL); } } @@ -3390,24 +3367,26 @@ export class FlinkSqlParser extends SQLParserBase { } public computedColumnDefinition(): ComputedColumnDefinitionContext { let localContext = new ComputedColumnDefinitionContext(this.context, this.state); - this.enterRule(localContext, 78, FlinkSqlParser.RULE_computedColumnDefinition); + this.enterRule(localContext, 76, FlinkSqlParser.RULE_computedColumnDefinition); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 799; + this.state = 796; this.columnNameCreate(); - this.state = 800; + this.state = 797; this.match(FlinkSqlParser.KW_AS); - this.state = 801; + this.state = 798; this.computedColumnExpression(); - this.state = 803; + this.state = 801; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 59) { { - this.state = 802; - this.commentSpec(); + this.state = 799; + this.match(FlinkSqlParser.KW_COMMENT); + this.state = 800; + localContext._comment = this.match(FlinkSqlParser.STRING_LITERAL); } } @@ -3429,11 +3408,11 @@ export class FlinkSqlParser extends SQLParserBase { } public computedColumnExpression(): ComputedColumnExpressionContext { let localContext = new ComputedColumnExpressionContext(this.context, this.state); - this.enterRule(localContext, 80, FlinkSqlParser.RULE_computedColumnExpression); + this.enterRule(localContext, 78, FlinkSqlParser.RULE_computedColumnExpression); try { this.enterOuterAlt(localContext, 1); { - this.state = 805; + this.state = 803; this.expression(); } } @@ -3453,19 +3432,19 @@ export class FlinkSqlParser extends SQLParserBase { } public watermarkDefinition(): WatermarkDefinitionContext { let localContext = new WatermarkDefinitionContext(this.context, this.state); - this.enterRule(localContext, 82, FlinkSqlParser.RULE_watermarkDefinition); + this.enterRule(localContext, 80, FlinkSqlParser.RULE_watermarkDefinition); try { this.enterOuterAlt(localContext, 1); { - this.state = 807; + this.state = 805; this.match(FlinkSqlParser.KW_WATERMARK); - this.state = 808; + this.state = 806; this.match(FlinkSqlParser.KW_FOR); - this.state = 809; + this.state = 807; this.columnName(); - this.state = 810; + this.state = 808; this.match(FlinkSqlParser.KW_AS); - this.state = 811; + this.state = 809; this.expression(); } } @@ -3485,32 +3464,32 @@ export class FlinkSqlParser extends SQLParserBase { } public tableConstraint(): TableConstraintContext { let localContext = new TableConstraintContext(this.context, this.state); - this.enterRule(localContext, 84, FlinkSqlParser.RULE_tableConstraint); + this.enterRule(localContext, 82, FlinkSqlParser.RULE_tableConstraint); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 815; + this.state = 813; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64) { { - this.state = 813; + this.state = 811; this.match(FlinkSqlParser.KW_CONSTRAINT); - this.state = 814; + this.state = 812; this.constraintName(); } } - this.state = 817; + this.state = 815; this.match(FlinkSqlParser.KW_PRIMARY); - this.state = 818; + this.state = 816; this.match(FlinkSqlParser.KW_KEY); - this.state = 819; + this.state = 817; this.columnNameList(); - this.state = 820; + this.state = 818; this.match(FlinkSqlParser.KW_NOT); - this.state = 821; + this.state = 819; this.match(FlinkSqlParser.KW_ENFORCED); } } @@ -3530,11 +3509,11 @@ export class FlinkSqlParser extends SQLParserBase { } public constraintName(): ConstraintNameContext { let localContext = new ConstraintNameContext(this.context, this.state); - this.enterRule(localContext, 86, FlinkSqlParser.RULE_constraintName); + this.enterRule(localContext, 84, FlinkSqlParser.RULE_constraintName); try { this.enterOuterAlt(localContext, 1); { - this.state = 823; + this.state = 821; this.identifier(); } } @@ -3554,15 +3533,15 @@ export class FlinkSqlParser extends SQLParserBase { } public selfDefinitionClause(): SelfDefinitionClauseContext { let localContext = new SelfDefinitionClauseContext(this.context, this.state); - this.enterRule(localContext, 88, FlinkSqlParser.RULE_selfDefinitionClause); + this.enterRule(localContext, 86, FlinkSqlParser.RULE_selfDefinitionClause); try { this.enterOuterAlt(localContext, 1); { - this.state = 825; + this.state = 823; this.match(FlinkSqlParser.KW_PERIOD); - this.state = 826; + this.state = 824; this.match(FlinkSqlParser.KW_FOR); - this.state = 827; + this.state = 825; this.match(FlinkSqlParser.KW_SYSTEM_TIME); } } @@ -3582,15 +3561,15 @@ export class FlinkSqlParser extends SQLParserBase { } public partitionDefinition(): PartitionDefinitionContext { let localContext = new PartitionDefinitionContext(this.context, this.state); - this.enterRule(localContext, 90, FlinkSqlParser.RULE_partitionDefinition); + this.enterRule(localContext, 88, FlinkSqlParser.RULE_partitionDefinition); try { this.enterOuterAlt(localContext, 1); { - this.state = 829; + this.state = 827; this.match(FlinkSqlParser.KW_PARTITIONED); - this.state = 830; + this.state = 828; this.match(FlinkSqlParser.KW_BY); - this.state = 831; + this.state = 829; this.transformList(); } } @@ -3610,32 +3589,32 @@ export class FlinkSqlParser extends SQLParserBase { } public transformList(): TransformListContext { let localContext = new TransformListContext(this.context, this.state); - this.enterRule(localContext, 92, FlinkSqlParser.RULE_transformList); + this.enterRule(localContext, 90, FlinkSqlParser.RULE_transformList); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 833; + this.state = 831; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 834; + this.state = 832; this.transform(); - this.state = 839; + this.state = 837; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 835; + this.state = 833; this.match(FlinkSqlParser.COMMA); - this.state = 836; + this.state = 834; this.transform(); } } - this.state = 841; + this.state = 839; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 842; + this.state = 840; this.match(FlinkSqlParser.RR_BRACKET); } } @@ -3655,17 +3634,17 @@ export class FlinkSqlParser extends SQLParserBase { } public transform(): TransformContext { let localContext = new TransformContext(this.context, this.state); - this.enterRule(localContext, 94, FlinkSqlParser.RULE_transform); + this.enterRule(localContext, 92, FlinkSqlParser.RULE_transform); let _la: number; try { - this.state = 856; + this.state = 854; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 69, this.context) ) { case 1: localContext = new IdentityTransformContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 844; + this.state = 842; this.columnName(); } break; @@ -3673,27 +3652,27 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ApplyTransformContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 845; + this.state = 843; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 846; + this.state = 844; this.transformArgument(); - this.state = 851; + this.state = 849; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 847; + this.state = 845; this.match(FlinkSqlParser.COMMA); - this.state = 848; + this.state = 846; this.transformArgument(); } } - this.state = 853; + this.state = 851; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 854; + this.state = 852; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -3715,22 +3694,22 @@ export class FlinkSqlParser extends SQLParserBase { } public transformArgument(): TransformArgumentContext { let localContext = new TransformArgumentContext(this.context, this.state); - this.enterRule(localContext, 96, FlinkSqlParser.RULE_transformArgument); + this.enterRule(localContext, 94, FlinkSqlParser.RULE_transformArgument); try { - this.state = 860; + this.state = 858; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 70, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 858; + this.state = 856; this.qualifiedName(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 859; + this.state = 857; this.constant(); } break; @@ -3752,37 +3731,37 @@ export class FlinkSqlParser extends SQLParserBase { } public likeDefinition(): LikeDefinitionContext { let localContext = new LikeDefinitionContext(this.context, this.state); - this.enterRule(localContext, 98, FlinkSqlParser.RULE_likeDefinition); + this.enterRule(localContext, 96, FlinkSqlParser.RULE_likeDefinition); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 862; + this.state = 860; this.match(FlinkSqlParser.KW_LIKE); - this.state = 863; + this.state = 861; this.tablePath(); - this.state = 872; + this.state = 870; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 72, this.context) ) { case 1: { - this.state = 864; + this.state = 862; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 868; + this.state = 866; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 266 || _la === 455 || _la === 462) { { { - this.state = 865; + this.state = 863; this.likeOption(); } } - this.state = 870; + this.state = 868; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 871; + this.state = 869; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -3805,17 +3784,17 @@ export class FlinkSqlParser extends SQLParserBase { } public likeOption(): LikeOptionContext { let localContext = new LikeOptionContext(this.context, this.state); - this.enterRule(localContext, 100, FlinkSqlParser.RULE_likeOption); + this.enterRule(localContext, 98, FlinkSqlParser.RULE_likeOption); let _la: number; try { - this.state = 878; + this.state = 876; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 73, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { { - this.state = 874; + this.state = 872; _la = this.tokenStream.LA(1); if(!(_la === 455 || _la === 462)) { this.errorHandler.recoverInline(this); @@ -3824,7 +3803,7 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 875; + this.state = 873; _la = this.tokenStream.LA(1); if(!(_la === 5 || _la === 270 || _la === 444)) { this.errorHandler.recoverInline(this); @@ -3840,7 +3819,7 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 2); { { - this.state = 876; + this.state = 874; _la = this.tokenStream.LA(1); if(!(_la === 266 || _la === 455 || _la === 462)) { this.errorHandler.recoverInline(this); @@ -3849,7 +3828,7 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 877; + this.state = 875; _la = this.tokenStream.LA(1); if(!(_la === 425 || _la === 458 || _la === 477)) { this.errorHandler.recoverInline(this); @@ -3879,17 +3858,17 @@ export class FlinkSqlParser extends SQLParserBase { } public createCatalog(): CreateCatalogContext { let localContext = new CreateCatalogContext(this.context, this.state); - this.enterRule(localContext, 102, FlinkSqlParser.RULE_createCatalog); + this.enterRule(localContext, 100, FlinkSqlParser.RULE_createCatalog); try { this.enterOuterAlt(localContext, 1); { - this.state = 880; + this.state = 878; this.match(FlinkSqlParser.KW_CREATE); - this.state = 881; + this.state = 879; this.match(FlinkSqlParser.KW_CATALOG); - this.state = 882; + this.state = 880; this.catalogPathCreate(); - this.state = 883; + this.state = 881; this.withOption(); } } @@ -3909,38 +3888,40 @@ export class FlinkSqlParser extends SQLParserBase { } public createDatabase(): CreateDatabaseContext { let localContext = new CreateDatabaseContext(this.context, this.state); - this.enterRule(localContext, 104, FlinkSqlParser.RULE_createDatabase); + this.enterRule(localContext, 102, FlinkSqlParser.RULE_createDatabase); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 885; + this.state = 883; this.match(FlinkSqlParser.KW_CREATE); - this.state = 886; + this.state = 884; this.match(FlinkSqlParser.KW_DATABASE); - this.state = 888; + this.state = 886; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 167) { { - this.state = 887; + this.state = 885; this.ifNotExists(); } } - this.state = 890; + this.state = 888; this.databasePathCreate(); - this.state = 892; + this.state = 891; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 59) { { - this.state = 891; - this.commentSpec(); + this.state = 889; + this.match(FlinkSqlParser.KW_COMMENT); + this.state = 890; + localContext._comment = this.match(FlinkSqlParser.STRING_LITERAL); } } - this.state = 894; + this.state = 893; this.withOption(); } } @@ -3960,43 +3941,43 @@ export class FlinkSqlParser extends SQLParserBase { } public createView(): CreateViewContext { let localContext = new CreateViewContext(this.context, this.state); - this.enterRule(localContext, 106, FlinkSqlParser.RULE_createView); + this.enterRule(localContext, 104, FlinkSqlParser.RULE_createView); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 896; + this.state = 895; this.match(FlinkSqlParser.KW_CREATE); - this.state = 898; + this.state = 897; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 497) { { - this.state = 897; + this.state = 896; this.match(FlinkSqlParser.KW_TEMPORARY); } } - this.state = 900; + this.state = 899; this.match(FlinkSqlParser.KW_VIEW); - this.state = 902; + this.state = 901; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 167) { { - this.state = 901; + this.state = 900; this.ifNotExists(); } } - this.state = 904; + this.state = 903; this.viewPathCreate(); - this.state = 906; + this.state = 905; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 516) { { - this.state = 905; + this.state = 904; this.columnNameList(); } } @@ -4006,8 +3987,10 @@ export class FlinkSqlParser extends SQLParserBase { _la = this.tokenStream.LA(1); if (_la === 59) { { + this.state = 907; + this.match(FlinkSqlParser.KW_COMMENT); this.state = 908; - this.commentSpec(); + localContext._comment = this.match(FlinkSqlParser.STRING_LITERAL); } } @@ -4033,7 +4016,7 @@ export class FlinkSqlParser extends SQLParserBase { } public createFunction(): CreateFunctionContext { let localContext = new CreateFunctionContext(this.context, this.state); - this.enterRule(localContext, 108, FlinkSqlParser.RULE_createFunction); + this.enterRule(localContext, 106, FlinkSqlParser.RULE_createFunction); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4123,7 +4106,7 @@ export class FlinkSqlParser extends SQLParserBase { } public usingClause(): UsingClauseContext { let localContext = new UsingClauseContext(this.context, this.state); - this.enterRule(localContext, 110, FlinkSqlParser.RULE_usingClause); + this.enterRule(localContext, 108, FlinkSqlParser.RULE_usingClause); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4170,7 +4153,7 @@ export class FlinkSqlParser extends SQLParserBase { } public jarFileName(): JarFileNameContext { let localContext = new JarFileNameContext(this.context, this.state); - this.enterRule(localContext, 112, FlinkSqlParser.RULE_jarFileName); + this.enterRule(localContext, 110, FlinkSqlParser.RULE_jarFileName); try { this.enterOuterAlt(localContext, 1); { @@ -4194,7 +4177,7 @@ export class FlinkSqlParser extends SQLParserBase { } public alterTable(): AlterTableContext { let localContext = new AlterTableContext(this.context, this.state); - this.enterRule(localContext, 114, FlinkSqlParser.RULE_alterTable); + this.enterRule(localContext, 112, FlinkSqlParser.RULE_alterTable); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4267,7 +4250,7 @@ export class FlinkSqlParser extends SQLParserBase { } public renameDefinition(): RenameDefinitionContext { let localContext = new RenameDefinitionContext(this.context, this.state); - this.enterRule(localContext, 116, FlinkSqlParser.RULE_renameDefinition); + this.enterRule(localContext, 114, FlinkSqlParser.RULE_renameDefinition); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4306,7 +4289,7 @@ export class FlinkSqlParser extends SQLParserBase { } public setKeyValueDefinition(): SetKeyValueDefinitionContext { let localContext = new SetKeyValueDefinitionContext(this.context, this.state); - this.enterRule(localContext, 118, FlinkSqlParser.RULE_setKeyValueDefinition); + this.enterRule(localContext, 116, FlinkSqlParser.RULE_setKeyValueDefinition); try { this.enterOuterAlt(localContext, 1); { @@ -4332,7 +4315,7 @@ export class FlinkSqlParser extends SQLParserBase { } public addConstraint(): AddConstraintContext { let localContext = new AddConstraintContext(this.context, this.state); - this.enterRule(localContext, 120, FlinkSqlParser.RULE_addConstraint); + this.enterRule(localContext, 118, FlinkSqlParser.RULE_addConstraint); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4377,7 +4360,7 @@ export class FlinkSqlParser extends SQLParserBase { } public dropConstraint(): DropConstraintContext { let localContext = new DropConstraintContext(this.context, this.state); - this.enterRule(localContext, 122, FlinkSqlParser.RULE_dropConstraint); + this.enterRule(localContext, 120, FlinkSqlParser.RULE_dropConstraint); try { this.enterOuterAlt(localContext, 1); { @@ -4405,7 +4388,7 @@ export class FlinkSqlParser extends SQLParserBase { } public addUnique(): AddUniqueContext { let localContext = new AddUniqueContext(this.context, this.state); - this.enterRule(localContext, 124, FlinkSqlParser.RULE_addUnique); + this.enterRule(localContext, 122, FlinkSqlParser.RULE_addUnique); try { this.enterOuterAlt(localContext, 1); { @@ -4433,7 +4416,7 @@ export class FlinkSqlParser extends SQLParserBase { } public notForced(): NotForcedContext { let localContext = new NotForcedContext(this.context, this.state); - this.enterRule(localContext, 126, FlinkSqlParser.RULE_notForced); + this.enterRule(localContext, 124, FlinkSqlParser.RULE_notForced); try { this.enterOuterAlt(localContext, 1); { @@ -4457,9 +4440,9 @@ export class FlinkSqlParser extends SQLParserBase { } return localContext; } - public alertView(): AlertViewContext { - let localContext = new AlertViewContext(this.context, this.state); - this.enterRule(localContext, 128, FlinkSqlParser.RULE_alertView); + public alterView(): AlterViewContext { + let localContext = new AlterViewContext(this.context, this.state); + this.enterRule(localContext, 126, FlinkSqlParser.RULE_alterView); try { this.enterOuterAlt(localContext, 1); { @@ -4507,7 +4490,7 @@ export class FlinkSqlParser extends SQLParserBase { } public alterDatabase(): AlterDatabaseContext { let localContext = new AlterDatabaseContext(this.context, this.state); - this.enterRule(localContext, 130, FlinkSqlParser.RULE_alterDatabase); + this.enterRule(localContext, 128, FlinkSqlParser.RULE_alterDatabase); try { this.enterOuterAlt(localContext, 1); { @@ -4537,7 +4520,7 @@ export class FlinkSqlParser extends SQLParserBase { } public alterFunction(): AlterFunctionContext { let localContext = new AlterFunctionContext(this.context, this.state); - this.enterRule(localContext, 132, FlinkSqlParser.RULE_alterFunction); + this.enterRule(localContext, 130, FlinkSqlParser.RULE_alterFunction); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4617,7 +4600,7 @@ export class FlinkSqlParser extends SQLParserBase { } public dropCatalog(): DropCatalogContext { let localContext = new DropCatalogContext(this.context, this.state); - this.enterRule(localContext, 134, FlinkSqlParser.RULE_dropCatalog); + this.enterRule(localContext, 132, FlinkSqlParser.RULE_dropCatalog); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4656,7 +4639,7 @@ export class FlinkSqlParser extends SQLParserBase { } public dropTable(): DropTableContext { let localContext = new DropTableContext(this.context, this.state); - this.enterRule(localContext, 136, FlinkSqlParser.RULE_dropTable); + this.enterRule(localContext, 134, FlinkSqlParser.RULE_dropTable); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4705,7 +4688,7 @@ export class FlinkSqlParser extends SQLParserBase { } public dropDatabase(): DropDatabaseContext { let localContext = new DropDatabaseContext(this.context, this.state); - this.enterRule(localContext, 138, FlinkSqlParser.RULE_dropDatabase); + this.enterRule(localContext, 136, FlinkSqlParser.RULE_dropDatabase); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4762,7 +4745,7 @@ export class FlinkSqlParser extends SQLParserBase { } public dropView(): DropViewContext { let localContext = new DropViewContext(this.context, this.state); - this.enterRule(localContext, 140, FlinkSqlParser.RULE_dropView); + this.enterRule(localContext, 138, FlinkSqlParser.RULE_dropView); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -4811,7 +4794,7 @@ export class FlinkSqlParser extends SQLParserBase { } public dropFunction(): DropFunctionContext { let localContext = new DropFunctionContext(this.context, this.state); - this.enterRule(localContext, 142, FlinkSqlParser.RULE_dropFunction); + this.enterRule(localContext, 140, FlinkSqlParser.RULE_dropFunction); try { this.enterOuterAlt(localContext, 1); { @@ -4867,7 +4850,7 @@ export class FlinkSqlParser extends SQLParserBase { } public insertStatement(): InsertStatementContext { let localContext = new InsertStatementContext(this.context, this.state); - this.enterRule(localContext, 144, FlinkSqlParser.RULE_insertStatement); + this.enterRule(localContext, 142, FlinkSqlParser.RULE_insertStatement); let _la: number; try { this.state = 1075; @@ -4928,7 +4911,7 @@ export class FlinkSqlParser extends SQLParserBase { } public insertSimpleStatement(): InsertSimpleStatementContext { let localContext = new InsertSimpleStatementContext(this.context, this.state); - this.enterRule(localContext, 146, FlinkSqlParser.RULE_insertSimpleStatement); + this.enterRule(localContext, 144, FlinkSqlParser.RULE_insertSimpleStatement); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -5000,7 +4983,7 @@ export class FlinkSqlParser extends SQLParserBase { } public insertPartitionDefinition(): InsertPartitionDefinitionContext { let localContext = new InsertPartitionDefinitionContext(this.context, this.state); - this.enterRule(localContext, 148, FlinkSqlParser.RULE_insertPartitionDefinition); + this.enterRule(localContext, 146, FlinkSqlParser.RULE_insertPartitionDefinition); try { this.enterOuterAlt(localContext, 1); { @@ -5026,7 +5009,7 @@ export class FlinkSqlParser extends SQLParserBase { } public valuesDefinition(): ValuesDefinitionContext { let localContext = new ValuesDefinitionContext(this.context, this.state); - this.enterRule(localContext, 150, FlinkSqlParser.RULE_valuesDefinition); + this.enterRule(localContext, 148, FlinkSqlParser.RULE_valuesDefinition); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -5069,7 +5052,7 @@ export class FlinkSqlParser extends SQLParserBase { } public valuesRowDefinition(): ValuesRowDefinitionContext { let localContext = new ValuesRowDefinitionContext(this.context, this.state); - this.enterRule(localContext, 152, FlinkSqlParser.RULE_valuesRowDefinition); + this.enterRule(localContext, 150, FlinkSqlParser.RULE_valuesRowDefinition); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -5114,7 +5097,7 @@ export class FlinkSqlParser extends SQLParserBase { } public insertMulStatementCompatibility(): InsertMulStatementCompatibilityContext { let localContext = new InsertMulStatementCompatibilityContext(this.context, this.state); - this.enterRule(localContext, 154, FlinkSqlParser.RULE_insertMulStatementCompatibility); + this.enterRule(localContext, 152, FlinkSqlParser.RULE_insertMulStatementCompatibility); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -5163,7 +5146,7 @@ export class FlinkSqlParser extends SQLParserBase { } public insertMulStatement(): InsertMulStatementContext { let localContext = new InsertMulStatementContext(this.context, this.state); - this.enterRule(localContext, 156, FlinkSqlParser.RULE_insertMulStatement); + this.enterRule(localContext, 154, FlinkSqlParser.RULE_insertMulStatement); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -5220,8 +5203,8 @@ export class FlinkSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new QueryStatementContext(this.context, parentState); let previousContext = localContext; - let _startState = 158; - this.enterRecursionRule(localContext, 158, FlinkSqlParser.RULE_queryStatement, _p); + let _startState = 156; + this.enterRecursionRule(localContext, 156, FlinkSqlParser.RULE_queryStatement, _p); let _la: number; try { let alternative: number; @@ -5393,7 +5376,7 @@ export class FlinkSqlParser extends SQLParserBase { } public valuesCaluse(): ValuesCaluseContext { let localContext = new ValuesCaluseContext(this.context, this.state); - this.enterRule(localContext, 160, FlinkSqlParser.RULE_valuesCaluse); + this.enterRule(localContext, 158, FlinkSqlParser.RULE_valuesCaluse); try { let alternative: number; this.enterOuterAlt(localContext, 1); @@ -5438,7 +5421,7 @@ export class FlinkSqlParser extends SQLParserBase { } public withClause(): WithClauseContext { let localContext = new WithClauseContext(this.context, this.state); - this.enterRule(localContext, 162, FlinkSqlParser.RULE_withClause); + this.enterRule(localContext, 160, FlinkSqlParser.RULE_withClause); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -5481,7 +5464,7 @@ export class FlinkSqlParser extends SQLParserBase { } public withItem(): WithItemContext { let localContext = new WithItemContext(this.context, this.state); - this.enterRule(localContext, 164, FlinkSqlParser.RULE_withItem); + this.enterRule(localContext, 162, FlinkSqlParser.RULE_withItem); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -5544,7 +5527,7 @@ export class FlinkSqlParser extends SQLParserBase { } public withItemName(): WithItemNameContext { let localContext = new WithItemNameContext(this.context, this.state); - this.enterRule(localContext, 166, FlinkSqlParser.RULE_withItemName); + this.enterRule(localContext, 164, FlinkSqlParser.RULE_withItemName); try { this.enterOuterAlt(localContext, 1); { @@ -5568,7 +5551,7 @@ export class FlinkSqlParser extends SQLParserBase { } public selectStatement(): SelectStatementContext { let localContext = new SelectStatementContext(this.context, this.state); - this.enterRule(localContext, 168, FlinkSqlParser.RULE_selectStatement); + this.enterRule(localContext, 166, FlinkSqlParser.RULE_selectStatement); try { this.state = 1239; this.errorHandler.sync(this); @@ -5659,7 +5642,7 @@ export class FlinkSqlParser extends SQLParserBase { } public selectClause(): SelectClauseContext { let localContext = new SelectClauseContext(this.context, this.state); - this.enterRule(localContext, 170, FlinkSqlParser.RULE_selectClause); + this.enterRule(localContext, 168, FlinkSqlParser.RULE_selectClause); try { let alternative: number; this.enterOuterAlt(localContext, 1); @@ -5728,7 +5711,7 @@ export class FlinkSqlParser extends SQLParserBase { } public projectItemDefinition(): ProjectItemDefinitionContext { let localContext = new ProjectItemDefinitionContext(this.context, this.state); - this.enterRule(localContext, 172, FlinkSqlParser.RULE_projectItemDefinition); + this.enterRule(localContext, 170, FlinkSqlParser.RULE_projectItemDefinition); let _la: number; try { this.state = 1271; @@ -5813,7 +5796,7 @@ export class FlinkSqlParser extends SQLParserBase { } public overWindowItem(): OverWindowItemContext { let localContext = new OverWindowItemContext(this.context, this.state); - this.enterRule(localContext, 174, FlinkSqlParser.RULE_overWindowItem); + this.enterRule(localContext, 172, FlinkSqlParser.RULE_overWindowItem); try { this.state = 1285; this.errorHandler.sync(this); @@ -5866,7 +5849,7 @@ export class FlinkSqlParser extends SQLParserBase { } public fromClause(): FromClauseContext { let localContext = new FromClauseContext(this.context, this.state); - this.enterRule(localContext, 176, FlinkSqlParser.RULE_fromClause); + this.enterRule(localContext, 174, FlinkSqlParser.RULE_fromClause); try { this.enterOuterAlt(localContext, 1); { @@ -5902,8 +5885,8 @@ export class FlinkSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new TableExpressionContext(this.context, parentState); let previousContext = localContext; - let _startState = 178; - this.enterRecursionRule(localContext, 178, FlinkSqlParser.RULE_tableExpression, _p); + let _startState = 176; + this.enterRecursionRule(localContext, 176, FlinkSqlParser.RULE_tableExpression, _p); let _la: number; try { let alternative: number; @@ -6065,7 +6048,7 @@ export class FlinkSqlParser extends SQLParserBase { } public tableReference(): TableReferenceContext { let localContext = new TableReferenceContext(this.context, this.state); - this.enterRule(localContext, 180, FlinkSqlParser.RULE_tableReference); + this.enterRule(localContext, 178, FlinkSqlParser.RULE_tableReference); try { this.enterOuterAlt(localContext, 1); { @@ -6099,12 +6082,12 @@ export class FlinkSqlParser extends SQLParserBase { } public tablePrimary(): TablePrimaryContext { let localContext = new TablePrimaryContext(this.context, this.state); - this.enterRule(localContext, 182, FlinkSqlParser.RULE_tablePrimary); + this.enterRule(localContext, 180, FlinkSqlParser.RULE_tablePrimary); let _la: number; try { - this.state = 1382; + this.state = 1370; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 157, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 153, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { @@ -6130,133 +6113,93 @@ export class FlinkSqlParser extends SQLParserBase { } break; } - this.state = 1342; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 151, this.context) ) { - case 1: - { - this.state = 1339; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 17) { - { - this.state = 1338; - this.match(FlinkSqlParser.KW_AS); - } - } - - this.state = 1341; - this.correlationName(); - } - break; - } } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1344; + this.state = 1338; this.viewPath(); - this.state = 1346; + this.state = 1340; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 152, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 150, this.context) ) { case 1: { - this.state = 1345; + this.state = 1339; this.systemTimePeriod(); } break; } - this.state = 1352; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 154, this.context) ) { - case 1: - { - this.state = 1349; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 17) { - { - this.state = 1348; - this.match(FlinkSqlParser.KW_AS); - } - } - - this.state = 1351; - this.correlationName(); - } - break; - } } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1354; + this.state = 1342; this.match(FlinkSqlParser.KW_LATERAL); - this.state = 1355; + this.state = 1343; this.match(FlinkSqlParser.KW_TABLE); - this.state = 1356; + this.state = 1344; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1357; + this.state = 1345; this.functionName(); - this.state = 1358; + this.state = 1346; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1359; + this.state = 1347; this.functionParam(); - this.state = 1364; + this.state = 1352; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1360; + this.state = 1348; this.match(FlinkSqlParser.COMMA); - this.state = 1361; + this.state = 1349; this.functionParam(); } } - this.state = 1366; + this.state = 1354; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1367; + this.state = 1355; this.match(FlinkSqlParser.RR_BRACKET); - this.state = 1368; + this.state = 1356; this.match(FlinkSqlParser.RR_BRACKET); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1371; + this.state = 1359; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 198) { { - this.state = 1370; + this.state = 1358; this.match(FlinkSqlParser.KW_LATERAL); } } - this.state = 1373; + this.state = 1361; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1374; + this.state = 1362; this.queryStatement(0); - this.state = 1375; + this.state = 1363; this.match(FlinkSqlParser.RR_BRACKET); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 1377; + this.state = 1365; this.match(FlinkSqlParser.KW_UNNEST); - this.state = 1378; + this.state = 1366; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1379; + this.state = 1367; this.expression(); - this.state = 1380; + this.state = 1368; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -6278,19 +6221,19 @@ export class FlinkSqlParser extends SQLParserBase { } public systemTimePeriod(): SystemTimePeriodContext { let localContext = new SystemTimePeriodContext(this.context, this.state); - this.enterRule(localContext, 184, FlinkSqlParser.RULE_systemTimePeriod); + this.enterRule(localContext, 182, FlinkSqlParser.RULE_systemTimePeriod); try { this.enterOuterAlt(localContext, 1); { - this.state = 1384; + this.state = 1372; this.match(FlinkSqlParser.KW_FOR); - this.state = 1385; + this.state = 1373; this.match(FlinkSqlParser.KW_SYSTEM_TIME); - this.state = 1386; + this.state = 1374; this.match(FlinkSqlParser.KW_AS); - this.state = 1387; + this.state = 1375; this.match(FlinkSqlParser.KW_OF); - this.state = 1388; + this.state = 1376; this.dateTimeExpression(); } } @@ -6310,11 +6253,11 @@ export class FlinkSqlParser extends SQLParserBase { } public dateTimeExpression(): DateTimeExpressionContext { let localContext = new DateTimeExpressionContext(this.context, this.state); - this.enterRule(localContext, 186, FlinkSqlParser.RULE_dateTimeExpression); + this.enterRule(localContext, 184, FlinkSqlParser.RULE_dateTimeExpression); try { this.enterOuterAlt(localContext, 1); { - this.state = 1390; + this.state = 1378; this.expression(); } } @@ -6334,17 +6277,17 @@ export class FlinkSqlParser extends SQLParserBase { } public inlineDataValueClause(): InlineDataValueClauseContext { let localContext = new InlineDataValueClauseContext(this.context, this.state); - this.enterRule(localContext, 188, FlinkSqlParser.RULE_inlineDataValueClause); + this.enterRule(localContext, 186, FlinkSqlParser.RULE_inlineDataValueClause); try { this.enterOuterAlt(localContext, 1); { - this.state = 1392; + this.state = 1380; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1393; + this.state = 1381; this.valuesDefinition(); - this.state = 1394; + this.state = 1382; this.match(FlinkSqlParser.RR_BRACKET); - this.state = 1395; + this.state = 1383; this.tableAlias(); } } @@ -6364,17 +6307,17 @@ export class FlinkSqlParser extends SQLParserBase { } public windoTVFClause(): WindoTVFClauseContext { let localContext = new WindoTVFClauseContext(this.context, this.state); - this.enterRule(localContext, 190, FlinkSqlParser.RULE_windoTVFClause); + this.enterRule(localContext, 188, FlinkSqlParser.RULE_windoTVFClause); try { this.enterOuterAlt(localContext, 1); { - this.state = 1397; + this.state = 1385; this.match(FlinkSqlParser.KW_TABLE); - this.state = 1398; + this.state = 1386; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1399; + this.state = 1387; this.windowTVFExression(); - this.state = 1400; + this.state = 1388; this.match(FlinkSqlParser.RR_BRACKET); } } @@ -6394,34 +6337,34 @@ export class FlinkSqlParser extends SQLParserBase { } public windowTVFExression(): WindowTVFExressionContext { let localContext = new WindowTVFExressionContext(this.context, this.state); - this.enterRule(localContext, 192, FlinkSqlParser.RULE_windowTVFExression); + this.enterRule(localContext, 190, FlinkSqlParser.RULE_windowTVFExression); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1402; + this.state = 1390; this.windoTVFName(); - this.state = 1403; + this.state = 1391; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1404; + this.state = 1392; this.windowTVFParam(); - this.state = 1409; + this.state = 1397; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1405; + this.state = 1393; this.match(FlinkSqlParser.COMMA); - this.state = 1406; + this.state = 1394; this.windowTVFParam(); } } - this.state = 1411; + this.state = 1399; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1412; + this.state = 1400; this.match(FlinkSqlParser.RR_BRACKET); } } @@ -6441,12 +6384,12 @@ export class FlinkSqlParser extends SQLParserBase { } public windoTVFName(): WindoTVFNameContext { let localContext = new WindoTVFNameContext(this.context, this.state); - this.enterRule(localContext, 194, FlinkSqlParser.RULE_windoTVFName); + this.enterRule(localContext, 192, FlinkSqlParser.RULE_windoTVFName); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1414; + this.state = 1402; _la = this.tokenStream.LA(1); if(!(_la === 445 || _la === 459 || _la === 499)) { this.errorHandler.recoverInline(this); @@ -6473,66 +6416,66 @@ export class FlinkSqlParser extends SQLParserBase { } public windowTVFParam(): WindowTVFParamContext { let localContext = new WindowTVFParamContext(this.context, this.state); - this.enterRule(localContext, 196, FlinkSqlParser.RULE_windowTVFParam); + this.enterRule(localContext, 194, FlinkSqlParser.RULE_windowTVFParam); try { - this.state = 1431; + this.state = 1419; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 159, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 155, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1416; + this.state = 1404; this.match(FlinkSqlParser.KW_TABLE); - this.state = 1417; + this.state = 1405; this.timeAttrColumn(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1418; + this.state = 1406; this.columnDescriptor(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1419; + this.state = 1407; this.timeIntervalExpression(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1420; + this.state = 1408; this.match(FlinkSqlParser.KW_DATA); - this.state = 1421; + this.state = 1409; this.match(FlinkSqlParser.DOUBLE_RIGHT_ARROW); - this.state = 1422; + this.state = 1410; this.match(FlinkSqlParser.KW_TABLE); - this.state = 1423; + this.state = 1411; this.timeAttrColumn(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 1424; + this.state = 1412; this.match(FlinkSqlParser.KW_TIMECOL); - this.state = 1425; + this.state = 1413; this.match(FlinkSqlParser.DOUBLE_RIGHT_ARROW); - this.state = 1426; + this.state = 1414; this.columnDescriptor(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 1427; + this.state = 1415; this.timeIntervalParamName(); - this.state = 1428; + this.state = 1416; this.match(FlinkSqlParser.DOUBLE_RIGHT_ARROW); - this.state = 1429; + this.state = 1417; this.timeIntervalExpression(); } break; @@ -6554,12 +6497,12 @@ export class FlinkSqlParser extends SQLParserBase { } public timeIntervalParamName(): TimeIntervalParamNameContext { let localContext = new TimeIntervalParamNameContext(this.context, this.state); - this.enterRule(localContext, 198, FlinkSqlParser.RULE_timeIntervalParamName); + this.enterRule(localContext, 196, FlinkSqlParser.RULE_timeIntervalParamName); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1433; + this.state = 1421; _la = this.tokenStream.LA(1); if(!(_la === 250 || _la === 446 || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 23) !== 0))) { this.errorHandler.recoverInline(this); @@ -6586,17 +6529,17 @@ export class FlinkSqlParser extends SQLParserBase { } public columnDescriptor(): ColumnDescriptorContext { let localContext = new ColumnDescriptorContext(this.context, this.state); - this.enterRule(localContext, 200, FlinkSqlParser.RULE_columnDescriptor); + this.enterRule(localContext, 198, FlinkSqlParser.RULE_columnDescriptor); try { this.enterOuterAlt(localContext, 1); { - this.state = 1435; + this.state = 1423; this.match(FlinkSqlParser.KW_DESCRIPTOR); - this.state = 1436; + this.state = 1424; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1437; + this.state = 1425; this.columnName(); - this.state = 1438; + this.state = 1426; this.match(FlinkSqlParser.RR_BRACKET); } } @@ -6616,26 +6559,26 @@ export class FlinkSqlParser extends SQLParserBase { } public joinCondition(): JoinConditionContext { let localContext = new JoinConditionContext(this.context, this.state); - this.enterRule(localContext, 202, FlinkSqlParser.RULE_joinCondition); + this.enterRule(localContext, 200, FlinkSqlParser.RULE_joinCondition); try { - this.state = 1444; + this.state = 1432; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_ON: this.enterOuterAlt(localContext, 1); { - this.state = 1440; + this.state = 1428; this.match(FlinkSqlParser.KW_ON); - this.state = 1441; + this.state = 1429; this.booleanExpression(0); } break; case FlinkSqlParser.KW_USING: this.enterOuterAlt(localContext, 2); { - this.state = 1442; + this.state = 1430; this.match(FlinkSqlParser.KW_USING); - this.state = 1443; + this.state = 1431; this.columnNameList(); } break; @@ -6659,13 +6602,13 @@ export class FlinkSqlParser extends SQLParserBase { } public whereClause(): WhereClauseContext { let localContext = new WhereClauseContext(this.context, this.state); - this.enterRule(localContext, 204, FlinkSqlParser.RULE_whereClause); + this.enterRule(localContext, 202, FlinkSqlParser.RULE_whereClause); try { this.enterOuterAlt(localContext, 1); { - this.state = 1446; + this.state = 1434; this.match(FlinkSqlParser.KW_WHERE); - this.state = 1447; + this.state = 1435; this.booleanExpression(0); } } @@ -6685,34 +6628,34 @@ export class FlinkSqlParser extends SQLParserBase { } public groupByClause(): GroupByClauseContext { let localContext = new GroupByClauseContext(this.context, this.state); - this.enterRule(localContext, 206, FlinkSqlParser.RULE_groupByClause); + this.enterRule(localContext, 204, FlinkSqlParser.RULE_groupByClause); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1449; + this.state = 1437; this.match(FlinkSqlParser.KW_GROUP); - this.state = 1450; + this.state = 1438; this.match(FlinkSqlParser.KW_BY); - this.state = 1451; + this.state = 1439; this.groupItemDefinition(); - this.state = 1456; + this.state = 1444; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 161, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 157, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1452; + this.state = 1440; this.match(FlinkSqlParser.COMMA); - this.state = 1453; + this.state = 1441; this.groupItemDefinition(); } } } - this.state = 1458; + this.state = 1446; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 161, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 157, this.context); } } } @@ -6732,124 +6675,124 @@ export class FlinkSqlParser extends SQLParserBase { } public groupItemDefinition(): GroupItemDefinitionContext { let localContext = new GroupItemDefinitionContext(this.context, this.state); - this.enterRule(localContext, 208, FlinkSqlParser.RULE_groupItemDefinition); + this.enterRule(localContext, 206, FlinkSqlParser.RULE_groupItemDefinition); let _la: number; try { - this.state = 1499; + this.state = 1487; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 165, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 161, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1459; + this.state = 1447; this.columnName(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1460; + this.state = 1448; this.groupWindowFunction(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1461; + this.state = 1449; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1462; + this.state = 1450; this.match(FlinkSqlParser.RR_BRACKET); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1463; + this.state = 1451; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1464; + this.state = 1452; this.expression(); - this.state = 1469; + this.state = 1457; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1465; + this.state = 1453; this.match(FlinkSqlParser.COMMA); - this.state = 1466; + this.state = 1454; this.expression(); } } - this.state = 1471; + this.state = 1459; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1472; + this.state = 1460; this.match(FlinkSqlParser.RR_BRACKET); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 1474; + this.state = 1462; this.groupingSetsNotaionName(); - this.state = 1475; + this.state = 1463; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1476; + this.state = 1464; this.expression(); - this.state = 1481; + this.state = 1469; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1477; + this.state = 1465; this.match(FlinkSqlParser.COMMA); - this.state = 1478; + this.state = 1466; this.expression(); } } - this.state = 1483; + this.state = 1471; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1484; + this.state = 1472; this.match(FlinkSqlParser.RR_BRACKET); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 1486; + this.state = 1474; this.groupingSets(); - this.state = 1487; + this.state = 1475; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1488; + this.state = 1476; this.groupItemDefinition(); - this.state = 1493; + this.state = 1481; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1489; + this.state = 1477; this.match(FlinkSqlParser.COMMA); - this.state = 1490; + this.state = 1478; this.groupItemDefinition(); } } - this.state = 1495; + this.state = 1483; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1496; + this.state = 1484; this.match(FlinkSqlParser.RR_BRACKET); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 1498; + this.state = 1486; this.expression(); } break; @@ -6871,13 +6814,13 @@ export class FlinkSqlParser extends SQLParserBase { } public groupingSets(): GroupingSetsContext { let localContext = new GroupingSetsContext(this.context, this.state); - this.enterRule(localContext, 210, FlinkSqlParser.RULE_groupingSets); + this.enterRule(localContext, 208, FlinkSqlParser.RULE_groupingSets); try { this.enterOuterAlt(localContext, 1); { - this.state = 1501; + this.state = 1489; this.match(FlinkSqlParser.KW_GROUPING); - this.state = 1502; + this.state = 1490; this.match(FlinkSqlParser.KW_SETS); } } @@ -6897,12 +6840,12 @@ export class FlinkSqlParser extends SQLParserBase { } public groupingSetsNotaionName(): GroupingSetsNotaionNameContext { let localContext = new GroupingSetsNotaionNameContext(this.context, this.state); - this.enterRule(localContext, 212, FlinkSqlParser.RULE_groupingSetsNotaionName); + this.enterRule(localContext, 210, FlinkSqlParser.RULE_groupingSetsNotaionName); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1504; + this.state = 1492; _la = this.tokenStream.LA(1); if(!(_la === 74 || _la === 320)) { this.errorHandler.recoverInline(this); @@ -6929,21 +6872,21 @@ export class FlinkSqlParser extends SQLParserBase { } public groupWindowFunction(): GroupWindowFunctionContext { let localContext = new GroupWindowFunctionContext(this.context, this.state); - this.enterRule(localContext, 214, FlinkSqlParser.RULE_groupWindowFunction); + this.enterRule(localContext, 212, FlinkSqlParser.RULE_groupWindowFunction); try { this.enterOuterAlt(localContext, 1); { - this.state = 1506; + this.state = 1494; this.groupWindowFunctionName(); - this.state = 1507; + this.state = 1495; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1508; + this.state = 1496; this.timeAttrColumn(); - this.state = 1509; + this.state = 1497; this.match(FlinkSqlParser.COMMA); - this.state = 1510; + this.state = 1498; this.timeIntervalExpression(); - this.state = 1511; + this.state = 1499; this.match(FlinkSqlParser.RR_BRACKET); } } @@ -6963,12 +6906,12 @@ export class FlinkSqlParser extends SQLParserBase { } public groupWindowFunctionName(): GroupWindowFunctionNameContext { let localContext = new GroupWindowFunctionNameContext(this.context, this.state); - this.enterRule(localContext, 216, FlinkSqlParser.RULE_groupWindowFunctionName); + this.enterRule(localContext, 214, FlinkSqlParser.RULE_groupWindowFunctionName); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1513; + this.state = 1501; _la = this.tokenStream.LA(1); if(!(_la === 459 || _la === 492 || _la === 499)) { this.errorHandler.recoverInline(this); @@ -6995,11 +6938,11 @@ export class FlinkSqlParser extends SQLParserBase { } public timeAttrColumn(): TimeAttrColumnContext { let localContext = new TimeAttrColumnContext(this.context, this.state); - this.enterRule(localContext, 218, FlinkSqlParser.RULE_timeAttrColumn); + this.enterRule(localContext, 216, FlinkSqlParser.RULE_timeAttrColumn); try { this.enterOuterAlt(localContext, 1); { - this.state = 1515; + this.state = 1503; this.uid(); } } @@ -7019,13 +6962,13 @@ export class FlinkSqlParser extends SQLParserBase { } public havingClause(): HavingClauseContext { let localContext = new HavingClauseContext(this.context, this.state); - this.enterRule(localContext, 220, FlinkSqlParser.RULE_havingClause); + this.enterRule(localContext, 218, FlinkSqlParser.RULE_havingClause); try { this.enterOuterAlt(localContext, 1); { - this.state = 1517; + this.state = 1505; this.match(FlinkSqlParser.KW_HAVING); - this.state = 1518; + this.state = 1506; this.booleanExpression(0); } } @@ -7045,32 +6988,32 @@ export class FlinkSqlParser extends SQLParserBase { } public windowClause(): WindowClauseContext { let localContext = new WindowClauseContext(this.context, this.state); - this.enterRule(localContext, 222, FlinkSqlParser.RULE_windowClause); + this.enterRule(localContext, 220, FlinkSqlParser.RULE_windowClause); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1520; + this.state = 1508; this.match(FlinkSqlParser.KW_WINDOW); - this.state = 1521; + this.state = 1509; this.namedWindow(); - this.state = 1526; + this.state = 1514; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 166, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 162, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1522; + this.state = 1510; this.match(FlinkSqlParser.COMMA); - this.state = 1523; + this.state = 1511; this.namedWindow(); } } } - this.state = 1528; + this.state = 1516; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 166, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 162, this.context); } } } @@ -7090,15 +7033,15 @@ export class FlinkSqlParser extends SQLParserBase { } public namedWindow(): NamedWindowContext { let localContext = new NamedWindowContext(this.context, this.state); - this.enterRule(localContext, 224, FlinkSqlParser.RULE_namedWindow); + this.enterRule(localContext, 222, FlinkSqlParser.RULE_namedWindow); try { this.enterOuterAlt(localContext, 1); { - this.state = 1529; + this.state = 1517; localContext._name = this.errorCapturingIdentifier(); - this.state = 1530; + this.state = 1518; this.match(FlinkSqlParser.KW_AS); - this.state = 1531; + this.state = 1519; this.windowSpec(); } } @@ -7118,54 +7061,54 @@ export class FlinkSqlParser extends SQLParserBase { } public windowSpec(): WindowSpecContext { let localContext = new WindowSpecContext(this.context, this.state); - this.enterRule(localContext, 226, FlinkSqlParser.RULE_windowSpec); + this.enterRule(localContext, 224, FlinkSqlParser.RULE_windowSpec); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1534; + this.state = 1522; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (((((_la - 437)) & ~0x1F) === 0 && ((1 << (_la - 437)) & 4294967295) !== 0) || ((((_la - 469)) & ~0x1F) === 0 && ((1 << (_la - 469)) & 4294967295) !== 0) || ((((_la - 501)) & ~0x1F) === 0 && ((1 << (_la - 501)) & 15) !== 0) || ((((_la - 537)) & ~0x1F) === 0 && ((1 << (_la - 537)) & 19) !== 0)) { { - this.state = 1533; + this.state = 1521; localContext._name = this.errorCapturingIdentifier(); } } - this.state = 1536; + this.state = 1524; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1538; + this.state = 1526; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 268) { { - this.state = 1537; + this.state = 1525; this.partitionByClause(); } } - this.state = 1541; + this.state = 1529; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 258) { { - this.state = 1540; + this.state = 1528; this.orderByCaluse(); } } - this.state = 1544; + this.state = 1532; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 292 || _la === 322) { { - this.state = 1543; + this.state = 1531; this.windowFrame(); } } - this.state = 1546; + this.state = 1534; this.match(FlinkSqlParser.RR_BRACKET); } } @@ -7185,95 +7128,95 @@ export class FlinkSqlParser extends SQLParserBase { } public matchRecognizeClause(): MatchRecognizeClauseContext { let localContext = new MatchRecognizeClauseContext(this.context, this.state); - this.enterRule(localContext, 228, FlinkSqlParser.RULE_matchRecognizeClause); + this.enterRule(localContext, 226, FlinkSqlParser.RULE_matchRecognizeClause); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1548; + this.state = 1536; this.match(FlinkSqlParser.KW_MATCH_RECOGNIZE); - this.state = 1549; + this.state = 1537; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1551; + this.state = 1539; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 268) { { - this.state = 1550; + this.state = 1538; this.partitionByClause(); } } - this.state = 1554; + this.state = 1542; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 258) { { - this.state = 1553; + this.state = 1541; this.orderByCaluse(); } } - this.state = 1557; + this.state = 1545; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 215) { { - this.state = 1556; + this.state = 1544; this.measuresClause(); } } - this.state = 1560; + this.state = 1548; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 5 || _la === 254) { { - this.state = 1559; + this.state = 1547; this.outputMode(); } } - this.state = 1563; + this.state = 1551; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 438) { { - this.state = 1562; + this.state = 1550; this.afterMatchStrategy(); } } - this.state = 1566; + this.state = 1554; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 271) { { - this.state = 1565; + this.state = 1553; this.patternDefination(); } } - this.state = 1568; + this.state = 1556; this.patternVariablesDefination(); - this.state = 1569; + this.state = 1557; this.match(FlinkSqlParser.RR_BRACKET); - this.state = 1574; + this.state = 1562; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 178, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 174, this.context) ) { case 1: { - this.state = 1571; + this.state = 1559; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 17) { { - this.state = 1570; + this.state = 1558; this.match(FlinkSqlParser.KW_AS); } } - this.state = 1573; + this.state = 1561; this.identifier(); } break; @@ -7296,34 +7239,34 @@ export class FlinkSqlParser extends SQLParserBase { } public orderByCaluse(): OrderByCaluseContext { let localContext = new OrderByCaluseContext(this.context, this.state); - this.enterRule(localContext, 230, FlinkSqlParser.RULE_orderByCaluse); + this.enterRule(localContext, 228, FlinkSqlParser.RULE_orderByCaluse); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1576; + this.state = 1564; this.match(FlinkSqlParser.KW_ORDER); - this.state = 1577; + this.state = 1565; this.match(FlinkSqlParser.KW_BY); - this.state = 1578; + this.state = 1566; this.orderItemDefition(); - this.state = 1583; + this.state = 1571; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 179, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 175, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1579; + this.state = 1567; this.match(FlinkSqlParser.COMMA); - this.state = 1580; + this.state = 1568; this.orderItemDefition(); } } } - this.state = 1585; + this.state = 1573; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 179, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 175, this.context); } } } @@ -7343,19 +7286,19 @@ export class FlinkSqlParser extends SQLParserBase { } public orderItemDefition(): OrderItemDefitionContext { let localContext = new OrderItemDefitionContext(this.context, this.state); - this.enterRule(localContext, 232, FlinkSqlParser.RULE_orderItemDefition); + this.enterRule(localContext, 230, FlinkSqlParser.RULE_orderItemDefition); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1586; + this.state = 1574; this.columnName(); - this.state = 1588; + this.state = 1576; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 180, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 176, this.context) ) { case 1: { - this.state = 1587; + this.state = 1575; localContext._ordering = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 439 || _la === 450)) { @@ -7368,14 +7311,14 @@ export class FlinkSqlParser extends SQLParserBase { } break; } - this.state = 1592; + this.state = 1580; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 181, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 177, this.context) ) { case 1: { - this.state = 1590; + this.state = 1578; this.match(FlinkSqlParser.KW_NULLS); - this.state = 1591; + this.state = 1579; localContext._nullOrder = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 457 || _la === 467)) { @@ -7406,18 +7349,18 @@ export class FlinkSqlParser extends SQLParserBase { } public limitClause(): LimitClauseContext { let localContext = new LimitClauseContext(this.context, this.state); - this.enterRule(localContext, 234, FlinkSqlParser.RULE_limitClause); + this.enterRule(localContext, 232, FlinkSqlParser.RULE_limitClause); try { this.enterOuterAlt(localContext, 1); { - this.state = 1594; + this.state = 1582; this.match(FlinkSqlParser.KW_LIMIT); - this.state = 1597; + this.state = 1585; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_ALL: { - this.state = 1595; + this.state = 1583; this.match(FlinkSqlParser.KW_ALL); } break; @@ -7573,7 +7516,7 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.BIT_STRING: case FlinkSqlParser.ID_LITERAL: { - this.state = 1596; + this.state = 1584; localContext._limit = this.expression(); } break; @@ -7598,30 +7541,30 @@ export class FlinkSqlParser extends SQLParserBase { } public partitionByClause(): PartitionByClauseContext { let localContext = new PartitionByClauseContext(this.context, this.state); - this.enterRule(localContext, 236, FlinkSqlParser.RULE_partitionByClause); + this.enterRule(localContext, 234, FlinkSqlParser.RULE_partitionByClause); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1599; + this.state = 1587; this.match(FlinkSqlParser.KW_PARTITION); - this.state = 1600; + this.state = 1588; this.match(FlinkSqlParser.KW_BY); - this.state = 1601; + this.state = 1589; this.columnName(); - this.state = 1606; + this.state = 1594; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1602; + this.state = 1590; this.match(FlinkSqlParser.COMMA); - this.state = 1603; + this.state = 1591; this.columnName(); } } - this.state = 1608; + this.state = 1596; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -7643,16 +7586,16 @@ export class FlinkSqlParser extends SQLParserBase { } public quantifiers(): QuantifiersContext { let localContext = new QuantifiersContext(this.context, this.state); - this.enterRule(localContext, 238, FlinkSqlParser.RULE_quantifiers); + this.enterRule(localContext, 236, FlinkSqlParser.RULE_quantifiers); try { - this.state = 1625; + this.state = 1613; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 184, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 180, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { { - this.state = 1609; + this.state = 1597; this.match(FlinkSqlParser.ASTERISK_SIGN); } } @@ -7661,7 +7604,7 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 2); { { - this.state = 1610; + this.state = 1598; this.match(FlinkSqlParser.ADD_SIGN); } } @@ -7670,7 +7613,7 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 3); { { - this.state = 1611; + this.state = 1599; this.match(FlinkSqlParser.QUESTION_MARK_SIGN); } } @@ -7679,15 +7622,15 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 4); { { - this.state = 1612; + this.state = 1600; this.match(FlinkSqlParser.LB_BRACKET); - this.state = 1613; + this.state = 1601; this.match(FlinkSqlParser.DIG_LITERAL); - this.state = 1614; + this.state = 1602; this.match(FlinkSqlParser.COMMA); - this.state = 1615; + this.state = 1603; this.match(FlinkSqlParser.DIG_LITERAL); - this.state = 1616; + this.state = 1604; this.match(FlinkSqlParser.RB_BRACKET); } } @@ -7696,13 +7639,13 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 5); { { - this.state = 1617; + this.state = 1605; this.match(FlinkSqlParser.LB_BRACKET); - this.state = 1618; + this.state = 1606; this.match(FlinkSqlParser.DIG_LITERAL); - this.state = 1619; + this.state = 1607; this.match(FlinkSqlParser.COMMA); - this.state = 1620; + this.state = 1608; this.match(FlinkSqlParser.RB_BRACKET); } } @@ -7711,13 +7654,13 @@ export class FlinkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 6); { { - this.state = 1621; + this.state = 1609; this.match(FlinkSqlParser.LB_BRACKET); - this.state = 1622; + this.state = 1610; this.match(FlinkSqlParser.COMMA); - this.state = 1623; + this.state = 1611; this.match(FlinkSqlParser.DIG_LITERAL); - this.state = 1624; + this.state = 1612; this.match(FlinkSqlParser.RB_BRACKET); } } @@ -7740,28 +7683,28 @@ export class FlinkSqlParser extends SQLParserBase { } public measuresClause(): MeasuresClauseContext { let localContext = new MeasuresClauseContext(this.context, this.state); - this.enterRule(localContext, 240, FlinkSqlParser.RULE_measuresClause); + this.enterRule(localContext, 238, FlinkSqlParser.RULE_measuresClause); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1627; + this.state = 1615; this.match(FlinkSqlParser.KW_MEASURES); - this.state = 1628; + this.state = 1616; this.projectItemDefinition(); - this.state = 1633; + this.state = 1621; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1629; + this.state = 1617; this.match(FlinkSqlParser.COMMA); - this.state = 1630; + this.state = 1618; this.projectItemDefinition(); } } - this.state = 1635; + this.state = 1623; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -7783,37 +7726,37 @@ export class FlinkSqlParser extends SQLParserBase { } public patternDefination(): PatternDefinationContext { let localContext = new PatternDefinationContext(this.context, this.state); - this.enterRule(localContext, 242, FlinkSqlParser.RULE_patternDefination); + this.enterRule(localContext, 240, FlinkSqlParser.RULE_patternDefination); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1636; + this.state = 1624; this.match(FlinkSqlParser.KW_PATTERN); - this.state = 1637; + this.state = 1625; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1639; + this.state = 1627; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 1638; + this.state = 1626; this.patternVariable(); } } - this.state = 1641; + this.state = 1629; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 538 || _la === 541); - this.state = 1643; + this.state = 1631; this.match(FlinkSqlParser.RR_BRACKET); - this.state = 1645; + this.state = 1633; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 434) { { - this.state = 1644; + this.state = 1632; this.withinClause(); } } @@ -7836,19 +7779,19 @@ export class FlinkSqlParser extends SQLParserBase { } public patternVariable(): PatternVariableContext { let localContext = new PatternVariableContext(this.context, this.state); - this.enterRule(localContext, 244, FlinkSqlParser.RULE_patternVariable); + this.enterRule(localContext, 242, FlinkSqlParser.RULE_patternVariable); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1647; + this.state = 1635; this.unquotedIdentifier(); - this.state = 1649; + this.state = 1637; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 135681) !== 0)) { { - this.state = 1648; + this.state = 1636; this.quantifiers(); } } @@ -7871,34 +7814,34 @@ export class FlinkSqlParser extends SQLParserBase { } public outputMode(): OutputModeContext { let localContext = new OutputModeContext(this.context, this.state); - this.enterRule(localContext, 246, FlinkSqlParser.RULE_outputMode); + this.enterRule(localContext, 244, FlinkSqlParser.RULE_outputMode); try { - this.state = 1659; + this.state = 1647; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_ALL: this.enterOuterAlt(localContext, 1); { - this.state = 1651; + this.state = 1639; this.match(FlinkSqlParser.KW_ALL); - this.state = 1652; + this.state = 1640; this.match(FlinkSqlParser.KW_ROWS); - this.state = 1653; + this.state = 1641; this.match(FlinkSqlParser.KW_PER); - this.state = 1654; + this.state = 1642; this.match(FlinkSqlParser.KW_MATCH); } break; case FlinkSqlParser.KW_ONE: this.enterOuterAlt(localContext, 2); { - this.state = 1655; + this.state = 1643; this.match(FlinkSqlParser.KW_ONE); - this.state = 1656; + this.state = 1644; this.match(FlinkSqlParser.KW_ROW); - this.state = 1657; + this.state = 1645; this.match(FlinkSqlParser.KW_PER); - this.state = 1658; + this.state = 1646; this.match(FlinkSqlParser.KW_MATCH); } break; @@ -7922,76 +7865,76 @@ export class FlinkSqlParser extends SQLParserBase { } public afterMatchStrategy(): AfterMatchStrategyContext { let localContext = new AfterMatchStrategyContext(this.context, this.state); - this.enterRule(localContext, 248, FlinkSqlParser.RULE_afterMatchStrategy); + this.enterRule(localContext, 246, FlinkSqlParser.RULE_afterMatchStrategy); try { - this.state = 1685; + this.state = 1673; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 190, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 186, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1661; + this.state = 1649; this.match(FlinkSqlParser.KW_AFTER); - this.state = 1662; + this.state = 1650; this.match(FlinkSqlParser.KW_MATCH); - this.state = 1663; + this.state = 1651; this.match(FlinkSqlParser.KW_SKIP); - this.state = 1664; + this.state = 1652; this.match(FlinkSqlParser.KW_PAST); - this.state = 1665; + this.state = 1653; this.match(FlinkSqlParser.KW_LAST); - this.state = 1666; + this.state = 1654; this.match(FlinkSqlParser.KW_ROW); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1667; + this.state = 1655; this.match(FlinkSqlParser.KW_AFTER); - this.state = 1668; + this.state = 1656; this.match(FlinkSqlParser.KW_MATCH); - this.state = 1669; + this.state = 1657; this.match(FlinkSqlParser.KW_SKIP); - this.state = 1670; + this.state = 1658; this.match(FlinkSqlParser.KW_TO); - this.state = 1671; + this.state = 1659; this.match(FlinkSqlParser.KW_NEXT); - this.state = 1672; + this.state = 1660; this.match(FlinkSqlParser.KW_ROW); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1673; + this.state = 1661; this.match(FlinkSqlParser.KW_AFTER); - this.state = 1674; + this.state = 1662; this.match(FlinkSqlParser.KW_MATCH); - this.state = 1675; + this.state = 1663; this.match(FlinkSqlParser.KW_SKIP); - this.state = 1676; + this.state = 1664; this.match(FlinkSqlParser.KW_TO); - this.state = 1677; + this.state = 1665; this.match(FlinkSqlParser.KW_LAST); - this.state = 1678; + this.state = 1666; this.unquotedIdentifier(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1679; + this.state = 1667; this.match(FlinkSqlParser.KW_AFTER); - this.state = 1680; + this.state = 1668; this.match(FlinkSqlParser.KW_MATCH); - this.state = 1681; + this.state = 1669; this.match(FlinkSqlParser.KW_SKIP); - this.state = 1682; + this.state = 1670; this.match(FlinkSqlParser.KW_TO); - this.state = 1683; + this.state = 1671; this.match(FlinkSqlParser.KW_FIRST); - this.state = 1684; + this.state = 1672; this.unquotedIdentifier(); } break; @@ -8013,28 +7956,28 @@ export class FlinkSqlParser extends SQLParserBase { } public patternVariablesDefination(): PatternVariablesDefinationContext { let localContext = new PatternVariablesDefinationContext(this.context, this.state); - this.enterRule(localContext, 250, FlinkSqlParser.RULE_patternVariablesDefination); + this.enterRule(localContext, 248, FlinkSqlParser.RULE_patternVariablesDefination); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1687; + this.state = 1675; this.match(FlinkSqlParser.KW_DEFINE); - this.state = 1688; + this.state = 1676; this.projectItemDefinition(); - this.state = 1693; + this.state = 1681; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1689; + this.state = 1677; this.match(FlinkSqlParser.COMMA); - this.state = 1690; + this.state = 1678; this.projectItemDefinition(); } } - this.state = 1695; + this.state = 1683; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -8056,34 +7999,34 @@ export class FlinkSqlParser extends SQLParserBase { } public windowFrame(): WindowFrameContext { let localContext = new WindowFrameContext(this.context, this.state); - this.enterRule(localContext, 252, FlinkSqlParser.RULE_windowFrame); + this.enterRule(localContext, 250, FlinkSqlParser.RULE_windowFrame); try { - this.state = 1705; + this.state = 1693; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_RANGE: this.enterOuterAlt(localContext, 1); { - this.state = 1696; + this.state = 1684; this.match(FlinkSqlParser.KW_RANGE); - this.state = 1697; + this.state = 1685; this.match(FlinkSqlParser.KW_BETWEEN); - this.state = 1698; + this.state = 1686; this.timeIntervalExpression(); - this.state = 1699; + this.state = 1687; this.frameBound(); } break; case FlinkSqlParser.KW_ROWS: this.enterOuterAlt(localContext, 2); { - this.state = 1701; + this.state = 1689; this.match(FlinkSqlParser.KW_ROWS); - this.state = 1702; + this.state = 1690; this.match(FlinkSqlParser.KW_BETWEEN); - this.state = 1703; + this.state = 1691; this.match(FlinkSqlParser.DIG_LITERAL); - this.state = 1704; + this.state = 1692; this.frameBound(); } break; @@ -8107,17 +8050,17 @@ export class FlinkSqlParser extends SQLParserBase { } public frameBound(): FrameBoundContext { let localContext = new FrameBoundContext(this.context, this.state); - this.enterRule(localContext, 254, FlinkSqlParser.RULE_frameBound); + this.enterRule(localContext, 252, FlinkSqlParser.RULE_frameBound); try { this.enterOuterAlt(localContext, 1); { - this.state = 1707; + this.state = 1695; this.match(FlinkSqlParser.KW_PRECEDING); - this.state = 1708; + this.state = 1696; this.match(FlinkSqlParser.KW_AND); - this.state = 1709; + this.state = 1697; this.match(FlinkSqlParser.KW_CURRENT); - this.state = 1710; + this.state = 1698; this.match(FlinkSqlParser.KW_ROW); } } @@ -8137,13 +8080,13 @@ export class FlinkSqlParser extends SQLParserBase { } public withinClause(): WithinClauseContext { let localContext = new WithinClauseContext(this.context, this.state); - this.enterRule(localContext, 256, FlinkSqlParser.RULE_withinClause); + this.enterRule(localContext, 254, FlinkSqlParser.RULE_withinClause); try { this.enterOuterAlt(localContext, 1); { - this.state = 1712; + this.state = 1700; this.match(FlinkSqlParser.KW_WITHIN); - this.state = 1713; + this.state = 1701; this.timeIntervalExpression(); } } @@ -8163,11 +8106,11 @@ export class FlinkSqlParser extends SQLParserBase { } public expression(): ExpressionContext { let localContext = new ExpressionContext(this.context, this.state); - this.enterRule(localContext, 258, FlinkSqlParser.RULE_expression); + this.enterRule(localContext, 256, FlinkSqlParser.RULE_expression); try { this.enterOuterAlt(localContext, 1); { - this.state = 1715; + this.state = 1703; this.booleanExpression(0); } } @@ -8197,25 +8140,25 @@ export class FlinkSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new BooleanExpressionContext(this.context, parentState); let previousContext = localContext; - let _startState = 260; - this.enterRecursionRule(localContext, 260, FlinkSqlParser.RULE_booleanExpression, _p); + let _startState = 258; + this.enterRecursionRule(localContext, 258, FlinkSqlParser.RULE_booleanExpression, _p); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1729; + this.state = 1717; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 194, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 190, this.context) ) { case 1: { localContext = new LogicalNotContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1718; + this.state = 1706; this.match(FlinkSqlParser.KW_NOT); - this.state = 1719; + this.state = 1707; this.booleanExpression(6); } break; @@ -8224,13 +8167,13 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ExistsContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1720; + this.state = 1708; this.match(FlinkSqlParser.KW_EXISTS); - this.state = 1721; + this.state = 1709; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1722; + this.state = 1710; this.queryStatement(0); - this.state = 1723; + this.state = 1711; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -8239,14 +8182,14 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new PredicatedContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1725; + this.state = 1713; this.valueExpression(0); - this.state = 1727; + this.state = 1715; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 193, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 189, this.context) ) { case 1: { - this.state = 1726; + this.state = 1714; this.predicate(); } break; @@ -8255,9 +8198,9 @@ export class FlinkSqlParser extends SQLParserBase { break; } this.context!.stop = this.tokenStream.LT(-1); - this.state = 1745; + this.state = 1733; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 197, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 193, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { if (this._parseListeners != null) { @@ -8265,21 +8208,21 @@ export class FlinkSqlParser extends SQLParserBase { } previousContext = localContext; { - this.state = 1743; + this.state = 1731; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 196, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 192, this.context) ) { case 1: { localContext = new LogicalBinaryContext(new BooleanExpressionContext(parentContext, parentState)); (localContext as LogicalBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_booleanExpression); - this.state = 1731; + this.state = 1719; if (!(this.precpred(this.context, 3))) { throw this.createFailedPredicateException("this.precpred(this.context, 3)"); } - this.state = 1732; + this.state = 1720; (localContext as LogicalBinaryContext)._operator = this.match(FlinkSqlParser.KW_AND); - this.state = 1733; + this.state = 1721; (localContext as LogicalBinaryContext)._right = this.booleanExpression(4); } break; @@ -8288,13 +8231,13 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new LogicalBinaryContext(new BooleanExpressionContext(parentContext, parentState)); (localContext as LogicalBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_booleanExpression); - this.state = 1734; + this.state = 1722; if (!(this.precpred(this.context, 2))) { throw this.createFailedPredicateException("this.precpred(this.context, 2)"); } - this.state = 1735; + this.state = 1723; (localContext as LogicalBinaryContext)._operator = this.match(FlinkSqlParser.KW_OR); - this.state = 1736; + this.state = 1724; (localContext as LogicalBinaryContext)._right = this.booleanExpression(3); } break; @@ -8302,23 +8245,23 @@ export class FlinkSqlParser extends SQLParserBase { { localContext = new LogicalNestedContext(new BooleanExpressionContext(parentContext, parentState)); this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_booleanExpression); - this.state = 1737; + this.state = 1725; if (!(this.precpred(this.context, 1))) { throw this.createFailedPredicateException("this.precpred(this.context, 1)"); } - this.state = 1738; + this.state = 1726; this.match(FlinkSqlParser.KW_IS); - this.state = 1740; + this.state = 1728; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1739; + this.state = 1727; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1742; + this.state = 1730; (localContext as LogicalNestedContext)._kind = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 140 || _la === 244 || _la === 397 || _la === 404)) { @@ -8333,9 +8276,9 @@ export class FlinkSqlParser extends SQLParserBase { } } } - this.state = 1747; + this.state = 1735; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 197, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 193, this.context); } } } @@ -8355,33 +8298,33 @@ export class FlinkSqlParser extends SQLParserBase { } public predicate(): PredicateContext { let localContext = new PredicateContext(this.context, this.state); - this.enterRule(localContext, 262, FlinkSqlParser.RULE_predicate); + this.enterRule(localContext, 260, FlinkSqlParser.RULE_predicate); let _la: number; try { - this.state = 1815; + this.state = 1803; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 208, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 204, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1749; + this.state = 1737; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1748; + this.state = 1736; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1751; + this.state = 1739; localContext._kind = this.match(FlinkSqlParser.KW_BETWEEN); - this.state = 1753; + this.state = 1741; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 19 || _la === 369) { { - this.state = 1752; + this.state = 1740; _la = this.tokenStream.LA(1); if(!(_la === 19 || _la === 369)) { this.errorHandler.recoverInline(this); @@ -8393,131 +8336,131 @@ export class FlinkSqlParser extends SQLParserBase { } } - this.state = 1755; + this.state = 1743; localContext._lower = this.valueExpression(0); - this.state = 1756; + this.state = 1744; this.match(FlinkSqlParser.KW_AND); - this.state = 1757; + this.state = 1745; localContext._upper = this.valueExpression(0); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1760; + this.state = 1748; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1759; + this.state = 1747; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1762; + this.state = 1750; localContext._kind = this.match(FlinkSqlParser.KW_IN); - this.state = 1763; + this.state = 1751; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1764; + this.state = 1752; this.expression(); - this.state = 1769; + this.state = 1757; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1765; + this.state = 1753; this.match(FlinkSqlParser.COMMA); - this.state = 1766; + this.state = 1754; this.expression(); } } - this.state = 1771; + this.state = 1759; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1772; + this.state = 1760; this.match(FlinkSqlParser.RR_BRACKET); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1775; + this.state = 1763; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1774; + this.state = 1762; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1777; + this.state = 1765; localContext._kind = this.match(FlinkSqlParser.KW_IN); - this.state = 1778; + this.state = 1766; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1779; + this.state = 1767; this.queryStatement(0); - this.state = 1780; + this.state = 1768; this.match(FlinkSqlParser.RR_BRACKET); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1782; + this.state = 1770; localContext._kind = this.match(FlinkSqlParser.KW_EXISTS); - this.state = 1783; + this.state = 1771; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1784; + this.state = 1772; this.queryStatement(0); - this.state = 1785; + this.state = 1773; this.match(FlinkSqlParser.RR_BRACKET); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 1788; + this.state = 1776; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1787; + this.state = 1775; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1790; + this.state = 1778; localContext._kind = this.match(FlinkSqlParser.KW_RLIKE); - this.state = 1791; + this.state = 1779; localContext._pattern = this.valueExpression(0); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 1792; + this.state = 1780; this.likePredicate(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 1793; + this.state = 1781; this.match(FlinkSqlParser.KW_IS); - this.state = 1795; + this.state = 1783; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1794; + this.state = 1782; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1797; + this.state = 1785; localContext._kind = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 140 || _la === 244 || _la === 397 || _la === 404)) { @@ -8532,53 +8475,53 @@ export class FlinkSqlParser extends SQLParserBase { case 8: this.enterOuterAlt(localContext, 8); { - this.state = 1798; + this.state = 1786; this.match(FlinkSqlParser.KW_IS); - this.state = 1800; + this.state = 1788; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1799; + this.state = 1787; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1802; + this.state = 1790; localContext._kind = this.match(FlinkSqlParser.KW_DISTINCT); - this.state = 1803; + this.state = 1791; this.match(FlinkSqlParser.KW_FROM); - this.state = 1804; + this.state = 1792; localContext._right = this.valueExpression(0); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 1806; + this.state = 1794; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1805; + this.state = 1793; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1808; + this.state = 1796; localContext._kind = this.match(FlinkSqlParser.KW_SIMILAR); - this.state = 1809; + this.state = 1797; this.match(FlinkSqlParser.KW_TO); - this.state = 1810; + this.state = 1798; localContext._right = this.valueExpression(0); - this.state = 1813; + this.state = 1801; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 207, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 203, this.context) ) { case 1: { - this.state = 1811; + this.state = 1799; this.match(FlinkSqlParser.KW_ESCAPE); - this.state = 1812; + this.state = 1800; this.stringLiteral(); } break; @@ -8603,28 +8546,28 @@ export class FlinkSqlParser extends SQLParserBase { } public likePredicate(): LikePredicateContext { let localContext = new LikePredicateContext(this.context, this.state); - this.enterRule(localContext, 264, FlinkSqlParser.RULE_likePredicate); + this.enterRule(localContext, 262, FlinkSqlParser.RULE_likePredicate); let _la: number; try { - this.state = 1846; + this.state = 1834; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 214, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 210, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1818; + this.state = 1806; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1817; + this.state = 1805; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1820; + this.state = 1808; localContext._kind = this.match(FlinkSqlParser.KW_LIKE); - this.state = 1821; + this.state = 1809; localContext._quantifier = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 5 || _la === 11)) { @@ -8634,40 +8577,40 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1835; + this.state = 1823; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 211, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 207, this.context) ) { case 1: { - this.state = 1822; + this.state = 1810; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1823; + this.state = 1811; this.match(FlinkSqlParser.RR_BRACKET); } break; case 2: { - this.state = 1824; + this.state = 1812; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1825; + this.state = 1813; this.expression(); - this.state = 1830; + this.state = 1818; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1826; + this.state = 1814; this.match(FlinkSqlParser.COMMA); - this.state = 1827; + this.state = 1815; this.expression(); } } - this.state = 1832; + this.state = 1820; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1833; + this.state = 1821; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -8677,28 +8620,28 @@ export class FlinkSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1838; + this.state = 1826; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 1837; + this.state = 1825; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 1840; + this.state = 1828; localContext._kind = this.match(FlinkSqlParser.KW_LIKE); - this.state = 1841; + this.state = 1829; localContext._pattern = this.valueExpression(0); - this.state = 1844; + this.state = 1832; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 213, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 209, this.context) ) { case 1: { - this.state = 1842; + this.state = 1830; this.match(FlinkSqlParser.KW_ESCAPE); - this.state = 1843; + this.state = 1831; this.stringLiteral(); } break; @@ -8733,23 +8676,23 @@ export class FlinkSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new ValueExpressionContext(this.context, parentState); let previousContext = localContext; - let _startState = 266; - this.enterRecursionRule(localContext, 266, FlinkSqlParser.RULE_valueExpression, _p); + let _startState = 264; + this.enterRecursionRule(localContext, 264, FlinkSqlParser.RULE_valueExpression, _p); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1852; + this.state = 1840; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 215, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 211, this.context) ) { case 1: { localContext = new ValueExpressionDefaultContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1849; + this.state = 1837; this.primaryExpression(0); } break; @@ -8758,7 +8701,7 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ArithmeticUnaryContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1850; + this.state = 1838; (localContext as ArithmeticUnaryContext)._operator = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & 3145729) !== 0))) { @@ -8768,15 +8711,15 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1851; + this.state = 1839; this.valueExpression(7); } break; } this.context!.stop = this.tokenStream.LT(-1); - this.state = 1875; + this.state = 1863; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 217, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 213, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { if (this._parseListeners != null) { @@ -8784,19 +8727,19 @@ export class FlinkSqlParser extends SQLParserBase { } previousContext = localContext; { - this.state = 1873; + this.state = 1861; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 216, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 212, this.context) ) { case 1: { localContext = new ArithmeticBinaryContext(new ValueExpressionContext(parentContext, parentState)); (localContext as ArithmeticBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_valueExpression); - this.state = 1854; + this.state = 1842; if (!(this.precpred(this.context, 6))) { throw this.createFailedPredicateException("this.precpred(this.context, 6)"); } - this.state = 1855; + this.state = 1843; (localContext as ArithmeticBinaryContext)._operator = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 452 || ((((_la - 527)) & ~0x1F) === 0 && ((1 << (_la - 527)) & 145) !== 0))) { @@ -8806,7 +8749,7 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1856; + this.state = 1844; (localContext as ArithmeticBinaryContext)._right = this.valueExpression(7); } break; @@ -8815,11 +8758,11 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ArithmeticBinaryContext(new ValueExpressionContext(parentContext, parentState)); (localContext as ArithmeticBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_valueExpression); - this.state = 1857; + this.state = 1845; if (!(this.precpred(this.context, 5))) { throw this.createFailedPredicateException("this.precpred(this.context, 5)"); } - this.state = 1858; + this.state = 1846; (localContext as ArithmeticBinaryContext)._operator = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(((((_la - 529)) & ~0x1F) === 0 && ((1 << (_la - 529)) & 11) !== 0))) { @@ -8829,7 +8772,7 @@ export class FlinkSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1859; + this.state = 1847; (localContext as ArithmeticBinaryContext)._right = this.valueExpression(6); } break; @@ -8838,13 +8781,13 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ArithmeticBinaryContext(new ValueExpressionContext(parentContext, parentState)); (localContext as ArithmeticBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_valueExpression); - this.state = 1860; + this.state = 1848; if (!(this.precpred(this.context, 4))) { throw this.createFailedPredicateException("this.precpred(this.context, 4)"); } - this.state = 1861; + this.state = 1849; (localContext as ArithmeticBinaryContext)._operator = this.match(FlinkSqlParser.BIT_AND_OP); - this.state = 1862; + this.state = 1850; (localContext as ArithmeticBinaryContext)._right = this.valueExpression(5); } break; @@ -8853,13 +8796,13 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ArithmeticBinaryContext(new ValueExpressionContext(parentContext, parentState)); (localContext as ArithmeticBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_valueExpression); - this.state = 1863; + this.state = 1851; if (!(this.precpred(this.context, 3))) { throw this.createFailedPredicateException("this.precpred(this.context, 3)"); } - this.state = 1864; + this.state = 1852; (localContext as ArithmeticBinaryContext)._operator = this.match(FlinkSqlParser.BIT_XOR_OP); - this.state = 1865; + this.state = 1853; (localContext as ArithmeticBinaryContext)._right = this.valueExpression(4); } break; @@ -8868,13 +8811,13 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ArithmeticBinaryContext(new ValueExpressionContext(parentContext, parentState)); (localContext as ArithmeticBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_valueExpression); - this.state = 1866; + this.state = 1854; if (!(this.precpred(this.context, 2))) { throw this.createFailedPredicateException("this.precpred(this.context, 2)"); } - this.state = 1867; + this.state = 1855; (localContext as ArithmeticBinaryContext)._operator = this.match(FlinkSqlParser.BIT_OR_OP); - this.state = 1868; + this.state = 1856; (localContext as ArithmeticBinaryContext)._right = this.valueExpression(3); } break; @@ -8883,22 +8826,22 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ComparisonContext(new ValueExpressionContext(parentContext, parentState)); (localContext as ComparisonContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_valueExpression); - this.state = 1869; + this.state = 1857; if (!(this.precpred(this.context, 1))) { throw this.createFailedPredicateException("this.precpred(this.context, 1)"); } - this.state = 1870; + this.state = 1858; this.comparisonOperator(); - this.state = 1871; + this.state = 1859; (localContext as ComparisonContext)._right = this.valueExpression(2); } break; } } } - this.state = 1877; + this.state = 1865; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 217, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 213, this.context); } } } @@ -8928,51 +8871,51 @@ export class FlinkSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new PrimaryExpressionContext(this.context, parentState); let previousContext = localContext; - let _startState = 268; - this.enterRecursionRule(localContext, 268, FlinkSqlParser.RULE_primaryExpression, _p); + let _startState = 266; + this.enterRecursionRule(localContext, 266, FlinkSqlParser.RULE_primaryExpression, _p); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1970; + this.state = 1958; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 227, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 223, this.context) ) { case 1: { localContext = new SearchedCaseContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1879; + this.state = 1867; this.match(FlinkSqlParser.KW_CASE); - this.state = 1881; + this.state = 1869; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 1880; + this.state = 1868; this.whenClause(); } } - this.state = 1883; + this.state = 1871; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 428); - this.state = 1887; + this.state = 1875; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 120) { { - this.state = 1885; + this.state = 1873; this.match(FlinkSqlParser.KW_ELSE); - this.state = 1886; + this.state = 1874; (localContext as SearchedCaseContext)._elseExpression = this.expression(); } } - this.state = 1889; + this.state = 1877; this.match(FlinkSqlParser.KW_END); } break; @@ -8981,37 +8924,37 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new SimpleCaseContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1891; + this.state = 1879; this.match(FlinkSqlParser.KW_CASE); - this.state = 1892; + this.state = 1880; (localContext as SimpleCaseContext)._value = this.expression(); - this.state = 1894; + this.state = 1882; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 1893; + this.state = 1881; this.whenClause(); } } - this.state = 1896; + this.state = 1884; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 428); - this.state = 1900; + this.state = 1888; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 120) { { - this.state = 1898; + this.state = 1886; this.match(FlinkSqlParser.KW_ELSE); - this.state = 1899; + this.state = 1887; (localContext as SimpleCaseContext)._elseExpression = this.expression(); } } - this.state = 1902; + this.state = 1890; this.match(FlinkSqlParser.KW_END); } break; @@ -9020,17 +8963,17 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new CastContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1904; + this.state = 1892; this.match(FlinkSqlParser.KW_CAST); - this.state = 1905; + this.state = 1893; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1906; + this.state = 1894; this.expression(); - this.state = 1907; + this.state = 1895; this.match(FlinkSqlParser.KW_AS); - this.state = 1908; + this.state = 1896; this.columnType(); - this.state = 1909; + this.state = 1897; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -9039,25 +8982,25 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new FirstContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1911; + this.state = 1899; this.match(FlinkSqlParser.KW_FIRST); - this.state = 1912; + this.state = 1900; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1913; + this.state = 1901; this.expression(); - this.state = 1916; + this.state = 1904; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 461) { { - this.state = 1914; + this.state = 1902; this.match(FlinkSqlParser.KW_IGNORE); - this.state = 1915; + this.state = 1903; this.match(FlinkSqlParser.KW_NULLS); } } - this.state = 1918; + this.state = 1906; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -9066,25 +9009,25 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new LastContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1920; + this.state = 1908; this.match(FlinkSqlParser.KW_LAST); - this.state = 1921; + this.state = 1909; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1922; + this.state = 1910; this.expression(); - this.state = 1925; + this.state = 1913; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 461) { { - this.state = 1923; + this.state = 1911; this.match(FlinkSqlParser.KW_IGNORE); - this.state = 1924; + this.state = 1912; this.match(FlinkSqlParser.KW_NULLS); } } - this.state = 1927; + this.state = 1915; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -9093,17 +9036,17 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new PositionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1929; + this.state = 1917; this.match(FlinkSqlParser.KW_POSITION); - this.state = 1930; + this.state = 1918; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1931; + this.state = 1919; (localContext as PositionContext)._substr = this.valueExpression(0); - this.state = 1932; + this.state = 1920; this.match(FlinkSqlParser.KW_IN); - this.state = 1933; + this.state = 1921; (localContext as PositionContext)._str = this.valueExpression(0); - this.state = 1934; + this.state = 1922; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -9112,7 +9055,7 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ConstantDefaultContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1936; + this.state = 1924; this.constant(); } break; @@ -9121,7 +9064,7 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new StarContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1937; + this.state = 1925; this.match(FlinkSqlParser.ASTERISK_SIGN); } break; @@ -9130,11 +9073,11 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new StarContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1938; + this.state = 1926; this.uid(); - this.state = 1939; + this.state = 1927; this.match(FlinkSqlParser.DOT); - this.state = 1940; + this.state = 1928; this.match(FlinkSqlParser.ASTERISK_SIGN); } break; @@ -9143,11 +9086,11 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new SubqueryExpressionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1942; + this.state = 1930; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1943; + this.state = 1931; this.queryStatement(0); - this.state = 1944; + this.state = 1932; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -9156,47 +9099,47 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new FunctionCallContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1946; + this.state = 1934; this.functionName(); - this.state = 1947; + this.state = 1935; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1959; + this.state = 1947; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 8396848) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 10489249) !== 0) || ((((_la - 69)) & ~0x1F) === 0 && ((1 << (_la - 69)) & 1883341377) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 201330753) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 337641555) !== 0) || ((((_la - 182)) & ~0x1F) === 0 && ((1 << (_la - 182)) & 244224001) !== 0) || ((((_la - 214)) & ~0x1F) === 0 && ((1 << (_la - 214)) & 3892347713) !== 0) || ((((_la - 264)) & ~0x1F) === 0 && ((1 << (_la - 264)) & 537530369) !== 0) || ((((_la - 317)) & ~0x1F) === 0 && ((1 << (_la - 317)) & 131185) !== 0) || ((((_la - 357)) & ~0x1F) === 0 && ((1 << (_la - 357)) & 14681219) !== 0) || ((((_la - 389)) & ~0x1F) === 0 && ((1 << (_la - 389)) & 3238528833) !== 0) || ((((_la - 427)) & ~0x1F) === 0 && ((1 << (_la - 427)) & 4294966785) !== 0) || ((((_la - 459)) & ~0x1F) === 0 && ((1 << (_la - 459)) & 4294967295) !== 0) || ((((_la - 491)) & ~0x1F) === 0 && ((1 << (_la - 491)) & 33832959) !== 0) || ((((_la - 527)) & ~0x1F) === 0 && ((1 << (_la - 527)) & 31757) !== 0)) { { - this.state = 1949; + this.state = 1937; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 224, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 220, this.context) ) { case 1: { - this.state = 1948; + this.state = 1936; this.setQuantifier(); } break; } - this.state = 1951; + this.state = 1939; this.functionParam(); - this.state = 1956; + this.state = 1944; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 1952; + this.state = 1940; this.match(FlinkSqlParser.COMMA); - this.state = 1953; + this.state = 1941; this.functionParam(); } } - this.state = 1958; + this.state = 1946; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 1961; + this.state = 1949; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -9205,7 +9148,7 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ColumnReferenceContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1963; + this.state = 1951; this.identifier(); } break; @@ -9214,7 +9157,7 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new DereferenceContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1964; + this.state = 1952; this.dereferenceDefinition(); } break; @@ -9223,11 +9166,11 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new ParenthesizedExpressionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1965; + this.state = 1953; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 1966; + this.state = 1954; this.expression(); - this.state = 1967; + this.state = 1955; this.match(FlinkSqlParser.RR_BRACKET); } break; @@ -9236,15 +9179,15 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new DateFunctionExpressionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 1969; + this.state = 1957; this.match(FlinkSqlParser.KW_CURRENT_TIMESTAMP); } break; } this.context!.stop = this.tokenStream.LT(-1); - this.state = 1979; + this.state = 1967; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 228, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 224, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { if (this._parseListeners != null) { @@ -9256,22 +9199,22 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new SubscriptContext(new PrimaryExpressionContext(parentContext, parentState)); (localContext as SubscriptContext)._value = previousContext; this.pushNewRecursionContext(localContext, _startState, FlinkSqlParser.RULE_primaryExpression); - this.state = 1972; + this.state = 1960; if (!(this.precpred(this.context, 5))) { throw this.createFailedPredicateException("this.precpred(this.context, 5)"); } - this.state = 1973; + this.state = 1961; this.match(FlinkSqlParser.LS_BRACKET); - this.state = 1974; + this.state = 1962; (localContext as SubscriptContext)._index = this.valueExpression(0); - this.state = 1975; + this.state = 1963; this.match(FlinkSqlParser.RS_BRACKET); } } } - this.state = 1981; + this.state = 1969; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 228, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 224, this.context); } } } @@ -9291,11 +9234,11 @@ export class FlinkSqlParser extends SQLParserBase { } public functionNameCreate(): FunctionNameCreateContext { let localContext = new FunctionNameCreateContext(this.context, this.state); - this.enterRule(localContext, 270, FlinkSqlParser.RULE_functionNameCreate); + this.enterRule(localContext, 268, FlinkSqlParser.RULE_functionNameCreate); try { this.enterOuterAlt(localContext, 1); { - this.state = 1982; + this.state = 1970; this.uid(); } } @@ -9315,22 +9258,22 @@ export class FlinkSqlParser extends SQLParserBase { } public functionName(): FunctionNameContext { let localContext = new FunctionNameContext(this.context, this.state); - this.enterRule(localContext, 272, FlinkSqlParser.RULE_functionName); + this.enterRule(localContext, 270, FlinkSqlParser.RULE_functionName); try { - this.state = 1986; + this.state = 1974; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 229, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 225, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1984; + this.state = 1972; this.reservedKeywordsUsedAsFuncName(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1985; + this.state = 1973; this.uid(); } break; @@ -9352,36 +9295,36 @@ export class FlinkSqlParser extends SQLParserBase { } public functionParam(): FunctionParamContext { let localContext = new FunctionParamContext(this.context, this.state); - this.enterRule(localContext, 274, FlinkSqlParser.RULE_functionParam); + this.enterRule(localContext, 272, FlinkSqlParser.RULE_functionParam); try { - this.state = 1992; + this.state = 1980; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 230, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 226, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1988; + this.state = 1976; this.reservedKeywordsUsedAsFuncParam(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1989; + this.state = 1977; this.timeIntervalUnit(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1990; + this.state = 1978; this.timePointUnit(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1991; + this.state = 1979; this.expression(); } break; @@ -9403,11 +9346,11 @@ export class FlinkSqlParser extends SQLParserBase { } public dereferenceDefinition(): DereferenceDefinitionContext { let localContext = new DereferenceDefinitionContext(this.context, this.state); - this.enterRule(localContext, 276, FlinkSqlParser.RULE_dereferenceDefinition); + this.enterRule(localContext, 274, FlinkSqlParser.RULE_dereferenceDefinition); try { this.enterOuterAlt(localContext, 1); { - this.state = 1994; + this.state = 1982; this.uid(); } } @@ -9427,11 +9370,11 @@ export class FlinkSqlParser extends SQLParserBase { } public correlationName(): CorrelationNameContext { let localContext = new CorrelationNameContext(this.context, this.state); - this.enterRule(localContext, 278, FlinkSqlParser.RULE_correlationName); + this.enterRule(localContext, 276, FlinkSqlParser.RULE_correlationName); try { this.enterOuterAlt(localContext, 1); { - this.state = 1996; + this.state = 1984; this.identifier(); } } @@ -9451,22 +9394,22 @@ export class FlinkSqlParser extends SQLParserBase { } public qualifiedName(): QualifiedNameContext { let localContext = new QualifiedNameContext(this.context, this.state); - this.enterRule(localContext, 280, FlinkSqlParser.RULE_qualifiedName); + this.enterRule(localContext, 278, FlinkSqlParser.RULE_qualifiedName); try { - this.state = 2000; + this.state = 1988; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 231, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 227, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1998; + this.state = 1986; this.identifier(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1999; + this.state = 1987; this.dereferenceDefinition(); } break; @@ -9488,24 +9431,24 @@ export class FlinkSqlParser extends SQLParserBase { } public timeIntervalExpression(): TimeIntervalExpressionContext { let localContext = new TimeIntervalExpressionContext(this.context, this.state); - this.enterRule(localContext, 282, FlinkSqlParser.RULE_timeIntervalExpression); + this.enterRule(localContext, 280, FlinkSqlParser.RULE_timeIntervalExpression); try { this.enterOuterAlt(localContext, 1); { - this.state = 2002; + this.state = 1990; this.match(FlinkSqlParser.KW_INTERVAL); - this.state = 2005; + this.state = 1993; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 232, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 228, this.context) ) { case 1: { - this.state = 2003; + this.state = 1991; this.errorCapturingMultiUnitsInterval(); } break; case 2: { - this.state = 2004; + this.state = 1992; this.errorCapturingUnitToUnitInterval(); } break; @@ -9528,18 +9471,18 @@ export class FlinkSqlParser extends SQLParserBase { } public errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext { let localContext = new ErrorCapturingMultiUnitsIntervalContext(this.context, this.state); - this.enterRule(localContext, 284, FlinkSqlParser.RULE_errorCapturingMultiUnitsInterval); + this.enterRule(localContext, 282, FlinkSqlParser.RULE_errorCapturingMultiUnitsInterval); try { this.enterOuterAlt(localContext, 1); { - this.state = 2007; + this.state = 1995; this.multiUnitsInterval(); - this.state = 2009; + this.state = 1997; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 233, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 229, this.context) ) { case 1: { - this.state = 2008; + this.state = 1996; this.unitToUnitInterval(); } break; @@ -9562,12 +9505,12 @@ export class FlinkSqlParser extends SQLParserBase { } public multiUnitsInterval(): MultiUnitsIntervalContext { let localContext = new MultiUnitsIntervalContext(this.context, this.state); - this.enterRule(localContext, 286, FlinkSqlParser.RULE_multiUnitsInterval); + this.enterRule(localContext, 284, FlinkSqlParser.RULE_multiUnitsInterval); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 2014; + this.state = 2002; this.errorHandler.sync(this); alternative = 1; do { @@ -9575,9 +9518,9 @@ export class FlinkSqlParser extends SQLParserBase { case 1: { { - this.state = 2011; + this.state = 1999; this.intervalValue(); - this.state = 2012; + this.state = 2000; this.timeIntervalUnit(); } } @@ -9585,9 +9528,9 @@ export class FlinkSqlParser extends SQLParserBase { default: throw new antlr.NoViableAltException(this); } - this.state = 2016; + this.state = 2004; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 234, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 230, this.context); } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } } @@ -9607,24 +9550,24 @@ export class FlinkSqlParser extends SQLParserBase { } public errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext { let localContext = new ErrorCapturingUnitToUnitIntervalContext(this.context, this.state); - this.enterRule(localContext, 288, FlinkSqlParser.RULE_errorCapturingUnitToUnitInterval); + this.enterRule(localContext, 286, FlinkSqlParser.RULE_errorCapturingUnitToUnitInterval); try { this.enterOuterAlt(localContext, 1); { - this.state = 2018; + this.state = 2006; localContext._body = this.unitToUnitInterval(); - this.state = 2021; + this.state = 2009; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 235, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 231, this.context) ) { case 1: { - this.state = 2019; + this.state = 2007; localContext._error1 = this.multiUnitsInterval(); } break; case 2: { - this.state = 2020; + this.state = 2008; localContext._error2 = this.unitToUnitInterval(); } break; @@ -9647,17 +9590,17 @@ export class FlinkSqlParser extends SQLParserBase { } public unitToUnitInterval(): UnitToUnitIntervalContext { let localContext = new UnitToUnitIntervalContext(this.context, this.state); - this.enterRule(localContext, 290, FlinkSqlParser.RULE_unitToUnitInterval); + this.enterRule(localContext, 288, FlinkSqlParser.RULE_unitToUnitInterval); try { this.enterOuterAlt(localContext, 1); { - this.state = 2023; + this.state = 2011; localContext._value = this.intervalValue(); - this.state = 2024; + this.state = 2012; localContext._from_ = this.timeIntervalUnit(); - this.state = 2025; + this.state = 2013; this.match(FlinkSqlParser.KW_TO); - this.state = 2026; + this.state = 2014; localContext._to = this.timeIntervalUnit(); } } @@ -9677,10 +9620,10 @@ export class FlinkSqlParser extends SQLParserBase { } public intervalValue(): IntervalValueContext { let localContext = new IntervalValueContext(this.context, this.state); - this.enterRule(localContext, 292, FlinkSqlParser.RULE_intervalValue); + this.enterRule(localContext, 290, FlinkSqlParser.RULE_intervalValue); let _la: number; try { - this.state = 2033; + this.state = 2021; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.HYPNEN_SIGN: @@ -9689,12 +9632,12 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.REAL_LITERAL: this.enterOuterAlt(localContext, 1); { - this.state = 2029; + this.state = 2017; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 529 || _la === 530) { { - this.state = 2028; + this.state = 2016; _la = this.tokenStream.LA(1); if(!(_la === 529 || _la === 530)) { this.errorHandler.recoverInline(this); @@ -9706,7 +9649,7 @@ export class FlinkSqlParser extends SQLParserBase { } } - this.state = 2031; + this.state = 2019; _la = this.tokenStream.LA(1); if(!(_la === 538 || _la === 539)) { this.errorHandler.recoverInline(this); @@ -9720,7 +9663,7 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.STRING_LITERAL: this.enterOuterAlt(localContext, 2); { - this.state = 2032; + this.state = 2020; this.match(FlinkSqlParser.STRING_LITERAL); } break; @@ -9744,29 +9687,29 @@ export class FlinkSqlParser extends SQLParserBase { } public tableAlias(): TableAliasContext { let localContext = new TableAliasContext(this.context, this.state); - this.enterRule(localContext, 294, FlinkSqlParser.RULE_tableAlias); + this.enterRule(localContext, 292, FlinkSqlParser.RULE_tableAlias); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2036; + this.state = 2024; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 17) { { - this.state = 2035; + this.state = 2023; this.match(FlinkSqlParser.KW_AS); } } - this.state = 2038; - this.identifier(); - this.state = 2040; + this.state = 2026; + localContext._alias = this.identifier(); + this.state = 2028; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 239, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 235, this.context) ) { case 1: { - this.state = 2039; + this.state = 2027; this.identifierList(); } break; @@ -9789,13 +9732,13 @@ export class FlinkSqlParser extends SQLParserBase { } public errorCapturingIdentifier(): ErrorCapturingIdentifierContext { let localContext = new ErrorCapturingIdentifierContext(this.context, this.state); - this.enterRule(localContext, 296, FlinkSqlParser.RULE_errorCapturingIdentifier); + this.enterRule(localContext, 294, FlinkSqlParser.RULE_errorCapturingIdentifier); try { this.enterOuterAlt(localContext, 1); { - this.state = 2042; + this.state = 2030; this.identifier(); - this.state = 2043; + this.state = 2031; this.errorCapturingIdentifierExtra(); } } @@ -9815,29 +9758,29 @@ export class FlinkSqlParser extends SQLParserBase { } public errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext { let localContext = new ErrorCapturingIdentifierExtraContext(this.context, this.state); - this.enterRule(localContext, 298, FlinkSqlParser.RULE_errorCapturingIdentifierExtra); + this.enterRule(localContext, 296, FlinkSqlParser.RULE_errorCapturingIdentifierExtra); let _la: number; try { - this.state = 2052; + this.state = 2040; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_MINUS: localContext = new ErrorIdentContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2047; + this.state = 2035; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 2045; + this.state = 2033; this.match(FlinkSqlParser.KW_MINUS); - this.state = 2046; + this.state = 2034; this.identifier(); } } - this.state = 2049; + this.state = 2037; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 221); @@ -9871,15 +9814,15 @@ export class FlinkSqlParser extends SQLParserBase { } public identifierList(): IdentifierListContext { let localContext = new IdentifierListContext(this.context, this.state); - this.enterRule(localContext, 300, FlinkSqlParser.RULE_identifierList); + this.enterRule(localContext, 298, FlinkSqlParser.RULE_identifierList); try { this.enterOuterAlt(localContext, 1); { - this.state = 2054; + this.state = 2042; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 2055; + this.state = 2043; this.identifierSeq(); - this.state = 2056; + this.state = 2044; this.match(FlinkSqlParser.RR_BRACKET); } } @@ -9899,26 +9842,26 @@ export class FlinkSqlParser extends SQLParserBase { } public identifierSeq(): IdentifierSeqContext { let localContext = new IdentifierSeqContext(this.context, this.state); - this.enterRule(localContext, 302, FlinkSqlParser.RULE_identifierSeq); + this.enterRule(localContext, 300, FlinkSqlParser.RULE_identifierSeq); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2058; + this.state = 2046; this.identifier(); - this.state = 2063; + this.state = 2051; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 2059; + this.state = 2047; this.match(FlinkSqlParser.COMMA); - this.state = 2060; + this.state = 2048; this.identifier(); } } - this.state = 2065; + this.state = 2053; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -9940,9 +9883,9 @@ export class FlinkSqlParser extends SQLParserBase { } public identifier(): IdentifierContext { let localContext = new IdentifierContext(this.context, this.state); - this.enterRule(localContext, 304, FlinkSqlParser.RULE_identifier); + this.enterRule(localContext, 302, FlinkSqlParser.RULE_identifier); try { - this.state = 2069; + this.state = 2057; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.DIG_LITERAL: @@ -9950,7 +9893,7 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new UnquotedIdentifierAlternativeContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2066; + this.state = 2054; this.unquotedIdentifier(); } break; @@ -9958,7 +9901,7 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new QuotedIdentifierAlternativeContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 2067; + this.state = 2055; this.quotedIdentifier(); } break; @@ -10033,7 +9976,7 @@ export class FlinkSqlParser extends SQLParserBase { localContext = new NonReservedKeywordsAlternativeContext(localContext); this.enterOuterAlt(localContext, 3); { - this.state = 2068; + this.state = 2056; this.nonReservedKeywords(); } break; @@ -10057,12 +10000,12 @@ export class FlinkSqlParser extends SQLParserBase { } public unquotedIdentifier(): UnquotedIdentifierContext { let localContext = new UnquotedIdentifierContext(this.context, this.state); - this.enterRule(localContext, 306, FlinkSqlParser.RULE_unquotedIdentifier); + this.enterRule(localContext, 304, FlinkSqlParser.RULE_unquotedIdentifier); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2071; + this.state = 2059; _la = this.tokenStream.LA(1); if(!(_la === 538 || _la === 541)) { this.errorHandler.recoverInline(this); @@ -10089,11 +10032,11 @@ export class FlinkSqlParser extends SQLParserBase { } public quotedIdentifier(): QuotedIdentifierContext { let localContext = new QuotedIdentifierContext(this.context, this.state); - this.enterRule(localContext, 308, FlinkSqlParser.RULE_quotedIdentifier); + this.enterRule(localContext, 306, FlinkSqlParser.RULE_quotedIdentifier); try { this.enterOuterAlt(localContext, 1); { - this.state = 2073; + this.state = 2061; this.match(FlinkSqlParser.STRING_LITERAL); } } @@ -10113,17 +10056,17 @@ export class FlinkSqlParser extends SQLParserBase { } public whenClause(): WhenClauseContext { let localContext = new WhenClauseContext(this.context, this.state); - this.enterRule(localContext, 310, FlinkSqlParser.RULE_whenClause); + this.enterRule(localContext, 308, FlinkSqlParser.RULE_whenClause); try { this.enterOuterAlt(localContext, 1); { - this.state = 2075; + this.state = 2063; this.match(FlinkSqlParser.KW_WHEN); - this.state = 2076; + this.state = 2064; localContext._condition = this.expression(); - this.state = 2077; + this.state = 2065; this.match(FlinkSqlParser.KW_THEN); - this.state = 2078; + this.state = 2066; localContext._result = this.expression(); } } @@ -10143,11 +10086,11 @@ export class FlinkSqlParser extends SQLParserBase { } public catalogPath(): CatalogPathContext { let localContext = new CatalogPathContext(this.context, this.state); - this.enterRule(localContext, 312, FlinkSqlParser.RULE_catalogPath); + this.enterRule(localContext, 310, FlinkSqlParser.RULE_catalogPath); try { this.enterOuterAlt(localContext, 1); { - this.state = 2080; + this.state = 2068; this.identifier(); } } @@ -10167,11 +10110,11 @@ export class FlinkSqlParser extends SQLParserBase { } public catalogPathCreate(): CatalogPathCreateContext { let localContext = new CatalogPathCreateContext(this.context, this.state); - this.enterRule(localContext, 314, FlinkSqlParser.RULE_catalogPathCreate); + this.enterRule(localContext, 312, FlinkSqlParser.RULE_catalogPathCreate); try { this.enterOuterAlt(localContext, 1); { - this.state = 2082; + this.state = 2070; this.identifier(); } } @@ -10191,21 +10134,21 @@ export class FlinkSqlParser extends SQLParserBase { } public databasePath(): DatabasePathContext { let localContext = new DatabasePathContext(this.context, this.state); - this.enterRule(localContext, 316, FlinkSqlParser.RULE_databasePath); + this.enterRule(localContext, 314, FlinkSqlParser.RULE_databasePath); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2084; + this.state = 2072; this.identifier(); - this.state = 2087; + this.state = 2075; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 513) { { - this.state = 2085; + this.state = 2073; this.match(FlinkSqlParser.DOT); - this.state = 2086; + this.state = 2074; this.identifier(); } } @@ -10228,21 +10171,21 @@ export class FlinkSqlParser extends SQLParserBase { } public databasePathCreate(): DatabasePathCreateContext { let localContext = new DatabasePathCreateContext(this.context, this.state); - this.enterRule(localContext, 318, FlinkSqlParser.RULE_databasePathCreate); + this.enterRule(localContext, 316, FlinkSqlParser.RULE_databasePathCreate); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2089; + this.state = 2077; this.identifier(); - this.state = 2092; + this.state = 2080; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 513) { { - this.state = 2090; + this.state = 2078; this.match(FlinkSqlParser.DOT); - this.state = 2091; + this.state = 2079; this.identifier(); } } @@ -10265,25 +10208,25 @@ export class FlinkSqlParser extends SQLParserBase { } public tablePathCreate(): TablePathCreateContext { let localContext = new TablePathCreateContext(this.context, this.state); - this.enterRule(localContext, 320, FlinkSqlParser.RULE_tablePathCreate); + this.enterRule(localContext, 318, FlinkSqlParser.RULE_tablePathCreate); let _la: number; try { - this.state = 2106; + this.state = 2094; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 248, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 244, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2094; + this.state = 2082; this.identifier(); - this.state = 2097; + this.state = 2085; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 513) { { - this.state = 2095; + this.state = 2083; this.match(FlinkSqlParser.DOT); - this.state = 2096; + this.state = 2084; this.identifier(); } } @@ -10293,20 +10236,20 @@ export class FlinkSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2099; + this.state = 2087; this.identifier(); - this.state = 2100; + this.state = 2088; this.match(FlinkSqlParser.DOT); - this.state = 2101; + this.state = 2089; this.identifier(); - this.state = 2104; + this.state = 2092; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 513) { { - this.state = 2102; + this.state = 2090; this.match(FlinkSqlParser.DOT); - this.state = 2103; + this.state = 2091; this.identifier(); } } @@ -10331,24 +10274,24 @@ export class FlinkSqlParser extends SQLParserBase { } public tablePath(): TablePathContext { let localContext = new TablePathContext(this.context, this.state); - this.enterRule(localContext, 322, FlinkSqlParser.RULE_tablePath); + this.enterRule(localContext, 320, FlinkSqlParser.RULE_tablePath); try { - this.state = 2120; + this.state = 2108; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 251, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 247, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2108; + this.state = 2096; this.identifier(); - this.state = 2111; + this.state = 2099; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 249, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 245, this.context) ) { case 1: { - this.state = 2109; + this.state = 2097; this.match(FlinkSqlParser.DOT); - this.state = 2110; + this.state = 2098; this.identifier(); } break; @@ -10358,20 +10301,20 @@ export class FlinkSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2113; + this.state = 2101; this.identifier(); - this.state = 2114; + this.state = 2102; this.match(FlinkSqlParser.DOT); - this.state = 2115; + this.state = 2103; this.identifier(); - this.state = 2118; + this.state = 2106; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 250, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 246, this.context) ) { case 1: { - this.state = 2116; + this.state = 2104; this.match(FlinkSqlParser.DOT); - this.state = 2117; + this.state = 2105; this.identifier(); } break; @@ -10396,24 +10339,24 @@ export class FlinkSqlParser extends SQLParserBase { } public viewPath(): ViewPathContext { let localContext = new ViewPathContext(this.context, this.state); - this.enterRule(localContext, 324, FlinkSqlParser.RULE_viewPath); + this.enterRule(localContext, 322, FlinkSqlParser.RULE_viewPath); try { - this.state = 2134; + this.state = 2122; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 254, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 250, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2122; + this.state = 2110; this.identifier(); - this.state = 2125; + this.state = 2113; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 252, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 248, this.context) ) { case 1: { - this.state = 2123; + this.state = 2111; this.match(FlinkSqlParser.DOT); - this.state = 2124; + this.state = 2112; this.identifier(); } break; @@ -10423,20 +10366,20 @@ export class FlinkSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2127; + this.state = 2115; this.identifier(); - this.state = 2128; + this.state = 2116; this.match(FlinkSqlParser.DOT); - this.state = 2129; + this.state = 2117; this.identifier(); - this.state = 2132; + this.state = 2120; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 253, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 249, this.context) ) { case 1: { - this.state = 2130; + this.state = 2118; this.match(FlinkSqlParser.DOT); - this.state = 2131; + this.state = 2119; this.identifier(); } break; @@ -10461,25 +10404,25 @@ export class FlinkSqlParser extends SQLParserBase { } public viewPathCreate(): ViewPathCreateContext { let localContext = new ViewPathCreateContext(this.context, this.state); - this.enterRule(localContext, 326, FlinkSqlParser.RULE_viewPathCreate); + this.enterRule(localContext, 324, FlinkSqlParser.RULE_viewPathCreate); let _la: number; try { - this.state = 2148; + this.state = 2136; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 257, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 253, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2136; + this.state = 2124; this.identifier(); - this.state = 2139; + this.state = 2127; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 513) { { - this.state = 2137; + this.state = 2125; this.match(FlinkSqlParser.DOT); - this.state = 2138; + this.state = 2126; this.identifier(); } } @@ -10489,20 +10432,20 @@ export class FlinkSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2141; + this.state = 2129; this.identifier(); - this.state = 2142; + this.state = 2130; this.match(FlinkSqlParser.DOT); - this.state = 2143; + this.state = 2131; this.identifier(); - this.state = 2146; + this.state = 2134; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 513) { { - this.state = 2144; + this.state = 2132; this.match(FlinkSqlParser.DOT); - this.state = 2145; + this.state = 2133; this.identifier(); } } @@ -10527,30 +10470,30 @@ export class FlinkSqlParser extends SQLParserBase { } public uid(): UidContext { let localContext = new UidContext(this.context, this.state); - this.enterRule(localContext, 328, FlinkSqlParser.RULE_uid); + this.enterRule(localContext, 326, FlinkSqlParser.RULE_uid); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 2150; + this.state = 2138; this.identifier(); - this.state = 2155; + this.state = 2143; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 258, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 254, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 2151; + this.state = 2139; this.match(FlinkSqlParser.DOT); - this.state = 2152; + this.state = 2140; this.identifier(); } } } - this.state = 2157; + this.state = 2145; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 258, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 254, this.context); } } } @@ -10570,13 +10513,13 @@ export class FlinkSqlParser extends SQLParserBase { } public withOption(): WithOptionContext { let localContext = new WithOptionContext(this.context, this.state); - this.enterRule(localContext, 330, FlinkSqlParser.RULE_withOption); + this.enterRule(localContext, 328, FlinkSqlParser.RULE_withOption); try { this.enterOuterAlt(localContext, 1); { - this.state = 2158; + this.state = 2146; this.match(FlinkSqlParser.KW_WITH); - this.state = 2159; + this.state = 2147; this.tablePropertyList(); } } @@ -10596,15 +10539,15 @@ export class FlinkSqlParser extends SQLParserBase { } public ifNotExists(): IfNotExistsContext { let localContext = new IfNotExistsContext(this.context, this.state); - this.enterRule(localContext, 332, FlinkSqlParser.RULE_ifNotExists); + this.enterRule(localContext, 330, FlinkSqlParser.RULE_ifNotExists); try { this.enterOuterAlt(localContext, 1); { - this.state = 2161; + this.state = 2149; this.match(FlinkSqlParser.KW_IF); - this.state = 2162; + this.state = 2150; this.match(FlinkSqlParser.KW_NOT); - this.state = 2163; + this.state = 2151; this.match(FlinkSqlParser.KW_EXISTS); } } @@ -10624,13 +10567,13 @@ export class FlinkSqlParser extends SQLParserBase { } public ifExists(): IfExistsContext { let localContext = new IfExistsContext(this.context, this.state); - this.enterRule(localContext, 334, FlinkSqlParser.RULE_ifExists); + this.enterRule(localContext, 332, FlinkSqlParser.RULE_ifExists); try { this.enterOuterAlt(localContext, 1); { - this.state = 2165; + this.state = 2153; this.match(FlinkSqlParser.KW_IF); - this.state = 2166; + this.state = 2154; this.match(FlinkSqlParser.KW_EXISTS); } } @@ -10650,32 +10593,32 @@ export class FlinkSqlParser extends SQLParserBase { } public tablePropertyList(): TablePropertyListContext { let localContext = new TablePropertyListContext(this.context, this.state); - this.enterRule(localContext, 336, FlinkSqlParser.RULE_tablePropertyList); + this.enterRule(localContext, 334, FlinkSqlParser.RULE_tablePropertyList); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2168; + this.state = 2156; this.match(FlinkSqlParser.LR_BRACKET); - this.state = 2169; + this.state = 2157; this.tableProperty(); - this.state = 2174; + this.state = 2162; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 520) { { { - this.state = 2170; + this.state = 2158; this.match(FlinkSqlParser.COMMA); - this.state = 2171; + this.state = 2159; this.tableProperty(); } } - this.state = 2176; + this.state = 2164; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 2177; + this.state = 2165; this.match(FlinkSqlParser.RR_BRACKET); } } @@ -10695,29 +10638,29 @@ export class FlinkSqlParser extends SQLParserBase { } public tableProperty(): TablePropertyContext { let localContext = new TablePropertyContext(this.context, this.state); - this.enterRule(localContext, 338, FlinkSqlParser.RULE_tableProperty); + this.enterRule(localContext, 336, FlinkSqlParser.RULE_tableProperty); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2179; + this.state = 2167; localContext._key = this.tablePropertyKey(); - this.state = 2184; + this.state = 2172; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 140 || _la === 397 || _la === 505 || ((((_la - 537)) & ~0x1F) === 0 && ((1 << (_la - 537)) & 7) !== 0)) { { - this.state = 2181; + this.state = 2169; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 505) { { - this.state = 2180; + this.state = 2168; this.match(FlinkSqlParser.EQUAL_SYMBOL); } } - this.state = 2183; + this.state = 2171; localContext._value = this.tablePropertyValue(); } } @@ -10740,29 +10683,29 @@ export class FlinkSqlParser extends SQLParserBase { } public tablePropertyKey(): TablePropertyKeyContext { let localContext = new TablePropertyKeyContext(this.context, this.state); - this.enterRule(localContext, 340, FlinkSqlParser.RULE_tablePropertyKey); + this.enterRule(localContext, 338, FlinkSqlParser.RULE_tablePropertyKey); try { - this.state = 2189; + this.state = 2177; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 262, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 258, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2186; + this.state = 2174; this.identifier(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2187; + this.state = 2175; this.dereferenceDefinition(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2188; + this.state = 2176; this.match(FlinkSqlParser.STRING_LITERAL); } break; @@ -10784,22 +10727,22 @@ export class FlinkSqlParser extends SQLParserBase { } public tablePropertyValue(): TablePropertyValueContext { let localContext = new TablePropertyValueContext(this.context, this.state); - this.enterRule(localContext, 342, FlinkSqlParser.RULE_tablePropertyValue); + this.enterRule(localContext, 340, FlinkSqlParser.RULE_tablePropertyValue); try { - this.state = 2195; + this.state = 2183; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.DIG_LITERAL: this.enterOuterAlt(localContext, 1); { - this.state = 2191; + this.state = 2179; this.match(FlinkSqlParser.DIG_LITERAL); } break; case FlinkSqlParser.REAL_LITERAL: this.enterOuterAlt(localContext, 2); { - this.state = 2192; + this.state = 2180; this.match(FlinkSqlParser.REAL_LITERAL); } break; @@ -10807,14 +10750,14 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.KW_TRUE: this.enterOuterAlt(localContext, 3); { - this.state = 2193; + this.state = 2181; this.booleanLiteral(); } break; case FlinkSqlParser.STRING_LITERAL: this.enterOuterAlt(localContext, 4); { - this.state = 2194; + this.state = 2182; this.match(FlinkSqlParser.STRING_LITERAL); } break; @@ -10838,40 +10781,40 @@ export class FlinkSqlParser extends SQLParserBase { } public logicalOperator(): LogicalOperatorContext { let localContext = new LogicalOperatorContext(this.context, this.state); - this.enterRule(localContext, 344, FlinkSqlParser.RULE_logicalOperator); + this.enterRule(localContext, 342, FlinkSqlParser.RULE_logicalOperator); try { - this.state = 2203; + this.state = 2191; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_AND: this.enterOuterAlt(localContext, 1); { - this.state = 2197; + this.state = 2185; this.match(FlinkSqlParser.KW_AND); } break; case FlinkSqlParser.BIT_AND_OP: this.enterOuterAlt(localContext, 2); { - this.state = 2198; + this.state = 2186; this.match(FlinkSqlParser.BIT_AND_OP); - this.state = 2199; + this.state = 2187; this.match(FlinkSqlParser.BIT_AND_OP); } break; case FlinkSqlParser.KW_OR: this.enterOuterAlt(localContext, 3); { - this.state = 2200; + this.state = 2188; this.match(FlinkSqlParser.KW_OR); } break; case FlinkSqlParser.BIT_OR_OP: this.enterOuterAlt(localContext, 4); { - this.state = 2201; + this.state = 2189; this.match(FlinkSqlParser.BIT_OR_OP); - this.state = 2202; + this.state = 2190; this.match(FlinkSqlParser.BIT_OR_OP); } break; @@ -10895,76 +10838,76 @@ export class FlinkSqlParser extends SQLParserBase { } public comparisonOperator(): ComparisonOperatorContext { let localContext = new ComparisonOperatorContext(this.context, this.state); - this.enterRule(localContext, 346, FlinkSqlParser.RULE_comparisonOperator); + this.enterRule(localContext, 344, FlinkSqlParser.RULE_comparisonOperator); try { - this.state = 2219; + this.state = 2207; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 265, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 261, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2205; + this.state = 2193; this.match(FlinkSqlParser.EQUAL_SYMBOL); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2206; + this.state = 2194; this.match(FlinkSqlParser.GREATER_SYMBOL); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2207; + this.state = 2195; this.match(FlinkSqlParser.LESS_SYMBOL); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2208; + this.state = 2196; this.match(FlinkSqlParser.LESS_SYMBOL); - this.state = 2209; + this.state = 2197; this.match(FlinkSqlParser.EQUAL_SYMBOL); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 2210; + this.state = 2198; this.match(FlinkSqlParser.GREATER_SYMBOL); - this.state = 2211; + this.state = 2199; this.match(FlinkSqlParser.EQUAL_SYMBOL); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 2212; + this.state = 2200; this.match(FlinkSqlParser.LESS_SYMBOL); - this.state = 2213; + this.state = 2201; this.match(FlinkSqlParser.GREATER_SYMBOL); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 2214; + this.state = 2202; this.match(FlinkSqlParser.EXCLAMATION_SYMBOL); - this.state = 2215; + this.state = 2203; this.match(FlinkSqlParser.EQUAL_SYMBOL); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 2216; + this.state = 2204; this.match(FlinkSqlParser.LESS_SYMBOL); - this.state = 2217; + this.state = 2205; this.match(FlinkSqlParser.EQUAL_SYMBOL); - this.state = 2218; + this.state = 2206; this.match(FlinkSqlParser.GREATER_SYMBOL); } break; @@ -10986,47 +10929,47 @@ export class FlinkSqlParser extends SQLParserBase { } public bitOperator(): BitOperatorContext { let localContext = new BitOperatorContext(this.context, this.state); - this.enterRule(localContext, 348, FlinkSqlParser.RULE_bitOperator); + this.enterRule(localContext, 346, FlinkSqlParser.RULE_bitOperator); try { - this.state = 2228; + this.state = 2216; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.LESS_SYMBOL: this.enterOuterAlt(localContext, 1); { - this.state = 2221; + this.state = 2209; this.match(FlinkSqlParser.LESS_SYMBOL); - this.state = 2222; + this.state = 2210; this.match(FlinkSqlParser.LESS_SYMBOL); } break; case FlinkSqlParser.GREATER_SYMBOL: this.enterOuterAlt(localContext, 2); { - this.state = 2223; + this.state = 2211; this.match(FlinkSqlParser.GREATER_SYMBOL); - this.state = 2224; + this.state = 2212; this.match(FlinkSqlParser.GREATER_SYMBOL); } break; case FlinkSqlParser.BIT_AND_OP: this.enterOuterAlt(localContext, 3); { - this.state = 2225; + this.state = 2213; this.match(FlinkSqlParser.BIT_AND_OP); } break; case FlinkSqlParser.BIT_XOR_OP: this.enterOuterAlt(localContext, 4); { - this.state = 2226; + this.state = 2214; this.match(FlinkSqlParser.BIT_XOR_OP); } break; case FlinkSqlParser.BIT_OR_OP: this.enterOuterAlt(localContext, 5); { - this.state = 2227; + this.state = 2215; this.match(FlinkSqlParser.BIT_OR_OP); } break; @@ -11050,12 +10993,12 @@ export class FlinkSqlParser extends SQLParserBase { } public mathOperator(): MathOperatorContext { let localContext = new MathOperatorContext(this.context, this.state); - this.enterRule(localContext, 350, FlinkSqlParser.RULE_mathOperator); + this.enterRule(localContext, 348, FlinkSqlParser.RULE_mathOperator); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2230; + this.state = 2218; _la = this.tokenStream.LA(1); if(!(_la === 452 || ((((_la - 527)) & ~0x1F) === 0 && ((1 << (_la - 527)) & 221) !== 0))) { this.errorHandler.recoverInline(this); @@ -11082,12 +11025,12 @@ export class FlinkSqlParser extends SQLParserBase { } public unaryOperator(): UnaryOperatorContext { let localContext = new UnaryOperatorContext(this.context, this.state); - this.enterRule(localContext, 352, FlinkSqlParser.RULE_unaryOperator); + this.enterRule(localContext, 350, FlinkSqlParser.RULE_unaryOperator); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2232; + this.state = 2220; _la = this.tokenStream.LA(1); if(!(_la === 241 || ((((_la - 508)) & ~0x1F) === 0 && ((1 << (_la - 508)) & 6291459) !== 0))) { this.errorHandler.recoverInline(this); @@ -11114,16 +11057,16 @@ export class FlinkSqlParser extends SQLParserBase { } public constant(): ConstantContext { let localContext = new ConstantContext(this.context, this.state); - this.enterRule(localContext, 354, FlinkSqlParser.RULE_constant); + this.enterRule(localContext, 352, FlinkSqlParser.RULE_constant); let _la: number; try { - this.state = 2248; + this.state = 2236; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case FlinkSqlParser.KW_INTERVAL: this.enterOuterAlt(localContext, 1); { - this.state = 2234; + this.state = 2222; this.timeIntervalExpression(); } break; @@ -11139,14 +11082,14 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.KW_WEEK: this.enterOuterAlt(localContext, 2); { - this.state = 2235; + this.state = 2223; this.timePointLiteral(); } break; case FlinkSqlParser.STRING_LITERAL: this.enterOuterAlt(localContext, 3); { - this.state = 2236; + this.state = 2224; this.stringLiteral(); } break; @@ -11154,17 +11097,17 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.DIG_LITERAL: this.enterOuterAlt(localContext, 4); { - this.state = 2238; + this.state = 2226; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 529) { { - this.state = 2237; + this.state = 2225; this.match(FlinkSqlParser.HYPNEN_SIGN); } } - this.state = 2240; + this.state = 2228; this.decimalLiteral(); } break; @@ -11172,21 +11115,21 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.KW_TRUE: this.enterOuterAlt(localContext, 5); { - this.state = 2241; + this.state = 2229; this.booleanLiteral(); } break; case FlinkSqlParser.REAL_LITERAL: this.enterOuterAlt(localContext, 6); { - this.state = 2242; + this.state = 2230; this.match(FlinkSqlParser.REAL_LITERAL); } break; case FlinkSqlParser.BIT_STRING: this.enterOuterAlt(localContext, 7); { - this.state = 2243; + this.state = 2231; this.match(FlinkSqlParser.BIT_STRING); } break; @@ -11194,17 +11137,17 @@ export class FlinkSqlParser extends SQLParserBase { case FlinkSqlParser.KW_NULL: this.enterOuterAlt(localContext, 8); { - this.state = 2245; + this.state = 2233; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 241) { { - this.state = 2244; + this.state = 2232; this.match(FlinkSqlParser.KW_NOT); } } - this.state = 2247; + this.state = 2235; this.match(FlinkSqlParser.KW_NULL); } break; @@ -11228,13 +11171,13 @@ export class FlinkSqlParser extends SQLParserBase { } public timePointLiteral(): TimePointLiteralContext { let localContext = new TimePointLiteralContext(this.context, this.state); - this.enterRule(localContext, 356, FlinkSqlParser.RULE_timePointLiteral); + this.enterRule(localContext, 354, FlinkSqlParser.RULE_timePointLiteral); try { this.enterOuterAlt(localContext, 1); { - this.state = 2250; + this.state = 2238; this.timePointUnit(); - this.state = 2251; + this.state = 2239; this.stringLiteral(); } } @@ -11254,11 +11197,11 @@ export class FlinkSqlParser extends SQLParserBase { } public stringLiteral(): StringLiteralContext { let localContext = new StringLiteralContext(this.context, this.state); - this.enterRule(localContext, 358, FlinkSqlParser.RULE_stringLiteral); + this.enterRule(localContext, 356, FlinkSqlParser.RULE_stringLiteral); try { this.enterOuterAlt(localContext, 1); { - this.state = 2253; + this.state = 2241; this.match(FlinkSqlParser.STRING_LITERAL); } } @@ -11278,11 +11221,11 @@ export class FlinkSqlParser extends SQLParserBase { } public decimalLiteral(): DecimalLiteralContext { let localContext = new DecimalLiteralContext(this.context, this.state); - this.enterRule(localContext, 360, FlinkSqlParser.RULE_decimalLiteral); + this.enterRule(localContext, 358, FlinkSqlParser.RULE_decimalLiteral); try { this.enterOuterAlt(localContext, 1); { - this.state = 2255; + this.state = 2243; this.match(FlinkSqlParser.DIG_LITERAL); } } @@ -11302,12 +11245,12 @@ export class FlinkSqlParser extends SQLParserBase { } public booleanLiteral(): BooleanLiteralContext { let localContext = new BooleanLiteralContext(this.context, this.state); - this.enterRule(localContext, 362, FlinkSqlParser.RULE_booleanLiteral); + this.enterRule(localContext, 360, FlinkSqlParser.RULE_booleanLiteral); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2257; + this.state = 2245; _la = this.tokenStream.LA(1); if(!(_la === 140 || _la === 397)) { this.errorHandler.recoverInline(this); @@ -11334,12 +11277,12 @@ export class FlinkSqlParser extends SQLParserBase { } public setQuantifier(): SetQuantifierContext { let localContext = new SetQuantifierContext(this.context, this.state); - this.enterRule(localContext, 364, FlinkSqlParser.RULE_setQuantifier); + this.enterRule(localContext, 362, FlinkSqlParser.RULE_setQuantifier); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2259; + this.state = 2247; _la = this.tokenStream.LA(1); if(!(_la === 5 || _la === 113)) { this.errorHandler.recoverInline(this); @@ -11366,12 +11309,12 @@ export class FlinkSqlParser extends SQLParserBase { } public timePointUnit(): TimePointUnitContext { let localContext = new TimePointUnitContext(this.context, this.state); - this.enterRule(localContext, 366, FlinkSqlParser.RULE_timePointUnit); + this.enterRule(localContext, 364, FlinkSqlParser.RULE_timePointUnit); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2261; + this.state = 2249; _la = this.tokenStream.LA(1); if(!(_la === 97 || _la === 165 || _la === 222 || _la === 229 || _la === 334 || _la === 436 || ((((_la - 470)) & ~0x1F) === 0 && ((1 << (_la - 470)) & 262149) !== 0) || _la === 502)) { this.errorHandler.recoverInline(this); @@ -11398,12 +11341,12 @@ export class FlinkSqlParser extends SQLParserBase { } public timeIntervalUnit(): TimeIntervalUnitContext { let localContext = new TimeIntervalUnitContext(this.context, this.state); - this.enterRule(localContext, 368, FlinkSqlParser.RULE_timeIntervalUnit); + this.enterRule(localContext, 366, FlinkSqlParser.RULE_timeIntervalUnit); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2263; + this.state = 2251; _la = this.tokenStream.LA(1); if(!(_la === 97 || _la === 165 || _la === 222 || _la === 229 || _la === 334 || ((((_la - 427)) & ~0x1F) === 0 && ((1 << (_la - 427)) & 140542465) !== 0) || ((((_la - 460)) & ~0x1F) === 0 && ((1 << (_la - 460)) & 2415983617) !== 0) || _la === 502 || _la === 503)) { this.errorHandler.recoverInline(this); @@ -11430,12 +11373,12 @@ export class FlinkSqlParser extends SQLParserBase { } public reservedKeywordsUsedAsFuncParam(): ReservedKeywordsUsedAsFuncParamContext { let localContext = new ReservedKeywordsUsedAsFuncParamContext(this.context, this.state); - this.enterRule(localContext, 370, FlinkSqlParser.RULE_reservedKeywordsUsedAsFuncParam); + this.enterRule(localContext, 368, FlinkSqlParser.RULE_reservedKeywordsUsedAsFuncParam); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2265; + this.state = 2253; _la = this.tokenStream.LA(1); if(!(((((_la - 5)) & ~0x1F) === 0 && ((1 << (_la - 5)) & 268435713) !== 0) || ((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 193) !== 0) || _la === 113 || ((((_la - 200)) & ~0x1F) === 0 && ((1 << (_la - 200)) & 385) !== 0) || _la === 389 || _la === 413 || _la === 527)) { this.errorHandler.recoverInline(this); @@ -11462,12 +11405,12 @@ export class FlinkSqlParser extends SQLParserBase { } public reservedKeywordsUsedAsFuncName(): ReservedKeywordsUsedAsFuncNameContext { let localContext = new ReservedKeywordsUsedAsFuncNameContext(this.context, this.state); - this.enterRule(localContext, 372, FlinkSqlParser.RULE_reservedKeywordsUsedAsFuncName); + this.enterRule(localContext, 370, FlinkSqlParser.RULE_reservedKeywordsUsedAsFuncName); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2267; + this.state = 2255; _la = this.tokenStream.LA(1); if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 8396816) !== 0) || ((((_la - 38)) & ~0x1F) === 0 && ((1 << (_la - 38)) & 2147811433) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 25232905) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 134221825) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 337641553) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 873523369) !== 0) || ((((_la - 229)) & ~0x1F) === 0 && ((1 << (_la - 229)) & 81921) !== 0) || ((((_la - 264)) & ~0x1F) === 0 && ((1 << (_la - 264)) & 537530369) !== 0) || ((((_la - 317)) & ~0x1F) === 0 && ((1 << (_la - 317)) & 131185) !== 0) || ((((_la - 357)) & ~0x1F) === 0 && ((1 << (_la - 357)) & 14681219) !== 0) || ((((_la - 395)) & ~0x1F) === 0 && ((1 << (_la - 395)) & 50339865) !== 0) || _la === 436 || _la === 469 || _la === 488 || _la === 502)) { this.errorHandler.recoverInline(this); @@ -11494,12 +11437,12 @@ export class FlinkSqlParser extends SQLParserBase { } public nonReservedKeywords(): NonReservedKeywordsContext { let localContext = new NonReservedKeywordsContext(this.context, this.state); - this.enterRule(localContext, 374, FlinkSqlParser.RULE_nonReservedKeywords); + this.enterRule(localContext, 372, FlinkSqlParser.RULE_nonReservedKeywords); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2269; + this.state = 2257; _la = this.tokenStream.LA(1); if(!(((((_la - 437)) & ~0x1F) === 0 && ((1 << (_la - 437)) & 4294967295) !== 0) || ((((_la - 469)) & ~0x1F) === 0 && ((1 << (_la - 469)) & 4294967295) !== 0) || ((((_la - 501)) & ~0x1F) === 0 && ((1 << (_la - 501)) & 15) !== 0))) { this.errorHandler.recoverInline(this); @@ -11529,15 +11472,15 @@ export class FlinkSqlParser extends SQLParserBase { switch (ruleIndex) { case 26: return this.columnName_sempred(localContext as ColumnNameContext, predIndex); - case 79: + case 78: return this.queryStatement_sempred(localContext as QueryStatementContext, predIndex); - case 89: + case 88: return this.tableExpression_sempred(localContext as TableExpressionContext, predIndex); - case 130: + case 129: return this.booleanExpression_sempred(localContext as BooleanExpressionContext, predIndex); - case 133: + case 132: return this.valueExpression_sempred(localContext as ValueExpressionContext, predIndex); - case 134: + case 133: return this.primaryExpression_sempred(localContext as PrimaryExpressionContext, predIndex); } return true; @@ -11602,7 +11545,7 @@ export class FlinkSqlParser extends SQLParserBase { } public static readonly _serializedATN: number[] = [ - 4,1,541,2272,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, + 4,1,541,2260,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, @@ -11633,32 +11576,32 @@ export class FlinkSqlParser extends SQLParserBase { 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,1,0,5,0,378,8,0,10,0,12,0,381,9,0,1,0,1,0,1,1, - 1,1,3,1,387,8,1,1,1,3,1,390,8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2, - 1,2,1,2,1,2,1,2,3,2,404,8,2,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4, - 1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,422,8,4,1,5,1,5,3,5,426,8,5,1,6, - 1,6,1,6,1,7,1,7,1,7,1,7,3,7,435,8,7,1,7,1,7,1,7,3,7,440,8,7,1,8, - 1,8,1,8,5,8,445,8,8,10,8,12,8,448,9,8,1,9,1,9,1,10,1,10,1,10,1,10, - 1,10,1,10,3,10,458,8,10,1,11,1,11,1,11,1,11,1,11,5,11,465,8,11,10, - 11,12,11,468,9,11,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3, - 12,479,8,12,1,12,3,12,482,8,12,1,12,1,12,1,12,1,12,1,12,3,12,489, - 8,12,1,12,3,12,492,8,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,500,8, - 12,1,12,1,12,3,12,504,8,12,1,12,1,12,1,12,3,12,509,8,12,1,12,3,12, - 512,8,12,1,13,1,13,1,13,1,13,1,13,3,13,519,8,13,1,14,1,14,1,14,1, - 14,1,15,1,15,3,15,527,8,15,1,16,1,16,3,16,531,8,16,1,17,1,17,1,17, - 1,17,1,18,1,18,1,18,1,18,1,18,1,18,3,18,543,8,18,1,18,1,18,1,18, - 1,18,1,18,1,18,3,18,551,8,18,1,18,1,18,3,18,555,8,18,1,18,1,18,1, - 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1, - 18,1,18,1,18,1,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,587,8,18,1,19,3,19,590,8,19,1,19,4,19,593,8,19,11,19, - 12,19,594,1,20,1,20,3,20,599,8,20,1,21,1,21,3,21,603,8,21,1,21,1, - 21,3,21,607,8,21,1,21,1,21,1,21,1,21,1,21,5,21,614,8,21,10,21,12, - 21,617,9,21,1,21,1,21,3,21,621,8,21,1,21,1,21,3,21,625,8,21,1,21, - 1,21,3,21,629,8,21,1,21,1,21,3,21,633,8,21,1,21,3,21,636,8,21,1, - 21,1,21,3,21,640,8,21,1,22,1,22,1,22,3,22,645,8,22,1,22,1,22,1,22, - 1,22,3,22,651,8,22,1,23,1,23,1,23,3,23,656,8,23,1,24,1,24,1,24,3, - 24,661,8,24,1,24,3,24,664,8,24,1,25,1,25,3,25,668,8,25,1,26,1,26, - 3,26,672,8,26,1,27,1,27,1,27,1,27,5,27,678,8,27,10,27,12,27,681, + 7,186,1,0,5,0,376,8,0,10,0,12,0,379,9,0,1,0,1,0,1,1,1,1,3,1,385, + 8,1,1,1,3,1,388,8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2, + 1,2,3,2,402,8,2,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4, + 1,4,1,4,1,4,1,4,3,4,420,8,4,1,5,1,5,3,5,424,8,5,1,6,1,6,1,6,1,7, + 1,7,1,7,1,7,3,7,433,8,7,1,7,1,7,1,7,3,7,438,8,7,1,8,1,8,1,8,5,8, + 443,8,8,10,8,12,8,446,9,8,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,10, + 3,10,456,8,10,1,11,1,11,1,11,1,11,1,11,5,11,463,8,11,10,11,12,11, + 466,9,11,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,477,8, + 12,1,12,3,12,480,8,12,1,12,1,12,1,12,1,12,1,12,3,12,487,8,12,1,12, + 3,12,490,8,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,498,8,12,1,12,1, + 12,3,12,502,8,12,1,12,1,12,1,12,3,12,507,8,12,1,12,3,12,510,8,12, + 1,13,1,13,1,13,1,13,1,13,3,13,517,8,13,1,14,1,14,1,14,1,14,1,15, + 1,15,3,15,525,8,15,1,16,1,16,3,16,529,8,16,1,17,1,17,1,17,1,17,1, + 18,1,18,1,18,1,18,1,18,1,18,3,18,541,8,18,1,18,1,18,1,18,1,18,1, + 18,1,18,3,18,549,8,18,1,18,1,18,3,18,553,8,18,1,18,1,18,1,18,1,18, + 1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18, + 1,18,1,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,585,8,18,1,19,3,19,588,8,19,1,19,4,19,591,8,19,11,19,12,19, + 592,1,20,1,20,3,20,597,8,20,1,21,1,21,3,21,601,8,21,1,21,1,21,3, + 21,605,8,21,1,21,1,21,1,21,1,21,1,21,5,21,612,8,21,10,21,12,21,615, + 9,21,1,21,1,21,3,21,619,8,21,1,21,1,21,3,21,623,8,21,1,21,1,21,3, + 21,627,8,21,1,21,1,21,1,21,3,21,632,8,21,1,21,3,21,635,8,21,1,21, + 1,21,3,21,639,8,21,1,22,1,22,1,22,3,22,644,8,22,1,22,1,22,1,22,1, + 22,3,22,650,8,22,1,23,1,23,1,23,3,23,655,8,23,1,24,1,24,1,24,3,24, + 660,8,24,1,24,1,24,3,24,664,8,24,1,25,1,25,3,25,668,8,25,1,26,1, + 26,3,26,672,8,26,1,27,1,27,1,27,1,27,5,27,678,8,27,10,27,12,27,681, 9,27,1,27,1,27,1,28,1,28,1,28,3,28,688,8,28,1,28,1,28,3,28,692,8, 28,1,28,1,28,3,28,696,8,28,1,28,1,28,3,28,700,8,28,1,28,1,28,3,28, 704,8,28,1,28,1,28,3,28,708,8,28,1,28,1,28,3,28,712,8,28,1,28,1, @@ -11668,904 +11611,898 @@ export class FlinkSqlParser extends SQLParserBase { 1,33,1,33,1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,34,1,34,1,34,5,34, 762,8,34,10,34,12,34,765,9,34,1,34,1,34,1,35,1,35,3,35,771,8,35, 1,35,1,35,1,35,1,35,3,35,777,8,35,1,35,3,35,780,8,35,1,35,3,35,783, - 8,35,1,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37,3,37,793,8,37,1,37, - 3,37,796,8,37,1,38,1,38,1,39,1,39,1,39,1,39,3,39,804,8,39,1,40,1, - 40,1,41,1,41,1,41,1,41,1,41,1,41,1,42,1,42,3,42,816,8,42,1,42,1, - 42,1,42,1,42,1,42,1,42,1,43,1,43,1,44,1,44,1,44,1,44,1,45,1,45,1, - 45,1,45,1,46,1,46,1,46,1,46,5,46,838,8,46,10,46,12,46,841,9,46,1, - 46,1,46,1,47,1,47,1,47,1,47,1,47,5,47,850,8,47,10,47,12,47,853,9, - 47,1,47,1,47,3,47,857,8,47,1,48,1,48,3,48,861,8,48,1,49,1,49,1,49, - 1,49,5,49,867,8,49,10,49,12,49,870,9,49,1,49,3,49,873,8,49,1,50, - 1,50,1,50,1,50,3,50,879,8,50,1,51,1,51,1,51,1,51,1,51,1,52,1,52, - 1,52,3,52,889,8,52,1,52,1,52,3,52,893,8,52,1,52,1,52,1,53,1,53,3, - 53,899,8,53,1,53,1,53,3,53,903,8,53,1,53,1,53,3,53,907,8,53,1,53, - 3,53,910,8,53,1,53,1,53,1,53,1,54,1,54,1,54,1,54,3,54,919,8,54,1, - 54,1,54,3,54,923,8,54,1,54,1,54,1,54,1,54,1,54,3,54,930,8,54,1,54, - 3,54,933,8,54,1,55,1,55,1,55,1,55,1,55,1,55,5,55,941,8,55,10,55, - 12,55,944,9,55,1,56,1,56,1,57,1,57,1,57,3,57,951,8,57,1,57,1,57, - 1,57,1,57,1,57,1,57,3,57,959,8,57,1,58,1,58,3,58,963,8,58,1,58,1, - 58,1,58,1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60,978, - 8,60,1,61,1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,63,1,63,1,63,1,64, - 1,64,1,64,1,64,1,64,1,64,3,64,997,8,64,1,65,1,65,1,65,1,65,1,65, - 1,66,1,66,1,66,1,66,3,66,1008,8,66,1,66,1,66,3,66,1012,8,66,1,66, - 1,66,1,66,1,66,1,66,3,66,1019,8,66,1,67,1,67,1,67,3,67,1024,8,67, - 1,67,1,67,1,68,1,68,3,68,1030,8,68,1,68,1,68,3,68,1034,8,68,1,68, - 1,68,1,69,1,69,1,69,3,69,1041,8,69,1,69,1,69,3,69,1045,8,69,1,70, - 1,70,3,70,1049,8,70,1,70,1,70,3,70,1053,8,70,1,70,1,70,1,71,1,71, - 1,71,1,71,3,71,1061,8,71,1,71,1,71,3,71,1065,8,71,1,71,1,71,1,72, - 3,72,1070,8,72,1,72,1,72,1,72,1,72,3,72,1076,8,72,1,73,1,73,1,73, - 1,73,3,73,1082,8,73,1,73,3,73,1085,8,73,1,73,1,73,3,73,1089,8,73, - 1,74,1,74,1,74,1,75,1,75,1,75,1,75,5,75,1098,8,75,10,75,12,75,1101, - 9,75,1,76,1,76,1,76,1,76,5,76,1107,8,76,10,76,12,76,1110,9,76,1, - 76,1,76,1,77,1,77,1,77,1,77,1,77,1,77,1,77,4,77,1121,8,77,11,77, - 12,77,1122,1,77,1,77,1,78,1,78,1,78,1,78,1,78,1,78,4,78,1133,8,78, - 11,78,12,78,1134,1,78,1,78,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1, - 79,1,79,1,79,1,79,3,79,1150,8,79,1,79,3,79,1153,8,79,1,79,1,79,3, - 79,1157,8,79,1,79,3,79,1160,8,79,3,79,1162,8,79,1,79,1,79,1,79,3, - 79,1167,8,79,1,79,1,79,3,79,1171,8,79,1,79,3,79,1174,8,79,5,79,1176, - 8,79,10,79,12,79,1179,9,79,1,80,1,80,1,80,1,80,5,80,1185,8,80,10, - 80,12,80,1188,9,80,1,81,1,81,1,81,1,81,5,81,1194,8,81,10,81,12,81, - 1197,9,81,1,82,1,82,1,82,1,82,1,82,5,82,1204,8,82,10,82,12,82,1207, - 9,82,1,82,1,82,3,82,1211,8,82,1,82,1,82,1,82,1,82,1,82,1,83,1,83, - 1,84,1,84,3,84,1222,8,84,1,84,3,84,1225,8,84,1,84,3,84,1228,8,84, - 1,84,3,84,1231,8,84,1,84,3,84,1234,8,84,1,84,1,84,1,84,1,84,3,84, - 1240,8,84,1,85,1,85,3,85,1244,8,85,1,85,1,85,1,85,1,85,5,85,1250, - 8,85,10,85,12,85,1253,9,85,3,85,1255,8,85,1,86,1,86,1,86,3,86,1260, - 8,86,1,86,3,86,1263,8,86,1,86,1,86,3,86,1267,8,86,1,86,3,86,1270, - 8,86,3,86,1272,8,86,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87, - 1,87,1,87,1,87,3,87,1286,8,87,1,88,1,88,1,88,1,89,1,89,1,89,1,89, - 5,89,1295,8,89,10,89,12,89,1298,9,89,1,89,1,89,3,89,1302,8,89,1, - 89,1,89,1,89,1,89,1,89,1,89,3,89,1310,8,89,1,89,3,89,1313,8,89,1, - 89,3,89,1316,8,89,1,89,1,89,1,89,3,89,1321,8,89,5,89,1323,8,89,10, - 89,12,89,1326,9,89,1,90,1,90,3,90,1330,8,90,1,91,3,91,1333,8,91, - 1,91,1,91,3,91,1337,8,91,1,91,3,91,1340,8,91,1,91,3,91,1343,8,91, - 1,91,1,91,3,91,1347,8,91,1,91,3,91,1350,8,91,1,91,3,91,1353,8,91, - 1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,5,91,1363,8,91,10,91,12, - 91,1366,9,91,1,91,1,91,1,91,1,91,3,91,1372,8,91,1,91,1,91,1,91,1, - 91,1,91,1,91,1,91,1,91,1,91,3,91,1383,8,91,1,92,1,92,1,92,1,92,1, - 92,1,92,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,96,5,96,1408,8,96,10,96,12,96,1411,9,96, - 1,96,1,96,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,98,1,98,1,98,1,98,1,98,3,98,1432,8,98,1,99,1,99,1,100,1,100, - 1,100,1,100,1,100,1,101,1,101,1,101,1,101,3,101,1445,8,101,1,102, - 1,102,1,102,1,103,1,103,1,103,1,103,1,103,5,103,1455,8,103,10,103, - 12,103,1458,9,103,1,104,1,104,1,104,1,104,1,104,1,104,1,104,1,104, - 5,104,1468,8,104,10,104,12,104,1471,9,104,1,104,1,104,1,104,1,104, - 1,104,1,104,1,104,5,104,1480,8,104,10,104,12,104,1483,9,104,1,104, - 1,104,1,104,1,104,1,104,1,104,1,104,5,104,1492,8,104,10,104,12,104, - 1495,9,104,1,104,1,104,1,104,3,104,1500,8,104,1,105,1,105,1,105, - 1,106,1,106,1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,108,1,108, - 1,109,1,109,1,110,1,110,1,110,1,111,1,111,1,111,1,111,5,111,1525, - 8,111,10,111,12,111,1528,9,111,1,112,1,112,1,112,1,112,1,113,3,113, - 1535,8,113,1,113,1,113,3,113,1539,8,113,1,113,3,113,1542,8,113,1, - 113,3,113,1545,8,113,1,113,1,113,1,114,1,114,1,114,3,114,1552,8, - 114,1,114,3,114,1555,8,114,1,114,3,114,1558,8,114,1,114,3,114,1561, - 8,114,1,114,3,114,1564,8,114,1,114,3,114,1567,8,114,1,114,1,114, - 1,114,3,114,1572,8,114,1,114,3,114,1575,8,114,1,115,1,115,1,115, - 1,115,1,115,5,115,1582,8,115,10,115,12,115,1585,9,115,1,116,1,116, - 3,116,1589,8,116,1,116,1,116,3,116,1593,8,116,1,117,1,117,1,117, - 3,117,1598,8,117,1,118,1,118,1,118,1,118,1,118,5,118,1605,8,118, - 10,118,12,118,1608,9,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119, - 1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,3,119,1626, - 8,119,1,120,1,120,1,120,1,120,5,120,1632,8,120,10,120,12,120,1635, - 9,120,1,121,1,121,1,121,4,121,1640,8,121,11,121,12,121,1641,1,121, - 1,121,3,121,1646,8,121,1,122,1,122,3,122,1650,8,122,1,123,1,123, - 1,123,1,123,1,123,1,123,1,123,1,123,3,123,1660,8,123,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 3,124,1686,8,124,1,125,1,125,1,125,1,125,5,125,1692,8,125,10,125, - 12,125,1695,9,125,1,126,1,126,1,126,1,126,1,126,1,126,1,126,1,126, - 1,126,3,126,1706,8,126,1,127,1,127,1,127,1,127,1,127,1,128,1,128, - 1,128,1,129,1,129,1,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130, - 1,130,1,130,3,130,1728,8,130,3,130,1730,8,130,1,130,1,130,1,130, - 1,130,1,130,1,130,1,130,1,130,1,130,3,130,1741,8,130,1,130,5,130, - 1744,8,130,10,130,12,130,1747,9,130,1,131,3,131,1750,8,131,1,131, - 1,131,3,131,1754,8,131,1,131,1,131,1,131,1,131,1,131,3,131,1761, - 8,131,1,131,1,131,1,131,1,131,1,131,5,131,1768,8,131,10,131,12,131, - 1771,9,131,1,131,1,131,1,131,3,131,1776,8,131,1,131,1,131,1,131, - 1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,3,131,1789,8,131, - 1,131,1,131,1,131,1,131,1,131,3,131,1796,8,131,1,131,1,131,1,131, - 3,131,1801,8,131,1,131,1,131,1,131,1,131,3,131,1807,8,131,1,131, - 1,131,1,131,1,131,1,131,3,131,1814,8,131,3,131,1816,8,131,1,132, - 3,132,1819,8,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132, - 5,132,1829,8,132,10,132,12,132,1832,9,132,1,132,1,132,3,132,1836, - 8,132,1,132,3,132,1839,8,132,1,132,1,132,1,132,1,132,3,132,1845, - 8,132,3,132,1847,8,132,1,133,1,133,1,133,1,133,3,133,1853,8,133, + 8,35,1,36,1,36,1,36,1,36,1,36,3,36,790,8,36,1,36,3,36,793,8,36,1, + 37,1,37,1,38,1,38,1,38,1,38,1,38,3,38,802,8,38,1,39,1,39,1,40,1, + 40,1,40,1,40,1,40,1,40,1,41,1,41,3,41,814,8,41,1,41,1,41,1,41,1, + 41,1,41,1,41,1,42,1,42,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,1, + 45,1,45,1,45,1,45,5,45,836,8,45,10,45,12,45,839,9,45,1,45,1,45,1, + 46,1,46,1,46,1,46,1,46,5,46,848,8,46,10,46,12,46,851,9,46,1,46,1, + 46,3,46,855,8,46,1,47,1,47,3,47,859,8,47,1,48,1,48,1,48,1,48,5,48, + 865,8,48,10,48,12,48,868,9,48,1,48,3,48,871,8,48,1,49,1,49,1,49, + 1,49,3,49,877,8,49,1,50,1,50,1,50,1,50,1,50,1,51,1,51,1,51,3,51, + 887,8,51,1,51,1,51,1,51,3,51,892,8,51,1,51,1,51,1,52,1,52,3,52,898, + 8,52,1,52,1,52,3,52,902,8,52,1,52,1,52,3,52,906,8,52,1,52,1,52,3, + 52,910,8,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,3,53,919,8,53,1,53, + 1,53,3,53,923,8,53,1,53,1,53,1,53,1,53,1,53,3,53,930,8,53,1,53,3, + 53,933,8,53,1,54,1,54,1,54,1,54,1,54,1,54,5,54,941,8,54,10,54,12, + 54,944,9,54,1,55,1,55,1,56,1,56,1,56,3,56,951,8,56,1,56,1,56,1,56, + 1,56,1,56,1,56,3,56,959,8,56,1,57,1,57,3,57,963,8,57,1,57,1,57,1, + 57,1,58,1,58,1,58,1,59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,978,8, + 59,1,60,1,60,1,60,1,60,1,61,1,61,1,61,1,61,1,62,1,62,1,62,1,63,1, + 63,1,63,1,63,1,63,1,63,3,63,997,8,63,1,64,1,64,1,64,1,64,1,64,1, + 65,1,65,1,65,1,65,3,65,1008,8,65,1,65,1,65,3,65,1012,8,65,1,65,1, + 65,1,65,1,65,1,65,3,65,1019,8,65,1,66,1,66,1,66,3,66,1024,8,66,1, + 66,1,66,1,67,1,67,3,67,1030,8,67,1,67,1,67,3,67,1034,8,67,1,67,1, + 67,1,68,1,68,1,68,3,68,1041,8,68,1,68,1,68,3,68,1045,8,68,1,69,1, + 69,3,69,1049,8,69,1,69,1,69,3,69,1053,8,69,1,69,1,69,1,70,1,70,1, + 70,1,70,3,70,1061,8,70,1,70,1,70,3,70,1065,8,70,1,70,1,70,1,71,3, + 71,1070,8,71,1,71,1,71,1,71,1,71,3,71,1076,8,71,1,72,1,72,1,72,1, + 72,3,72,1082,8,72,1,72,3,72,1085,8,72,1,72,1,72,3,72,1089,8,72,1, + 73,1,73,1,73,1,74,1,74,1,74,1,74,5,74,1098,8,74,10,74,12,74,1101, + 9,74,1,75,1,75,1,75,1,75,5,75,1107,8,75,10,75,12,75,1110,9,75,1, + 75,1,75,1,76,1,76,1,76,1,76,1,76,1,76,1,76,4,76,1121,8,76,11,76, + 12,76,1122,1,76,1,76,1,77,1,77,1,77,1,77,1,77,1,77,4,77,1133,8,77, + 11,77,12,77,1134,1,77,1,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1, + 78,1,78,1,78,1,78,3,78,1150,8,78,1,78,3,78,1153,8,78,1,78,1,78,3, + 78,1157,8,78,1,78,3,78,1160,8,78,3,78,1162,8,78,1,78,1,78,1,78,3, + 78,1167,8,78,1,78,1,78,3,78,1171,8,78,1,78,3,78,1174,8,78,5,78,1176, + 8,78,10,78,12,78,1179,9,78,1,79,1,79,1,79,1,79,5,79,1185,8,79,10, + 79,12,79,1188,9,79,1,80,1,80,1,80,1,80,5,80,1194,8,80,10,80,12,80, + 1197,9,80,1,81,1,81,1,81,1,81,1,81,5,81,1204,8,81,10,81,12,81,1207, + 9,81,1,81,1,81,3,81,1211,8,81,1,81,1,81,1,81,1,81,1,81,1,82,1,82, + 1,83,1,83,3,83,1222,8,83,1,83,3,83,1225,8,83,1,83,3,83,1228,8,83, + 1,83,3,83,1231,8,83,1,83,3,83,1234,8,83,1,83,1,83,1,83,1,83,3,83, + 1240,8,83,1,84,1,84,3,84,1244,8,84,1,84,1,84,1,84,1,84,5,84,1250, + 8,84,10,84,12,84,1253,9,84,3,84,1255,8,84,1,85,1,85,1,85,3,85,1260, + 8,85,1,85,3,85,1263,8,85,1,85,1,85,3,85,1267,8,85,1,85,3,85,1270, + 8,85,3,85,1272,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, + 1,86,1,86,1,86,3,86,1286,8,86,1,87,1,87,1,87,1,88,1,88,1,88,1,88, + 5,88,1295,8,88,10,88,12,88,1298,9,88,1,88,1,88,3,88,1302,8,88,1, + 88,1,88,1,88,1,88,1,88,1,88,3,88,1310,8,88,1,88,3,88,1313,8,88,1, + 88,3,88,1316,8,88,1,88,1,88,1,88,3,88,1321,8,88,5,88,1323,8,88,10, + 88,12,88,1326,9,88,1,89,1,89,3,89,1330,8,89,1,90,3,90,1333,8,90, + 1,90,1,90,3,90,1337,8,90,1,90,1,90,3,90,1341,8,90,1,90,1,90,1,90, + 1,90,1,90,1,90,1,90,1,90,5,90,1351,8,90,10,90,12,90,1354,9,90,1, + 90,1,90,1,90,1,90,3,90,1360,8,90,1,90,1,90,1,90,1,90,1,90,1,90,1, + 90,1,90,1,90,3,90,1371,8,90,1,91,1,91,1,91,1,91,1,91,1,91,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,95,1,95,1, + 95,1,95,1,95,5,95,1396,8,95,10,95,12,95,1399,9,95,1,95,1,95,1,96, + 1,96,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97, + 1,97,1,97,1,97,3,97,1420,8,97,1,98,1,98,1,99,1,99,1,99,1,99,1,99, + 1,100,1,100,1,100,1,100,3,100,1433,8,100,1,101,1,101,1,101,1,102, + 1,102,1,102,1,102,1,102,5,102,1443,8,102,10,102,12,102,1446,9,102, + 1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103,5,103,1456,8,103, + 10,103,12,103,1459,9,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103, + 5,103,1468,8,103,10,103,12,103,1471,9,103,1,103,1,103,1,103,1,103, + 1,103,1,103,1,103,5,103,1480,8,103,10,103,12,103,1483,9,103,1,103, + 1,103,1,103,3,103,1488,8,103,1,104,1,104,1,104,1,105,1,105,1,106, + 1,106,1,106,1,106,1,106,1,106,1,106,1,107,1,107,1,108,1,108,1,109, + 1,109,1,109,1,110,1,110,1,110,1,110,5,110,1513,8,110,10,110,12,110, + 1516,9,110,1,111,1,111,1,111,1,111,1,112,3,112,1523,8,112,1,112, + 1,112,3,112,1527,8,112,1,112,3,112,1530,8,112,1,112,3,112,1533,8, + 112,1,112,1,112,1,113,1,113,1,113,3,113,1540,8,113,1,113,3,113,1543, + 8,113,1,113,3,113,1546,8,113,1,113,3,113,1549,8,113,1,113,3,113, + 1552,8,113,1,113,3,113,1555,8,113,1,113,1,113,1,113,3,113,1560,8, + 113,1,113,3,113,1563,8,113,1,114,1,114,1,114,1,114,1,114,5,114,1570, + 8,114,10,114,12,114,1573,9,114,1,115,1,115,3,115,1577,8,115,1,115, + 1,115,3,115,1581,8,115,1,116,1,116,1,116,3,116,1586,8,116,1,117, + 1,117,1,117,1,117,1,117,5,117,1593,8,117,10,117,12,117,1596,9,117, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 1,118,1,118,1,118,1,118,1,118,3,118,1614,8,118,1,119,1,119,1,119, + 1,119,5,119,1620,8,119,10,119,12,119,1623,9,119,1,120,1,120,1,120, + 4,120,1628,8,120,11,120,12,120,1629,1,120,1,120,3,120,1634,8,120, + 1,121,1,121,3,121,1638,8,121,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,3,122,1648,8,122,1,123,1,123,1,123,1,123,1,123,1,123, + 1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123, + 1,123,1,123,1,123,1,123,1,123,1,123,1,123,3,123,1674,8,123,1,124, + 1,124,1,124,1,124,5,124,1680,8,124,10,124,12,124,1683,9,124,1,125, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,3,125,1694,8,125, + 1,126,1,126,1,126,1,126,1,126,1,127,1,127,1,127,1,128,1,128,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,3,129,1716, + 8,129,3,129,1718,8,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,1,129,3,129,1729,8,129,1,129,5,129,1732,8,129,10,129,12,129, + 1735,9,129,1,130,3,130,1738,8,130,1,130,1,130,3,130,1742,8,130,1, + 130,1,130,1,130,1,130,1,130,3,130,1749,8,130,1,130,1,130,1,130,1, + 130,1,130,5,130,1756,8,130,10,130,12,130,1759,9,130,1,130,1,130, + 1,130,3,130,1764,8,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130, + 1,130,1,130,1,130,1,130,3,130,1777,8,130,1,130,1,130,1,130,1,130, + 1,130,3,130,1784,8,130,1,130,1,130,1,130,3,130,1789,8,130,1,130, + 1,130,1,130,1,130,3,130,1795,8,130,1,130,1,130,1,130,1,130,1,130, + 3,130,1802,8,130,3,130,1804,8,130,1,131,3,131,1807,8,131,1,131,1, + 131,1,131,1,131,1,131,1,131,1,131,1,131,5,131,1817,8,131,10,131, + 12,131,1820,9,131,1,131,1,131,3,131,1824,8,131,1,131,3,131,1827, + 8,131,1,131,1,131,1,131,1,131,3,131,1833,8,131,3,131,1835,8,131, + 1,132,1,132,1,132,1,132,3,132,1841,8,132,1,132,1,132,1,132,1,132, + 1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132, + 1,132,1,132,1,132,1,132,5,132,1862,8,132,10,132,12,132,1865,9,132, + 1,133,1,133,1,133,4,133,1870,8,133,11,133,12,133,1871,1,133,1,133, + 3,133,1876,8,133,1,133,1,133,1,133,1,133,1,133,4,133,1883,8,133, + 11,133,12,133,1884,1,133,1,133,3,133,1889,8,133,1,133,1,133,1,133, + 1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133, + 3,133,1905,8,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,3,133, + 1914,8,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133, 1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133, - 1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,5,133,1874,8,133, - 10,133,12,133,1877,9,133,1,134,1,134,1,134,4,134,1882,8,134,11,134, - 12,134,1883,1,134,1,134,3,134,1888,8,134,1,134,1,134,1,134,1,134, - 1,134,4,134,1895,8,134,11,134,12,134,1896,1,134,1,134,3,134,1901, - 8,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134, - 1,134,1,134,1,134,1,134,3,134,1917,8,134,1,134,1,134,1,134,1,134, - 1,134,1,134,1,134,3,134,1926,8,134,1,134,1,134,1,134,1,134,1,134, - 1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134, - 1,134,1,134,1,134,1,134,1,134,1,134,3,134,1950,8,134,1,134,1,134, - 1,134,5,134,1955,8,134,10,134,12,134,1958,9,134,3,134,1960,8,134, - 1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,3,134,1971, - 8,134,1,134,1,134,1,134,1,134,1,134,5,134,1978,8,134,10,134,12,134, - 1981,9,134,1,135,1,135,1,136,1,136,3,136,1987,8,136,1,137,1,137, - 1,137,1,137,3,137,1993,8,137,1,138,1,138,1,139,1,139,1,140,1,140, - 3,140,2001,8,140,1,141,1,141,1,141,3,141,2006,8,141,1,142,1,142, - 3,142,2010,8,142,1,143,1,143,1,143,4,143,2015,8,143,11,143,12,143, - 2016,1,144,1,144,1,144,3,144,2022,8,144,1,145,1,145,1,145,1,145, - 1,145,1,146,3,146,2030,8,146,1,146,1,146,3,146,2034,8,146,1,147, - 3,147,2037,8,147,1,147,1,147,3,147,2041,8,147,1,148,1,148,1,148, - 1,149,1,149,4,149,2048,8,149,11,149,12,149,2049,1,149,3,149,2053, - 8,149,1,150,1,150,1,150,1,150,1,151,1,151,1,151,5,151,2062,8,151, - 10,151,12,151,2065,9,151,1,152,1,152,1,152,3,152,2070,8,152,1,153, - 1,153,1,154,1,154,1,155,1,155,1,155,1,155,1,155,1,156,1,156,1,157, - 1,157,1,158,1,158,1,158,3,158,2088,8,158,1,159,1,159,1,159,3,159, - 2093,8,159,1,160,1,160,1,160,3,160,2098,8,160,1,160,1,160,1,160, - 1,160,1,160,3,160,2105,8,160,3,160,2107,8,160,1,161,1,161,1,161, - 3,161,2112,8,161,1,161,1,161,1,161,1,161,1,161,3,161,2119,8,161, - 3,161,2121,8,161,1,162,1,162,1,162,3,162,2126,8,162,1,162,1,162, - 1,162,1,162,1,162,3,162,2133,8,162,3,162,2135,8,162,1,163,1,163, - 1,163,3,163,2140,8,163,1,163,1,163,1,163,1,163,1,163,3,163,2147, - 8,163,3,163,2149,8,163,1,164,1,164,1,164,5,164,2154,8,164,10,164, - 12,164,2157,9,164,1,165,1,165,1,165,1,166,1,166,1,166,1,166,1,167, - 1,167,1,167,1,168,1,168,1,168,1,168,5,168,2173,8,168,10,168,12,168, - 2176,9,168,1,168,1,168,1,169,1,169,3,169,2182,8,169,1,169,3,169, - 2185,8,169,1,170,1,170,1,170,3,170,2190,8,170,1,171,1,171,1,171, - 1,171,3,171,2196,8,171,1,172,1,172,1,172,1,172,1,172,1,172,3,172, - 2204,8,172,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173, - 1,173,1,173,1,173,1,173,1,173,3,173,2220,8,173,1,174,1,174,1,174, - 1,174,1,174,1,174,1,174,3,174,2229,8,174,1,175,1,175,1,176,1,176, - 1,177,1,177,1,177,1,177,3,177,2239,8,177,1,177,1,177,1,177,1,177, - 1,177,3,177,2246,8,177,1,177,3,177,2249,8,177,1,178,1,178,1,178, - 1,179,1,179,1,180,1,180,1,181,1,181,1,182,1,182,1,183,1,183,1,184, - 1,184,1,185,1,185,1,186,1,186,1,187,1,187,1,187,1,2155,5,158,178, - 260,266,268,188,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,0,45,2,0,109,109,450,450,3,0,45,45,128,128,188,188,4,0,42,42, - 90,90,422,422,464,464,2,0,441,441,447,447,2,0,151,151,170,170,2, - 0,437,437,489,489,2,0,482,485,487,487,3,0,32,32,91,91,244,244,11, - 0,28,29,35,35,46,46,92,92,178,179,344,344,360,360,378,378,381,381, - 387,387,416,417,2,0,433,433,435,435,4,0,101,102,115,115,144,144, - 246,246,2,0,13,13,231,231,2,0,455,455,462,462,3,0,5,5,270,270,444, - 444,3,0,266,266,455,455,462,462,3,0,425,425,458,458,477,477,3,0, - 330,330,465,465,481,481,2,0,440,440,490,490,2,0,183,183,265,265, - 3,0,130,130,180,180,402,402,4,0,152,152,174,174,201,201,317,317, - 3,0,445,445,459,459,499,499,4,0,250,250,446,446,494,496,498,498, - 2,0,74,74,320,320,3,0,459,459,492,492,499,499,2,0,439,439,450,450, - 2,0,457,457,467,467,4,0,140,140,244,244,397,397,404,404,2,0,19,19, - 369,369,2,0,5,5,11,11,2,0,509,509,529,530,4,0,452,452,527,527,531, - 531,534,534,2,0,529,530,532,532,1,0,529,530,1,0,538,539,2,0,538, - 538,541,541,4,0,452,452,527,527,529,531,533,534,3,0,241,241,508, - 509,529,530,2,0,140,140,397,397,2,0,5,5,113,113,10,0,97,97,165,165, - 222,222,229,229,334,334,436,436,470,470,472,472,488,488,502,502, - 15,0,97,97,165,165,222,222,229,229,334,334,427,427,436,436,442,442, - 448,449,454,454,460,460,470,475,488,488,491,491,502,503,11,0,5,5, - 13,13,33,33,78,78,84,85,113,113,200,200,207,208,389,389,413,413, - 527,527,55,0,4,4,13,13,23,23,38,38,41,41,43,44,54,54,56,56,69,69, - 75,75,78,78,84,85,91,91,98,99,107,107,119,119,134,134,139,139,143, - 143,145,145,160,160,165,165,167,167,194,194,197,197,199,199,201, - 201,205,205,207,209,214,214,220,220,222,223,229,229,243,243,245, - 245,264,264,276,276,281,281,283,283,293,293,317,317,321,323,334, - 334,357,358,364,364,367,367,378,380,395,395,398,399,408,408,419, - 420,436,436,469,469,488,488,502,502,1,0,437,504,2475,0,379,1,0,0, - 0,2,389,1,0,0,0,4,403,1,0,0,0,6,405,1,0,0,0,8,421,1,0,0,0,10,425, - 1,0,0,0,12,427,1,0,0,0,14,430,1,0,0,0,16,441,1,0,0,0,18,449,1,0, - 0,0,20,457,1,0,0,0,22,459,1,0,0,0,24,511,1,0,0,0,26,513,1,0,0,0, - 28,520,1,0,0,0,30,524,1,0,0,0,32,528,1,0,0,0,34,532,1,0,0,0,36,586, - 1,0,0,0,38,592,1,0,0,0,40,598,1,0,0,0,42,600,1,0,0,0,44,641,1,0, - 0,0,46,655,1,0,0,0,48,657,1,0,0,0,50,667,1,0,0,0,52,671,1,0,0,0, - 54,673,1,0,0,0,56,721,1,0,0,0,58,723,1,0,0,0,60,727,1,0,0,0,62,735, - 1,0,0,0,64,743,1,0,0,0,66,747,1,0,0,0,68,754,1,0,0,0,70,782,1,0, - 0,0,72,784,1,0,0,0,74,787,1,0,0,0,76,797,1,0,0,0,78,799,1,0,0,0, - 80,805,1,0,0,0,82,807,1,0,0,0,84,815,1,0,0,0,86,823,1,0,0,0,88,825, - 1,0,0,0,90,829,1,0,0,0,92,833,1,0,0,0,94,856,1,0,0,0,96,860,1,0, - 0,0,98,862,1,0,0,0,100,878,1,0,0,0,102,880,1,0,0,0,104,885,1,0,0, - 0,106,896,1,0,0,0,108,914,1,0,0,0,110,934,1,0,0,0,112,945,1,0,0, - 0,114,947,1,0,0,0,116,960,1,0,0,0,118,967,1,0,0,0,120,970,1,0,0, - 0,122,979,1,0,0,0,124,983,1,0,0,0,126,987,1,0,0,0,128,990,1,0,0, - 0,130,998,1,0,0,0,132,1003,1,0,0,0,134,1020,1,0,0,0,136,1027,1,0, - 0,0,138,1037,1,0,0,0,140,1046,1,0,0,0,142,1056,1,0,0,0,144,1075, - 1,0,0,0,146,1077,1,0,0,0,148,1090,1,0,0,0,150,1093,1,0,0,0,152,1102, - 1,0,0,0,154,1113,1,0,0,0,156,1126,1,0,0,0,158,1161,1,0,0,0,160,1180, - 1,0,0,0,162,1189,1,0,0,0,164,1198,1,0,0,0,166,1217,1,0,0,0,168,1239, - 1,0,0,0,170,1241,1,0,0,0,172,1271,1,0,0,0,174,1285,1,0,0,0,176,1287, - 1,0,0,0,178,1301,1,0,0,0,180,1327,1,0,0,0,182,1382,1,0,0,0,184,1384, - 1,0,0,0,186,1390,1,0,0,0,188,1392,1,0,0,0,190,1397,1,0,0,0,192,1402, - 1,0,0,0,194,1414,1,0,0,0,196,1431,1,0,0,0,198,1433,1,0,0,0,200,1435, - 1,0,0,0,202,1444,1,0,0,0,204,1446,1,0,0,0,206,1449,1,0,0,0,208,1499, - 1,0,0,0,210,1501,1,0,0,0,212,1504,1,0,0,0,214,1506,1,0,0,0,216,1513, - 1,0,0,0,218,1515,1,0,0,0,220,1517,1,0,0,0,222,1520,1,0,0,0,224,1529, - 1,0,0,0,226,1534,1,0,0,0,228,1548,1,0,0,0,230,1576,1,0,0,0,232,1586, - 1,0,0,0,234,1594,1,0,0,0,236,1599,1,0,0,0,238,1625,1,0,0,0,240,1627, - 1,0,0,0,242,1636,1,0,0,0,244,1647,1,0,0,0,246,1659,1,0,0,0,248,1685, - 1,0,0,0,250,1687,1,0,0,0,252,1705,1,0,0,0,254,1707,1,0,0,0,256,1712, - 1,0,0,0,258,1715,1,0,0,0,260,1729,1,0,0,0,262,1815,1,0,0,0,264,1846, - 1,0,0,0,266,1852,1,0,0,0,268,1970,1,0,0,0,270,1982,1,0,0,0,272,1986, - 1,0,0,0,274,1992,1,0,0,0,276,1994,1,0,0,0,278,1996,1,0,0,0,280,2000, - 1,0,0,0,282,2002,1,0,0,0,284,2007,1,0,0,0,286,2014,1,0,0,0,288,2018, - 1,0,0,0,290,2023,1,0,0,0,292,2033,1,0,0,0,294,2036,1,0,0,0,296,2042, - 1,0,0,0,298,2052,1,0,0,0,300,2054,1,0,0,0,302,2058,1,0,0,0,304,2069, - 1,0,0,0,306,2071,1,0,0,0,308,2073,1,0,0,0,310,2075,1,0,0,0,312,2080, - 1,0,0,0,314,2082,1,0,0,0,316,2084,1,0,0,0,318,2089,1,0,0,0,320,2106, - 1,0,0,0,322,2120,1,0,0,0,324,2134,1,0,0,0,326,2148,1,0,0,0,328,2150, - 1,0,0,0,330,2158,1,0,0,0,332,2161,1,0,0,0,334,2165,1,0,0,0,336,2168, - 1,0,0,0,338,2179,1,0,0,0,340,2189,1,0,0,0,342,2195,1,0,0,0,344,2203, - 1,0,0,0,346,2219,1,0,0,0,348,2228,1,0,0,0,350,2230,1,0,0,0,352,2232, - 1,0,0,0,354,2248,1,0,0,0,356,2250,1,0,0,0,358,2253,1,0,0,0,360,2255, - 1,0,0,0,362,2257,1,0,0,0,364,2259,1,0,0,0,366,2261,1,0,0,0,368,2263, - 1,0,0,0,370,2265,1,0,0,0,372,2267,1,0,0,0,374,2269,1,0,0,0,376,378, - 3,2,1,0,377,376,1,0,0,0,378,381,1,0,0,0,379,377,1,0,0,0,379,380, - 1,0,0,0,380,382,1,0,0,0,381,379,1,0,0,0,382,383,5,0,0,1,383,1,1, - 0,0,0,384,386,3,4,2,0,385,387,5,521,0,0,386,385,1,0,0,0,386,387, - 1,0,0,0,387,390,1,0,0,0,388,390,3,6,3,0,389,384,1,0,0,0,389,388, - 1,0,0,0,390,3,1,0,0,0,391,404,3,8,4,0,392,404,3,10,5,0,393,404,3, - 12,6,0,394,404,3,14,7,0,395,404,3,20,10,0,396,404,3,24,12,0,397, - 404,3,26,13,0,398,404,3,28,14,0,399,404,3,30,15,0,400,404,3,32,16, - 0,401,404,3,34,17,0,402,404,3,36,18,0,403,391,1,0,0,0,403,392,1, - 0,0,0,403,393,1,0,0,0,403,394,1,0,0,0,403,395,1,0,0,0,403,396,1, - 0,0,0,403,397,1,0,0,0,403,398,1,0,0,0,403,399,1,0,0,0,403,400,1, - 0,0,0,403,401,1,0,0,0,403,402,1,0,0,0,404,5,1,0,0,0,405,406,5,521, - 0,0,406,7,1,0,0,0,407,422,3,40,20,0,408,422,3,104,52,0,409,422,3, - 106,53,0,410,422,3,108,54,0,411,422,3,102,51,0,412,422,3,114,57, - 0,413,422,3,128,64,0,414,422,3,130,65,0,415,422,3,132,66,0,416,422, - 3,134,67,0,417,422,3,136,68,0,418,422,3,138,69,0,419,422,3,140,70, - 0,420,422,3,142,71,0,421,407,1,0,0,0,421,408,1,0,0,0,421,409,1,0, - 0,0,421,410,1,0,0,0,421,411,1,0,0,0,421,412,1,0,0,0,421,413,1,0, - 0,0,421,414,1,0,0,0,421,415,1,0,0,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,9,1,0,0, - 0,423,426,3,158,79,0,424,426,3,144,72,0,425,423,1,0,0,0,425,424, - 1,0,0,0,426,11,1,0,0,0,427,428,7,0,0,0,428,429,3,322,161,0,429,13, - 1,0,0,0,430,434,5,135,0,0,431,435,3,16,8,0,432,433,5,479,0,0,433, - 435,5,146,0,0,434,431,1,0,0,0,434,432,1,0,0,0,434,435,1,0,0,0,435, - 439,1,0,0,0,436,440,3,10,5,0,437,440,3,146,73,0,438,440,3,156,78, - 0,439,436,1,0,0,0,439,437,1,0,0,0,439,438,1,0,0,0,440,15,1,0,0,0, - 441,446,3,18,9,0,442,443,5,520,0,0,443,445,3,18,9,0,444,442,1,0, - 0,0,445,448,1,0,0,0,446,444,1,0,0,0,446,447,1,0,0,0,447,17,1,0,0, - 0,448,446,1,0,0,0,449,450,7,1,0,0,450,19,1,0,0,0,451,452,5,410,0, - 0,452,453,5,441,0,0,453,458,3,312,156,0,454,455,5,410,0,0,455,458, - 3,316,158,0,456,458,3,22,11,0,457,451,1,0,0,0,457,454,1,0,0,0,457, - 456,1,0,0,0,458,21,1,0,0,0,459,460,5,410,0,0,460,461,5,227,0,0,461, - 466,3,328,164,0,462,463,5,520,0,0,463,465,3,328,164,0,464,462,1, - 0,0,0,465,468,1,0,0,0,466,464,1,0,0,0,466,467,1,0,0,0,467,23,1,0, - 0,0,468,466,1,0,0,0,469,470,5,341,0,0,470,512,7,2,0,0,471,472,5, - 341,0,0,472,473,5,76,0,0,473,512,7,3,0,0,474,475,5,341,0,0,475,478, - 5,374,0,0,476,477,7,4,0,0,477,479,3,316,158,0,478,476,1,0,0,0,478, - 479,1,0,0,0,479,481,1,0,0,0,480,482,3,264,132,0,481,480,1,0,0,0, - 481,482,1,0,0,0,482,512,1,0,0,0,483,484,5,341,0,0,484,485,5,58,0, - 0,485,488,7,4,0,0,486,489,3,324,162,0,487,489,3,322,161,0,488,486, - 1,0,0,0,488,487,1,0,0,0,489,491,1,0,0,0,490,492,3,264,132,0,491, - 490,1,0,0,0,491,492,1,0,0,0,492,512,1,0,0,0,493,494,5,341,0,0,494, - 499,5,72,0,0,495,496,5,373,0,0,496,500,3,322,161,0,497,498,5,501, - 0,0,498,500,3,324,162,0,499,495,1,0,0,0,499,497,1,0,0,0,500,512, - 1,0,0,0,501,503,5,341,0,0,502,504,5,411,0,0,503,502,1,0,0,0,503, - 504,1,0,0,0,504,505,1,0,0,0,505,512,5,154,0,0,506,508,5,341,0,0, - 507,509,5,152,0,0,508,507,1,0,0,0,508,509,1,0,0,0,509,510,1,0,0, - 0,510,512,5,227,0,0,511,469,1,0,0,0,511,471,1,0,0,0,511,474,1,0, - 0,0,511,483,1,0,0,0,511,493,1,0,0,0,511,501,1,0,0,0,511,506,1,0, - 0,0,512,25,1,0,0,0,513,514,5,468,0,0,514,515,5,226,0,0,515,518,3, - 328,164,0,516,517,5,433,0,0,517,519,3,336,168,0,518,516,1,0,0,0, - 518,519,1,0,0,0,519,27,1,0,0,0,520,521,5,500,0,0,521,522,5,226,0, - 0,522,523,3,328,164,0,523,29,1,0,0,0,524,526,5,340,0,0,525,527,3, - 338,169,0,526,525,1,0,0,0,526,527,1,0,0,0,527,31,1,0,0,0,528,530, - 5,312,0,0,529,531,3,340,170,0,530,529,1,0,0,0,530,531,1,0,0,0,531, - 33,1,0,0,0,532,533,7,5,0,0,533,534,5,463,0,0,534,535,3,112,56,0, - 535,35,1,0,0,0,536,537,5,437,0,0,537,538,5,463,0,0,538,539,5,433, - 0,0,539,542,3,38,19,0,540,541,5,17,0,0,541,543,3,328,164,0,542,540, - 1,0,0,0,542,543,1,0,0,0,543,587,1,0,0,0,544,545,5,437,0,0,545,546, - 5,456,0,0,546,547,5,433,0,0,547,550,3,38,19,0,548,549,5,17,0,0,549, - 551,3,328,164,0,550,548,1,0,0,0,550,551,1,0,0,0,551,554,1,0,0,0, - 552,553,5,311,0,0,553,555,3,328,164,0,554,552,1,0,0,0,554,555,1, - 0,0,0,555,587,1,0,0,0,556,557,5,437,0,0,557,558,7,6,0,0,558,559, - 5,433,0,0,559,560,3,38,19,0,560,561,5,311,0,0,561,562,3,328,164, - 0,562,587,1,0,0,0,563,564,5,437,0,0,564,565,5,486,0,0,565,587,3, - 38,19,0,566,567,5,437,0,0,567,568,5,453,0,0,568,569,5,456,0,0,569, - 570,5,433,0,0,570,571,3,38,19,0,571,572,5,311,0,0,572,573,3,328, - 164,0,573,574,5,466,0,0,574,575,3,328,164,0,575,587,1,0,0,0,576, - 577,5,437,0,0,577,578,5,443,0,0,578,579,5,456,0,0,579,580,5,433, - 0,0,580,581,3,38,19,0,581,582,5,146,0,0,582,583,3,328,164,0,583, - 584,5,17,0,0,584,585,3,328,164,0,585,587,1,0,0,0,586,536,1,0,0,0, - 586,544,1,0,0,0,586,556,1,0,0,0,586,563,1,0,0,0,586,566,1,0,0,0, - 586,576,1,0,0,0,587,37,1,0,0,0,588,590,5,534,0,0,589,588,1,0,0,0, - 589,590,1,0,0,0,590,591,1,0,0,0,591,593,3,328,164,0,592,589,1,0, - 0,0,593,594,1,0,0,0,594,592,1,0,0,0,594,595,1,0,0,0,595,39,1,0,0, - 0,596,599,3,42,21,0,597,599,3,44,22,0,598,596,1,0,0,0,598,597,1, - 0,0,0,599,41,1,0,0,0,600,602,5,72,0,0,601,603,5,497,0,0,602,601, - 1,0,0,0,602,603,1,0,0,0,603,604,1,0,0,0,604,606,5,373,0,0,605,607, - 3,332,166,0,606,605,1,0,0,0,606,607,1,0,0,0,607,608,1,0,0,0,608, - 609,3,320,160,0,609,610,5,516,0,0,610,615,3,46,23,0,611,612,5,520, - 0,0,612,614,3,46,23,0,613,611,1,0,0,0,614,617,1,0,0,0,615,613,1, - 0,0,0,615,616,1,0,0,0,616,620,1,0,0,0,617,615,1,0,0,0,618,619,5, - 520,0,0,619,621,3,82,41,0,620,618,1,0,0,0,620,621,1,0,0,0,621,624, - 1,0,0,0,622,623,5,520,0,0,623,625,3,84,42,0,624,622,1,0,0,0,624, - 625,1,0,0,0,625,628,1,0,0,0,626,627,5,520,0,0,627,629,3,88,44,0, - 628,626,1,0,0,0,628,629,1,0,0,0,629,630,1,0,0,0,630,632,5,517,0, - 0,631,633,3,72,36,0,632,631,1,0,0,0,632,633,1,0,0,0,633,635,1,0, - 0,0,634,636,3,90,45,0,635,634,1,0,0,0,635,636,1,0,0,0,636,637,1, - 0,0,0,637,639,3,330,165,0,638,640,3,98,49,0,639,638,1,0,0,0,639, - 640,1,0,0,0,640,43,1,0,0,0,641,642,5,72,0,0,642,644,5,373,0,0,643, - 645,3,332,166,0,644,643,1,0,0,0,644,645,1,0,0,0,645,646,1,0,0,0, - 646,647,3,320,160,0,647,650,3,330,165,0,648,649,5,17,0,0,649,651, - 3,158,79,0,650,648,1,0,0,0,650,651,1,0,0,0,651,45,1,0,0,0,652,656, - 3,48,24,0,653,656,3,74,37,0,654,656,3,78,39,0,655,652,1,0,0,0,655, - 653,1,0,0,0,655,654,1,0,0,0,656,47,1,0,0,0,657,658,3,50,25,0,658, - 660,3,56,28,0,659,661,3,70,35,0,660,659,1,0,0,0,660,661,1,0,0,0, - 661,663,1,0,0,0,662,664,3,72,36,0,663,662,1,0,0,0,663,664,1,0,0, - 0,664,49,1,0,0,0,665,668,3,328,164,0,666,668,3,258,129,0,667,665, - 1,0,0,0,667,666,1,0,0,0,668,51,1,0,0,0,669,672,3,328,164,0,670,672, - 4,26,0,0,671,669,1,0,0,0,671,670,1,0,0,0,672,53,1,0,0,0,673,674, - 5,516,0,0,674,679,3,52,26,0,675,676,5,520,0,0,676,678,3,52,26,0, - 677,675,1,0,0,0,678,681,1,0,0,0,679,677,1,0,0,0,679,680,1,0,0,0, - 680,682,1,0,0,0,681,679,1,0,0,0,682,683,5,517,0,0,683,55,1,0,0,0, - 684,722,7,7,0,0,685,687,7,8,0,0,686,688,3,58,29,0,687,686,1,0,0, - 0,687,688,1,0,0,0,688,722,1,0,0,0,689,691,5,379,0,0,690,692,3,58, - 29,0,691,690,1,0,0,0,691,692,1,0,0,0,692,699,1,0,0,0,693,695,7,9, - 0,0,694,696,5,206,0,0,695,694,1,0,0,0,695,696,1,0,0,0,696,697,1, - 0,0,0,697,698,5,378,0,0,698,700,5,504,0,0,699,693,1,0,0,0,699,700, - 1,0,0,0,700,722,1,0,0,0,701,703,7,10,0,0,702,704,3,60,30,0,703,702, - 1,0,0,0,703,704,1,0,0,0,704,722,1,0,0,0,705,707,7,11,0,0,706,708, - 3,64,32,0,707,706,1,0,0,0,707,708,1,0,0,0,708,722,1,0,0,0,709,711, - 5,469,0,0,710,712,3,66,33,0,711,710,1,0,0,0,711,712,1,0,0,0,712, - 722,1,0,0,0,713,715,5,321,0,0,714,716,3,68,34,0,715,714,1,0,0,0, - 715,716,1,0,0,0,716,722,1,0,0,0,717,719,5,294,0,0,718,720,3,62,31, - 0,719,718,1,0,0,0,719,720,1,0,0,0,720,722,1,0,0,0,721,684,1,0,0, - 0,721,685,1,0,0,0,721,689,1,0,0,0,721,701,1,0,0,0,721,705,1,0,0, - 0,721,709,1,0,0,0,721,713,1,0,0,0,721,717,1,0,0,0,722,57,1,0,0,0, - 723,724,5,516,0,0,724,725,3,360,180,0,725,726,5,517,0,0,726,59,1, - 0,0,0,727,728,5,516,0,0,728,731,3,360,180,0,729,730,5,520,0,0,730, - 732,3,360,180,0,731,729,1,0,0,0,731,732,1,0,0,0,732,733,1,0,0,0, - 733,734,5,517,0,0,734,61,1,0,0,0,735,736,5,516,0,0,736,739,3,358, - 179,0,737,738,5,520,0,0,738,740,3,358,179,0,739,737,1,0,0,0,739, - 740,1,0,0,0,740,741,1,0,0,0,741,742,5,517,0,0,742,63,1,0,0,0,743, - 744,5,507,0,0,744,745,3,56,28,0,745,746,5,506,0,0,746,65,1,0,0,0, - 747,748,5,507,0,0,748,749,3,56,28,0,749,750,5,520,0,0,750,751,3, - 56,28,0,751,752,1,0,0,0,752,753,5,506,0,0,753,67,1,0,0,0,754,755, - 5,507,0,0,755,756,3,52,26,0,756,763,3,56,28,0,757,758,5,520,0,0, - 758,759,3,52,26,0,759,760,3,56,28,0,760,762,1,0,0,0,761,757,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,767,5,506,0,0,767,69,1,0,0,0,768,769,5,64, - 0,0,769,771,3,86,43,0,770,768,1,0,0,0,770,771,1,0,0,0,771,772,1, - 0,0,0,772,773,5,288,0,0,773,776,5,466,0,0,774,775,5,241,0,0,775, - 777,5,125,0,0,776,774,1,0,0,0,776,777,1,0,0,0,777,783,1,0,0,0,778, - 780,5,241,0,0,779,778,1,0,0,0,779,780,1,0,0,0,780,781,1,0,0,0,781, - 783,5,244,0,0,782,770,1,0,0,0,782,779,1,0,0,0,783,71,1,0,0,0,784, - 785,5,59,0,0,785,786,5,537,0,0,786,73,1,0,0,0,787,788,3,50,25,0, - 788,789,3,56,28,0,789,792,5,218,0,0,790,791,5,151,0,0,791,793,3, - 76,38,0,792,790,1,0,0,0,792,793,1,0,0,0,793,795,1,0,0,0,794,796, - 5,423,0,0,795,794,1,0,0,0,795,796,1,0,0,0,796,75,1,0,0,0,797,798, - 5,537,0,0,798,77,1,0,0,0,799,800,3,50,25,0,800,801,5,17,0,0,801, - 803,3,80,40,0,802,804,3,72,36,0,803,802,1,0,0,0,803,804,1,0,0,0, - 804,79,1,0,0,0,805,806,3,258,129,0,806,81,1,0,0,0,807,808,5,424, - 0,0,808,809,5,146,0,0,809,810,3,52,26,0,810,811,5,17,0,0,811,812, - 3,258,129,0,812,83,1,0,0,0,813,814,5,64,0,0,814,816,3,86,43,0,815, - 813,1,0,0,0,815,816,1,0,0,0,816,817,1,0,0,0,817,818,5,288,0,0,818, - 819,5,466,0,0,819,820,3,54,27,0,820,821,5,241,0,0,821,822,5,125, - 0,0,822,85,1,0,0,0,823,824,3,304,152,0,824,87,1,0,0,0,825,826,5, - 277,0,0,826,827,5,146,0,0,827,828,5,371,0,0,828,89,1,0,0,0,829,830, - 5,269,0,0,830,831,5,34,0,0,831,832,3,92,46,0,832,91,1,0,0,0,833, - 834,5,516,0,0,834,839,3,94,47,0,835,836,5,520,0,0,836,838,3,94,47, - 0,837,835,1,0,0,0,838,841,1,0,0,0,839,837,1,0,0,0,839,840,1,0,0, - 0,840,842,1,0,0,0,841,839,1,0,0,0,842,843,5,517,0,0,843,93,1,0,0, - 0,844,857,3,52,26,0,845,846,5,516,0,0,846,851,3,96,48,0,847,848, - 5,520,0,0,848,850,3,96,48,0,849,847,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, - 855,5,517,0,0,855,857,1,0,0,0,856,844,1,0,0,0,856,845,1,0,0,0,857, - 95,1,0,0,0,858,861,3,280,140,0,859,861,3,354,177,0,860,858,1,0,0, - 0,860,859,1,0,0,0,861,97,1,0,0,0,862,863,5,202,0,0,863,872,3,322, - 161,0,864,868,5,516,0,0,865,867,3,100,50,0,866,865,1,0,0,0,867,870, - 1,0,0,0,868,866,1,0,0,0,868,869,1,0,0,0,869,871,1,0,0,0,870,868, - 1,0,0,0,871,873,5,517,0,0,872,864,1,0,0,0,872,873,1,0,0,0,873,99, - 1,0,0,0,874,875,7,12,0,0,875,879,7,13,0,0,876,877,7,14,0,0,877,879, - 7,15,0,0,878,874,1,0,0,0,878,876,1,0,0,0,879,101,1,0,0,0,880,881, - 5,72,0,0,881,882,5,441,0,0,882,883,3,314,157,0,883,884,3,330,165, - 0,884,103,1,0,0,0,885,886,5,72,0,0,886,888,5,447,0,0,887,889,3,332, - 166,0,888,887,1,0,0,0,888,889,1,0,0,0,889,890,1,0,0,0,890,892,3, - 318,159,0,891,893,3,72,36,0,892,891,1,0,0,0,892,893,1,0,0,0,893, - 894,1,0,0,0,894,895,3,330,165,0,895,105,1,0,0,0,896,898,5,72,0,0, - 897,899,5,497,0,0,898,897,1,0,0,0,898,899,1,0,0,0,899,900,1,0,0, - 0,900,902,5,501,0,0,901,903,3,332,166,0,902,901,1,0,0,0,902,903, - 1,0,0,0,903,904,1,0,0,0,904,906,3,326,163,0,905,907,3,54,27,0,906, - 905,1,0,0,0,906,907,1,0,0,0,907,909,1,0,0,0,908,910,3,72,36,0,909, - 908,1,0,0,0,909,910,1,0,0,0,910,911,1,0,0,0,911,912,5,17,0,0,912, - 913,3,158,79,0,913,107,1,0,0,0,914,918,5,72,0,0,915,919,5,497,0, - 0,916,917,5,497,0,0,917,919,5,370,0,0,918,915,1,0,0,0,918,916,1, - 0,0,0,918,919,1,0,0,0,919,920,1,0,0,0,920,922,5,153,0,0,921,923, - 3,332,166,0,922,921,1,0,0,0,922,923,1,0,0,0,923,924,1,0,0,0,924, - 925,3,270,135,0,925,926,5,17,0,0,926,929,3,304,152,0,927,928,5,195, - 0,0,928,930,7,16,0,0,929,927,1,0,0,0,929,930,1,0,0,0,930,932,1,0, - 0,0,931,933,3,110,55,0,932,931,1,0,0,0,932,933,1,0,0,0,933,109,1, - 0,0,0,934,935,5,412,0,0,935,936,5,463,0,0,936,942,3,112,56,0,937, - 938,5,520,0,0,938,939,5,463,0,0,939,941,3,112,56,0,940,937,1,0,0, - 0,941,944,1,0,0,0,942,940,1,0,0,0,942,943,1,0,0,0,943,111,1,0,0, - 0,944,942,1,0,0,0,945,946,5,537,0,0,946,113,1,0,0,0,947,948,5,8, - 0,0,948,950,5,373,0,0,949,951,3,334,167,0,950,949,1,0,0,0,950,951, - 1,0,0,0,951,952,1,0,0,0,952,958,3,322,161,0,953,959,3,116,58,0,954, - 959,3,118,59,0,955,959,3,120,60,0,956,959,3,122,61,0,957,959,3,124, - 62,0,958,953,1,0,0,0,958,954,1,0,0,0,958,955,1,0,0,0,958,956,1,0, - 0,0,958,957,1,0,0,0,959,115,1,0,0,0,960,962,5,311,0,0,961,963,3, - 328,164,0,962,961,1,0,0,0,962,963,1,0,0,0,963,964,1,0,0,0,964,965, - 5,388,0,0,965,966,3,328,164,0,966,117,1,0,0,0,967,968,5,340,0,0, - 968,969,3,336,168,0,969,119,1,0,0,0,970,971,5,437,0,0,971,972,5, - 64,0,0,972,973,3,86,43,0,973,974,5,288,0,0,974,975,5,466,0,0,975, - 977,3,54,27,0,976,978,3,126,63,0,977,976,1,0,0,0,977,978,1,0,0,0, - 978,121,1,0,0,0,979,980,5,116,0,0,980,981,5,64,0,0,981,982,3,86, - 43,0,982,123,1,0,0,0,983,984,5,437,0,0,984,985,5,403,0,0,985,986, - 3,54,27,0,986,125,1,0,0,0,987,988,5,241,0,0,988,989,5,125,0,0,989, - 127,1,0,0,0,990,991,5,8,0,0,991,992,5,501,0,0,992,996,3,324,162, - 0,993,997,3,116,58,0,994,995,5,17,0,0,995,997,3,158,79,0,996,993, - 1,0,0,0,996,994,1,0,0,0,997,129,1,0,0,0,998,999,5,8,0,0,999,1000, - 5,447,0,0,1000,1001,3,316,158,0,1001,1002,3,118,59,0,1002,131,1, - 0,0,0,1003,1007,5,8,0,0,1004,1008,5,497,0,0,1005,1006,5,497,0,0, - 1006,1008,5,370,0,0,1007,1004,1,0,0,0,1007,1005,1,0,0,0,1007,1008, - 1,0,0,0,1008,1009,1,0,0,0,1009,1011,5,153,0,0,1010,1012,3,334,167, - 0,1011,1010,1,0,0,0,1011,1012,1,0,0,0,1012,1013,1,0,0,0,1013,1014, - 3,272,136,0,1014,1015,5,17,0,0,1015,1018,3,304,152,0,1016,1017,5, - 195,0,0,1017,1019,7,16,0,0,1018,1016,1,0,0,0,1018,1019,1,0,0,0,1019, - 133,1,0,0,0,1020,1021,5,116,0,0,1021,1023,5,441,0,0,1022,1024,3, - 334,167,0,1023,1022,1,0,0,0,1023,1024,1,0,0,0,1024,1025,1,0,0,0, - 1025,1026,3,312,156,0,1026,135,1,0,0,0,1027,1029,5,116,0,0,1028, - 1030,5,497,0,0,1029,1028,1,0,0,0,1029,1030,1,0,0,0,1030,1031,1,0, - 0,0,1031,1033,5,373,0,0,1032,1034,3,334,167,0,1033,1032,1,0,0,0, - 1033,1034,1,0,0,0,1034,1035,1,0,0,0,1035,1036,3,322,161,0,1036,137, - 1,0,0,0,1037,1038,5,116,0,0,1038,1040,5,447,0,0,1039,1041,3,334, - 167,0,1040,1039,1,0,0,0,1040,1041,1,0,0,0,1041,1042,1,0,0,0,1042, - 1044,3,316,158,0,1043,1045,7,17,0,0,1044,1043,1,0,0,0,1044,1045, - 1,0,0,0,1045,139,1,0,0,0,1046,1048,5,116,0,0,1047,1049,5,497,0,0, - 1048,1047,1,0,0,0,1048,1049,1,0,0,0,1049,1050,1,0,0,0,1050,1052, - 5,501,0,0,1051,1053,3,334,167,0,1052,1051,1,0,0,0,1052,1053,1,0, - 0,0,1053,1054,1,0,0,0,1054,1055,3,324,162,0,1055,141,1,0,0,0,1056, - 1060,5,116,0,0,1057,1061,5,497,0,0,1058,1059,5,497,0,0,1059,1061, - 5,370,0,0,1060,1057,1,0,0,0,1060,1058,1,0,0,0,1060,1061,1,0,0,0, - 1061,1062,1,0,0,0,1062,1064,5,153,0,0,1063,1065,3,334,167,0,1064, - 1063,1,0,0,0,1064,1065,1,0,0,0,1065,1066,1,0,0,0,1066,1067,3,272, - 136,0,1067,143,1,0,0,0,1068,1070,5,132,0,0,1069,1068,1,0,0,0,1069, - 1070,1,0,0,0,1070,1071,1,0,0,0,1071,1076,3,146,73,0,1072,1076,3, - 154,77,0,1073,1074,5,132,0,0,1074,1076,3,156,78,0,1075,1069,1,0, - 0,0,1075,1072,1,0,0,0,1075,1073,1,0,0,0,1076,145,1,0,0,0,1077,1078, - 5,177,0,0,1078,1079,7,18,0,0,1079,1088,3,322,161,0,1080,1082,3,148, - 74,0,1081,1080,1,0,0,0,1081,1082,1,0,0,0,1082,1084,1,0,0,0,1083, - 1085,3,54,27,0,1084,1083,1,0,0,0,1084,1085,1,0,0,0,1085,1086,1,0, - 0,0,1086,1089,3,158,79,0,1087,1089,3,150,75,0,1088,1081,1,0,0,0, - 1088,1087,1,0,0,0,1089,147,1,0,0,0,1090,1091,5,268,0,0,1091,1092, - 3,336,168,0,1092,149,1,0,0,0,1093,1094,5,414,0,0,1094,1099,3,152, - 76,0,1095,1096,5,520,0,0,1096,1098,3,152,76,0,1097,1095,1,0,0,0, - 1098,1101,1,0,0,0,1099,1097,1,0,0,0,1099,1100,1,0,0,0,1100,151,1, - 0,0,0,1101,1099,1,0,0,0,1102,1103,5,516,0,0,1103,1108,3,354,177, - 0,1104,1105,5,520,0,0,1105,1107,3,354,177,0,1106,1104,1,0,0,0,1107, - 1110,1,0,0,0,1108,1106,1,0,0,0,1108,1109,1,0,0,0,1109,1111,1,0,0, - 0,1110,1108,1,0,0,0,1111,1112,5,517,0,0,1112,153,1,0,0,0,1113,1114, - 5,24,0,0,1114,1115,5,354,0,0,1115,1116,5,340,0,0,1116,1120,5,521, - 0,0,1117,1118,3,146,73,0,1118,1119,5,521,0,0,1119,1121,1,0,0,0,1120, - 1117,1,0,0,0,1121,1122,1,0,0,0,1122,1120,1,0,0,0,1122,1123,1,0,0, - 0,1123,1124,1,0,0,0,1124,1125,5,122,0,0,1125,155,1,0,0,0,1126,1127, - 5,354,0,0,1127,1128,5,340,0,0,1128,1132,5,24,0,0,1129,1130,3,146, - 73,0,1130,1131,5,521,0,0,1131,1133,1,0,0,0,1132,1129,1,0,0,0,1133, - 1134,1,0,0,0,1134,1132,1,0,0,0,1134,1135,1,0,0,0,1135,1136,1,0,0, - 0,1136,1137,5,122,0,0,1137,157,1,0,0,0,1138,1139,6,79,-1,0,1139, - 1162,3,160,80,0,1140,1141,3,162,81,0,1141,1142,3,158,79,5,1142,1162, - 1,0,0,0,1143,1144,5,516,0,0,1144,1145,3,158,79,0,1145,1146,5,517, - 0,0,1146,1162,1,0,0,0,1147,1149,3,170,85,0,1148,1150,3,230,115,0, - 1149,1148,1,0,0,0,1149,1150,1,0,0,0,1150,1152,1,0,0,0,1151,1153, - 3,234,117,0,1152,1151,1,0,0,0,1152,1153,1,0,0,0,1153,1162,1,0,0, - 0,1154,1156,3,168,84,0,1155,1157,3,230,115,0,1156,1155,1,0,0,0,1156, - 1157,1,0,0,0,1157,1159,1,0,0,0,1158,1160,3,234,117,0,1159,1158,1, - 0,0,0,1159,1160,1,0,0,0,1160,1162,1,0,0,0,1161,1138,1,0,0,0,1161, - 1140,1,0,0,0,1161,1143,1,0,0,0,1161,1147,1,0,0,0,1161,1154,1,0,0, - 0,1162,1177,1,0,0,0,1163,1164,10,3,0,0,1164,1166,7,19,0,0,1165,1167, - 5,5,0,0,1166,1165,1,0,0,0,1166,1167,1,0,0,0,1167,1168,1,0,0,0,1168, - 1170,3,158,79,0,1169,1171,3,230,115,0,1170,1169,1,0,0,0,1170,1171, - 1,0,0,0,1171,1173,1,0,0,0,1172,1174,3,234,117,0,1173,1172,1,0,0, - 0,1173,1174,1,0,0,0,1174,1176,1,0,0,0,1175,1163,1,0,0,0,1176,1179, - 1,0,0,0,1177,1175,1,0,0,0,1177,1178,1,0,0,0,1178,159,1,0,0,0,1179, - 1177,1,0,0,0,1180,1181,5,414,0,0,1181,1186,3,258,129,0,1182,1183, - 5,520,0,0,1183,1185,3,258,129,0,1184,1182,1,0,0,0,1185,1188,1,0, - 0,0,1186,1184,1,0,0,0,1186,1187,1,0,0,0,1187,161,1,0,0,0,1188,1186, - 1,0,0,0,1189,1190,5,433,0,0,1190,1195,3,164,82,0,1191,1192,5,520, - 0,0,1192,1194,3,164,82,0,1193,1191,1,0,0,0,1194,1197,1,0,0,0,1195, - 1193,1,0,0,0,1195,1196,1,0,0,0,1196,163,1,0,0,0,1197,1195,1,0,0, - 0,1198,1210,3,166,83,0,1199,1200,5,516,0,0,1200,1205,3,52,26,0,1201, - 1202,5,520,0,0,1202,1204,3,52,26,0,1203,1201,1,0,0,0,1204,1207,1, - 0,0,0,1205,1203,1,0,0,0,1205,1206,1,0,0,0,1206,1208,1,0,0,0,1207, - 1205,1,0,0,0,1208,1209,5,517,0,0,1209,1211,1,0,0,0,1210,1199,1,0, - 0,0,1210,1211,1,0,0,0,1211,1212,1,0,0,0,1212,1213,5,17,0,0,1213, - 1214,5,516,0,0,1214,1215,3,158,79,0,1215,1216,5,517,0,0,1216,165, - 1,0,0,0,1217,1218,3,304,152,0,1218,167,1,0,0,0,1219,1221,3,170,85, - 0,1220,1222,3,176,88,0,1221,1220,1,0,0,0,1221,1222,1,0,0,0,1222, - 1224,1,0,0,0,1223,1225,3,204,102,0,1224,1223,1,0,0,0,1224,1225,1, - 0,0,0,1225,1227,1,0,0,0,1226,1228,3,206,103,0,1227,1226,1,0,0,0, - 1227,1228,1,0,0,0,1228,1230,1,0,0,0,1229,1231,3,220,110,0,1230,1229, - 1,0,0,0,1230,1231,1,0,0,0,1231,1233,1,0,0,0,1232,1234,3,222,111, - 0,1233,1232,1,0,0,0,1233,1234,1,0,0,0,1234,1240,1,0,0,0,1235,1236, - 3,170,85,0,1236,1237,3,176,88,0,1237,1238,3,228,114,0,1238,1240, - 1,0,0,0,1239,1219,1,0,0,0,1239,1235,1,0,0,0,1240,169,1,0,0,0,1241, - 1243,5,336,0,0,1242,1244,3,364,182,0,1243,1242,1,0,0,0,1243,1244, - 1,0,0,0,1244,1254,1,0,0,0,1245,1255,5,527,0,0,1246,1251,3,172,86, - 0,1247,1248,5,520,0,0,1248,1250,3,172,86,0,1249,1247,1,0,0,0,1250, - 1253,1,0,0,0,1251,1249,1,0,0,0,1251,1252,1,0,0,0,1252,1255,1,0,0, - 0,1253,1251,1,0,0,0,1254,1245,1,0,0,0,1254,1246,1,0,0,0,1255,171, - 1,0,0,0,1256,1272,3,174,87,0,1257,1262,3,52,26,0,1258,1260,5,17, - 0,0,1259,1258,1,0,0,0,1259,1260,1,0,0,0,1260,1261,1,0,0,0,1261,1263, - 3,258,129,0,1262,1259,1,0,0,0,1262,1263,1,0,0,0,1263,1272,1,0,0, - 0,1264,1269,3,258,129,0,1265,1267,5,17,0,0,1266,1265,1,0,0,0,1266, - 1267,1,0,0,0,1267,1268,1,0,0,0,1268,1270,3,52,26,0,1269,1266,1,0, - 0,0,1269,1270,1,0,0,0,1270,1272,1,0,0,0,1271,1256,1,0,0,0,1271,1257, - 1,0,0,0,1271,1264,1,0,0,0,1272,173,1,0,0,0,1273,1274,3,268,134,0, - 1274,1275,5,262,0,0,1275,1276,3,226,113,0,1276,1277,5,17,0,0,1277, - 1278,3,304,152,0,1278,1286,1,0,0,0,1279,1280,3,268,134,0,1280,1281, - 5,262,0,0,1281,1282,3,296,148,0,1282,1283,5,17,0,0,1283,1284,3,304, - 152,0,1284,1286,1,0,0,0,1285,1273,1,0,0,0,1285,1279,1,0,0,0,1286, - 175,1,0,0,0,1287,1288,5,151,0,0,1288,1289,3,178,89,0,1289,177,1, - 0,0,0,1290,1291,6,89,-1,0,1291,1296,3,180,90,0,1292,1293,5,520,0, - 0,1293,1295,3,180,90,0,1294,1292,1,0,0,0,1295,1298,1,0,0,0,1296, - 1294,1,0,0,0,1296,1297,1,0,0,0,1297,1302,1,0,0,0,1298,1296,1,0,0, - 0,1299,1302,3,188,94,0,1300,1302,3,190,95,0,1301,1290,1,0,0,0,1301, - 1299,1,0,0,0,1301,1300,1,0,0,0,1302,1324,1,0,0,0,1303,1304,10,3, - 0,0,1304,1305,5,73,0,0,1305,1306,5,185,0,0,1306,1323,3,178,89,4, - 1307,1309,10,4,0,0,1308,1310,5,233,0,0,1309,1308,1,0,0,0,1309,1310, - 1,0,0,0,1310,1312,1,0,0,0,1311,1313,7,20,0,0,1312,1311,1,0,0,0,1312, - 1313,1,0,0,0,1313,1315,1,0,0,0,1314,1316,5,261,0,0,1315,1314,1,0, - 0,0,1315,1316,1,0,0,0,1316,1317,1,0,0,0,1317,1318,5,185,0,0,1318, - 1320,3,178,89,0,1319,1321,3,202,101,0,1320,1319,1,0,0,0,1320,1321, - 1,0,0,0,1321,1323,1,0,0,0,1322,1303,1,0,0,0,1322,1307,1,0,0,0,1323, - 1326,1,0,0,0,1324,1322,1,0,0,0,1324,1325,1,0,0,0,1325,179,1,0,0, - 0,1326,1324,1,0,0,0,1327,1329,3,182,91,0,1328,1330,3,294,147,0,1329, - 1328,1,0,0,0,1329,1330,1,0,0,0,1330,181,1,0,0,0,1331,1333,5,373, - 0,0,1332,1331,1,0,0,0,1332,1333,1,0,0,0,1333,1334,1,0,0,0,1334,1336, - 3,322,161,0,1335,1337,3,184,92,0,1336,1335,1,0,0,0,1336,1337,1,0, - 0,0,1337,1342,1,0,0,0,1338,1340,5,17,0,0,1339,1338,1,0,0,0,1339, - 1340,1,0,0,0,1340,1341,1,0,0,0,1341,1343,3,278,139,0,1342,1339,1, - 0,0,0,1342,1343,1,0,0,0,1343,1383,1,0,0,0,1344,1346,3,324,162,0, - 1345,1347,3,184,92,0,1346,1345,1,0,0,0,1346,1347,1,0,0,0,1347,1352, - 1,0,0,0,1348,1350,5,17,0,0,1349,1348,1,0,0,0,1349,1350,1,0,0,0,1350, - 1351,1,0,0,0,1351,1353,3,278,139,0,1352,1349,1,0,0,0,1352,1353,1, - 0,0,0,1353,1383,1,0,0,0,1354,1355,5,198,0,0,1355,1356,5,373,0,0, - 1356,1357,5,516,0,0,1357,1358,3,272,136,0,1358,1359,5,516,0,0,1359, - 1364,3,274,137,0,1360,1361,5,520,0,0,1361,1363,3,274,137,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,1367,1,0,0,0,1366,1364,1,0,0,0,1367,1368,5,517,0,0,1368,1369, - 5,517,0,0,1369,1383,1,0,0,0,1370,1372,5,198,0,0,1371,1370,1,0,0, - 0,1371,1372,1,0,0,0,1372,1373,1,0,0,0,1373,1374,5,516,0,0,1374,1375, - 3,158,79,0,1375,1376,5,517,0,0,1376,1383,1,0,0,0,1377,1378,5,405, - 0,0,1378,1379,5,516,0,0,1379,1380,3,258,129,0,1380,1381,5,517,0, - 0,1381,1383,1,0,0,0,1382,1332,1,0,0,0,1382,1344,1,0,0,0,1382,1354, - 1,0,0,0,1382,1371,1,0,0,0,1382,1377,1,0,0,0,1383,183,1,0,0,0,1384, - 1385,5,146,0,0,1385,1386,5,371,0,0,1386,1387,5,17,0,0,1387,1388, - 5,249,0,0,1388,1389,3,186,93,0,1389,185,1,0,0,0,1390,1391,3,258, - 129,0,1391,187,1,0,0,0,1392,1393,5,516,0,0,1393,1394,3,150,75,0, - 1394,1395,5,517,0,0,1395,1396,3,294,147,0,1396,189,1,0,0,0,1397, - 1398,5,373,0,0,1398,1399,5,516,0,0,1399,1400,3,192,96,0,1400,1401, - 5,517,0,0,1401,191,1,0,0,0,1402,1403,3,194,97,0,1403,1404,5,516, - 0,0,1404,1409,3,196,98,0,1405,1406,5,520,0,0,1406,1408,3,196,98, - 0,1407,1405,1,0,0,0,1408,1411,1,0,0,0,1409,1407,1,0,0,0,1409,1410, - 1,0,0,0,1410,1412,1,0,0,0,1411,1409,1,0,0,0,1412,1413,5,517,0,0, - 1413,193,1,0,0,0,1414,1415,7,21,0,0,1415,195,1,0,0,0,1416,1417,5, - 373,0,0,1417,1432,3,218,109,0,1418,1432,3,200,100,0,1419,1432,3, - 282,141,0,1420,1421,5,446,0,0,1421,1422,5,536,0,0,1422,1423,5,373, - 0,0,1423,1432,3,218,109,0,1424,1425,5,498,0,0,1425,1426,5,536,0, - 0,1426,1432,3,200,100,0,1427,1428,3,198,99,0,1428,1429,5,536,0,0, - 1429,1430,3,282,141,0,1430,1432,1,0,0,0,1431,1416,1,0,0,0,1431,1418, - 1,0,0,0,1431,1419,1,0,0,0,1431,1420,1,0,0,0,1431,1424,1,0,0,0,1431, - 1427,1,0,0,0,1432,197,1,0,0,0,1433,1434,7,22,0,0,1434,199,1,0,0, - 0,1435,1436,5,451,0,0,1436,1437,5,516,0,0,1437,1438,3,52,26,0,1438, - 1439,5,517,0,0,1439,201,1,0,0,0,1440,1441,5,253,0,0,1441,1445,3, - 260,130,0,1442,1443,5,412,0,0,1443,1445,3,54,27,0,1444,1440,1,0, - 0,0,1444,1442,1,0,0,0,1445,203,1,0,0,0,1446,1447,5,430,0,0,1447, - 1448,3,260,130,0,1448,205,1,0,0,0,1449,1450,5,159,0,0,1450,1451, - 5,34,0,0,1451,1456,3,208,104,0,1452,1453,5,520,0,0,1453,1455,3,208, - 104,0,1454,1452,1,0,0,0,1455,1458,1,0,0,0,1456,1454,1,0,0,0,1456, - 1457,1,0,0,0,1457,207,1,0,0,0,1458,1456,1,0,0,0,1459,1500,3,52,26, - 0,1460,1500,3,214,107,0,1461,1462,5,516,0,0,1462,1500,5,517,0,0, - 1463,1464,5,516,0,0,1464,1469,3,258,129,0,1465,1466,5,520,0,0,1466, - 1468,3,258,129,0,1467,1465,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, - 1473,5,517,0,0,1473,1500,1,0,0,0,1474,1475,3,212,106,0,1475,1476, - 5,516,0,0,1476,1481,3,258,129,0,1477,1478,5,520,0,0,1478,1480,3, - 258,129,0,1479,1477,1,0,0,0,1480,1483,1,0,0,0,1481,1479,1,0,0,0, - 1481,1482,1,0,0,0,1482,1484,1,0,0,0,1483,1481,1,0,0,0,1484,1485, - 5,517,0,0,1485,1500,1,0,0,0,1486,1487,3,210,105,0,1487,1488,5,516, - 0,0,1488,1493,3,208,104,0,1489,1490,5,520,0,0,1490,1492,3,208,104, - 0,1491,1489,1,0,0,0,1492,1495,1,0,0,0,1493,1491,1,0,0,0,1493,1494, - 1,0,0,0,1494,1496,1,0,0,0,1495,1493,1,0,0,0,1496,1497,5,517,0,0, - 1497,1500,1,0,0,0,1498,1500,3,258,129,0,1499,1459,1,0,0,0,1499,1460, - 1,0,0,0,1499,1461,1,0,0,0,1499,1463,1,0,0,0,1499,1474,1,0,0,0,1499, - 1486,1,0,0,0,1499,1498,1,0,0,0,1500,209,1,0,0,0,1501,1502,5,160, - 0,0,1502,1503,5,493,0,0,1503,211,1,0,0,0,1504,1505,7,23,0,0,1505, - 213,1,0,0,0,1506,1507,3,216,108,0,1507,1508,5,516,0,0,1508,1509, - 3,218,109,0,1509,1510,5,520,0,0,1510,1511,3,282,141,0,1511,1512, - 5,517,0,0,1512,215,1,0,0,0,1513,1514,7,24,0,0,1514,217,1,0,0,0,1515, - 1516,3,328,164,0,1516,219,1,0,0,0,1517,1518,5,163,0,0,1518,1519, - 3,260,130,0,1519,221,1,0,0,0,1520,1521,5,432,0,0,1521,1526,3,224, - 112,0,1522,1523,5,520,0,0,1523,1525,3,224,112,0,1524,1522,1,0,0, - 0,1525,1528,1,0,0,0,1526,1524,1,0,0,0,1526,1527,1,0,0,0,1527,223, - 1,0,0,0,1528,1526,1,0,0,0,1529,1530,3,296,148,0,1530,1531,5,17,0, - 0,1531,1532,3,226,113,0,1532,225,1,0,0,0,1533,1535,3,296,148,0,1534, - 1533,1,0,0,0,1534,1535,1,0,0,0,1535,1536,1,0,0,0,1536,1538,5,516, - 0,0,1537,1539,3,236,118,0,1538,1537,1,0,0,0,1538,1539,1,0,0,0,1539, - 1541,1,0,0,0,1540,1542,3,230,115,0,1541,1540,1,0,0,0,1541,1542,1, - 0,0,0,1542,1544,1,0,0,0,1543,1545,3,252,126,0,1544,1543,1,0,0,0, - 1544,1545,1,0,0,0,1545,1546,1,0,0,0,1546,1547,5,517,0,0,1547,227, - 1,0,0,0,1548,1549,5,213,0,0,1549,1551,5,516,0,0,1550,1552,3,236, - 118,0,1551,1550,1,0,0,0,1551,1552,1,0,0,0,1552,1554,1,0,0,0,1553, - 1555,3,230,115,0,1554,1553,1,0,0,0,1554,1555,1,0,0,0,1555,1557,1, - 0,0,0,1556,1558,3,240,120,0,1557,1556,1,0,0,0,1557,1558,1,0,0,0, - 1558,1560,1,0,0,0,1559,1561,3,246,123,0,1560,1559,1,0,0,0,1560,1561, - 1,0,0,0,1561,1563,1,0,0,0,1562,1564,3,248,124,0,1563,1562,1,0,0, - 0,1563,1564,1,0,0,0,1564,1566,1,0,0,0,1565,1567,3,242,121,0,1566, - 1565,1,0,0,0,1566,1567,1,0,0,0,1567,1568,1,0,0,0,1568,1569,3,250, - 125,0,1569,1574,5,517,0,0,1570,1572,5,17,0,0,1571,1570,1,0,0,0,1571, - 1572,1,0,0,0,1572,1573,1,0,0,0,1573,1575,3,304,152,0,1574,1571,1, - 0,0,0,1574,1575,1,0,0,0,1575,229,1,0,0,0,1576,1577,5,258,0,0,1577, - 1578,5,34,0,0,1578,1583,3,232,116,0,1579,1580,5,520,0,0,1580,1582, - 3,232,116,0,1581,1579,1,0,0,0,1582,1585,1,0,0,0,1583,1581,1,0,0, - 0,1583,1584,1,0,0,0,1584,231,1,0,0,0,1585,1583,1,0,0,0,1586,1588, - 3,52,26,0,1587,1589,7,25,0,0,1588,1587,1,0,0,0,1588,1589,1,0,0,0, - 1589,1592,1,0,0,0,1590,1591,5,476,0,0,1591,1593,7,26,0,0,1592,1590, - 1,0,0,0,1592,1593,1,0,0,0,1593,233,1,0,0,0,1594,1597,5,204,0,0,1595, - 1598,5,5,0,0,1596,1598,3,258,129,0,1597,1595,1,0,0,0,1597,1596,1, - 0,0,0,1598,235,1,0,0,0,1599,1600,5,268,0,0,1600,1601,5,34,0,0,1601, - 1606,3,52,26,0,1602,1603,5,520,0,0,1603,1605,3,52,26,0,1604,1602, - 1,0,0,0,1605,1608,1,0,0,0,1606,1604,1,0,0,0,1606,1607,1,0,0,0,1607, - 237,1,0,0,0,1608,1606,1,0,0,0,1609,1626,5,527,0,0,1610,1626,5,530, - 0,0,1611,1626,5,535,0,0,1612,1613,5,518,0,0,1613,1614,5,538,0,0, - 1614,1615,5,520,0,0,1615,1616,5,538,0,0,1616,1626,5,519,0,0,1617, - 1618,5,518,0,0,1618,1619,5,538,0,0,1619,1620,5,520,0,0,1620,1626, - 5,519,0,0,1621,1622,5,518,0,0,1622,1623,5,520,0,0,1623,1624,5,538, - 0,0,1624,1626,5,519,0,0,1625,1609,1,0,0,0,1625,1610,1,0,0,0,1625, - 1611,1,0,0,0,1625,1612,1,0,0,0,1625,1617,1,0,0,0,1625,1621,1,0,0, - 0,1626,239,1,0,0,0,1627,1628,5,215,0,0,1628,1633,3,172,86,0,1629, - 1630,5,520,0,0,1630,1632,3,172,86,0,1631,1629,1,0,0,0,1632,1635, - 1,0,0,0,1633,1631,1,0,0,0,1633,1634,1,0,0,0,1634,241,1,0,0,0,1635, - 1633,1,0,0,0,1636,1637,5,271,0,0,1637,1639,5,516,0,0,1638,1640,3, - 244,122,0,1639,1638,1,0,0,0,1640,1641,1,0,0,0,1641,1639,1,0,0,0, - 1641,1642,1,0,0,0,1642,1643,1,0,0,0,1643,1645,5,517,0,0,1644,1646, - 3,256,128,0,1645,1644,1,0,0,0,1645,1646,1,0,0,0,1646,243,1,0,0,0, - 1647,1649,3,306,153,0,1648,1650,3,238,119,0,1649,1648,1,0,0,0,1649, - 1650,1,0,0,0,1650,245,1,0,0,0,1651,1652,5,5,0,0,1652,1653,5,322, - 0,0,1653,1654,5,272,0,0,1654,1660,5,210,0,0,1655,1656,5,254,0,0, - 1656,1657,5,321,0,0,1657,1658,5,272,0,0,1658,1660,5,210,0,0,1659, - 1651,1,0,0,0,1659,1655,1,0,0,0,1660,247,1,0,0,0,1661,1662,5,438, - 0,0,1662,1663,5,210,0,0,1663,1664,5,343,0,0,1664,1665,5,478,0,0, - 1665,1666,5,467,0,0,1666,1686,5,321,0,0,1667,1668,5,438,0,0,1668, - 1669,5,210,0,0,1669,1670,5,343,0,0,1670,1671,5,388,0,0,1671,1672, - 5,237,0,0,1672,1686,5,321,0,0,1673,1674,5,438,0,0,1674,1675,5,210, - 0,0,1675,1676,5,343,0,0,1676,1677,5,388,0,0,1677,1678,5,467,0,0, - 1678,1686,3,306,153,0,1679,1680,5,438,0,0,1680,1681,5,210,0,0,1681, - 1682,5,343,0,0,1682,1683,5,388,0,0,1683,1684,5,457,0,0,1684,1686, - 3,306,153,0,1685,1661,1,0,0,0,1685,1667,1,0,0,0,1685,1673,1,0,0, - 0,1685,1679,1,0,0,0,1686,249,1,0,0,0,1687,1688,5,105,0,0,1688,1693, - 3,172,86,0,1689,1690,5,520,0,0,1690,1692,3,172,86,0,1691,1689,1, - 0,0,0,1692,1695,1,0,0,0,1693,1691,1,0,0,0,1693,1694,1,0,0,0,1694, - 251,1,0,0,0,1695,1693,1,0,0,0,1696,1697,5,292,0,0,1697,1698,5,27, - 0,0,1698,1699,3,282,141,0,1699,1700,3,254,127,0,1700,1706,1,0,0, - 0,1701,1702,5,322,0,0,1702,1703,5,27,0,0,1703,1704,5,538,0,0,1704, - 1706,3,254,127,0,1705,1696,1,0,0,0,1705,1701,1,0,0,0,1706,253,1, - 0,0,0,1707,1708,5,480,0,0,1708,1709,5,10,0,0,1709,1710,5,76,0,0, - 1710,1711,5,321,0,0,1711,255,1,0,0,0,1712,1713,5,434,0,0,1713,1714, - 3,282,141,0,1714,257,1,0,0,0,1715,1716,3,260,130,0,1716,259,1,0, - 0,0,1717,1718,6,130,-1,0,1718,1719,5,241,0,0,1719,1730,3,260,130, - 6,1720,1721,5,133,0,0,1721,1722,5,516,0,0,1722,1723,3,158,79,0,1723, - 1724,5,517,0,0,1724,1730,1,0,0,0,1725,1727,3,266,133,0,1726,1728, - 3,262,131,0,1727,1726,1,0,0,0,1727,1728,1,0,0,0,1728,1730,1,0,0, - 0,1729,1717,1,0,0,0,1729,1720,1,0,0,0,1729,1725,1,0,0,0,1730,1745, - 1,0,0,0,1731,1732,10,3,0,0,1732,1733,5,10,0,0,1733,1744,3,260,130, - 4,1734,1735,10,2,0,0,1735,1736,5,257,0,0,1736,1744,3,260,130,3,1737, - 1738,10,1,0,0,1738,1740,5,184,0,0,1739,1741,5,241,0,0,1740,1739, - 1,0,0,0,1740,1741,1,0,0,0,1741,1742,1,0,0,0,1742,1744,7,27,0,0,1743, - 1731,1,0,0,0,1743,1734,1,0,0,0,1743,1737,1,0,0,0,1744,1747,1,0,0, - 0,1745,1743,1,0,0,0,1745,1746,1,0,0,0,1746,261,1,0,0,0,1747,1745, - 1,0,0,0,1748,1750,5,241,0,0,1749,1748,1,0,0,0,1749,1750,1,0,0,0, - 1750,1751,1,0,0,0,1751,1753,5,27,0,0,1752,1754,7,28,0,0,1753,1752, - 1,0,0,0,1753,1754,1,0,0,0,1754,1755,1,0,0,0,1755,1756,3,266,133, - 0,1756,1757,5,10,0,0,1757,1758,3,266,133,0,1758,1816,1,0,0,0,1759, - 1761,5,241,0,0,1760,1759,1,0,0,0,1760,1761,1,0,0,0,1761,1762,1,0, - 0,0,1762,1763,5,170,0,0,1763,1764,5,516,0,0,1764,1769,3,258,129, - 0,1765,1766,5,520,0,0,1766,1768,3,258,129,0,1767,1765,1,0,0,0,1768, - 1771,1,0,0,0,1769,1767,1,0,0,0,1769,1770,1,0,0,0,1770,1772,1,0,0, - 0,1771,1769,1,0,0,0,1772,1773,5,517,0,0,1773,1816,1,0,0,0,1774,1776, - 5,241,0,0,1775,1774,1,0,0,0,1775,1776,1,0,0,0,1776,1777,1,0,0,0, - 1777,1778,5,170,0,0,1778,1779,5,516,0,0,1779,1780,3,158,79,0,1780, - 1781,5,517,0,0,1781,1816,1,0,0,0,1782,1783,5,133,0,0,1783,1784,5, - 516,0,0,1784,1785,3,158,79,0,1785,1786,5,517,0,0,1786,1816,1,0,0, - 0,1787,1789,5,241,0,0,1788,1787,1,0,0,0,1788,1789,1,0,0,0,1789,1790, - 1,0,0,0,1790,1791,5,318,0,0,1791,1816,3,266,133,0,1792,1816,3,264, - 132,0,1793,1795,5,184,0,0,1794,1796,5,241,0,0,1795,1794,1,0,0,0, - 1795,1796,1,0,0,0,1796,1797,1,0,0,0,1797,1816,7,27,0,0,1798,1800, - 5,184,0,0,1799,1801,5,241,0,0,1800,1799,1,0,0,0,1800,1801,1,0,0, - 0,1801,1802,1,0,0,0,1802,1803,5,113,0,0,1803,1804,5,151,0,0,1804, - 1816,3,266,133,0,1805,1807,5,241,0,0,1806,1805,1,0,0,0,1806,1807, - 1,0,0,0,1807,1808,1,0,0,0,1808,1809,5,342,0,0,1809,1810,5,388,0, - 0,1810,1813,3,266,133,0,1811,1812,5,127,0,0,1812,1814,3,358,179, - 0,1813,1811,1,0,0,0,1813,1814,1,0,0,0,1814,1816,1,0,0,0,1815,1749, - 1,0,0,0,1815,1760,1,0,0,0,1815,1775,1,0,0,0,1815,1782,1,0,0,0,1815, - 1788,1,0,0,0,1815,1792,1,0,0,0,1815,1793,1,0,0,0,1815,1798,1,0,0, - 0,1815,1806,1,0,0,0,1816,263,1,0,0,0,1817,1819,5,241,0,0,1818,1817, - 1,0,0,0,1818,1819,1,0,0,0,1819,1820,1,0,0,0,1820,1821,5,202,0,0, - 1821,1835,7,29,0,0,1822,1823,5,516,0,0,1823,1836,5,517,0,0,1824, - 1825,5,516,0,0,1825,1830,3,258,129,0,1826,1827,5,520,0,0,1827,1829, - 3,258,129,0,1828,1826,1,0,0,0,1829,1832,1,0,0,0,1830,1828,1,0,0, - 0,1830,1831,1,0,0,0,1831,1833,1,0,0,0,1832,1830,1,0,0,0,1833,1834, - 5,517,0,0,1834,1836,1,0,0,0,1835,1822,1,0,0,0,1835,1824,1,0,0,0, - 1836,1847,1,0,0,0,1837,1839,5,241,0,0,1838,1837,1,0,0,0,1838,1839, - 1,0,0,0,1839,1840,1,0,0,0,1840,1841,5,202,0,0,1841,1844,3,266,133, - 0,1842,1843,5,127,0,0,1843,1845,3,358,179,0,1844,1842,1,0,0,0,1844, - 1845,1,0,0,0,1845,1847,1,0,0,0,1846,1818,1,0,0,0,1846,1838,1,0,0, - 0,1847,265,1,0,0,0,1848,1849,6,133,-1,0,1849,1853,3,268,134,0,1850, - 1851,7,30,0,0,1851,1853,3,266,133,7,1852,1848,1,0,0,0,1852,1850, - 1,0,0,0,1853,1875,1,0,0,0,1854,1855,10,6,0,0,1855,1856,7,31,0,0, - 1856,1874,3,266,133,7,1857,1858,10,5,0,0,1858,1859,7,32,0,0,1859, - 1874,3,266,133,6,1860,1861,10,4,0,0,1861,1862,5,511,0,0,1862,1874, - 3,266,133,5,1863,1864,10,3,0,0,1864,1865,5,512,0,0,1865,1874,3,266, - 133,4,1866,1867,10,2,0,0,1867,1868,5,510,0,0,1868,1874,3,266,133, - 3,1869,1870,10,1,0,0,1870,1871,3,346,173,0,1871,1872,3,266,133,2, - 1872,1874,1,0,0,0,1873,1854,1,0,0,0,1873,1857,1,0,0,0,1873,1860, - 1,0,0,0,1873,1863,1,0,0,0,1873,1866,1,0,0,0,1873,1869,1,0,0,0,1874, - 1877,1,0,0,0,1875,1873,1,0,0,0,1875,1876,1,0,0,0,1876,267,1,0,0, - 0,1877,1875,1,0,0,0,1878,1879,6,134,-1,0,1879,1881,5,40,0,0,1880, - 1882,3,310,155,0,1881,1880,1,0,0,0,1882,1883,1,0,0,0,1883,1881,1, - 0,0,0,1883,1884,1,0,0,0,1884,1887,1,0,0,0,1885,1886,5,120,0,0,1886, - 1888,3,258,129,0,1887,1885,1,0,0,0,1887,1888,1,0,0,0,1888,1889,1, - 0,0,0,1889,1890,5,122,0,0,1890,1971,1,0,0,0,1891,1892,5,40,0,0,1892, - 1894,3,258,129,0,1893,1895,3,310,155,0,1894,1893,1,0,0,0,1895,1896, - 1,0,0,0,1896,1894,1,0,0,0,1896,1897,1,0,0,0,1897,1900,1,0,0,0,1898, - 1899,5,120,0,0,1899,1901,3,258,129,0,1900,1898,1,0,0,0,1900,1901, - 1,0,0,0,1901,1902,1,0,0,0,1902,1903,5,122,0,0,1903,1971,1,0,0,0, - 1904,1905,5,41,0,0,1905,1906,5,516,0,0,1906,1907,3,258,129,0,1907, - 1908,5,17,0,0,1908,1909,3,56,28,0,1909,1910,5,517,0,0,1910,1971, - 1,0,0,0,1911,1912,5,457,0,0,1912,1913,5,516,0,0,1913,1916,3,258, - 129,0,1914,1915,5,461,0,0,1915,1917,5,476,0,0,1916,1914,1,0,0,0, - 1916,1917,1,0,0,0,1917,1918,1,0,0,0,1918,1919,5,517,0,0,1919,1971, - 1,0,0,0,1920,1921,5,467,0,0,1921,1922,5,516,0,0,1922,1925,3,258, - 129,0,1923,1924,5,461,0,0,1924,1926,5,476,0,0,1925,1923,1,0,0,0, - 1925,1926,1,0,0,0,1926,1927,1,0,0,0,1927,1928,5,517,0,0,1928,1971, - 1,0,0,0,1929,1930,5,281,0,0,1930,1931,5,516,0,0,1931,1932,3,266, - 133,0,1932,1933,5,170,0,0,1933,1934,3,266,133,0,1934,1935,5,517, - 0,0,1935,1971,1,0,0,0,1936,1971,3,354,177,0,1937,1971,5,527,0,0, - 1938,1939,3,328,164,0,1939,1940,5,513,0,0,1940,1941,5,527,0,0,1941, - 1971,1,0,0,0,1942,1943,5,516,0,0,1943,1944,3,158,79,0,1944,1945, - 5,517,0,0,1945,1971,1,0,0,0,1946,1947,3,272,136,0,1947,1959,5,516, - 0,0,1948,1950,3,364,182,0,1949,1948,1,0,0,0,1949,1950,1,0,0,0,1950, - 1951,1,0,0,0,1951,1956,3,274,137,0,1952,1953,5,520,0,0,1953,1955, - 3,274,137,0,1954,1952,1,0,0,0,1955,1958,1,0,0,0,1956,1954,1,0,0, - 0,1956,1957,1,0,0,0,1957,1960,1,0,0,0,1958,1956,1,0,0,0,1959,1949, - 1,0,0,0,1959,1960,1,0,0,0,1960,1961,1,0,0,0,1961,1962,5,517,0,0, - 1962,1971,1,0,0,0,1963,1971,3,304,152,0,1964,1971,3,276,138,0,1965, - 1966,5,516,0,0,1966,1967,3,258,129,0,1967,1968,5,517,0,0,1968,1971, - 1,0,0,0,1969,1971,5,85,0,0,1970,1878,1,0,0,0,1970,1891,1,0,0,0,1970, - 1904,1,0,0,0,1970,1911,1,0,0,0,1970,1920,1,0,0,0,1970,1929,1,0,0, - 0,1970,1936,1,0,0,0,1970,1937,1,0,0,0,1970,1938,1,0,0,0,1970,1942, - 1,0,0,0,1970,1946,1,0,0,0,1970,1963,1,0,0,0,1970,1964,1,0,0,0,1970, - 1965,1,0,0,0,1970,1969,1,0,0,0,1971,1979,1,0,0,0,1972,1973,10,5, - 0,0,1973,1974,5,514,0,0,1974,1975,3,266,133,0,1975,1976,5,515,0, - 0,1976,1978,1,0,0,0,1977,1972,1,0,0,0,1978,1981,1,0,0,0,1979,1977, - 1,0,0,0,1979,1980,1,0,0,0,1980,269,1,0,0,0,1981,1979,1,0,0,0,1982, - 1983,3,328,164,0,1983,271,1,0,0,0,1984,1987,3,372,186,0,1985,1987, - 3,328,164,0,1986,1984,1,0,0,0,1986,1985,1,0,0,0,1987,273,1,0,0,0, - 1988,1993,3,370,185,0,1989,1993,3,368,184,0,1990,1993,3,366,183, - 0,1991,1993,3,258,129,0,1992,1988,1,0,0,0,1992,1989,1,0,0,0,1992, - 1990,1,0,0,0,1992,1991,1,0,0,0,1993,275,1,0,0,0,1994,1995,3,328, - 164,0,1995,277,1,0,0,0,1996,1997,3,304,152,0,1997,279,1,0,0,0,1998, - 2001,3,304,152,0,1999,2001,3,276,138,0,2000,1998,1,0,0,0,2000,1999, - 1,0,0,0,2001,281,1,0,0,0,2002,2005,5,182,0,0,2003,2006,3,284,142, - 0,2004,2006,3,288,144,0,2005,2003,1,0,0,0,2005,2004,1,0,0,0,2005, - 2006,1,0,0,0,2006,283,1,0,0,0,2007,2009,3,286,143,0,2008,2010,3, - 290,145,0,2009,2008,1,0,0,0,2009,2010,1,0,0,0,2010,285,1,0,0,0,2011, - 2012,3,292,146,0,2012,2013,3,368,184,0,2013,2015,1,0,0,0,2014,2011, - 1,0,0,0,2015,2016,1,0,0,0,2016,2014,1,0,0,0,2016,2017,1,0,0,0,2017, - 287,1,0,0,0,2018,2021,3,290,145,0,2019,2022,3,286,143,0,2020,2022, - 3,290,145,0,2021,2019,1,0,0,0,2021,2020,1,0,0,0,2021,2022,1,0,0, - 0,2022,289,1,0,0,0,2023,2024,3,292,146,0,2024,2025,3,368,184,0,2025, - 2026,5,388,0,0,2026,2027,3,368,184,0,2027,291,1,0,0,0,2028,2030, - 7,33,0,0,2029,2028,1,0,0,0,2029,2030,1,0,0,0,2030,2031,1,0,0,0,2031, - 2034,7,34,0,0,2032,2034,5,537,0,0,2033,2029,1,0,0,0,2033,2032,1, - 0,0,0,2034,293,1,0,0,0,2035,2037,5,17,0,0,2036,2035,1,0,0,0,2036, - 2037,1,0,0,0,2037,2038,1,0,0,0,2038,2040,3,304,152,0,2039,2041,3, - 300,150,0,2040,2039,1,0,0,0,2040,2041,1,0,0,0,2041,295,1,0,0,0,2042, - 2043,3,304,152,0,2043,2044,3,298,149,0,2044,297,1,0,0,0,2045,2046, - 5,221,0,0,2046,2048,3,304,152,0,2047,2045,1,0,0,0,2048,2049,1,0, - 0,0,2049,2047,1,0,0,0,2049,2050,1,0,0,0,2050,2053,1,0,0,0,2051,2053, - 1,0,0,0,2052,2047,1,0,0,0,2052,2051,1,0,0,0,2053,299,1,0,0,0,2054, - 2055,5,516,0,0,2055,2056,3,302,151,0,2056,2057,5,517,0,0,2057,301, - 1,0,0,0,2058,2063,3,304,152,0,2059,2060,5,520,0,0,2060,2062,3,304, - 152,0,2061,2059,1,0,0,0,2062,2065,1,0,0,0,2063,2061,1,0,0,0,2063, - 2064,1,0,0,0,2064,303,1,0,0,0,2065,2063,1,0,0,0,2066,2070,3,306, - 153,0,2067,2070,3,308,154,0,2068,2070,3,374,187,0,2069,2066,1,0, - 0,0,2069,2067,1,0,0,0,2069,2068,1,0,0,0,2070,305,1,0,0,0,2071,2072, - 7,35,0,0,2072,307,1,0,0,0,2073,2074,5,537,0,0,2074,309,1,0,0,0,2075, - 2076,5,428,0,0,2076,2077,3,258,129,0,2077,2078,5,376,0,0,2078,2079, - 3,258,129,0,2079,311,1,0,0,0,2080,2081,3,304,152,0,2081,313,1,0, - 0,0,2082,2083,3,304,152,0,2083,315,1,0,0,0,2084,2087,3,304,152,0, - 2085,2086,5,513,0,0,2086,2088,3,304,152,0,2087,2085,1,0,0,0,2087, - 2088,1,0,0,0,2088,317,1,0,0,0,2089,2092,3,304,152,0,2090,2091,5, - 513,0,0,2091,2093,3,304,152,0,2092,2090,1,0,0,0,2092,2093,1,0,0, - 0,2093,319,1,0,0,0,2094,2097,3,304,152,0,2095,2096,5,513,0,0,2096, - 2098,3,304,152,0,2097,2095,1,0,0,0,2097,2098,1,0,0,0,2098,2107,1, - 0,0,0,2099,2100,3,304,152,0,2100,2101,5,513,0,0,2101,2104,3,304, - 152,0,2102,2103,5,513,0,0,2103,2105,3,304,152,0,2104,2102,1,0,0, - 0,2104,2105,1,0,0,0,2105,2107,1,0,0,0,2106,2094,1,0,0,0,2106,2099, - 1,0,0,0,2107,321,1,0,0,0,2108,2111,3,304,152,0,2109,2110,5,513,0, - 0,2110,2112,3,304,152,0,2111,2109,1,0,0,0,2111,2112,1,0,0,0,2112, - 2121,1,0,0,0,2113,2114,3,304,152,0,2114,2115,5,513,0,0,2115,2118, - 3,304,152,0,2116,2117,5,513,0,0,2117,2119,3,304,152,0,2118,2116, - 1,0,0,0,2118,2119,1,0,0,0,2119,2121,1,0,0,0,2120,2108,1,0,0,0,2120, - 2113,1,0,0,0,2121,323,1,0,0,0,2122,2125,3,304,152,0,2123,2124,5, - 513,0,0,2124,2126,3,304,152,0,2125,2123,1,0,0,0,2125,2126,1,0,0, - 0,2126,2135,1,0,0,0,2127,2128,3,304,152,0,2128,2129,5,513,0,0,2129, - 2132,3,304,152,0,2130,2131,5,513,0,0,2131,2133,3,304,152,0,2132, - 2130,1,0,0,0,2132,2133,1,0,0,0,2133,2135,1,0,0,0,2134,2122,1,0,0, - 0,2134,2127,1,0,0,0,2135,325,1,0,0,0,2136,2139,3,304,152,0,2137, - 2138,5,513,0,0,2138,2140,3,304,152,0,2139,2137,1,0,0,0,2139,2140, - 1,0,0,0,2140,2149,1,0,0,0,2141,2142,3,304,152,0,2142,2143,5,513, - 0,0,2143,2146,3,304,152,0,2144,2145,5,513,0,0,2145,2147,3,304,152, - 0,2146,2144,1,0,0,0,2146,2147,1,0,0,0,2147,2149,1,0,0,0,2148,2136, - 1,0,0,0,2148,2141,1,0,0,0,2149,327,1,0,0,0,2150,2155,3,304,152,0, - 2151,2152,5,513,0,0,2152,2154,3,304,152,0,2153,2151,1,0,0,0,2154, - 2157,1,0,0,0,2155,2156,1,0,0,0,2155,2153,1,0,0,0,2156,329,1,0,0, - 0,2157,2155,1,0,0,0,2158,2159,5,433,0,0,2159,2160,3,336,168,0,2160, - 331,1,0,0,0,2161,2162,5,167,0,0,2162,2163,5,241,0,0,2163,2164,5, - 133,0,0,2164,333,1,0,0,0,2165,2166,5,167,0,0,2166,2167,5,133,0,0, - 2167,335,1,0,0,0,2168,2169,5,516,0,0,2169,2174,3,338,169,0,2170, - 2171,5,520,0,0,2171,2173,3,338,169,0,2172,2170,1,0,0,0,2173,2176, - 1,0,0,0,2174,2172,1,0,0,0,2174,2175,1,0,0,0,2175,2177,1,0,0,0,2176, - 2174,1,0,0,0,2177,2178,5,517,0,0,2178,337,1,0,0,0,2179,2184,3,340, - 170,0,2180,2182,5,505,0,0,2181,2180,1,0,0,0,2181,2182,1,0,0,0,2182, - 2183,1,0,0,0,2183,2185,3,342,171,0,2184,2181,1,0,0,0,2184,2185,1, - 0,0,0,2185,339,1,0,0,0,2186,2190,3,304,152,0,2187,2190,3,276,138, - 0,2188,2190,5,537,0,0,2189,2186,1,0,0,0,2189,2187,1,0,0,0,2189,2188, - 1,0,0,0,2190,341,1,0,0,0,2191,2196,5,538,0,0,2192,2196,5,539,0,0, - 2193,2196,3,362,181,0,2194,2196,5,537,0,0,2195,2191,1,0,0,0,2195, - 2192,1,0,0,0,2195,2193,1,0,0,0,2195,2194,1,0,0,0,2196,343,1,0,0, - 0,2197,2204,5,10,0,0,2198,2199,5,511,0,0,2199,2204,5,511,0,0,2200, - 2204,5,257,0,0,2201,2202,5,510,0,0,2202,2204,5,510,0,0,2203,2197, - 1,0,0,0,2203,2198,1,0,0,0,2203,2200,1,0,0,0,2203,2201,1,0,0,0,2204, - 345,1,0,0,0,2205,2220,5,505,0,0,2206,2220,5,506,0,0,2207,2220,5, - 507,0,0,2208,2209,5,507,0,0,2209,2220,5,505,0,0,2210,2211,5,506, - 0,0,2211,2220,5,505,0,0,2212,2213,5,507,0,0,2213,2220,5,506,0,0, - 2214,2215,5,508,0,0,2215,2220,5,505,0,0,2216,2217,5,507,0,0,2217, - 2218,5,505,0,0,2218,2220,5,506,0,0,2219,2205,1,0,0,0,2219,2206,1, - 0,0,0,2219,2207,1,0,0,0,2219,2208,1,0,0,0,2219,2210,1,0,0,0,2219, - 2212,1,0,0,0,2219,2214,1,0,0,0,2219,2216,1,0,0,0,2220,347,1,0,0, - 0,2221,2222,5,507,0,0,2222,2229,5,507,0,0,2223,2224,5,506,0,0,2224, - 2229,5,506,0,0,2225,2229,5,511,0,0,2226,2229,5,512,0,0,2227,2229, - 5,510,0,0,2228,2221,1,0,0,0,2228,2223,1,0,0,0,2228,2225,1,0,0,0, - 2228,2226,1,0,0,0,2228,2227,1,0,0,0,2229,349,1,0,0,0,2230,2231,7, - 36,0,0,2231,351,1,0,0,0,2232,2233,7,37,0,0,2233,353,1,0,0,0,2234, - 2249,3,282,141,0,2235,2249,3,356,178,0,2236,2249,3,358,179,0,2237, - 2239,5,529,0,0,2238,2237,1,0,0,0,2238,2239,1,0,0,0,2239,2240,1,0, - 0,0,2240,2249,3,360,180,0,2241,2249,3,362,181,0,2242,2249,5,539, - 0,0,2243,2249,5,540,0,0,2244,2246,5,241,0,0,2245,2244,1,0,0,0,2245, - 2246,1,0,0,0,2246,2247,1,0,0,0,2247,2249,5,244,0,0,2248,2234,1,0, - 0,0,2248,2235,1,0,0,0,2248,2236,1,0,0,0,2248,2238,1,0,0,0,2248,2241, - 1,0,0,0,2248,2242,1,0,0,0,2248,2243,1,0,0,0,2248,2245,1,0,0,0,2249, - 355,1,0,0,0,2250,2251,3,366,183,0,2251,2252,3,358,179,0,2252,357, - 1,0,0,0,2253,2254,5,537,0,0,2254,359,1,0,0,0,2255,2256,5,538,0,0, - 2256,361,1,0,0,0,2257,2258,7,38,0,0,2258,363,1,0,0,0,2259,2260,7, - 39,0,0,2260,365,1,0,0,0,2261,2262,7,40,0,0,2262,367,1,0,0,0,2263, - 2264,7,41,0,0,2264,369,1,0,0,0,2265,2266,7,42,0,0,2266,371,1,0,0, - 0,2267,2268,7,43,0,0,2268,373,1,0,0,0,2269,2270,7,44,0,0,2270,375, - 1,0,0,0,270,379,386,389,403,421,425,434,439,446,457,466,478,481, - 488,491,499,503,508,511,518,526,530,542,550,554,586,589,594,598, - 602,606,615,620,624,628,632,635,639,644,650,655,660,663,667,671, + 1,133,1,133,3,133,1938,8,133,1,133,1,133,1,133,5,133,1943,8,133, + 10,133,12,133,1946,9,133,3,133,1948,8,133,1,133,1,133,1,133,1,133, + 1,133,1,133,1,133,1,133,1,133,3,133,1959,8,133,1,133,1,133,1,133, + 1,133,1,133,5,133,1966,8,133,10,133,12,133,1969,9,133,1,134,1,134, + 1,135,1,135,3,135,1975,8,135,1,136,1,136,1,136,1,136,3,136,1981, + 8,136,1,137,1,137,1,138,1,138,1,139,1,139,3,139,1989,8,139,1,140, + 1,140,1,140,3,140,1994,8,140,1,141,1,141,3,141,1998,8,141,1,142, + 1,142,1,142,4,142,2003,8,142,11,142,12,142,2004,1,143,1,143,1,143, + 3,143,2010,8,143,1,144,1,144,1,144,1,144,1,144,1,145,3,145,2018, + 8,145,1,145,1,145,3,145,2022,8,145,1,146,3,146,2025,8,146,1,146, + 1,146,3,146,2029,8,146,1,147,1,147,1,147,1,148,1,148,4,148,2036, + 8,148,11,148,12,148,2037,1,148,3,148,2041,8,148,1,149,1,149,1,149, + 1,149,1,150,1,150,1,150,5,150,2050,8,150,10,150,12,150,2053,9,150, + 1,151,1,151,1,151,3,151,2058,8,151,1,152,1,152,1,153,1,153,1,154, + 1,154,1,154,1,154,1,154,1,155,1,155,1,156,1,156,1,157,1,157,1,157, + 3,157,2076,8,157,1,158,1,158,1,158,3,158,2081,8,158,1,159,1,159, + 1,159,3,159,2086,8,159,1,159,1,159,1,159,1,159,1,159,3,159,2093, + 8,159,3,159,2095,8,159,1,160,1,160,1,160,3,160,2100,8,160,1,160, + 1,160,1,160,1,160,1,160,3,160,2107,8,160,3,160,2109,8,160,1,161, + 1,161,1,161,3,161,2114,8,161,1,161,1,161,1,161,1,161,1,161,3,161, + 2121,8,161,3,161,2123,8,161,1,162,1,162,1,162,3,162,2128,8,162,1, + 162,1,162,1,162,1,162,1,162,3,162,2135,8,162,3,162,2137,8,162,1, + 163,1,163,1,163,5,163,2142,8,163,10,163,12,163,2145,9,163,1,164, + 1,164,1,164,1,165,1,165,1,165,1,165,1,166,1,166,1,166,1,167,1,167, + 1,167,1,167,5,167,2161,8,167,10,167,12,167,2164,9,167,1,167,1,167, + 1,168,1,168,3,168,2170,8,168,1,168,3,168,2173,8,168,1,169,1,169, + 1,169,3,169,2178,8,169,1,170,1,170,1,170,1,170,3,170,2184,8,170, + 1,171,1,171,1,171,1,171,1,171,1,171,3,171,2192,8,171,1,172,1,172, + 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172, + 1,172,3,172,2208,8,172,1,173,1,173,1,173,1,173,1,173,1,173,1,173, + 3,173,2217,8,173,1,174,1,174,1,175,1,175,1,176,1,176,1,176,1,176, + 3,176,2227,8,176,1,176,1,176,1,176,1,176,1,176,3,176,2234,8,176, + 1,176,3,176,2237,8,176,1,177,1,177,1,177,1,178,1,178,1,179,1,179, + 1,180,1,180,1,181,1,181,1,182,1,182,1,183,1,183,1,184,1,184,1,185, + 1,185,1,186,1,186,1,186,1,2143,5,156,176,258,264,266,187,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,0,45,2,0,109,109,450,450, + 3,0,45,45,128,128,188,188,4,0,42,42,90,90,422,422,464,464,2,0,441, + 441,447,447,2,0,151,151,170,170,2,0,437,437,489,489,2,0,482,485, + 487,487,3,0,32,32,91,91,244,244,11,0,28,29,35,35,46,46,92,92,178, + 179,344,344,360,360,378,378,381,381,387,387,416,417,2,0,433,433, + 435,435,4,0,101,102,115,115,144,144,246,246,2,0,13,13,231,231,2, + 0,455,455,462,462,3,0,5,5,270,270,444,444,3,0,266,266,455,455,462, + 462,3,0,425,425,458,458,477,477,3,0,330,330,465,465,481,481,2,0, + 440,440,490,490,2,0,183,183,265,265,3,0,130,130,180,180,402,402, + 4,0,152,152,174,174,201,201,317,317,3,0,445,445,459,459,499,499, + 4,0,250,250,446,446,494,496,498,498,2,0,74,74,320,320,3,0,459,459, + 492,492,499,499,2,0,439,439,450,450,2,0,457,457,467,467,4,0,140, + 140,244,244,397,397,404,404,2,0,19,19,369,369,2,0,5,5,11,11,2,0, + 509,509,529,530,4,0,452,452,527,527,531,531,534,534,2,0,529,530, + 532,532,1,0,529,530,1,0,538,539,2,0,538,538,541,541,4,0,452,452, + 527,527,529,531,533,534,3,0,241,241,508,509,529,530,2,0,140,140, + 397,397,2,0,5,5,113,113,10,0,97,97,165,165,222,222,229,229,334,334, + 436,436,470,470,472,472,488,488,502,502,15,0,97,97,165,165,222,222, + 229,229,334,334,427,427,436,436,442,442,448,449,454,454,460,460, + 470,475,488,488,491,491,502,503,11,0,5,5,13,13,33,33,78,78,84,85, + 113,113,200,200,207,208,389,389,413,413,527,527,55,0,4,4,13,13,23, + 23,38,38,41,41,43,44,54,54,56,56,69,69,75,75,78,78,84,85,91,91,98, + 99,107,107,119,119,134,134,139,139,143,143,145,145,160,160,165,165, + 167,167,194,194,197,197,199,199,201,201,205,205,207,209,214,214, + 220,220,222,223,229,229,243,243,245,245,264,264,276,276,281,281, + 283,283,293,293,317,317,321,323,334,334,357,358,364,364,367,367, + 378,380,395,395,398,399,408,408,419,420,436,436,469,469,488,488, + 502,502,1,0,437,504,2460,0,377,1,0,0,0,2,387,1,0,0,0,4,401,1,0,0, + 0,6,403,1,0,0,0,8,419,1,0,0,0,10,423,1,0,0,0,12,425,1,0,0,0,14,428, + 1,0,0,0,16,439,1,0,0,0,18,447,1,0,0,0,20,455,1,0,0,0,22,457,1,0, + 0,0,24,509,1,0,0,0,26,511,1,0,0,0,28,518,1,0,0,0,30,522,1,0,0,0, + 32,526,1,0,0,0,34,530,1,0,0,0,36,584,1,0,0,0,38,590,1,0,0,0,40,596, + 1,0,0,0,42,598,1,0,0,0,44,640,1,0,0,0,46,654,1,0,0,0,48,656,1,0, + 0,0,50,667,1,0,0,0,52,671,1,0,0,0,54,673,1,0,0,0,56,721,1,0,0,0, + 58,723,1,0,0,0,60,727,1,0,0,0,62,735,1,0,0,0,64,743,1,0,0,0,66,747, + 1,0,0,0,68,754,1,0,0,0,70,782,1,0,0,0,72,784,1,0,0,0,74,794,1,0, + 0,0,76,796,1,0,0,0,78,803,1,0,0,0,80,805,1,0,0,0,82,813,1,0,0,0, + 84,821,1,0,0,0,86,823,1,0,0,0,88,827,1,0,0,0,90,831,1,0,0,0,92,854, + 1,0,0,0,94,858,1,0,0,0,96,860,1,0,0,0,98,876,1,0,0,0,100,878,1,0, + 0,0,102,883,1,0,0,0,104,895,1,0,0,0,106,914,1,0,0,0,108,934,1,0, + 0,0,110,945,1,0,0,0,112,947,1,0,0,0,114,960,1,0,0,0,116,967,1,0, + 0,0,118,970,1,0,0,0,120,979,1,0,0,0,122,983,1,0,0,0,124,987,1,0, + 0,0,126,990,1,0,0,0,128,998,1,0,0,0,130,1003,1,0,0,0,132,1020,1, + 0,0,0,134,1027,1,0,0,0,136,1037,1,0,0,0,138,1046,1,0,0,0,140,1056, + 1,0,0,0,142,1075,1,0,0,0,144,1077,1,0,0,0,146,1090,1,0,0,0,148,1093, + 1,0,0,0,150,1102,1,0,0,0,152,1113,1,0,0,0,154,1126,1,0,0,0,156,1161, + 1,0,0,0,158,1180,1,0,0,0,160,1189,1,0,0,0,162,1198,1,0,0,0,164,1217, + 1,0,0,0,166,1239,1,0,0,0,168,1241,1,0,0,0,170,1271,1,0,0,0,172,1285, + 1,0,0,0,174,1287,1,0,0,0,176,1301,1,0,0,0,178,1327,1,0,0,0,180,1370, + 1,0,0,0,182,1372,1,0,0,0,184,1378,1,0,0,0,186,1380,1,0,0,0,188,1385, + 1,0,0,0,190,1390,1,0,0,0,192,1402,1,0,0,0,194,1419,1,0,0,0,196,1421, + 1,0,0,0,198,1423,1,0,0,0,200,1432,1,0,0,0,202,1434,1,0,0,0,204,1437, + 1,0,0,0,206,1487,1,0,0,0,208,1489,1,0,0,0,210,1492,1,0,0,0,212,1494, + 1,0,0,0,214,1501,1,0,0,0,216,1503,1,0,0,0,218,1505,1,0,0,0,220,1508, + 1,0,0,0,222,1517,1,0,0,0,224,1522,1,0,0,0,226,1536,1,0,0,0,228,1564, + 1,0,0,0,230,1574,1,0,0,0,232,1582,1,0,0,0,234,1587,1,0,0,0,236,1613, + 1,0,0,0,238,1615,1,0,0,0,240,1624,1,0,0,0,242,1635,1,0,0,0,244,1647, + 1,0,0,0,246,1673,1,0,0,0,248,1675,1,0,0,0,250,1693,1,0,0,0,252,1695, + 1,0,0,0,254,1700,1,0,0,0,256,1703,1,0,0,0,258,1717,1,0,0,0,260,1803, + 1,0,0,0,262,1834,1,0,0,0,264,1840,1,0,0,0,266,1958,1,0,0,0,268,1970, + 1,0,0,0,270,1974,1,0,0,0,272,1980,1,0,0,0,274,1982,1,0,0,0,276,1984, + 1,0,0,0,278,1988,1,0,0,0,280,1990,1,0,0,0,282,1995,1,0,0,0,284,2002, + 1,0,0,0,286,2006,1,0,0,0,288,2011,1,0,0,0,290,2021,1,0,0,0,292,2024, + 1,0,0,0,294,2030,1,0,0,0,296,2040,1,0,0,0,298,2042,1,0,0,0,300,2046, + 1,0,0,0,302,2057,1,0,0,0,304,2059,1,0,0,0,306,2061,1,0,0,0,308,2063, + 1,0,0,0,310,2068,1,0,0,0,312,2070,1,0,0,0,314,2072,1,0,0,0,316,2077, + 1,0,0,0,318,2094,1,0,0,0,320,2108,1,0,0,0,322,2122,1,0,0,0,324,2136, + 1,0,0,0,326,2138,1,0,0,0,328,2146,1,0,0,0,330,2149,1,0,0,0,332,2153, + 1,0,0,0,334,2156,1,0,0,0,336,2167,1,0,0,0,338,2177,1,0,0,0,340,2183, + 1,0,0,0,342,2191,1,0,0,0,344,2207,1,0,0,0,346,2216,1,0,0,0,348,2218, + 1,0,0,0,350,2220,1,0,0,0,352,2236,1,0,0,0,354,2238,1,0,0,0,356,2241, + 1,0,0,0,358,2243,1,0,0,0,360,2245,1,0,0,0,362,2247,1,0,0,0,364,2249, + 1,0,0,0,366,2251,1,0,0,0,368,2253,1,0,0,0,370,2255,1,0,0,0,372,2257, + 1,0,0,0,374,376,3,2,1,0,375,374,1,0,0,0,376,379,1,0,0,0,377,375, + 1,0,0,0,377,378,1,0,0,0,378,380,1,0,0,0,379,377,1,0,0,0,380,381, + 5,0,0,1,381,1,1,0,0,0,382,384,3,4,2,0,383,385,5,521,0,0,384,383, + 1,0,0,0,384,385,1,0,0,0,385,388,1,0,0,0,386,388,3,6,3,0,387,382, + 1,0,0,0,387,386,1,0,0,0,388,3,1,0,0,0,389,402,3,8,4,0,390,402,3, + 10,5,0,391,402,3,12,6,0,392,402,3,14,7,0,393,402,3,20,10,0,394,402, + 3,24,12,0,395,402,3,26,13,0,396,402,3,28,14,0,397,402,3,30,15,0, + 398,402,3,32,16,0,399,402,3,34,17,0,400,402,3,36,18,0,401,389,1, + 0,0,0,401,390,1,0,0,0,401,391,1,0,0,0,401,392,1,0,0,0,401,393,1, + 0,0,0,401,394,1,0,0,0,401,395,1,0,0,0,401,396,1,0,0,0,401,397,1, + 0,0,0,401,398,1,0,0,0,401,399,1,0,0,0,401,400,1,0,0,0,402,5,1,0, + 0,0,403,404,5,521,0,0,404,7,1,0,0,0,405,420,3,40,20,0,406,420,3, + 102,51,0,407,420,3,104,52,0,408,420,3,106,53,0,409,420,3,100,50, + 0,410,420,3,112,56,0,411,420,3,126,63,0,412,420,3,128,64,0,413,420, + 3,130,65,0,414,420,3,132,66,0,415,420,3,134,67,0,416,420,3,136,68, + 0,417,420,3,138,69,0,418,420,3,140,70,0,419,405,1,0,0,0,419,406, + 1,0,0,0,419,407,1,0,0,0,419,408,1,0,0,0,419,409,1,0,0,0,419,410, + 1,0,0,0,419,411,1,0,0,0,419,412,1,0,0,0,419,413,1,0,0,0,419,414, + 1,0,0,0,419,415,1,0,0,0,419,416,1,0,0,0,419,417,1,0,0,0,419,418, + 1,0,0,0,420,9,1,0,0,0,421,424,3,156,78,0,422,424,3,142,71,0,423, + 421,1,0,0,0,423,422,1,0,0,0,424,11,1,0,0,0,425,426,7,0,0,0,426,427, + 3,320,160,0,427,13,1,0,0,0,428,432,5,135,0,0,429,433,3,16,8,0,430, + 431,5,479,0,0,431,433,5,146,0,0,432,429,1,0,0,0,432,430,1,0,0,0, + 432,433,1,0,0,0,433,437,1,0,0,0,434,438,3,10,5,0,435,438,3,144,72, + 0,436,438,3,154,77,0,437,434,1,0,0,0,437,435,1,0,0,0,437,436,1,0, + 0,0,438,15,1,0,0,0,439,444,3,18,9,0,440,441,5,520,0,0,441,443,3, + 18,9,0,442,440,1,0,0,0,443,446,1,0,0,0,444,442,1,0,0,0,444,445,1, + 0,0,0,445,17,1,0,0,0,446,444,1,0,0,0,447,448,7,1,0,0,448,19,1,0, + 0,0,449,450,5,410,0,0,450,451,5,441,0,0,451,456,3,310,155,0,452, + 453,5,410,0,0,453,456,3,314,157,0,454,456,3,22,11,0,455,449,1,0, + 0,0,455,452,1,0,0,0,455,454,1,0,0,0,456,21,1,0,0,0,457,458,5,410, + 0,0,458,459,5,227,0,0,459,464,3,326,163,0,460,461,5,520,0,0,461, + 463,3,326,163,0,462,460,1,0,0,0,463,466,1,0,0,0,464,462,1,0,0,0, + 464,465,1,0,0,0,465,23,1,0,0,0,466,464,1,0,0,0,467,468,5,341,0,0, + 468,510,7,2,0,0,469,470,5,341,0,0,470,471,5,76,0,0,471,510,7,3,0, + 0,472,473,5,341,0,0,473,476,5,374,0,0,474,475,7,4,0,0,475,477,3, + 314,157,0,476,474,1,0,0,0,476,477,1,0,0,0,477,479,1,0,0,0,478,480, + 3,262,131,0,479,478,1,0,0,0,479,480,1,0,0,0,480,510,1,0,0,0,481, + 482,5,341,0,0,482,483,5,58,0,0,483,486,7,4,0,0,484,487,3,322,161, + 0,485,487,3,320,160,0,486,484,1,0,0,0,486,485,1,0,0,0,487,489,1, + 0,0,0,488,490,3,262,131,0,489,488,1,0,0,0,489,490,1,0,0,0,490,510, + 1,0,0,0,491,492,5,341,0,0,492,497,5,72,0,0,493,494,5,373,0,0,494, + 498,3,320,160,0,495,496,5,501,0,0,496,498,3,322,161,0,497,493,1, + 0,0,0,497,495,1,0,0,0,498,510,1,0,0,0,499,501,5,341,0,0,500,502, + 5,411,0,0,501,500,1,0,0,0,501,502,1,0,0,0,502,503,1,0,0,0,503,510, + 5,154,0,0,504,506,5,341,0,0,505,507,5,152,0,0,506,505,1,0,0,0,506, + 507,1,0,0,0,507,508,1,0,0,0,508,510,5,227,0,0,509,467,1,0,0,0,509, + 469,1,0,0,0,509,472,1,0,0,0,509,481,1,0,0,0,509,491,1,0,0,0,509, + 499,1,0,0,0,509,504,1,0,0,0,510,25,1,0,0,0,511,512,5,468,0,0,512, + 513,5,226,0,0,513,516,3,326,163,0,514,515,5,433,0,0,515,517,3,334, + 167,0,516,514,1,0,0,0,516,517,1,0,0,0,517,27,1,0,0,0,518,519,5,500, + 0,0,519,520,5,226,0,0,520,521,3,326,163,0,521,29,1,0,0,0,522,524, + 5,340,0,0,523,525,3,336,168,0,524,523,1,0,0,0,524,525,1,0,0,0,525, + 31,1,0,0,0,526,528,5,312,0,0,527,529,3,338,169,0,528,527,1,0,0,0, + 528,529,1,0,0,0,529,33,1,0,0,0,530,531,7,5,0,0,531,532,5,463,0,0, + 532,533,3,110,55,0,533,35,1,0,0,0,534,535,5,437,0,0,535,536,5,463, + 0,0,536,537,5,433,0,0,537,540,3,38,19,0,538,539,5,17,0,0,539,541, + 3,326,163,0,540,538,1,0,0,0,540,541,1,0,0,0,541,585,1,0,0,0,542, + 543,5,437,0,0,543,544,5,456,0,0,544,545,5,433,0,0,545,548,3,38,19, + 0,546,547,5,17,0,0,547,549,3,326,163,0,548,546,1,0,0,0,548,549,1, + 0,0,0,549,552,1,0,0,0,550,551,5,311,0,0,551,553,3,326,163,0,552, + 550,1,0,0,0,552,553,1,0,0,0,553,585,1,0,0,0,554,555,5,437,0,0,555, + 556,7,6,0,0,556,557,5,433,0,0,557,558,3,38,19,0,558,559,5,311,0, + 0,559,560,3,326,163,0,560,585,1,0,0,0,561,562,5,437,0,0,562,563, + 5,486,0,0,563,585,3,38,19,0,564,565,5,437,0,0,565,566,5,453,0,0, + 566,567,5,456,0,0,567,568,5,433,0,0,568,569,3,38,19,0,569,570,5, + 311,0,0,570,571,3,326,163,0,571,572,5,466,0,0,572,573,3,326,163, + 0,573,585,1,0,0,0,574,575,5,437,0,0,575,576,5,443,0,0,576,577,5, + 456,0,0,577,578,5,433,0,0,578,579,3,38,19,0,579,580,5,146,0,0,580, + 581,3,326,163,0,581,582,5,17,0,0,582,583,3,326,163,0,583,585,1,0, + 0,0,584,534,1,0,0,0,584,542,1,0,0,0,584,554,1,0,0,0,584,561,1,0, + 0,0,584,564,1,0,0,0,584,574,1,0,0,0,585,37,1,0,0,0,586,588,5,534, + 0,0,587,586,1,0,0,0,587,588,1,0,0,0,588,589,1,0,0,0,589,591,3,326, + 163,0,590,587,1,0,0,0,591,592,1,0,0,0,592,590,1,0,0,0,592,593,1, + 0,0,0,593,39,1,0,0,0,594,597,3,42,21,0,595,597,3,44,22,0,596,594, + 1,0,0,0,596,595,1,0,0,0,597,41,1,0,0,0,598,600,5,72,0,0,599,601, + 5,497,0,0,600,599,1,0,0,0,600,601,1,0,0,0,601,602,1,0,0,0,602,604, + 5,373,0,0,603,605,3,330,165,0,604,603,1,0,0,0,604,605,1,0,0,0,605, + 606,1,0,0,0,606,607,3,318,159,0,607,608,5,516,0,0,608,613,3,46,23, + 0,609,610,5,520,0,0,610,612,3,46,23,0,611,609,1,0,0,0,612,615,1, + 0,0,0,613,611,1,0,0,0,613,614,1,0,0,0,614,618,1,0,0,0,615,613,1, + 0,0,0,616,617,5,520,0,0,617,619,3,80,40,0,618,616,1,0,0,0,618,619, + 1,0,0,0,619,622,1,0,0,0,620,621,5,520,0,0,621,623,3,82,41,0,622, + 620,1,0,0,0,622,623,1,0,0,0,623,626,1,0,0,0,624,625,5,520,0,0,625, + 627,3,86,43,0,626,624,1,0,0,0,626,627,1,0,0,0,627,628,1,0,0,0,628, + 631,5,517,0,0,629,630,5,59,0,0,630,632,5,537,0,0,631,629,1,0,0,0, + 631,632,1,0,0,0,632,634,1,0,0,0,633,635,3,88,44,0,634,633,1,0,0, + 0,634,635,1,0,0,0,635,636,1,0,0,0,636,638,3,328,164,0,637,639,3, + 96,48,0,638,637,1,0,0,0,638,639,1,0,0,0,639,43,1,0,0,0,640,641,5, + 72,0,0,641,643,5,373,0,0,642,644,3,330,165,0,643,642,1,0,0,0,643, + 644,1,0,0,0,644,645,1,0,0,0,645,646,3,318,159,0,646,649,3,328,164, + 0,647,648,5,17,0,0,648,650,3,156,78,0,649,647,1,0,0,0,649,650,1, + 0,0,0,650,45,1,0,0,0,651,655,3,48,24,0,652,655,3,72,36,0,653,655, + 3,76,38,0,654,651,1,0,0,0,654,652,1,0,0,0,654,653,1,0,0,0,655,47, + 1,0,0,0,656,657,3,50,25,0,657,659,3,56,28,0,658,660,3,70,35,0,659, + 658,1,0,0,0,659,660,1,0,0,0,660,663,1,0,0,0,661,662,5,59,0,0,662, + 664,5,537,0,0,663,661,1,0,0,0,663,664,1,0,0,0,664,49,1,0,0,0,665, + 668,3,326,163,0,666,668,3,256,128,0,667,665,1,0,0,0,667,666,1,0, + 0,0,668,51,1,0,0,0,669,672,3,326,163,0,670,672,4,26,0,0,671,669, + 1,0,0,0,671,670,1,0,0,0,672,53,1,0,0,0,673,674,5,516,0,0,674,679, + 3,52,26,0,675,676,5,520,0,0,676,678,3,52,26,0,677,675,1,0,0,0,678, + 681,1,0,0,0,679,677,1,0,0,0,679,680,1,0,0,0,680,682,1,0,0,0,681, + 679,1,0,0,0,682,683,5,517,0,0,683,55,1,0,0,0,684,722,7,7,0,0,685, + 687,7,8,0,0,686,688,3,58,29,0,687,686,1,0,0,0,687,688,1,0,0,0,688, + 722,1,0,0,0,689,691,5,379,0,0,690,692,3,58,29,0,691,690,1,0,0,0, + 691,692,1,0,0,0,692,699,1,0,0,0,693,695,7,9,0,0,694,696,5,206,0, + 0,695,694,1,0,0,0,695,696,1,0,0,0,696,697,1,0,0,0,697,698,5,378, + 0,0,698,700,5,504,0,0,699,693,1,0,0,0,699,700,1,0,0,0,700,722,1, + 0,0,0,701,703,7,10,0,0,702,704,3,60,30,0,703,702,1,0,0,0,703,704, + 1,0,0,0,704,722,1,0,0,0,705,707,7,11,0,0,706,708,3,64,32,0,707,706, + 1,0,0,0,707,708,1,0,0,0,708,722,1,0,0,0,709,711,5,469,0,0,710,712, + 3,66,33,0,711,710,1,0,0,0,711,712,1,0,0,0,712,722,1,0,0,0,713,715, + 5,321,0,0,714,716,3,68,34,0,715,714,1,0,0,0,715,716,1,0,0,0,716, + 722,1,0,0,0,717,719,5,294,0,0,718,720,3,62,31,0,719,718,1,0,0,0, + 719,720,1,0,0,0,720,722,1,0,0,0,721,684,1,0,0,0,721,685,1,0,0,0, + 721,689,1,0,0,0,721,701,1,0,0,0,721,705,1,0,0,0,721,709,1,0,0,0, + 721,713,1,0,0,0,721,717,1,0,0,0,722,57,1,0,0,0,723,724,5,516,0,0, + 724,725,3,358,179,0,725,726,5,517,0,0,726,59,1,0,0,0,727,728,5,516, + 0,0,728,731,3,358,179,0,729,730,5,520,0,0,730,732,3,358,179,0,731, + 729,1,0,0,0,731,732,1,0,0,0,732,733,1,0,0,0,733,734,5,517,0,0,734, + 61,1,0,0,0,735,736,5,516,0,0,736,739,3,356,178,0,737,738,5,520,0, + 0,738,740,3,356,178,0,739,737,1,0,0,0,739,740,1,0,0,0,740,741,1, + 0,0,0,741,742,5,517,0,0,742,63,1,0,0,0,743,744,5,507,0,0,744,745, + 3,56,28,0,745,746,5,506,0,0,746,65,1,0,0,0,747,748,5,507,0,0,748, + 749,3,56,28,0,749,750,5,520,0,0,750,751,3,56,28,0,751,752,1,0,0, + 0,752,753,5,506,0,0,753,67,1,0,0,0,754,755,5,507,0,0,755,756,3,52, + 26,0,756,763,3,56,28,0,757,758,5,520,0,0,758,759,3,52,26,0,759,760, + 3,56,28,0,760,762,1,0,0,0,761,757,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,767, + 5,506,0,0,767,69,1,0,0,0,768,769,5,64,0,0,769,771,3,84,42,0,770, + 768,1,0,0,0,770,771,1,0,0,0,771,772,1,0,0,0,772,773,5,288,0,0,773, + 776,5,466,0,0,774,775,5,241,0,0,775,777,5,125,0,0,776,774,1,0,0, + 0,776,777,1,0,0,0,777,783,1,0,0,0,778,780,5,241,0,0,779,778,1,0, + 0,0,779,780,1,0,0,0,780,781,1,0,0,0,781,783,5,244,0,0,782,770,1, + 0,0,0,782,779,1,0,0,0,783,71,1,0,0,0,784,785,3,50,25,0,785,786,3, + 56,28,0,786,789,5,218,0,0,787,788,5,151,0,0,788,790,3,74,37,0,789, + 787,1,0,0,0,789,790,1,0,0,0,790,792,1,0,0,0,791,793,5,423,0,0,792, + 791,1,0,0,0,792,793,1,0,0,0,793,73,1,0,0,0,794,795,5,537,0,0,795, + 75,1,0,0,0,796,797,3,50,25,0,797,798,5,17,0,0,798,801,3,78,39,0, + 799,800,5,59,0,0,800,802,5,537,0,0,801,799,1,0,0,0,801,802,1,0,0, + 0,802,77,1,0,0,0,803,804,3,256,128,0,804,79,1,0,0,0,805,806,5,424, + 0,0,806,807,5,146,0,0,807,808,3,52,26,0,808,809,5,17,0,0,809,810, + 3,256,128,0,810,81,1,0,0,0,811,812,5,64,0,0,812,814,3,84,42,0,813, + 811,1,0,0,0,813,814,1,0,0,0,814,815,1,0,0,0,815,816,5,288,0,0,816, + 817,5,466,0,0,817,818,3,54,27,0,818,819,5,241,0,0,819,820,5,125, + 0,0,820,83,1,0,0,0,821,822,3,302,151,0,822,85,1,0,0,0,823,824,5, + 277,0,0,824,825,5,146,0,0,825,826,5,371,0,0,826,87,1,0,0,0,827,828, + 5,269,0,0,828,829,5,34,0,0,829,830,3,90,45,0,830,89,1,0,0,0,831, + 832,5,516,0,0,832,837,3,92,46,0,833,834,5,520,0,0,834,836,3,92,46, + 0,835,833,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,841,5,517,0,0,841,91,1,0,0, + 0,842,855,3,52,26,0,843,844,5,516,0,0,844,849,3,94,47,0,845,846, + 5,520,0,0,846,848,3,94,47,0,847,845,1,0,0,0,848,851,1,0,0,0,849, + 847,1,0,0,0,849,850,1,0,0,0,850,852,1,0,0,0,851,849,1,0,0,0,852, + 853,5,517,0,0,853,855,1,0,0,0,854,842,1,0,0,0,854,843,1,0,0,0,855, + 93,1,0,0,0,856,859,3,278,139,0,857,859,3,352,176,0,858,856,1,0,0, + 0,858,857,1,0,0,0,859,95,1,0,0,0,860,861,5,202,0,0,861,870,3,320, + 160,0,862,866,5,516,0,0,863,865,3,98,49,0,864,863,1,0,0,0,865,868, + 1,0,0,0,866,864,1,0,0,0,866,867,1,0,0,0,867,869,1,0,0,0,868,866, + 1,0,0,0,869,871,5,517,0,0,870,862,1,0,0,0,870,871,1,0,0,0,871,97, + 1,0,0,0,872,873,7,12,0,0,873,877,7,13,0,0,874,875,7,14,0,0,875,877, + 7,15,0,0,876,872,1,0,0,0,876,874,1,0,0,0,877,99,1,0,0,0,878,879, + 5,72,0,0,879,880,5,441,0,0,880,881,3,312,156,0,881,882,3,328,164, + 0,882,101,1,0,0,0,883,884,5,72,0,0,884,886,5,447,0,0,885,887,3,330, + 165,0,886,885,1,0,0,0,886,887,1,0,0,0,887,888,1,0,0,0,888,891,3, + 316,158,0,889,890,5,59,0,0,890,892,5,537,0,0,891,889,1,0,0,0,891, + 892,1,0,0,0,892,893,1,0,0,0,893,894,3,328,164,0,894,103,1,0,0,0, + 895,897,5,72,0,0,896,898,5,497,0,0,897,896,1,0,0,0,897,898,1,0,0, + 0,898,899,1,0,0,0,899,901,5,501,0,0,900,902,3,330,165,0,901,900, + 1,0,0,0,901,902,1,0,0,0,902,903,1,0,0,0,903,905,3,324,162,0,904, + 906,3,54,27,0,905,904,1,0,0,0,905,906,1,0,0,0,906,909,1,0,0,0,907, + 908,5,59,0,0,908,910,5,537,0,0,909,907,1,0,0,0,909,910,1,0,0,0,910, + 911,1,0,0,0,911,912,5,17,0,0,912,913,3,156,78,0,913,105,1,0,0,0, + 914,918,5,72,0,0,915,919,5,497,0,0,916,917,5,497,0,0,917,919,5,370, + 0,0,918,915,1,0,0,0,918,916,1,0,0,0,918,919,1,0,0,0,919,920,1,0, + 0,0,920,922,5,153,0,0,921,923,3,330,165,0,922,921,1,0,0,0,922,923, + 1,0,0,0,923,924,1,0,0,0,924,925,3,268,134,0,925,926,5,17,0,0,926, + 929,3,302,151,0,927,928,5,195,0,0,928,930,7,16,0,0,929,927,1,0,0, + 0,929,930,1,0,0,0,930,932,1,0,0,0,931,933,3,108,54,0,932,931,1,0, + 0,0,932,933,1,0,0,0,933,107,1,0,0,0,934,935,5,412,0,0,935,936,5, + 463,0,0,936,942,3,110,55,0,937,938,5,520,0,0,938,939,5,463,0,0,939, + 941,3,110,55,0,940,937,1,0,0,0,941,944,1,0,0,0,942,940,1,0,0,0,942, + 943,1,0,0,0,943,109,1,0,0,0,944,942,1,0,0,0,945,946,5,537,0,0,946, + 111,1,0,0,0,947,948,5,8,0,0,948,950,5,373,0,0,949,951,3,332,166, + 0,950,949,1,0,0,0,950,951,1,0,0,0,951,952,1,0,0,0,952,958,3,320, + 160,0,953,959,3,114,57,0,954,959,3,116,58,0,955,959,3,118,59,0,956, + 959,3,120,60,0,957,959,3,122,61,0,958,953,1,0,0,0,958,954,1,0,0, + 0,958,955,1,0,0,0,958,956,1,0,0,0,958,957,1,0,0,0,959,113,1,0,0, + 0,960,962,5,311,0,0,961,963,3,326,163,0,962,961,1,0,0,0,962,963, + 1,0,0,0,963,964,1,0,0,0,964,965,5,388,0,0,965,966,3,326,163,0,966, + 115,1,0,0,0,967,968,5,340,0,0,968,969,3,334,167,0,969,117,1,0,0, + 0,970,971,5,437,0,0,971,972,5,64,0,0,972,973,3,84,42,0,973,974,5, + 288,0,0,974,975,5,466,0,0,975,977,3,54,27,0,976,978,3,124,62,0,977, + 976,1,0,0,0,977,978,1,0,0,0,978,119,1,0,0,0,979,980,5,116,0,0,980, + 981,5,64,0,0,981,982,3,84,42,0,982,121,1,0,0,0,983,984,5,437,0,0, + 984,985,5,403,0,0,985,986,3,54,27,0,986,123,1,0,0,0,987,988,5,241, + 0,0,988,989,5,125,0,0,989,125,1,0,0,0,990,991,5,8,0,0,991,992,5, + 501,0,0,992,996,3,322,161,0,993,997,3,114,57,0,994,995,5,17,0,0, + 995,997,3,156,78,0,996,993,1,0,0,0,996,994,1,0,0,0,997,127,1,0,0, + 0,998,999,5,8,0,0,999,1000,5,447,0,0,1000,1001,3,314,157,0,1001, + 1002,3,116,58,0,1002,129,1,0,0,0,1003,1007,5,8,0,0,1004,1008,5,497, + 0,0,1005,1006,5,497,0,0,1006,1008,5,370,0,0,1007,1004,1,0,0,0,1007, + 1005,1,0,0,0,1007,1008,1,0,0,0,1008,1009,1,0,0,0,1009,1011,5,153, + 0,0,1010,1012,3,332,166,0,1011,1010,1,0,0,0,1011,1012,1,0,0,0,1012, + 1013,1,0,0,0,1013,1014,3,270,135,0,1014,1015,5,17,0,0,1015,1018, + 3,302,151,0,1016,1017,5,195,0,0,1017,1019,7,16,0,0,1018,1016,1,0, + 0,0,1018,1019,1,0,0,0,1019,131,1,0,0,0,1020,1021,5,116,0,0,1021, + 1023,5,441,0,0,1022,1024,3,332,166,0,1023,1022,1,0,0,0,1023,1024, + 1,0,0,0,1024,1025,1,0,0,0,1025,1026,3,310,155,0,1026,133,1,0,0,0, + 1027,1029,5,116,0,0,1028,1030,5,497,0,0,1029,1028,1,0,0,0,1029,1030, + 1,0,0,0,1030,1031,1,0,0,0,1031,1033,5,373,0,0,1032,1034,3,332,166, + 0,1033,1032,1,0,0,0,1033,1034,1,0,0,0,1034,1035,1,0,0,0,1035,1036, + 3,320,160,0,1036,135,1,0,0,0,1037,1038,5,116,0,0,1038,1040,5,447, + 0,0,1039,1041,3,332,166,0,1040,1039,1,0,0,0,1040,1041,1,0,0,0,1041, + 1042,1,0,0,0,1042,1044,3,314,157,0,1043,1045,7,17,0,0,1044,1043, + 1,0,0,0,1044,1045,1,0,0,0,1045,137,1,0,0,0,1046,1048,5,116,0,0,1047, + 1049,5,497,0,0,1048,1047,1,0,0,0,1048,1049,1,0,0,0,1049,1050,1,0, + 0,0,1050,1052,5,501,0,0,1051,1053,3,332,166,0,1052,1051,1,0,0,0, + 1052,1053,1,0,0,0,1053,1054,1,0,0,0,1054,1055,3,322,161,0,1055,139, + 1,0,0,0,1056,1060,5,116,0,0,1057,1061,5,497,0,0,1058,1059,5,497, + 0,0,1059,1061,5,370,0,0,1060,1057,1,0,0,0,1060,1058,1,0,0,0,1060, + 1061,1,0,0,0,1061,1062,1,0,0,0,1062,1064,5,153,0,0,1063,1065,3,332, + 166,0,1064,1063,1,0,0,0,1064,1065,1,0,0,0,1065,1066,1,0,0,0,1066, + 1067,3,270,135,0,1067,141,1,0,0,0,1068,1070,5,132,0,0,1069,1068, + 1,0,0,0,1069,1070,1,0,0,0,1070,1071,1,0,0,0,1071,1076,3,144,72,0, + 1072,1076,3,152,76,0,1073,1074,5,132,0,0,1074,1076,3,154,77,0,1075, + 1069,1,0,0,0,1075,1072,1,0,0,0,1075,1073,1,0,0,0,1076,143,1,0,0, + 0,1077,1078,5,177,0,0,1078,1079,7,18,0,0,1079,1088,3,320,160,0,1080, + 1082,3,146,73,0,1081,1080,1,0,0,0,1081,1082,1,0,0,0,1082,1084,1, + 0,0,0,1083,1085,3,54,27,0,1084,1083,1,0,0,0,1084,1085,1,0,0,0,1085, + 1086,1,0,0,0,1086,1089,3,156,78,0,1087,1089,3,148,74,0,1088,1081, + 1,0,0,0,1088,1087,1,0,0,0,1089,145,1,0,0,0,1090,1091,5,268,0,0,1091, + 1092,3,334,167,0,1092,147,1,0,0,0,1093,1094,5,414,0,0,1094,1099, + 3,150,75,0,1095,1096,5,520,0,0,1096,1098,3,150,75,0,1097,1095,1, + 0,0,0,1098,1101,1,0,0,0,1099,1097,1,0,0,0,1099,1100,1,0,0,0,1100, + 149,1,0,0,0,1101,1099,1,0,0,0,1102,1103,5,516,0,0,1103,1108,3,352, + 176,0,1104,1105,5,520,0,0,1105,1107,3,352,176,0,1106,1104,1,0,0, + 0,1107,1110,1,0,0,0,1108,1106,1,0,0,0,1108,1109,1,0,0,0,1109,1111, + 1,0,0,0,1110,1108,1,0,0,0,1111,1112,5,517,0,0,1112,151,1,0,0,0,1113, + 1114,5,24,0,0,1114,1115,5,354,0,0,1115,1116,5,340,0,0,1116,1120, + 5,521,0,0,1117,1118,3,144,72,0,1118,1119,5,521,0,0,1119,1121,1,0, + 0,0,1120,1117,1,0,0,0,1121,1122,1,0,0,0,1122,1120,1,0,0,0,1122,1123, + 1,0,0,0,1123,1124,1,0,0,0,1124,1125,5,122,0,0,1125,153,1,0,0,0,1126, + 1127,5,354,0,0,1127,1128,5,340,0,0,1128,1132,5,24,0,0,1129,1130, + 3,144,72,0,1130,1131,5,521,0,0,1131,1133,1,0,0,0,1132,1129,1,0,0, + 0,1133,1134,1,0,0,0,1134,1132,1,0,0,0,1134,1135,1,0,0,0,1135,1136, + 1,0,0,0,1136,1137,5,122,0,0,1137,155,1,0,0,0,1138,1139,6,78,-1,0, + 1139,1162,3,158,79,0,1140,1141,3,160,80,0,1141,1142,3,156,78,5,1142, + 1162,1,0,0,0,1143,1144,5,516,0,0,1144,1145,3,156,78,0,1145,1146, + 5,517,0,0,1146,1162,1,0,0,0,1147,1149,3,168,84,0,1148,1150,3,228, + 114,0,1149,1148,1,0,0,0,1149,1150,1,0,0,0,1150,1152,1,0,0,0,1151, + 1153,3,232,116,0,1152,1151,1,0,0,0,1152,1153,1,0,0,0,1153,1162,1, + 0,0,0,1154,1156,3,166,83,0,1155,1157,3,228,114,0,1156,1155,1,0,0, + 0,1156,1157,1,0,0,0,1157,1159,1,0,0,0,1158,1160,3,232,116,0,1159, + 1158,1,0,0,0,1159,1160,1,0,0,0,1160,1162,1,0,0,0,1161,1138,1,0,0, + 0,1161,1140,1,0,0,0,1161,1143,1,0,0,0,1161,1147,1,0,0,0,1161,1154, + 1,0,0,0,1162,1177,1,0,0,0,1163,1164,10,3,0,0,1164,1166,7,19,0,0, + 1165,1167,5,5,0,0,1166,1165,1,0,0,0,1166,1167,1,0,0,0,1167,1168, + 1,0,0,0,1168,1170,3,156,78,0,1169,1171,3,228,114,0,1170,1169,1,0, + 0,0,1170,1171,1,0,0,0,1171,1173,1,0,0,0,1172,1174,3,232,116,0,1173, + 1172,1,0,0,0,1173,1174,1,0,0,0,1174,1176,1,0,0,0,1175,1163,1,0,0, + 0,1176,1179,1,0,0,0,1177,1175,1,0,0,0,1177,1178,1,0,0,0,1178,157, + 1,0,0,0,1179,1177,1,0,0,0,1180,1181,5,414,0,0,1181,1186,3,256,128, + 0,1182,1183,5,520,0,0,1183,1185,3,256,128,0,1184,1182,1,0,0,0,1185, + 1188,1,0,0,0,1186,1184,1,0,0,0,1186,1187,1,0,0,0,1187,159,1,0,0, + 0,1188,1186,1,0,0,0,1189,1190,5,433,0,0,1190,1195,3,162,81,0,1191, + 1192,5,520,0,0,1192,1194,3,162,81,0,1193,1191,1,0,0,0,1194,1197, + 1,0,0,0,1195,1193,1,0,0,0,1195,1196,1,0,0,0,1196,161,1,0,0,0,1197, + 1195,1,0,0,0,1198,1210,3,164,82,0,1199,1200,5,516,0,0,1200,1205, + 3,52,26,0,1201,1202,5,520,0,0,1202,1204,3,52,26,0,1203,1201,1,0, + 0,0,1204,1207,1,0,0,0,1205,1203,1,0,0,0,1205,1206,1,0,0,0,1206,1208, + 1,0,0,0,1207,1205,1,0,0,0,1208,1209,5,517,0,0,1209,1211,1,0,0,0, + 1210,1199,1,0,0,0,1210,1211,1,0,0,0,1211,1212,1,0,0,0,1212,1213, + 5,17,0,0,1213,1214,5,516,0,0,1214,1215,3,156,78,0,1215,1216,5,517, + 0,0,1216,163,1,0,0,0,1217,1218,3,302,151,0,1218,165,1,0,0,0,1219, + 1221,3,168,84,0,1220,1222,3,174,87,0,1221,1220,1,0,0,0,1221,1222, + 1,0,0,0,1222,1224,1,0,0,0,1223,1225,3,202,101,0,1224,1223,1,0,0, + 0,1224,1225,1,0,0,0,1225,1227,1,0,0,0,1226,1228,3,204,102,0,1227, + 1226,1,0,0,0,1227,1228,1,0,0,0,1228,1230,1,0,0,0,1229,1231,3,218, + 109,0,1230,1229,1,0,0,0,1230,1231,1,0,0,0,1231,1233,1,0,0,0,1232, + 1234,3,220,110,0,1233,1232,1,0,0,0,1233,1234,1,0,0,0,1234,1240,1, + 0,0,0,1235,1236,3,168,84,0,1236,1237,3,174,87,0,1237,1238,3,226, + 113,0,1238,1240,1,0,0,0,1239,1219,1,0,0,0,1239,1235,1,0,0,0,1240, + 167,1,0,0,0,1241,1243,5,336,0,0,1242,1244,3,362,181,0,1243,1242, + 1,0,0,0,1243,1244,1,0,0,0,1244,1254,1,0,0,0,1245,1255,5,527,0,0, + 1246,1251,3,170,85,0,1247,1248,5,520,0,0,1248,1250,3,170,85,0,1249, + 1247,1,0,0,0,1250,1253,1,0,0,0,1251,1249,1,0,0,0,1251,1252,1,0,0, + 0,1252,1255,1,0,0,0,1253,1251,1,0,0,0,1254,1245,1,0,0,0,1254,1246, + 1,0,0,0,1255,169,1,0,0,0,1256,1272,3,172,86,0,1257,1262,3,52,26, + 0,1258,1260,5,17,0,0,1259,1258,1,0,0,0,1259,1260,1,0,0,0,1260,1261, + 1,0,0,0,1261,1263,3,256,128,0,1262,1259,1,0,0,0,1262,1263,1,0,0, + 0,1263,1272,1,0,0,0,1264,1269,3,256,128,0,1265,1267,5,17,0,0,1266, + 1265,1,0,0,0,1266,1267,1,0,0,0,1267,1268,1,0,0,0,1268,1270,3,52, + 26,0,1269,1266,1,0,0,0,1269,1270,1,0,0,0,1270,1272,1,0,0,0,1271, + 1256,1,0,0,0,1271,1257,1,0,0,0,1271,1264,1,0,0,0,1272,171,1,0,0, + 0,1273,1274,3,266,133,0,1274,1275,5,262,0,0,1275,1276,3,224,112, + 0,1276,1277,5,17,0,0,1277,1278,3,302,151,0,1278,1286,1,0,0,0,1279, + 1280,3,266,133,0,1280,1281,5,262,0,0,1281,1282,3,294,147,0,1282, + 1283,5,17,0,0,1283,1284,3,302,151,0,1284,1286,1,0,0,0,1285,1273, + 1,0,0,0,1285,1279,1,0,0,0,1286,173,1,0,0,0,1287,1288,5,151,0,0,1288, + 1289,3,176,88,0,1289,175,1,0,0,0,1290,1291,6,88,-1,0,1291,1296,3, + 178,89,0,1292,1293,5,520,0,0,1293,1295,3,178,89,0,1294,1292,1,0, + 0,0,1295,1298,1,0,0,0,1296,1294,1,0,0,0,1296,1297,1,0,0,0,1297,1302, + 1,0,0,0,1298,1296,1,0,0,0,1299,1302,3,186,93,0,1300,1302,3,188,94, + 0,1301,1290,1,0,0,0,1301,1299,1,0,0,0,1301,1300,1,0,0,0,1302,1324, + 1,0,0,0,1303,1304,10,3,0,0,1304,1305,5,73,0,0,1305,1306,5,185,0, + 0,1306,1323,3,176,88,4,1307,1309,10,4,0,0,1308,1310,5,233,0,0,1309, + 1308,1,0,0,0,1309,1310,1,0,0,0,1310,1312,1,0,0,0,1311,1313,7,20, + 0,0,1312,1311,1,0,0,0,1312,1313,1,0,0,0,1313,1315,1,0,0,0,1314,1316, + 5,261,0,0,1315,1314,1,0,0,0,1315,1316,1,0,0,0,1316,1317,1,0,0,0, + 1317,1318,5,185,0,0,1318,1320,3,176,88,0,1319,1321,3,200,100,0,1320, + 1319,1,0,0,0,1320,1321,1,0,0,0,1321,1323,1,0,0,0,1322,1303,1,0,0, + 0,1322,1307,1,0,0,0,1323,1326,1,0,0,0,1324,1322,1,0,0,0,1324,1325, + 1,0,0,0,1325,177,1,0,0,0,1326,1324,1,0,0,0,1327,1329,3,180,90,0, + 1328,1330,3,292,146,0,1329,1328,1,0,0,0,1329,1330,1,0,0,0,1330,179, + 1,0,0,0,1331,1333,5,373,0,0,1332,1331,1,0,0,0,1332,1333,1,0,0,0, + 1333,1334,1,0,0,0,1334,1336,3,320,160,0,1335,1337,3,182,91,0,1336, + 1335,1,0,0,0,1336,1337,1,0,0,0,1337,1371,1,0,0,0,1338,1340,3,322, + 161,0,1339,1341,3,182,91,0,1340,1339,1,0,0,0,1340,1341,1,0,0,0,1341, + 1371,1,0,0,0,1342,1343,5,198,0,0,1343,1344,5,373,0,0,1344,1345,5, + 516,0,0,1345,1346,3,270,135,0,1346,1347,5,516,0,0,1347,1352,3,272, + 136,0,1348,1349,5,520,0,0,1349,1351,3,272,136,0,1350,1348,1,0,0, + 0,1351,1354,1,0,0,0,1352,1350,1,0,0,0,1352,1353,1,0,0,0,1353,1355, + 1,0,0,0,1354,1352,1,0,0,0,1355,1356,5,517,0,0,1356,1357,5,517,0, + 0,1357,1371,1,0,0,0,1358,1360,5,198,0,0,1359,1358,1,0,0,0,1359,1360, + 1,0,0,0,1360,1361,1,0,0,0,1361,1362,5,516,0,0,1362,1363,3,156,78, + 0,1363,1364,5,517,0,0,1364,1371,1,0,0,0,1365,1366,5,405,0,0,1366, + 1367,5,516,0,0,1367,1368,3,256,128,0,1368,1369,5,517,0,0,1369,1371, + 1,0,0,0,1370,1332,1,0,0,0,1370,1338,1,0,0,0,1370,1342,1,0,0,0,1370, + 1359,1,0,0,0,1370,1365,1,0,0,0,1371,181,1,0,0,0,1372,1373,5,146, + 0,0,1373,1374,5,371,0,0,1374,1375,5,17,0,0,1375,1376,5,249,0,0,1376, + 1377,3,184,92,0,1377,183,1,0,0,0,1378,1379,3,256,128,0,1379,185, + 1,0,0,0,1380,1381,5,516,0,0,1381,1382,3,148,74,0,1382,1383,5,517, + 0,0,1383,1384,3,292,146,0,1384,187,1,0,0,0,1385,1386,5,373,0,0,1386, + 1387,5,516,0,0,1387,1388,3,190,95,0,1388,1389,5,517,0,0,1389,189, + 1,0,0,0,1390,1391,3,192,96,0,1391,1392,5,516,0,0,1392,1397,3,194, + 97,0,1393,1394,5,520,0,0,1394,1396,3,194,97,0,1395,1393,1,0,0,0, + 1396,1399,1,0,0,0,1397,1395,1,0,0,0,1397,1398,1,0,0,0,1398,1400, + 1,0,0,0,1399,1397,1,0,0,0,1400,1401,5,517,0,0,1401,191,1,0,0,0,1402, + 1403,7,21,0,0,1403,193,1,0,0,0,1404,1405,5,373,0,0,1405,1420,3,216, + 108,0,1406,1420,3,198,99,0,1407,1420,3,280,140,0,1408,1409,5,446, + 0,0,1409,1410,5,536,0,0,1410,1411,5,373,0,0,1411,1420,3,216,108, + 0,1412,1413,5,498,0,0,1413,1414,5,536,0,0,1414,1420,3,198,99,0,1415, + 1416,3,196,98,0,1416,1417,5,536,0,0,1417,1418,3,280,140,0,1418,1420, + 1,0,0,0,1419,1404,1,0,0,0,1419,1406,1,0,0,0,1419,1407,1,0,0,0,1419, + 1408,1,0,0,0,1419,1412,1,0,0,0,1419,1415,1,0,0,0,1420,195,1,0,0, + 0,1421,1422,7,22,0,0,1422,197,1,0,0,0,1423,1424,5,451,0,0,1424,1425, + 5,516,0,0,1425,1426,3,52,26,0,1426,1427,5,517,0,0,1427,199,1,0,0, + 0,1428,1429,5,253,0,0,1429,1433,3,258,129,0,1430,1431,5,412,0,0, + 1431,1433,3,54,27,0,1432,1428,1,0,0,0,1432,1430,1,0,0,0,1433,201, + 1,0,0,0,1434,1435,5,430,0,0,1435,1436,3,258,129,0,1436,203,1,0,0, + 0,1437,1438,5,159,0,0,1438,1439,5,34,0,0,1439,1444,3,206,103,0,1440, + 1441,5,520,0,0,1441,1443,3,206,103,0,1442,1440,1,0,0,0,1443,1446, + 1,0,0,0,1444,1442,1,0,0,0,1444,1445,1,0,0,0,1445,205,1,0,0,0,1446, + 1444,1,0,0,0,1447,1488,3,52,26,0,1448,1488,3,212,106,0,1449,1450, + 5,516,0,0,1450,1488,5,517,0,0,1451,1452,5,516,0,0,1452,1457,3,256, + 128,0,1453,1454,5,520,0,0,1454,1456,3,256,128,0,1455,1453,1,0,0, + 0,1456,1459,1,0,0,0,1457,1455,1,0,0,0,1457,1458,1,0,0,0,1458,1460, + 1,0,0,0,1459,1457,1,0,0,0,1460,1461,5,517,0,0,1461,1488,1,0,0,0, + 1462,1463,3,210,105,0,1463,1464,5,516,0,0,1464,1469,3,256,128,0, + 1465,1466,5,520,0,0,1466,1468,3,256,128,0,1467,1465,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,1473,5,517,0,0,1473,1488,1,0,0,0,1474,1475, + 3,208,104,0,1475,1476,5,516,0,0,1476,1481,3,206,103,0,1477,1478, + 5,520,0,0,1478,1480,3,206,103,0,1479,1477,1,0,0,0,1480,1483,1,0, + 0,0,1481,1479,1,0,0,0,1481,1482,1,0,0,0,1482,1484,1,0,0,0,1483,1481, + 1,0,0,0,1484,1485,5,517,0,0,1485,1488,1,0,0,0,1486,1488,3,256,128, + 0,1487,1447,1,0,0,0,1487,1448,1,0,0,0,1487,1449,1,0,0,0,1487,1451, + 1,0,0,0,1487,1462,1,0,0,0,1487,1474,1,0,0,0,1487,1486,1,0,0,0,1488, + 207,1,0,0,0,1489,1490,5,160,0,0,1490,1491,5,493,0,0,1491,209,1,0, + 0,0,1492,1493,7,23,0,0,1493,211,1,0,0,0,1494,1495,3,214,107,0,1495, + 1496,5,516,0,0,1496,1497,3,216,108,0,1497,1498,5,520,0,0,1498,1499, + 3,280,140,0,1499,1500,5,517,0,0,1500,213,1,0,0,0,1501,1502,7,24, + 0,0,1502,215,1,0,0,0,1503,1504,3,326,163,0,1504,217,1,0,0,0,1505, + 1506,5,163,0,0,1506,1507,3,258,129,0,1507,219,1,0,0,0,1508,1509, + 5,432,0,0,1509,1514,3,222,111,0,1510,1511,5,520,0,0,1511,1513,3, + 222,111,0,1512,1510,1,0,0,0,1513,1516,1,0,0,0,1514,1512,1,0,0,0, + 1514,1515,1,0,0,0,1515,221,1,0,0,0,1516,1514,1,0,0,0,1517,1518,3, + 294,147,0,1518,1519,5,17,0,0,1519,1520,3,224,112,0,1520,223,1,0, + 0,0,1521,1523,3,294,147,0,1522,1521,1,0,0,0,1522,1523,1,0,0,0,1523, + 1524,1,0,0,0,1524,1526,5,516,0,0,1525,1527,3,234,117,0,1526,1525, + 1,0,0,0,1526,1527,1,0,0,0,1527,1529,1,0,0,0,1528,1530,3,228,114, + 0,1529,1528,1,0,0,0,1529,1530,1,0,0,0,1530,1532,1,0,0,0,1531,1533, + 3,250,125,0,1532,1531,1,0,0,0,1532,1533,1,0,0,0,1533,1534,1,0,0, + 0,1534,1535,5,517,0,0,1535,225,1,0,0,0,1536,1537,5,213,0,0,1537, + 1539,5,516,0,0,1538,1540,3,234,117,0,1539,1538,1,0,0,0,1539,1540, + 1,0,0,0,1540,1542,1,0,0,0,1541,1543,3,228,114,0,1542,1541,1,0,0, + 0,1542,1543,1,0,0,0,1543,1545,1,0,0,0,1544,1546,3,238,119,0,1545, + 1544,1,0,0,0,1545,1546,1,0,0,0,1546,1548,1,0,0,0,1547,1549,3,244, + 122,0,1548,1547,1,0,0,0,1548,1549,1,0,0,0,1549,1551,1,0,0,0,1550, + 1552,3,246,123,0,1551,1550,1,0,0,0,1551,1552,1,0,0,0,1552,1554,1, + 0,0,0,1553,1555,3,240,120,0,1554,1553,1,0,0,0,1554,1555,1,0,0,0, + 1555,1556,1,0,0,0,1556,1557,3,248,124,0,1557,1562,5,517,0,0,1558, + 1560,5,17,0,0,1559,1558,1,0,0,0,1559,1560,1,0,0,0,1560,1561,1,0, + 0,0,1561,1563,3,302,151,0,1562,1559,1,0,0,0,1562,1563,1,0,0,0,1563, + 227,1,0,0,0,1564,1565,5,258,0,0,1565,1566,5,34,0,0,1566,1571,3,230, + 115,0,1567,1568,5,520,0,0,1568,1570,3,230,115,0,1569,1567,1,0,0, + 0,1570,1573,1,0,0,0,1571,1569,1,0,0,0,1571,1572,1,0,0,0,1572,229, + 1,0,0,0,1573,1571,1,0,0,0,1574,1576,3,52,26,0,1575,1577,7,25,0,0, + 1576,1575,1,0,0,0,1576,1577,1,0,0,0,1577,1580,1,0,0,0,1578,1579, + 5,476,0,0,1579,1581,7,26,0,0,1580,1578,1,0,0,0,1580,1581,1,0,0,0, + 1581,231,1,0,0,0,1582,1585,5,204,0,0,1583,1586,5,5,0,0,1584,1586, + 3,256,128,0,1585,1583,1,0,0,0,1585,1584,1,0,0,0,1586,233,1,0,0,0, + 1587,1588,5,268,0,0,1588,1589,5,34,0,0,1589,1594,3,52,26,0,1590, + 1591,5,520,0,0,1591,1593,3,52,26,0,1592,1590,1,0,0,0,1593,1596,1, + 0,0,0,1594,1592,1,0,0,0,1594,1595,1,0,0,0,1595,235,1,0,0,0,1596, + 1594,1,0,0,0,1597,1614,5,527,0,0,1598,1614,5,530,0,0,1599,1614,5, + 535,0,0,1600,1601,5,518,0,0,1601,1602,5,538,0,0,1602,1603,5,520, + 0,0,1603,1604,5,538,0,0,1604,1614,5,519,0,0,1605,1606,5,518,0,0, + 1606,1607,5,538,0,0,1607,1608,5,520,0,0,1608,1614,5,519,0,0,1609, + 1610,5,518,0,0,1610,1611,5,520,0,0,1611,1612,5,538,0,0,1612,1614, + 5,519,0,0,1613,1597,1,0,0,0,1613,1598,1,0,0,0,1613,1599,1,0,0,0, + 1613,1600,1,0,0,0,1613,1605,1,0,0,0,1613,1609,1,0,0,0,1614,237,1, + 0,0,0,1615,1616,5,215,0,0,1616,1621,3,170,85,0,1617,1618,5,520,0, + 0,1618,1620,3,170,85,0,1619,1617,1,0,0,0,1620,1623,1,0,0,0,1621, + 1619,1,0,0,0,1621,1622,1,0,0,0,1622,239,1,0,0,0,1623,1621,1,0,0, + 0,1624,1625,5,271,0,0,1625,1627,5,516,0,0,1626,1628,3,242,121,0, + 1627,1626,1,0,0,0,1628,1629,1,0,0,0,1629,1627,1,0,0,0,1629,1630, + 1,0,0,0,1630,1631,1,0,0,0,1631,1633,5,517,0,0,1632,1634,3,254,127, + 0,1633,1632,1,0,0,0,1633,1634,1,0,0,0,1634,241,1,0,0,0,1635,1637, + 3,304,152,0,1636,1638,3,236,118,0,1637,1636,1,0,0,0,1637,1638,1, + 0,0,0,1638,243,1,0,0,0,1639,1640,5,5,0,0,1640,1641,5,322,0,0,1641, + 1642,5,272,0,0,1642,1648,5,210,0,0,1643,1644,5,254,0,0,1644,1645, + 5,321,0,0,1645,1646,5,272,0,0,1646,1648,5,210,0,0,1647,1639,1,0, + 0,0,1647,1643,1,0,0,0,1648,245,1,0,0,0,1649,1650,5,438,0,0,1650, + 1651,5,210,0,0,1651,1652,5,343,0,0,1652,1653,5,478,0,0,1653,1654, + 5,467,0,0,1654,1674,5,321,0,0,1655,1656,5,438,0,0,1656,1657,5,210, + 0,0,1657,1658,5,343,0,0,1658,1659,5,388,0,0,1659,1660,5,237,0,0, + 1660,1674,5,321,0,0,1661,1662,5,438,0,0,1662,1663,5,210,0,0,1663, + 1664,5,343,0,0,1664,1665,5,388,0,0,1665,1666,5,467,0,0,1666,1674, + 3,304,152,0,1667,1668,5,438,0,0,1668,1669,5,210,0,0,1669,1670,5, + 343,0,0,1670,1671,5,388,0,0,1671,1672,5,457,0,0,1672,1674,3,304, + 152,0,1673,1649,1,0,0,0,1673,1655,1,0,0,0,1673,1661,1,0,0,0,1673, + 1667,1,0,0,0,1674,247,1,0,0,0,1675,1676,5,105,0,0,1676,1681,3,170, + 85,0,1677,1678,5,520,0,0,1678,1680,3,170,85,0,1679,1677,1,0,0,0, + 1680,1683,1,0,0,0,1681,1679,1,0,0,0,1681,1682,1,0,0,0,1682,249,1, + 0,0,0,1683,1681,1,0,0,0,1684,1685,5,292,0,0,1685,1686,5,27,0,0,1686, + 1687,3,280,140,0,1687,1688,3,252,126,0,1688,1694,1,0,0,0,1689,1690, + 5,322,0,0,1690,1691,5,27,0,0,1691,1692,5,538,0,0,1692,1694,3,252, + 126,0,1693,1684,1,0,0,0,1693,1689,1,0,0,0,1694,251,1,0,0,0,1695, + 1696,5,480,0,0,1696,1697,5,10,0,0,1697,1698,5,76,0,0,1698,1699,5, + 321,0,0,1699,253,1,0,0,0,1700,1701,5,434,0,0,1701,1702,3,280,140, + 0,1702,255,1,0,0,0,1703,1704,3,258,129,0,1704,257,1,0,0,0,1705,1706, + 6,129,-1,0,1706,1707,5,241,0,0,1707,1718,3,258,129,6,1708,1709,5, + 133,0,0,1709,1710,5,516,0,0,1710,1711,3,156,78,0,1711,1712,5,517, + 0,0,1712,1718,1,0,0,0,1713,1715,3,264,132,0,1714,1716,3,260,130, + 0,1715,1714,1,0,0,0,1715,1716,1,0,0,0,1716,1718,1,0,0,0,1717,1705, + 1,0,0,0,1717,1708,1,0,0,0,1717,1713,1,0,0,0,1718,1733,1,0,0,0,1719, + 1720,10,3,0,0,1720,1721,5,10,0,0,1721,1732,3,258,129,4,1722,1723, + 10,2,0,0,1723,1724,5,257,0,0,1724,1732,3,258,129,3,1725,1726,10, + 1,0,0,1726,1728,5,184,0,0,1727,1729,5,241,0,0,1728,1727,1,0,0,0, + 1728,1729,1,0,0,0,1729,1730,1,0,0,0,1730,1732,7,27,0,0,1731,1719, + 1,0,0,0,1731,1722,1,0,0,0,1731,1725,1,0,0,0,1732,1735,1,0,0,0,1733, + 1731,1,0,0,0,1733,1734,1,0,0,0,1734,259,1,0,0,0,1735,1733,1,0,0, + 0,1736,1738,5,241,0,0,1737,1736,1,0,0,0,1737,1738,1,0,0,0,1738,1739, + 1,0,0,0,1739,1741,5,27,0,0,1740,1742,7,28,0,0,1741,1740,1,0,0,0, + 1741,1742,1,0,0,0,1742,1743,1,0,0,0,1743,1744,3,264,132,0,1744,1745, + 5,10,0,0,1745,1746,3,264,132,0,1746,1804,1,0,0,0,1747,1749,5,241, + 0,0,1748,1747,1,0,0,0,1748,1749,1,0,0,0,1749,1750,1,0,0,0,1750,1751, + 5,170,0,0,1751,1752,5,516,0,0,1752,1757,3,256,128,0,1753,1754,5, + 520,0,0,1754,1756,3,256,128,0,1755,1753,1,0,0,0,1756,1759,1,0,0, + 0,1757,1755,1,0,0,0,1757,1758,1,0,0,0,1758,1760,1,0,0,0,1759,1757, + 1,0,0,0,1760,1761,5,517,0,0,1761,1804,1,0,0,0,1762,1764,5,241,0, + 0,1763,1762,1,0,0,0,1763,1764,1,0,0,0,1764,1765,1,0,0,0,1765,1766, + 5,170,0,0,1766,1767,5,516,0,0,1767,1768,3,156,78,0,1768,1769,5,517, + 0,0,1769,1804,1,0,0,0,1770,1771,5,133,0,0,1771,1772,5,516,0,0,1772, + 1773,3,156,78,0,1773,1774,5,517,0,0,1774,1804,1,0,0,0,1775,1777, + 5,241,0,0,1776,1775,1,0,0,0,1776,1777,1,0,0,0,1777,1778,1,0,0,0, + 1778,1779,5,318,0,0,1779,1804,3,264,132,0,1780,1804,3,262,131,0, + 1781,1783,5,184,0,0,1782,1784,5,241,0,0,1783,1782,1,0,0,0,1783,1784, + 1,0,0,0,1784,1785,1,0,0,0,1785,1804,7,27,0,0,1786,1788,5,184,0,0, + 1787,1789,5,241,0,0,1788,1787,1,0,0,0,1788,1789,1,0,0,0,1789,1790, + 1,0,0,0,1790,1791,5,113,0,0,1791,1792,5,151,0,0,1792,1804,3,264, + 132,0,1793,1795,5,241,0,0,1794,1793,1,0,0,0,1794,1795,1,0,0,0,1795, + 1796,1,0,0,0,1796,1797,5,342,0,0,1797,1798,5,388,0,0,1798,1801,3, + 264,132,0,1799,1800,5,127,0,0,1800,1802,3,356,178,0,1801,1799,1, + 0,0,0,1801,1802,1,0,0,0,1802,1804,1,0,0,0,1803,1737,1,0,0,0,1803, + 1748,1,0,0,0,1803,1763,1,0,0,0,1803,1770,1,0,0,0,1803,1776,1,0,0, + 0,1803,1780,1,0,0,0,1803,1781,1,0,0,0,1803,1786,1,0,0,0,1803,1794, + 1,0,0,0,1804,261,1,0,0,0,1805,1807,5,241,0,0,1806,1805,1,0,0,0,1806, + 1807,1,0,0,0,1807,1808,1,0,0,0,1808,1809,5,202,0,0,1809,1823,7,29, + 0,0,1810,1811,5,516,0,0,1811,1824,5,517,0,0,1812,1813,5,516,0,0, + 1813,1818,3,256,128,0,1814,1815,5,520,0,0,1815,1817,3,256,128,0, + 1816,1814,1,0,0,0,1817,1820,1,0,0,0,1818,1816,1,0,0,0,1818,1819, + 1,0,0,0,1819,1821,1,0,0,0,1820,1818,1,0,0,0,1821,1822,5,517,0,0, + 1822,1824,1,0,0,0,1823,1810,1,0,0,0,1823,1812,1,0,0,0,1824,1835, + 1,0,0,0,1825,1827,5,241,0,0,1826,1825,1,0,0,0,1826,1827,1,0,0,0, + 1827,1828,1,0,0,0,1828,1829,5,202,0,0,1829,1832,3,264,132,0,1830, + 1831,5,127,0,0,1831,1833,3,356,178,0,1832,1830,1,0,0,0,1832,1833, + 1,0,0,0,1833,1835,1,0,0,0,1834,1806,1,0,0,0,1834,1826,1,0,0,0,1835, + 263,1,0,0,0,1836,1837,6,132,-1,0,1837,1841,3,266,133,0,1838,1839, + 7,30,0,0,1839,1841,3,264,132,7,1840,1836,1,0,0,0,1840,1838,1,0,0, + 0,1841,1863,1,0,0,0,1842,1843,10,6,0,0,1843,1844,7,31,0,0,1844,1862, + 3,264,132,7,1845,1846,10,5,0,0,1846,1847,7,32,0,0,1847,1862,3,264, + 132,6,1848,1849,10,4,0,0,1849,1850,5,511,0,0,1850,1862,3,264,132, + 5,1851,1852,10,3,0,0,1852,1853,5,512,0,0,1853,1862,3,264,132,4,1854, + 1855,10,2,0,0,1855,1856,5,510,0,0,1856,1862,3,264,132,3,1857,1858, + 10,1,0,0,1858,1859,3,344,172,0,1859,1860,3,264,132,2,1860,1862,1, + 0,0,0,1861,1842,1,0,0,0,1861,1845,1,0,0,0,1861,1848,1,0,0,0,1861, + 1851,1,0,0,0,1861,1854,1,0,0,0,1861,1857,1,0,0,0,1862,1865,1,0,0, + 0,1863,1861,1,0,0,0,1863,1864,1,0,0,0,1864,265,1,0,0,0,1865,1863, + 1,0,0,0,1866,1867,6,133,-1,0,1867,1869,5,40,0,0,1868,1870,3,308, + 154,0,1869,1868,1,0,0,0,1870,1871,1,0,0,0,1871,1869,1,0,0,0,1871, + 1872,1,0,0,0,1872,1875,1,0,0,0,1873,1874,5,120,0,0,1874,1876,3,256, + 128,0,1875,1873,1,0,0,0,1875,1876,1,0,0,0,1876,1877,1,0,0,0,1877, + 1878,5,122,0,0,1878,1959,1,0,0,0,1879,1880,5,40,0,0,1880,1882,3, + 256,128,0,1881,1883,3,308,154,0,1882,1881,1,0,0,0,1883,1884,1,0, + 0,0,1884,1882,1,0,0,0,1884,1885,1,0,0,0,1885,1888,1,0,0,0,1886,1887, + 5,120,0,0,1887,1889,3,256,128,0,1888,1886,1,0,0,0,1888,1889,1,0, + 0,0,1889,1890,1,0,0,0,1890,1891,5,122,0,0,1891,1959,1,0,0,0,1892, + 1893,5,41,0,0,1893,1894,5,516,0,0,1894,1895,3,256,128,0,1895,1896, + 5,17,0,0,1896,1897,3,56,28,0,1897,1898,5,517,0,0,1898,1959,1,0,0, + 0,1899,1900,5,457,0,0,1900,1901,5,516,0,0,1901,1904,3,256,128,0, + 1902,1903,5,461,0,0,1903,1905,5,476,0,0,1904,1902,1,0,0,0,1904,1905, + 1,0,0,0,1905,1906,1,0,0,0,1906,1907,5,517,0,0,1907,1959,1,0,0,0, + 1908,1909,5,467,0,0,1909,1910,5,516,0,0,1910,1913,3,256,128,0,1911, + 1912,5,461,0,0,1912,1914,5,476,0,0,1913,1911,1,0,0,0,1913,1914,1, + 0,0,0,1914,1915,1,0,0,0,1915,1916,5,517,0,0,1916,1959,1,0,0,0,1917, + 1918,5,281,0,0,1918,1919,5,516,0,0,1919,1920,3,264,132,0,1920,1921, + 5,170,0,0,1921,1922,3,264,132,0,1922,1923,5,517,0,0,1923,1959,1, + 0,0,0,1924,1959,3,352,176,0,1925,1959,5,527,0,0,1926,1927,3,326, + 163,0,1927,1928,5,513,0,0,1928,1929,5,527,0,0,1929,1959,1,0,0,0, + 1930,1931,5,516,0,0,1931,1932,3,156,78,0,1932,1933,5,517,0,0,1933, + 1959,1,0,0,0,1934,1935,3,270,135,0,1935,1947,5,516,0,0,1936,1938, + 3,362,181,0,1937,1936,1,0,0,0,1937,1938,1,0,0,0,1938,1939,1,0,0, + 0,1939,1944,3,272,136,0,1940,1941,5,520,0,0,1941,1943,3,272,136, + 0,1942,1940,1,0,0,0,1943,1946,1,0,0,0,1944,1942,1,0,0,0,1944,1945, + 1,0,0,0,1945,1948,1,0,0,0,1946,1944,1,0,0,0,1947,1937,1,0,0,0,1947, + 1948,1,0,0,0,1948,1949,1,0,0,0,1949,1950,5,517,0,0,1950,1959,1,0, + 0,0,1951,1959,3,302,151,0,1952,1959,3,274,137,0,1953,1954,5,516, + 0,0,1954,1955,3,256,128,0,1955,1956,5,517,0,0,1956,1959,1,0,0,0, + 1957,1959,5,85,0,0,1958,1866,1,0,0,0,1958,1879,1,0,0,0,1958,1892, + 1,0,0,0,1958,1899,1,0,0,0,1958,1908,1,0,0,0,1958,1917,1,0,0,0,1958, + 1924,1,0,0,0,1958,1925,1,0,0,0,1958,1926,1,0,0,0,1958,1930,1,0,0, + 0,1958,1934,1,0,0,0,1958,1951,1,0,0,0,1958,1952,1,0,0,0,1958,1953, + 1,0,0,0,1958,1957,1,0,0,0,1959,1967,1,0,0,0,1960,1961,10,5,0,0,1961, + 1962,5,514,0,0,1962,1963,3,264,132,0,1963,1964,5,515,0,0,1964,1966, + 1,0,0,0,1965,1960,1,0,0,0,1966,1969,1,0,0,0,1967,1965,1,0,0,0,1967, + 1968,1,0,0,0,1968,267,1,0,0,0,1969,1967,1,0,0,0,1970,1971,3,326, + 163,0,1971,269,1,0,0,0,1972,1975,3,370,185,0,1973,1975,3,326,163, + 0,1974,1972,1,0,0,0,1974,1973,1,0,0,0,1975,271,1,0,0,0,1976,1981, + 3,368,184,0,1977,1981,3,366,183,0,1978,1981,3,364,182,0,1979,1981, + 3,256,128,0,1980,1976,1,0,0,0,1980,1977,1,0,0,0,1980,1978,1,0,0, + 0,1980,1979,1,0,0,0,1981,273,1,0,0,0,1982,1983,3,326,163,0,1983, + 275,1,0,0,0,1984,1985,3,302,151,0,1985,277,1,0,0,0,1986,1989,3,302, + 151,0,1987,1989,3,274,137,0,1988,1986,1,0,0,0,1988,1987,1,0,0,0, + 1989,279,1,0,0,0,1990,1993,5,182,0,0,1991,1994,3,282,141,0,1992, + 1994,3,286,143,0,1993,1991,1,0,0,0,1993,1992,1,0,0,0,1993,1994,1, + 0,0,0,1994,281,1,0,0,0,1995,1997,3,284,142,0,1996,1998,3,288,144, + 0,1997,1996,1,0,0,0,1997,1998,1,0,0,0,1998,283,1,0,0,0,1999,2000, + 3,290,145,0,2000,2001,3,366,183,0,2001,2003,1,0,0,0,2002,1999,1, + 0,0,0,2003,2004,1,0,0,0,2004,2002,1,0,0,0,2004,2005,1,0,0,0,2005, + 285,1,0,0,0,2006,2009,3,288,144,0,2007,2010,3,284,142,0,2008,2010, + 3,288,144,0,2009,2007,1,0,0,0,2009,2008,1,0,0,0,2009,2010,1,0,0, + 0,2010,287,1,0,0,0,2011,2012,3,290,145,0,2012,2013,3,366,183,0,2013, + 2014,5,388,0,0,2014,2015,3,366,183,0,2015,289,1,0,0,0,2016,2018, + 7,33,0,0,2017,2016,1,0,0,0,2017,2018,1,0,0,0,2018,2019,1,0,0,0,2019, + 2022,7,34,0,0,2020,2022,5,537,0,0,2021,2017,1,0,0,0,2021,2020,1, + 0,0,0,2022,291,1,0,0,0,2023,2025,5,17,0,0,2024,2023,1,0,0,0,2024, + 2025,1,0,0,0,2025,2026,1,0,0,0,2026,2028,3,302,151,0,2027,2029,3, + 298,149,0,2028,2027,1,0,0,0,2028,2029,1,0,0,0,2029,293,1,0,0,0,2030, + 2031,3,302,151,0,2031,2032,3,296,148,0,2032,295,1,0,0,0,2033,2034, + 5,221,0,0,2034,2036,3,302,151,0,2035,2033,1,0,0,0,2036,2037,1,0, + 0,0,2037,2035,1,0,0,0,2037,2038,1,0,0,0,2038,2041,1,0,0,0,2039,2041, + 1,0,0,0,2040,2035,1,0,0,0,2040,2039,1,0,0,0,2041,297,1,0,0,0,2042, + 2043,5,516,0,0,2043,2044,3,300,150,0,2044,2045,5,517,0,0,2045,299, + 1,0,0,0,2046,2051,3,302,151,0,2047,2048,5,520,0,0,2048,2050,3,302, + 151,0,2049,2047,1,0,0,0,2050,2053,1,0,0,0,2051,2049,1,0,0,0,2051, + 2052,1,0,0,0,2052,301,1,0,0,0,2053,2051,1,0,0,0,2054,2058,3,304, + 152,0,2055,2058,3,306,153,0,2056,2058,3,372,186,0,2057,2054,1,0, + 0,0,2057,2055,1,0,0,0,2057,2056,1,0,0,0,2058,303,1,0,0,0,2059,2060, + 7,35,0,0,2060,305,1,0,0,0,2061,2062,5,537,0,0,2062,307,1,0,0,0,2063, + 2064,5,428,0,0,2064,2065,3,256,128,0,2065,2066,5,376,0,0,2066,2067, + 3,256,128,0,2067,309,1,0,0,0,2068,2069,3,302,151,0,2069,311,1,0, + 0,0,2070,2071,3,302,151,0,2071,313,1,0,0,0,2072,2075,3,302,151,0, + 2073,2074,5,513,0,0,2074,2076,3,302,151,0,2075,2073,1,0,0,0,2075, + 2076,1,0,0,0,2076,315,1,0,0,0,2077,2080,3,302,151,0,2078,2079,5, + 513,0,0,2079,2081,3,302,151,0,2080,2078,1,0,0,0,2080,2081,1,0,0, + 0,2081,317,1,0,0,0,2082,2085,3,302,151,0,2083,2084,5,513,0,0,2084, + 2086,3,302,151,0,2085,2083,1,0,0,0,2085,2086,1,0,0,0,2086,2095,1, + 0,0,0,2087,2088,3,302,151,0,2088,2089,5,513,0,0,2089,2092,3,302, + 151,0,2090,2091,5,513,0,0,2091,2093,3,302,151,0,2092,2090,1,0,0, + 0,2092,2093,1,0,0,0,2093,2095,1,0,0,0,2094,2082,1,0,0,0,2094,2087, + 1,0,0,0,2095,319,1,0,0,0,2096,2099,3,302,151,0,2097,2098,5,513,0, + 0,2098,2100,3,302,151,0,2099,2097,1,0,0,0,2099,2100,1,0,0,0,2100, + 2109,1,0,0,0,2101,2102,3,302,151,0,2102,2103,5,513,0,0,2103,2106, + 3,302,151,0,2104,2105,5,513,0,0,2105,2107,3,302,151,0,2106,2104, + 1,0,0,0,2106,2107,1,0,0,0,2107,2109,1,0,0,0,2108,2096,1,0,0,0,2108, + 2101,1,0,0,0,2109,321,1,0,0,0,2110,2113,3,302,151,0,2111,2112,5, + 513,0,0,2112,2114,3,302,151,0,2113,2111,1,0,0,0,2113,2114,1,0,0, + 0,2114,2123,1,0,0,0,2115,2116,3,302,151,0,2116,2117,5,513,0,0,2117, + 2120,3,302,151,0,2118,2119,5,513,0,0,2119,2121,3,302,151,0,2120, + 2118,1,0,0,0,2120,2121,1,0,0,0,2121,2123,1,0,0,0,2122,2110,1,0,0, + 0,2122,2115,1,0,0,0,2123,323,1,0,0,0,2124,2127,3,302,151,0,2125, + 2126,5,513,0,0,2126,2128,3,302,151,0,2127,2125,1,0,0,0,2127,2128, + 1,0,0,0,2128,2137,1,0,0,0,2129,2130,3,302,151,0,2130,2131,5,513, + 0,0,2131,2134,3,302,151,0,2132,2133,5,513,0,0,2133,2135,3,302,151, + 0,2134,2132,1,0,0,0,2134,2135,1,0,0,0,2135,2137,1,0,0,0,2136,2124, + 1,0,0,0,2136,2129,1,0,0,0,2137,325,1,0,0,0,2138,2143,3,302,151,0, + 2139,2140,5,513,0,0,2140,2142,3,302,151,0,2141,2139,1,0,0,0,2142, + 2145,1,0,0,0,2143,2144,1,0,0,0,2143,2141,1,0,0,0,2144,327,1,0,0, + 0,2145,2143,1,0,0,0,2146,2147,5,433,0,0,2147,2148,3,334,167,0,2148, + 329,1,0,0,0,2149,2150,5,167,0,0,2150,2151,5,241,0,0,2151,2152,5, + 133,0,0,2152,331,1,0,0,0,2153,2154,5,167,0,0,2154,2155,5,133,0,0, + 2155,333,1,0,0,0,2156,2157,5,516,0,0,2157,2162,3,336,168,0,2158, + 2159,5,520,0,0,2159,2161,3,336,168,0,2160,2158,1,0,0,0,2161,2164, + 1,0,0,0,2162,2160,1,0,0,0,2162,2163,1,0,0,0,2163,2165,1,0,0,0,2164, + 2162,1,0,0,0,2165,2166,5,517,0,0,2166,335,1,0,0,0,2167,2172,3,338, + 169,0,2168,2170,5,505,0,0,2169,2168,1,0,0,0,2169,2170,1,0,0,0,2170, + 2171,1,0,0,0,2171,2173,3,340,170,0,2172,2169,1,0,0,0,2172,2173,1, + 0,0,0,2173,337,1,0,0,0,2174,2178,3,302,151,0,2175,2178,3,274,137, + 0,2176,2178,5,537,0,0,2177,2174,1,0,0,0,2177,2175,1,0,0,0,2177,2176, + 1,0,0,0,2178,339,1,0,0,0,2179,2184,5,538,0,0,2180,2184,5,539,0,0, + 2181,2184,3,360,180,0,2182,2184,5,537,0,0,2183,2179,1,0,0,0,2183, + 2180,1,0,0,0,2183,2181,1,0,0,0,2183,2182,1,0,0,0,2184,341,1,0,0, + 0,2185,2192,5,10,0,0,2186,2187,5,511,0,0,2187,2192,5,511,0,0,2188, + 2192,5,257,0,0,2189,2190,5,510,0,0,2190,2192,5,510,0,0,2191,2185, + 1,0,0,0,2191,2186,1,0,0,0,2191,2188,1,0,0,0,2191,2189,1,0,0,0,2192, + 343,1,0,0,0,2193,2208,5,505,0,0,2194,2208,5,506,0,0,2195,2208,5, + 507,0,0,2196,2197,5,507,0,0,2197,2208,5,505,0,0,2198,2199,5,506, + 0,0,2199,2208,5,505,0,0,2200,2201,5,507,0,0,2201,2208,5,506,0,0, + 2202,2203,5,508,0,0,2203,2208,5,505,0,0,2204,2205,5,507,0,0,2205, + 2206,5,505,0,0,2206,2208,5,506,0,0,2207,2193,1,0,0,0,2207,2194,1, + 0,0,0,2207,2195,1,0,0,0,2207,2196,1,0,0,0,2207,2198,1,0,0,0,2207, + 2200,1,0,0,0,2207,2202,1,0,0,0,2207,2204,1,0,0,0,2208,345,1,0,0, + 0,2209,2210,5,507,0,0,2210,2217,5,507,0,0,2211,2212,5,506,0,0,2212, + 2217,5,506,0,0,2213,2217,5,511,0,0,2214,2217,5,512,0,0,2215,2217, + 5,510,0,0,2216,2209,1,0,0,0,2216,2211,1,0,0,0,2216,2213,1,0,0,0, + 2216,2214,1,0,0,0,2216,2215,1,0,0,0,2217,347,1,0,0,0,2218,2219,7, + 36,0,0,2219,349,1,0,0,0,2220,2221,7,37,0,0,2221,351,1,0,0,0,2222, + 2237,3,280,140,0,2223,2237,3,354,177,0,2224,2237,3,356,178,0,2225, + 2227,5,529,0,0,2226,2225,1,0,0,0,2226,2227,1,0,0,0,2227,2228,1,0, + 0,0,2228,2237,3,358,179,0,2229,2237,3,360,180,0,2230,2237,5,539, + 0,0,2231,2237,5,540,0,0,2232,2234,5,241,0,0,2233,2232,1,0,0,0,2233, + 2234,1,0,0,0,2234,2235,1,0,0,0,2235,2237,5,244,0,0,2236,2222,1,0, + 0,0,2236,2223,1,0,0,0,2236,2224,1,0,0,0,2236,2226,1,0,0,0,2236,2229, + 1,0,0,0,2236,2230,1,0,0,0,2236,2231,1,0,0,0,2236,2233,1,0,0,0,2237, + 353,1,0,0,0,2238,2239,3,364,182,0,2239,2240,3,356,178,0,2240,355, + 1,0,0,0,2241,2242,5,537,0,0,2242,357,1,0,0,0,2243,2244,5,538,0,0, + 2244,359,1,0,0,0,2245,2246,7,38,0,0,2246,361,1,0,0,0,2247,2248,7, + 39,0,0,2248,363,1,0,0,0,2249,2250,7,40,0,0,2250,365,1,0,0,0,2251, + 2252,7,41,0,0,2252,367,1,0,0,0,2253,2254,7,42,0,0,2254,369,1,0,0, + 0,2255,2256,7,43,0,0,2256,371,1,0,0,0,2257,2258,7,44,0,0,2258,373, + 1,0,0,0,266,377,384,387,401,419,423,432,437,444,455,464,476,479, + 486,489,497,501,506,509,516,524,528,540,548,552,584,587,592,596, + 600,604,613,618,622,626,631,634,638,643,649,654,659,663,667,671, 679,687,691,695,699,703,707,711,715,719,721,731,739,763,770,776, - 779,782,792,795,803,815,839,851,856,860,868,872,878,888,892,898, - 902,906,909,918,922,929,932,942,950,958,962,977,996,1007,1011,1018, + 779,782,789,792,801,813,837,849,854,858,866,870,876,886,891,897, + 901,905,909,918,922,929,932,942,950,958,962,977,996,1007,1011,1018, 1023,1029,1033,1040,1044,1048,1052,1060,1064,1069,1075,1081,1084, 1088,1099,1108,1122,1134,1149,1152,1156,1159,1161,1166,1170,1173, 1177,1186,1195,1205,1210,1221,1224,1227,1230,1233,1239,1243,1251, 1254,1259,1262,1266,1269,1271,1285,1296,1301,1309,1312,1315,1320, - 1322,1324,1329,1332,1336,1339,1342,1346,1349,1352,1364,1371,1382, - 1409,1431,1444,1456,1469,1481,1493,1499,1526,1534,1538,1541,1544, - 1551,1554,1557,1560,1563,1566,1571,1574,1583,1588,1592,1597,1606, - 1625,1633,1641,1645,1649,1659,1685,1693,1705,1727,1729,1740,1743, - 1745,1749,1753,1760,1769,1775,1788,1795,1800,1806,1813,1815,1818, - 1830,1835,1838,1844,1846,1852,1873,1875,1883,1887,1896,1900,1916, - 1925,1949,1956,1959,1970,1979,1986,1992,2000,2005,2009,2016,2021, - 2029,2033,2036,2040,2049,2052,2063,2069,2087,2092,2097,2104,2106, - 2111,2118,2120,2125,2132,2134,2139,2146,2148,2155,2174,2181,2184, - 2189,2195,2203,2219,2228,2238,2245,2248 + 1322,1324,1329,1332,1336,1340,1352,1359,1370,1397,1419,1432,1444, + 1457,1469,1481,1487,1514,1522,1526,1529,1532,1539,1542,1545,1548, + 1551,1554,1559,1562,1571,1576,1580,1585,1594,1613,1621,1629,1633, + 1637,1647,1673,1681,1693,1715,1717,1728,1731,1733,1737,1741,1748, + 1757,1763,1776,1783,1788,1794,1801,1803,1806,1818,1823,1826,1832, + 1834,1840,1861,1863,1871,1875,1884,1888,1904,1913,1937,1944,1947, + 1958,1967,1974,1980,1988,1993,1997,2004,2009,2017,2021,2024,2028, + 2037,2040,2051,2057,2075,2080,2085,2092,2094,2099,2106,2108,2113, + 2120,2122,2127,2134,2136,2143,2162,2169,2172,2177,2183,2191,2207, + 2216,2226,2233,2236 ]; private static __ATN: antlr.ATN; @@ -12777,8 +12714,8 @@ export class DdlStatementContext extends antlr.ParserRuleContext { public alterTable(): AlterTableContext | null { return this.getRuleContext(0, AlterTableContext); } - public alertView(): AlertViewContext | null { - return this.getRuleContext(0, AlertViewContext); + public alterView(): AlterViewContext | null { + return this.getRuleContext(0, AlterViewContext); } public alterDatabase(): AlterDatabaseContext | null { return this.getRuleContext(0, AlterDatabaseContext); @@ -13560,6 +13497,7 @@ export class CreateTableContext extends antlr.ParserRuleContext { export class SimpleCreateTableContext extends antlr.ParserRuleContext { + public _comment?: Token | null; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -13614,8 +13552,8 @@ export class SimpleCreateTableContext extends antlr.ParserRuleContext { public selfDefinitionClause(): SelfDefinitionClauseContext | null { return this.getRuleContext(0, SelfDefinitionClauseContext); } - public commentSpec(): CommentSpecContext | null { - return this.getRuleContext(0, CommentSpecContext); + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.KW_COMMENT, 0); } public partitionDefinition(): PartitionDefinitionContext | null { return this.getRuleContext(0, PartitionDefinitionContext); @@ -13623,6 +13561,9 @@ export class SimpleCreateTableContext extends antlr.ParserRuleContext { public likeDefinition(): LikeDefinitionContext | null { return this.getRuleContext(0, LikeDefinitionContext); } + public STRING_LITERAL(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.STRING_LITERAL, 0); + } public override get ruleIndex(): number { return FlinkSqlParser.RULE_simpleCreateTable; } @@ -13731,6 +13672,7 @@ export class ColumnOptionDefinitionContext extends antlr.ParserRuleContext { export class PhysicalColumnDefinitionContext extends antlr.ParserRuleContext { + public _comment?: Token | null; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -13743,8 +13685,11 @@ export class PhysicalColumnDefinitionContext extends antlr.ParserRuleContext { public columnConstraint(): ColumnConstraintContext | null { return this.getRuleContext(0, ColumnConstraintContext); } - public commentSpec(): CommentSpecContext | null { - return this.getRuleContext(0, CommentSpecContext); + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.KW_COMMENT, 0); + } + public STRING_LITERAL(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.STRING_LITERAL, 0); } public override get ruleIndex(): number { return FlinkSqlParser.RULE_physicalColumnDefinition; @@ -13884,8 +13829,7 @@ export class ColumnNameListContext extends antlr.ParserRuleContext { export class ColumnTypeContext extends antlr.ParserRuleContext { - public _typeName?: Token | null; - public _type_?: Token | null; + public _colType?: Token | null; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -14341,39 +14285,6 @@ export class ColumnConstraintContext extends antlr.ParserRuleContext { } -export class CommentSpecContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_COMMENT(): antlr.TerminalNode { - return this.getToken(FlinkSqlParser.KW_COMMENT, 0)!; - } - public STRING_LITERAL(): antlr.TerminalNode { - return this.getToken(FlinkSqlParser.STRING_LITERAL, 0)!; - } - public override get ruleIndex(): number { - return FlinkSqlParser.RULE_commentSpec; - } - public override enterRule(listener: FlinkSqlParserListener): void { - if(listener.enterCommentSpec) { - listener.enterCommentSpec(this); - } - } - public override exitRule(listener: FlinkSqlParserListener): void { - if(listener.exitCommentSpec) { - listener.exitCommentSpec(this); - } - } - public override accept(visitor: FlinkSqlParserVisitor): Result | null { - if (visitor.visitCommentSpec) { - return visitor.visitCommentSpec(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class MetadataColumnDefinitionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -14450,6 +14361,7 @@ export class MetadataKeyContext extends antlr.ParserRuleContext { export class ComputedColumnDefinitionContext extends antlr.ParserRuleContext { + public _comment?: Token | null; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -14462,8 +14374,11 @@ export class ComputedColumnDefinitionContext extends antlr.ParserRuleContext { public computedColumnExpression(): ComputedColumnExpressionContext { return this.getRuleContext(0, ComputedColumnExpressionContext)!; } - public commentSpec(): CommentSpecContext | null { - return this.getRuleContext(0, CommentSpecContext); + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.KW_COMMENT, 0); + } + public STRING_LITERAL(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.STRING_LITERAL, 0); } public override get ruleIndex(): number { return FlinkSqlParser.RULE_computedColumnDefinition; @@ -15022,6 +14937,7 @@ export class CreateCatalogContext extends antlr.ParserRuleContext { export class CreateDatabaseContext extends antlr.ParserRuleContext { + public _comment?: Token | null; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -15040,8 +14956,11 @@ export class CreateDatabaseContext extends antlr.ParserRuleContext { public ifNotExists(): IfNotExistsContext | null { return this.getRuleContext(0, IfNotExistsContext); } - public commentSpec(): CommentSpecContext | null { - return this.getRuleContext(0, CommentSpecContext); + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.KW_COMMENT, 0); + } + public STRING_LITERAL(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.STRING_LITERAL, 0); } public override get ruleIndex(): number { return FlinkSqlParser.RULE_createDatabase; @@ -15067,6 +14986,7 @@ export class CreateDatabaseContext extends antlr.ParserRuleContext { export class CreateViewContext extends antlr.ParserRuleContext { + public _comment?: Token | null; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -15094,8 +15014,11 @@ export class CreateViewContext extends antlr.ParserRuleContext { public columnNameList(): ColumnNameListContext | null { return this.getRuleContext(0, ColumnNameListContext); } - public commentSpec(): CommentSpecContext | null { - return this.getRuleContext(0, CommentSpecContext); + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.KW_COMMENT, 0); + } + public STRING_LITERAL(): antlr.TerminalNode | null { + return this.getToken(FlinkSqlParser.STRING_LITERAL, 0); } public override get ruleIndex(): number { return FlinkSqlParser.RULE_createView; @@ -15555,7 +15478,7 @@ export class NotForcedContext extends antlr.ParserRuleContext { } -export class AlertViewContext extends antlr.ParserRuleContext { +export class AlterViewContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -15578,21 +15501,21 @@ export class AlertViewContext extends antlr.ParserRuleContext { return this.getRuleContext(0, QueryStatementContext); } public override get ruleIndex(): number { - return FlinkSqlParser.RULE_alertView; + return FlinkSqlParser.RULE_alterView; } public override enterRule(listener: FlinkSqlParserListener): void { - if(listener.enterAlertView) { - listener.enterAlertView(this); + if(listener.enterAlterView) { + listener.enterAlterView(this); } } public override exitRule(listener: FlinkSqlParserListener): void { - if(listener.exitAlertView) { - listener.exitAlertView(this); + if(listener.exitAlterView) { + listener.exitAlterView(this); } } public override accept(visitor: FlinkSqlParserVisitor): Result | null { - if (visitor.visitAlertView) { - return visitor.visitAlertView(this); + if (visitor.visitAlterView) { + return visitor.visitAlterView(this); } else { return visitor.visitChildren(this); } @@ -16877,12 +16800,6 @@ export class TablePrimaryContext extends antlr.ParserRuleContext { public systemTimePeriod(): SystemTimePeriodContext | null { return this.getRuleContext(0, SystemTimePeriodContext); } - public correlationName(): CorrelationNameContext | null { - return this.getRuleContext(0, CorrelationNameContext); - } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(FlinkSqlParser.KW_AS, 0); - } public viewPath(): ViewPathContext | null { return this.getRuleContext(0, ViewPathContext); } @@ -20180,6 +20097,7 @@ export class IntervalValueContext extends antlr.ParserRuleContext { export class TableAliasContext extends antlr.ParserRuleContext { + public _alias?: IdentifierContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } diff --git a/src/lib/flink/FlinkSqlParserListener.ts b/src/lib/flink/FlinkSqlParserListener.ts index 7d29d303..d348207e 100644 --- a/src/lib/flink/FlinkSqlParserListener.ts +++ b/src/lib/flink/FlinkSqlParserListener.ts @@ -44,7 +44,6 @@ import { LengthOneTypeDimensionContext } from "./FlinkSqlParser.js"; import { MapTypeDimensionContext } from "./FlinkSqlParser.js"; import { RowTypeDimensionContext } from "./FlinkSqlParser.js"; import { ColumnConstraintContext } from "./FlinkSqlParser.js"; -import { CommentSpecContext } from "./FlinkSqlParser.js"; import { MetadataColumnDefinitionContext } from "./FlinkSqlParser.js"; import { MetadataKeyContext } from "./FlinkSqlParser.js"; import { ComputedColumnDefinitionContext } from "./FlinkSqlParser.js"; @@ -73,7 +72,7 @@ import { AddConstraintContext } from "./FlinkSqlParser.js"; import { DropConstraintContext } from "./FlinkSqlParser.js"; import { AddUniqueContext } from "./FlinkSqlParser.js"; import { NotForcedContext } from "./FlinkSqlParser.js"; -import { AlertViewContext } from "./FlinkSqlParser.js"; +import { AlterViewContext } from "./FlinkSqlParser.js"; import { AlterDatabaseContext } from "./FlinkSqlParser.js"; import { AlterFunctionContext } from "./FlinkSqlParser.js"; import { DropCatalogContext } from "./FlinkSqlParser.js"; @@ -588,16 +587,6 @@ export class FlinkSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitColumnConstraint?: (ctx: ColumnConstraintContext) => void; - /** - * Enter a parse tree produced by `FlinkSqlParser.commentSpec`. - * @param ctx the parse tree - */ - enterCommentSpec?: (ctx: CommentSpecContext) => void; - /** - * Exit a parse tree produced by `FlinkSqlParser.commentSpec`. - * @param ctx the parse tree - */ - exitCommentSpec?: (ctx: CommentSpecContext) => void; /** * Enter a parse tree produced by `FlinkSqlParser.metadataColumnDefinition`. * @param ctx the parse tree @@ -883,15 +872,15 @@ export class FlinkSqlParserListener implements ParseTreeListener { */ exitNotForced?: (ctx: NotForcedContext) => void; /** - * Enter a parse tree produced by `FlinkSqlParser.alertView`. + * Enter a parse tree produced by `FlinkSqlParser.alterView`. * @param ctx the parse tree */ - enterAlertView?: (ctx: AlertViewContext) => void; + enterAlterView?: (ctx: AlterViewContext) => void; /** - * Exit a parse tree produced by `FlinkSqlParser.alertView`. + * Exit a parse tree produced by `FlinkSqlParser.alterView`. * @param ctx the parse tree */ - exitAlertView?: (ctx: AlertViewContext) => void; + exitAlterView?: (ctx: AlterViewContext) => void; /** * Enter a parse tree produced by `FlinkSqlParser.alterDatabase`. * @param ctx the parse tree diff --git a/src/lib/flink/FlinkSqlParserVisitor.ts b/src/lib/flink/FlinkSqlParserVisitor.ts index 74f12419..d8064813 100644 --- a/src/lib/flink/FlinkSqlParserVisitor.ts +++ b/src/lib/flink/FlinkSqlParserVisitor.ts @@ -44,7 +44,6 @@ import { LengthOneTypeDimensionContext } from "./FlinkSqlParser.js"; import { MapTypeDimensionContext } from "./FlinkSqlParser.js"; import { RowTypeDimensionContext } from "./FlinkSqlParser.js"; import { ColumnConstraintContext } from "./FlinkSqlParser.js"; -import { CommentSpecContext } from "./FlinkSqlParser.js"; import { MetadataColumnDefinitionContext } from "./FlinkSqlParser.js"; import { MetadataKeyContext } from "./FlinkSqlParser.js"; import { ComputedColumnDefinitionContext } from "./FlinkSqlParser.js"; @@ -73,7 +72,7 @@ import { AddConstraintContext } from "./FlinkSqlParser.js"; import { DropConstraintContext } from "./FlinkSqlParser.js"; import { AddUniqueContext } from "./FlinkSqlParser.js"; import { NotForcedContext } from "./FlinkSqlParser.js"; -import { AlertViewContext } from "./FlinkSqlParser.js"; +import { AlterViewContext } from "./FlinkSqlParser.js"; import { AlterDatabaseContext } from "./FlinkSqlParser.js"; import { AlterFunctionContext } from "./FlinkSqlParser.js"; import { DropCatalogContext } from "./FlinkSqlParser.js"; @@ -447,12 +446,6 @@ export class FlinkSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `FlinkSqlParser.commentSpec`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCommentSpec?: (ctx: CommentSpecContext) => Result; /** * Visit a parse tree produced by `FlinkSqlParser.metadataColumnDefinition`. * @param ctx the parse tree @@ -624,11 +617,11 @@ export class FlinkSqlParserVisitor extends AbstractParseTreeVisitor Result; /** - * Visit a parse tree produced by `FlinkSqlParser.alertView`. + * Visit a parse tree produced by `FlinkSqlParser.alterView`. * @param ctx the parse tree * @return the visitor result */ - visitAlertView?: (ctx: AlertViewContext) => Result; + visitAlterView?: (ctx: AlterViewContext) => Result; /** * Visit a parse tree produced by `FlinkSqlParser.alterDatabase`. * @param ctx the parse tree diff --git a/src/lib/hive/HiveSqlParser.ts b/src/lib/hive/HiveSqlParser.ts index b7caa520..0dbcfbe3 100644 --- a/src/lib/hive/HiveSqlParser.ts +++ b/src/lib/hive/HiveSqlParser.ts @@ -10836,7 +10836,7 @@ export class HiveSqlParser extends SQLParserBase { this.state = 2290; localContext._colName = this.columnNameCreate(); this.state = 2291; - this.columnType(); + localContext._colType = this.columnType(); this.state = 2293; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -16816,7 +16816,7 @@ export class HiveSqlParser extends SQLParserBase { this.state = 3480; this.function_(); this.state = 3481; - this.tableAlias(); + localContext._alias = this.tableAlias(); this.state = 3491; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -16874,7 +16874,7 @@ export class HiveSqlParser extends SQLParserBase { this.state = 3498; this.function_(); this.state = 3499; - this.tableAlias(); + localContext._alias = this.tableAlias(); this.state = 3509; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -16928,7 +16928,7 @@ export class HiveSqlParser extends SQLParserBase { } this.state = 3518; - this.tableAlias(); + localContext._alias = this.tableAlias(); this.state = 3530; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 458, this.context) ) { @@ -34747,16 +34747,17 @@ export class TableConstraintContext extends antlr.ParserRuleContext { export class ColumnNameTypeConstraintContext extends antlr.ParserRuleContext { public _colName?: ColumnNameCreateContext; + public _colType?: ColumnTypeContext; public _comment?: Token | null; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public columnType(): ColumnTypeContext { - return this.getRuleContext(0, ColumnTypeContext)!; - } public columnNameCreate(): ColumnNameCreateContext { return this.getRuleContext(0, ColumnNameCreateContext)!; } + public columnType(): ColumnTypeContext { + return this.getRuleContext(0, ColumnTypeContext)!; + } public columnConstraint(): ColumnConstraintContext | null { return this.getRuleContext(0, ColumnConstraintContext); } @@ -38744,6 +38745,7 @@ export class JoinTokenContext extends antlr.ParserRuleContext { export class LateralViewContext extends antlr.ParserRuleContext { + public _alias?: TableAliasContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } diff --git a/src/lib/impala/ImpalaSqlParser.interp b/src/lib/impala/ImpalaSqlParser.interp index fe75d1a6..6c98fc59 100644 --- a/src/lib/impala/ImpalaSqlParser.interp +++ b/src/lib/impala/ImpalaSqlParser.interp @@ -685,6 +685,7 @@ createCommonItem assignmentList assignmentItem viewColumns +viewColumnItem queryStatement with constraintSpecification @@ -693,6 +694,7 @@ columnSpec columnDefinition kuduTableElement kuduColumnDefinition +commentClause columnSpecWithKudu createColumnSpecWithKudu kuduAttributes @@ -769,4 +771,4 @@ nonReserved atn: -[4, 1, 289, 2771, 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, 1, 0, 5, 0, 368, 8, 0, 10, 0, 12, 0, 371, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 377, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 401, 8, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 414, 8, 4, 1, 5, 1, 5, 3, 5, 418, 8, 5, 1, 5, 1, 5, 3, 5, 422, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 429, 8, 5, 10, 5, 12, 5, 432, 9, 5, 1, 5, 1, 5, 3, 5, 436, 8, 5, 1, 5, 1, 5, 3, 5, 440, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 446, 8, 5, 3, 5, 448, 8, 5, 1, 5, 1, 5, 1, 5, 3, 5, 453, 8, 5, 1, 6, 1, 6, 3, 6, 457, 8, 6, 1, 6, 1, 6, 3, 6, 461, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 468, 8, 6, 1, 6, 1, 6, 1, 6, 3, 6, 473, 8, 6, 1, 6, 1, 6, 1, 7, 1, 7, 3, 7, 479, 8, 7, 1, 7, 1, 7, 3, 7, 483, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 5, 7, 490, 8, 7, 10, 7, 12, 7, 493, 9, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 499, 8, 7, 1, 7, 1, 7, 3, 7, 503, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 508, 8, 7, 3, 7, 510, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 515, 8, 7, 1, 7, 1, 7, 3, 7, 519, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 526, 8, 7, 1, 7, 1, 7, 3, 7, 530, 8, 7, 1, 8, 1, 8, 1, 8, 3, 8, 535, 8, 8, 1, 8, 1, 8, 3, 8, 539, 8, 8, 1, 8, 1, 8, 3, 8, 543, 8, 8, 1, 8, 1, 8, 3, 8, 547, 8, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 3, 9, 555, 8, 9, 1, 9, 1, 9, 1, 9, 3, 9, 560, 8, 9, 1, 9, 1, 9, 3, 9, 564, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 3, 11, 572, 8, 11, 1, 11, 1, 11, 3, 11, 576, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 583, 8, 11, 10, 11, 12, 11, 586, 9, 11, 3, 11, 588, 8, 11, 1, 11, 3, 11, 591, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 597, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 604, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 615, 8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 620, 8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 625, 8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 630, 8, 11, 1, 12, 1, 12, 1, 12, 3, 12, 635, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 5, 12, 642, 8, 12, 10, 12, 12, 12, 645, 9, 12, 3, 12, 647, 8, 12, 1, 12, 3, 12, 650, 8, 12, 1, 12, 1, 12, 3, 12, 654, 8, 12, 1, 12, 1, 12, 1, 12, 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, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 680, 8, 13, 1, 14, 1, 14, 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, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 706, 8, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 715, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 725, 8, 16, 1, 16, 3, 16, 728, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 742, 8, 18, 1, 18, 1, 18, 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, 3, 20, 760, 8, 20, 3, 20, 762, 8, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 769, 8, 20, 10, 20, 12, 20, 772, 9, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 782, 8, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 791, 8, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 798, 8, 22, 1, 22, 1, 22, 3, 22, 802, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 809, 8, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 815, 8, 23, 1, 23, 3, 23, 818, 8, 23, 1, 23, 1, 23, 1, 23, 3, 23, 823, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 830, 8, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 844, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 857, 8, 26, 1, 26, 1, 26, 1, 26, 3, 26, 862, 8, 26, 1, 26, 1, 26, 1, 26, 3, 26, 867, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 873, 8, 27, 1, 27, 1, 27, 1, 27, 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, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 3, 32, 909, 8, 32, 1, 32, 3, 32, 912, 8, 32, 1, 32, 1, 32, 1, 33, 1, 33, 3, 33, 918, 8, 33, 1, 33, 3, 33, 921, 8, 33, 1, 33, 1, 33, 1, 34, 1, 34, 3, 34, 927, 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 933, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 945, 8, 35, 3, 35, 947, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 958, 8, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 966, 8, 37, 1, 38, 1, 38, 1, 38, 3, 38, 971, 8, 38, 1, 38, 1, 38, 3, 38, 975, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 980, 8, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 3, 40, 987, 8, 40, 1, 40, 1, 40, 3, 40, 991, 8, 40, 1, 41, 1, 41, 3, 41, 995, 8, 41, 1, 41, 1, 41, 1, 41, 1, 41, 3, 41, 1001, 8, 41, 1, 42, 1, 42, 3, 42, 1005, 8, 42, 1, 42, 1, 42, 3, 42, 1009, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 1016, 8, 42, 10, 42, 12, 42, 1019, 9, 42, 3, 42, 1021, 8, 42, 1, 42, 3, 42, 1024, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 3, 44, 1032, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1046, 8, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1053, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1066, 8, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1072, 8, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1077, 8, 49, 1, 49, 3, 49, 1080, 8, 49, 1, 50, 3, 50, 1083, 8, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1088, 8, 50, 1, 50, 1, 50, 3, 50, 1092, 8, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 5, 50, 1099, 8, 50, 10, 50, 12, 50, 1102, 9, 50, 1, 50, 1, 50, 3, 50, 1106, 8, 50, 1, 50, 1, 50, 1, 51, 1, 51, 3, 51, 1112, 8, 51, 1, 52, 1, 52, 3, 52, 1116, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1121, 8, 52, 1, 53, 1, 53, 1, 53, 3, 53, 1126, 8, 53, 1, 53, 3, 53, 1129, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 5, 53, 1135, 8, 53, 10, 53, 12, 53, 1138, 9, 53, 3, 53, 1140, 8, 53, 1, 53, 1, 53, 3, 53, 1144, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1154, 8, 54, 10, 54, 12, 54, 1157, 9, 54, 3, 54, 1159, 8, 54, 1, 54, 1, 54, 3, 54, 1163, 8, 54, 1, 55, 1, 55, 1, 55, 3, 55, 1168, 8, 55, 1, 55, 1, 55, 3, 55, 1172, 8, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1188, 8, 56, 1, 57, 1, 57, 1, 57, 3, 57, 1193, 8, 57, 1, 57, 1, 57, 1, 57, 5, 57, 1198, 8, 57, 10, 57, 12, 57, 1201, 9, 57, 3, 57, 1203, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1209, 8, 58, 1, 58, 3, 58, 1212, 8, 58, 1, 58, 1, 58, 1, 58, 5, 58, 1217, 8, 58, 10, 58, 12, 58, 1220, 9, 58, 3, 58, 1222, 8, 58, 1, 59, 1, 59, 3, 59, 1226, 8, 59, 1, 59, 1, 59, 1, 59, 3, 59, 1231, 8, 59, 1, 59, 3, 59, 1234, 8, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1239, 8, 59, 10, 59, 12, 59, 1242, 9, 59, 3, 59, 1244, 8, 59, 1, 60, 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, 64, 1, 64, 3, 64, 1268, 8, 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, 3, 65, 1282, 8, 65, 1, 65, 1, 65, 3, 65, 1286, 8, 65, 1, 66, 1, 66, 3, 66, 1290, 8, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1310, 8, 68, 3, 68, 1312, 8, 68, 3, 68, 1314, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1323, 8, 69, 3, 69, 1325, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1334, 8, 70, 3, 70, 1336, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1345, 8, 71, 3, 71, 1347, 8, 71, 1, 72, 1, 72, 1, 72, 3, 72, 1352, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1361, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 1370, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1379, 8, 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1390, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1396, 8, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1401, 8, 78, 1, 78, 3, 78, 1404, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1417, 8, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1427, 8, 80, 1, 80, 1, 80, 3, 80, 1431, 8, 80, 1, 81, 1, 81, 1, 81, 3, 81, 1436, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 5, 82, 1445, 8, 82, 10, 82, 12, 82, 1448, 9, 82, 1, 82, 1, 82, 3, 82, 1452, 8, 82, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 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, 93, 5, 93, 1483, 8, 93, 10, 93, 12, 93, 1486, 9, 93, 1, 94, 1, 94, 1, 94, 5, 94, 1491, 8, 94, 10, 94, 12, 94, 1494, 9, 94, 1, 95, 1, 95, 3, 95, 1498, 8, 95, 1, 96, 1, 96, 3, 96, 1502, 8, 96, 1, 97, 1, 97, 3, 97, 1506, 8, 97, 1, 98, 1, 98, 1, 98, 3, 98, 1511, 8, 98, 1, 98, 1, 98, 3, 98, 1515, 8, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1520, 8, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1525, 8, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1530, 8, 98, 1, 98, 1, 98, 3, 98, 1534, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1543, 8, 98, 1, 98, 3, 98, 1546, 8, 98, 1, 98, 1, 98, 3, 98, 1550, 8, 98, 1, 99, 1, 99, 1, 99, 5, 99, 1555, 8, 99, 10, 99, 12, 99, 1558, 9, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1568, 8, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1574, 8, 101, 5, 101, 1576, 8, 101, 10, 101, 12, 101, 1579, 9, 101, 1, 101, 1, 101, 1, 102, 3, 102, 1584, 8, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 1592, 8, 103, 10, 103, 12, 103, 1595, 9, 103, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1601, 8, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1606, 8, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1611, 8, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1616, 8, 104, 1, 104, 1, 104, 5, 104, 1620, 8, 104, 10, 104, 12, 104, 1623, 9, 104, 3, 104, 1625, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 1634, 8, 105, 1, 105, 3, 105, 1637, 8, 105, 1, 105, 3, 105, 1640, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 1646, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 1652, 8, 107, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 1660, 8, 109, 10, 109, 12, 109, 1663, 9, 109, 3, 109, 1665, 8, 109, 1, 109, 1, 109, 3, 109, 1669, 8, 109, 1, 109, 1, 109, 3, 109, 1673, 8, 109, 1, 110, 1, 110, 1, 110, 5, 110, 1678, 8, 110, 10, 110, 12, 110, 1681, 9, 110, 3, 110, 1683, 8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 1689, 8, 111, 1, 111, 1, 111, 5, 111, 1693, 8, 111, 10, 111, 12, 111, 1696, 9, 111, 3, 111, 1698, 8, 111, 1, 112, 3, 112, 1701, 8, 112, 1, 112, 1, 112, 3, 112, 1705, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1715, 8, 113, 1, 114, 1, 114, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 5, 116, 1724, 8, 116, 10, 116, 12, 116, 1727, 9, 116, 1, 116, 1, 116, 3, 116, 1731, 8, 116, 1, 116, 3, 116, 1734, 8, 116, 1, 117, 1, 117, 3, 117, 1738, 8, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 3, 118, 1745, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 5, 118, 1753, 8, 118, 10, 118, 12, 118, 1756, 9, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 1767, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 1773, 8, 119, 3, 119, 1775, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 1784, 8, 120, 1, 120, 3, 120, 1787, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 1794, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 1804, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 1810, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 5, 124, 1816, 8, 124, 10, 124, 12, 124, 1819, 9, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 1827, 8, 125, 10, 125, 12, 125, 1830, 9, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 5, 126, 1837, 8, 126, 10, 126, 12, 126, 1840, 9, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1850, 8, 127, 3, 127, 1852, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1858, 8, 127, 1, 128, 1, 128, 1, 128, 3, 128, 1863, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 1871, 8, 129, 10, 129, 12, 129, 1874, 9, 129, 3, 129, 1876, 8, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 1882, 8, 129, 3, 129, 1884, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1892, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 1898, 8, 130, 1, 130, 5, 130, 1901, 8, 130, 10, 130, 12, 130, 1904, 9, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 5, 131, 1913, 8, 131, 10, 131, 12, 131, 1916, 9, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1922, 8, 131, 1, 132, 1, 132, 3, 132, 1926, 8, 132, 1, 132, 1, 132, 3, 132, 1930, 8, 132, 1, 133, 1, 133, 3, 133, 1934, 8, 133, 1, 133, 3, 133, 1937, 8, 133, 1, 133, 1, 133, 1, 133, 5, 133, 1942, 8, 133, 10, 133, 12, 133, 1945, 9, 133, 1, 133, 1, 133, 1, 133, 1, 133, 5, 133, 1951, 8, 133, 10, 133, 12, 133, 1954, 9, 133, 3, 133, 1956, 8, 133, 1, 133, 1, 133, 3, 133, 1960, 8, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1965, 8, 133, 1, 133, 1, 133, 3, 133, 1969, 8, 133, 1, 134, 3, 134, 1972, 8, 134, 1, 134, 1, 134, 1, 134, 5, 134, 1977, 8, 134, 10, 134, 12, 134, 1980, 9, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 5, 136, 1988, 8, 136, 10, 136, 12, 136, 1991, 9, 136, 3, 136, 1993, 8, 136, 1, 136, 1, 136, 3, 136, 1997, 8, 136, 1, 137, 1, 137, 3, 137, 2001, 8, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 139, 1, 139, 3, 139, 2010, 8, 139, 1, 139, 3, 139, 2013, 8, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2020, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 2034, 8, 140, 5, 140, 2036, 8, 140, 10, 140, 12, 140, 2039, 9, 140, 1, 141, 3, 141, 2042, 8, 141, 1, 141, 1, 141, 3, 141, 2046, 8, 141, 1, 141, 1, 141, 3, 141, 2050, 8, 141, 1, 141, 1, 141, 3, 141, 2054, 8, 141, 1, 141, 1, 141, 3, 141, 2058, 8, 141, 1, 141, 1, 141, 3, 141, 2062, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2072, 8, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 5, 142, 2081, 8, 142, 10, 142, 12, 142, 2084, 9, 142, 1, 142, 1, 142, 3, 142, 2088, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2101, 8, 143, 3, 143, 2103, 8, 143, 1, 144, 1, 144, 1, 145, 1, 145, 3, 145, 2109, 8, 145, 1, 145, 1, 145, 3, 145, 2113, 8, 145, 3, 145, 2115, 8, 145, 1, 146, 1, 146, 1, 146, 1, 146, 5, 146, 2121, 8, 146, 10, 146, 12, 146, 2124, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 3, 147, 2130, 8, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2135, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 5, 149, 2146, 8, 149, 10, 149, 12, 149, 2149, 9, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2154, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 3, 151, 2162, 8, 151, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 3, 153, 2169, 8, 153, 1, 153, 1, 153, 3, 153, 2173, 8, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 5, 153, 2181, 8, 153, 10, 153, 12, 153, 2184, 9, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2194, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2202, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 2209, 8, 154, 10, 154, 12, 154, 2212, 9, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2217, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2222, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2228, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2234, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2239, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2244, 8, 154, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 2250, 8, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 5, 155, 2261, 8, 155, 10, 155, 12, 155, 2264, 9, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2290, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2296, 8, 156, 5, 156, 2298, 8, 156, 10, 156, 12, 156, 2301, 9, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 2310, 8, 156, 10, 156, 12, 156, 2313, 9, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2322, 8, 156, 1, 156, 3, 156, 2325, 8, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2330, 8, 156, 1, 156, 1, 156, 1, 156, 5, 156, 2335, 8, 156, 10, 156, 12, 156, 2338, 9, 156, 3, 156, 2340, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 2347, 8, 156, 10, 156, 12, 156, 2350, 9, 156, 3, 156, 2352, 8, 156, 1, 156, 1, 156, 3, 156, 2356, 8, 156, 1, 156, 3, 156, 2359, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 2369, 8, 156, 10, 156, 12, 156, 2372, 9, 156, 3, 156, 2374, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 4, 156, 2391, 8, 156, 11, 156, 12, 156, 2392, 1, 156, 1, 156, 3, 156, 2397, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 4, 156, 2403, 8, 156, 11, 156, 12, 156, 2404, 1, 156, 1, 156, 3, 156, 2409, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 2432, 8, 156, 10, 156, 12, 156, 2435, 9, 156, 3, 156, 2437, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2446, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2452, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2458, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2464, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2475, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2484, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 2504, 8, 156, 10, 156, 12, 156, 2507, 9, 156, 3, 156, 2509, 8, 156, 1, 156, 3, 156, 2512, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 2522, 8, 156, 10, 156, 12, 156, 2525, 9, 156, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 2531, 8, 157, 3, 157, 2533, 8, 157, 1, 158, 1, 158, 1, 159, 1, 159, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 2555, 8, 161, 1, 162, 1, 162, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 5, 164, 2582, 8, 164, 10, 164, 12, 164, 2585, 9, 164, 1, 164, 1, 164, 1, 164, 1, 164, 3, 164, 2591, 8, 164, 1, 164, 1, 164, 1, 164, 1, 164, 5, 164, 2597, 8, 164, 10, 164, 12, 164, 2600, 9, 164, 1, 164, 1, 164, 3, 164, 2604, 8, 164, 3, 164, 2606, 8, 164, 1, 164, 1, 164, 5, 164, 2610, 8, 164, 10, 164, 12, 164, 2613, 9, 164, 1, 165, 1, 165, 1, 166, 1, 166, 3, 166, 2619, 8, 166, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 2625, 8, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 5, 170, 2645, 8, 170, 10, 170, 12, 170, 2648, 9, 170, 3, 170, 2650, 8, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 5, 170, 2657, 8, 170, 10, 170, 12, 170, 2660, 9, 170, 3, 170, 2662, 8, 170, 1, 170, 3, 170, 2665, 8, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2685, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2696, 8, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 2703, 8, 173, 1, 174, 1, 174, 1, 174, 5, 174, 2708, 8, 174, 10, 174, 12, 174, 2711, 9, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 2724, 8, 175, 3, 175, 2726, 8, 175, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 5, 177, 2733, 8, 177, 10, 177, 12, 177, 2736, 9, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 2744, 8, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 2751, 8, 179, 1, 180, 3, 180, 2754, 8, 180, 1, 180, 1, 180, 3, 180, 2758, 8, 180, 1, 180, 1, 180, 3, 180, 2762, 8, 180, 1, 180, 3, 180, 2765, 8, 180, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 10, 770, 1446, 1621, 1661, 1679, 1694, 1725, 1754, 1828, 2299, 6, 260, 280, 306, 310, 312, 328, 183, 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, 0, 33, 2, 0, 46, 46, 170, 170, 2, 0, 166, 166, 204, 204, 2, 0, 176, 176, 202, 202, 2, 0, 69, 69, 80, 80, 2, 0, 27, 27, 159, 159, 2, 0, 103, 103, 144, 144, 2, 0, 47, 47, 171, 171, 2, 0, 3, 3, 12, 12, 3, 0, 87, 87, 166, 166, 204, 204, 2, 0, 178, 178, 209, 209, 1, 0, 245, 248, 2, 0, 147, 147, 219, 223, 2, 0, 65, 65, 95, 95, 2, 0, 64, 64, 200, 200, 2, 0, 10, 10, 55, 55, 2, 0, 75, 75, 112, 112, 2, 0, 2, 2, 57, 57, 2, 0, 14, 14, 185, 185, 3, 0, 106, 106, 115, 115, 164, 164, 2, 0, 105, 105, 163, 163, 4, 0, 70, 70, 133, 133, 194, 194, 208, 208, 1, 0, 255, 256, 1, 0, 257, 259, 1, 0, 249, 254, 3, 0, 2, 2, 6, 6, 181, 181, 2, 0, 70, 70, 194, 194, 5, 0, 48, 49, 91, 92, 122, 125, 172, 173, 217, 218, 1, 0, 127, 130, 2, 0, 8, 8, 227, 244, 2, 0, 77, 77, 149, 149, 4, 0, 46, 46, 178, 178, 188, 188, 209, 209, 16, 0, 28, 29, 40, 40, 43, 43, 48, 48, 68, 68, 91, 91, 114, 114, 122, 122, 124, 124, 158, 158, 165, 165, 172, 172, 184, 184, 196, 196, 204, 204, 217, 217, 23, 0, 14, 14, 43, 44, 48, 49, 65, 65, 68, 68, 91, 91, 95, 95, 110, 110, 119, 119, 122, 125, 127, 130, 137, 137, 140, 140, 152, 153, 172, 173, 180, 180, 184, 185, 195, 195, 204, 204, 213, 213, 217, 217, 220, 220, 231, 231, 3093, 0, 369, 1, 0, 0, 0, 2, 374, 1, 0, 0, 0, 4, 400, 1, 0, 0, 0, 6, 402, 1, 0, 0, 0, 8, 413, 1, 0, 0, 0, 10, 415, 1, 0, 0, 0, 12, 454, 1, 0, 0, 0, 14, 476, 1, 0, 0, 0, 16, 531, 1, 0, 0, 0, 18, 551, 1, 0, 0, 0, 20, 565, 1, 0, 0, 0, 22, 569, 1, 0, 0, 0, 24, 631, 1, 0, 0, 0, 26, 679, 1, 0, 0, 0, 28, 681, 1, 0, 0, 0, 30, 689, 1, 0, 0, 0, 32, 709, 1, 0, 0, 0, 34, 729, 1, 0, 0, 0, 36, 736, 1, 0, 0, 0, 38, 745, 1, 0, 0, 0, 40, 753, 1, 0, 0, 0, 42, 775, 1, 0, 0, 0, 44, 785, 1, 0, 0, 0, 46, 803, 1, 0, 0, 0, 48, 824, 1, 0, 0, 0, 50, 845, 1, 0, 0, 0, 52, 851, 1, 0, 0, 0, 54, 868, 1, 0, 0, 0, 56, 877, 1, 0, 0, 0, 58, 884, 1, 0, 0, 0, 60, 892, 1, 0, 0, 0, 62, 899, 1, 0, 0, 0, 64, 906, 1, 0, 0, 0, 66, 915, 1, 0, 0, 0, 68, 926, 1, 0, 0, 0, 70, 928, 1, 0, 0, 0, 72, 948, 1, 0, 0, 0, 74, 965, 1, 0, 0, 0, 76, 967, 1, 0, 0, 0, 78, 976, 1, 0, 0, 0, 80, 983, 1, 0, 0, 0, 82, 992, 1, 0, 0, 0, 84, 1002, 1, 0, 0, 0, 86, 1025, 1, 0, 0, 0, 88, 1031, 1, 0, 0, 0, 90, 1033, 1, 0, 0, 0, 92, 1040, 1, 0, 0, 0, 94, 1052, 1, 0, 0, 0, 96, 1054, 1, 0, 0, 0, 98, 1061, 1, 0, 0, 0, 100, 1082, 1, 0, 0, 0, 102, 1111, 1, 0, 0, 0, 104, 1113, 1, 0, 0, 0, 106, 1122, 1, 0, 0, 0, 108, 1145, 1, 0, 0, 0, 110, 1164, 1, 0, 0, 0, 112, 1187, 1, 0, 0, 0, 114, 1189, 1, 0, 0, 0, 116, 1204, 1, 0, 0, 0, 118, 1223, 1, 0, 0, 0, 120, 1245, 1, 0, 0, 0, 122, 1250, 1, 0, 0, 0, 124, 1255, 1, 0, 0, 0, 126, 1260, 1, 0, 0, 0, 128, 1265, 1, 0, 0, 0, 130, 1272, 1, 0, 0, 0, 132, 1287, 1, 0, 0, 0, 134, 1293, 1, 0, 0, 0, 136, 1313, 1, 0, 0, 0, 138, 1315, 1, 0, 0, 0, 140, 1326, 1, 0, 0, 0, 142, 1337, 1, 0, 0, 0, 144, 1351, 1, 0, 0, 0, 146, 1353, 1, 0, 0, 0, 148, 1362, 1, 0, 0, 0, 150, 1371, 1, 0, 0, 0, 152, 1380, 1, 0, 0, 0, 154, 1383, 1, 0, 0, 0, 156, 1391, 1, 0, 0, 0, 158, 1407, 1, 0, 0, 0, 160, 1411, 1, 0, 0, 0, 162, 1435, 1, 0, 0, 0, 164, 1437, 1, 0, 0, 0, 166, 1453, 1, 0, 0, 0, 168, 1456, 1, 0, 0, 0, 170, 1460, 1, 0, 0, 0, 172, 1463, 1, 0, 0, 0, 174, 1467, 1, 0, 0, 0, 176, 1469, 1, 0, 0, 0, 178, 1471, 1, 0, 0, 0, 180, 1473, 1, 0, 0, 0, 182, 1475, 1, 0, 0, 0, 184, 1477, 1, 0, 0, 0, 186, 1479, 1, 0, 0, 0, 188, 1487, 1, 0, 0, 0, 190, 1497, 1, 0, 0, 0, 192, 1501, 1, 0, 0, 0, 194, 1505, 1, 0, 0, 0, 196, 1510, 1, 0, 0, 0, 198, 1551, 1, 0, 0, 0, 200, 1559, 1, 0, 0, 0, 202, 1563, 1, 0, 0, 0, 204, 1583, 1, 0, 0, 0, 206, 1587, 1, 0, 0, 0, 208, 1596, 1, 0, 0, 0, 210, 1626, 1, 0, 0, 0, 212, 1641, 1, 0, 0, 0, 214, 1647, 1, 0, 0, 0, 216, 1653, 1, 0, 0, 0, 218, 1655, 1, 0, 0, 0, 220, 1674, 1, 0, 0, 0, 222, 1684, 1, 0, 0, 0, 224, 1704, 1, 0, 0, 0, 226, 1714, 1, 0, 0, 0, 228, 1716, 1, 0, 0, 0, 230, 1718, 1, 0, 0, 0, 232, 1733, 1, 0, 0, 0, 234, 1735, 1, 0, 0, 0, 236, 1742, 1, 0, 0, 0, 238, 1774, 1, 0, 0, 0, 240, 1786, 1, 0, 0, 0, 242, 1793, 1, 0, 0, 0, 244, 1803, 1, 0, 0, 0, 246, 1805, 1, 0, 0, 0, 248, 1811, 1, 0, 0, 0, 250, 1822, 1, 0, 0, 0, 252, 1833, 1, 0, 0, 0, 254, 1841, 1, 0, 0, 0, 256, 1859, 1, 0, 0, 0, 258, 1864, 1, 0, 0, 0, 260, 1885, 1, 0, 0, 0, 262, 1921, 1, 0, 0, 0, 264, 1923, 1, 0, 0, 0, 266, 1931, 1, 0, 0, 0, 268, 1971, 1, 0, 0, 0, 270, 1981, 1, 0, 0, 0, 272, 1996, 1, 0, 0, 0, 274, 1998, 1, 0, 0, 0, 276, 2005, 1, 0, 0, 0, 278, 2019, 1, 0, 0, 0, 280, 2021, 1, 0, 0, 0, 282, 2071, 1, 0, 0, 0, 284, 2087, 1, 0, 0, 0, 286, 2089, 1, 0, 0, 0, 288, 2104, 1, 0, 0, 0, 290, 2106, 1, 0, 0, 0, 292, 2116, 1, 0, 0, 0, 294, 2134, 1, 0, 0, 0, 296, 2136, 1, 0, 0, 0, 298, 2140, 1, 0, 0, 0, 300, 2155, 1, 0, 0, 0, 302, 2161, 1, 0, 0, 0, 304, 2163, 1, 0, 0, 0, 306, 2172, 1, 0, 0, 0, 308, 2243, 1, 0, 0, 0, 310, 2249, 1, 0, 0, 0, 312, 2511, 1, 0, 0, 0, 314, 2532, 1, 0, 0, 0, 316, 2534, 1, 0, 0, 0, 318, 2536, 1, 0, 0, 0, 320, 2538, 1, 0, 0, 0, 322, 2554, 1, 0, 0, 0, 324, 2556, 1, 0, 0, 0, 326, 2558, 1, 0, 0, 0, 328, 2605, 1, 0, 0, 0, 330, 2614, 1, 0, 0, 0, 332, 2618, 1, 0, 0, 0, 334, 2624, 1, 0, 0, 0, 336, 2626, 1, 0, 0, 0, 338, 2631, 1, 0, 0, 0, 340, 2637, 1, 0, 0, 0, 342, 2684, 1, 0, 0, 0, 344, 2695, 1, 0, 0, 0, 346, 2702, 1, 0, 0, 0, 348, 2704, 1, 0, 0, 0, 350, 2725, 1, 0, 0, 0, 352, 2727, 1, 0, 0, 0, 354, 2729, 1, 0, 0, 0, 356, 2743, 1, 0, 0, 0, 358, 2750, 1, 0, 0, 0, 360, 2764, 1, 0, 0, 0, 362, 2766, 1, 0, 0, 0, 364, 2768, 1, 0, 0, 0, 366, 368, 3, 2, 1, 0, 367, 366, 1, 0, 0, 0, 368, 371, 1, 0, 0, 0, 369, 367, 1, 0, 0, 0, 369, 370, 1, 0, 0, 0, 370, 372, 1, 0, 0, 0, 371, 369, 1, 0, 0, 0, 372, 373, 5, 0, 0, 1, 373, 1, 1, 0, 0, 0, 374, 376, 3, 4, 2, 0, 375, 377, 5, 262, 0, 0, 376, 375, 1, 0, 0, 0, 376, 377, 1, 0, 0, 0, 377, 3, 1, 0, 0, 0, 378, 401, 3, 204, 102, 0, 379, 401, 3, 6, 3, 0, 380, 401, 3, 8, 4, 0, 381, 401, 3, 26, 13, 0, 382, 401, 3, 64, 32, 0, 383, 401, 3, 66, 33, 0, 384, 401, 3, 68, 34, 0, 385, 401, 3, 74, 37, 0, 386, 401, 3, 88, 44, 0, 387, 401, 3, 94, 47, 0, 388, 401, 3, 100, 50, 0, 389, 401, 3, 102, 51, 0, 390, 401, 3, 108, 54, 0, 391, 401, 3, 110, 55, 0, 392, 401, 3, 112, 56, 0, 393, 401, 3, 144, 72, 0, 394, 401, 3, 152, 76, 0, 395, 401, 3, 154, 77, 0, 396, 401, 3, 156, 78, 0, 397, 401, 3, 158, 79, 0, 398, 401, 3, 160, 80, 0, 399, 401, 3, 162, 81, 0, 400, 378, 1, 0, 0, 0, 400, 379, 1, 0, 0, 0, 400, 380, 1, 0, 0, 0, 400, 381, 1, 0, 0, 0, 400, 382, 1, 0, 0, 0, 400, 383, 1, 0, 0, 0, 400, 384, 1, 0, 0, 0, 400, 385, 1, 0, 0, 0, 400, 386, 1, 0, 0, 0, 400, 387, 1, 0, 0, 0, 400, 388, 1, 0, 0, 0, 400, 389, 1, 0, 0, 0, 400, 390, 1, 0, 0, 0, 400, 391, 1, 0, 0, 0, 400, 392, 1, 0, 0, 0, 400, 393, 1, 0, 0, 0, 400, 394, 1, 0, 0, 0, 400, 395, 1, 0, 0, 0, 400, 396, 1, 0, 0, 0, 400, 397, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 399, 1, 0, 0, 0, 401, 5, 1, 0, 0, 0, 402, 403, 5, 203, 0, 0, 403, 404, 3, 184, 92, 0, 404, 7, 1, 0, 0, 0, 405, 414, 3, 18, 9, 0, 406, 414, 3, 20, 10, 0, 407, 414, 3, 22, 11, 0, 408, 414, 3, 24, 12, 0, 409, 414, 3, 16, 8, 0, 410, 414, 3, 14, 7, 0, 411, 414, 3, 12, 6, 0, 412, 414, 3, 10, 5, 0, 413, 405, 1, 0, 0, 0, 413, 406, 1, 0, 0, 0, 413, 407, 1, 0, 0, 0, 413, 408, 1, 0, 0, 0, 413, 409, 1, 0, 0, 0, 413, 410, 1, 0, 0, 0, 413, 411, 1, 0, 0, 0, 413, 412, 1, 0, 0, 0, 414, 9, 1, 0, 0, 0, 415, 417, 5, 37, 0, 0, 416, 418, 5, 19, 0, 0, 417, 416, 1, 0, 0, 0, 417, 418, 1, 0, 0, 0, 418, 419, 1, 0, 0, 0, 419, 421, 5, 188, 0, 0, 420, 422, 3, 172, 86, 0, 421, 420, 1, 0, 0, 0, 421, 422, 1, 0, 0, 0, 422, 423, 1, 0, 0, 0, 423, 439, 3, 174, 87, 0, 424, 425, 5, 265, 0, 0, 425, 430, 3, 214, 107, 0, 426, 427, 5, 263, 0, 0, 427, 429, 3, 214, 107, 0, 428, 426, 1, 0, 0, 0, 429, 432, 1, 0, 0, 0, 430, 428, 1, 0, 0, 0, 430, 431, 1, 0, 0, 0, 431, 435, 1, 0, 0, 0, 432, 430, 1, 0, 0, 0, 433, 434, 5, 263, 0, 0, 434, 436, 3, 208, 104, 0, 435, 433, 1, 0, 0, 0, 435, 436, 1, 0, 0, 0, 436, 437, 1, 0, 0, 0, 437, 438, 5, 266, 0, 0, 438, 440, 1, 0, 0, 0, 439, 424, 1, 0, 0, 0, 439, 440, 1, 0, 0, 0, 440, 447, 1, 0, 0, 0, 441, 442, 5, 17, 0, 0, 442, 445, 5, 26, 0, 0, 443, 446, 3, 292, 146, 0, 444, 446, 3, 250, 125, 0, 445, 443, 1, 0, 0, 0, 445, 444, 1, 0, 0, 0, 446, 448, 1, 0, 0, 0, 447, 441, 1, 0, 0, 0, 447, 448, 1, 0, 0, 0, 448, 449, 1, 0, 0, 0, 449, 452, 3, 196, 98, 0, 450, 451, 5, 9, 0, 0, 451, 453, 3, 204, 102, 0, 452, 450, 1, 0, 0, 0, 452, 453, 1, 0, 0, 0, 453, 11, 1, 0, 0, 0, 454, 456, 5, 37, 0, 0, 455, 457, 5, 19, 0, 0, 456, 455, 1, 0, 0, 0, 456, 457, 1, 0, 0, 0, 457, 458, 1, 0, 0, 0, 458, 460, 5, 188, 0, 0, 459, 461, 3, 172, 86, 0, 460, 459, 1, 0, 0, 0, 460, 461, 1, 0, 0, 0, 461, 462, 1, 0, 0, 0, 462, 463, 3, 174, 87, 0, 463, 467, 5, 115, 0, 0, 464, 468, 3, 186, 93, 0, 465, 466, 5, 147, 0, 0, 466, 468, 3, 314, 157, 0, 467, 464, 1, 0, 0, 0, 467, 465, 1, 0, 0, 0, 468, 472, 1, 0, 0, 0, 469, 470, 5, 17, 0, 0, 470, 471, 5, 26, 0, 0, 471, 473, 3, 250, 125, 0, 472, 469, 1, 0, 0, 0, 472, 473, 1, 0, 0, 0, 473, 474, 1, 0, 0, 0, 474, 475, 3, 196, 98, 0, 475, 13, 1, 0, 0, 0, 476, 478, 5, 37, 0, 0, 477, 479, 5, 19, 0, 0, 478, 477, 1, 0, 0, 0, 478, 479, 1, 0, 0, 0, 479, 480, 1, 0, 0, 0, 480, 482, 5, 188, 0, 0, 481, 483, 3, 172, 86, 0, 482, 481, 1, 0, 0, 0, 482, 483, 1, 0, 0, 0, 483, 484, 1, 0, 0, 0, 484, 502, 3, 174, 87, 0, 485, 486, 5, 265, 0, 0, 486, 491, 3, 216, 108, 0, 487, 488, 5, 263, 0, 0, 488, 490, 3, 216, 108, 0, 489, 487, 1, 0, 0, 0, 490, 493, 1, 0, 0, 0, 491, 489, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 498, 1, 0, 0, 0, 493, 491, 1, 0, 0, 0, 494, 495, 5, 263, 0, 0, 495, 496, 5, 150, 0, 0, 496, 497, 5, 110, 0, 0, 497, 499, 3, 292, 146, 0, 498, 494, 1, 0, 0, 0, 498, 499, 1, 0, 0, 0, 499, 500, 1, 0, 0, 0, 500, 501, 5, 266, 0, 0, 501, 503, 1, 0, 0, 0, 502, 485, 1, 0, 0, 0, 502, 503, 1, 0, 0, 0, 503, 509, 1, 0, 0, 0, 504, 505, 5, 150, 0, 0, 505, 507, 5, 110, 0, 0, 506, 508, 3, 292, 146, 0, 507, 506, 1, 0, 0, 0, 507, 508, 1, 0, 0, 0, 508, 510, 1, 0, 0, 0, 509, 504, 1, 0, 0, 0, 509, 510, 1, 0, 0, 0, 510, 514, 1, 0, 0, 0, 511, 512, 5, 145, 0, 0, 512, 513, 5, 26, 0, 0, 513, 515, 3, 232, 116, 0, 514, 511, 1, 0, 0, 0, 514, 515, 1, 0, 0, 0, 515, 518, 1, 0, 0, 0, 516, 517, 5, 34, 0, 0, 517, 519, 3, 314, 157, 0, 518, 516, 1, 0, 0, 0, 518, 519, 1, 0, 0, 0, 519, 520, 1, 0, 0, 0, 520, 521, 5, 23, 0, 0, 521, 522, 5, 9, 0, 0, 522, 525, 5, 111, 0, 0, 523, 524, 5, 25, 0, 0, 524, 526, 3, 248, 124, 0, 525, 523, 1, 0, 0, 0, 525, 526, 1, 0, 0, 0, 526, 529, 1, 0, 0, 0, 527, 528, 5, 9, 0, 0, 528, 530, 3, 204, 102, 0, 529, 527, 1, 0, 0, 0, 529, 530, 1, 0, 0, 0, 530, 15, 1, 0, 0, 0, 531, 532, 5, 37, 0, 0, 532, 534, 5, 212, 0, 0, 533, 535, 3, 172, 86, 0, 534, 533, 1, 0, 0, 0, 534, 535, 1, 0, 0, 0, 535, 536, 1, 0, 0, 0, 536, 538, 3, 178, 89, 0, 537, 539, 3, 202, 101, 0, 538, 537, 1, 0, 0, 0, 538, 539, 1, 0, 0, 0, 539, 542, 1, 0, 0, 0, 540, 541, 5, 34, 0, 0, 541, 543, 3, 314, 157, 0, 542, 540, 1, 0, 0, 0, 542, 543, 1, 0, 0, 0, 543, 546, 1, 0, 0, 0, 544, 545, 5, 25, 0, 0, 545, 547, 3, 248, 124, 0, 546, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 548, 1, 0, 0, 0, 548, 549, 5, 9, 0, 0, 549, 550, 3, 204, 102, 0, 550, 17, 1, 0, 0, 0, 551, 552, 5, 37, 0, 0, 552, 554, 7, 0, 0, 0, 553, 555, 3, 172, 86, 0, 554, 553, 1, 0, 0, 0, 554, 555, 1, 0, 0, 0, 555, 556, 1, 0, 0, 0, 556, 559, 3, 176, 88, 0, 557, 558, 5, 34, 0, 0, 558, 560, 3, 314, 157, 0, 559, 557, 1, 0, 0, 0, 559, 560, 1, 0, 0, 0, 560, 563, 1, 0, 0, 0, 561, 562, 5, 24, 0, 0, 562, 564, 3, 314, 157, 0, 563, 561, 1, 0, 0, 0, 563, 564, 1, 0, 0, 0, 564, 19, 1, 0, 0, 0, 565, 566, 5, 37, 0, 0, 566, 567, 5, 166, 0, 0, 567, 568, 3, 358, 179, 0, 568, 21, 1, 0, 0, 0, 569, 571, 5, 37, 0, 0, 570, 572, 5, 12, 0, 0, 571, 570, 1, 0, 0, 0, 571, 572, 1, 0, 0, 0, 572, 573, 1, 0, 0, 0, 573, 575, 5, 84, 0, 0, 574, 576, 3, 172, 86, 0, 575, 574, 1, 0, 0, 0, 575, 576, 1, 0, 0, 0, 576, 577, 1, 0, 0, 0, 577, 590, 3, 180, 90, 0, 578, 587, 5, 265, 0, 0, 579, 584, 3, 328, 164, 0, 580, 581, 5, 263, 0, 0, 581, 583, 3, 328, 164, 0, 582, 580, 1, 0, 0, 0, 583, 586, 1, 0, 0, 0, 584, 582, 1, 0, 0, 0, 584, 585, 1, 0, 0, 0, 585, 588, 1, 0, 0, 0, 586, 584, 1, 0, 0, 0, 587, 579, 1, 0, 0, 0, 587, 588, 1, 0, 0, 0, 588, 589, 1, 0, 0, 0, 589, 591, 5, 266, 0, 0, 590, 578, 1, 0, 0, 0, 590, 591, 1, 0, 0, 0, 591, 592, 1, 0, 0, 0, 592, 593, 5, 160, 0, 0, 593, 596, 3, 328, 164, 0, 594, 595, 5, 102, 0, 0, 595, 597, 3, 328, 164, 0, 596, 594, 1, 0, 0, 0, 596, 597, 1, 0, 0, 0, 597, 598, 1, 0, 0, 0, 598, 599, 5, 24, 0, 0, 599, 603, 5, 274, 0, 0, 600, 601, 5, 104, 0, 0, 601, 602, 5, 249, 0, 0, 602, 604, 5, 274, 0, 0, 603, 600, 1, 0, 0, 0, 603, 604, 1, 0, 0, 0, 604, 605, 1, 0, 0, 0, 605, 606, 5, 206, 0, 0, 606, 607, 5, 249, 0, 0, 607, 608, 5, 274, 0, 0, 608, 609, 5, 126, 0, 0, 609, 610, 5, 249, 0, 0, 610, 614, 5, 274, 0, 0, 611, 612, 5, 18, 0, 0, 612, 613, 5, 249, 0, 0, 613, 615, 5, 274, 0, 0, 614, 611, 1, 0, 0, 0, 614, 615, 1, 0, 0, 0, 615, 619, 1, 0, 0, 0, 616, 617, 5, 20, 0, 0, 617, 618, 5, 249, 0, 0, 618, 620, 5, 274, 0, 0, 619, 616, 1, 0, 0, 0, 619, 620, 1, 0, 0, 0, 620, 624, 1, 0, 0, 0, 621, 622, 5, 187, 0, 0, 622, 623, 5, 249, 0, 0, 623, 625, 5, 274, 0, 0, 624, 621, 1, 0, 0, 0, 624, 625, 1, 0, 0, 0, 625, 629, 1, 0, 0, 0, 626, 627, 5, 76, 0, 0, 627, 628, 5, 249, 0, 0, 628, 630, 5, 274, 0, 0, 629, 626, 1, 0, 0, 0, 629, 630, 1, 0, 0, 0, 630, 23, 1, 0, 0, 0, 631, 632, 5, 37, 0, 0, 632, 634, 5, 84, 0, 0, 633, 635, 3, 172, 86, 0, 634, 633, 1, 0, 0, 0, 634, 635, 1, 0, 0, 0, 635, 636, 1, 0, 0, 0, 636, 649, 3, 180, 90, 0, 637, 646, 5, 265, 0, 0, 638, 643, 3, 328, 164, 0, 639, 640, 5, 263, 0, 0, 640, 642, 3, 328, 164, 0, 641, 639, 1, 0, 0, 0, 642, 645, 1, 0, 0, 0, 643, 641, 1, 0, 0, 0, 643, 644, 1, 0, 0, 0, 644, 647, 1, 0, 0, 0, 645, 643, 1, 0, 0, 0, 646, 638, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 648, 1, 0, 0, 0, 648, 650, 5, 266, 0, 0, 649, 637, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 653, 1, 0, 0, 0, 651, 652, 5, 160, 0, 0, 652, 654, 3, 328, 164, 0, 653, 651, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 656, 5, 24, 0, 0, 656, 657, 5, 274, 0, 0, 657, 658, 5, 186, 0, 0, 658, 659, 5, 249, 0, 0, 659, 660, 3, 314, 157, 0, 660, 25, 1, 0, 0, 0, 661, 680, 3, 28, 14, 0, 662, 680, 3, 62, 31, 0, 663, 680, 3, 60, 30, 0, 664, 680, 3, 58, 29, 0, 665, 680, 3, 54, 27, 0, 666, 680, 3, 56, 28, 0, 667, 680, 3, 52, 26, 0, 668, 680, 3, 48, 24, 0, 669, 680, 3, 50, 25, 0, 670, 680, 3, 46, 23, 0, 671, 680, 3, 44, 22, 0, 672, 680, 3, 42, 21, 0, 673, 680, 3, 40, 20, 0, 674, 680, 3, 34, 17, 0, 675, 680, 3, 30, 15, 0, 676, 680, 3, 32, 16, 0, 677, 680, 3, 36, 18, 0, 678, 680, 3, 38, 19, 0, 679, 661, 1, 0, 0, 0, 679, 662, 1, 0, 0, 0, 679, 663, 1, 0, 0, 0, 679, 664, 1, 0, 0, 0, 679, 665, 1, 0, 0, 0, 679, 666, 1, 0, 0, 0, 679, 667, 1, 0, 0, 0, 679, 668, 1, 0, 0, 0, 679, 669, 1, 0, 0, 0, 679, 670, 1, 0, 0, 0, 679, 671, 1, 0, 0, 0, 679, 672, 1, 0, 0, 0, 679, 673, 1, 0, 0, 0, 679, 674, 1, 0, 0, 0, 679, 675, 1, 0, 0, 0, 679, 676, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 679, 678, 1, 0, 0, 0, 680, 27, 1, 0, 0, 0, 681, 682, 5, 4, 0, 0, 682, 683, 5, 46, 0, 0, 683, 684, 3, 184, 92, 0, 684, 685, 5, 176, 0, 0, 685, 686, 5, 142, 0, 0, 686, 687, 7, 1, 0, 0, 687, 688, 3, 358, 179, 0, 688, 29, 1, 0, 0, 0, 689, 690, 5, 4, 0, 0, 690, 691, 5, 188, 0, 0, 691, 692, 3, 186, 93, 0, 692, 693, 5, 176, 0, 0, 693, 694, 5, 32, 0, 0, 694, 695, 5, 182, 0, 0, 695, 696, 3, 192, 96, 0, 696, 697, 5, 265, 0, 0, 697, 698, 3, 228, 114, 0, 698, 699, 5, 249, 0, 0, 699, 705, 3, 314, 157, 0, 700, 701, 5, 263, 0, 0, 701, 702, 3, 228, 114, 0, 702, 703, 5, 249, 0, 0, 703, 704, 3, 314, 157, 0, 704, 706, 1, 0, 0, 0, 705, 700, 1, 0, 0, 0, 705, 706, 1, 0, 0, 0, 706, 707, 1, 0, 0, 0, 707, 708, 5, 266, 0, 0, 708, 31, 1, 0, 0, 0, 709, 710, 5, 4, 0, 0, 710, 711, 5, 188, 0, 0, 711, 714, 3, 186, 93, 0, 712, 713, 5, 145, 0, 0, 713, 715, 3, 304, 152, 0, 714, 712, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 727, 5, 176, 0, 0, 717, 718, 5, 30, 0, 0, 718, 719, 5, 94, 0, 0, 719, 724, 3, 314, 157, 0, 720, 721, 5, 216, 0, 0, 721, 722, 5, 151, 0, 0, 722, 723, 5, 249, 0, 0, 723, 725, 3, 360, 180, 0, 724, 720, 1, 0, 0, 0, 724, 725, 1, 0, 0, 0, 725, 728, 1, 0, 0, 0, 726, 728, 5, 197, 0, 0, 727, 717, 1, 0, 0, 0, 727, 726, 1, 0, 0, 0, 728, 33, 1, 0, 0, 0, 729, 730, 5, 4, 0, 0, 730, 731, 5, 188, 0, 0, 731, 732, 3, 186, 93, 0, 732, 733, 5, 31, 0, 0, 733, 734, 3, 192, 96, 0, 734, 735, 3, 220, 110, 0, 735, 35, 1, 0, 0, 0, 736, 737, 5, 4, 0, 0, 737, 738, 5, 188, 0, 0, 738, 739, 3, 186, 93, 0, 739, 741, 5, 58, 0, 0, 740, 742, 5, 32, 0, 0, 741, 740, 1, 0, 0, 0, 741, 742, 1, 0, 0, 0, 742, 743, 1, 0, 0, 0, 743, 744, 3, 192, 96, 0, 744, 37, 1, 0, 0, 0, 745, 746, 5, 4, 0, 0, 746, 747, 5, 188, 0, 0, 747, 748, 3, 186, 93, 0, 748, 749, 5, 176, 0, 0, 749, 750, 5, 142, 0, 0, 750, 751, 7, 1, 0, 0, 751, 752, 3, 358, 179, 0, 752, 39, 1, 0, 0, 0, 753, 754, 5, 4, 0, 0, 754, 755, 5, 188, 0, 0, 755, 761, 3, 186, 93, 0, 756, 762, 5, 158, 0, 0, 757, 759, 5, 1, 0, 0, 758, 760, 3, 172, 86, 0, 759, 758, 1, 0, 0, 0, 759, 760, 1, 0, 0, 0, 760, 762, 1, 0, 0, 0, 761, 756, 1, 0, 0, 0, 761, 757, 1, 0, 0, 0, 762, 763, 1, 0, 0, 0, 763, 764, 5, 33, 0, 0, 764, 765, 5, 265, 0, 0, 765, 770, 3, 220, 110, 0, 766, 767, 5, 263, 0, 0, 767, 769, 3, 220, 110, 0, 768, 766, 1, 0, 0, 0, 769, 772, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, 770, 768, 1, 0, 0, 0, 771, 773, 1, 0, 0, 0, 772, 770, 1, 0, 0, 0, 773, 774, 5, 266, 0, 0, 774, 41, 1, 0, 0, 0, 775, 776, 5, 4, 0, 0, 776, 777, 5, 188, 0, 0, 777, 778, 3, 186, 93, 0, 778, 779, 5, 1, 0, 0, 779, 781, 5, 32, 0, 0, 780, 782, 3, 172, 86, 0, 781, 780, 1, 0, 0, 0, 781, 782, 1, 0, 0, 0, 782, 783, 1, 0, 0, 0, 783, 784, 3, 222, 111, 0, 784, 43, 1, 0, 0, 0, 785, 786, 5, 4, 0, 0, 786, 787, 5, 188, 0, 0, 787, 788, 3, 186, 93, 0, 788, 790, 5, 4, 0, 0, 789, 791, 5, 32, 0, 0, 790, 789, 1, 0, 0, 0, 790, 791, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 801, 3, 192, 96, 0, 793, 797, 5, 176, 0, 0, 794, 798, 3, 226, 113, 0, 795, 796, 5, 34, 0, 0, 796, 798, 3, 314, 157, 0, 797, 794, 1, 0, 0, 0, 797, 795, 1, 0, 0, 0, 798, 802, 1, 0, 0, 0, 799, 800, 5, 58, 0, 0, 800, 802, 5, 51, 0, 0, 801, 793, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, 45, 1, 0, 0, 0, 803, 804, 5, 4, 0, 0, 804, 805, 5, 188, 0, 0, 805, 806, 3, 186, 93, 0, 806, 808, 5, 1, 0, 0, 807, 809, 3, 172, 86, 0, 808, 807, 1, 0, 0, 0, 808, 809, 1, 0, 0, 0, 809, 822, 1, 0, 0, 0, 810, 811, 5, 145, 0, 0, 811, 814, 3, 304, 152, 0, 812, 813, 5, 24, 0, 0, 813, 815, 3, 314, 157, 0, 814, 812, 1, 0, 0, 0, 814, 815, 1, 0, 0, 0, 815, 817, 1, 0, 0, 0, 816, 818, 3, 240, 120, 0, 817, 816, 1, 0, 0, 0, 817, 818, 1, 0, 0, 0, 818, 823, 1, 0, 0, 0, 819, 820, 5, 154, 0, 0, 820, 821, 5, 145, 0, 0, 821, 823, 3, 238, 119, 0, 822, 810, 1, 0, 0, 0, 822, 819, 1, 0, 0, 0, 823, 47, 1, 0, 0, 0, 824, 825, 5, 4, 0, 0, 825, 826, 5, 188, 0, 0, 826, 829, 3, 186, 93, 0, 827, 828, 5, 145, 0, 0, 828, 830, 3, 304, 152, 0, 829, 827, 1, 0, 0, 0, 829, 830, 1, 0, 0, 0, 830, 831, 1, 0, 0, 0, 831, 843, 5, 176, 0, 0, 832, 833, 5, 72, 0, 0, 833, 844, 3, 230, 115, 0, 834, 835, 5, 168, 0, 0, 835, 836, 5, 79, 0, 0, 836, 844, 3, 254, 127, 0, 837, 838, 5, 24, 0, 0, 838, 844, 3, 314, 157, 0, 839, 840, 5, 25, 0, 0, 840, 844, 3, 248, 124, 0, 841, 842, 5, 175, 0, 0, 842, 844, 3, 248, 124, 0, 843, 832, 1, 0, 0, 0, 843, 834, 1, 0, 0, 0, 843, 837, 1, 0, 0, 0, 843, 839, 1, 0, 0, 0, 843, 841, 1, 0, 0, 0, 844, 49, 1, 0, 0, 0, 845, 846, 5, 4, 0, 0, 846, 847, 5, 188, 0, 0, 847, 848, 3, 186, 93, 0, 848, 849, 5, 155, 0, 0, 849, 850, 5, 146, 0, 0, 850, 51, 1, 0, 0, 0, 851, 852, 5, 4, 0, 0, 852, 853, 5, 188, 0, 0, 853, 854, 3, 186, 93, 0, 854, 856, 5, 58, 0, 0, 855, 857, 3, 170, 85, 0, 856, 855, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 857, 866, 1, 0, 0, 0, 858, 859, 5, 145, 0, 0, 859, 861, 3, 304, 152, 0, 860, 862, 5, 22, 0, 0, 861, 860, 1, 0, 0, 0, 861, 862, 1, 0, 0, 0, 862, 867, 1, 0, 0, 0, 863, 864, 5, 154, 0, 0, 864, 865, 5, 145, 0, 0, 865, 867, 3, 238, 119, 0, 866, 858, 1, 0, 0, 0, 866, 863, 1, 0, 0, 0, 867, 53, 1, 0, 0, 0, 868, 869, 5, 4, 0, 0, 869, 870, 5, 212, 0, 0, 870, 872, 3, 188, 94, 0, 871, 873, 3, 202, 101, 0, 872, 871, 1, 0, 0, 0, 872, 873, 1, 0, 0, 0, 873, 874, 1, 0, 0, 0, 874, 875, 5, 9, 0, 0, 875, 876, 3, 204, 102, 0, 876, 55, 1, 0, 0, 0, 877, 878, 5, 4, 0, 0, 878, 879, 5, 212, 0, 0, 879, 880, 3, 188, 94, 0, 880, 881, 5, 156, 0, 0, 881, 882, 5, 193, 0, 0, 882, 883, 3, 188, 94, 0, 883, 57, 1, 0, 0, 0, 884, 885, 5, 4, 0, 0, 885, 886, 5, 212, 0, 0, 886, 887, 3, 188, 94, 0, 887, 888, 5, 176, 0, 0, 888, 889, 5, 142, 0, 0, 889, 890, 7, 1, 0, 0, 890, 891, 3, 354, 177, 0, 891, 59, 1, 0, 0, 0, 892, 893, 5, 4, 0, 0, 893, 894, 5, 188, 0, 0, 894, 895, 3, 186, 93, 0, 895, 896, 5, 156, 0, 0, 896, 897, 5, 193, 0, 0, 897, 898, 3, 186, 93, 0, 898, 61, 1, 0, 0, 0, 899, 900, 5, 4, 0, 0, 900, 901, 5, 212, 0, 0, 901, 902, 3, 188, 94, 0, 902, 903, 7, 2, 0, 0, 903, 904, 5, 25, 0, 0, 904, 905, 3, 248, 124, 0, 905, 63, 1, 0, 0, 0, 906, 908, 5, 196, 0, 0, 907, 909, 5, 188, 0, 0, 908, 907, 1, 0, 0, 0, 908, 909, 1, 0, 0, 0, 909, 911, 1, 0, 0, 0, 910, 912, 3, 170, 85, 0, 911, 910, 1, 0, 0, 0, 911, 912, 1, 0, 0, 0, 912, 913, 1, 0, 0, 0, 913, 914, 3, 186, 93, 0, 914, 65, 1, 0, 0, 0, 915, 917, 5, 56, 0, 0, 916, 918, 5, 46, 0, 0, 917, 916, 1, 0, 0, 0, 917, 918, 1, 0, 0, 0, 918, 920, 1, 0, 0, 0, 919, 921, 7, 3, 0, 0, 920, 919, 1, 0, 0, 0, 920, 921, 1, 0, 0, 0, 921, 922, 1, 0, 0, 0, 922, 923, 3, 354, 177, 0, 923, 67, 1, 0, 0, 0, 924, 927, 3, 70, 35, 0, 925, 927, 3, 72, 36, 0, 926, 924, 1, 0, 0, 0, 926, 925, 1, 0, 0, 0, 927, 69, 1, 0, 0, 0, 928, 929, 5, 36, 0, 0, 929, 930, 5, 182, 0, 0, 930, 932, 3, 186, 93, 0, 931, 933, 3, 292, 146, 0, 932, 931, 1, 0, 0, 0, 932, 933, 1, 0, 0, 0, 933, 946, 1, 0, 0, 0, 934, 935, 5, 190, 0, 0, 935, 936, 5, 185, 0, 0, 936, 937, 5, 265, 0, 0, 937, 938, 3, 360, 180, 0, 938, 944, 5, 266, 0, 0, 939, 940, 5, 157, 0, 0, 940, 941, 5, 265, 0, 0, 941, 942, 3, 360, 180, 0, 942, 943, 5, 266, 0, 0, 943, 945, 1, 0, 0, 0, 944, 939, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 947, 1, 0, 0, 0, 946, 934, 1, 0, 0, 0, 946, 947, 1, 0, 0, 0, 947, 71, 1, 0, 0, 0, 948, 949, 5, 36, 0, 0, 949, 950, 5, 96, 0, 0, 950, 951, 5, 182, 0, 0, 951, 957, 3, 186, 93, 0, 952, 953, 5, 145, 0, 0, 953, 954, 5, 265, 0, 0, 954, 955, 3, 304, 152, 0, 955, 956, 5, 266, 0, 0, 956, 958, 1, 0, 0, 0, 957, 952, 1, 0, 0, 0, 957, 958, 1, 0, 0, 0, 958, 73, 1, 0, 0, 0, 959, 966, 3, 86, 43, 0, 960, 966, 3, 84, 42, 0, 961, 966, 3, 82, 41, 0, 962, 966, 3, 78, 39, 0, 963, 966, 3, 80, 40, 0, 964, 966, 3, 76, 38, 0, 965, 959, 1, 0, 0, 0, 965, 960, 1, 0, 0, 0, 965, 961, 1, 0, 0, 0, 965, 962, 1, 0, 0, 0, 965, 963, 1, 0, 0, 0, 965, 964, 1, 0, 0, 0, 966, 75, 1, 0, 0, 0, 967, 968, 5, 58, 0, 0, 968, 970, 7, 0, 0, 0, 969, 971, 3, 170, 85, 0, 970, 969, 1, 0, 0, 0, 970, 971, 1, 0, 0, 0, 971, 972, 1, 0, 0, 0, 972, 974, 3, 184, 92, 0, 973, 975, 7, 4, 0, 0, 974, 973, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 77, 1, 0, 0, 0, 976, 977, 5, 58, 0, 0, 977, 979, 5, 212, 0, 0, 978, 980, 3, 170, 85, 0, 979, 978, 1, 0, 0, 0, 979, 980, 1, 0, 0, 0, 980, 981, 1, 0, 0, 0, 981, 982, 3, 188, 94, 0, 982, 79, 1, 0, 0, 0, 983, 984, 5, 58, 0, 0, 984, 986, 5, 188, 0, 0, 985, 987, 3, 170, 85, 0, 986, 985, 1, 0, 0, 0, 986, 987, 1, 0, 0, 0, 987, 988, 1, 0, 0, 0, 988, 990, 3, 186, 93, 0, 989, 991, 5, 22, 0, 0, 990, 989, 1, 0, 0, 0, 990, 991, 1, 0, 0, 0, 991, 81, 1, 0, 0, 0, 992, 994, 5, 58, 0, 0, 993, 995, 5, 96, 0, 0, 994, 993, 1, 0, 0, 0, 994, 995, 1, 0, 0, 0, 995, 996, 1, 0, 0, 0, 996, 997, 5, 182, 0, 0, 997, 1000, 3, 186, 93, 0, 998, 999, 5, 145, 0, 0, 999, 1001, 3, 304, 152, 0, 1000, 998, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 83, 1, 0, 0, 0, 1002, 1004, 5, 58, 0, 0, 1003, 1005, 5, 12, 0, 0, 1004, 1003, 1, 0, 0, 0, 1004, 1005, 1, 0, 0, 0, 1005, 1006, 1, 0, 0, 0, 1006, 1008, 5, 84, 0, 0, 1007, 1009, 3, 170, 85, 0, 1008, 1007, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 1023, 3, 190, 95, 0, 1011, 1020, 5, 265, 0, 0, 1012, 1017, 3, 328, 164, 0, 1013, 1014, 5, 263, 0, 0, 1014, 1016, 3, 328, 164, 0, 1015, 1013, 1, 0, 0, 0, 1016, 1019, 1, 0, 0, 0, 1017, 1015, 1, 0, 0, 0, 1017, 1018, 1, 0, 0, 0, 1018, 1021, 1, 0, 0, 0, 1019, 1017, 1, 0, 0, 0, 1020, 1012, 1, 0, 0, 0, 1020, 1021, 1, 0, 0, 0, 1021, 1022, 1, 0, 0, 0, 1022, 1024, 5, 266, 0, 0, 1023, 1011, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 85, 1, 0, 0, 0, 1025, 1026, 5, 58, 0, 0, 1026, 1027, 5, 166, 0, 0, 1027, 1028, 3, 358, 179, 0, 1028, 87, 1, 0, 0, 0, 1029, 1032, 3, 90, 45, 0, 1030, 1032, 3, 92, 46, 0, 1031, 1029, 1, 0, 0, 0, 1031, 1030, 1, 0, 0, 0, 1032, 89, 1, 0, 0, 0, 1033, 1034, 5, 86, 0, 0, 1034, 1035, 5, 166, 0, 0, 1035, 1036, 3, 358, 179, 0, 1036, 1037, 5, 193, 0, 0, 1037, 1038, 5, 87, 0, 0, 1038, 1039, 3, 358, 179, 0, 1039, 91, 1, 0, 0, 0, 1040, 1041, 5, 86, 0, 0, 1041, 1042, 3, 350, 175, 0, 1042, 1043, 5, 136, 0, 0, 1043, 1045, 3, 352, 176, 0, 1044, 1046, 3, 354, 177, 0, 1045, 1044, 1, 0, 0, 0, 1045, 1046, 1, 0, 0, 0, 1046, 1047, 1, 0, 0, 0, 1047, 1048, 5, 193, 0, 0, 1048, 1049, 3, 356, 178, 0, 1049, 93, 1, 0, 0, 0, 1050, 1053, 3, 96, 48, 0, 1051, 1053, 3, 98, 49, 0, 1052, 1050, 1, 0, 0, 0, 1052, 1051, 1, 0, 0, 0, 1053, 95, 1, 0, 0, 0, 1054, 1055, 5, 161, 0, 0, 1055, 1056, 5, 166, 0, 0, 1056, 1057, 3, 358, 179, 0, 1057, 1058, 5, 82, 0, 0, 1058, 1059, 5, 87, 0, 0, 1059, 1060, 3, 358, 179, 0, 1060, 97, 1, 0, 0, 0, 1061, 1065, 5, 161, 0, 0, 1062, 1063, 5, 86, 0, 0, 1063, 1064, 5, 137, 0, 0, 1064, 1066, 5, 78, 0, 0, 1065, 1062, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1067, 1, 0, 0, 0, 1067, 1068, 3, 350, 175, 0, 1068, 1069, 5, 136, 0, 0, 1069, 1071, 3, 352, 176, 0, 1070, 1072, 3, 354, 177, 0, 1071, 1070, 1, 0, 0, 0, 1071, 1072, 1, 0, 0, 0, 1072, 1073, 1, 0, 0, 0, 1073, 1079, 5, 82, 0, 0, 1074, 1080, 3, 356, 178, 0, 1075, 1077, 5, 166, 0, 0, 1076, 1075, 1, 0, 0, 0, 1076, 1077, 1, 0, 0, 0, 1077, 1078, 1, 0, 0, 0, 1078, 1080, 3, 358, 179, 0, 1079, 1074, 1, 0, 0, 0, 1079, 1076, 1, 0, 0, 0, 1080, 99, 1, 0, 0, 0, 1081, 1083, 3, 206, 103, 0, 1082, 1081, 1, 0, 0, 0, 1082, 1083, 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 1085, 5, 99, 0, 0, 1085, 1087, 7, 5, 0, 0, 1086, 1088, 5, 188, 0, 0, 1087, 1086, 1, 0, 0, 0, 1087, 1088, 1, 0, 0, 0, 1088, 1089, 1, 0, 0, 0, 1089, 1091, 3, 186, 93, 0, 1090, 1092, 3, 292, 146, 0, 1091, 1090, 1, 0, 0, 0, 1091, 1092, 1, 0, 0, 0, 1092, 1105, 1, 0, 0, 0, 1093, 1094, 5, 145, 0, 0, 1094, 1095, 5, 265, 0, 0, 1095, 1100, 3, 304, 152, 0, 1096, 1097, 5, 263, 0, 0, 1097, 1099, 3, 304, 152, 0, 1098, 1096, 1, 0, 0, 0, 1099, 1102, 1, 0, 0, 0, 1100, 1098, 1, 0, 0, 0, 1100, 1101, 1, 0, 0, 0, 1101, 1103, 1, 0, 0, 0, 1102, 1100, 1, 0, 0, 0, 1103, 1104, 5, 266, 0, 0, 1104, 1106, 1, 0, 0, 0, 1105, 1093, 1, 0, 0, 0, 1105, 1106, 1, 0, 0, 0, 1106, 1107, 1, 0, 0, 0, 1107, 1108, 3, 204, 102, 0, 1108, 101, 1, 0, 0, 0, 1109, 1112, 3, 104, 52, 0, 1110, 1112, 3, 106, 53, 0, 1111, 1109, 1, 0, 0, 0, 1111, 1110, 1, 0, 0, 0, 1112, 103, 1, 0, 0, 0, 1113, 1115, 5, 50, 0, 0, 1114, 1116, 5, 82, 0, 0, 1115, 1114, 1, 0, 0, 0, 1115, 1116, 1, 0, 0, 0, 1116, 1117, 1, 0, 0, 0, 1117, 1120, 3, 186, 93, 0, 1118, 1119, 5, 215, 0, 0, 1119, 1121, 3, 306, 153, 0, 1120, 1118, 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 105, 1, 0, 0, 0, 1122, 1123, 5, 50, 0, 0, 1123, 1128, 3, 186, 93, 0, 1124, 1126, 5, 9, 0, 0, 1125, 1124, 1, 0, 0, 0, 1125, 1126, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1129, 3, 358, 179, 0, 1128, 1125, 1, 0, 0, 0, 1128, 1129, 1, 0, 0, 0, 1129, 1130, 1, 0, 0, 0, 1130, 1139, 5, 82, 0, 0, 1131, 1136, 3, 280, 140, 0, 1132, 1133, 5, 263, 0, 0, 1133, 1135, 3, 280, 140, 0, 1134, 1132, 1, 0, 0, 0, 1135, 1138, 1, 0, 0, 0, 1136, 1134, 1, 0, 0, 0, 1136, 1137, 1, 0, 0, 0, 1137, 1140, 1, 0, 0, 0, 1138, 1136, 1, 0, 0, 0, 1139, 1131, 1, 0, 0, 0, 1139, 1140, 1, 0, 0, 0, 1140, 1143, 1, 0, 0, 0, 1141, 1142, 5, 215, 0, 0, 1142, 1144, 3, 306, 153, 0, 1143, 1141, 1, 0, 0, 0, 1143, 1144, 1, 0, 0, 0, 1144, 107, 1, 0, 0, 0, 1145, 1146, 5, 54, 0, 0, 1146, 1147, 3, 186, 93, 0, 1147, 1148, 5, 176, 0, 0, 1148, 1158, 3, 198, 99, 0, 1149, 1150, 5, 82, 0, 0, 1150, 1155, 3, 280, 140, 0, 1151, 1152, 5, 263, 0, 0, 1152, 1154, 3, 280, 140, 0, 1153, 1151, 1, 0, 0, 0, 1154, 1157, 1, 0, 0, 0, 1155, 1153, 1, 0, 0, 0, 1155, 1156, 1, 0, 0, 0, 1156, 1159, 1, 0, 0, 0, 1157, 1155, 1, 0, 0, 0, 1158, 1149, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1162, 1, 0, 0, 0, 1160, 1161, 5, 215, 0, 0, 1161, 1163, 3, 306, 153, 0, 1162, 1160, 1, 0, 0, 0, 1162, 1163, 1, 0, 0, 0, 1163, 109, 1, 0, 0, 0, 1164, 1165, 5, 207, 0, 0, 1165, 1167, 5, 103, 0, 0, 1166, 1168, 5, 188, 0, 0, 1167, 1166, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1169, 1, 0, 0, 0, 1169, 1171, 3, 186, 93, 0, 1170, 1172, 3, 292, 146, 0, 1171, 1170, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 1173, 1, 0, 0, 0, 1173, 1174, 3, 204, 102, 0, 1174, 111, 1, 0, 0, 0, 1175, 1188, 3, 132, 66, 0, 1176, 1188, 3, 134, 67, 0, 1177, 1188, 3, 136, 68, 0, 1178, 1188, 3, 130, 65, 0, 1179, 1188, 3, 128, 64, 0, 1180, 1188, 3, 126, 63, 0, 1181, 1188, 3, 124, 62, 0, 1182, 1188, 3, 122, 61, 0, 1183, 1188, 3, 120, 60, 0, 1184, 1188, 3, 118, 59, 0, 1185, 1188, 3, 116, 58, 0, 1186, 1188, 3, 114, 57, 0, 1187, 1175, 1, 0, 0, 0, 1187, 1176, 1, 0, 0, 0, 1187, 1177, 1, 0, 0, 0, 1187, 1178, 1, 0, 0, 0, 1187, 1179, 1, 0, 0, 0, 1187, 1180, 1, 0, 0, 0, 1187, 1181, 1, 0, 0, 0, 1187, 1182, 1, 0, 0, 0, 1187, 1183, 1, 0, 0, 0, 1187, 1184, 1, 0, 0, 0, 1187, 1185, 1, 0, 0, 0, 1187, 1186, 1, 0, 0, 0, 1188, 113, 1, 0, 0, 0, 1189, 1190, 5, 179, 0, 0, 1190, 1202, 7, 6, 0, 0, 1191, 1193, 5, 115, 0, 0, 1192, 1191, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1199, 3, 314, 157, 0, 1195, 1196, 5, 271, 0, 0, 1196, 1198, 3, 314, 157, 0, 1197, 1195, 1, 0, 0, 0, 1198, 1201, 1, 0, 0, 0, 1199, 1197, 1, 0, 0, 0, 1199, 1200, 1, 0, 0, 0, 1200, 1203, 1, 0, 0, 0, 1201, 1199, 1, 0, 0, 0, 1202, 1192, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 115, 1, 0, 0, 0, 1204, 1205, 5, 179, 0, 0, 1205, 1208, 5, 189, 0, 0, 1206, 1207, 5, 94, 0, 0, 1207, 1209, 3, 186, 93, 0, 1208, 1206, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 1221, 1, 0, 0, 0, 1210, 1212, 5, 115, 0, 0, 1211, 1210, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1213, 1, 0, 0, 0, 1213, 1218, 3, 314, 157, 0, 1214, 1215, 5, 271, 0, 0, 1215, 1217, 3, 314, 157, 0, 1216, 1214, 1, 0, 0, 0, 1217, 1220, 1, 0, 0, 0, 1218, 1216, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, 1222, 1, 0, 0, 0, 1220, 1218, 1, 0, 0, 0, 1221, 1211, 1, 0, 0, 0, 1221, 1222, 1, 0, 0, 0, 1222, 117, 1, 0, 0, 0, 1223, 1225, 5, 179, 0, 0, 1224, 1226, 7, 7, 0, 0, 1225, 1224, 1, 0, 0, 0, 1225, 1226, 1, 0, 0, 0, 1226, 1227, 1, 0, 0, 0, 1227, 1230, 5, 85, 0, 0, 1228, 1229, 5, 94, 0, 0, 1229, 1231, 3, 184, 92, 0, 1230, 1228, 1, 0, 0, 0, 1230, 1231, 1, 0, 0, 0, 1231, 1243, 1, 0, 0, 0, 1232, 1234, 5, 115, 0, 0, 1233, 1232, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1240, 3, 314, 157, 0, 1236, 1237, 5, 271, 0, 0, 1237, 1239, 3, 314, 157, 0, 1238, 1236, 1, 0, 0, 0, 1239, 1242, 1, 0, 0, 0, 1240, 1238, 1, 0, 0, 0, 1240, 1241, 1, 0, 0, 0, 1241, 1244, 1, 0, 0, 0, 1242, 1240, 1, 0, 0, 0, 1243, 1233, 1, 0, 0, 0, 1243, 1244, 1, 0, 0, 0, 1244, 119, 1, 0, 0, 0, 1245, 1246, 5, 179, 0, 0, 1246, 1247, 5, 37, 0, 0, 1247, 1248, 5, 188, 0, 0, 1248, 1249, 3, 186, 93, 0, 1249, 121, 1, 0, 0, 0, 1250, 1251, 5, 179, 0, 0, 1251, 1252, 5, 37, 0, 0, 1252, 1253, 5, 212, 0, 0, 1253, 1254, 3, 188, 94, 0, 1254, 123, 1, 0, 0, 0, 1255, 1256, 5, 179, 0, 0, 1256, 1257, 5, 188, 0, 0, 1257, 1258, 5, 182, 0, 0, 1258, 1259, 3, 186, 93, 0, 1259, 125, 1, 0, 0, 0, 1260, 1261, 5, 179, 0, 0, 1261, 1262, 5, 32, 0, 0, 1262, 1263, 5, 182, 0, 0, 1263, 1264, 3, 186, 93, 0, 1264, 127, 1, 0, 0, 0, 1265, 1267, 5, 179, 0, 0, 1266, 1268, 5, 154, 0, 0, 1267, 1266, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, 1270, 5, 146, 0, 0, 1270, 1271, 3, 186, 93, 0, 1271, 129, 1, 0, 0, 0, 1272, 1273, 5, 179, 0, 0, 1273, 1274, 5, 73, 0, 0, 1274, 1275, 5, 94, 0, 0, 1275, 1285, 3, 186, 93, 0, 1276, 1277, 5, 145, 0, 0, 1277, 1278, 5, 265, 0, 0, 1278, 1281, 3, 304, 152, 0, 1279, 1280, 5, 263, 0, 0, 1280, 1282, 3, 304, 152, 0, 1281, 1279, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1283, 1, 0, 0, 0, 1283, 1284, 5, 266, 0, 0, 1284, 1286, 1, 0, 0, 0, 1285, 1276, 1, 0, 0, 0, 1285, 1286, 1, 0, 0, 0, 1286, 131, 1, 0, 0, 0, 1287, 1289, 5, 179, 0, 0, 1288, 1290, 5, 39, 0, 0, 1289, 1288, 1, 0, 0, 0, 1289, 1290, 1, 0, 0, 0, 1290, 1291, 1, 0, 0, 0, 1291, 1292, 5, 167, 0, 0, 1292, 133, 1, 0, 0, 0, 1293, 1294, 5, 179, 0, 0, 1294, 1295, 5, 166, 0, 0, 1295, 1296, 5, 86, 0, 0, 1296, 1297, 5, 87, 0, 0, 1297, 1298, 3, 358, 179, 0, 1298, 135, 1, 0, 0, 0, 1299, 1314, 3, 138, 69, 0, 1300, 1314, 3, 140, 70, 0, 1301, 1314, 3, 142, 71, 0, 1302, 1303, 5, 179, 0, 0, 1303, 1304, 5, 86, 0, 0, 1304, 1305, 7, 8, 0, 0, 1305, 1311, 3, 358, 179, 0, 1306, 1307, 5, 136, 0, 0, 1307, 1309, 7, 9, 0, 0, 1308, 1310, 3, 354, 177, 0, 1309, 1308, 1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 1312, 1, 0, 0, 0, 1311, 1306, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1314, 1, 0, 0, 0, 1313, 1299, 1, 0, 0, 0, 1313, 1300, 1, 0, 0, 0, 1313, 1301, 1, 0, 0, 0, 1313, 1302, 1, 0, 0, 0, 1314, 137, 1, 0, 0, 0, 1315, 1316, 5, 179, 0, 0, 1316, 1317, 5, 86, 0, 0, 1317, 1318, 7, 8, 0, 0, 1318, 1324, 3, 358, 179, 0, 1319, 1320, 5, 136, 0, 0, 1320, 1322, 5, 46, 0, 0, 1321, 1323, 3, 184, 92, 0, 1322, 1321, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 1325, 1, 0, 0, 0, 1324, 1319, 1, 0, 0, 0, 1324, 1325, 1, 0, 0, 0, 1325, 139, 1, 0, 0, 0, 1326, 1327, 5, 179, 0, 0, 1327, 1328, 5, 86, 0, 0, 1328, 1329, 7, 8, 0, 0, 1329, 1335, 3, 358, 179, 0, 1330, 1331, 5, 136, 0, 0, 1331, 1333, 5, 188, 0, 0, 1332, 1334, 3, 186, 93, 0, 1333, 1332, 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 1336, 1, 0, 0, 0, 1335, 1330, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, 141, 1, 0, 0, 0, 1337, 1338, 5, 179, 0, 0, 1338, 1339, 5, 86, 0, 0, 1339, 1340, 7, 8, 0, 0, 1340, 1346, 3, 358, 179, 0, 1341, 1342, 5, 136, 0, 0, 1342, 1344, 5, 32, 0, 0, 1343, 1345, 3, 192, 96, 0, 1344, 1343, 1, 0, 0, 0, 1344, 1345, 1, 0, 0, 0, 1345, 1347, 1, 0, 0, 0, 1346, 1341, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 143, 1, 0, 0, 0, 1348, 1352, 3, 146, 73, 0, 1349, 1352, 3, 148, 74, 0, 1350, 1352, 3, 150, 75, 0, 1351, 1348, 1, 0, 0, 0, 1351, 1349, 1, 0, 0, 0, 1351, 1350, 1, 0, 0, 0, 1352, 145, 1, 0, 0, 0, 1353, 1354, 5, 34, 0, 0, 1354, 1355, 5, 136, 0, 0, 1355, 1356, 5, 46, 0, 0, 1356, 1357, 3, 184, 92, 0, 1357, 1360, 5, 108, 0, 0, 1358, 1361, 3, 314, 157, 0, 1359, 1361, 5, 133, 0, 0, 1360, 1358, 1, 0, 0, 0, 1360, 1359, 1, 0, 0, 0, 1361, 147, 1, 0, 0, 0, 1362, 1363, 5, 34, 0, 0, 1363, 1364, 5, 136, 0, 0, 1364, 1365, 5, 188, 0, 0, 1365, 1366, 3, 186, 93, 0, 1366, 1369, 5, 108, 0, 0, 1367, 1370, 3, 314, 157, 0, 1368, 1370, 5, 133, 0, 0, 1369, 1367, 1, 0, 0, 0, 1369, 1368, 1, 0, 0, 0, 1370, 149, 1, 0, 0, 0, 1371, 1372, 5, 34, 0, 0, 1372, 1373, 5, 136, 0, 0, 1373, 1374, 5, 32, 0, 0, 1374, 1375, 3, 192, 96, 0, 1375, 1378, 5, 108, 0, 0, 1376, 1379, 3, 314, 157, 0, 1377, 1379, 5, 133, 0, 0, 1378, 1376, 1, 0, 0, 0, 1378, 1377, 1, 0, 0, 0, 1379, 151, 1, 0, 0, 0, 1380, 1381, 5, 67, 0, 0, 1381, 1382, 3, 4, 2, 0, 1382, 153, 1, 0, 0, 0, 1383, 1389, 5, 176, 0, 0, 1384, 1390, 5, 2, 0, 0, 1385, 1386, 3, 358, 179, 0, 1386, 1387, 5, 249, 0, 0, 1387, 1388, 3, 304, 152, 0, 1388, 1390, 1, 0, 0, 0, 1389, 1384, 1, 0, 0, 0, 1389, 1385, 1, 0, 0, 0, 1389, 1390, 1, 0, 0, 0, 1390, 155, 1, 0, 0, 0, 1391, 1392, 5, 264, 0, 0, 1392, 1393, 5, 180, 0, 0, 1393, 1403, 5, 265, 0, 0, 1394, 1396, 3, 314, 157, 0, 1395, 1394, 1, 0, 0, 0, 1395, 1396, 1, 0, 0, 0, 1396, 1404, 1, 0, 0, 0, 1397, 1400, 3, 314, 157, 0, 1398, 1399, 5, 263, 0, 0, 1399, 1401, 3, 304, 152, 0, 1400, 1398, 1, 0, 0, 0, 1400, 1401, 1, 0, 0, 0, 1401, 1404, 1, 0, 0, 0, 1402, 1404, 3, 304, 152, 0, 1403, 1395, 1, 0, 0, 0, 1403, 1397, 1, 0, 0, 0, 1403, 1402, 1, 0, 0, 0, 1404, 1405, 1, 0, 0, 0, 1405, 1406, 5, 266, 0, 0, 1406, 157, 1, 0, 0, 0, 1407, 1408, 5, 107, 0, 0, 1408, 1409, 5, 121, 0, 0, 1409, 1410, 3, 186, 93, 0, 1410, 159, 1, 0, 0, 0, 1411, 1412, 5, 118, 0, 0, 1412, 1413, 5, 45, 0, 0, 1413, 1414, 5, 98, 0, 0, 1414, 1416, 5, 274, 0, 0, 1415, 1417, 5, 144, 0, 0, 1416, 1415, 1, 0, 0, 0, 1416, 1417, 1, 0, 0, 0, 1417, 1418, 1, 0, 0, 0, 1418, 1419, 5, 103, 0, 0, 1419, 1420, 5, 188, 0, 0, 1420, 1430, 3, 186, 93, 0, 1421, 1422, 5, 145, 0, 0, 1422, 1423, 5, 265, 0, 0, 1423, 1426, 3, 304, 152, 0, 1424, 1425, 5, 263, 0, 0, 1425, 1427, 3, 304, 152, 0, 1426, 1424, 1, 0, 0, 0, 1426, 1427, 1, 0, 0, 0, 1427, 1428, 1, 0, 0, 0, 1428, 1429, 5, 266, 0, 0, 1429, 1431, 1, 0, 0, 0, 1430, 1421, 1, 0, 0, 0, 1430, 1431, 1, 0, 0, 0, 1431, 161, 1, 0, 0, 0, 1432, 1436, 3, 164, 82, 0, 1433, 1436, 3, 166, 83, 0, 1434, 1436, 3, 168, 84, 0, 1435, 1432, 1, 0, 0, 0, 1435, 1433, 1, 0, 0, 0, 1435, 1434, 1, 0, 0, 0, 1436, 163, 1, 0, 0, 0, 1437, 1438, 5, 162, 0, 0, 1438, 1451, 3, 186, 93, 0, 1439, 1440, 5, 145, 0, 0, 1440, 1441, 5, 265, 0, 0, 1441, 1446, 3, 304, 152, 0, 1442, 1443, 5, 263, 0, 0, 1443, 1445, 3, 304, 152, 0, 1444, 1442, 1, 0, 0, 0, 1445, 1448, 1, 0, 0, 0, 1446, 1447, 1, 0, 0, 0, 1446, 1444, 1, 0, 0, 0, 1447, 1449, 1, 0, 0, 0, 1448, 1446, 1, 0, 0, 0, 1449, 1450, 5, 266, 0, 0, 1450, 1452, 1, 0, 0, 0, 1451, 1439, 1, 0, 0, 0, 1451, 1452, 1, 0, 0, 0, 1452, 165, 1, 0, 0, 0, 1453, 1454, 5, 162, 0, 0, 1454, 1455, 5, 13, 0, 0, 1455, 167, 1, 0, 0, 0, 1456, 1457, 5, 162, 0, 0, 1457, 1458, 5, 85, 0, 0, 1458, 1459, 3, 190, 95, 0, 1459, 169, 1, 0, 0, 0, 1460, 1461, 5, 93, 0, 0, 1461, 1462, 5, 66, 0, 0, 1462, 171, 1, 0, 0, 0, 1463, 1464, 5, 93, 0, 0, 1464, 1465, 5, 132, 0, 0, 1465, 1466, 5, 66, 0, 0, 1466, 173, 1, 0, 0, 0, 1467, 1468, 3, 354, 177, 0, 1468, 175, 1, 0, 0, 0, 1469, 1470, 3, 354, 177, 0, 1470, 177, 1, 0, 0, 0, 1471, 1472, 3, 354, 177, 0, 1472, 179, 1, 0, 0, 0, 1473, 1474, 3, 354, 177, 0, 1474, 181, 1, 0, 0, 0, 1475, 1476, 3, 354, 177, 0, 1476, 183, 1, 0, 0, 0, 1477, 1478, 3, 354, 177, 0, 1478, 185, 1, 0, 0, 0, 1479, 1484, 3, 358, 179, 0, 1480, 1481, 5, 261, 0, 0, 1481, 1483, 3, 358, 179, 0, 1482, 1480, 1, 0, 0, 0, 1483, 1486, 1, 0, 0, 0, 1484, 1482, 1, 0, 0, 0, 1484, 1485, 1, 0, 0, 0, 1485, 187, 1, 0, 0, 0, 1486, 1484, 1, 0, 0, 0, 1487, 1492, 3, 358, 179, 0, 1488, 1489, 5, 261, 0, 0, 1489, 1491, 3, 358, 179, 0, 1490, 1488, 1, 0, 0, 0, 1491, 1494, 1, 0, 0, 0, 1492, 1490, 1, 0, 0, 0, 1492, 1493, 1, 0, 0, 0, 1493, 189, 1, 0, 0, 0, 1494, 1492, 1, 0, 0, 0, 1495, 1498, 3, 362, 181, 0, 1496, 1498, 3, 354, 177, 0, 1497, 1495, 1, 0, 0, 0, 1497, 1496, 1, 0, 0, 0, 1498, 191, 1, 0, 0, 0, 1499, 1502, 3, 354, 177, 0, 1500, 1502, 4, 96, 0, 0, 1501, 1499, 1, 0, 0, 0, 1501, 1500, 1, 0, 0, 0, 1502, 193, 1, 0, 0, 0, 1503, 1506, 3, 186, 93, 0, 1504, 1506, 3, 188, 94, 0, 1505, 1503, 1, 0, 0, 0, 1505, 1504, 1, 0, 0, 0, 1506, 195, 1, 0, 0, 0, 1507, 1508, 5, 21, 0, 0, 1508, 1509, 5, 26, 0, 0, 1509, 1511, 3, 292, 146, 0, 1510, 1507, 1, 0, 0, 0, 1510, 1511, 1, 0, 0, 0, 1511, 1514, 1, 0, 0, 0, 1512, 1513, 5, 34, 0, 0, 1513, 1515, 3, 314, 157, 0, 1514, 1512, 1, 0, 0, 0, 1514, 1515, 1, 0, 0, 0, 1515, 1519, 1, 0, 0, 0, 1516, 1517, 5, 168, 0, 0, 1517, 1518, 5, 79, 0, 0, 1518, 1520, 3, 254, 127, 0, 1519, 1516, 1, 0, 0, 0, 1519, 1520, 1, 0, 0, 0, 1520, 1524, 1, 0, 0, 0, 1521, 1522, 5, 216, 0, 0, 1522, 1523, 5, 175, 0, 0, 1523, 1525, 3, 248, 124, 0, 1524, 1521, 1, 0, 0, 0, 1524, 1525, 1, 0, 0, 0, 1525, 1529, 1, 0, 0, 0, 1526, 1527, 5, 23, 0, 0, 1527, 1528, 5, 9, 0, 0, 1528, 1530, 3, 230, 115, 0, 1529, 1526, 1, 0, 0, 0, 1529, 1530, 1, 0, 0, 0, 1530, 1533, 1, 0, 0, 0, 1531, 1532, 5, 24, 0, 0, 1532, 1534, 3, 314, 157, 0, 1533, 1531, 1, 0, 0, 0, 1533, 1534, 1, 0, 0, 0, 1534, 1545, 1, 0, 0, 0, 1535, 1536, 5, 30, 0, 0, 1536, 1537, 5, 94, 0, 0, 1537, 1542, 3, 354, 177, 0, 1538, 1539, 5, 216, 0, 0, 1539, 1540, 5, 151, 0, 0, 1540, 1541, 5, 249, 0, 0, 1541, 1543, 5, 277, 0, 0, 1542, 1538, 1, 0, 0, 0, 1542, 1543, 1, 0, 0, 0, 1543, 1546, 1, 0, 0, 0, 1544, 1546, 5, 197, 0, 0, 1545, 1535, 1, 0, 0, 0, 1545, 1544, 1, 0, 0, 0, 1545, 1546, 1, 0, 0, 0, 1546, 1549, 1, 0, 0, 0, 1547, 1548, 5, 25, 0, 0, 1548, 1550, 3, 248, 124, 0, 1549, 1547, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 197, 1, 0, 0, 0, 1551, 1556, 3, 200, 100, 0, 1552, 1553, 5, 263, 0, 0, 1553, 1555, 3, 200, 100, 0, 1554, 1552, 1, 0, 0, 0, 1555, 1558, 1, 0, 0, 0, 1556, 1554, 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0, 1557, 199, 1, 0, 0, 0, 1558, 1556, 1, 0, 0, 0, 1559, 1560, 3, 354, 177, 0, 1560, 1561, 5, 249, 0, 0, 1561, 1562, 3, 304, 152, 0, 1562, 201, 1, 0, 0, 0, 1563, 1564, 5, 265, 0, 0, 1564, 1567, 3, 182, 91, 0, 1565, 1566, 5, 34, 0, 0, 1566, 1568, 3, 314, 157, 0, 1567, 1565, 1, 0, 0, 0, 1567, 1568, 1, 0, 0, 0, 1568, 1577, 1, 0, 0, 0, 1569, 1570, 5, 263, 0, 0, 1570, 1573, 3, 182, 91, 0, 1571, 1572, 5, 34, 0, 0, 1572, 1574, 3, 314, 157, 0, 1573, 1571, 1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, 1576, 1, 0, 0, 0, 1575, 1569, 1, 0, 0, 0, 1576, 1579, 1, 0, 0, 0, 1577, 1575, 1, 0, 0, 0, 1577, 1578, 1, 0, 0, 0, 1578, 1580, 1, 0, 0, 0, 1579, 1577, 1, 0, 0, 0, 1580, 1581, 5, 266, 0, 0, 1581, 203, 1, 0, 0, 0, 1582, 1584, 3, 206, 103, 0, 1583, 1582, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1586, 3, 258, 129, 0, 1586, 205, 1, 0, 0, 0, 1587, 1588, 5, 216, 0, 0, 1588, 1593, 3, 274, 137, 0, 1589, 1590, 5, 263, 0, 0, 1590, 1592, 3, 274, 137, 0, 1591, 1589, 1, 0, 0, 0, 1592, 1595, 1, 0, 0, 0, 1593, 1591, 1, 0, 0, 0, 1593, 1594, 1, 0, 0, 0, 1594, 207, 1, 0, 0, 0, 1595, 1593, 1, 0, 0, 0, 1596, 1597, 5, 150, 0, 0, 1597, 1598, 5, 110, 0, 0, 1598, 1600, 3, 292, 146, 0, 1599, 1601, 5, 53, 0, 0, 1600, 1599, 1, 0, 0, 0, 1600, 1601, 1, 0, 0, 0, 1601, 1605, 1, 0, 0, 0, 1602, 1606, 5, 225, 0, 0, 1603, 1604, 5, 263, 0, 0, 1604, 1606, 5, 225, 0, 0, 1605, 1602, 1, 0, 0, 0, 1605, 1603, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, 1606, 1610, 1, 0, 0, 0, 1607, 1611, 5, 226, 0, 0, 1608, 1609, 5, 263, 0, 0, 1609, 1611, 5, 226, 0, 0, 1610, 1607, 1, 0, 0, 0, 1610, 1608, 1, 0, 0, 0, 1610, 1611, 1, 0, 0, 0, 1611, 1624, 1, 0, 0, 0, 1612, 1613, 5, 263, 0, 0, 1613, 1616, 3, 210, 105, 0, 1614, 1616, 3, 210, 105, 0, 1615, 1612, 1, 0, 0, 0, 1615, 1614, 1, 0, 0, 0, 1616, 1621, 1, 0, 0, 0, 1617, 1618, 5, 263, 0, 0, 1618, 1620, 3, 210, 105, 0, 1619, 1617, 1, 0, 0, 0, 1620, 1623, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1621, 1619, 1, 0, 0, 0, 1622, 1625, 1, 0, 0, 0, 1623, 1621, 1, 0, 0, 0, 1624, 1615, 1, 0, 0, 0, 1624, 1625, 1, 0, 0, 0, 1625, 209, 1, 0, 0, 0, 1626, 1627, 5, 81, 0, 0, 1627, 1628, 5, 110, 0, 0, 1628, 1629, 3, 292, 146, 0, 1629, 1630, 5, 224, 0, 0, 1630, 1631, 3, 186, 93, 0, 1631, 1633, 3, 292, 146, 0, 1632, 1634, 5, 53, 0, 0, 1633, 1632, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 1636, 1, 0, 0, 0, 1635, 1637, 5, 225, 0, 0, 1636, 1635, 1, 0, 0, 0, 1636, 1637, 1, 0, 0, 0, 1637, 1639, 1, 0, 0, 0, 1638, 1640, 5, 226, 0, 0, 1639, 1638, 1, 0, 0, 0, 1639, 1640, 1, 0, 0, 0, 1640, 211, 1, 0, 0, 0, 1641, 1642, 3, 192, 96, 0, 1642, 1645, 3, 328, 164, 0, 1643, 1644, 5, 34, 0, 0, 1644, 1646, 3, 314, 157, 0, 1645, 1643, 1, 0, 0, 0, 1645, 1646, 1, 0, 0, 0, 1646, 213, 1, 0, 0, 0, 1647, 1648, 3, 182, 91, 0, 1648, 1651, 3, 328, 164, 0, 1649, 1650, 5, 34, 0, 0, 1650, 1652, 3, 314, 157, 0, 1651, 1649, 1, 0, 0, 0, 1651, 1652, 1, 0, 0, 0, 1652, 215, 1, 0, 0, 0, 1653, 1654, 3, 218, 109, 0, 1654, 217, 1, 0, 0, 0, 1655, 1656, 3, 182, 91, 0, 1656, 1664, 3, 328, 164, 0, 1657, 1661, 3, 224, 112, 0, 1658, 1660, 3, 224, 112, 0, 1659, 1658, 1, 0, 0, 0, 1660, 1663, 1, 0, 0, 0, 1661, 1662, 1, 0, 0, 0, 1661, 1659, 1, 0, 0, 0, 1662, 1665, 1, 0, 0, 0, 1663, 1661, 1, 0, 0, 0, 1664, 1657, 1, 0, 0, 0, 1664, 1665, 1, 0, 0, 0, 1665, 1668, 1, 0, 0, 0, 1666, 1667, 5, 34, 0, 0, 1667, 1669, 3, 314, 157, 0, 1668, 1666, 1, 0, 0, 0, 1668, 1669, 1, 0, 0, 0, 1669, 1672, 1, 0, 0, 0, 1670, 1671, 5, 150, 0, 0, 1671, 1673, 5, 110, 0, 0, 1672, 1670, 1, 0, 0, 0, 1672, 1673, 1, 0, 0, 0, 1673, 219, 1, 0, 0, 0, 1674, 1682, 3, 212, 106, 0, 1675, 1679, 3, 224, 112, 0, 1676, 1678, 3, 224, 112, 0, 1677, 1676, 1, 0, 0, 0, 1678, 1681, 1, 0, 0, 0, 1679, 1680, 1, 0, 0, 0, 1679, 1677, 1, 0, 0, 0, 1680, 1683, 1, 0, 0, 0, 1681, 1679, 1, 0, 0, 0, 1682, 1675, 1, 0, 0, 0, 1682, 1683, 1, 0, 0, 0, 1683, 221, 1, 0, 0, 0, 1684, 1685, 3, 182, 91, 0, 1685, 1688, 3, 328, 164, 0, 1686, 1687, 5, 34, 0, 0, 1687, 1689, 3, 314, 157, 0, 1688, 1686, 1, 0, 0, 0, 1688, 1689, 1, 0, 0, 0, 1689, 1697, 1, 0, 0, 0, 1690, 1694, 3, 224, 112, 0, 1691, 1693, 3, 224, 112, 0, 1692, 1691, 1, 0, 0, 0, 1693, 1696, 1, 0, 0, 0, 1694, 1695, 1, 0, 0, 0, 1694, 1692, 1, 0, 0, 0, 1695, 1698, 1, 0, 0, 0, 1696, 1694, 1, 0, 0, 0, 1697, 1690, 1, 0, 0, 0, 1697, 1698, 1, 0, 0, 0, 1698, 223, 1, 0, 0, 0, 1699, 1701, 5, 132, 0, 0, 1700, 1699, 1, 0, 0, 0, 1700, 1701, 1, 0, 0, 0, 1701, 1702, 1, 0, 0, 0, 1702, 1705, 5, 133, 0, 0, 1703, 1705, 3, 226, 113, 0, 1704, 1700, 1, 0, 0, 0, 1704, 1703, 1, 0, 0, 0, 1705, 225, 1, 0, 0, 0, 1706, 1707, 5, 60, 0, 0, 1707, 1715, 3, 304, 152, 0, 1708, 1709, 5, 35, 0, 0, 1709, 1715, 3, 304, 152, 0, 1710, 1711, 5, 51, 0, 0, 1711, 1715, 3, 304, 152, 0, 1712, 1713, 5, 16, 0, 0, 1713, 1715, 3, 360, 180, 0, 1714, 1706, 1, 0, 0, 0, 1714, 1708, 1, 0, 0, 0, 1714, 1710, 1, 0, 0, 0, 1714, 1712, 1, 0, 0, 0, 1715, 227, 1, 0, 0, 0, 1716, 1717, 7, 10, 0, 0, 1717, 229, 1, 0, 0, 0, 1718, 1719, 7, 11, 0, 0, 1719, 231, 1, 0, 0, 0, 1720, 1725, 3, 234, 117, 0, 1721, 1722, 5, 263, 0, 0, 1722, 1724, 3, 234, 117, 0, 1723, 1721, 1, 0, 0, 0, 1724, 1727, 1, 0, 0, 0, 1725, 1726, 1, 0, 0, 0, 1725, 1723, 1, 0, 0, 0, 1726, 1730, 1, 0, 0, 0, 1727, 1725, 1, 0, 0, 0, 1728, 1729, 5, 263, 0, 0, 1729, 1731, 3, 236, 118, 0, 1730, 1728, 1, 0, 0, 0, 1730, 1731, 1, 0, 0, 0, 1731, 1734, 1, 0, 0, 0, 1732, 1734, 3, 236, 118, 0, 1733, 1720, 1, 0, 0, 0, 1733, 1732, 1, 0, 0, 0, 1734, 233, 1, 0, 0, 0, 1735, 1737, 5, 89, 0, 0, 1736, 1738, 3, 292, 146, 0, 1737, 1736, 1, 0, 0, 0, 1737, 1738, 1, 0, 0, 0, 1738, 1739, 1, 0, 0, 0, 1739, 1740, 5, 146, 0, 0, 1740, 1741, 3, 360, 180, 0, 1741, 235, 1, 0, 0, 0, 1742, 1744, 5, 154, 0, 0, 1743, 1745, 3, 292, 146, 0, 1744, 1743, 1, 0, 0, 0, 1744, 1745, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 1747, 5, 265, 0, 0, 1747, 1748, 5, 145, 0, 0, 1748, 1754, 3, 238, 119, 0, 1749, 1750, 5, 263, 0, 0, 1750, 1751, 5, 145, 0, 0, 1751, 1753, 3, 238, 119, 0, 1752, 1749, 1, 0, 0, 0, 1753, 1756, 1, 0, 0, 0, 1754, 1755, 1, 0, 0, 0, 1754, 1752, 1, 0, 0, 0, 1755, 1757, 1, 0, 0, 0, 1756, 1754, 1, 0, 0, 0, 1757, 1758, 5, 266, 0, 0, 1758, 237, 1, 0, 0, 0, 1759, 1760, 5, 210, 0, 0, 1760, 1761, 3, 244, 122, 0, 1761, 1762, 3, 304, 152, 0, 1762, 1775, 1, 0, 0, 0, 1763, 1764, 3, 304, 152, 0, 1764, 1765, 3, 242, 121, 0, 1765, 1767, 1, 0, 0, 0, 1766, 1763, 1, 0, 0, 0, 1766, 1767, 1, 0, 0, 0, 1767, 1768, 1, 0, 0, 0, 1768, 1772, 5, 211, 0, 0, 1769, 1770, 3, 242, 121, 0, 1770, 1771, 3, 304, 152, 0, 1771, 1773, 1, 0, 0, 0, 1772, 1769, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1775, 1, 0, 0, 0, 1774, 1759, 1, 0, 0, 0, 1774, 1766, 1, 0, 0, 0, 1775, 239, 1, 0, 0, 0, 1776, 1777, 5, 30, 0, 0, 1777, 1778, 5, 94, 0, 0, 1778, 1783, 3, 358, 179, 0, 1779, 1780, 5, 216, 0, 0, 1780, 1781, 5, 151, 0, 0, 1781, 1782, 5, 249, 0, 0, 1782, 1784, 3, 360, 180, 0, 1783, 1779, 1, 0, 0, 0, 1783, 1784, 1, 0, 0, 0, 1784, 1787, 1, 0, 0, 0, 1785, 1787, 5, 197, 0, 0, 1786, 1776, 1, 0, 0, 0, 1786, 1785, 1, 0, 0, 0, 1787, 241, 1, 0, 0, 0, 1788, 1794, 1, 0, 0, 0, 1789, 1794, 5, 251, 0, 0, 1790, 1794, 5, 252, 0, 0, 1791, 1794, 5, 253, 0, 0, 1792, 1794, 5, 254, 0, 0, 1793, 1788, 1, 0, 0, 0, 1793, 1789, 1, 0, 0, 0, 1793, 1790, 1, 0, 0, 0, 1793, 1791, 1, 0, 0, 0, 1793, 1792, 1, 0, 0, 0, 1794, 243, 1, 0, 0, 0, 1795, 1804, 5, 249, 0, 0, 1796, 1804, 5, 250, 0, 0, 1797, 1804, 5, 115, 0, 0, 1798, 1804, 5, 164, 0, 0, 1799, 1804, 5, 163, 0, 0, 1800, 1804, 5, 15, 0, 0, 1801, 1804, 5, 94, 0, 0, 1802, 1804, 3, 242, 121, 0, 1803, 1795, 1, 0, 0, 0, 1803, 1796, 1, 0, 0, 0, 1803, 1797, 1, 0, 0, 0, 1803, 1798, 1, 0, 0, 0, 1803, 1799, 1, 0, 0, 0, 1803, 1800, 1, 0, 0, 0, 1803, 1801, 1, 0, 0, 0, 1803, 1802, 1, 0, 0, 0, 1804, 245, 1, 0, 0, 0, 1805, 1806, 5, 115, 0, 0, 1806, 1809, 3, 354, 177, 0, 1807, 1808, 7, 12, 0, 0, 1808, 1810, 5, 153, 0, 0, 1809, 1807, 1, 0, 0, 0, 1809, 1810, 1, 0, 0, 0, 1810, 247, 1, 0, 0, 0, 1811, 1812, 5, 265, 0, 0, 1812, 1817, 3, 256, 128, 0, 1813, 1814, 5, 263, 0, 0, 1814, 1816, 3, 256, 128, 0, 1815, 1813, 1, 0, 0, 0, 1816, 1819, 1, 0, 0, 0, 1817, 1815, 1, 0, 0, 0, 1817, 1818, 1, 0, 0, 0, 1818, 1820, 1, 0, 0, 0, 1819, 1817, 1, 0, 0, 0, 1820, 1821, 5, 266, 0, 0, 1821, 249, 1, 0, 0, 0, 1822, 1823, 5, 265, 0, 0, 1823, 1828, 3, 212, 106, 0, 1824, 1825, 5, 263, 0, 0, 1825, 1827, 3, 212, 106, 0, 1826, 1824, 1, 0, 0, 0, 1827, 1830, 1, 0, 0, 0, 1828, 1829, 1, 0, 0, 0, 1828, 1826, 1, 0, 0, 0, 1829, 1831, 1, 0, 0, 0, 1830, 1828, 1, 0, 0, 0, 1831, 1832, 5, 266, 0, 0, 1832, 251, 1, 0, 0, 0, 1833, 1838, 3, 304, 152, 0, 1834, 1835, 5, 263, 0, 0, 1835, 1837, 3, 304, 152, 0, 1836, 1834, 1, 0, 0, 0, 1837, 1840, 1, 0, 0, 0, 1838, 1836, 1, 0, 0, 0, 1838, 1839, 1, 0, 0, 0, 1839, 253, 1, 0, 0, 0, 1840, 1838, 1, 0, 0, 0, 1841, 1851, 5, 52, 0, 0, 1842, 1843, 5, 71, 0, 0, 1843, 1844, 5, 191, 0, 0, 1844, 1845, 5, 26, 0, 0, 1845, 1849, 3, 314, 157, 0, 1846, 1847, 5, 63, 0, 0, 1847, 1848, 5, 26, 0, 0, 1848, 1850, 3, 314, 157, 0, 1849, 1846, 1, 0, 0, 0, 1849, 1850, 1, 0, 0, 0, 1850, 1852, 1, 0, 0, 0, 1851, 1842, 1, 0, 0, 0, 1851, 1852, 1, 0, 0, 0, 1852, 1857, 1, 0, 0, 0, 1853, 1854, 5, 117, 0, 0, 1854, 1855, 5, 191, 0, 0, 1855, 1856, 5, 26, 0, 0, 1856, 1858, 3, 314, 157, 0, 1857, 1853, 1, 0, 0, 0, 1857, 1858, 1, 0, 0, 0, 1858, 255, 1, 0, 0, 0, 1859, 1862, 3, 358, 179, 0, 1860, 1861, 5, 249, 0, 0, 1861, 1863, 3, 304, 152, 0, 1862, 1860, 1, 0, 0, 0, 1862, 1863, 1, 0, 0, 0, 1863, 257, 1, 0, 0, 0, 1864, 1875, 3, 260, 130, 0, 1865, 1866, 5, 139, 0, 0, 1866, 1867, 5, 26, 0, 0, 1867, 1872, 3, 264, 132, 0, 1868, 1869, 5, 263, 0, 0, 1869, 1871, 3, 264, 132, 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, 1876, 1, 0, 0, 0, 1874, 1872, 1, 0, 0, 0, 1875, 1865, 1, 0, 0, 0, 1875, 1876, 1, 0, 0, 0, 1876, 1883, 1, 0, 0, 0, 1877, 1878, 5, 116, 0, 0, 1878, 1881, 3, 304, 152, 0, 1879, 1880, 5, 135, 0, 0, 1880, 1882, 5, 277, 0, 0, 1881, 1879, 1, 0, 0, 0, 1881, 1882, 1, 0, 0, 0, 1882, 1884, 1, 0, 0, 0, 1883, 1877, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 259, 1, 0, 0, 0, 1885, 1886, 6, 130, -1, 0, 1886, 1887, 3, 262, 131, 0, 1887, 1902, 1, 0, 0, 0, 1888, 1889, 10, 2, 0, 0, 1889, 1891, 5, 100, 0, 0, 1890, 1892, 3, 276, 138, 0, 1891, 1890, 1, 0, 0, 0, 1891, 1892, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1901, 3, 260, 130, 3, 1894, 1895, 10, 1, 0, 0, 1895, 1897, 7, 13, 0, 0, 1896, 1898, 3, 276, 138, 0, 1897, 1896, 1, 0, 0, 0, 1897, 1898, 1, 0, 0, 0, 1898, 1899, 1, 0, 0, 0, 1899, 1901, 3, 260, 130, 2, 1900, 1888, 1, 0, 0, 0, 1900, 1894, 1, 0, 0, 0, 1901, 1904, 1, 0, 0, 0, 1902, 1900, 1, 0, 0, 0, 1902, 1903, 1, 0, 0, 0, 1903, 261, 1, 0, 0, 0, 1904, 1902, 1, 0, 0, 0, 1905, 1922, 3, 266, 133, 0, 1906, 1907, 5, 188, 0, 0, 1907, 1922, 3, 186, 93, 0, 1908, 1909, 5, 211, 0, 0, 1909, 1914, 3, 304, 152, 0, 1910, 1911, 5, 263, 0, 0, 1911, 1913, 3, 304, 152, 0, 1912, 1910, 1, 0, 0, 0, 1913, 1916, 1, 0, 0, 0, 1914, 1912, 1, 0, 0, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1922, 1, 0, 0, 0, 1916, 1914, 1, 0, 0, 0, 1917, 1918, 5, 265, 0, 0, 1918, 1919, 3, 258, 129, 0, 1919, 1920, 5, 266, 0, 0, 1920, 1922, 1, 0, 0, 0, 1921, 1905, 1, 0, 0, 0, 1921, 1906, 1, 0, 0, 0, 1921, 1908, 1, 0, 0, 0, 1921, 1917, 1, 0, 0, 0, 1922, 263, 1, 0, 0, 0, 1923, 1925, 3, 302, 151, 0, 1924, 1926, 7, 14, 0, 0, 1925, 1924, 1, 0, 0, 0, 1925, 1926, 1, 0, 0, 0, 1926, 1929, 1, 0, 0, 0, 1927, 1928, 5, 134, 0, 0, 1928, 1930, 7, 15, 0, 0, 1929, 1927, 1, 0, 0, 0, 1929, 1930, 1, 0, 0, 0, 1930, 265, 1, 0, 0, 0, 1931, 1933, 5, 174, 0, 0, 1932, 1934, 3, 276, 138, 0, 1933, 1932, 1, 0, 0, 0, 1933, 1934, 1, 0, 0, 0, 1934, 1936, 1, 0, 0, 0, 1935, 1937, 5, 183, 0, 0, 1936, 1935, 1, 0, 0, 0, 1936, 1937, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1943, 3, 278, 139, 0, 1939, 1940, 5, 263, 0, 0, 1940, 1942, 3, 278, 139, 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, 1955, 1, 0, 0, 0, 1945, 1943, 1, 0, 0, 0, 1946, 1947, 5, 82, 0, 0, 1947, 1952, 3, 280, 140, 0, 1948, 1949, 5, 263, 0, 0, 1949, 1951, 3, 280, 140, 0, 1950, 1948, 1, 0, 0, 0, 1951, 1954, 1, 0, 0, 0, 1952, 1950, 1, 0, 0, 0, 1952, 1953, 1, 0, 0, 0, 1953, 1956, 1, 0, 0, 0, 1954, 1952, 1, 0, 0, 0, 1955, 1946, 1, 0, 0, 0, 1955, 1956, 1, 0, 0, 0, 1956, 1959, 1, 0, 0, 0, 1957, 1958, 5, 215, 0, 0, 1958, 1960, 3, 306, 153, 0, 1959, 1957, 1, 0, 0, 0, 1959, 1960, 1, 0, 0, 0, 1960, 1964, 1, 0, 0, 0, 1961, 1962, 5, 87, 0, 0, 1962, 1963, 5, 26, 0, 0, 1963, 1965, 3, 268, 134, 0, 1964, 1961, 1, 0, 0, 0, 1964, 1965, 1, 0, 0, 0, 1965, 1968, 1, 0, 0, 0, 1966, 1967, 5, 90, 0, 0, 1967, 1969, 3, 306, 153, 0, 1968, 1966, 1, 0, 0, 0, 1968, 1969, 1, 0, 0, 0, 1969, 267, 1, 0, 0, 0, 1970, 1972, 3, 276, 138, 0, 1971, 1970, 1, 0, 0, 0, 1971, 1972, 1, 0, 0, 0, 1972, 1973, 1, 0, 0, 0, 1973, 1978, 3, 270, 135, 0, 1974, 1975, 5, 263, 0, 0, 1975, 1977, 3, 270, 135, 0, 1976, 1974, 1, 0, 0, 0, 1977, 1980, 1, 0, 0, 0, 1978, 1976, 1, 0, 0, 0, 1978, 1979, 1, 0, 0, 0, 1979, 269, 1, 0, 0, 0, 1980, 1978, 1, 0, 0, 0, 1981, 1982, 3, 272, 136, 0, 1982, 271, 1, 0, 0, 0, 1983, 1992, 5, 265, 0, 0, 1984, 1989, 3, 302, 151, 0, 1985, 1986, 5, 263, 0, 0, 1986, 1988, 3, 302, 151, 0, 1987, 1985, 1, 0, 0, 0, 1988, 1991, 1, 0, 0, 0, 1989, 1987, 1, 0, 0, 0, 1989, 1990, 1, 0, 0, 0, 1990, 1993, 1, 0, 0, 0, 1991, 1989, 1, 0, 0, 0, 1992, 1984, 1, 0, 0, 0, 1992, 1993, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 1997, 5, 266, 0, 0, 1995, 1997, 3, 302, 151, 0, 1996, 1983, 1, 0, 0, 0, 1996, 1995, 1, 0, 0, 0, 1997, 273, 1, 0, 0, 0, 1998, 2000, 3, 358, 179, 0, 1999, 2001, 3, 292, 146, 0, 2000, 1999, 1, 0, 0, 0, 2000, 2001, 1, 0, 0, 0, 2001, 2002, 1, 0, 0, 0, 2002, 2003, 5, 9, 0, 0, 2003, 2004, 3, 296, 148, 0, 2004, 275, 1, 0, 0, 0, 2005, 2006, 7, 16, 0, 0, 2006, 277, 1, 0, 0, 0, 2007, 2012, 3, 302, 151, 0, 2008, 2010, 5, 9, 0, 0, 2009, 2008, 1, 0, 0, 0, 2009, 2010, 1, 0, 0, 0, 2010, 2011, 1, 0, 0, 0, 2011, 2013, 3, 358, 179, 0, 2012, 2009, 1, 0, 0, 0, 2012, 2013, 1, 0, 0, 0, 2013, 2020, 1, 0, 0, 0, 2014, 2015, 3, 354, 177, 0, 2015, 2016, 5, 261, 0, 0, 2016, 2017, 5, 257, 0, 0, 2017, 2020, 1, 0, 0, 0, 2018, 2020, 5, 257, 0, 0, 2019, 2007, 1, 0, 0, 0, 2019, 2014, 1, 0, 0, 0, 2019, 2018, 1, 0, 0, 0, 2020, 279, 1, 0, 0, 0, 2021, 2022, 6, 140, -1, 0, 2022, 2023, 3, 286, 143, 0, 2023, 2037, 1, 0, 0, 0, 2024, 2033, 10, 2, 0, 0, 2025, 2026, 5, 38, 0, 0, 2026, 2027, 5, 109, 0, 0, 2027, 2034, 3, 286, 143, 0, 2028, 2029, 3, 282, 141, 0, 2029, 2030, 5, 109, 0, 0, 2030, 2031, 3, 280, 140, 0, 2031, 2032, 3, 284, 142, 0, 2032, 2034, 1, 0, 0, 0, 2033, 2025, 1, 0, 0, 0, 2033, 2028, 1, 0, 0, 0, 2034, 2036, 1, 0, 0, 0, 2035, 2024, 1, 0, 0, 0, 2036, 2039, 1, 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 281, 1, 0, 0, 0, 2039, 2037, 1, 0, 0, 0, 2040, 2042, 5, 97, 0, 0, 2041, 2040, 1, 0, 0, 0, 2041, 2042, 1, 0, 0, 0, 2042, 2072, 1, 0, 0, 0, 2043, 2045, 5, 114, 0, 0, 2044, 2046, 5, 97, 0, 0, 2045, 2044, 1, 0, 0, 0, 2045, 2046, 1, 0, 0, 0, 2046, 2072, 1, 0, 0, 0, 2047, 2049, 5, 165, 0, 0, 2048, 2050, 5, 97, 0, 0, 2049, 2048, 1, 0, 0, 0, 2049, 2050, 1, 0, 0, 0, 2050, 2072, 1, 0, 0, 0, 2051, 2053, 5, 114, 0, 0, 2052, 2054, 5, 141, 0, 0, 2053, 2052, 1, 0, 0, 0, 2053, 2054, 1, 0, 0, 0, 2054, 2072, 1, 0, 0, 0, 2055, 2057, 5, 165, 0, 0, 2056, 2058, 5, 141, 0, 0, 2057, 2056, 1, 0, 0, 0, 2057, 2058, 1, 0, 0, 0, 2058, 2072, 1, 0, 0, 0, 2059, 2061, 5, 83, 0, 0, 2060, 2062, 5, 141, 0, 0, 2061, 2060, 1, 0, 0, 0, 2061, 2062, 1, 0, 0, 0, 2062, 2072, 1, 0, 0, 0, 2063, 2064, 5, 114, 0, 0, 2064, 2072, 5, 177, 0, 0, 2065, 2066, 5, 165, 0, 0, 2066, 2072, 5, 177, 0, 0, 2067, 2068, 5, 114, 0, 0, 2068, 2072, 5, 7, 0, 0, 2069, 2070, 5, 165, 0, 0, 2070, 2072, 5, 7, 0, 0, 2071, 2041, 1, 0, 0, 0, 2071, 2043, 1, 0, 0, 0, 2071, 2047, 1, 0, 0, 0, 2071, 2051, 1, 0, 0, 0, 2071, 2055, 1, 0, 0, 0, 2071, 2059, 1, 0, 0, 0, 2071, 2063, 1, 0, 0, 0, 2071, 2065, 1, 0, 0, 0, 2071, 2067, 1, 0, 0, 0, 2071, 2069, 1, 0, 0, 0, 2072, 283, 1, 0, 0, 0, 2073, 2074, 5, 136, 0, 0, 2074, 2088, 3, 306, 153, 0, 2075, 2076, 5, 205, 0, 0, 2076, 2077, 5, 265, 0, 0, 2077, 2082, 3, 358, 179, 0, 2078, 2079, 5, 263, 0, 0, 2079, 2081, 3, 358, 179, 0, 2080, 2078, 1, 0, 0, 0, 2081, 2084, 1, 0, 0, 0, 2082, 2080, 1, 0, 0, 0, 2082, 2083, 1, 0, 0, 0, 2083, 2085, 1, 0, 0, 0, 2084, 2082, 1, 0, 0, 0, 2085, 2086, 5, 266, 0, 0, 2086, 2088, 1, 0, 0, 0, 2087, 2073, 1, 0, 0, 0, 2087, 2075, 1, 0, 0, 0, 2088, 285, 1, 0, 0, 0, 2089, 2102, 3, 290, 145, 0, 2090, 2091, 5, 190, 0, 0, 2091, 2092, 3, 288, 144, 0, 2092, 2093, 5, 265, 0, 0, 2093, 2094, 3, 304, 152, 0, 2094, 2100, 5, 266, 0, 0, 2095, 2096, 5, 157, 0, 0, 2096, 2097, 5, 265, 0, 0, 2097, 2098, 3, 304, 152, 0, 2098, 2099, 5, 266, 0, 0, 2099, 2101, 1, 0, 0, 0, 2100, 2095, 1, 0, 0, 0, 2100, 2101, 1, 0, 0, 0, 2101, 2103, 1, 0, 0, 0, 2102, 2090, 1, 0, 0, 0, 2102, 2103, 1, 0, 0, 0, 2103, 287, 1, 0, 0, 0, 2104, 2105, 7, 17, 0, 0, 2105, 289, 1, 0, 0, 0, 2106, 2114, 3, 294, 147, 0, 2107, 2109, 5, 9, 0, 0, 2108, 2107, 1, 0, 0, 0, 2108, 2109, 1, 0, 0, 0, 2109, 2110, 1, 0, 0, 0, 2110, 2112, 3, 358, 179, 0, 2111, 2113, 3, 292, 146, 0, 2112, 2111, 1, 0, 0, 0, 2112, 2113, 1, 0, 0, 0, 2113, 2115, 1, 0, 0, 0, 2114, 2108, 1, 0, 0, 0, 2114, 2115, 1, 0, 0, 0, 2115, 291, 1, 0, 0, 0, 2116, 2117, 5, 265, 0, 0, 2117, 2122, 3, 192, 96, 0, 2118, 2119, 5, 263, 0, 0, 2119, 2121, 3, 192, 96, 0, 2120, 2118, 1, 0, 0, 0, 2121, 2124, 1, 0, 0, 0, 2122, 2120, 1, 0, 0, 0, 2122, 2123, 1, 0, 0, 0, 2123, 2125, 1, 0, 0, 0, 2124, 2122, 1, 0, 0, 0, 2125, 2126, 5, 266, 0, 0, 2126, 293, 1, 0, 0, 0, 2127, 2135, 3, 194, 97, 0, 2128, 2130, 5, 113, 0, 0, 2129, 2128, 1, 0, 0, 0, 2129, 2130, 1, 0, 0, 0, 2130, 2131, 1, 0, 0, 0, 2131, 2135, 3, 296, 148, 0, 2132, 2135, 3, 298, 149, 0, 2133, 2135, 3, 300, 150, 0, 2134, 2127, 1, 0, 0, 0, 2134, 2129, 1, 0, 0, 0, 2134, 2132, 1, 0, 0, 0, 2134, 2133, 1, 0, 0, 0, 2135, 295, 1, 0, 0, 0, 2136, 2137, 5, 265, 0, 0, 2137, 2138, 3, 204, 102, 0, 2138, 2139, 5, 266, 0, 0, 2139, 297, 1, 0, 0, 0, 2140, 2141, 5, 201, 0, 0, 2141, 2142, 5, 265, 0, 0, 2142, 2147, 3, 304, 152, 0, 2143, 2144, 5, 263, 0, 0, 2144, 2146, 3, 304, 152, 0, 2145, 2143, 1, 0, 0, 0, 2146, 2149, 1, 0, 0, 0, 2147, 2145, 1, 0, 0, 0, 2147, 2148, 1, 0, 0, 0, 2148, 2150, 1, 0, 0, 0, 2149, 2147, 1, 0, 0, 0, 2150, 2153, 5, 266, 0, 0, 2151, 2152, 5, 216, 0, 0, 2152, 2154, 5, 140, 0, 0, 2153, 2151, 1, 0, 0, 0, 2153, 2154, 1, 0, 0, 0, 2154, 299, 1, 0, 0, 0, 2155, 2156, 5, 265, 0, 0, 2156, 2157, 3, 280, 140, 0, 2157, 2158, 5, 266, 0, 0, 2158, 301, 1, 0, 0, 0, 2159, 2162, 3, 192, 96, 0, 2160, 2162, 3, 304, 152, 0, 2161, 2159, 1, 0, 0, 0, 2161, 2160, 1, 0, 0, 0, 2162, 303, 1, 0, 0, 0, 2163, 2164, 3, 306, 153, 0, 2164, 305, 1, 0, 0, 0, 2165, 2166, 6, 153, -1, 0, 2166, 2168, 3, 310, 155, 0, 2167, 2169, 3, 308, 154, 0, 2168, 2167, 1, 0, 0, 0, 2168, 2169, 1, 0, 0, 0, 2169, 2173, 1, 0, 0, 0, 2170, 2171, 5, 132, 0, 0, 2171, 2173, 3, 306, 153, 3, 2172, 2165, 1, 0, 0, 0, 2172, 2170, 1, 0, 0, 0, 2173, 2182, 1, 0, 0, 0, 2174, 2175, 10, 2, 0, 0, 2175, 2176, 5, 5, 0, 0, 2176, 2181, 3, 306, 153, 3, 2177, 2178, 10, 1, 0, 0, 2178, 2179, 5, 138, 0, 0, 2179, 2181, 3, 306, 153, 2, 2180, 2174, 1, 0, 0, 0, 2180, 2177, 1, 0, 0, 0, 2181, 2184, 1, 0, 0, 0, 2182, 2180, 1, 0, 0, 0, 2182, 2183, 1, 0, 0, 0, 2183, 307, 1, 0, 0, 0, 2184, 2182, 1, 0, 0, 0, 2185, 2186, 3, 316, 158, 0, 2186, 2187, 3, 310, 155, 0, 2187, 2244, 1, 0, 0, 0, 2188, 2189, 3, 316, 158, 0, 2189, 2190, 3, 318, 159, 0, 2190, 2191, 3, 296, 148, 0, 2191, 2244, 1, 0, 0, 0, 2192, 2194, 5, 132, 0, 0, 2193, 2192, 1, 0, 0, 0, 2193, 2194, 1, 0, 0, 0, 2194, 2195, 1, 0, 0, 0, 2195, 2196, 5, 15, 0, 0, 2196, 2197, 3, 310, 155, 0, 2197, 2198, 5, 5, 0, 0, 2198, 2199, 3, 310, 155, 0, 2199, 2244, 1, 0, 0, 0, 2200, 2202, 5, 132, 0, 0, 2201, 2200, 1, 0, 0, 0, 2201, 2202, 1, 0, 0, 0, 2202, 2203, 1, 0, 0, 0, 2203, 2204, 5, 94, 0, 0, 2204, 2205, 5, 265, 0, 0, 2205, 2210, 3, 304, 152, 0, 2206, 2207, 5, 263, 0, 0, 2207, 2209, 3, 304, 152, 0, 2208, 2206, 1, 0, 0, 0, 2209, 2212, 1, 0, 0, 0, 2210, 2208, 1, 0, 0, 0, 2210, 2211, 1, 0, 0, 0, 2211, 2213, 1, 0, 0, 0, 2212, 2210, 1, 0, 0, 0, 2213, 2214, 5, 266, 0, 0, 2214, 2244, 1, 0, 0, 0, 2215, 2217, 5, 132, 0, 0, 2216, 2215, 1, 0, 0, 0, 2216, 2217, 1, 0, 0, 0, 2217, 2218, 1, 0, 0, 0, 2218, 2219, 5, 94, 0, 0, 2219, 2244, 3, 296, 148, 0, 2220, 2222, 5, 132, 0, 0, 2221, 2220, 1, 0, 0, 0, 2221, 2222, 1, 0, 0, 0, 2222, 2223, 1, 0, 0, 0, 2223, 2224, 7, 18, 0, 0, 2224, 2227, 3, 310, 155, 0, 2225, 2226, 5, 62, 0, 0, 2226, 2228, 3, 310, 155, 0, 2227, 2225, 1, 0, 0, 0, 2227, 2228, 1, 0, 0, 0, 2228, 2244, 1, 0, 0, 0, 2229, 2230, 7, 19, 0, 0, 2230, 2244, 3, 310, 155, 0, 2231, 2233, 5, 108, 0, 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, 2244, 7, 20, 0, 0, 2236, 2238, 5, 108, 0, 0, 2237, 2239, 5, 132, 0, 0, 2238, 2237, 1, 0, 0, 0, 2238, 2239, 1, 0, 0, 0, 2239, 2240, 1, 0, 0, 0, 2240, 2241, 5, 57, 0, 0, 2241, 2242, 5, 82, 0, 0, 2242, 2244, 3, 310, 155, 0, 2243, 2185, 1, 0, 0, 0, 2243, 2188, 1, 0, 0, 0, 2243, 2193, 1, 0, 0, 0, 2243, 2201, 1, 0, 0, 0, 2243, 2216, 1, 0, 0, 0, 2243, 2221, 1, 0, 0, 0, 2243, 2229, 1, 0, 0, 0, 2243, 2231, 1, 0, 0, 0, 2243, 2236, 1, 0, 0, 0, 2244, 309, 1, 0, 0, 0, 2245, 2246, 6, 155, -1, 0, 2246, 2250, 3, 312, 156, 0, 2247, 2248, 7, 21, 0, 0, 2248, 2250, 3, 310, 155, 4, 2249, 2245, 1, 0, 0, 0, 2249, 2247, 1, 0, 0, 0, 2250, 2262, 1, 0, 0, 0, 2251, 2252, 10, 3, 0, 0, 2252, 2253, 7, 22, 0, 0, 2253, 2261, 3, 310, 155, 4, 2254, 2255, 10, 2, 0, 0, 2255, 2256, 7, 21, 0, 0, 2256, 2261, 3, 310, 155, 3, 2257, 2258, 10, 1, 0, 0, 2258, 2259, 5, 260, 0, 0, 2259, 2261, 3, 310, 155, 2, 2260, 2251, 1, 0, 0, 0, 2260, 2254, 1, 0, 0, 0, 2260, 2257, 1, 0, 0, 0, 2261, 2264, 1, 0, 0, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 311, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2265, 2266, 6, 156, -1, 0, 2266, 2512, 5, 133, 0, 0, 2267, 2512, 3, 322, 161, 0, 2268, 2269, 3, 358, 179, 0, 2269, 2270, 3, 314, 157, 0, 2270, 2512, 1, 0, 0, 0, 2271, 2272, 5, 286, 0, 0, 2272, 2512, 3, 314, 157, 0, 2273, 2512, 3, 360, 180, 0, 2274, 2512, 3, 320, 160, 0, 2275, 2512, 3, 314, 157, 0, 2276, 2512, 5, 276, 0, 0, 2277, 2512, 5, 272, 0, 0, 2278, 2279, 5, 148, 0, 0, 2279, 2280, 5, 265, 0, 0, 2280, 2281, 3, 310, 155, 0, 2281, 2282, 5, 94, 0, 0, 2282, 2283, 3, 310, 155, 0, 2283, 2284, 5, 266, 0, 0, 2284, 2512, 1, 0, 0, 0, 2285, 2286, 5, 265, 0, 0, 2286, 2289, 3, 304, 152, 0, 2287, 2288, 5, 9, 0, 0, 2288, 2290, 3, 328, 164, 0, 2289, 2287, 1, 0, 0, 0, 2289, 2290, 1, 0, 0, 0, 2290, 2299, 1, 0, 0, 0, 2291, 2292, 5, 263, 0, 0, 2292, 2295, 3, 304, 152, 0, 2293, 2294, 5, 9, 0, 0, 2294, 2296, 3, 328, 164, 0, 2295, 2293, 1, 0, 0, 0, 2295, 2296, 1, 0, 0, 0, 2296, 2298, 1, 0, 0, 0, 2297, 2291, 1, 0, 0, 0, 2298, 2301, 1, 0, 0, 0, 2299, 2300, 1, 0, 0, 0, 2299, 2297, 1, 0, 0, 0, 2300, 2302, 1, 0, 0, 0, 2301, 2299, 1, 0, 0, 0, 2302, 2303, 5, 266, 0, 0, 2303, 2512, 1, 0, 0, 0, 2304, 2305, 5, 168, 0, 0, 2305, 2306, 5, 265, 0, 0, 2306, 2311, 3, 304, 152, 0, 2307, 2308, 5, 263, 0, 0, 2308, 2310, 3, 304, 152, 0, 2309, 2307, 1, 0, 0, 0, 2310, 2313, 1, 0, 0, 0, 2311, 2309, 1, 0, 0, 0, 2311, 2312, 1, 0, 0, 0, 2312, 2314, 1, 0, 0, 0, 2313, 2311, 1, 0, 0, 0, 2314, 2315, 5, 266, 0, 0, 2315, 2512, 1, 0, 0, 0, 2316, 2317, 3, 190, 95, 0, 2317, 2318, 5, 265, 0, 0, 2318, 2319, 5, 257, 0, 0, 2319, 2321, 5, 266, 0, 0, 2320, 2322, 3, 338, 169, 0, 2321, 2320, 1, 0, 0, 0, 2321, 2322, 1, 0, 0, 0, 2322, 2324, 1, 0, 0, 0, 2323, 2325, 3, 340, 170, 0, 2324, 2323, 1, 0, 0, 0, 2324, 2325, 1, 0, 0, 0, 2325, 2512, 1, 0, 0, 0, 2326, 2327, 3, 190, 95, 0, 2327, 2339, 5, 265, 0, 0, 2328, 2330, 3, 276, 138, 0, 2329, 2328, 1, 0, 0, 0, 2329, 2330, 1, 0, 0, 0, 2330, 2331, 1, 0, 0, 0, 2331, 2336, 3, 304, 152, 0, 2332, 2333, 5, 263, 0, 0, 2333, 2335, 3, 304, 152, 0, 2334, 2332, 1, 0, 0, 0, 2335, 2338, 1, 0, 0, 0, 2336, 2334, 1, 0, 0, 0, 2336, 2337, 1, 0, 0, 0, 2337, 2340, 1, 0, 0, 0, 2338, 2336, 1, 0, 0, 0, 2339, 2329, 1, 0, 0, 0, 2339, 2340, 1, 0, 0, 0, 2340, 2351, 1, 0, 0, 0, 2341, 2342, 5, 139, 0, 0, 2342, 2343, 5, 26, 0, 0, 2343, 2348, 3, 264, 132, 0, 2344, 2345, 5, 263, 0, 0, 2345, 2347, 3, 264, 132, 0, 2346, 2344, 1, 0, 0, 0, 2347, 2350, 1, 0, 0, 0, 2348, 2346, 1, 0, 0, 0, 2348, 2349, 1, 0, 0, 0, 2349, 2352, 1, 0, 0, 0, 2350, 2348, 1, 0, 0, 0, 2351, 2341, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2353, 1, 0, 0, 0, 2353, 2355, 5, 266, 0, 0, 2354, 2356, 3, 338, 169, 0, 2355, 2354, 1, 0, 0, 0, 2355, 2356, 1, 0, 0, 0, 2356, 2358, 1, 0, 0, 0, 2357, 2359, 3, 340, 170, 0, 2358, 2357, 1, 0, 0, 0, 2358, 2359, 1, 0, 0, 0, 2359, 2512, 1, 0, 0, 0, 2360, 2361, 3, 358, 179, 0, 2361, 2362, 5, 273, 0, 0, 2362, 2363, 3, 304, 152, 0, 2363, 2512, 1, 0, 0, 0, 2364, 2373, 5, 265, 0, 0, 2365, 2370, 3, 358, 179, 0, 2366, 2367, 5, 263, 0, 0, 2367, 2369, 3, 358, 179, 0, 2368, 2366, 1, 0, 0, 0, 2369, 2372, 1, 0, 0, 0, 2370, 2368, 1, 0, 0, 0, 2370, 2371, 1, 0, 0, 0, 2371, 2374, 1, 0, 0, 0, 2372, 2370, 1, 0, 0, 0, 2373, 2365, 1, 0, 0, 0, 2373, 2374, 1, 0, 0, 0, 2374, 2375, 1, 0, 0, 0, 2375, 2376, 5, 266, 0, 0, 2376, 2377, 5, 273, 0, 0, 2377, 2512, 3, 304, 152, 0, 2378, 2379, 5, 265, 0, 0, 2379, 2380, 3, 204, 102, 0, 2380, 2381, 5, 266, 0, 0, 2381, 2512, 1, 0, 0, 0, 2382, 2383, 5, 66, 0, 0, 2383, 2384, 5, 265, 0, 0, 2384, 2385, 3, 204, 102, 0, 2385, 2386, 5, 266, 0, 0, 2386, 2512, 1, 0, 0, 0, 2387, 2388, 5, 28, 0, 0, 2388, 2390, 3, 310, 155, 0, 2389, 2391, 3, 336, 168, 0, 2390, 2389, 1, 0, 0, 0, 2391, 2392, 1, 0, 0, 0, 2392, 2390, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2396, 1, 0, 0, 0, 2394, 2395, 5, 59, 0, 0, 2395, 2397, 3, 304, 152, 0, 2396, 2394, 1, 0, 0, 0, 2396, 2397, 1, 0, 0, 0, 2397, 2398, 1, 0, 0, 0, 2398, 2399, 5, 61, 0, 0, 2399, 2512, 1, 0, 0, 0, 2400, 2402, 5, 28, 0, 0, 2401, 2403, 3, 336, 168, 0, 2402, 2401, 1, 0, 0, 0, 2403, 2404, 1, 0, 0, 0, 2404, 2402, 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 2408, 1, 0, 0, 0, 2406, 2407, 5, 59, 0, 0, 2407, 2409, 3, 304, 152, 0, 2408, 2406, 1, 0, 0, 0, 2408, 2409, 1, 0, 0, 0, 2409, 2410, 1, 0, 0, 0, 2410, 2411, 5, 61, 0, 0, 2411, 2512, 1, 0, 0, 0, 2412, 2413, 5, 29, 0, 0, 2413, 2414, 5, 265, 0, 0, 2414, 2415, 3, 304, 152, 0, 2415, 2416, 5, 9, 0, 0, 2416, 2417, 3, 328, 164, 0, 2417, 2418, 5, 266, 0, 0, 2418, 2512, 1, 0, 0, 0, 2419, 2420, 5, 195, 0, 0, 2420, 2421, 5, 265, 0, 0, 2421, 2422, 3, 304, 152, 0, 2422, 2423, 5, 9, 0, 0, 2423, 2424, 3, 328, 164, 0, 2424, 2425, 5, 266, 0, 0, 2425, 2512, 1, 0, 0, 0, 2426, 2427, 5, 8, 0, 0, 2427, 2436, 5, 267, 0, 0, 2428, 2433, 3, 304, 152, 0, 2429, 2430, 5, 263, 0, 0, 2430, 2432, 3, 304, 152, 0, 2431, 2429, 1, 0, 0, 0, 2432, 2435, 1, 0, 0, 0, 2433, 2431, 1, 0, 0, 0, 2433, 2434, 1, 0, 0, 0, 2434, 2437, 1, 0, 0, 0, 2435, 2433, 1, 0, 0, 0, 2436, 2428, 1, 0, 0, 0, 2436, 2437, 1, 0, 0, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2512, 5, 268, 0, 0, 2439, 2512, 3, 358, 179, 0, 2440, 2512, 5, 40, 0, 0, 2441, 2445, 5, 42, 0, 0, 2442, 2443, 5, 265, 0, 0, 2443, 2444, 5, 277, 0, 0, 2444, 2446, 5, 266, 0, 0, 2445, 2442, 1, 0, 0, 0, 2445, 2446, 1, 0, 0, 0, 2446, 2512, 1, 0, 0, 0, 2447, 2451, 5, 43, 0, 0, 2448, 2449, 5, 265, 0, 0, 2449, 2450, 5, 277, 0, 0, 2450, 2452, 5, 266, 0, 0, 2451, 2448, 1, 0, 0, 0, 2451, 2452, 1, 0, 0, 0, 2452, 2512, 1, 0, 0, 0, 2453, 2457, 5, 119, 0, 0, 2454, 2455, 5, 265, 0, 0, 2455, 2456, 5, 277, 0, 0, 2456, 2458, 5, 266, 0, 0, 2457, 2454, 1, 0, 0, 0, 2457, 2458, 1, 0, 0, 0, 2458, 2512, 1, 0, 0, 0, 2459, 2463, 5, 120, 0, 0, 2460, 2461, 5, 265, 0, 0, 2461, 2462, 5, 277, 0, 0, 2462, 2464, 5, 266, 0, 0, 2463, 2460, 1, 0, 0, 0, 2463, 2464, 1, 0, 0, 0, 2464, 2512, 1, 0, 0, 0, 2465, 2512, 5, 44, 0, 0, 2466, 2512, 5, 41, 0, 0, 2467, 2468, 5, 184, 0, 0, 2468, 2469, 5, 265, 0, 0, 2469, 2470, 3, 310, 155, 0, 2470, 2471, 5, 82, 0, 0, 2471, 2474, 3, 310, 155, 0, 2472, 2473, 5, 78, 0, 0, 2473, 2475, 3, 310, 155, 0, 2474, 2472, 1, 0, 0, 0, 2474, 2475, 1, 0, 0, 0, 2475, 2476, 1, 0, 0, 0, 2476, 2477, 5, 266, 0, 0, 2477, 2512, 1, 0, 0, 0, 2478, 2479, 5, 131, 0, 0, 2479, 2480, 5, 265, 0, 0, 2480, 2483, 3, 310, 155, 0, 2481, 2482, 5, 263, 0, 0, 2482, 2484, 3, 326, 163, 0, 2483, 2481, 1, 0, 0, 0, 2483, 2484, 1, 0, 0, 0, 2484, 2485, 1, 0, 0, 0, 2485, 2486, 5, 266, 0, 0, 2486, 2512, 1, 0, 0, 0, 2487, 2488, 5, 68, 0, 0, 2488, 2489, 5, 265, 0, 0, 2489, 2490, 3, 358, 179, 0, 2490, 2491, 5, 82, 0, 0, 2491, 2492, 3, 310, 155, 0, 2492, 2493, 5, 266, 0, 0, 2493, 2512, 1, 0, 0, 0, 2494, 2495, 5, 265, 0, 0, 2495, 2496, 3, 304, 152, 0, 2496, 2497, 5, 266, 0, 0, 2497, 2512, 1, 0, 0, 0, 2498, 2499, 5, 88, 0, 0, 2499, 2508, 5, 265, 0, 0, 2500, 2505, 3, 354, 177, 0, 2501, 2502, 5, 263, 0, 0, 2502, 2504, 3, 354, 177, 0, 2503, 2501, 1, 0, 0, 0, 2504, 2507, 1, 0, 0, 0, 2505, 2503, 1, 0, 0, 0, 2505, 2506, 1, 0, 0, 0, 2506, 2509, 1, 0, 0, 0, 2507, 2505, 1, 0, 0, 0, 2508, 2500, 1, 0, 0, 0, 2508, 2509, 1, 0, 0, 0, 2509, 2510, 1, 0, 0, 0, 2510, 2512, 5, 266, 0, 0, 2511, 2265, 1, 0, 0, 0, 2511, 2267, 1, 0, 0, 0, 2511, 2268, 1, 0, 0, 0, 2511, 2271, 1, 0, 0, 0, 2511, 2273, 1, 0, 0, 0, 2511, 2274, 1, 0, 0, 0, 2511, 2275, 1, 0, 0, 0, 2511, 2276, 1, 0, 0, 0, 2511, 2277, 1, 0, 0, 0, 2511, 2278, 1, 0, 0, 0, 2511, 2285, 1, 0, 0, 0, 2511, 2304, 1, 0, 0, 0, 2511, 2316, 1, 0, 0, 0, 2511, 2326, 1, 0, 0, 0, 2511, 2360, 1, 0, 0, 0, 2511, 2364, 1, 0, 0, 0, 2511, 2378, 1, 0, 0, 0, 2511, 2382, 1, 0, 0, 0, 2511, 2387, 1, 0, 0, 0, 2511, 2400, 1, 0, 0, 0, 2511, 2412, 1, 0, 0, 0, 2511, 2419, 1, 0, 0, 0, 2511, 2426, 1, 0, 0, 0, 2511, 2439, 1, 0, 0, 0, 2511, 2440, 1, 0, 0, 0, 2511, 2441, 1, 0, 0, 0, 2511, 2447, 1, 0, 0, 0, 2511, 2453, 1, 0, 0, 0, 2511, 2459, 1, 0, 0, 0, 2511, 2465, 1, 0, 0, 0, 2511, 2466, 1, 0, 0, 0, 2511, 2467, 1, 0, 0, 0, 2511, 2478, 1, 0, 0, 0, 2511, 2487, 1, 0, 0, 0, 2511, 2494, 1, 0, 0, 0, 2511, 2498, 1, 0, 0, 0, 2512, 2523, 1, 0, 0, 0, 2513, 2514, 10, 15, 0, 0, 2514, 2515, 5, 267, 0, 0, 2515, 2516, 3, 310, 155, 0, 2516, 2517, 5, 268, 0, 0, 2517, 2522, 1, 0, 0, 0, 2518, 2519, 10, 13, 0, 0, 2519, 2520, 5, 261, 0, 0, 2520, 2522, 3, 358, 179, 0, 2521, 2513, 1, 0, 0, 0, 2521, 2518, 1, 0, 0, 0, 2522, 2525, 1, 0, 0, 0, 2523, 2521, 1, 0, 0, 0, 2523, 2524, 1, 0, 0, 0, 2524, 313, 1, 0, 0, 0, 2525, 2523, 1, 0, 0, 0, 2526, 2533, 5, 274, 0, 0, 2527, 2530, 5, 275, 0, 0, 2528, 2529, 5, 198, 0, 0, 2529, 2531, 5, 274, 0, 0, 2530, 2528, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 2533, 1, 0, 0, 0, 2532, 2526, 1, 0, 0, 0, 2532, 2527, 1, 0, 0, 0, 2533, 315, 1, 0, 0, 0, 2534, 2535, 7, 23, 0, 0, 2535, 317, 1, 0, 0, 0, 2536, 2537, 7, 24, 0, 0, 2537, 319, 1, 0, 0, 0, 2538, 2539, 7, 25, 0, 0, 2539, 321, 1, 0, 0, 0, 2540, 2541, 5, 277, 0, 0, 2541, 2555, 3, 324, 162, 0, 2542, 2543, 5, 265, 0, 0, 2543, 2544, 5, 277, 0, 0, 2544, 2545, 5, 266, 0, 0, 2545, 2555, 3, 324, 162, 0, 2546, 2547, 5, 101, 0, 0, 2547, 2548, 5, 277, 0, 0, 2548, 2555, 3, 324, 162, 0, 2549, 2550, 5, 101, 0, 0, 2550, 2551, 5, 265, 0, 0, 2551, 2552, 5, 277, 0, 0, 2552, 2553, 5, 266, 0, 0, 2553, 2555, 3, 324, 162, 0, 2554, 2540, 1, 0, 0, 0, 2554, 2542, 1, 0, 0, 0, 2554, 2546, 1, 0, 0, 0, 2554, 2549, 1, 0, 0, 0, 2555, 323, 1, 0, 0, 0, 2556, 2557, 7, 26, 0, 0, 2557, 325, 1, 0, 0, 0, 2558, 2559, 7, 27, 0, 0, 2559, 327, 1, 0, 0, 0, 2560, 2561, 6, 164, -1, 0, 2561, 2562, 5, 8, 0, 0, 2562, 2563, 5, 251, 0, 0, 2563, 2564, 3, 328, 164, 0, 2564, 2565, 5, 253, 0, 0, 2565, 2606, 1, 0, 0, 0, 2566, 2567, 5, 235, 0, 0, 2567, 2568, 5, 251, 0, 0, 2568, 2569, 3, 328, 164, 0, 2569, 2570, 5, 263, 0, 0, 2570, 2571, 3, 328, 164, 0, 2571, 2572, 5, 253, 0, 0, 2572, 2606, 1, 0, 0, 0, 2573, 2574, 5, 240, 0, 0, 2574, 2575, 5, 251, 0, 0, 2575, 2576, 3, 358, 179, 0, 2576, 2583, 3, 328, 164, 0, 2577, 2578, 5, 263, 0, 0, 2578, 2579, 3, 358, 179, 0, 2579, 2580, 3, 328, 164, 0, 2580, 2582, 1, 0, 0, 0, 2581, 2577, 1, 0, 0, 0, 2582, 2585, 1, 0, 0, 0, 2583, 2581, 1, 0, 0, 0, 2583, 2584, 1, 0, 0, 0, 2584, 2586, 1, 0, 0, 0, 2585, 2583, 1, 0, 0, 0, 2586, 2587, 5, 253, 0, 0, 2587, 2606, 1, 0, 0, 0, 2588, 2591, 3, 334, 167, 0, 2589, 2591, 3, 330, 165, 0, 2590, 2588, 1, 0, 0, 0, 2590, 2589, 1, 0, 0, 0, 2591, 2603, 1, 0, 0, 0, 2592, 2593, 5, 265, 0, 0, 2593, 2598, 3, 332, 166, 0, 2594, 2595, 5, 263, 0, 0, 2595, 2597, 3, 332, 166, 0, 2596, 2594, 1, 0, 0, 0, 2597, 2600, 1, 0, 0, 0, 2598, 2596, 1, 0, 0, 0, 2598, 2599, 1, 0, 0, 0, 2599, 2601, 1, 0, 0, 0, 2600, 2598, 1, 0, 0, 0, 2601, 2602, 5, 266, 0, 0, 2602, 2604, 1, 0, 0, 0, 2603, 2592, 1, 0, 0, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2606, 1, 0, 0, 0, 2605, 2560, 1, 0, 0, 0, 2605, 2566, 1, 0, 0, 0, 2605, 2573, 1, 0, 0, 0, 2605, 2590, 1, 0, 0, 0, 2606, 2611, 1, 0, 0, 0, 2607, 2608, 10, 5, 0, 0, 2608, 2610, 5, 8, 0, 0, 2609, 2607, 1, 0, 0, 0, 2610, 2613, 1, 0, 0, 0, 2611, 2609, 1, 0, 0, 0, 2611, 2612, 1, 0, 0, 0, 2612, 329, 1, 0, 0, 0, 2613, 2611, 1, 0, 0, 0, 2614, 2615, 7, 28, 0, 0, 2615, 331, 1, 0, 0, 0, 2616, 2619, 5, 277, 0, 0, 2617, 2619, 3, 328, 164, 0, 2618, 2616, 1, 0, 0, 0, 2618, 2617, 1, 0, 0, 0, 2619, 333, 1, 0, 0, 0, 2620, 2625, 5, 284, 0, 0, 2621, 2625, 5, 285, 0, 0, 2622, 2625, 5, 286, 0, 0, 2623, 2625, 3, 358, 179, 0, 2624, 2620, 1, 0, 0, 0, 2624, 2621, 1, 0, 0, 0, 2624, 2622, 1, 0, 0, 0, 2624, 2623, 1, 0, 0, 0, 2625, 335, 1, 0, 0, 0, 2626, 2627, 5, 214, 0, 0, 2627, 2628, 3, 304, 152, 0, 2628, 2629, 5, 192, 0, 0, 2629, 2630, 3, 304, 152, 0, 2630, 337, 1, 0, 0, 0, 2631, 2632, 5, 74, 0, 0, 2632, 2633, 5, 265, 0, 0, 2633, 2634, 5, 215, 0, 0, 2634, 2635, 3, 306, 153, 0, 2635, 2636, 5, 266, 0, 0, 2636, 339, 1, 0, 0, 0, 2637, 2638, 5, 143, 0, 0, 2638, 2649, 5, 265, 0, 0, 2639, 2640, 5, 145, 0, 0, 2640, 2641, 5, 26, 0, 0, 2641, 2646, 3, 304, 152, 0, 2642, 2643, 5, 263, 0, 0, 2643, 2645, 3, 304, 152, 0, 2644, 2642, 1, 0, 0, 0, 2645, 2648, 1, 0, 0, 0, 2646, 2644, 1, 0, 0, 0, 2646, 2647, 1, 0, 0, 0, 2647, 2650, 1, 0, 0, 0, 2648, 2646, 1, 0, 0, 0, 2649, 2639, 1, 0, 0, 0, 2649, 2650, 1, 0, 0, 0, 2650, 2661, 1, 0, 0, 0, 2651, 2652, 5, 139, 0, 0, 2652, 2653, 5, 26, 0, 0, 2653, 2658, 3, 264, 132, 0, 2654, 2655, 5, 263, 0, 0, 2655, 2657, 3, 264, 132, 0, 2656, 2654, 1, 0, 0, 0, 2657, 2660, 1, 0, 0, 0, 2658, 2656, 1, 0, 0, 0, 2658, 2659, 1, 0, 0, 0, 2659, 2662, 1, 0, 0, 0, 2660, 2658, 1, 0, 0, 0, 2661, 2651, 1, 0, 0, 0, 2661, 2662, 1, 0, 0, 0, 2662, 2664, 1, 0, 0, 0, 2663, 2665, 3, 342, 171, 0, 2664, 2663, 1, 0, 0, 0, 2664, 2665, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666, 2667, 5, 266, 0, 0, 2667, 341, 1, 0, 0, 0, 2668, 2669, 5, 154, 0, 0, 2669, 2685, 3, 344, 172, 0, 2670, 2671, 5, 169, 0, 0, 2671, 2685, 3, 344, 172, 0, 2672, 2673, 5, 154, 0, 0, 2673, 2674, 5, 15, 0, 0, 2674, 2675, 3, 344, 172, 0, 2675, 2676, 5, 5, 0, 0, 2676, 2677, 3, 344, 172, 0, 2677, 2685, 1, 0, 0, 0, 2678, 2679, 5, 169, 0, 0, 2679, 2680, 5, 15, 0, 0, 2680, 2681, 3, 344, 172, 0, 2681, 2682, 5, 5, 0, 0, 2682, 2683, 3, 344, 172, 0, 2683, 2685, 1, 0, 0, 0, 2684, 2668, 1, 0, 0, 0, 2684, 2670, 1, 0, 0, 0, 2684, 2672, 1, 0, 0, 0, 2684, 2678, 1, 0, 0, 0, 2685, 343, 1, 0, 0, 0, 2686, 2687, 5, 199, 0, 0, 2687, 2696, 5, 149, 0, 0, 2688, 2689, 5, 199, 0, 0, 2689, 2696, 5, 77, 0, 0, 2690, 2691, 5, 39, 0, 0, 2691, 2696, 5, 168, 0, 0, 2692, 2693, 3, 304, 152, 0, 2693, 2694, 7, 29, 0, 0, 2694, 2696, 1, 0, 0, 0, 2695, 2686, 1, 0, 0, 0, 2695, 2688, 1, 0, 0, 0, 2695, 2690, 1, 0, 0, 0, 2695, 2692, 1, 0, 0, 0, 2696, 345, 1, 0, 0, 0, 2697, 2698, 3, 358, 179, 0, 2698, 2699, 5, 261, 0, 0, 2699, 2700, 3, 358, 179, 0, 2700, 2703, 1, 0, 0, 0, 2701, 2703, 3, 358, 179, 0, 2702, 2697, 1, 0, 0, 0, 2702, 2701, 1, 0, 0, 0, 2703, 347, 1, 0, 0, 0, 2704, 2709, 3, 346, 173, 0, 2705, 2706, 5, 263, 0, 0, 2706, 2708, 3, 346, 173, 0, 2707, 2705, 1, 0, 0, 0, 2708, 2711, 1, 0, 0, 0, 2709, 2707, 1, 0, 0, 0, 2709, 2710, 1, 0, 0, 0, 2710, 349, 1, 0, 0, 0, 2711, 2709, 1, 0, 0, 0, 2712, 2726, 5, 2, 0, 0, 2713, 2726, 5, 4, 0, 0, 2714, 2726, 5, 58, 0, 0, 2715, 2726, 5, 37, 0, 0, 2716, 2726, 5, 99, 0, 0, 2717, 2726, 5, 162, 0, 0, 2718, 2723, 5, 174, 0, 0, 2719, 2720, 5, 265, 0, 0, 2720, 2721, 3, 358, 179, 0, 2721, 2722, 5, 266, 0, 0, 2722, 2724, 1, 0, 0, 0, 2723, 2719, 1, 0, 0, 0, 2723, 2724, 1, 0, 0, 0, 2724, 2726, 1, 0, 0, 0, 2725, 2712, 1, 0, 0, 0, 2725, 2713, 1, 0, 0, 0, 2725, 2714, 1, 0, 0, 0, 2725, 2715, 1, 0, 0, 0, 2725, 2716, 1, 0, 0, 0, 2725, 2717, 1, 0, 0, 0, 2725, 2718, 1, 0, 0, 0, 2726, 351, 1, 0, 0, 0, 2727, 2728, 7, 30, 0, 0, 2728, 353, 1, 0, 0, 0, 2729, 2734, 3, 358, 179, 0, 2730, 2731, 5, 261, 0, 0, 2731, 2733, 3, 358, 179, 0, 2732, 2730, 1, 0, 0, 0, 2733, 2736, 1, 0, 0, 0, 2734, 2732, 1, 0, 0, 0, 2734, 2735, 1, 0, 0, 0, 2735, 355, 1, 0, 0, 0, 2736, 2734, 1, 0, 0, 0, 2737, 2738, 5, 166, 0, 0, 2738, 2744, 3, 358, 179, 0, 2739, 2740, 5, 204, 0, 0, 2740, 2744, 3, 358, 179, 0, 2741, 2742, 5, 87, 0, 0, 2742, 2744, 3, 358, 179, 0, 2743, 2737, 1, 0, 0, 0, 2743, 2739, 1, 0, 0, 0, 2743, 2741, 1, 0, 0, 0, 2744, 357, 1, 0, 0, 0, 2745, 2751, 5, 280, 0, 0, 2746, 2751, 5, 274, 0, 0, 2747, 2751, 3, 364, 182, 0, 2748, 2751, 5, 283, 0, 0, 2749, 2751, 5, 281, 0, 0, 2750, 2745, 1, 0, 0, 0, 2750, 2746, 1, 0, 0, 0, 2750, 2747, 1, 0, 0, 0, 2750, 2748, 1, 0, 0, 0, 2750, 2749, 1, 0, 0, 0, 2751, 359, 1, 0, 0, 0, 2752, 2754, 5, 256, 0, 0, 2753, 2752, 1, 0, 0, 0, 2753, 2754, 1, 0, 0, 0, 2754, 2755, 1, 0, 0, 0, 2755, 2765, 5, 278, 0, 0, 2756, 2758, 5, 256, 0, 0, 2757, 2756, 1, 0, 0, 0, 2757, 2758, 1, 0, 0, 0, 2758, 2759, 1, 0, 0, 0, 2759, 2765, 5, 279, 0, 0, 2760, 2762, 5, 256, 0, 0, 2761, 2760, 1, 0, 0, 0, 2761, 2762, 1, 0, 0, 0, 2762, 2763, 1, 0, 0, 0, 2763, 2765, 5, 277, 0, 0, 2764, 2753, 1, 0, 0, 0, 2764, 2757, 1, 0, 0, 0, 2764, 2761, 1, 0, 0, 0, 2765, 361, 1, 0, 0, 0, 2766, 2767, 7, 31, 0, 0, 2767, 363, 1, 0, 0, 0, 2768, 2769, 7, 32, 0, 0, 2769, 365, 1, 0, 0, 0, 352, 369, 376, 400, 413, 417, 421, 430, 435, 439, 445, 447, 452, 456, 460, 467, 472, 478, 482, 491, 498, 502, 507, 509, 514, 518, 525, 529, 534, 538, 542, 546, 554, 559, 563, 571, 575, 584, 587, 590, 596, 603, 614, 619, 624, 629, 634, 643, 646, 649, 653, 679, 705, 714, 724, 727, 741, 759, 761, 770, 781, 790, 797, 801, 808, 814, 817, 822, 829, 843, 856, 861, 866, 872, 908, 911, 917, 920, 926, 932, 944, 946, 957, 965, 970, 974, 979, 986, 990, 994, 1000, 1004, 1008, 1017, 1020, 1023, 1031, 1045, 1052, 1065, 1071, 1076, 1079, 1082, 1087, 1091, 1100, 1105, 1111, 1115, 1120, 1125, 1128, 1136, 1139, 1143, 1155, 1158, 1162, 1167, 1171, 1187, 1192, 1199, 1202, 1208, 1211, 1218, 1221, 1225, 1230, 1233, 1240, 1243, 1267, 1281, 1285, 1289, 1309, 1311, 1313, 1322, 1324, 1333, 1335, 1344, 1346, 1351, 1360, 1369, 1378, 1389, 1395, 1400, 1403, 1416, 1426, 1430, 1435, 1446, 1451, 1484, 1492, 1497, 1501, 1505, 1510, 1514, 1519, 1524, 1529, 1533, 1542, 1545, 1549, 1556, 1567, 1573, 1577, 1583, 1593, 1600, 1605, 1610, 1615, 1621, 1624, 1633, 1636, 1639, 1645, 1651, 1661, 1664, 1668, 1672, 1679, 1682, 1688, 1694, 1697, 1700, 1704, 1714, 1725, 1730, 1733, 1737, 1744, 1754, 1766, 1772, 1774, 1783, 1786, 1793, 1803, 1809, 1817, 1828, 1838, 1849, 1851, 1857, 1862, 1872, 1875, 1881, 1883, 1891, 1897, 1900, 1902, 1914, 1921, 1925, 1929, 1933, 1936, 1943, 1952, 1955, 1959, 1964, 1968, 1971, 1978, 1989, 1992, 1996, 2000, 2009, 2012, 2019, 2033, 2037, 2041, 2045, 2049, 2053, 2057, 2061, 2071, 2082, 2087, 2100, 2102, 2108, 2112, 2114, 2122, 2129, 2134, 2147, 2153, 2161, 2168, 2172, 2180, 2182, 2193, 2201, 2210, 2216, 2221, 2227, 2233, 2238, 2243, 2249, 2260, 2262, 2289, 2295, 2299, 2311, 2321, 2324, 2329, 2336, 2339, 2348, 2351, 2355, 2358, 2370, 2373, 2392, 2396, 2404, 2408, 2433, 2436, 2445, 2451, 2457, 2463, 2474, 2483, 2505, 2508, 2511, 2521, 2523, 2530, 2532, 2554, 2583, 2590, 2598, 2603, 2605, 2611, 2618, 2624, 2646, 2649, 2658, 2661, 2664, 2684, 2695, 2702, 2709, 2723, 2725, 2734, 2743, 2750, 2753, 2757, 2761, 2764] \ No newline at end of file +[4, 1, 289, 2772, 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, 1, 0, 5, 0, 372, 8, 0, 10, 0, 12, 0, 375, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 381, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 405, 8, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 418, 8, 4, 1, 5, 1, 5, 3, 5, 422, 8, 5, 1, 5, 1, 5, 3, 5, 426, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 433, 8, 5, 10, 5, 12, 5, 436, 9, 5, 1, 5, 1, 5, 3, 5, 440, 8, 5, 1, 5, 1, 5, 3, 5, 444, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 450, 8, 5, 3, 5, 452, 8, 5, 1, 5, 1, 5, 1, 5, 3, 5, 457, 8, 5, 1, 6, 1, 6, 3, 6, 461, 8, 6, 1, 6, 1, 6, 3, 6, 465, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 472, 8, 6, 1, 6, 1, 6, 1, 6, 3, 6, 477, 8, 6, 1, 6, 1, 6, 1, 7, 1, 7, 3, 7, 483, 8, 7, 1, 7, 1, 7, 3, 7, 487, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 5, 7, 494, 8, 7, 10, 7, 12, 7, 497, 9, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 503, 8, 7, 1, 7, 1, 7, 3, 7, 507, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 512, 8, 7, 3, 7, 514, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 519, 8, 7, 1, 7, 3, 7, 522, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 529, 8, 7, 1, 7, 1, 7, 3, 7, 533, 8, 7, 1, 8, 1, 8, 1, 8, 3, 8, 538, 8, 8, 1, 8, 1, 8, 3, 8, 542, 8, 8, 1, 8, 3, 8, 545, 8, 8, 1, 8, 1, 8, 3, 8, 549, 8, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 3, 9, 557, 8, 9, 1, 9, 1, 9, 3, 9, 561, 8, 9, 1, 9, 1, 9, 3, 9, 565, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 3, 11, 573, 8, 11, 1, 11, 1, 11, 3, 11, 577, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 584, 8, 11, 10, 11, 12, 11, 587, 9, 11, 3, 11, 589, 8, 11, 1, 11, 3, 11, 592, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 598, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 605, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 616, 8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 621, 8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 626, 8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 631, 8, 11, 1, 12, 1, 12, 1, 12, 3, 12, 636, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 5, 12, 643, 8, 12, 10, 12, 12, 12, 646, 9, 12, 3, 12, 648, 8, 12, 1, 12, 3, 12, 651, 8, 12, 1, 12, 1, 12, 3, 12, 655, 8, 12, 1, 12, 1, 12, 1, 12, 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, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 681, 8, 13, 1, 14, 1, 14, 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, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 707, 8, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 716, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 726, 8, 16, 1, 16, 3, 16, 729, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 743, 8, 18, 1, 18, 1, 18, 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, 3, 20, 761, 8, 20, 3, 20, 763, 8, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 770, 8, 20, 10, 20, 12, 20, 773, 9, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 783, 8, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 792, 8, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 799, 8, 22, 1, 22, 1, 22, 3, 22, 803, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 810, 8, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 816, 8, 23, 1, 23, 3, 23, 819, 8, 23, 1, 23, 1, 23, 1, 23, 3, 23, 824, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 831, 8, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 845, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 858, 8, 26, 1, 26, 1, 26, 1, 26, 3, 26, 863, 8, 26, 1, 26, 1, 26, 1, 26, 3, 26, 868, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 874, 8, 27, 1, 27, 1, 27, 1, 27, 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, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 3, 32, 910, 8, 32, 1, 32, 3, 32, 913, 8, 32, 1, 32, 1, 32, 1, 33, 1, 33, 3, 33, 919, 8, 33, 1, 33, 3, 33, 922, 8, 33, 1, 33, 1, 33, 1, 34, 1, 34, 3, 34, 928, 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 934, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 946, 8, 35, 3, 35, 948, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 959, 8, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 967, 8, 37, 1, 38, 1, 38, 1, 38, 3, 38, 972, 8, 38, 1, 38, 1, 38, 3, 38, 976, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 981, 8, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 3, 40, 988, 8, 40, 1, 40, 1, 40, 3, 40, 992, 8, 40, 1, 41, 1, 41, 3, 41, 996, 8, 41, 1, 41, 1, 41, 1, 41, 1, 41, 3, 41, 1002, 8, 41, 1, 42, 1, 42, 3, 42, 1006, 8, 42, 1, 42, 1, 42, 3, 42, 1010, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 1017, 8, 42, 10, 42, 12, 42, 1020, 9, 42, 3, 42, 1022, 8, 42, 1, 42, 3, 42, 1025, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 3, 44, 1033, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1047, 8, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1054, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1067, 8, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1073, 8, 49, 1, 49, 1, 49, 1, 49, 3, 49, 1078, 8, 49, 1, 49, 3, 49, 1081, 8, 49, 1, 50, 3, 50, 1084, 8, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1089, 8, 50, 1, 50, 1, 50, 3, 50, 1093, 8, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 5, 50, 1100, 8, 50, 10, 50, 12, 50, 1103, 9, 50, 1, 50, 1, 50, 3, 50, 1107, 8, 50, 1, 50, 1, 50, 1, 51, 1, 51, 3, 51, 1113, 8, 51, 1, 52, 1, 52, 3, 52, 1117, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1122, 8, 52, 1, 53, 1, 53, 1, 53, 3, 53, 1127, 8, 53, 1, 53, 3, 53, 1130, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 5, 53, 1136, 8, 53, 10, 53, 12, 53, 1139, 9, 53, 3, 53, 1141, 8, 53, 1, 53, 1, 53, 3, 53, 1145, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1155, 8, 54, 10, 54, 12, 54, 1158, 9, 54, 3, 54, 1160, 8, 54, 1, 54, 1, 54, 3, 54, 1164, 8, 54, 1, 55, 1, 55, 1, 55, 3, 55, 1169, 8, 55, 1, 55, 1, 55, 3, 55, 1173, 8, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1189, 8, 56, 1, 57, 1, 57, 1, 57, 3, 57, 1194, 8, 57, 1, 57, 1, 57, 1, 57, 5, 57, 1199, 8, 57, 10, 57, 12, 57, 1202, 9, 57, 3, 57, 1204, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1210, 8, 58, 1, 58, 3, 58, 1213, 8, 58, 1, 58, 1, 58, 1, 58, 5, 58, 1218, 8, 58, 10, 58, 12, 58, 1221, 9, 58, 3, 58, 1223, 8, 58, 1, 59, 1, 59, 3, 59, 1227, 8, 59, 1, 59, 1, 59, 1, 59, 3, 59, 1232, 8, 59, 1, 59, 3, 59, 1235, 8, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1240, 8, 59, 10, 59, 12, 59, 1243, 9, 59, 3, 59, 1245, 8, 59, 1, 60, 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, 64, 1, 64, 3, 64, 1269, 8, 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, 3, 65, 1283, 8, 65, 1, 65, 1, 65, 3, 65, 1287, 8, 65, 1, 66, 1, 66, 3, 66, 1291, 8, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1311, 8, 68, 3, 68, 1313, 8, 68, 3, 68, 1315, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1324, 8, 69, 3, 69, 1326, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1335, 8, 70, 3, 70, 1337, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1346, 8, 71, 3, 71, 1348, 8, 71, 1, 72, 1, 72, 1, 72, 3, 72, 1353, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1362, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 1371, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1380, 8, 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1391, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1397, 8, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1402, 8, 78, 1, 78, 3, 78, 1405, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1418, 8, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1428, 8, 80, 1, 80, 1, 80, 3, 80, 1432, 8, 80, 1, 81, 1, 81, 1, 81, 3, 81, 1437, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 5, 82, 1446, 8, 82, 10, 82, 12, 82, 1449, 9, 82, 1, 82, 1, 82, 3, 82, 1453, 8, 82, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 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, 93, 5, 93, 1484, 8, 93, 10, 93, 12, 93, 1487, 9, 93, 1, 94, 1, 94, 1, 94, 5, 94, 1492, 8, 94, 10, 94, 12, 94, 1495, 9, 94, 1, 95, 1, 95, 3, 95, 1499, 8, 95, 1, 96, 1, 96, 3, 96, 1503, 8, 96, 1, 97, 1, 97, 3, 97, 1507, 8, 97, 1, 98, 1, 98, 1, 98, 3, 98, 1512, 8, 98, 1, 98, 3, 98, 1515, 8, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1520, 8, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1525, 8, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1530, 8, 98, 1, 98, 1, 98, 3, 98, 1534, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1543, 8, 98, 1, 98, 3, 98, 1546, 8, 98, 1, 98, 1, 98, 3, 98, 1550, 8, 98, 1, 99, 1, 99, 1, 99, 5, 99, 1555, 8, 99, 10, 99, 12, 99, 1558, 9, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 3, 101, 1566, 8, 101, 1, 101, 1, 101, 3, 101, 1570, 8, 101, 5, 101, 1572, 8, 101, 10, 101, 12, 101, 1575, 9, 101, 1, 101, 1, 101, 1, 102, 1, 102, 3, 102, 1581, 8, 102, 1, 103, 3, 103, 1584, 8, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 5, 104, 1592, 8, 104, 10, 104, 12, 104, 1595, 9, 104, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 1601, 8, 105, 1, 105, 1, 105, 1, 105, 3, 105, 1606, 8, 105, 1, 105, 1, 105, 1, 105, 3, 105, 1611, 8, 105, 1, 105, 1, 105, 1, 105, 3, 105, 1616, 8, 105, 1, 105, 1, 105, 5, 105, 1620, 8, 105, 10, 105, 12, 105, 1623, 9, 105, 3, 105, 1625, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 1634, 8, 106, 1, 106, 3, 106, 1637, 8, 106, 1, 106, 3, 106, 1640, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 1646, 8, 107, 1, 108, 1, 108, 1, 108, 3, 108, 1651, 8, 108, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1659, 8, 110, 10, 110, 12, 110, 1662, 9, 110, 3, 110, 1664, 8, 110, 1, 110, 3, 110, 1667, 8, 110, 1, 110, 1, 110, 3, 110, 1671, 8, 110, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 5, 112, 1679, 8, 112, 10, 112, 12, 112, 1682, 9, 112, 3, 112, 1684, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1690, 8, 113, 1, 113, 1, 113, 5, 113, 1694, 8, 113, 10, 113, 12, 113, 1697, 9, 113, 3, 113, 1699, 8, 113, 1, 114, 3, 114, 1702, 8, 114, 1, 114, 1, 114, 3, 114, 1706, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 3, 115, 1716, 8, 115, 1, 116, 1, 116, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 5, 118, 1725, 8, 118, 10, 118, 12, 118, 1728, 9, 118, 1, 118, 1, 118, 3, 118, 1732, 8, 118, 1, 118, 3, 118, 1735, 8, 118, 1, 119, 1, 119, 3, 119, 1739, 8, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 3, 120, 1746, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 5, 120, 1754, 8, 120, 10, 120, 12, 120, 1757, 9, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 1768, 8, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 1774, 8, 121, 3, 121, 1776, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 1785, 8, 122, 1, 122, 3, 122, 1788, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 1795, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 1805, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 1811, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 5, 126, 1817, 8, 126, 10, 126, 12, 126, 1820, 9, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 5, 127, 1828, 8, 127, 10, 127, 12, 127, 1831, 9, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 5, 128, 1838, 8, 128, 10, 128, 12, 128, 1841, 9, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 1851, 8, 129, 3, 129, 1853, 8, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 1859, 8, 129, 1, 130, 1, 130, 1, 130, 3, 130, 1864, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 5, 131, 1872, 8, 131, 10, 131, 12, 131, 1875, 9, 131, 3, 131, 1877, 8, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1883, 8, 131, 3, 131, 1885, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 1893, 8, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 1899, 8, 132, 1, 132, 5, 132, 1902, 8, 132, 10, 132, 12, 132, 1905, 9, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 5, 133, 1914, 8, 133, 10, 133, 12, 133, 1917, 9, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1923, 8, 133, 1, 134, 1, 134, 3, 134, 1927, 8, 134, 1, 134, 1, 134, 3, 134, 1931, 8, 134, 1, 135, 1, 135, 3, 135, 1935, 8, 135, 1, 135, 3, 135, 1938, 8, 135, 1, 135, 1, 135, 1, 135, 5, 135, 1943, 8, 135, 10, 135, 12, 135, 1946, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 1952, 8, 135, 10, 135, 12, 135, 1955, 9, 135, 3, 135, 1957, 8, 135, 1, 135, 1, 135, 3, 135, 1961, 8, 135, 1, 135, 1, 135, 1, 135, 3, 135, 1966, 8, 135, 1, 135, 1, 135, 3, 135, 1970, 8, 135, 1, 136, 3, 136, 1973, 8, 136, 1, 136, 1, 136, 1, 136, 5, 136, 1978, 8, 136, 10, 136, 12, 136, 1981, 9, 136, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 5, 138, 1989, 8, 138, 10, 138, 12, 138, 1992, 9, 138, 3, 138, 1994, 8, 138, 1, 138, 1, 138, 3, 138, 1998, 8, 138, 1, 139, 1, 139, 3, 139, 2002, 8, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 3, 141, 2011, 8, 141, 1, 141, 3, 141, 2014, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2021, 8, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 3, 142, 2035, 8, 142, 5, 142, 2037, 8, 142, 10, 142, 12, 142, 2040, 9, 142, 1, 143, 3, 143, 2043, 8, 143, 1, 143, 1, 143, 3, 143, 2047, 8, 143, 1, 143, 1, 143, 3, 143, 2051, 8, 143, 1, 143, 1, 143, 3, 143, 2055, 8, 143, 1, 143, 1, 143, 3, 143, 2059, 8, 143, 1, 143, 1, 143, 3, 143, 2063, 8, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2073, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 5, 144, 2082, 8, 144, 10, 144, 12, 144, 2085, 9, 144, 1, 144, 1, 144, 3, 144, 2089, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2102, 8, 145, 3, 145, 2104, 8, 145, 1, 146, 1, 146, 1, 147, 1, 147, 3, 147, 2110, 8, 147, 1, 147, 1, 147, 3, 147, 2114, 8, 147, 3, 147, 2116, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 5, 148, 2122, 8, 148, 10, 148, 12, 148, 2125, 9, 148, 1, 148, 1, 148, 1, 149, 1, 149, 3, 149, 2131, 8, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2136, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 2147, 8, 151, 10, 151, 12, 151, 2150, 9, 151, 1, 151, 1, 151, 1, 151, 3, 151, 2155, 8, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 3, 153, 2163, 8, 153, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 3, 155, 2170, 8, 155, 1, 155, 1, 155, 3, 155, 2174, 8, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 5, 155, 2182, 8, 155, 10, 155, 12, 155, 2185, 9, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2195, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2203, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 2210, 8, 156, 10, 156, 12, 156, 2213, 9, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2218, 8, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2223, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2229, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2235, 8, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2240, 8, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2245, 8, 156, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 2251, 8, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 5, 157, 2262, 8, 157, 10, 157, 12, 157, 2265, 9, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2291, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2297, 8, 158, 5, 158, 2299, 8, 158, 10, 158, 12, 158, 2302, 9, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 5, 158, 2311, 8, 158, 10, 158, 12, 158, 2314, 9, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2323, 8, 158, 1, 158, 3, 158, 2326, 8, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2331, 8, 158, 1, 158, 1, 158, 1, 158, 5, 158, 2336, 8, 158, 10, 158, 12, 158, 2339, 9, 158, 3, 158, 2341, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 5, 158, 2348, 8, 158, 10, 158, 12, 158, 2351, 9, 158, 3, 158, 2353, 8, 158, 1, 158, 1, 158, 3, 158, 2357, 8, 158, 1, 158, 3, 158, 2360, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 5, 158, 2370, 8, 158, 10, 158, 12, 158, 2373, 9, 158, 3, 158, 2375, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 4, 158, 2392, 8, 158, 11, 158, 12, 158, 2393, 1, 158, 1, 158, 3, 158, 2398, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 4, 158, 2404, 8, 158, 11, 158, 12, 158, 2405, 1, 158, 1, 158, 3, 158, 2410, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 5, 158, 2433, 8, 158, 10, 158, 12, 158, 2436, 9, 158, 3, 158, 2438, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2447, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2453, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2459, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2465, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2476, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2485, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 5, 158, 2505, 8, 158, 10, 158, 12, 158, 2508, 9, 158, 3, 158, 2510, 8, 158, 1, 158, 3, 158, 2513, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 5, 158, 2523, 8, 158, 10, 158, 12, 158, 2526, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2532, 8, 159, 3, 159, 2534, 8, 159, 1, 160, 1, 160, 1, 161, 1, 161, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2556, 8, 163, 1, 164, 1, 164, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 5, 166, 2583, 8, 166, 10, 166, 12, 166, 2586, 9, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 2592, 8, 166, 1, 166, 1, 166, 1, 166, 1, 166, 5, 166, 2598, 8, 166, 10, 166, 12, 166, 2601, 9, 166, 1, 166, 1, 166, 3, 166, 2605, 8, 166, 3, 166, 2607, 8, 166, 1, 166, 1, 166, 5, 166, 2611, 8, 166, 10, 166, 12, 166, 2614, 9, 166, 1, 167, 1, 167, 1, 168, 1, 168, 3, 168, 2620, 8, 168, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 2626, 8, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 5, 172, 2646, 8, 172, 10, 172, 12, 172, 2649, 9, 172, 3, 172, 2651, 8, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 5, 172, 2658, 8, 172, 10, 172, 12, 172, 2661, 9, 172, 3, 172, 2663, 8, 172, 1, 172, 3, 172, 2666, 8, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 2686, 8, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2697, 8, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 2704, 8, 175, 1, 176, 1, 176, 1, 176, 5, 176, 2709, 8, 176, 10, 176, 12, 176, 2712, 9, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 2725, 8, 177, 3, 177, 2727, 8, 177, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 5, 179, 2734, 8, 179, 10, 179, 12, 179, 2737, 9, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, 2745, 8, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 2752, 8, 181, 1, 182, 3, 182, 2755, 8, 182, 1, 182, 1, 182, 3, 182, 2759, 8, 182, 1, 182, 1, 182, 3, 182, 2763, 8, 182, 1, 182, 3, 182, 2766, 8, 182, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 10, 771, 1447, 1621, 1660, 1680, 1695, 1726, 1755, 1829, 2300, 6, 264, 284, 310, 314, 316, 332, 185, 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, 0, 33, 2, 0, 46, 46, 170, 170, 2, 0, 166, 166, 204, 204, 2, 0, 176, 176, 202, 202, 2, 0, 69, 69, 80, 80, 2, 0, 27, 27, 159, 159, 2, 0, 103, 103, 144, 144, 2, 0, 47, 47, 171, 171, 2, 0, 3, 3, 12, 12, 3, 0, 87, 87, 166, 166, 204, 204, 2, 0, 178, 178, 209, 209, 1, 0, 245, 248, 2, 0, 147, 147, 219, 223, 2, 0, 65, 65, 95, 95, 2, 0, 64, 64, 200, 200, 2, 0, 10, 10, 55, 55, 2, 0, 75, 75, 112, 112, 2, 0, 2, 2, 57, 57, 2, 0, 14, 14, 185, 185, 3, 0, 106, 106, 115, 115, 164, 164, 2, 0, 105, 105, 163, 163, 4, 0, 70, 70, 133, 133, 194, 194, 208, 208, 1, 0, 255, 256, 1, 0, 257, 259, 1, 0, 249, 254, 3, 0, 2, 2, 6, 6, 181, 181, 2, 0, 70, 70, 194, 194, 5, 0, 48, 49, 91, 92, 122, 125, 172, 173, 217, 218, 1, 0, 127, 130, 2, 0, 8, 8, 227, 244, 2, 0, 77, 77, 149, 149, 4, 0, 46, 46, 178, 178, 188, 188, 209, 209, 16, 0, 28, 29, 40, 40, 43, 43, 48, 48, 68, 68, 91, 91, 114, 114, 122, 122, 124, 124, 158, 158, 165, 165, 172, 172, 184, 184, 196, 196, 204, 204, 217, 217, 23, 0, 14, 14, 43, 44, 48, 49, 65, 65, 68, 68, 91, 91, 95, 95, 110, 110, 119, 119, 122, 125, 127, 130, 137, 137, 140, 140, 152, 153, 172, 173, 180, 180, 184, 185, 195, 195, 204, 204, 213, 213, 217, 217, 220, 220, 231, 231, 3093, 0, 373, 1, 0, 0, 0, 2, 378, 1, 0, 0, 0, 4, 404, 1, 0, 0, 0, 6, 406, 1, 0, 0, 0, 8, 417, 1, 0, 0, 0, 10, 419, 1, 0, 0, 0, 12, 458, 1, 0, 0, 0, 14, 480, 1, 0, 0, 0, 16, 534, 1, 0, 0, 0, 18, 553, 1, 0, 0, 0, 20, 566, 1, 0, 0, 0, 22, 570, 1, 0, 0, 0, 24, 632, 1, 0, 0, 0, 26, 680, 1, 0, 0, 0, 28, 682, 1, 0, 0, 0, 30, 690, 1, 0, 0, 0, 32, 710, 1, 0, 0, 0, 34, 730, 1, 0, 0, 0, 36, 737, 1, 0, 0, 0, 38, 746, 1, 0, 0, 0, 40, 754, 1, 0, 0, 0, 42, 776, 1, 0, 0, 0, 44, 786, 1, 0, 0, 0, 46, 804, 1, 0, 0, 0, 48, 825, 1, 0, 0, 0, 50, 846, 1, 0, 0, 0, 52, 852, 1, 0, 0, 0, 54, 869, 1, 0, 0, 0, 56, 878, 1, 0, 0, 0, 58, 885, 1, 0, 0, 0, 60, 893, 1, 0, 0, 0, 62, 900, 1, 0, 0, 0, 64, 907, 1, 0, 0, 0, 66, 916, 1, 0, 0, 0, 68, 927, 1, 0, 0, 0, 70, 929, 1, 0, 0, 0, 72, 949, 1, 0, 0, 0, 74, 966, 1, 0, 0, 0, 76, 968, 1, 0, 0, 0, 78, 977, 1, 0, 0, 0, 80, 984, 1, 0, 0, 0, 82, 993, 1, 0, 0, 0, 84, 1003, 1, 0, 0, 0, 86, 1026, 1, 0, 0, 0, 88, 1032, 1, 0, 0, 0, 90, 1034, 1, 0, 0, 0, 92, 1041, 1, 0, 0, 0, 94, 1053, 1, 0, 0, 0, 96, 1055, 1, 0, 0, 0, 98, 1062, 1, 0, 0, 0, 100, 1083, 1, 0, 0, 0, 102, 1112, 1, 0, 0, 0, 104, 1114, 1, 0, 0, 0, 106, 1123, 1, 0, 0, 0, 108, 1146, 1, 0, 0, 0, 110, 1165, 1, 0, 0, 0, 112, 1188, 1, 0, 0, 0, 114, 1190, 1, 0, 0, 0, 116, 1205, 1, 0, 0, 0, 118, 1224, 1, 0, 0, 0, 120, 1246, 1, 0, 0, 0, 122, 1251, 1, 0, 0, 0, 124, 1256, 1, 0, 0, 0, 126, 1261, 1, 0, 0, 0, 128, 1266, 1, 0, 0, 0, 130, 1273, 1, 0, 0, 0, 132, 1288, 1, 0, 0, 0, 134, 1294, 1, 0, 0, 0, 136, 1314, 1, 0, 0, 0, 138, 1316, 1, 0, 0, 0, 140, 1327, 1, 0, 0, 0, 142, 1338, 1, 0, 0, 0, 144, 1352, 1, 0, 0, 0, 146, 1354, 1, 0, 0, 0, 148, 1363, 1, 0, 0, 0, 150, 1372, 1, 0, 0, 0, 152, 1381, 1, 0, 0, 0, 154, 1384, 1, 0, 0, 0, 156, 1392, 1, 0, 0, 0, 158, 1408, 1, 0, 0, 0, 160, 1412, 1, 0, 0, 0, 162, 1436, 1, 0, 0, 0, 164, 1438, 1, 0, 0, 0, 166, 1454, 1, 0, 0, 0, 168, 1457, 1, 0, 0, 0, 170, 1461, 1, 0, 0, 0, 172, 1464, 1, 0, 0, 0, 174, 1468, 1, 0, 0, 0, 176, 1470, 1, 0, 0, 0, 178, 1472, 1, 0, 0, 0, 180, 1474, 1, 0, 0, 0, 182, 1476, 1, 0, 0, 0, 184, 1478, 1, 0, 0, 0, 186, 1480, 1, 0, 0, 0, 188, 1488, 1, 0, 0, 0, 190, 1498, 1, 0, 0, 0, 192, 1502, 1, 0, 0, 0, 194, 1506, 1, 0, 0, 0, 196, 1511, 1, 0, 0, 0, 198, 1551, 1, 0, 0, 0, 200, 1559, 1, 0, 0, 0, 202, 1563, 1, 0, 0, 0, 204, 1578, 1, 0, 0, 0, 206, 1583, 1, 0, 0, 0, 208, 1587, 1, 0, 0, 0, 210, 1596, 1, 0, 0, 0, 212, 1626, 1, 0, 0, 0, 214, 1641, 1, 0, 0, 0, 216, 1647, 1, 0, 0, 0, 218, 1652, 1, 0, 0, 0, 220, 1654, 1, 0, 0, 0, 222, 1672, 1, 0, 0, 0, 224, 1675, 1, 0, 0, 0, 226, 1685, 1, 0, 0, 0, 228, 1705, 1, 0, 0, 0, 230, 1715, 1, 0, 0, 0, 232, 1717, 1, 0, 0, 0, 234, 1719, 1, 0, 0, 0, 236, 1734, 1, 0, 0, 0, 238, 1736, 1, 0, 0, 0, 240, 1743, 1, 0, 0, 0, 242, 1775, 1, 0, 0, 0, 244, 1787, 1, 0, 0, 0, 246, 1794, 1, 0, 0, 0, 248, 1804, 1, 0, 0, 0, 250, 1806, 1, 0, 0, 0, 252, 1812, 1, 0, 0, 0, 254, 1823, 1, 0, 0, 0, 256, 1834, 1, 0, 0, 0, 258, 1842, 1, 0, 0, 0, 260, 1860, 1, 0, 0, 0, 262, 1865, 1, 0, 0, 0, 264, 1886, 1, 0, 0, 0, 266, 1922, 1, 0, 0, 0, 268, 1924, 1, 0, 0, 0, 270, 1932, 1, 0, 0, 0, 272, 1972, 1, 0, 0, 0, 274, 1982, 1, 0, 0, 0, 276, 1997, 1, 0, 0, 0, 278, 1999, 1, 0, 0, 0, 280, 2006, 1, 0, 0, 0, 282, 2020, 1, 0, 0, 0, 284, 2022, 1, 0, 0, 0, 286, 2072, 1, 0, 0, 0, 288, 2088, 1, 0, 0, 0, 290, 2090, 1, 0, 0, 0, 292, 2105, 1, 0, 0, 0, 294, 2107, 1, 0, 0, 0, 296, 2117, 1, 0, 0, 0, 298, 2135, 1, 0, 0, 0, 300, 2137, 1, 0, 0, 0, 302, 2141, 1, 0, 0, 0, 304, 2156, 1, 0, 0, 0, 306, 2162, 1, 0, 0, 0, 308, 2164, 1, 0, 0, 0, 310, 2173, 1, 0, 0, 0, 312, 2244, 1, 0, 0, 0, 314, 2250, 1, 0, 0, 0, 316, 2512, 1, 0, 0, 0, 318, 2533, 1, 0, 0, 0, 320, 2535, 1, 0, 0, 0, 322, 2537, 1, 0, 0, 0, 324, 2539, 1, 0, 0, 0, 326, 2555, 1, 0, 0, 0, 328, 2557, 1, 0, 0, 0, 330, 2559, 1, 0, 0, 0, 332, 2606, 1, 0, 0, 0, 334, 2615, 1, 0, 0, 0, 336, 2619, 1, 0, 0, 0, 338, 2625, 1, 0, 0, 0, 340, 2627, 1, 0, 0, 0, 342, 2632, 1, 0, 0, 0, 344, 2638, 1, 0, 0, 0, 346, 2685, 1, 0, 0, 0, 348, 2696, 1, 0, 0, 0, 350, 2703, 1, 0, 0, 0, 352, 2705, 1, 0, 0, 0, 354, 2726, 1, 0, 0, 0, 356, 2728, 1, 0, 0, 0, 358, 2730, 1, 0, 0, 0, 360, 2744, 1, 0, 0, 0, 362, 2751, 1, 0, 0, 0, 364, 2765, 1, 0, 0, 0, 366, 2767, 1, 0, 0, 0, 368, 2769, 1, 0, 0, 0, 370, 372, 3, 2, 1, 0, 371, 370, 1, 0, 0, 0, 372, 375, 1, 0, 0, 0, 373, 371, 1, 0, 0, 0, 373, 374, 1, 0, 0, 0, 374, 376, 1, 0, 0, 0, 375, 373, 1, 0, 0, 0, 376, 377, 5, 0, 0, 1, 377, 1, 1, 0, 0, 0, 378, 380, 3, 4, 2, 0, 379, 381, 5, 262, 0, 0, 380, 379, 1, 0, 0, 0, 380, 381, 1, 0, 0, 0, 381, 3, 1, 0, 0, 0, 382, 405, 3, 206, 103, 0, 383, 405, 3, 6, 3, 0, 384, 405, 3, 8, 4, 0, 385, 405, 3, 26, 13, 0, 386, 405, 3, 64, 32, 0, 387, 405, 3, 66, 33, 0, 388, 405, 3, 68, 34, 0, 389, 405, 3, 74, 37, 0, 390, 405, 3, 88, 44, 0, 391, 405, 3, 94, 47, 0, 392, 405, 3, 100, 50, 0, 393, 405, 3, 102, 51, 0, 394, 405, 3, 108, 54, 0, 395, 405, 3, 110, 55, 0, 396, 405, 3, 112, 56, 0, 397, 405, 3, 144, 72, 0, 398, 405, 3, 152, 76, 0, 399, 405, 3, 154, 77, 0, 400, 405, 3, 156, 78, 0, 401, 405, 3, 158, 79, 0, 402, 405, 3, 160, 80, 0, 403, 405, 3, 162, 81, 0, 404, 382, 1, 0, 0, 0, 404, 383, 1, 0, 0, 0, 404, 384, 1, 0, 0, 0, 404, 385, 1, 0, 0, 0, 404, 386, 1, 0, 0, 0, 404, 387, 1, 0, 0, 0, 404, 388, 1, 0, 0, 0, 404, 389, 1, 0, 0, 0, 404, 390, 1, 0, 0, 0, 404, 391, 1, 0, 0, 0, 404, 392, 1, 0, 0, 0, 404, 393, 1, 0, 0, 0, 404, 394, 1, 0, 0, 0, 404, 395, 1, 0, 0, 0, 404, 396, 1, 0, 0, 0, 404, 397, 1, 0, 0, 0, 404, 398, 1, 0, 0, 0, 404, 399, 1, 0, 0, 0, 404, 400, 1, 0, 0, 0, 404, 401, 1, 0, 0, 0, 404, 402, 1, 0, 0, 0, 404, 403, 1, 0, 0, 0, 405, 5, 1, 0, 0, 0, 406, 407, 5, 203, 0, 0, 407, 408, 3, 184, 92, 0, 408, 7, 1, 0, 0, 0, 409, 418, 3, 18, 9, 0, 410, 418, 3, 20, 10, 0, 411, 418, 3, 22, 11, 0, 412, 418, 3, 24, 12, 0, 413, 418, 3, 16, 8, 0, 414, 418, 3, 14, 7, 0, 415, 418, 3, 12, 6, 0, 416, 418, 3, 10, 5, 0, 417, 409, 1, 0, 0, 0, 417, 410, 1, 0, 0, 0, 417, 411, 1, 0, 0, 0, 417, 412, 1, 0, 0, 0, 417, 413, 1, 0, 0, 0, 417, 414, 1, 0, 0, 0, 417, 415, 1, 0, 0, 0, 417, 416, 1, 0, 0, 0, 418, 9, 1, 0, 0, 0, 419, 421, 5, 37, 0, 0, 420, 422, 5, 19, 0, 0, 421, 420, 1, 0, 0, 0, 421, 422, 1, 0, 0, 0, 422, 423, 1, 0, 0, 0, 423, 425, 5, 188, 0, 0, 424, 426, 3, 172, 86, 0, 425, 424, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 427, 1, 0, 0, 0, 427, 443, 3, 174, 87, 0, 428, 429, 5, 265, 0, 0, 429, 434, 3, 216, 108, 0, 430, 431, 5, 263, 0, 0, 431, 433, 3, 216, 108, 0, 432, 430, 1, 0, 0, 0, 433, 436, 1, 0, 0, 0, 434, 432, 1, 0, 0, 0, 434, 435, 1, 0, 0, 0, 435, 439, 1, 0, 0, 0, 436, 434, 1, 0, 0, 0, 437, 438, 5, 263, 0, 0, 438, 440, 3, 210, 105, 0, 439, 437, 1, 0, 0, 0, 439, 440, 1, 0, 0, 0, 440, 441, 1, 0, 0, 0, 441, 442, 5, 266, 0, 0, 442, 444, 1, 0, 0, 0, 443, 428, 1, 0, 0, 0, 443, 444, 1, 0, 0, 0, 444, 451, 1, 0, 0, 0, 445, 446, 5, 17, 0, 0, 446, 449, 5, 26, 0, 0, 447, 450, 3, 296, 148, 0, 448, 450, 3, 254, 127, 0, 449, 447, 1, 0, 0, 0, 449, 448, 1, 0, 0, 0, 450, 452, 1, 0, 0, 0, 451, 445, 1, 0, 0, 0, 451, 452, 1, 0, 0, 0, 452, 453, 1, 0, 0, 0, 453, 456, 3, 196, 98, 0, 454, 455, 5, 9, 0, 0, 455, 457, 3, 206, 103, 0, 456, 454, 1, 0, 0, 0, 456, 457, 1, 0, 0, 0, 457, 11, 1, 0, 0, 0, 458, 460, 5, 37, 0, 0, 459, 461, 5, 19, 0, 0, 460, 459, 1, 0, 0, 0, 460, 461, 1, 0, 0, 0, 461, 462, 1, 0, 0, 0, 462, 464, 5, 188, 0, 0, 463, 465, 3, 172, 86, 0, 464, 463, 1, 0, 0, 0, 464, 465, 1, 0, 0, 0, 465, 466, 1, 0, 0, 0, 466, 467, 3, 174, 87, 0, 467, 471, 5, 115, 0, 0, 468, 472, 3, 186, 93, 0, 469, 470, 5, 147, 0, 0, 470, 472, 3, 318, 159, 0, 471, 468, 1, 0, 0, 0, 471, 469, 1, 0, 0, 0, 472, 476, 1, 0, 0, 0, 473, 474, 5, 17, 0, 0, 474, 475, 5, 26, 0, 0, 475, 477, 3, 254, 127, 0, 476, 473, 1, 0, 0, 0, 476, 477, 1, 0, 0, 0, 477, 478, 1, 0, 0, 0, 478, 479, 3, 196, 98, 0, 479, 13, 1, 0, 0, 0, 480, 482, 5, 37, 0, 0, 481, 483, 5, 19, 0, 0, 482, 481, 1, 0, 0, 0, 482, 483, 1, 0, 0, 0, 483, 484, 1, 0, 0, 0, 484, 486, 5, 188, 0, 0, 485, 487, 3, 172, 86, 0, 486, 485, 1, 0, 0, 0, 486, 487, 1, 0, 0, 0, 487, 488, 1, 0, 0, 0, 488, 506, 3, 174, 87, 0, 489, 490, 5, 265, 0, 0, 490, 495, 3, 218, 109, 0, 491, 492, 5, 263, 0, 0, 492, 494, 3, 218, 109, 0, 493, 491, 1, 0, 0, 0, 494, 497, 1, 0, 0, 0, 495, 493, 1, 0, 0, 0, 495, 496, 1, 0, 0, 0, 496, 502, 1, 0, 0, 0, 497, 495, 1, 0, 0, 0, 498, 499, 5, 263, 0, 0, 499, 500, 5, 150, 0, 0, 500, 501, 5, 110, 0, 0, 501, 503, 3, 296, 148, 0, 502, 498, 1, 0, 0, 0, 502, 503, 1, 0, 0, 0, 503, 504, 1, 0, 0, 0, 504, 505, 5, 266, 0, 0, 505, 507, 1, 0, 0, 0, 506, 489, 1, 0, 0, 0, 506, 507, 1, 0, 0, 0, 507, 513, 1, 0, 0, 0, 508, 509, 5, 150, 0, 0, 509, 511, 5, 110, 0, 0, 510, 512, 3, 296, 148, 0, 511, 510, 1, 0, 0, 0, 511, 512, 1, 0, 0, 0, 512, 514, 1, 0, 0, 0, 513, 508, 1, 0, 0, 0, 513, 514, 1, 0, 0, 0, 514, 518, 1, 0, 0, 0, 515, 516, 5, 145, 0, 0, 516, 517, 5, 26, 0, 0, 517, 519, 3, 236, 118, 0, 518, 515, 1, 0, 0, 0, 518, 519, 1, 0, 0, 0, 519, 521, 1, 0, 0, 0, 520, 522, 3, 222, 111, 0, 521, 520, 1, 0, 0, 0, 521, 522, 1, 0, 0, 0, 522, 523, 1, 0, 0, 0, 523, 524, 5, 23, 0, 0, 524, 525, 5, 9, 0, 0, 525, 528, 5, 111, 0, 0, 526, 527, 5, 25, 0, 0, 527, 529, 3, 252, 126, 0, 528, 526, 1, 0, 0, 0, 528, 529, 1, 0, 0, 0, 529, 532, 1, 0, 0, 0, 530, 531, 5, 9, 0, 0, 531, 533, 3, 206, 103, 0, 532, 530, 1, 0, 0, 0, 532, 533, 1, 0, 0, 0, 533, 15, 1, 0, 0, 0, 534, 535, 5, 37, 0, 0, 535, 537, 5, 212, 0, 0, 536, 538, 3, 172, 86, 0, 537, 536, 1, 0, 0, 0, 537, 538, 1, 0, 0, 0, 538, 539, 1, 0, 0, 0, 539, 541, 3, 178, 89, 0, 540, 542, 3, 202, 101, 0, 541, 540, 1, 0, 0, 0, 541, 542, 1, 0, 0, 0, 542, 544, 1, 0, 0, 0, 543, 545, 3, 222, 111, 0, 544, 543, 1, 0, 0, 0, 544, 545, 1, 0, 0, 0, 545, 548, 1, 0, 0, 0, 546, 547, 5, 25, 0, 0, 547, 549, 3, 252, 126, 0, 548, 546, 1, 0, 0, 0, 548, 549, 1, 0, 0, 0, 549, 550, 1, 0, 0, 0, 550, 551, 5, 9, 0, 0, 551, 552, 3, 206, 103, 0, 552, 17, 1, 0, 0, 0, 553, 554, 5, 37, 0, 0, 554, 556, 7, 0, 0, 0, 555, 557, 3, 172, 86, 0, 556, 555, 1, 0, 0, 0, 556, 557, 1, 0, 0, 0, 557, 558, 1, 0, 0, 0, 558, 560, 3, 176, 88, 0, 559, 561, 3, 222, 111, 0, 560, 559, 1, 0, 0, 0, 560, 561, 1, 0, 0, 0, 561, 564, 1, 0, 0, 0, 562, 563, 5, 24, 0, 0, 563, 565, 3, 318, 159, 0, 564, 562, 1, 0, 0, 0, 564, 565, 1, 0, 0, 0, 565, 19, 1, 0, 0, 0, 566, 567, 5, 37, 0, 0, 567, 568, 5, 166, 0, 0, 568, 569, 3, 362, 181, 0, 569, 21, 1, 0, 0, 0, 570, 572, 5, 37, 0, 0, 571, 573, 5, 12, 0, 0, 572, 571, 1, 0, 0, 0, 572, 573, 1, 0, 0, 0, 573, 574, 1, 0, 0, 0, 574, 576, 5, 84, 0, 0, 575, 577, 3, 172, 86, 0, 576, 575, 1, 0, 0, 0, 576, 577, 1, 0, 0, 0, 577, 578, 1, 0, 0, 0, 578, 591, 3, 180, 90, 0, 579, 588, 5, 265, 0, 0, 580, 585, 3, 332, 166, 0, 581, 582, 5, 263, 0, 0, 582, 584, 3, 332, 166, 0, 583, 581, 1, 0, 0, 0, 584, 587, 1, 0, 0, 0, 585, 583, 1, 0, 0, 0, 585, 586, 1, 0, 0, 0, 586, 589, 1, 0, 0, 0, 587, 585, 1, 0, 0, 0, 588, 580, 1, 0, 0, 0, 588, 589, 1, 0, 0, 0, 589, 590, 1, 0, 0, 0, 590, 592, 5, 266, 0, 0, 591, 579, 1, 0, 0, 0, 591, 592, 1, 0, 0, 0, 592, 593, 1, 0, 0, 0, 593, 594, 5, 160, 0, 0, 594, 597, 3, 332, 166, 0, 595, 596, 5, 102, 0, 0, 596, 598, 3, 332, 166, 0, 597, 595, 1, 0, 0, 0, 597, 598, 1, 0, 0, 0, 598, 599, 1, 0, 0, 0, 599, 600, 5, 24, 0, 0, 600, 604, 5, 274, 0, 0, 601, 602, 5, 104, 0, 0, 602, 603, 5, 249, 0, 0, 603, 605, 5, 274, 0, 0, 604, 601, 1, 0, 0, 0, 604, 605, 1, 0, 0, 0, 605, 606, 1, 0, 0, 0, 606, 607, 5, 206, 0, 0, 607, 608, 5, 249, 0, 0, 608, 609, 5, 274, 0, 0, 609, 610, 5, 126, 0, 0, 610, 611, 5, 249, 0, 0, 611, 615, 5, 274, 0, 0, 612, 613, 5, 18, 0, 0, 613, 614, 5, 249, 0, 0, 614, 616, 5, 274, 0, 0, 615, 612, 1, 0, 0, 0, 615, 616, 1, 0, 0, 0, 616, 620, 1, 0, 0, 0, 617, 618, 5, 20, 0, 0, 618, 619, 5, 249, 0, 0, 619, 621, 5, 274, 0, 0, 620, 617, 1, 0, 0, 0, 620, 621, 1, 0, 0, 0, 621, 625, 1, 0, 0, 0, 622, 623, 5, 187, 0, 0, 623, 624, 5, 249, 0, 0, 624, 626, 5, 274, 0, 0, 625, 622, 1, 0, 0, 0, 625, 626, 1, 0, 0, 0, 626, 630, 1, 0, 0, 0, 627, 628, 5, 76, 0, 0, 628, 629, 5, 249, 0, 0, 629, 631, 5, 274, 0, 0, 630, 627, 1, 0, 0, 0, 630, 631, 1, 0, 0, 0, 631, 23, 1, 0, 0, 0, 632, 633, 5, 37, 0, 0, 633, 635, 5, 84, 0, 0, 634, 636, 3, 172, 86, 0, 635, 634, 1, 0, 0, 0, 635, 636, 1, 0, 0, 0, 636, 637, 1, 0, 0, 0, 637, 650, 3, 180, 90, 0, 638, 647, 5, 265, 0, 0, 639, 644, 3, 332, 166, 0, 640, 641, 5, 263, 0, 0, 641, 643, 3, 332, 166, 0, 642, 640, 1, 0, 0, 0, 643, 646, 1, 0, 0, 0, 644, 642, 1, 0, 0, 0, 644, 645, 1, 0, 0, 0, 645, 648, 1, 0, 0, 0, 646, 644, 1, 0, 0, 0, 647, 639, 1, 0, 0, 0, 647, 648, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 649, 651, 5, 266, 0, 0, 650, 638, 1, 0, 0, 0, 650, 651, 1, 0, 0, 0, 651, 654, 1, 0, 0, 0, 652, 653, 5, 160, 0, 0, 653, 655, 3, 332, 166, 0, 654, 652, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 656, 1, 0, 0, 0, 656, 657, 5, 24, 0, 0, 657, 658, 5, 274, 0, 0, 658, 659, 5, 186, 0, 0, 659, 660, 5, 249, 0, 0, 660, 661, 3, 318, 159, 0, 661, 25, 1, 0, 0, 0, 662, 681, 3, 28, 14, 0, 663, 681, 3, 62, 31, 0, 664, 681, 3, 60, 30, 0, 665, 681, 3, 58, 29, 0, 666, 681, 3, 54, 27, 0, 667, 681, 3, 56, 28, 0, 668, 681, 3, 52, 26, 0, 669, 681, 3, 48, 24, 0, 670, 681, 3, 50, 25, 0, 671, 681, 3, 46, 23, 0, 672, 681, 3, 44, 22, 0, 673, 681, 3, 42, 21, 0, 674, 681, 3, 40, 20, 0, 675, 681, 3, 34, 17, 0, 676, 681, 3, 30, 15, 0, 677, 681, 3, 32, 16, 0, 678, 681, 3, 36, 18, 0, 679, 681, 3, 38, 19, 0, 680, 662, 1, 0, 0, 0, 680, 663, 1, 0, 0, 0, 680, 664, 1, 0, 0, 0, 680, 665, 1, 0, 0, 0, 680, 666, 1, 0, 0, 0, 680, 667, 1, 0, 0, 0, 680, 668, 1, 0, 0, 0, 680, 669, 1, 0, 0, 0, 680, 670, 1, 0, 0, 0, 680, 671, 1, 0, 0, 0, 680, 672, 1, 0, 0, 0, 680, 673, 1, 0, 0, 0, 680, 674, 1, 0, 0, 0, 680, 675, 1, 0, 0, 0, 680, 676, 1, 0, 0, 0, 680, 677, 1, 0, 0, 0, 680, 678, 1, 0, 0, 0, 680, 679, 1, 0, 0, 0, 681, 27, 1, 0, 0, 0, 682, 683, 5, 4, 0, 0, 683, 684, 5, 46, 0, 0, 684, 685, 3, 184, 92, 0, 685, 686, 5, 176, 0, 0, 686, 687, 5, 142, 0, 0, 687, 688, 7, 1, 0, 0, 688, 689, 3, 362, 181, 0, 689, 29, 1, 0, 0, 0, 690, 691, 5, 4, 0, 0, 691, 692, 5, 188, 0, 0, 692, 693, 3, 186, 93, 0, 693, 694, 5, 176, 0, 0, 694, 695, 5, 32, 0, 0, 695, 696, 5, 182, 0, 0, 696, 697, 3, 192, 96, 0, 697, 698, 5, 265, 0, 0, 698, 699, 3, 232, 116, 0, 699, 700, 5, 249, 0, 0, 700, 706, 3, 318, 159, 0, 701, 702, 5, 263, 0, 0, 702, 703, 3, 232, 116, 0, 703, 704, 5, 249, 0, 0, 704, 705, 3, 318, 159, 0, 705, 707, 1, 0, 0, 0, 706, 701, 1, 0, 0, 0, 706, 707, 1, 0, 0, 0, 707, 708, 1, 0, 0, 0, 708, 709, 5, 266, 0, 0, 709, 31, 1, 0, 0, 0, 710, 711, 5, 4, 0, 0, 711, 712, 5, 188, 0, 0, 712, 715, 3, 186, 93, 0, 713, 714, 5, 145, 0, 0, 714, 716, 3, 308, 154, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 717, 1, 0, 0, 0, 717, 728, 5, 176, 0, 0, 718, 719, 5, 30, 0, 0, 719, 720, 5, 94, 0, 0, 720, 725, 3, 318, 159, 0, 721, 722, 5, 216, 0, 0, 722, 723, 5, 151, 0, 0, 723, 724, 5, 249, 0, 0, 724, 726, 3, 364, 182, 0, 725, 721, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 729, 1, 0, 0, 0, 727, 729, 5, 197, 0, 0, 728, 718, 1, 0, 0, 0, 728, 727, 1, 0, 0, 0, 729, 33, 1, 0, 0, 0, 730, 731, 5, 4, 0, 0, 731, 732, 5, 188, 0, 0, 732, 733, 3, 186, 93, 0, 733, 734, 5, 31, 0, 0, 734, 735, 3, 192, 96, 0, 735, 736, 3, 224, 112, 0, 736, 35, 1, 0, 0, 0, 737, 738, 5, 4, 0, 0, 738, 739, 5, 188, 0, 0, 739, 740, 3, 186, 93, 0, 740, 742, 5, 58, 0, 0, 741, 743, 5, 32, 0, 0, 742, 741, 1, 0, 0, 0, 742, 743, 1, 0, 0, 0, 743, 744, 1, 0, 0, 0, 744, 745, 3, 192, 96, 0, 745, 37, 1, 0, 0, 0, 746, 747, 5, 4, 0, 0, 747, 748, 5, 188, 0, 0, 748, 749, 3, 186, 93, 0, 749, 750, 5, 176, 0, 0, 750, 751, 5, 142, 0, 0, 751, 752, 7, 1, 0, 0, 752, 753, 3, 362, 181, 0, 753, 39, 1, 0, 0, 0, 754, 755, 5, 4, 0, 0, 755, 756, 5, 188, 0, 0, 756, 762, 3, 186, 93, 0, 757, 763, 5, 158, 0, 0, 758, 760, 5, 1, 0, 0, 759, 761, 3, 172, 86, 0, 760, 759, 1, 0, 0, 0, 760, 761, 1, 0, 0, 0, 761, 763, 1, 0, 0, 0, 762, 757, 1, 0, 0, 0, 762, 758, 1, 0, 0, 0, 763, 764, 1, 0, 0, 0, 764, 765, 5, 33, 0, 0, 765, 766, 5, 265, 0, 0, 766, 771, 3, 224, 112, 0, 767, 768, 5, 263, 0, 0, 768, 770, 3, 224, 112, 0, 769, 767, 1, 0, 0, 0, 770, 773, 1, 0, 0, 0, 771, 772, 1, 0, 0, 0, 771, 769, 1, 0, 0, 0, 772, 774, 1, 0, 0, 0, 773, 771, 1, 0, 0, 0, 774, 775, 5, 266, 0, 0, 775, 41, 1, 0, 0, 0, 776, 777, 5, 4, 0, 0, 777, 778, 5, 188, 0, 0, 778, 779, 3, 186, 93, 0, 779, 780, 5, 1, 0, 0, 780, 782, 5, 32, 0, 0, 781, 783, 3, 172, 86, 0, 782, 781, 1, 0, 0, 0, 782, 783, 1, 0, 0, 0, 783, 784, 1, 0, 0, 0, 784, 785, 3, 226, 113, 0, 785, 43, 1, 0, 0, 0, 786, 787, 5, 4, 0, 0, 787, 788, 5, 188, 0, 0, 788, 789, 3, 186, 93, 0, 789, 791, 5, 4, 0, 0, 790, 792, 5, 32, 0, 0, 791, 790, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 802, 3, 192, 96, 0, 794, 798, 5, 176, 0, 0, 795, 799, 3, 230, 115, 0, 796, 797, 5, 34, 0, 0, 797, 799, 3, 318, 159, 0, 798, 795, 1, 0, 0, 0, 798, 796, 1, 0, 0, 0, 799, 803, 1, 0, 0, 0, 800, 801, 5, 58, 0, 0, 801, 803, 5, 51, 0, 0, 802, 794, 1, 0, 0, 0, 802, 800, 1, 0, 0, 0, 803, 45, 1, 0, 0, 0, 804, 805, 5, 4, 0, 0, 805, 806, 5, 188, 0, 0, 806, 807, 3, 186, 93, 0, 807, 809, 5, 1, 0, 0, 808, 810, 3, 172, 86, 0, 809, 808, 1, 0, 0, 0, 809, 810, 1, 0, 0, 0, 810, 823, 1, 0, 0, 0, 811, 812, 5, 145, 0, 0, 812, 815, 3, 308, 154, 0, 813, 814, 5, 24, 0, 0, 814, 816, 3, 318, 159, 0, 815, 813, 1, 0, 0, 0, 815, 816, 1, 0, 0, 0, 816, 818, 1, 0, 0, 0, 817, 819, 3, 244, 122, 0, 818, 817, 1, 0, 0, 0, 818, 819, 1, 0, 0, 0, 819, 824, 1, 0, 0, 0, 820, 821, 5, 154, 0, 0, 821, 822, 5, 145, 0, 0, 822, 824, 3, 242, 121, 0, 823, 811, 1, 0, 0, 0, 823, 820, 1, 0, 0, 0, 824, 47, 1, 0, 0, 0, 825, 826, 5, 4, 0, 0, 826, 827, 5, 188, 0, 0, 827, 830, 3, 186, 93, 0, 828, 829, 5, 145, 0, 0, 829, 831, 3, 308, 154, 0, 830, 828, 1, 0, 0, 0, 830, 831, 1, 0, 0, 0, 831, 832, 1, 0, 0, 0, 832, 844, 5, 176, 0, 0, 833, 834, 5, 72, 0, 0, 834, 845, 3, 234, 117, 0, 835, 836, 5, 168, 0, 0, 836, 837, 5, 79, 0, 0, 837, 845, 3, 258, 129, 0, 838, 839, 5, 24, 0, 0, 839, 845, 3, 318, 159, 0, 840, 841, 5, 25, 0, 0, 841, 845, 3, 252, 126, 0, 842, 843, 5, 175, 0, 0, 843, 845, 3, 252, 126, 0, 844, 833, 1, 0, 0, 0, 844, 835, 1, 0, 0, 0, 844, 838, 1, 0, 0, 0, 844, 840, 1, 0, 0, 0, 844, 842, 1, 0, 0, 0, 845, 49, 1, 0, 0, 0, 846, 847, 5, 4, 0, 0, 847, 848, 5, 188, 0, 0, 848, 849, 3, 186, 93, 0, 849, 850, 5, 155, 0, 0, 850, 851, 5, 146, 0, 0, 851, 51, 1, 0, 0, 0, 852, 853, 5, 4, 0, 0, 853, 854, 5, 188, 0, 0, 854, 855, 3, 186, 93, 0, 855, 857, 5, 58, 0, 0, 856, 858, 3, 170, 85, 0, 857, 856, 1, 0, 0, 0, 857, 858, 1, 0, 0, 0, 858, 867, 1, 0, 0, 0, 859, 860, 5, 145, 0, 0, 860, 862, 3, 308, 154, 0, 861, 863, 5, 22, 0, 0, 862, 861, 1, 0, 0, 0, 862, 863, 1, 0, 0, 0, 863, 868, 1, 0, 0, 0, 864, 865, 5, 154, 0, 0, 865, 866, 5, 145, 0, 0, 866, 868, 3, 242, 121, 0, 867, 859, 1, 0, 0, 0, 867, 864, 1, 0, 0, 0, 868, 53, 1, 0, 0, 0, 869, 870, 5, 4, 0, 0, 870, 871, 5, 212, 0, 0, 871, 873, 3, 188, 94, 0, 872, 874, 3, 202, 101, 0, 873, 872, 1, 0, 0, 0, 873, 874, 1, 0, 0, 0, 874, 875, 1, 0, 0, 0, 875, 876, 5, 9, 0, 0, 876, 877, 3, 206, 103, 0, 877, 55, 1, 0, 0, 0, 878, 879, 5, 4, 0, 0, 879, 880, 5, 212, 0, 0, 880, 881, 3, 188, 94, 0, 881, 882, 5, 156, 0, 0, 882, 883, 5, 193, 0, 0, 883, 884, 3, 188, 94, 0, 884, 57, 1, 0, 0, 0, 885, 886, 5, 4, 0, 0, 886, 887, 5, 212, 0, 0, 887, 888, 3, 188, 94, 0, 888, 889, 5, 176, 0, 0, 889, 890, 5, 142, 0, 0, 890, 891, 7, 1, 0, 0, 891, 892, 3, 358, 179, 0, 892, 59, 1, 0, 0, 0, 893, 894, 5, 4, 0, 0, 894, 895, 5, 188, 0, 0, 895, 896, 3, 186, 93, 0, 896, 897, 5, 156, 0, 0, 897, 898, 5, 193, 0, 0, 898, 899, 3, 186, 93, 0, 899, 61, 1, 0, 0, 0, 900, 901, 5, 4, 0, 0, 901, 902, 5, 212, 0, 0, 902, 903, 3, 188, 94, 0, 903, 904, 7, 2, 0, 0, 904, 905, 5, 25, 0, 0, 905, 906, 3, 252, 126, 0, 906, 63, 1, 0, 0, 0, 907, 909, 5, 196, 0, 0, 908, 910, 5, 188, 0, 0, 909, 908, 1, 0, 0, 0, 909, 910, 1, 0, 0, 0, 910, 912, 1, 0, 0, 0, 911, 913, 3, 170, 85, 0, 912, 911, 1, 0, 0, 0, 912, 913, 1, 0, 0, 0, 913, 914, 1, 0, 0, 0, 914, 915, 3, 186, 93, 0, 915, 65, 1, 0, 0, 0, 916, 918, 5, 56, 0, 0, 917, 919, 5, 46, 0, 0, 918, 917, 1, 0, 0, 0, 918, 919, 1, 0, 0, 0, 919, 921, 1, 0, 0, 0, 920, 922, 7, 3, 0, 0, 921, 920, 1, 0, 0, 0, 921, 922, 1, 0, 0, 0, 922, 923, 1, 0, 0, 0, 923, 924, 3, 358, 179, 0, 924, 67, 1, 0, 0, 0, 925, 928, 3, 70, 35, 0, 926, 928, 3, 72, 36, 0, 927, 925, 1, 0, 0, 0, 927, 926, 1, 0, 0, 0, 928, 69, 1, 0, 0, 0, 929, 930, 5, 36, 0, 0, 930, 931, 5, 182, 0, 0, 931, 933, 3, 186, 93, 0, 932, 934, 3, 296, 148, 0, 933, 932, 1, 0, 0, 0, 933, 934, 1, 0, 0, 0, 934, 947, 1, 0, 0, 0, 935, 936, 5, 190, 0, 0, 936, 937, 5, 185, 0, 0, 937, 938, 5, 265, 0, 0, 938, 939, 3, 364, 182, 0, 939, 945, 5, 266, 0, 0, 940, 941, 5, 157, 0, 0, 941, 942, 5, 265, 0, 0, 942, 943, 3, 364, 182, 0, 943, 944, 5, 266, 0, 0, 944, 946, 1, 0, 0, 0, 945, 940, 1, 0, 0, 0, 945, 946, 1, 0, 0, 0, 946, 948, 1, 0, 0, 0, 947, 935, 1, 0, 0, 0, 947, 948, 1, 0, 0, 0, 948, 71, 1, 0, 0, 0, 949, 950, 5, 36, 0, 0, 950, 951, 5, 96, 0, 0, 951, 952, 5, 182, 0, 0, 952, 958, 3, 186, 93, 0, 953, 954, 5, 145, 0, 0, 954, 955, 5, 265, 0, 0, 955, 956, 3, 308, 154, 0, 956, 957, 5, 266, 0, 0, 957, 959, 1, 0, 0, 0, 958, 953, 1, 0, 0, 0, 958, 959, 1, 0, 0, 0, 959, 73, 1, 0, 0, 0, 960, 967, 3, 86, 43, 0, 961, 967, 3, 84, 42, 0, 962, 967, 3, 82, 41, 0, 963, 967, 3, 78, 39, 0, 964, 967, 3, 80, 40, 0, 965, 967, 3, 76, 38, 0, 966, 960, 1, 0, 0, 0, 966, 961, 1, 0, 0, 0, 966, 962, 1, 0, 0, 0, 966, 963, 1, 0, 0, 0, 966, 964, 1, 0, 0, 0, 966, 965, 1, 0, 0, 0, 967, 75, 1, 0, 0, 0, 968, 969, 5, 58, 0, 0, 969, 971, 7, 0, 0, 0, 970, 972, 3, 170, 85, 0, 971, 970, 1, 0, 0, 0, 971, 972, 1, 0, 0, 0, 972, 973, 1, 0, 0, 0, 973, 975, 3, 184, 92, 0, 974, 976, 7, 4, 0, 0, 975, 974, 1, 0, 0, 0, 975, 976, 1, 0, 0, 0, 976, 77, 1, 0, 0, 0, 977, 978, 5, 58, 0, 0, 978, 980, 5, 212, 0, 0, 979, 981, 3, 170, 85, 0, 980, 979, 1, 0, 0, 0, 980, 981, 1, 0, 0, 0, 981, 982, 1, 0, 0, 0, 982, 983, 3, 188, 94, 0, 983, 79, 1, 0, 0, 0, 984, 985, 5, 58, 0, 0, 985, 987, 5, 188, 0, 0, 986, 988, 3, 170, 85, 0, 987, 986, 1, 0, 0, 0, 987, 988, 1, 0, 0, 0, 988, 989, 1, 0, 0, 0, 989, 991, 3, 186, 93, 0, 990, 992, 5, 22, 0, 0, 991, 990, 1, 0, 0, 0, 991, 992, 1, 0, 0, 0, 992, 81, 1, 0, 0, 0, 993, 995, 5, 58, 0, 0, 994, 996, 5, 96, 0, 0, 995, 994, 1, 0, 0, 0, 995, 996, 1, 0, 0, 0, 996, 997, 1, 0, 0, 0, 997, 998, 5, 182, 0, 0, 998, 1001, 3, 186, 93, 0, 999, 1000, 5, 145, 0, 0, 1000, 1002, 3, 308, 154, 0, 1001, 999, 1, 0, 0, 0, 1001, 1002, 1, 0, 0, 0, 1002, 83, 1, 0, 0, 0, 1003, 1005, 5, 58, 0, 0, 1004, 1006, 5, 12, 0, 0, 1005, 1004, 1, 0, 0, 0, 1005, 1006, 1, 0, 0, 0, 1006, 1007, 1, 0, 0, 0, 1007, 1009, 5, 84, 0, 0, 1008, 1010, 3, 170, 85, 0, 1009, 1008, 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 1011, 1, 0, 0, 0, 1011, 1024, 3, 190, 95, 0, 1012, 1021, 5, 265, 0, 0, 1013, 1018, 3, 332, 166, 0, 1014, 1015, 5, 263, 0, 0, 1015, 1017, 3, 332, 166, 0, 1016, 1014, 1, 0, 0, 0, 1017, 1020, 1, 0, 0, 0, 1018, 1016, 1, 0, 0, 0, 1018, 1019, 1, 0, 0, 0, 1019, 1022, 1, 0, 0, 0, 1020, 1018, 1, 0, 0, 0, 1021, 1013, 1, 0, 0, 0, 1021, 1022, 1, 0, 0, 0, 1022, 1023, 1, 0, 0, 0, 1023, 1025, 5, 266, 0, 0, 1024, 1012, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 85, 1, 0, 0, 0, 1026, 1027, 5, 58, 0, 0, 1027, 1028, 5, 166, 0, 0, 1028, 1029, 3, 362, 181, 0, 1029, 87, 1, 0, 0, 0, 1030, 1033, 3, 90, 45, 0, 1031, 1033, 3, 92, 46, 0, 1032, 1030, 1, 0, 0, 0, 1032, 1031, 1, 0, 0, 0, 1033, 89, 1, 0, 0, 0, 1034, 1035, 5, 86, 0, 0, 1035, 1036, 5, 166, 0, 0, 1036, 1037, 3, 362, 181, 0, 1037, 1038, 5, 193, 0, 0, 1038, 1039, 5, 87, 0, 0, 1039, 1040, 3, 362, 181, 0, 1040, 91, 1, 0, 0, 0, 1041, 1042, 5, 86, 0, 0, 1042, 1043, 3, 354, 177, 0, 1043, 1044, 5, 136, 0, 0, 1044, 1046, 3, 356, 178, 0, 1045, 1047, 3, 358, 179, 0, 1046, 1045, 1, 0, 0, 0, 1046, 1047, 1, 0, 0, 0, 1047, 1048, 1, 0, 0, 0, 1048, 1049, 5, 193, 0, 0, 1049, 1050, 3, 360, 180, 0, 1050, 93, 1, 0, 0, 0, 1051, 1054, 3, 96, 48, 0, 1052, 1054, 3, 98, 49, 0, 1053, 1051, 1, 0, 0, 0, 1053, 1052, 1, 0, 0, 0, 1054, 95, 1, 0, 0, 0, 1055, 1056, 5, 161, 0, 0, 1056, 1057, 5, 166, 0, 0, 1057, 1058, 3, 362, 181, 0, 1058, 1059, 5, 82, 0, 0, 1059, 1060, 5, 87, 0, 0, 1060, 1061, 3, 362, 181, 0, 1061, 97, 1, 0, 0, 0, 1062, 1066, 5, 161, 0, 0, 1063, 1064, 5, 86, 0, 0, 1064, 1065, 5, 137, 0, 0, 1065, 1067, 5, 78, 0, 0, 1066, 1063, 1, 0, 0, 0, 1066, 1067, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1069, 3, 354, 177, 0, 1069, 1070, 5, 136, 0, 0, 1070, 1072, 3, 356, 178, 0, 1071, 1073, 3, 358, 179, 0, 1072, 1071, 1, 0, 0, 0, 1072, 1073, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1080, 5, 82, 0, 0, 1075, 1081, 3, 360, 180, 0, 1076, 1078, 5, 166, 0, 0, 1077, 1076, 1, 0, 0, 0, 1077, 1078, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 1081, 3, 362, 181, 0, 1080, 1075, 1, 0, 0, 0, 1080, 1077, 1, 0, 0, 0, 1081, 99, 1, 0, 0, 0, 1082, 1084, 3, 208, 104, 0, 1083, 1082, 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 1085, 1, 0, 0, 0, 1085, 1086, 5, 99, 0, 0, 1086, 1088, 7, 5, 0, 0, 1087, 1089, 5, 188, 0, 0, 1088, 1087, 1, 0, 0, 0, 1088, 1089, 1, 0, 0, 0, 1089, 1090, 1, 0, 0, 0, 1090, 1092, 3, 186, 93, 0, 1091, 1093, 3, 296, 148, 0, 1092, 1091, 1, 0, 0, 0, 1092, 1093, 1, 0, 0, 0, 1093, 1106, 1, 0, 0, 0, 1094, 1095, 5, 145, 0, 0, 1095, 1096, 5, 265, 0, 0, 1096, 1101, 3, 308, 154, 0, 1097, 1098, 5, 263, 0, 0, 1098, 1100, 3, 308, 154, 0, 1099, 1097, 1, 0, 0, 0, 1100, 1103, 1, 0, 0, 0, 1101, 1099, 1, 0, 0, 0, 1101, 1102, 1, 0, 0, 0, 1102, 1104, 1, 0, 0, 0, 1103, 1101, 1, 0, 0, 0, 1104, 1105, 5, 266, 0, 0, 1105, 1107, 1, 0, 0, 0, 1106, 1094, 1, 0, 0, 0, 1106, 1107, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 1109, 3, 206, 103, 0, 1109, 101, 1, 0, 0, 0, 1110, 1113, 3, 104, 52, 0, 1111, 1113, 3, 106, 53, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1111, 1, 0, 0, 0, 1113, 103, 1, 0, 0, 0, 1114, 1116, 5, 50, 0, 0, 1115, 1117, 5, 82, 0, 0, 1116, 1115, 1, 0, 0, 0, 1116, 1117, 1, 0, 0, 0, 1117, 1118, 1, 0, 0, 0, 1118, 1121, 3, 186, 93, 0, 1119, 1120, 5, 215, 0, 0, 1120, 1122, 3, 310, 155, 0, 1121, 1119, 1, 0, 0, 0, 1121, 1122, 1, 0, 0, 0, 1122, 105, 1, 0, 0, 0, 1123, 1124, 5, 50, 0, 0, 1124, 1129, 3, 186, 93, 0, 1125, 1127, 5, 9, 0, 0, 1126, 1125, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1128, 1, 0, 0, 0, 1128, 1130, 3, 362, 181, 0, 1129, 1126, 1, 0, 0, 0, 1129, 1130, 1, 0, 0, 0, 1130, 1131, 1, 0, 0, 0, 1131, 1140, 5, 82, 0, 0, 1132, 1137, 3, 284, 142, 0, 1133, 1134, 5, 263, 0, 0, 1134, 1136, 3, 284, 142, 0, 1135, 1133, 1, 0, 0, 0, 1136, 1139, 1, 0, 0, 0, 1137, 1135, 1, 0, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, 1141, 1, 0, 0, 0, 1139, 1137, 1, 0, 0, 0, 1140, 1132, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 1144, 1, 0, 0, 0, 1142, 1143, 5, 215, 0, 0, 1143, 1145, 3, 310, 155, 0, 1144, 1142, 1, 0, 0, 0, 1144, 1145, 1, 0, 0, 0, 1145, 107, 1, 0, 0, 0, 1146, 1147, 5, 54, 0, 0, 1147, 1148, 3, 186, 93, 0, 1148, 1149, 5, 176, 0, 0, 1149, 1159, 3, 198, 99, 0, 1150, 1151, 5, 82, 0, 0, 1151, 1156, 3, 284, 142, 0, 1152, 1153, 5, 263, 0, 0, 1153, 1155, 3, 284, 142, 0, 1154, 1152, 1, 0, 0, 0, 1155, 1158, 1, 0, 0, 0, 1156, 1154, 1, 0, 0, 0, 1156, 1157, 1, 0, 0, 0, 1157, 1160, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1159, 1150, 1, 0, 0, 0, 1159, 1160, 1, 0, 0, 0, 1160, 1163, 1, 0, 0, 0, 1161, 1162, 5, 215, 0, 0, 1162, 1164, 3, 310, 155, 0, 1163, 1161, 1, 0, 0, 0, 1163, 1164, 1, 0, 0, 0, 1164, 109, 1, 0, 0, 0, 1165, 1166, 5, 207, 0, 0, 1166, 1168, 5, 103, 0, 0, 1167, 1169, 5, 188, 0, 0, 1168, 1167, 1, 0, 0, 0, 1168, 1169, 1, 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1172, 3, 186, 93, 0, 1171, 1173, 3, 296, 148, 0, 1172, 1171, 1, 0, 0, 0, 1172, 1173, 1, 0, 0, 0, 1173, 1174, 1, 0, 0, 0, 1174, 1175, 3, 206, 103, 0, 1175, 111, 1, 0, 0, 0, 1176, 1189, 3, 132, 66, 0, 1177, 1189, 3, 134, 67, 0, 1178, 1189, 3, 136, 68, 0, 1179, 1189, 3, 130, 65, 0, 1180, 1189, 3, 128, 64, 0, 1181, 1189, 3, 126, 63, 0, 1182, 1189, 3, 124, 62, 0, 1183, 1189, 3, 122, 61, 0, 1184, 1189, 3, 120, 60, 0, 1185, 1189, 3, 118, 59, 0, 1186, 1189, 3, 116, 58, 0, 1187, 1189, 3, 114, 57, 0, 1188, 1176, 1, 0, 0, 0, 1188, 1177, 1, 0, 0, 0, 1188, 1178, 1, 0, 0, 0, 1188, 1179, 1, 0, 0, 0, 1188, 1180, 1, 0, 0, 0, 1188, 1181, 1, 0, 0, 0, 1188, 1182, 1, 0, 0, 0, 1188, 1183, 1, 0, 0, 0, 1188, 1184, 1, 0, 0, 0, 1188, 1185, 1, 0, 0, 0, 1188, 1186, 1, 0, 0, 0, 1188, 1187, 1, 0, 0, 0, 1189, 113, 1, 0, 0, 0, 1190, 1191, 5, 179, 0, 0, 1191, 1203, 7, 6, 0, 0, 1192, 1194, 5, 115, 0, 0, 1193, 1192, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1195, 1, 0, 0, 0, 1195, 1200, 3, 318, 159, 0, 1196, 1197, 5, 271, 0, 0, 1197, 1199, 3, 318, 159, 0, 1198, 1196, 1, 0, 0, 0, 1199, 1202, 1, 0, 0, 0, 1200, 1198, 1, 0, 0, 0, 1200, 1201, 1, 0, 0, 0, 1201, 1204, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1203, 1193, 1, 0, 0, 0, 1203, 1204, 1, 0, 0, 0, 1204, 115, 1, 0, 0, 0, 1205, 1206, 5, 179, 0, 0, 1206, 1209, 5, 189, 0, 0, 1207, 1208, 5, 94, 0, 0, 1208, 1210, 3, 186, 93, 0, 1209, 1207, 1, 0, 0, 0, 1209, 1210, 1, 0, 0, 0, 1210, 1222, 1, 0, 0, 0, 1211, 1213, 5, 115, 0, 0, 1212, 1211, 1, 0, 0, 0, 1212, 1213, 1, 0, 0, 0, 1213, 1214, 1, 0, 0, 0, 1214, 1219, 3, 318, 159, 0, 1215, 1216, 5, 271, 0, 0, 1216, 1218, 3, 318, 159, 0, 1217, 1215, 1, 0, 0, 0, 1218, 1221, 1, 0, 0, 0, 1219, 1217, 1, 0, 0, 0, 1219, 1220, 1, 0, 0, 0, 1220, 1223, 1, 0, 0, 0, 1221, 1219, 1, 0, 0, 0, 1222, 1212, 1, 0, 0, 0, 1222, 1223, 1, 0, 0, 0, 1223, 117, 1, 0, 0, 0, 1224, 1226, 5, 179, 0, 0, 1225, 1227, 7, 7, 0, 0, 1226, 1225, 1, 0, 0, 0, 1226, 1227, 1, 0, 0, 0, 1227, 1228, 1, 0, 0, 0, 1228, 1231, 5, 85, 0, 0, 1229, 1230, 5, 94, 0, 0, 1230, 1232, 3, 184, 92, 0, 1231, 1229, 1, 0, 0, 0, 1231, 1232, 1, 0, 0, 0, 1232, 1244, 1, 0, 0, 0, 1233, 1235, 5, 115, 0, 0, 1234, 1233, 1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1236, 1, 0, 0, 0, 1236, 1241, 3, 318, 159, 0, 1237, 1238, 5, 271, 0, 0, 1238, 1240, 3, 318, 159, 0, 1239, 1237, 1, 0, 0, 0, 1240, 1243, 1, 0, 0, 0, 1241, 1239, 1, 0, 0, 0, 1241, 1242, 1, 0, 0, 0, 1242, 1245, 1, 0, 0, 0, 1243, 1241, 1, 0, 0, 0, 1244, 1234, 1, 0, 0, 0, 1244, 1245, 1, 0, 0, 0, 1245, 119, 1, 0, 0, 0, 1246, 1247, 5, 179, 0, 0, 1247, 1248, 5, 37, 0, 0, 1248, 1249, 5, 188, 0, 0, 1249, 1250, 3, 186, 93, 0, 1250, 121, 1, 0, 0, 0, 1251, 1252, 5, 179, 0, 0, 1252, 1253, 5, 37, 0, 0, 1253, 1254, 5, 212, 0, 0, 1254, 1255, 3, 188, 94, 0, 1255, 123, 1, 0, 0, 0, 1256, 1257, 5, 179, 0, 0, 1257, 1258, 5, 188, 0, 0, 1258, 1259, 5, 182, 0, 0, 1259, 1260, 3, 186, 93, 0, 1260, 125, 1, 0, 0, 0, 1261, 1262, 5, 179, 0, 0, 1262, 1263, 5, 32, 0, 0, 1263, 1264, 5, 182, 0, 0, 1264, 1265, 3, 186, 93, 0, 1265, 127, 1, 0, 0, 0, 1266, 1268, 5, 179, 0, 0, 1267, 1269, 5, 154, 0, 0, 1268, 1267, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, 1270, 1, 0, 0, 0, 1270, 1271, 5, 146, 0, 0, 1271, 1272, 3, 186, 93, 0, 1272, 129, 1, 0, 0, 0, 1273, 1274, 5, 179, 0, 0, 1274, 1275, 5, 73, 0, 0, 1275, 1276, 5, 94, 0, 0, 1276, 1286, 3, 186, 93, 0, 1277, 1278, 5, 145, 0, 0, 1278, 1279, 5, 265, 0, 0, 1279, 1282, 3, 308, 154, 0, 1280, 1281, 5, 263, 0, 0, 1281, 1283, 3, 308, 154, 0, 1282, 1280, 1, 0, 0, 0, 1282, 1283, 1, 0, 0, 0, 1283, 1284, 1, 0, 0, 0, 1284, 1285, 5, 266, 0, 0, 1285, 1287, 1, 0, 0, 0, 1286, 1277, 1, 0, 0, 0, 1286, 1287, 1, 0, 0, 0, 1287, 131, 1, 0, 0, 0, 1288, 1290, 5, 179, 0, 0, 1289, 1291, 5, 39, 0, 0, 1290, 1289, 1, 0, 0, 0, 1290, 1291, 1, 0, 0, 0, 1291, 1292, 1, 0, 0, 0, 1292, 1293, 5, 167, 0, 0, 1293, 133, 1, 0, 0, 0, 1294, 1295, 5, 179, 0, 0, 1295, 1296, 5, 166, 0, 0, 1296, 1297, 5, 86, 0, 0, 1297, 1298, 5, 87, 0, 0, 1298, 1299, 3, 362, 181, 0, 1299, 135, 1, 0, 0, 0, 1300, 1315, 3, 138, 69, 0, 1301, 1315, 3, 140, 70, 0, 1302, 1315, 3, 142, 71, 0, 1303, 1304, 5, 179, 0, 0, 1304, 1305, 5, 86, 0, 0, 1305, 1306, 7, 8, 0, 0, 1306, 1312, 3, 362, 181, 0, 1307, 1308, 5, 136, 0, 0, 1308, 1310, 7, 9, 0, 0, 1309, 1311, 3, 358, 179, 0, 1310, 1309, 1, 0, 0, 0, 1310, 1311, 1, 0, 0, 0, 1311, 1313, 1, 0, 0, 0, 1312, 1307, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1315, 1, 0, 0, 0, 1314, 1300, 1, 0, 0, 0, 1314, 1301, 1, 0, 0, 0, 1314, 1302, 1, 0, 0, 0, 1314, 1303, 1, 0, 0, 0, 1315, 137, 1, 0, 0, 0, 1316, 1317, 5, 179, 0, 0, 1317, 1318, 5, 86, 0, 0, 1318, 1319, 7, 8, 0, 0, 1319, 1325, 3, 362, 181, 0, 1320, 1321, 5, 136, 0, 0, 1321, 1323, 5, 46, 0, 0, 1322, 1324, 3, 184, 92, 0, 1323, 1322, 1, 0, 0, 0, 1323, 1324, 1, 0, 0, 0, 1324, 1326, 1, 0, 0, 0, 1325, 1320, 1, 0, 0, 0, 1325, 1326, 1, 0, 0, 0, 1326, 139, 1, 0, 0, 0, 1327, 1328, 5, 179, 0, 0, 1328, 1329, 5, 86, 0, 0, 1329, 1330, 7, 8, 0, 0, 1330, 1336, 3, 362, 181, 0, 1331, 1332, 5, 136, 0, 0, 1332, 1334, 5, 188, 0, 0, 1333, 1335, 3, 186, 93, 0, 1334, 1333, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 1337, 1, 0, 0, 0, 1336, 1331, 1, 0, 0, 0, 1336, 1337, 1, 0, 0, 0, 1337, 141, 1, 0, 0, 0, 1338, 1339, 5, 179, 0, 0, 1339, 1340, 5, 86, 0, 0, 1340, 1341, 7, 8, 0, 0, 1341, 1347, 3, 362, 181, 0, 1342, 1343, 5, 136, 0, 0, 1343, 1345, 5, 32, 0, 0, 1344, 1346, 3, 192, 96, 0, 1345, 1344, 1, 0, 0, 0, 1345, 1346, 1, 0, 0, 0, 1346, 1348, 1, 0, 0, 0, 1347, 1342, 1, 0, 0, 0, 1347, 1348, 1, 0, 0, 0, 1348, 143, 1, 0, 0, 0, 1349, 1353, 3, 146, 73, 0, 1350, 1353, 3, 148, 74, 0, 1351, 1353, 3, 150, 75, 0, 1352, 1349, 1, 0, 0, 0, 1352, 1350, 1, 0, 0, 0, 1352, 1351, 1, 0, 0, 0, 1353, 145, 1, 0, 0, 0, 1354, 1355, 5, 34, 0, 0, 1355, 1356, 5, 136, 0, 0, 1356, 1357, 5, 46, 0, 0, 1357, 1358, 3, 184, 92, 0, 1358, 1361, 5, 108, 0, 0, 1359, 1362, 3, 318, 159, 0, 1360, 1362, 5, 133, 0, 0, 1361, 1359, 1, 0, 0, 0, 1361, 1360, 1, 0, 0, 0, 1362, 147, 1, 0, 0, 0, 1363, 1364, 5, 34, 0, 0, 1364, 1365, 5, 136, 0, 0, 1365, 1366, 5, 188, 0, 0, 1366, 1367, 3, 186, 93, 0, 1367, 1370, 5, 108, 0, 0, 1368, 1371, 3, 318, 159, 0, 1369, 1371, 5, 133, 0, 0, 1370, 1368, 1, 0, 0, 0, 1370, 1369, 1, 0, 0, 0, 1371, 149, 1, 0, 0, 0, 1372, 1373, 5, 34, 0, 0, 1373, 1374, 5, 136, 0, 0, 1374, 1375, 5, 32, 0, 0, 1375, 1376, 3, 192, 96, 0, 1376, 1379, 5, 108, 0, 0, 1377, 1380, 3, 318, 159, 0, 1378, 1380, 5, 133, 0, 0, 1379, 1377, 1, 0, 0, 0, 1379, 1378, 1, 0, 0, 0, 1380, 151, 1, 0, 0, 0, 1381, 1382, 5, 67, 0, 0, 1382, 1383, 3, 4, 2, 0, 1383, 153, 1, 0, 0, 0, 1384, 1390, 5, 176, 0, 0, 1385, 1391, 5, 2, 0, 0, 1386, 1387, 3, 362, 181, 0, 1387, 1388, 5, 249, 0, 0, 1388, 1389, 3, 308, 154, 0, 1389, 1391, 1, 0, 0, 0, 1390, 1385, 1, 0, 0, 0, 1390, 1386, 1, 0, 0, 0, 1390, 1391, 1, 0, 0, 0, 1391, 155, 1, 0, 0, 0, 1392, 1393, 5, 264, 0, 0, 1393, 1394, 5, 180, 0, 0, 1394, 1404, 5, 265, 0, 0, 1395, 1397, 3, 318, 159, 0, 1396, 1395, 1, 0, 0, 0, 1396, 1397, 1, 0, 0, 0, 1397, 1405, 1, 0, 0, 0, 1398, 1401, 3, 318, 159, 0, 1399, 1400, 5, 263, 0, 0, 1400, 1402, 3, 308, 154, 0, 1401, 1399, 1, 0, 0, 0, 1401, 1402, 1, 0, 0, 0, 1402, 1405, 1, 0, 0, 0, 1403, 1405, 3, 308, 154, 0, 1404, 1396, 1, 0, 0, 0, 1404, 1398, 1, 0, 0, 0, 1404, 1403, 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 1407, 5, 266, 0, 0, 1407, 157, 1, 0, 0, 0, 1408, 1409, 5, 107, 0, 0, 1409, 1410, 5, 121, 0, 0, 1410, 1411, 3, 186, 93, 0, 1411, 159, 1, 0, 0, 0, 1412, 1413, 5, 118, 0, 0, 1413, 1414, 5, 45, 0, 0, 1414, 1415, 5, 98, 0, 0, 1415, 1417, 5, 274, 0, 0, 1416, 1418, 5, 144, 0, 0, 1417, 1416, 1, 0, 0, 0, 1417, 1418, 1, 0, 0, 0, 1418, 1419, 1, 0, 0, 0, 1419, 1420, 5, 103, 0, 0, 1420, 1421, 5, 188, 0, 0, 1421, 1431, 3, 186, 93, 0, 1422, 1423, 5, 145, 0, 0, 1423, 1424, 5, 265, 0, 0, 1424, 1427, 3, 308, 154, 0, 1425, 1426, 5, 263, 0, 0, 1426, 1428, 3, 308, 154, 0, 1427, 1425, 1, 0, 0, 0, 1427, 1428, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 1430, 5, 266, 0, 0, 1430, 1432, 1, 0, 0, 0, 1431, 1422, 1, 0, 0, 0, 1431, 1432, 1, 0, 0, 0, 1432, 161, 1, 0, 0, 0, 1433, 1437, 3, 164, 82, 0, 1434, 1437, 3, 166, 83, 0, 1435, 1437, 3, 168, 84, 0, 1436, 1433, 1, 0, 0, 0, 1436, 1434, 1, 0, 0, 0, 1436, 1435, 1, 0, 0, 0, 1437, 163, 1, 0, 0, 0, 1438, 1439, 5, 162, 0, 0, 1439, 1452, 3, 186, 93, 0, 1440, 1441, 5, 145, 0, 0, 1441, 1442, 5, 265, 0, 0, 1442, 1447, 3, 308, 154, 0, 1443, 1444, 5, 263, 0, 0, 1444, 1446, 3, 308, 154, 0, 1445, 1443, 1, 0, 0, 0, 1446, 1449, 1, 0, 0, 0, 1447, 1448, 1, 0, 0, 0, 1447, 1445, 1, 0, 0, 0, 1448, 1450, 1, 0, 0, 0, 1449, 1447, 1, 0, 0, 0, 1450, 1451, 5, 266, 0, 0, 1451, 1453, 1, 0, 0, 0, 1452, 1440, 1, 0, 0, 0, 1452, 1453, 1, 0, 0, 0, 1453, 165, 1, 0, 0, 0, 1454, 1455, 5, 162, 0, 0, 1455, 1456, 5, 13, 0, 0, 1456, 167, 1, 0, 0, 0, 1457, 1458, 5, 162, 0, 0, 1458, 1459, 5, 85, 0, 0, 1459, 1460, 3, 190, 95, 0, 1460, 169, 1, 0, 0, 0, 1461, 1462, 5, 93, 0, 0, 1462, 1463, 5, 66, 0, 0, 1463, 171, 1, 0, 0, 0, 1464, 1465, 5, 93, 0, 0, 1465, 1466, 5, 132, 0, 0, 1466, 1467, 5, 66, 0, 0, 1467, 173, 1, 0, 0, 0, 1468, 1469, 3, 358, 179, 0, 1469, 175, 1, 0, 0, 0, 1470, 1471, 3, 358, 179, 0, 1471, 177, 1, 0, 0, 0, 1472, 1473, 3, 358, 179, 0, 1473, 179, 1, 0, 0, 0, 1474, 1475, 3, 358, 179, 0, 1475, 181, 1, 0, 0, 0, 1476, 1477, 3, 358, 179, 0, 1477, 183, 1, 0, 0, 0, 1478, 1479, 3, 358, 179, 0, 1479, 185, 1, 0, 0, 0, 1480, 1485, 3, 362, 181, 0, 1481, 1482, 5, 261, 0, 0, 1482, 1484, 3, 362, 181, 0, 1483, 1481, 1, 0, 0, 0, 1484, 1487, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1485, 1486, 1, 0, 0, 0, 1486, 187, 1, 0, 0, 0, 1487, 1485, 1, 0, 0, 0, 1488, 1493, 3, 362, 181, 0, 1489, 1490, 5, 261, 0, 0, 1490, 1492, 3, 362, 181, 0, 1491, 1489, 1, 0, 0, 0, 1492, 1495, 1, 0, 0, 0, 1493, 1491, 1, 0, 0, 0, 1493, 1494, 1, 0, 0, 0, 1494, 189, 1, 0, 0, 0, 1495, 1493, 1, 0, 0, 0, 1496, 1499, 3, 366, 183, 0, 1497, 1499, 3, 358, 179, 0, 1498, 1496, 1, 0, 0, 0, 1498, 1497, 1, 0, 0, 0, 1499, 191, 1, 0, 0, 0, 1500, 1503, 3, 358, 179, 0, 1501, 1503, 4, 96, 0, 0, 1502, 1500, 1, 0, 0, 0, 1502, 1501, 1, 0, 0, 0, 1503, 193, 1, 0, 0, 0, 1504, 1507, 3, 186, 93, 0, 1505, 1507, 3, 188, 94, 0, 1506, 1504, 1, 0, 0, 0, 1506, 1505, 1, 0, 0, 0, 1507, 195, 1, 0, 0, 0, 1508, 1509, 5, 21, 0, 0, 1509, 1510, 5, 26, 0, 0, 1510, 1512, 3, 296, 148, 0, 1511, 1508, 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 1514, 1, 0, 0, 0, 1513, 1515, 3, 222, 111, 0, 1514, 1513, 1, 0, 0, 0, 1514, 1515, 1, 0, 0, 0, 1515, 1519, 1, 0, 0, 0, 1516, 1517, 5, 168, 0, 0, 1517, 1518, 5, 79, 0, 0, 1518, 1520, 3, 258, 129, 0, 1519, 1516, 1, 0, 0, 0, 1519, 1520, 1, 0, 0, 0, 1520, 1524, 1, 0, 0, 0, 1521, 1522, 5, 216, 0, 0, 1522, 1523, 5, 175, 0, 0, 1523, 1525, 3, 252, 126, 0, 1524, 1521, 1, 0, 0, 0, 1524, 1525, 1, 0, 0, 0, 1525, 1529, 1, 0, 0, 0, 1526, 1527, 5, 23, 0, 0, 1527, 1528, 5, 9, 0, 0, 1528, 1530, 3, 234, 117, 0, 1529, 1526, 1, 0, 0, 0, 1529, 1530, 1, 0, 0, 0, 1530, 1533, 1, 0, 0, 0, 1531, 1532, 5, 24, 0, 0, 1532, 1534, 3, 318, 159, 0, 1533, 1531, 1, 0, 0, 0, 1533, 1534, 1, 0, 0, 0, 1534, 1545, 1, 0, 0, 0, 1535, 1536, 5, 30, 0, 0, 1536, 1537, 5, 94, 0, 0, 1537, 1542, 3, 358, 179, 0, 1538, 1539, 5, 216, 0, 0, 1539, 1540, 5, 151, 0, 0, 1540, 1541, 5, 249, 0, 0, 1541, 1543, 5, 277, 0, 0, 1542, 1538, 1, 0, 0, 0, 1542, 1543, 1, 0, 0, 0, 1543, 1546, 1, 0, 0, 0, 1544, 1546, 5, 197, 0, 0, 1545, 1535, 1, 0, 0, 0, 1545, 1544, 1, 0, 0, 0, 1545, 1546, 1, 0, 0, 0, 1546, 1549, 1, 0, 0, 0, 1547, 1548, 5, 25, 0, 0, 1548, 1550, 3, 252, 126, 0, 1549, 1547, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 197, 1, 0, 0, 0, 1551, 1556, 3, 200, 100, 0, 1552, 1553, 5, 263, 0, 0, 1553, 1555, 3, 200, 100, 0, 1554, 1552, 1, 0, 0, 0, 1555, 1558, 1, 0, 0, 0, 1556, 1554, 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0, 1557, 199, 1, 0, 0, 0, 1558, 1556, 1, 0, 0, 0, 1559, 1560, 3, 358, 179, 0, 1560, 1561, 5, 249, 0, 0, 1561, 1562, 3, 308, 154, 0, 1562, 201, 1, 0, 0, 0, 1563, 1565, 5, 265, 0, 0, 1564, 1566, 3, 204, 102, 0, 1565, 1564, 1, 0, 0, 0, 1565, 1566, 1, 0, 0, 0, 1566, 1573, 1, 0, 0, 0, 1567, 1569, 5, 263, 0, 0, 1568, 1570, 3, 204, 102, 0, 1569, 1568, 1, 0, 0, 0, 1569, 1570, 1, 0, 0, 0, 1570, 1572, 1, 0, 0, 0, 1571, 1567, 1, 0, 0, 0, 1572, 1575, 1, 0, 0, 0, 1573, 1571, 1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, 1576, 1, 0, 0, 0, 1575, 1573, 1, 0, 0, 0, 1576, 1577, 5, 266, 0, 0, 1577, 203, 1, 0, 0, 0, 1578, 1580, 3, 182, 91, 0, 1579, 1581, 3, 222, 111, 0, 1580, 1579, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, 205, 1, 0, 0, 0, 1582, 1584, 3, 208, 104, 0, 1583, 1582, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1586, 3, 262, 131, 0, 1586, 207, 1, 0, 0, 0, 1587, 1588, 5, 216, 0, 0, 1588, 1593, 3, 278, 139, 0, 1589, 1590, 5, 263, 0, 0, 1590, 1592, 3, 278, 139, 0, 1591, 1589, 1, 0, 0, 0, 1592, 1595, 1, 0, 0, 0, 1593, 1591, 1, 0, 0, 0, 1593, 1594, 1, 0, 0, 0, 1594, 209, 1, 0, 0, 0, 1595, 1593, 1, 0, 0, 0, 1596, 1597, 5, 150, 0, 0, 1597, 1598, 5, 110, 0, 0, 1598, 1600, 3, 296, 148, 0, 1599, 1601, 5, 53, 0, 0, 1600, 1599, 1, 0, 0, 0, 1600, 1601, 1, 0, 0, 0, 1601, 1605, 1, 0, 0, 0, 1602, 1606, 5, 225, 0, 0, 1603, 1604, 5, 263, 0, 0, 1604, 1606, 5, 225, 0, 0, 1605, 1602, 1, 0, 0, 0, 1605, 1603, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, 1606, 1610, 1, 0, 0, 0, 1607, 1611, 5, 226, 0, 0, 1608, 1609, 5, 263, 0, 0, 1609, 1611, 5, 226, 0, 0, 1610, 1607, 1, 0, 0, 0, 1610, 1608, 1, 0, 0, 0, 1610, 1611, 1, 0, 0, 0, 1611, 1624, 1, 0, 0, 0, 1612, 1613, 5, 263, 0, 0, 1613, 1616, 3, 212, 106, 0, 1614, 1616, 3, 212, 106, 0, 1615, 1612, 1, 0, 0, 0, 1615, 1614, 1, 0, 0, 0, 1616, 1621, 1, 0, 0, 0, 1617, 1618, 5, 263, 0, 0, 1618, 1620, 3, 212, 106, 0, 1619, 1617, 1, 0, 0, 0, 1620, 1623, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1621, 1619, 1, 0, 0, 0, 1622, 1625, 1, 0, 0, 0, 1623, 1621, 1, 0, 0, 0, 1624, 1615, 1, 0, 0, 0, 1624, 1625, 1, 0, 0, 0, 1625, 211, 1, 0, 0, 0, 1626, 1627, 5, 81, 0, 0, 1627, 1628, 5, 110, 0, 0, 1628, 1629, 3, 296, 148, 0, 1629, 1630, 5, 224, 0, 0, 1630, 1631, 3, 186, 93, 0, 1631, 1633, 3, 296, 148, 0, 1632, 1634, 5, 53, 0, 0, 1633, 1632, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 1636, 1, 0, 0, 0, 1635, 1637, 5, 225, 0, 0, 1636, 1635, 1, 0, 0, 0, 1636, 1637, 1, 0, 0, 0, 1637, 1639, 1, 0, 0, 0, 1638, 1640, 5, 226, 0, 0, 1639, 1638, 1, 0, 0, 0, 1639, 1640, 1, 0, 0, 0, 1640, 213, 1, 0, 0, 0, 1641, 1642, 3, 192, 96, 0, 1642, 1645, 3, 332, 166, 0, 1643, 1644, 5, 34, 0, 0, 1644, 1646, 3, 318, 159, 0, 1645, 1643, 1, 0, 0, 0, 1645, 1646, 1, 0, 0, 0, 1646, 215, 1, 0, 0, 0, 1647, 1648, 3, 182, 91, 0, 1648, 1650, 3, 332, 166, 0, 1649, 1651, 3, 222, 111, 0, 1650, 1649, 1, 0, 0, 0, 1650, 1651, 1, 0, 0, 0, 1651, 217, 1, 0, 0, 0, 1652, 1653, 3, 220, 110, 0, 1653, 219, 1, 0, 0, 0, 1654, 1655, 3, 182, 91, 0, 1655, 1663, 3, 332, 166, 0, 1656, 1660, 3, 228, 114, 0, 1657, 1659, 3, 228, 114, 0, 1658, 1657, 1, 0, 0, 0, 1659, 1662, 1, 0, 0, 0, 1660, 1661, 1, 0, 0, 0, 1660, 1658, 1, 0, 0, 0, 1661, 1664, 1, 0, 0, 0, 1662, 1660, 1, 0, 0, 0, 1663, 1656, 1, 0, 0, 0, 1663, 1664, 1, 0, 0, 0, 1664, 1666, 1, 0, 0, 0, 1665, 1667, 3, 222, 111, 0, 1666, 1665, 1, 0, 0, 0, 1666, 1667, 1, 0, 0, 0, 1667, 1670, 1, 0, 0, 0, 1668, 1669, 5, 150, 0, 0, 1669, 1671, 5, 110, 0, 0, 1670, 1668, 1, 0, 0, 0, 1670, 1671, 1, 0, 0, 0, 1671, 221, 1, 0, 0, 0, 1672, 1673, 5, 34, 0, 0, 1673, 1674, 3, 318, 159, 0, 1674, 223, 1, 0, 0, 0, 1675, 1683, 3, 214, 107, 0, 1676, 1680, 3, 228, 114, 0, 1677, 1679, 3, 228, 114, 0, 1678, 1677, 1, 0, 0, 0, 1679, 1682, 1, 0, 0, 0, 1680, 1681, 1, 0, 0, 0, 1680, 1678, 1, 0, 0, 0, 1681, 1684, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1683, 1676, 1, 0, 0, 0, 1683, 1684, 1, 0, 0, 0, 1684, 225, 1, 0, 0, 0, 1685, 1686, 3, 182, 91, 0, 1686, 1689, 3, 332, 166, 0, 1687, 1688, 5, 34, 0, 0, 1688, 1690, 3, 318, 159, 0, 1689, 1687, 1, 0, 0, 0, 1689, 1690, 1, 0, 0, 0, 1690, 1698, 1, 0, 0, 0, 1691, 1695, 3, 228, 114, 0, 1692, 1694, 3, 228, 114, 0, 1693, 1692, 1, 0, 0, 0, 1694, 1697, 1, 0, 0, 0, 1695, 1696, 1, 0, 0, 0, 1695, 1693, 1, 0, 0, 0, 1696, 1699, 1, 0, 0, 0, 1697, 1695, 1, 0, 0, 0, 1698, 1691, 1, 0, 0, 0, 1698, 1699, 1, 0, 0, 0, 1699, 227, 1, 0, 0, 0, 1700, 1702, 5, 132, 0, 0, 1701, 1700, 1, 0, 0, 0, 1701, 1702, 1, 0, 0, 0, 1702, 1703, 1, 0, 0, 0, 1703, 1706, 5, 133, 0, 0, 1704, 1706, 3, 230, 115, 0, 1705, 1701, 1, 0, 0, 0, 1705, 1704, 1, 0, 0, 0, 1706, 229, 1, 0, 0, 0, 1707, 1708, 5, 60, 0, 0, 1708, 1716, 3, 308, 154, 0, 1709, 1710, 5, 35, 0, 0, 1710, 1716, 3, 308, 154, 0, 1711, 1712, 5, 51, 0, 0, 1712, 1716, 3, 308, 154, 0, 1713, 1714, 5, 16, 0, 0, 1714, 1716, 3, 364, 182, 0, 1715, 1707, 1, 0, 0, 0, 1715, 1709, 1, 0, 0, 0, 1715, 1711, 1, 0, 0, 0, 1715, 1713, 1, 0, 0, 0, 1716, 231, 1, 0, 0, 0, 1717, 1718, 7, 10, 0, 0, 1718, 233, 1, 0, 0, 0, 1719, 1720, 7, 11, 0, 0, 1720, 235, 1, 0, 0, 0, 1721, 1726, 3, 238, 119, 0, 1722, 1723, 5, 263, 0, 0, 1723, 1725, 3, 238, 119, 0, 1724, 1722, 1, 0, 0, 0, 1725, 1728, 1, 0, 0, 0, 1726, 1727, 1, 0, 0, 0, 1726, 1724, 1, 0, 0, 0, 1727, 1731, 1, 0, 0, 0, 1728, 1726, 1, 0, 0, 0, 1729, 1730, 5, 263, 0, 0, 1730, 1732, 3, 240, 120, 0, 1731, 1729, 1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732, 1735, 1, 0, 0, 0, 1733, 1735, 3, 240, 120, 0, 1734, 1721, 1, 0, 0, 0, 1734, 1733, 1, 0, 0, 0, 1735, 237, 1, 0, 0, 0, 1736, 1738, 5, 89, 0, 0, 1737, 1739, 3, 296, 148, 0, 1738, 1737, 1, 0, 0, 0, 1738, 1739, 1, 0, 0, 0, 1739, 1740, 1, 0, 0, 0, 1740, 1741, 5, 146, 0, 0, 1741, 1742, 3, 364, 182, 0, 1742, 239, 1, 0, 0, 0, 1743, 1745, 5, 154, 0, 0, 1744, 1746, 3, 296, 148, 0, 1745, 1744, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 1747, 1, 0, 0, 0, 1747, 1748, 5, 265, 0, 0, 1748, 1749, 5, 145, 0, 0, 1749, 1755, 3, 242, 121, 0, 1750, 1751, 5, 263, 0, 0, 1751, 1752, 5, 145, 0, 0, 1752, 1754, 3, 242, 121, 0, 1753, 1750, 1, 0, 0, 0, 1754, 1757, 1, 0, 0, 0, 1755, 1756, 1, 0, 0, 0, 1755, 1753, 1, 0, 0, 0, 1756, 1758, 1, 0, 0, 0, 1757, 1755, 1, 0, 0, 0, 1758, 1759, 5, 266, 0, 0, 1759, 241, 1, 0, 0, 0, 1760, 1761, 5, 210, 0, 0, 1761, 1762, 3, 248, 124, 0, 1762, 1763, 3, 308, 154, 0, 1763, 1776, 1, 0, 0, 0, 1764, 1765, 3, 308, 154, 0, 1765, 1766, 3, 246, 123, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1764, 1, 0, 0, 0, 1767, 1768, 1, 0, 0, 0, 1768, 1769, 1, 0, 0, 0, 1769, 1773, 5, 211, 0, 0, 1770, 1771, 3, 246, 123, 0, 1771, 1772, 3, 308, 154, 0, 1772, 1774, 1, 0, 0, 0, 1773, 1770, 1, 0, 0, 0, 1773, 1774, 1, 0, 0, 0, 1774, 1776, 1, 0, 0, 0, 1775, 1760, 1, 0, 0, 0, 1775, 1767, 1, 0, 0, 0, 1776, 243, 1, 0, 0, 0, 1777, 1778, 5, 30, 0, 0, 1778, 1779, 5, 94, 0, 0, 1779, 1784, 3, 362, 181, 0, 1780, 1781, 5, 216, 0, 0, 1781, 1782, 5, 151, 0, 0, 1782, 1783, 5, 249, 0, 0, 1783, 1785, 3, 364, 182, 0, 1784, 1780, 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1788, 1, 0, 0, 0, 1786, 1788, 5, 197, 0, 0, 1787, 1777, 1, 0, 0, 0, 1787, 1786, 1, 0, 0, 0, 1788, 245, 1, 0, 0, 0, 1789, 1795, 1, 0, 0, 0, 1790, 1795, 5, 251, 0, 0, 1791, 1795, 5, 252, 0, 0, 1792, 1795, 5, 253, 0, 0, 1793, 1795, 5, 254, 0, 0, 1794, 1789, 1, 0, 0, 0, 1794, 1790, 1, 0, 0, 0, 1794, 1791, 1, 0, 0, 0, 1794, 1792, 1, 0, 0, 0, 1794, 1793, 1, 0, 0, 0, 1795, 247, 1, 0, 0, 0, 1796, 1805, 5, 249, 0, 0, 1797, 1805, 5, 250, 0, 0, 1798, 1805, 5, 115, 0, 0, 1799, 1805, 5, 164, 0, 0, 1800, 1805, 5, 163, 0, 0, 1801, 1805, 5, 15, 0, 0, 1802, 1805, 5, 94, 0, 0, 1803, 1805, 3, 246, 123, 0, 1804, 1796, 1, 0, 0, 0, 1804, 1797, 1, 0, 0, 0, 1804, 1798, 1, 0, 0, 0, 1804, 1799, 1, 0, 0, 0, 1804, 1800, 1, 0, 0, 0, 1804, 1801, 1, 0, 0, 0, 1804, 1802, 1, 0, 0, 0, 1804, 1803, 1, 0, 0, 0, 1805, 249, 1, 0, 0, 0, 1806, 1807, 5, 115, 0, 0, 1807, 1810, 3, 358, 179, 0, 1808, 1809, 7, 12, 0, 0, 1809, 1811, 5, 153, 0, 0, 1810, 1808, 1, 0, 0, 0, 1810, 1811, 1, 0, 0, 0, 1811, 251, 1, 0, 0, 0, 1812, 1813, 5, 265, 0, 0, 1813, 1818, 3, 260, 130, 0, 1814, 1815, 5, 263, 0, 0, 1815, 1817, 3, 260, 130, 0, 1816, 1814, 1, 0, 0, 0, 1817, 1820, 1, 0, 0, 0, 1818, 1816, 1, 0, 0, 0, 1818, 1819, 1, 0, 0, 0, 1819, 1821, 1, 0, 0, 0, 1820, 1818, 1, 0, 0, 0, 1821, 1822, 5, 266, 0, 0, 1822, 253, 1, 0, 0, 0, 1823, 1824, 5, 265, 0, 0, 1824, 1829, 3, 214, 107, 0, 1825, 1826, 5, 263, 0, 0, 1826, 1828, 3, 214, 107, 0, 1827, 1825, 1, 0, 0, 0, 1828, 1831, 1, 0, 0, 0, 1829, 1830, 1, 0, 0, 0, 1829, 1827, 1, 0, 0, 0, 1830, 1832, 1, 0, 0, 0, 1831, 1829, 1, 0, 0, 0, 1832, 1833, 5, 266, 0, 0, 1833, 255, 1, 0, 0, 0, 1834, 1839, 3, 308, 154, 0, 1835, 1836, 5, 263, 0, 0, 1836, 1838, 3, 308, 154, 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, 257, 1, 0, 0, 0, 1841, 1839, 1, 0, 0, 0, 1842, 1852, 5, 52, 0, 0, 1843, 1844, 5, 71, 0, 0, 1844, 1845, 5, 191, 0, 0, 1845, 1846, 5, 26, 0, 0, 1846, 1850, 3, 318, 159, 0, 1847, 1848, 5, 63, 0, 0, 1848, 1849, 5, 26, 0, 0, 1849, 1851, 3, 318, 159, 0, 1850, 1847, 1, 0, 0, 0, 1850, 1851, 1, 0, 0, 0, 1851, 1853, 1, 0, 0, 0, 1852, 1843, 1, 0, 0, 0, 1852, 1853, 1, 0, 0, 0, 1853, 1858, 1, 0, 0, 0, 1854, 1855, 5, 117, 0, 0, 1855, 1856, 5, 191, 0, 0, 1856, 1857, 5, 26, 0, 0, 1857, 1859, 3, 318, 159, 0, 1858, 1854, 1, 0, 0, 0, 1858, 1859, 1, 0, 0, 0, 1859, 259, 1, 0, 0, 0, 1860, 1863, 3, 362, 181, 0, 1861, 1862, 5, 249, 0, 0, 1862, 1864, 3, 308, 154, 0, 1863, 1861, 1, 0, 0, 0, 1863, 1864, 1, 0, 0, 0, 1864, 261, 1, 0, 0, 0, 1865, 1876, 3, 264, 132, 0, 1866, 1867, 5, 139, 0, 0, 1867, 1868, 5, 26, 0, 0, 1868, 1873, 3, 268, 134, 0, 1869, 1870, 5, 263, 0, 0, 1870, 1872, 3, 268, 134, 0, 1871, 1869, 1, 0, 0, 0, 1872, 1875, 1, 0, 0, 0, 1873, 1871, 1, 0, 0, 0, 1873, 1874, 1, 0, 0, 0, 1874, 1877, 1, 0, 0, 0, 1875, 1873, 1, 0, 0, 0, 1876, 1866, 1, 0, 0, 0, 1876, 1877, 1, 0, 0, 0, 1877, 1884, 1, 0, 0, 0, 1878, 1879, 5, 116, 0, 0, 1879, 1882, 3, 308, 154, 0, 1880, 1881, 5, 135, 0, 0, 1881, 1883, 5, 277, 0, 0, 1882, 1880, 1, 0, 0, 0, 1882, 1883, 1, 0, 0, 0, 1883, 1885, 1, 0, 0, 0, 1884, 1878, 1, 0, 0, 0, 1884, 1885, 1, 0, 0, 0, 1885, 263, 1, 0, 0, 0, 1886, 1887, 6, 132, -1, 0, 1887, 1888, 3, 266, 133, 0, 1888, 1903, 1, 0, 0, 0, 1889, 1890, 10, 2, 0, 0, 1890, 1892, 5, 100, 0, 0, 1891, 1893, 3, 280, 140, 0, 1892, 1891, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1894, 1, 0, 0, 0, 1894, 1902, 3, 264, 132, 3, 1895, 1896, 10, 1, 0, 0, 1896, 1898, 7, 13, 0, 0, 1897, 1899, 3, 280, 140, 0, 1898, 1897, 1, 0, 0, 0, 1898, 1899, 1, 0, 0, 0, 1899, 1900, 1, 0, 0, 0, 1900, 1902, 3, 264, 132, 2, 1901, 1889, 1, 0, 0, 0, 1901, 1895, 1, 0, 0, 0, 1902, 1905, 1, 0, 0, 0, 1903, 1901, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904, 265, 1, 0, 0, 0, 1905, 1903, 1, 0, 0, 0, 1906, 1923, 3, 270, 135, 0, 1907, 1908, 5, 188, 0, 0, 1908, 1923, 3, 186, 93, 0, 1909, 1910, 5, 211, 0, 0, 1910, 1915, 3, 308, 154, 0, 1911, 1912, 5, 263, 0, 0, 1912, 1914, 3, 308, 154, 0, 1913, 1911, 1, 0, 0, 0, 1914, 1917, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1923, 1, 0, 0, 0, 1917, 1915, 1, 0, 0, 0, 1918, 1919, 5, 265, 0, 0, 1919, 1920, 3, 262, 131, 0, 1920, 1921, 5, 266, 0, 0, 1921, 1923, 1, 0, 0, 0, 1922, 1906, 1, 0, 0, 0, 1922, 1907, 1, 0, 0, 0, 1922, 1909, 1, 0, 0, 0, 1922, 1918, 1, 0, 0, 0, 1923, 267, 1, 0, 0, 0, 1924, 1926, 3, 306, 153, 0, 1925, 1927, 7, 14, 0, 0, 1926, 1925, 1, 0, 0, 0, 1926, 1927, 1, 0, 0, 0, 1927, 1930, 1, 0, 0, 0, 1928, 1929, 5, 134, 0, 0, 1929, 1931, 7, 15, 0, 0, 1930, 1928, 1, 0, 0, 0, 1930, 1931, 1, 0, 0, 0, 1931, 269, 1, 0, 0, 0, 1932, 1934, 5, 174, 0, 0, 1933, 1935, 3, 280, 140, 0, 1934, 1933, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1937, 1, 0, 0, 0, 1936, 1938, 5, 183, 0, 0, 1937, 1936, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1944, 3, 282, 141, 0, 1940, 1941, 5, 263, 0, 0, 1941, 1943, 3, 282, 141, 0, 1942, 1940, 1, 0, 0, 0, 1943, 1946, 1, 0, 0, 0, 1944, 1942, 1, 0, 0, 0, 1944, 1945, 1, 0, 0, 0, 1945, 1956, 1, 0, 0, 0, 1946, 1944, 1, 0, 0, 0, 1947, 1948, 5, 82, 0, 0, 1948, 1953, 3, 284, 142, 0, 1949, 1950, 5, 263, 0, 0, 1950, 1952, 3, 284, 142, 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, 1947, 1, 0, 0, 0, 1956, 1957, 1, 0, 0, 0, 1957, 1960, 1, 0, 0, 0, 1958, 1959, 5, 215, 0, 0, 1959, 1961, 3, 310, 155, 0, 1960, 1958, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1965, 1, 0, 0, 0, 1962, 1963, 5, 87, 0, 0, 1963, 1964, 5, 26, 0, 0, 1964, 1966, 3, 272, 136, 0, 1965, 1962, 1, 0, 0, 0, 1965, 1966, 1, 0, 0, 0, 1966, 1969, 1, 0, 0, 0, 1967, 1968, 5, 90, 0, 0, 1968, 1970, 3, 310, 155, 0, 1969, 1967, 1, 0, 0, 0, 1969, 1970, 1, 0, 0, 0, 1970, 271, 1, 0, 0, 0, 1971, 1973, 3, 280, 140, 0, 1972, 1971, 1, 0, 0, 0, 1972, 1973, 1, 0, 0, 0, 1973, 1974, 1, 0, 0, 0, 1974, 1979, 3, 274, 137, 0, 1975, 1976, 5, 263, 0, 0, 1976, 1978, 3, 274, 137, 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, 273, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1982, 1983, 3, 276, 138, 0, 1983, 275, 1, 0, 0, 0, 1984, 1993, 5, 265, 0, 0, 1985, 1990, 3, 306, 153, 0, 1986, 1987, 5, 263, 0, 0, 1987, 1989, 3, 306, 153, 0, 1988, 1986, 1, 0, 0, 0, 1989, 1992, 1, 0, 0, 0, 1990, 1988, 1, 0, 0, 0, 1990, 1991, 1, 0, 0, 0, 1991, 1994, 1, 0, 0, 0, 1992, 1990, 1, 0, 0, 0, 1993, 1985, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 1995, 1, 0, 0, 0, 1995, 1998, 5, 266, 0, 0, 1996, 1998, 3, 306, 153, 0, 1997, 1984, 1, 0, 0, 0, 1997, 1996, 1, 0, 0, 0, 1998, 277, 1, 0, 0, 0, 1999, 2001, 3, 362, 181, 0, 2000, 2002, 3, 296, 148, 0, 2001, 2000, 1, 0, 0, 0, 2001, 2002, 1, 0, 0, 0, 2002, 2003, 1, 0, 0, 0, 2003, 2004, 5, 9, 0, 0, 2004, 2005, 3, 300, 150, 0, 2005, 279, 1, 0, 0, 0, 2006, 2007, 7, 16, 0, 0, 2007, 281, 1, 0, 0, 0, 2008, 2013, 3, 306, 153, 0, 2009, 2011, 5, 9, 0, 0, 2010, 2009, 1, 0, 0, 0, 2010, 2011, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2014, 3, 362, 181, 0, 2013, 2010, 1, 0, 0, 0, 2013, 2014, 1, 0, 0, 0, 2014, 2021, 1, 0, 0, 0, 2015, 2016, 3, 358, 179, 0, 2016, 2017, 5, 261, 0, 0, 2017, 2018, 5, 257, 0, 0, 2018, 2021, 1, 0, 0, 0, 2019, 2021, 5, 257, 0, 0, 2020, 2008, 1, 0, 0, 0, 2020, 2015, 1, 0, 0, 0, 2020, 2019, 1, 0, 0, 0, 2021, 283, 1, 0, 0, 0, 2022, 2023, 6, 142, -1, 0, 2023, 2024, 3, 290, 145, 0, 2024, 2038, 1, 0, 0, 0, 2025, 2034, 10, 2, 0, 0, 2026, 2027, 5, 38, 0, 0, 2027, 2028, 5, 109, 0, 0, 2028, 2035, 3, 290, 145, 0, 2029, 2030, 3, 286, 143, 0, 2030, 2031, 5, 109, 0, 0, 2031, 2032, 3, 284, 142, 0, 2032, 2033, 3, 288, 144, 0, 2033, 2035, 1, 0, 0, 0, 2034, 2026, 1, 0, 0, 0, 2034, 2029, 1, 0, 0, 0, 2035, 2037, 1, 0, 0, 0, 2036, 2025, 1, 0, 0, 0, 2037, 2040, 1, 0, 0, 0, 2038, 2036, 1, 0, 0, 0, 2038, 2039, 1, 0, 0, 0, 2039, 285, 1, 0, 0, 0, 2040, 2038, 1, 0, 0, 0, 2041, 2043, 5, 97, 0, 0, 2042, 2041, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, 0, 2043, 2073, 1, 0, 0, 0, 2044, 2046, 5, 114, 0, 0, 2045, 2047, 5, 97, 0, 0, 2046, 2045, 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2073, 1, 0, 0, 0, 2048, 2050, 5, 165, 0, 0, 2049, 2051, 5, 97, 0, 0, 2050, 2049, 1, 0, 0, 0, 2050, 2051, 1, 0, 0, 0, 2051, 2073, 1, 0, 0, 0, 2052, 2054, 5, 114, 0, 0, 2053, 2055, 5, 141, 0, 0, 2054, 2053, 1, 0, 0, 0, 2054, 2055, 1, 0, 0, 0, 2055, 2073, 1, 0, 0, 0, 2056, 2058, 5, 165, 0, 0, 2057, 2059, 5, 141, 0, 0, 2058, 2057, 1, 0, 0, 0, 2058, 2059, 1, 0, 0, 0, 2059, 2073, 1, 0, 0, 0, 2060, 2062, 5, 83, 0, 0, 2061, 2063, 5, 141, 0, 0, 2062, 2061, 1, 0, 0, 0, 2062, 2063, 1, 0, 0, 0, 2063, 2073, 1, 0, 0, 0, 2064, 2065, 5, 114, 0, 0, 2065, 2073, 5, 177, 0, 0, 2066, 2067, 5, 165, 0, 0, 2067, 2073, 5, 177, 0, 0, 2068, 2069, 5, 114, 0, 0, 2069, 2073, 5, 7, 0, 0, 2070, 2071, 5, 165, 0, 0, 2071, 2073, 5, 7, 0, 0, 2072, 2042, 1, 0, 0, 0, 2072, 2044, 1, 0, 0, 0, 2072, 2048, 1, 0, 0, 0, 2072, 2052, 1, 0, 0, 0, 2072, 2056, 1, 0, 0, 0, 2072, 2060, 1, 0, 0, 0, 2072, 2064, 1, 0, 0, 0, 2072, 2066, 1, 0, 0, 0, 2072, 2068, 1, 0, 0, 0, 2072, 2070, 1, 0, 0, 0, 2073, 287, 1, 0, 0, 0, 2074, 2075, 5, 136, 0, 0, 2075, 2089, 3, 310, 155, 0, 2076, 2077, 5, 205, 0, 0, 2077, 2078, 5, 265, 0, 0, 2078, 2083, 3, 362, 181, 0, 2079, 2080, 5, 263, 0, 0, 2080, 2082, 3, 362, 181, 0, 2081, 2079, 1, 0, 0, 0, 2082, 2085, 1, 0, 0, 0, 2083, 2081, 1, 0, 0, 0, 2083, 2084, 1, 0, 0, 0, 2084, 2086, 1, 0, 0, 0, 2085, 2083, 1, 0, 0, 0, 2086, 2087, 5, 266, 0, 0, 2087, 2089, 1, 0, 0, 0, 2088, 2074, 1, 0, 0, 0, 2088, 2076, 1, 0, 0, 0, 2089, 289, 1, 0, 0, 0, 2090, 2103, 3, 294, 147, 0, 2091, 2092, 5, 190, 0, 0, 2092, 2093, 3, 292, 146, 0, 2093, 2094, 5, 265, 0, 0, 2094, 2095, 3, 308, 154, 0, 2095, 2101, 5, 266, 0, 0, 2096, 2097, 5, 157, 0, 0, 2097, 2098, 5, 265, 0, 0, 2098, 2099, 3, 308, 154, 0, 2099, 2100, 5, 266, 0, 0, 2100, 2102, 1, 0, 0, 0, 2101, 2096, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2104, 1, 0, 0, 0, 2103, 2091, 1, 0, 0, 0, 2103, 2104, 1, 0, 0, 0, 2104, 291, 1, 0, 0, 0, 2105, 2106, 7, 17, 0, 0, 2106, 293, 1, 0, 0, 0, 2107, 2115, 3, 298, 149, 0, 2108, 2110, 5, 9, 0, 0, 2109, 2108, 1, 0, 0, 0, 2109, 2110, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2113, 3, 362, 181, 0, 2112, 2114, 3, 296, 148, 0, 2113, 2112, 1, 0, 0, 0, 2113, 2114, 1, 0, 0, 0, 2114, 2116, 1, 0, 0, 0, 2115, 2109, 1, 0, 0, 0, 2115, 2116, 1, 0, 0, 0, 2116, 295, 1, 0, 0, 0, 2117, 2118, 5, 265, 0, 0, 2118, 2123, 3, 192, 96, 0, 2119, 2120, 5, 263, 0, 0, 2120, 2122, 3, 192, 96, 0, 2121, 2119, 1, 0, 0, 0, 2122, 2125, 1, 0, 0, 0, 2123, 2121, 1, 0, 0, 0, 2123, 2124, 1, 0, 0, 0, 2124, 2126, 1, 0, 0, 0, 2125, 2123, 1, 0, 0, 0, 2126, 2127, 5, 266, 0, 0, 2127, 297, 1, 0, 0, 0, 2128, 2136, 3, 194, 97, 0, 2129, 2131, 5, 113, 0, 0, 2130, 2129, 1, 0, 0, 0, 2130, 2131, 1, 0, 0, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2136, 3, 300, 150, 0, 2133, 2136, 3, 302, 151, 0, 2134, 2136, 3, 304, 152, 0, 2135, 2128, 1, 0, 0, 0, 2135, 2130, 1, 0, 0, 0, 2135, 2133, 1, 0, 0, 0, 2135, 2134, 1, 0, 0, 0, 2136, 299, 1, 0, 0, 0, 2137, 2138, 5, 265, 0, 0, 2138, 2139, 3, 206, 103, 0, 2139, 2140, 5, 266, 0, 0, 2140, 301, 1, 0, 0, 0, 2141, 2142, 5, 201, 0, 0, 2142, 2143, 5, 265, 0, 0, 2143, 2148, 3, 308, 154, 0, 2144, 2145, 5, 263, 0, 0, 2145, 2147, 3, 308, 154, 0, 2146, 2144, 1, 0, 0, 0, 2147, 2150, 1, 0, 0, 0, 2148, 2146, 1, 0, 0, 0, 2148, 2149, 1, 0, 0, 0, 2149, 2151, 1, 0, 0, 0, 2150, 2148, 1, 0, 0, 0, 2151, 2154, 5, 266, 0, 0, 2152, 2153, 5, 216, 0, 0, 2153, 2155, 5, 140, 0, 0, 2154, 2152, 1, 0, 0, 0, 2154, 2155, 1, 0, 0, 0, 2155, 303, 1, 0, 0, 0, 2156, 2157, 5, 265, 0, 0, 2157, 2158, 3, 284, 142, 0, 2158, 2159, 5, 266, 0, 0, 2159, 305, 1, 0, 0, 0, 2160, 2163, 3, 192, 96, 0, 2161, 2163, 3, 308, 154, 0, 2162, 2160, 1, 0, 0, 0, 2162, 2161, 1, 0, 0, 0, 2163, 307, 1, 0, 0, 0, 2164, 2165, 3, 310, 155, 0, 2165, 309, 1, 0, 0, 0, 2166, 2167, 6, 155, -1, 0, 2167, 2169, 3, 314, 157, 0, 2168, 2170, 3, 312, 156, 0, 2169, 2168, 1, 0, 0, 0, 2169, 2170, 1, 0, 0, 0, 2170, 2174, 1, 0, 0, 0, 2171, 2172, 5, 132, 0, 0, 2172, 2174, 3, 310, 155, 3, 2173, 2166, 1, 0, 0, 0, 2173, 2171, 1, 0, 0, 0, 2174, 2183, 1, 0, 0, 0, 2175, 2176, 10, 2, 0, 0, 2176, 2177, 5, 5, 0, 0, 2177, 2182, 3, 310, 155, 3, 2178, 2179, 10, 1, 0, 0, 2179, 2180, 5, 138, 0, 0, 2180, 2182, 3, 310, 155, 2, 2181, 2175, 1, 0, 0, 0, 2181, 2178, 1, 0, 0, 0, 2182, 2185, 1, 0, 0, 0, 2183, 2181, 1, 0, 0, 0, 2183, 2184, 1, 0, 0, 0, 2184, 311, 1, 0, 0, 0, 2185, 2183, 1, 0, 0, 0, 2186, 2187, 3, 320, 160, 0, 2187, 2188, 3, 314, 157, 0, 2188, 2245, 1, 0, 0, 0, 2189, 2190, 3, 320, 160, 0, 2190, 2191, 3, 322, 161, 0, 2191, 2192, 3, 300, 150, 0, 2192, 2245, 1, 0, 0, 0, 2193, 2195, 5, 132, 0, 0, 2194, 2193, 1, 0, 0, 0, 2194, 2195, 1, 0, 0, 0, 2195, 2196, 1, 0, 0, 0, 2196, 2197, 5, 15, 0, 0, 2197, 2198, 3, 314, 157, 0, 2198, 2199, 5, 5, 0, 0, 2199, 2200, 3, 314, 157, 0, 2200, 2245, 1, 0, 0, 0, 2201, 2203, 5, 132, 0, 0, 2202, 2201, 1, 0, 0, 0, 2202, 2203, 1, 0, 0, 0, 2203, 2204, 1, 0, 0, 0, 2204, 2205, 5, 94, 0, 0, 2205, 2206, 5, 265, 0, 0, 2206, 2211, 3, 308, 154, 0, 2207, 2208, 5, 263, 0, 0, 2208, 2210, 3, 308, 154, 0, 2209, 2207, 1, 0, 0, 0, 2210, 2213, 1, 0, 0, 0, 2211, 2209, 1, 0, 0, 0, 2211, 2212, 1, 0, 0, 0, 2212, 2214, 1, 0, 0, 0, 2213, 2211, 1, 0, 0, 0, 2214, 2215, 5, 266, 0, 0, 2215, 2245, 1, 0, 0, 0, 2216, 2218, 5, 132, 0, 0, 2217, 2216, 1, 0, 0, 0, 2217, 2218, 1, 0, 0, 0, 2218, 2219, 1, 0, 0, 0, 2219, 2220, 5, 94, 0, 0, 2220, 2245, 3, 300, 150, 0, 2221, 2223, 5, 132, 0, 0, 2222, 2221, 1, 0, 0, 0, 2222, 2223, 1, 0, 0, 0, 2223, 2224, 1, 0, 0, 0, 2224, 2225, 7, 18, 0, 0, 2225, 2228, 3, 314, 157, 0, 2226, 2227, 5, 62, 0, 0, 2227, 2229, 3, 314, 157, 0, 2228, 2226, 1, 0, 0, 0, 2228, 2229, 1, 0, 0, 0, 2229, 2245, 1, 0, 0, 0, 2230, 2231, 7, 19, 0, 0, 2231, 2245, 3, 314, 157, 0, 2232, 2234, 5, 108, 0, 0, 2233, 2235, 5, 132, 0, 0, 2234, 2233, 1, 0, 0, 0, 2234, 2235, 1, 0, 0, 0, 2235, 2236, 1, 0, 0, 0, 2236, 2245, 7, 20, 0, 0, 2237, 2239, 5, 108, 0, 0, 2238, 2240, 5, 132, 0, 0, 2239, 2238, 1, 0, 0, 0, 2239, 2240, 1, 0, 0, 0, 2240, 2241, 1, 0, 0, 0, 2241, 2242, 5, 57, 0, 0, 2242, 2243, 5, 82, 0, 0, 2243, 2245, 3, 314, 157, 0, 2244, 2186, 1, 0, 0, 0, 2244, 2189, 1, 0, 0, 0, 2244, 2194, 1, 0, 0, 0, 2244, 2202, 1, 0, 0, 0, 2244, 2217, 1, 0, 0, 0, 2244, 2222, 1, 0, 0, 0, 2244, 2230, 1, 0, 0, 0, 2244, 2232, 1, 0, 0, 0, 2244, 2237, 1, 0, 0, 0, 2245, 313, 1, 0, 0, 0, 2246, 2247, 6, 157, -1, 0, 2247, 2251, 3, 316, 158, 0, 2248, 2249, 7, 21, 0, 0, 2249, 2251, 3, 314, 157, 4, 2250, 2246, 1, 0, 0, 0, 2250, 2248, 1, 0, 0, 0, 2251, 2263, 1, 0, 0, 0, 2252, 2253, 10, 3, 0, 0, 2253, 2254, 7, 22, 0, 0, 2254, 2262, 3, 314, 157, 4, 2255, 2256, 10, 2, 0, 0, 2256, 2257, 7, 21, 0, 0, 2257, 2262, 3, 314, 157, 3, 2258, 2259, 10, 1, 0, 0, 2259, 2260, 5, 260, 0, 0, 2260, 2262, 3, 314, 157, 2, 2261, 2252, 1, 0, 0, 0, 2261, 2255, 1, 0, 0, 0, 2261, 2258, 1, 0, 0, 0, 2262, 2265, 1, 0, 0, 0, 2263, 2261, 1, 0, 0, 0, 2263, 2264, 1, 0, 0, 0, 2264, 315, 1, 0, 0, 0, 2265, 2263, 1, 0, 0, 0, 2266, 2267, 6, 158, -1, 0, 2267, 2513, 5, 133, 0, 0, 2268, 2513, 3, 326, 163, 0, 2269, 2270, 3, 362, 181, 0, 2270, 2271, 3, 318, 159, 0, 2271, 2513, 1, 0, 0, 0, 2272, 2273, 5, 286, 0, 0, 2273, 2513, 3, 318, 159, 0, 2274, 2513, 3, 364, 182, 0, 2275, 2513, 3, 324, 162, 0, 2276, 2513, 3, 318, 159, 0, 2277, 2513, 5, 276, 0, 0, 2278, 2513, 5, 272, 0, 0, 2279, 2280, 5, 148, 0, 0, 2280, 2281, 5, 265, 0, 0, 2281, 2282, 3, 314, 157, 0, 2282, 2283, 5, 94, 0, 0, 2283, 2284, 3, 314, 157, 0, 2284, 2285, 5, 266, 0, 0, 2285, 2513, 1, 0, 0, 0, 2286, 2287, 5, 265, 0, 0, 2287, 2290, 3, 308, 154, 0, 2288, 2289, 5, 9, 0, 0, 2289, 2291, 3, 332, 166, 0, 2290, 2288, 1, 0, 0, 0, 2290, 2291, 1, 0, 0, 0, 2291, 2300, 1, 0, 0, 0, 2292, 2293, 5, 263, 0, 0, 2293, 2296, 3, 308, 154, 0, 2294, 2295, 5, 9, 0, 0, 2295, 2297, 3, 332, 166, 0, 2296, 2294, 1, 0, 0, 0, 2296, 2297, 1, 0, 0, 0, 2297, 2299, 1, 0, 0, 0, 2298, 2292, 1, 0, 0, 0, 2299, 2302, 1, 0, 0, 0, 2300, 2301, 1, 0, 0, 0, 2300, 2298, 1, 0, 0, 0, 2301, 2303, 1, 0, 0, 0, 2302, 2300, 1, 0, 0, 0, 2303, 2304, 5, 266, 0, 0, 2304, 2513, 1, 0, 0, 0, 2305, 2306, 5, 168, 0, 0, 2306, 2307, 5, 265, 0, 0, 2307, 2312, 3, 308, 154, 0, 2308, 2309, 5, 263, 0, 0, 2309, 2311, 3, 308, 154, 0, 2310, 2308, 1, 0, 0, 0, 2311, 2314, 1, 0, 0, 0, 2312, 2310, 1, 0, 0, 0, 2312, 2313, 1, 0, 0, 0, 2313, 2315, 1, 0, 0, 0, 2314, 2312, 1, 0, 0, 0, 2315, 2316, 5, 266, 0, 0, 2316, 2513, 1, 0, 0, 0, 2317, 2318, 3, 190, 95, 0, 2318, 2319, 5, 265, 0, 0, 2319, 2320, 5, 257, 0, 0, 2320, 2322, 5, 266, 0, 0, 2321, 2323, 3, 342, 171, 0, 2322, 2321, 1, 0, 0, 0, 2322, 2323, 1, 0, 0, 0, 2323, 2325, 1, 0, 0, 0, 2324, 2326, 3, 344, 172, 0, 2325, 2324, 1, 0, 0, 0, 2325, 2326, 1, 0, 0, 0, 2326, 2513, 1, 0, 0, 0, 2327, 2328, 3, 190, 95, 0, 2328, 2340, 5, 265, 0, 0, 2329, 2331, 3, 280, 140, 0, 2330, 2329, 1, 0, 0, 0, 2330, 2331, 1, 0, 0, 0, 2331, 2332, 1, 0, 0, 0, 2332, 2337, 3, 308, 154, 0, 2333, 2334, 5, 263, 0, 0, 2334, 2336, 3, 308, 154, 0, 2335, 2333, 1, 0, 0, 0, 2336, 2339, 1, 0, 0, 0, 2337, 2335, 1, 0, 0, 0, 2337, 2338, 1, 0, 0, 0, 2338, 2341, 1, 0, 0, 0, 2339, 2337, 1, 0, 0, 0, 2340, 2330, 1, 0, 0, 0, 2340, 2341, 1, 0, 0, 0, 2341, 2352, 1, 0, 0, 0, 2342, 2343, 5, 139, 0, 0, 2343, 2344, 5, 26, 0, 0, 2344, 2349, 3, 268, 134, 0, 2345, 2346, 5, 263, 0, 0, 2346, 2348, 3, 268, 134, 0, 2347, 2345, 1, 0, 0, 0, 2348, 2351, 1, 0, 0, 0, 2349, 2347, 1, 0, 0, 0, 2349, 2350, 1, 0, 0, 0, 2350, 2353, 1, 0, 0, 0, 2351, 2349, 1, 0, 0, 0, 2352, 2342, 1, 0, 0, 0, 2352, 2353, 1, 0, 0, 0, 2353, 2354, 1, 0, 0, 0, 2354, 2356, 5, 266, 0, 0, 2355, 2357, 3, 342, 171, 0, 2356, 2355, 1, 0, 0, 0, 2356, 2357, 1, 0, 0, 0, 2357, 2359, 1, 0, 0, 0, 2358, 2360, 3, 344, 172, 0, 2359, 2358, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360, 2513, 1, 0, 0, 0, 2361, 2362, 3, 362, 181, 0, 2362, 2363, 5, 273, 0, 0, 2363, 2364, 3, 308, 154, 0, 2364, 2513, 1, 0, 0, 0, 2365, 2374, 5, 265, 0, 0, 2366, 2371, 3, 362, 181, 0, 2367, 2368, 5, 263, 0, 0, 2368, 2370, 3, 362, 181, 0, 2369, 2367, 1, 0, 0, 0, 2370, 2373, 1, 0, 0, 0, 2371, 2369, 1, 0, 0, 0, 2371, 2372, 1, 0, 0, 0, 2372, 2375, 1, 0, 0, 0, 2373, 2371, 1, 0, 0, 0, 2374, 2366, 1, 0, 0, 0, 2374, 2375, 1, 0, 0, 0, 2375, 2376, 1, 0, 0, 0, 2376, 2377, 5, 266, 0, 0, 2377, 2378, 5, 273, 0, 0, 2378, 2513, 3, 308, 154, 0, 2379, 2380, 5, 265, 0, 0, 2380, 2381, 3, 206, 103, 0, 2381, 2382, 5, 266, 0, 0, 2382, 2513, 1, 0, 0, 0, 2383, 2384, 5, 66, 0, 0, 2384, 2385, 5, 265, 0, 0, 2385, 2386, 3, 206, 103, 0, 2386, 2387, 5, 266, 0, 0, 2387, 2513, 1, 0, 0, 0, 2388, 2389, 5, 28, 0, 0, 2389, 2391, 3, 314, 157, 0, 2390, 2392, 3, 340, 170, 0, 2391, 2390, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2391, 1, 0, 0, 0, 2393, 2394, 1, 0, 0, 0, 2394, 2397, 1, 0, 0, 0, 2395, 2396, 5, 59, 0, 0, 2396, 2398, 3, 308, 154, 0, 2397, 2395, 1, 0, 0, 0, 2397, 2398, 1, 0, 0, 0, 2398, 2399, 1, 0, 0, 0, 2399, 2400, 5, 61, 0, 0, 2400, 2513, 1, 0, 0, 0, 2401, 2403, 5, 28, 0, 0, 2402, 2404, 3, 340, 170, 0, 2403, 2402, 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 2403, 1, 0, 0, 0, 2405, 2406, 1, 0, 0, 0, 2406, 2409, 1, 0, 0, 0, 2407, 2408, 5, 59, 0, 0, 2408, 2410, 3, 308, 154, 0, 2409, 2407, 1, 0, 0, 0, 2409, 2410, 1, 0, 0, 0, 2410, 2411, 1, 0, 0, 0, 2411, 2412, 5, 61, 0, 0, 2412, 2513, 1, 0, 0, 0, 2413, 2414, 5, 29, 0, 0, 2414, 2415, 5, 265, 0, 0, 2415, 2416, 3, 308, 154, 0, 2416, 2417, 5, 9, 0, 0, 2417, 2418, 3, 332, 166, 0, 2418, 2419, 5, 266, 0, 0, 2419, 2513, 1, 0, 0, 0, 2420, 2421, 5, 195, 0, 0, 2421, 2422, 5, 265, 0, 0, 2422, 2423, 3, 308, 154, 0, 2423, 2424, 5, 9, 0, 0, 2424, 2425, 3, 332, 166, 0, 2425, 2426, 5, 266, 0, 0, 2426, 2513, 1, 0, 0, 0, 2427, 2428, 5, 8, 0, 0, 2428, 2437, 5, 267, 0, 0, 2429, 2434, 3, 308, 154, 0, 2430, 2431, 5, 263, 0, 0, 2431, 2433, 3, 308, 154, 0, 2432, 2430, 1, 0, 0, 0, 2433, 2436, 1, 0, 0, 0, 2434, 2432, 1, 0, 0, 0, 2434, 2435, 1, 0, 0, 0, 2435, 2438, 1, 0, 0, 0, 2436, 2434, 1, 0, 0, 0, 2437, 2429, 1, 0, 0, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2439, 1, 0, 0, 0, 2439, 2513, 5, 268, 0, 0, 2440, 2513, 3, 362, 181, 0, 2441, 2513, 5, 40, 0, 0, 2442, 2446, 5, 42, 0, 0, 2443, 2444, 5, 265, 0, 0, 2444, 2445, 5, 277, 0, 0, 2445, 2447, 5, 266, 0, 0, 2446, 2443, 1, 0, 0, 0, 2446, 2447, 1, 0, 0, 0, 2447, 2513, 1, 0, 0, 0, 2448, 2452, 5, 43, 0, 0, 2449, 2450, 5, 265, 0, 0, 2450, 2451, 5, 277, 0, 0, 2451, 2453, 5, 266, 0, 0, 2452, 2449, 1, 0, 0, 0, 2452, 2453, 1, 0, 0, 0, 2453, 2513, 1, 0, 0, 0, 2454, 2458, 5, 119, 0, 0, 2455, 2456, 5, 265, 0, 0, 2456, 2457, 5, 277, 0, 0, 2457, 2459, 5, 266, 0, 0, 2458, 2455, 1, 0, 0, 0, 2458, 2459, 1, 0, 0, 0, 2459, 2513, 1, 0, 0, 0, 2460, 2464, 5, 120, 0, 0, 2461, 2462, 5, 265, 0, 0, 2462, 2463, 5, 277, 0, 0, 2463, 2465, 5, 266, 0, 0, 2464, 2461, 1, 0, 0, 0, 2464, 2465, 1, 0, 0, 0, 2465, 2513, 1, 0, 0, 0, 2466, 2513, 5, 44, 0, 0, 2467, 2513, 5, 41, 0, 0, 2468, 2469, 5, 184, 0, 0, 2469, 2470, 5, 265, 0, 0, 2470, 2471, 3, 314, 157, 0, 2471, 2472, 5, 82, 0, 0, 2472, 2475, 3, 314, 157, 0, 2473, 2474, 5, 78, 0, 0, 2474, 2476, 3, 314, 157, 0, 2475, 2473, 1, 0, 0, 0, 2475, 2476, 1, 0, 0, 0, 2476, 2477, 1, 0, 0, 0, 2477, 2478, 5, 266, 0, 0, 2478, 2513, 1, 0, 0, 0, 2479, 2480, 5, 131, 0, 0, 2480, 2481, 5, 265, 0, 0, 2481, 2484, 3, 314, 157, 0, 2482, 2483, 5, 263, 0, 0, 2483, 2485, 3, 330, 165, 0, 2484, 2482, 1, 0, 0, 0, 2484, 2485, 1, 0, 0, 0, 2485, 2486, 1, 0, 0, 0, 2486, 2487, 5, 266, 0, 0, 2487, 2513, 1, 0, 0, 0, 2488, 2489, 5, 68, 0, 0, 2489, 2490, 5, 265, 0, 0, 2490, 2491, 3, 362, 181, 0, 2491, 2492, 5, 82, 0, 0, 2492, 2493, 3, 314, 157, 0, 2493, 2494, 5, 266, 0, 0, 2494, 2513, 1, 0, 0, 0, 2495, 2496, 5, 265, 0, 0, 2496, 2497, 3, 308, 154, 0, 2497, 2498, 5, 266, 0, 0, 2498, 2513, 1, 0, 0, 0, 2499, 2500, 5, 88, 0, 0, 2500, 2509, 5, 265, 0, 0, 2501, 2506, 3, 358, 179, 0, 2502, 2503, 5, 263, 0, 0, 2503, 2505, 3, 358, 179, 0, 2504, 2502, 1, 0, 0, 0, 2505, 2508, 1, 0, 0, 0, 2506, 2504, 1, 0, 0, 0, 2506, 2507, 1, 0, 0, 0, 2507, 2510, 1, 0, 0, 0, 2508, 2506, 1, 0, 0, 0, 2509, 2501, 1, 0, 0, 0, 2509, 2510, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 2513, 5, 266, 0, 0, 2512, 2266, 1, 0, 0, 0, 2512, 2268, 1, 0, 0, 0, 2512, 2269, 1, 0, 0, 0, 2512, 2272, 1, 0, 0, 0, 2512, 2274, 1, 0, 0, 0, 2512, 2275, 1, 0, 0, 0, 2512, 2276, 1, 0, 0, 0, 2512, 2277, 1, 0, 0, 0, 2512, 2278, 1, 0, 0, 0, 2512, 2279, 1, 0, 0, 0, 2512, 2286, 1, 0, 0, 0, 2512, 2305, 1, 0, 0, 0, 2512, 2317, 1, 0, 0, 0, 2512, 2327, 1, 0, 0, 0, 2512, 2361, 1, 0, 0, 0, 2512, 2365, 1, 0, 0, 0, 2512, 2379, 1, 0, 0, 0, 2512, 2383, 1, 0, 0, 0, 2512, 2388, 1, 0, 0, 0, 2512, 2401, 1, 0, 0, 0, 2512, 2413, 1, 0, 0, 0, 2512, 2420, 1, 0, 0, 0, 2512, 2427, 1, 0, 0, 0, 2512, 2440, 1, 0, 0, 0, 2512, 2441, 1, 0, 0, 0, 2512, 2442, 1, 0, 0, 0, 2512, 2448, 1, 0, 0, 0, 2512, 2454, 1, 0, 0, 0, 2512, 2460, 1, 0, 0, 0, 2512, 2466, 1, 0, 0, 0, 2512, 2467, 1, 0, 0, 0, 2512, 2468, 1, 0, 0, 0, 2512, 2479, 1, 0, 0, 0, 2512, 2488, 1, 0, 0, 0, 2512, 2495, 1, 0, 0, 0, 2512, 2499, 1, 0, 0, 0, 2513, 2524, 1, 0, 0, 0, 2514, 2515, 10, 15, 0, 0, 2515, 2516, 5, 267, 0, 0, 2516, 2517, 3, 314, 157, 0, 2517, 2518, 5, 268, 0, 0, 2518, 2523, 1, 0, 0, 0, 2519, 2520, 10, 13, 0, 0, 2520, 2521, 5, 261, 0, 0, 2521, 2523, 3, 362, 181, 0, 2522, 2514, 1, 0, 0, 0, 2522, 2519, 1, 0, 0, 0, 2523, 2526, 1, 0, 0, 0, 2524, 2522, 1, 0, 0, 0, 2524, 2525, 1, 0, 0, 0, 2525, 317, 1, 0, 0, 0, 2526, 2524, 1, 0, 0, 0, 2527, 2534, 5, 274, 0, 0, 2528, 2531, 5, 275, 0, 0, 2529, 2530, 5, 198, 0, 0, 2530, 2532, 5, 274, 0, 0, 2531, 2529, 1, 0, 0, 0, 2531, 2532, 1, 0, 0, 0, 2532, 2534, 1, 0, 0, 0, 2533, 2527, 1, 0, 0, 0, 2533, 2528, 1, 0, 0, 0, 2534, 319, 1, 0, 0, 0, 2535, 2536, 7, 23, 0, 0, 2536, 321, 1, 0, 0, 0, 2537, 2538, 7, 24, 0, 0, 2538, 323, 1, 0, 0, 0, 2539, 2540, 7, 25, 0, 0, 2540, 325, 1, 0, 0, 0, 2541, 2542, 5, 277, 0, 0, 2542, 2556, 3, 328, 164, 0, 2543, 2544, 5, 265, 0, 0, 2544, 2545, 5, 277, 0, 0, 2545, 2546, 5, 266, 0, 0, 2546, 2556, 3, 328, 164, 0, 2547, 2548, 5, 101, 0, 0, 2548, 2549, 5, 277, 0, 0, 2549, 2556, 3, 328, 164, 0, 2550, 2551, 5, 101, 0, 0, 2551, 2552, 5, 265, 0, 0, 2552, 2553, 5, 277, 0, 0, 2553, 2554, 5, 266, 0, 0, 2554, 2556, 3, 328, 164, 0, 2555, 2541, 1, 0, 0, 0, 2555, 2543, 1, 0, 0, 0, 2555, 2547, 1, 0, 0, 0, 2555, 2550, 1, 0, 0, 0, 2556, 327, 1, 0, 0, 0, 2557, 2558, 7, 26, 0, 0, 2558, 329, 1, 0, 0, 0, 2559, 2560, 7, 27, 0, 0, 2560, 331, 1, 0, 0, 0, 2561, 2562, 6, 166, -1, 0, 2562, 2563, 5, 8, 0, 0, 2563, 2564, 5, 251, 0, 0, 2564, 2565, 3, 332, 166, 0, 2565, 2566, 5, 253, 0, 0, 2566, 2607, 1, 0, 0, 0, 2567, 2568, 5, 235, 0, 0, 2568, 2569, 5, 251, 0, 0, 2569, 2570, 3, 332, 166, 0, 2570, 2571, 5, 263, 0, 0, 2571, 2572, 3, 332, 166, 0, 2572, 2573, 5, 253, 0, 0, 2573, 2607, 1, 0, 0, 0, 2574, 2575, 5, 240, 0, 0, 2575, 2576, 5, 251, 0, 0, 2576, 2577, 3, 362, 181, 0, 2577, 2584, 3, 332, 166, 0, 2578, 2579, 5, 263, 0, 0, 2579, 2580, 3, 362, 181, 0, 2580, 2581, 3, 332, 166, 0, 2581, 2583, 1, 0, 0, 0, 2582, 2578, 1, 0, 0, 0, 2583, 2586, 1, 0, 0, 0, 2584, 2582, 1, 0, 0, 0, 2584, 2585, 1, 0, 0, 0, 2585, 2587, 1, 0, 0, 0, 2586, 2584, 1, 0, 0, 0, 2587, 2588, 5, 253, 0, 0, 2588, 2607, 1, 0, 0, 0, 2589, 2592, 3, 338, 169, 0, 2590, 2592, 3, 334, 167, 0, 2591, 2589, 1, 0, 0, 0, 2591, 2590, 1, 0, 0, 0, 2592, 2604, 1, 0, 0, 0, 2593, 2594, 5, 265, 0, 0, 2594, 2599, 3, 336, 168, 0, 2595, 2596, 5, 263, 0, 0, 2596, 2598, 3, 336, 168, 0, 2597, 2595, 1, 0, 0, 0, 2598, 2601, 1, 0, 0, 0, 2599, 2597, 1, 0, 0, 0, 2599, 2600, 1, 0, 0, 0, 2600, 2602, 1, 0, 0, 0, 2601, 2599, 1, 0, 0, 0, 2602, 2603, 5, 266, 0, 0, 2603, 2605, 1, 0, 0, 0, 2604, 2593, 1, 0, 0, 0, 2604, 2605, 1, 0, 0, 0, 2605, 2607, 1, 0, 0, 0, 2606, 2561, 1, 0, 0, 0, 2606, 2567, 1, 0, 0, 0, 2606, 2574, 1, 0, 0, 0, 2606, 2591, 1, 0, 0, 0, 2607, 2612, 1, 0, 0, 0, 2608, 2609, 10, 5, 0, 0, 2609, 2611, 5, 8, 0, 0, 2610, 2608, 1, 0, 0, 0, 2611, 2614, 1, 0, 0, 0, 2612, 2610, 1, 0, 0, 0, 2612, 2613, 1, 0, 0, 0, 2613, 333, 1, 0, 0, 0, 2614, 2612, 1, 0, 0, 0, 2615, 2616, 7, 28, 0, 0, 2616, 335, 1, 0, 0, 0, 2617, 2620, 5, 277, 0, 0, 2618, 2620, 3, 332, 166, 0, 2619, 2617, 1, 0, 0, 0, 2619, 2618, 1, 0, 0, 0, 2620, 337, 1, 0, 0, 0, 2621, 2626, 5, 284, 0, 0, 2622, 2626, 5, 285, 0, 0, 2623, 2626, 5, 286, 0, 0, 2624, 2626, 3, 362, 181, 0, 2625, 2621, 1, 0, 0, 0, 2625, 2622, 1, 0, 0, 0, 2625, 2623, 1, 0, 0, 0, 2625, 2624, 1, 0, 0, 0, 2626, 339, 1, 0, 0, 0, 2627, 2628, 5, 214, 0, 0, 2628, 2629, 3, 308, 154, 0, 2629, 2630, 5, 192, 0, 0, 2630, 2631, 3, 308, 154, 0, 2631, 341, 1, 0, 0, 0, 2632, 2633, 5, 74, 0, 0, 2633, 2634, 5, 265, 0, 0, 2634, 2635, 5, 215, 0, 0, 2635, 2636, 3, 310, 155, 0, 2636, 2637, 5, 266, 0, 0, 2637, 343, 1, 0, 0, 0, 2638, 2639, 5, 143, 0, 0, 2639, 2650, 5, 265, 0, 0, 2640, 2641, 5, 145, 0, 0, 2641, 2642, 5, 26, 0, 0, 2642, 2647, 3, 308, 154, 0, 2643, 2644, 5, 263, 0, 0, 2644, 2646, 3, 308, 154, 0, 2645, 2643, 1, 0, 0, 0, 2646, 2649, 1, 0, 0, 0, 2647, 2645, 1, 0, 0, 0, 2647, 2648, 1, 0, 0, 0, 2648, 2651, 1, 0, 0, 0, 2649, 2647, 1, 0, 0, 0, 2650, 2640, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2662, 1, 0, 0, 0, 2652, 2653, 5, 139, 0, 0, 2653, 2654, 5, 26, 0, 0, 2654, 2659, 3, 268, 134, 0, 2655, 2656, 5, 263, 0, 0, 2656, 2658, 3, 268, 134, 0, 2657, 2655, 1, 0, 0, 0, 2658, 2661, 1, 0, 0, 0, 2659, 2657, 1, 0, 0, 0, 2659, 2660, 1, 0, 0, 0, 2660, 2663, 1, 0, 0, 0, 2661, 2659, 1, 0, 0, 0, 2662, 2652, 1, 0, 0, 0, 2662, 2663, 1, 0, 0, 0, 2663, 2665, 1, 0, 0, 0, 2664, 2666, 3, 346, 173, 0, 2665, 2664, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666, 2667, 1, 0, 0, 0, 2667, 2668, 5, 266, 0, 0, 2668, 345, 1, 0, 0, 0, 2669, 2670, 5, 154, 0, 0, 2670, 2686, 3, 348, 174, 0, 2671, 2672, 5, 169, 0, 0, 2672, 2686, 3, 348, 174, 0, 2673, 2674, 5, 154, 0, 0, 2674, 2675, 5, 15, 0, 0, 2675, 2676, 3, 348, 174, 0, 2676, 2677, 5, 5, 0, 0, 2677, 2678, 3, 348, 174, 0, 2678, 2686, 1, 0, 0, 0, 2679, 2680, 5, 169, 0, 0, 2680, 2681, 5, 15, 0, 0, 2681, 2682, 3, 348, 174, 0, 2682, 2683, 5, 5, 0, 0, 2683, 2684, 3, 348, 174, 0, 2684, 2686, 1, 0, 0, 0, 2685, 2669, 1, 0, 0, 0, 2685, 2671, 1, 0, 0, 0, 2685, 2673, 1, 0, 0, 0, 2685, 2679, 1, 0, 0, 0, 2686, 347, 1, 0, 0, 0, 2687, 2688, 5, 199, 0, 0, 2688, 2697, 5, 149, 0, 0, 2689, 2690, 5, 199, 0, 0, 2690, 2697, 5, 77, 0, 0, 2691, 2692, 5, 39, 0, 0, 2692, 2697, 5, 168, 0, 0, 2693, 2694, 3, 308, 154, 0, 2694, 2695, 7, 29, 0, 0, 2695, 2697, 1, 0, 0, 0, 2696, 2687, 1, 0, 0, 0, 2696, 2689, 1, 0, 0, 0, 2696, 2691, 1, 0, 0, 0, 2696, 2693, 1, 0, 0, 0, 2697, 349, 1, 0, 0, 0, 2698, 2699, 3, 362, 181, 0, 2699, 2700, 5, 261, 0, 0, 2700, 2701, 3, 362, 181, 0, 2701, 2704, 1, 0, 0, 0, 2702, 2704, 3, 362, 181, 0, 2703, 2698, 1, 0, 0, 0, 2703, 2702, 1, 0, 0, 0, 2704, 351, 1, 0, 0, 0, 2705, 2710, 3, 350, 175, 0, 2706, 2707, 5, 263, 0, 0, 2707, 2709, 3, 350, 175, 0, 2708, 2706, 1, 0, 0, 0, 2709, 2712, 1, 0, 0, 0, 2710, 2708, 1, 0, 0, 0, 2710, 2711, 1, 0, 0, 0, 2711, 353, 1, 0, 0, 0, 2712, 2710, 1, 0, 0, 0, 2713, 2727, 5, 2, 0, 0, 2714, 2727, 5, 4, 0, 0, 2715, 2727, 5, 58, 0, 0, 2716, 2727, 5, 37, 0, 0, 2717, 2727, 5, 99, 0, 0, 2718, 2727, 5, 162, 0, 0, 2719, 2724, 5, 174, 0, 0, 2720, 2721, 5, 265, 0, 0, 2721, 2722, 3, 362, 181, 0, 2722, 2723, 5, 266, 0, 0, 2723, 2725, 1, 0, 0, 0, 2724, 2720, 1, 0, 0, 0, 2724, 2725, 1, 0, 0, 0, 2725, 2727, 1, 0, 0, 0, 2726, 2713, 1, 0, 0, 0, 2726, 2714, 1, 0, 0, 0, 2726, 2715, 1, 0, 0, 0, 2726, 2716, 1, 0, 0, 0, 2726, 2717, 1, 0, 0, 0, 2726, 2718, 1, 0, 0, 0, 2726, 2719, 1, 0, 0, 0, 2727, 355, 1, 0, 0, 0, 2728, 2729, 7, 30, 0, 0, 2729, 357, 1, 0, 0, 0, 2730, 2735, 3, 362, 181, 0, 2731, 2732, 5, 261, 0, 0, 2732, 2734, 3, 362, 181, 0, 2733, 2731, 1, 0, 0, 0, 2734, 2737, 1, 0, 0, 0, 2735, 2733, 1, 0, 0, 0, 2735, 2736, 1, 0, 0, 0, 2736, 359, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2738, 2739, 5, 166, 0, 0, 2739, 2745, 3, 362, 181, 0, 2740, 2741, 5, 204, 0, 0, 2741, 2745, 3, 362, 181, 0, 2742, 2743, 5, 87, 0, 0, 2743, 2745, 3, 362, 181, 0, 2744, 2738, 1, 0, 0, 0, 2744, 2740, 1, 0, 0, 0, 2744, 2742, 1, 0, 0, 0, 2745, 361, 1, 0, 0, 0, 2746, 2752, 5, 280, 0, 0, 2747, 2752, 5, 274, 0, 0, 2748, 2752, 3, 368, 184, 0, 2749, 2752, 5, 283, 0, 0, 2750, 2752, 5, 281, 0, 0, 2751, 2746, 1, 0, 0, 0, 2751, 2747, 1, 0, 0, 0, 2751, 2748, 1, 0, 0, 0, 2751, 2749, 1, 0, 0, 0, 2751, 2750, 1, 0, 0, 0, 2752, 363, 1, 0, 0, 0, 2753, 2755, 5, 256, 0, 0, 2754, 2753, 1, 0, 0, 0, 2754, 2755, 1, 0, 0, 0, 2755, 2756, 1, 0, 0, 0, 2756, 2766, 5, 278, 0, 0, 2757, 2759, 5, 256, 0, 0, 2758, 2757, 1, 0, 0, 0, 2758, 2759, 1, 0, 0, 0, 2759, 2760, 1, 0, 0, 0, 2760, 2766, 5, 279, 0, 0, 2761, 2763, 5, 256, 0, 0, 2762, 2761, 1, 0, 0, 0, 2762, 2763, 1, 0, 0, 0, 2763, 2764, 1, 0, 0, 0, 2764, 2766, 5, 277, 0, 0, 2765, 2754, 1, 0, 0, 0, 2765, 2758, 1, 0, 0, 0, 2765, 2762, 1, 0, 0, 0, 2766, 365, 1, 0, 0, 0, 2767, 2768, 7, 31, 0, 0, 2768, 367, 1, 0, 0, 0, 2769, 2770, 7, 32, 0, 0, 2770, 369, 1, 0, 0, 0, 353, 373, 380, 404, 417, 421, 425, 434, 439, 443, 449, 451, 456, 460, 464, 471, 476, 482, 486, 495, 502, 506, 511, 513, 518, 521, 528, 532, 537, 541, 544, 548, 556, 560, 564, 572, 576, 585, 588, 591, 597, 604, 615, 620, 625, 630, 635, 644, 647, 650, 654, 680, 706, 715, 725, 728, 742, 760, 762, 771, 782, 791, 798, 802, 809, 815, 818, 823, 830, 844, 857, 862, 867, 873, 909, 912, 918, 921, 927, 933, 945, 947, 958, 966, 971, 975, 980, 987, 991, 995, 1001, 1005, 1009, 1018, 1021, 1024, 1032, 1046, 1053, 1066, 1072, 1077, 1080, 1083, 1088, 1092, 1101, 1106, 1112, 1116, 1121, 1126, 1129, 1137, 1140, 1144, 1156, 1159, 1163, 1168, 1172, 1188, 1193, 1200, 1203, 1209, 1212, 1219, 1222, 1226, 1231, 1234, 1241, 1244, 1268, 1282, 1286, 1290, 1310, 1312, 1314, 1323, 1325, 1334, 1336, 1345, 1347, 1352, 1361, 1370, 1379, 1390, 1396, 1401, 1404, 1417, 1427, 1431, 1436, 1447, 1452, 1485, 1493, 1498, 1502, 1506, 1511, 1514, 1519, 1524, 1529, 1533, 1542, 1545, 1549, 1556, 1565, 1569, 1573, 1580, 1583, 1593, 1600, 1605, 1610, 1615, 1621, 1624, 1633, 1636, 1639, 1645, 1650, 1660, 1663, 1666, 1670, 1680, 1683, 1689, 1695, 1698, 1701, 1705, 1715, 1726, 1731, 1734, 1738, 1745, 1755, 1767, 1773, 1775, 1784, 1787, 1794, 1804, 1810, 1818, 1829, 1839, 1850, 1852, 1858, 1863, 1873, 1876, 1882, 1884, 1892, 1898, 1901, 1903, 1915, 1922, 1926, 1930, 1934, 1937, 1944, 1953, 1956, 1960, 1965, 1969, 1972, 1979, 1990, 1993, 1997, 2001, 2010, 2013, 2020, 2034, 2038, 2042, 2046, 2050, 2054, 2058, 2062, 2072, 2083, 2088, 2101, 2103, 2109, 2113, 2115, 2123, 2130, 2135, 2148, 2154, 2162, 2169, 2173, 2181, 2183, 2194, 2202, 2211, 2217, 2222, 2228, 2234, 2239, 2244, 2250, 2261, 2263, 2290, 2296, 2300, 2312, 2322, 2325, 2330, 2337, 2340, 2349, 2352, 2356, 2359, 2371, 2374, 2393, 2397, 2405, 2409, 2434, 2437, 2446, 2452, 2458, 2464, 2475, 2484, 2506, 2509, 2512, 2522, 2524, 2531, 2533, 2555, 2584, 2591, 2599, 2604, 2606, 2612, 2619, 2625, 2647, 2650, 2659, 2662, 2665, 2685, 2696, 2703, 2710, 2724, 2726, 2735, 2744, 2751, 2754, 2758, 2762, 2765] \ No newline at end of file diff --git a/src/lib/impala/ImpalaSqlParser.ts b/src/lib/impala/ImpalaSqlParser.ts index b9a88388..06c61db8 100644 --- a/src/lib/impala/ImpalaSqlParser.ts +++ b/src/lib/impala/ImpalaSqlParser.ts @@ -408,87 +408,89 @@ export class ImpalaSqlParser extends SQLParserBase { public static readonly RULE_assignmentList = 99; public static readonly RULE_assignmentItem = 100; public static readonly RULE_viewColumns = 101; - public static readonly RULE_queryStatement = 102; - public static readonly RULE_with = 103; - public static readonly RULE_constraintSpecification = 104; - public static readonly RULE_foreignKeySpecification = 105; - public static readonly RULE_columnSpec = 106; - public static readonly RULE_columnDefinition = 107; - public static readonly RULE_kuduTableElement = 108; - public static readonly RULE_kuduColumnDefinition = 109; - public static readonly RULE_columnSpecWithKudu = 110; - public static readonly RULE_createColumnSpecWithKudu = 111; - public static readonly RULE_kuduAttributes = 112; - public static readonly RULE_kuduStorageAttr = 113; - public static readonly RULE_statsKey = 114; - public static readonly RULE_fileFormat = 115; - public static readonly RULE_kuduPartitionClause = 116; - public static readonly RULE_hashClause = 117; - public static readonly RULE_rangeClause = 118; - public static readonly RULE_kuduPartitionSpec = 119; - public static readonly RULE_cacheSpec = 120; - public static readonly RULE_rangeOperator = 121; - public static readonly RULE_partitionCol = 122; - public static readonly RULE_likeClause = 123; - public static readonly RULE_properties = 124; - public static readonly RULE_partitionedBy = 125; - public static readonly RULE_sortedBy = 126; - public static readonly RULE_rowFormat = 127; - public static readonly RULE_property = 128; - public static readonly RULE_queryNoWith = 129; - public static readonly RULE_queryTerm = 130; - public static readonly RULE_queryPrimary = 131; - public static readonly RULE_sortItem = 132; - public static readonly RULE_querySpecification = 133; - public static readonly RULE_groupBy = 134; - public static readonly RULE_groupingElement = 135; - public static readonly RULE_groupingSet = 136; - public static readonly RULE_namedQuery = 137; - public static readonly RULE_setQuantifier = 138; - public static readonly RULE_selectItem = 139; - public static readonly RULE_relation = 140; - public static readonly RULE_joinType = 141; - public static readonly RULE_joinCriteria = 142; - public static readonly RULE_sampledRelation = 143; - public static readonly RULE_sampleType = 144; - public static readonly RULE_aliasedRelation = 145; - public static readonly RULE_columnAliases = 146; - public static readonly RULE_relationPrimary = 147; - public static readonly RULE_subQueryRelation = 148; - public static readonly RULE_unnest = 149; - public static readonly RULE_parenthesizedRelation = 150; - public static readonly RULE_columnItem = 151; - public static readonly RULE_expression = 152; - public static readonly RULE_booleanExpression = 153; - public static readonly RULE_predicate = 154; - public static readonly RULE_valueExpression = 155; - public static readonly RULE_primaryExpression = 156; - public static readonly RULE_stringLiteral = 157; - public static readonly RULE_comparisonOperator = 158; - public static readonly RULE_comparisonQuantifier = 159; - public static readonly RULE_booleanValue = 160; - public static readonly RULE_interval = 161; - public static readonly RULE_intervalField = 162; - public static readonly RULE_normalForm = 163; - public static readonly RULE_type = 164; - public static readonly RULE_dataType = 165; - public static readonly RULE_typeParameter = 166; - public static readonly RULE_baseType = 167; - public static readonly RULE_whenClause = 168; - public static readonly RULE_filter = 169; - public static readonly RULE_over = 170; - public static readonly RULE_windowFrame = 171; - public static readonly RULE_frameBound = 172; - public static readonly RULE_pathElement = 173; - public static readonly RULE_pathSpecification = 174; - public static readonly RULE_privilege = 175; - public static readonly RULE_objectType = 176; - public static readonly RULE_qualifiedName = 177; - public static readonly RULE_principal = 178; - public static readonly RULE_identifier = 179; - public static readonly RULE_number = 180; - public static readonly RULE_reservedKeywordsUsedAsFuncName = 181; - public static readonly RULE_nonReserved = 182; + public static readonly RULE_viewColumnItem = 102; + public static readonly RULE_queryStatement = 103; + public static readonly RULE_with = 104; + public static readonly RULE_constraintSpecification = 105; + public static readonly RULE_foreignKeySpecification = 106; + public static readonly RULE_columnSpec = 107; + public static readonly RULE_columnDefinition = 108; + public static readonly RULE_kuduTableElement = 109; + public static readonly RULE_kuduColumnDefinition = 110; + public static readonly RULE_commentClause = 111; + public static readonly RULE_columnSpecWithKudu = 112; + public static readonly RULE_createColumnSpecWithKudu = 113; + public static readonly RULE_kuduAttributes = 114; + public static readonly RULE_kuduStorageAttr = 115; + public static readonly RULE_statsKey = 116; + public static readonly RULE_fileFormat = 117; + public static readonly RULE_kuduPartitionClause = 118; + public static readonly RULE_hashClause = 119; + public static readonly RULE_rangeClause = 120; + public static readonly RULE_kuduPartitionSpec = 121; + public static readonly RULE_cacheSpec = 122; + public static readonly RULE_rangeOperator = 123; + public static readonly RULE_partitionCol = 124; + public static readonly RULE_likeClause = 125; + public static readonly RULE_properties = 126; + public static readonly RULE_partitionedBy = 127; + public static readonly RULE_sortedBy = 128; + public static readonly RULE_rowFormat = 129; + public static readonly RULE_property = 130; + public static readonly RULE_queryNoWith = 131; + public static readonly RULE_queryTerm = 132; + public static readonly RULE_queryPrimary = 133; + public static readonly RULE_sortItem = 134; + public static readonly RULE_querySpecification = 135; + public static readonly RULE_groupBy = 136; + public static readonly RULE_groupingElement = 137; + public static readonly RULE_groupingSet = 138; + public static readonly RULE_namedQuery = 139; + public static readonly RULE_setQuantifier = 140; + public static readonly RULE_selectItem = 141; + public static readonly RULE_relation = 142; + public static readonly RULE_joinType = 143; + public static readonly RULE_joinCriteria = 144; + public static readonly RULE_sampledRelation = 145; + public static readonly RULE_sampleType = 146; + public static readonly RULE_aliasedRelation = 147; + public static readonly RULE_columnAliases = 148; + public static readonly RULE_relationPrimary = 149; + public static readonly RULE_subQueryRelation = 150; + public static readonly RULE_unnest = 151; + public static readonly RULE_parenthesizedRelation = 152; + public static readonly RULE_columnItem = 153; + public static readonly RULE_expression = 154; + public static readonly RULE_booleanExpression = 155; + public static readonly RULE_predicate = 156; + public static readonly RULE_valueExpression = 157; + public static readonly RULE_primaryExpression = 158; + public static readonly RULE_stringLiteral = 159; + public static readonly RULE_comparisonOperator = 160; + public static readonly RULE_comparisonQuantifier = 161; + public static readonly RULE_booleanValue = 162; + public static readonly RULE_interval = 163; + public static readonly RULE_intervalField = 164; + public static readonly RULE_normalForm = 165; + public static readonly RULE_type = 166; + public static readonly RULE_dataType = 167; + public static readonly RULE_typeParameter = 168; + public static readonly RULE_baseType = 169; + public static readonly RULE_whenClause = 170; + public static readonly RULE_filter = 171; + public static readonly RULE_over = 172; + public static readonly RULE_windowFrame = 173; + public static readonly RULE_frameBound = 174; + public static readonly RULE_pathElement = 175; + public static readonly RULE_pathSpecification = 176; + public static readonly RULE_privilege = 177; + public static readonly RULE_objectType = 178; + public static readonly RULE_qualifiedName = 179; + public static readonly RULE_principal = 180; + public static readonly RULE_identifier = 181; + public static readonly RULE_number = 182; + public static readonly RULE_reservedKeywordsUsedAsFuncName = 183; + public static readonly RULE_nonReserved = 184; public static readonly literalNames = [ null, "'ADD'", "'ALL'", "'ANALYTIC'", "'ALTER'", "'AND'", "'ANY'", @@ -625,9 +627,10 @@ export class ImpalaSqlParser extends SQLParserBase { "viewNameCreate", "functionNameCreate", "columnNamePathCreate", "databaseNamePath", "tableNamePath", "viewNamePath", "functionNamePath", "columnNamePath", "tableOrViewPath", "createCommonItem", "assignmentList", - "assignmentItem", "viewColumns", "queryStatement", "with", "constraintSpecification", - "foreignKeySpecification", "columnSpec", "columnDefinition", "kuduTableElement", - "kuduColumnDefinition", "columnSpecWithKudu", "createColumnSpecWithKudu", + "assignmentItem", "viewColumns", "viewColumnItem", "queryStatement", + "with", "constraintSpecification", "foreignKeySpecification", "columnSpec", + "columnDefinition", "kuduTableElement", "kuduColumnDefinition", + "commentClause", "columnSpecWithKudu", "createColumnSpecWithKudu", "kuduAttributes", "kuduStorageAttr", "statsKey", "fileFormat", "kuduPartitionClause", "hashClause", "rangeClause", "kuduPartitionSpec", "cacheSpec", "rangeOperator", "partitionCol", "likeClause", "properties", "partitionedBy", "sortedBy", @@ -667,21 +670,21 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 369; + this.state = 373; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 4 || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 22085645) !== 0) || _la === 67 || _la === 86 || ((((_la - 99)) & ~0x1F) === 0 && ((1 << (_la - 99)) & 524545) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 134520835) !== 0) || ((((_la - 196)) & ~0x1F) === 0 && ((1 << (_la - 196)) & 1083521) !== 0) || _la === 264 || _la === 265) { { { - this.state = 366; + this.state = 370; this.singleStatement(); } } - this.state = 371; + this.state = 375; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 372; + this.state = 376; this.match(ImpalaSqlParser.EOF); } } @@ -706,14 +709,14 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 374; + this.state = 378; this.sqlStatement(); - this.state = 376; + this.state = 380; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 262) { { - this.state = 375; + this.state = 379; this.match(ImpalaSqlParser.SEMICOLON); } } @@ -738,160 +741,160 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new SqlStatementContext(this.context, this.state); this.enterRule(localContext, 4, ImpalaSqlParser.RULE_sqlStatement); try { - this.state = 400; + this.state = 404; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 2, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 378; + this.state = 382; this.queryStatement(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 379; + this.state = 383; this.useStatement(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 380; + this.state = 384; this.createStatement(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 381; + this.state = 385; this.alterStatement(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 382; + this.state = 386; this.truncateTableStatement(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 383; + this.state = 387; this.describeStatement(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 384; + this.state = 388; this.computeStatement(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 385; + this.state = 389; this.dropStatement(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 386; + this.state = 390; this.grantStatement(); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 387; + this.state = 391; this.revokeStatement(); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 388; + this.state = 392; this.insertStatement(); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 389; + this.state = 393; this.deleteStatement(); } break; case 13: this.enterOuterAlt(localContext, 13); { - this.state = 390; + this.state = 394; this.updateStatement(); } break; case 14: this.enterOuterAlt(localContext, 14); { - this.state = 391; + this.state = 395; this.upsertStatement(); } break; case 15: this.enterOuterAlt(localContext, 15); { - this.state = 392; + this.state = 396; this.showStatement(); } break; case 16: this.enterOuterAlt(localContext, 16); { - this.state = 393; + this.state = 397; this.addCommentStatement(); } break; case 17: this.enterOuterAlt(localContext, 17); { - this.state = 394; + this.state = 398; this.explainStatement(); } break; case 18: this.enterOuterAlt(localContext, 18); { - this.state = 395; + this.state = 399; this.setStatement(); } break; case 19: this.enterOuterAlt(localContext, 19); { - this.state = 396; + this.state = 400; this.shutdownStatement(); } break; case 20: this.enterOuterAlt(localContext, 20); { - this.state = 397; + this.state = 401; this.invalidateMetaStatement(); } break; case 21: this.enterOuterAlt(localContext, 21); { - this.state = 398; + this.state = 402; this.loadDataStatement(); } break; case 22: this.enterOuterAlt(localContext, 22); { - this.state = 399; + this.state = 403; this.refreshStatement(); } break; @@ -917,9 +920,9 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 402; + this.state = 406; this.match(ImpalaSqlParser.KW_USE); - this.state = 403; + this.state = 407; this.databaseNamePath(); } } @@ -941,62 +944,62 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new CreateStatementContext(this.context, this.state); this.enterRule(localContext, 8, ImpalaSqlParser.RULE_createStatement); try { - this.state = 413; + this.state = 417; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 405; + this.state = 409; this.createSchema(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 406; + this.state = 410; this.createRole(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 407; + this.state = 411; this.createAggregateFunction(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 408; + this.state = 412; this.createFunction(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 409; + this.state = 413; this.createView(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 410; + this.state = 414; this.createKuduTableAsSelect(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 411; + this.state = 415; this.createTableLike(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 412; + this.state = 416; this.createTableSelect(); } break; @@ -1024,97 +1027,97 @@ export class ImpalaSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 415; + this.state = 419; this.match(ImpalaSqlParser.KW_CREATE); - this.state = 417; + this.state = 421; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 19) { { - this.state = 416; + this.state = 420; this.match(ImpalaSqlParser.KW_EXTERNAL); } } - this.state = 419; + this.state = 423; this.match(ImpalaSqlParser.KW_TABLE); - this.state = 421; + this.state = 425; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 420; + this.state = 424; this.ifNotExists(); } } - this.state = 423; + this.state = 427; this.tableNameCreate(); - this.state = 439; + this.state = 443; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 8, this.context) ) { case 1: { - this.state = 424; + this.state = 428; this.match(ImpalaSqlParser.LPAREN); - this.state = 425; + this.state = 429; this.columnDefinition(); - this.state = 430; + this.state = 434; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 6, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 426; + this.state = 430; this.match(ImpalaSqlParser.COMMA); - this.state = 427; + this.state = 431; this.columnDefinition(); } } } - this.state = 432; + this.state = 436; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 6, this.context); } - this.state = 435; + this.state = 439; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 263) { { - this.state = 433; + this.state = 437; this.match(ImpalaSqlParser.COMMA); - this.state = 434; + this.state = 438; this.constraintSpecification(); } } - this.state = 437; + this.state = 441; this.match(ImpalaSqlParser.RPAREN); } break; } - this.state = 447; + this.state = 451; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 17) { { - this.state = 441; + this.state = 445; this.match(ImpalaSqlParser.KW_PARTITIONED); - this.state = 442; + this.state = 446; this.match(ImpalaSqlParser.KW_BY); - this.state = 445; + this.state = 449; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 9, this.context) ) { case 1: { - this.state = 443; + this.state = 447; this.columnAliases(); } break; case 2: { - this.state = 444; + this.state = 448; this.partitionedBy(); } break; @@ -1122,16 +1125,16 @@ export class ImpalaSqlParser extends SQLParserBase { } } - this.state = 449; + this.state = 453; this.createCommonItem(); - this.state = 452; + this.state = 456; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 450; + this.state = 454; this.match(ImpalaSqlParser.KW_AS); - this.state = 451; + this.state = 455; this.queryStatement(); } } @@ -1159,35 +1162,35 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 454; + this.state = 458; this.match(ImpalaSqlParser.KW_CREATE); - this.state = 456; + this.state = 460; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 19) { { - this.state = 455; + this.state = 459; this.match(ImpalaSqlParser.KW_EXTERNAL); } } - this.state = 458; + this.state = 462; this.match(ImpalaSqlParser.KW_TABLE); - this.state = 460; + this.state = 464; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 459; + this.state = 463; this.ifNotExists(); } } - this.state = 462; + this.state = 466; this.tableNameCreate(); - this.state = 463; - this.match(ImpalaSqlParser.KW_LIKE); this.state = 467; + this.match(ImpalaSqlParser.KW_LIKE); + this.state = 471; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_BERNOULLI: @@ -1229,36 +1232,36 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.DIGIT_IDENTIFIER: case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: { - this.state = 464; + this.state = 468; this.tableNamePath(); } break; case ImpalaSqlParser.KW_PARQUET: { - this.state = 465; + this.state = 469; this.match(ImpalaSqlParser.KW_PARQUET); - this.state = 466; + this.state = 470; localContext._parquet = this.stringLiteral(); } break; default: throw new antlr.NoViableAltException(this); } - this.state = 472; + this.state = 476; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 17) { { - this.state = 469; + this.state = 473; this.match(ImpalaSqlParser.KW_PARTITIONED); - this.state = 470; + this.state = 474; this.match(ImpalaSqlParser.KW_BY); - this.state = 471; + this.state = 475; this.partitionedBy(); } } - this.state = 474; + this.state = 478; this.createCommonItem(); } } @@ -1284,95 +1287,95 @@ export class ImpalaSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 476; + this.state = 480; this.match(ImpalaSqlParser.KW_CREATE); - this.state = 478; + this.state = 482; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 19) { { - this.state = 477; + this.state = 481; this.match(ImpalaSqlParser.KW_EXTERNAL); } } - this.state = 480; + this.state = 484; this.match(ImpalaSqlParser.KW_TABLE); - this.state = 482; + this.state = 486; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 481; + this.state = 485; this.ifNotExists(); } } - this.state = 484; + this.state = 488; this.tableNameCreate(); - this.state = 502; + this.state = 506; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 265) { { - this.state = 485; + this.state = 489; this.match(ImpalaSqlParser.LPAREN); - this.state = 486; + this.state = 490; this.kuduTableElement(); - this.state = 491; + this.state = 495; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 18, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 487; + this.state = 491; this.match(ImpalaSqlParser.COMMA); - this.state = 488; + this.state = 492; this.kuduTableElement(); } } } - this.state = 493; + this.state = 497; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 18, this.context); } - this.state = 498; + this.state = 502; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 263) { { - this.state = 494; + this.state = 498; this.match(ImpalaSqlParser.COMMA); - this.state = 495; + this.state = 499; this.match(ImpalaSqlParser.KW_PRIMARY); - this.state = 496; + this.state = 500; this.match(ImpalaSqlParser.KW_KEY); - this.state = 497; + this.state = 501; this.columnAliases(); } } - this.state = 500; + this.state = 504; this.match(ImpalaSqlParser.RPAREN); } } - this.state = 509; + this.state = 513; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 150) { { - this.state = 504; + this.state = 508; this.match(ImpalaSqlParser.KW_PRIMARY); - this.state = 505; + this.state = 509; this.match(ImpalaSqlParser.KW_KEY); - this.state = 507; + this.state = 511; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 265) { { - this.state = 506; + this.state = 510; this.columnAliases(); } } @@ -1380,58 +1383,56 @@ export class ImpalaSqlParser extends SQLParserBase { } } - this.state = 514; + this.state = 518; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 511; + this.state = 515; this.match(ImpalaSqlParser.KW_PARTITION); - this.state = 512; + this.state = 516; this.match(ImpalaSqlParser.KW_BY); - this.state = 513; + this.state = 517; this.kuduPartitionClause(); } } - this.state = 518; + this.state = 521; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 34) { { - this.state = 516; - this.match(ImpalaSqlParser.KW_COMMENT); - this.state = 517; - this.stringLiteral(); + this.state = 520; + this.commentClause(); } } - this.state = 520; + this.state = 523; this.match(ImpalaSqlParser.KW_STORED); - this.state = 521; + this.state = 524; this.match(ImpalaSqlParser.KW_AS); - this.state = 522; - this.match(ImpalaSqlParser.KW_KUDU); this.state = 525; + this.match(ImpalaSqlParser.KW_KUDU); + this.state = 528; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 25) { { - this.state = 523; + this.state = 526; this.match(ImpalaSqlParser.KW_TBLPROPERTIES); - this.state = 524; + this.state = 527; localContext._tblProp = this.properties(); } } - this.state = 529; + this.state = 532; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 527; + this.state = 530; this.match(ImpalaSqlParser.KW_AS); - this.state = 528; + this.state = 531; this.queryStatement(); } } @@ -1459,59 +1460,57 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 531; + this.state = 534; this.match(ImpalaSqlParser.KW_CREATE); - this.state = 532; + this.state = 535; this.match(ImpalaSqlParser.KW_VIEW); - this.state = 534; + this.state = 537; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 533; + this.state = 536; this.ifNotExists(); } } - this.state = 536; + this.state = 539; this.viewNameCreate(); - this.state = 538; + this.state = 541; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 265) { { - this.state = 537; + this.state = 540; this.viewColumns(); } } - this.state = 542; + this.state = 544; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 34) { { - this.state = 540; - this.match(ImpalaSqlParser.KW_COMMENT); - this.state = 541; - this.stringLiteral(); + this.state = 543; + this.commentClause(); } } - this.state = 546; + this.state = 548; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 25) { { - this.state = 544; + this.state = 546; this.match(ImpalaSqlParser.KW_TBLPROPERTIES); - this.state = 545; + this.state = 547; localContext._tblProp = this.properties(); } } - this.state = 548; + this.state = 550; this.match(ImpalaSqlParser.KW_AS); - this.state = 549; + this.state = 551; this.queryStatement(); } } @@ -1536,9 +1535,9 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 551; + this.state = 553; this.match(ImpalaSqlParser.KW_CREATE); - this.state = 552; + this.state = 554; _la = this.tokenStream.LA(1); if(!(_la === 46 || _la === 170)) { this.errorHandler.recoverInline(this); @@ -1547,38 +1546,36 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 554; + this.state = 556; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 553; + this.state = 555; this.ifNotExists(); } } - this.state = 556; + this.state = 558; this.databaseNameCreate(); - this.state = 559; + this.state = 560; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 32, this.context) ) { case 1: { - this.state = 557; - this.match(ImpalaSqlParser.KW_COMMENT); - this.state = 558; - localContext._comment = this.stringLiteral(); + this.state = 559; + this.commentClause(); } break; } - this.state = 563; + this.state = 564; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 24) { { - this.state = 561; - this.match(ImpalaSqlParser.KW_LOCATION); this.state = 562; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 563; localContext._location = this.stringLiteral(); } } @@ -1605,11 +1602,11 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 565; - this.match(ImpalaSqlParser.KW_CREATE); this.state = 566; - this.match(ImpalaSqlParser.KW_ROLE); + this.match(ImpalaSqlParser.KW_CREATE); this.state = 567; + this.match(ImpalaSqlParser.KW_ROLE); + this.state = 568; localContext._name = this.identifier(); } } @@ -1634,168 +1631,168 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 569; + this.state = 570; this.match(ImpalaSqlParser.KW_CREATE); - this.state = 571; + this.state = 572; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 12) { { - this.state = 570; + this.state = 571; this.match(ImpalaSqlParser.KW_AGGREGATE); } } - this.state = 573; + this.state = 574; this.match(ImpalaSqlParser.KW_FUNCTION); - this.state = 575; + this.state = 576; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 574; + this.state = 575; this.ifNotExists(); } } - this.state = 577; + this.state = 578; this.functionNameCreate(); - this.state = 590; + this.state = 591; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 265) { { - this.state = 578; + this.state = 579; this.match(ImpalaSqlParser.LPAREN); - this.state = 587; + this.state = 588; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 8 || _la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 4286652929) !== 0) || ((((_la - 236)) & ~0x1F) === 0 && ((1 << (_la - 236)) & 511) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 7873) !== 0)) { { - this.state = 579; + this.state = 580; this.type_(0); - this.state = 584; + this.state = 585; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 580; - this.match(ImpalaSqlParser.COMMA); this.state = 581; + this.match(ImpalaSqlParser.COMMA); + this.state = 582; this.type_(0); } } - this.state = 586; + this.state = 587; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 589; + this.state = 590; this.match(ImpalaSqlParser.RPAREN); } } - this.state = 592; - this.match(ImpalaSqlParser.KW_RETURNS); this.state = 593; - this.type_(0); - this.state = 596; + this.match(ImpalaSqlParser.KW_RETURNS); + this.state = 594; + localContext._returnType = this.type_(0); + this.state = 597; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 102) { { - this.state = 594; - this.match(ImpalaSqlParser.KW_INTERMEDIATE); this.state = 595; + this.match(ImpalaSqlParser.KW_INTERMEDIATE); + this.state = 596; this.type_(0); } } - this.state = 598; - this.match(ImpalaSqlParser.KW_LOCATION); this.state = 599; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 600; this.match(ImpalaSqlParser.STRING); - this.state = 603; + this.state = 604; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 104) { { - this.state = 600; - this.match(ImpalaSqlParser.KW_INIT_FN); this.state = 601; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_INIT_FN); this.state = 602; + this.match(ImpalaSqlParser.EQ); + this.state = 603; this.match(ImpalaSqlParser.STRING); } } - this.state = 605; - this.match(ImpalaSqlParser.KW_UPDATE_FN); this.state = 606; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_UPDATE_FN); this.state = 607; - this.match(ImpalaSqlParser.STRING); + this.match(ImpalaSqlParser.EQ); this.state = 608; - this.match(ImpalaSqlParser.KW_MERGE_FN); + this.match(ImpalaSqlParser.STRING); this.state = 609; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_MERGE_FN); this.state = 610; + this.match(ImpalaSqlParser.EQ); + this.state = 611; this.match(ImpalaSqlParser.STRING); - this.state = 614; + this.state = 615; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 18) { { - this.state = 611; - this.match(ImpalaSqlParser.KW_PREPARE_FN); this.state = 612; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_PREPARE_FN); this.state = 613; + this.match(ImpalaSqlParser.EQ); + this.state = 614; this.match(ImpalaSqlParser.STRING); } } - this.state = 619; + this.state = 620; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 20) { { - this.state = 616; - this.match(ImpalaSqlParser.KW_CLOSEFN); this.state = 617; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_CLOSEFN); this.state = 618; + this.match(ImpalaSqlParser.EQ); + this.state = 619; this.match(ImpalaSqlParser.STRING); } } - this.state = 624; + this.state = 625; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 187) { { - this.state = 621; - this.match(ImpalaSqlParser.KW_SERIALIZE_FN); this.state = 622; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_SERIALIZE_FN); this.state = 623; + this.match(ImpalaSqlParser.EQ); + this.state = 624; this.match(ImpalaSqlParser.STRING); } } - this.state = 629; + this.state = 630; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 76) { { - this.state = 626; - this.match(ImpalaSqlParser.KW_FINALIZE_FN); this.state = 627; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_FINALIZE_FN); this.state = 628; + this.match(ImpalaSqlParser.EQ); + this.state = 629; this.match(ImpalaSqlParser.STRING); } } @@ -1823,81 +1820,81 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 631; - this.match(ImpalaSqlParser.KW_CREATE); this.state = 632; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 633; this.match(ImpalaSqlParser.KW_FUNCTION); - this.state = 634; + this.state = 635; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 633; + this.state = 634; this.ifNotExists(); } } - this.state = 636; + this.state = 637; this.functionNameCreate(); - this.state = 649; + this.state = 650; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 265) { { - this.state = 637; + this.state = 638; this.match(ImpalaSqlParser.LPAREN); - this.state = 646; + this.state = 647; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 8 || _la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 4286652929) !== 0) || ((((_la - 236)) & ~0x1F) === 0 && ((1 << (_la - 236)) & 511) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 7873) !== 0)) { { - this.state = 638; + this.state = 639; this.type_(0); - this.state = 643; + this.state = 644; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 639; - this.match(ImpalaSqlParser.COMMA); this.state = 640; + this.match(ImpalaSqlParser.COMMA); + this.state = 641; this.type_(0); } } - this.state = 645; + this.state = 646; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 648; + this.state = 649; this.match(ImpalaSqlParser.RPAREN); } } - this.state = 653; + this.state = 654; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 160) { { - this.state = 651; - this.match(ImpalaSqlParser.KW_RETURNS); this.state = 652; - this.type_(0); + this.match(ImpalaSqlParser.KW_RETURNS); + this.state = 653; + localContext._returnType = this.type_(0); } } - this.state = 655; - this.match(ImpalaSqlParser.KW_LOCATION); this.state = 656; - this.match(ImpalaSqlParser.STRING); + this.match(ImpalaSqlParser.KW_LOCATION); this.state = 657; - this.match(ImpalaSqlParser.KW_SYMBOL); + this.match(ImpalaSqlParser.STRING); this.state = 658; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_SYMBOL); this.state = 659; + this.match(ImpalaSqlParser.EQ); + this.state = 660; localContext._symbol_ = this.stringLiteral(); } } @@ -1919,132 +1916,132 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new AlterStatementContext(this.context, this.state); this.enterRule(localContext, 26, ImpalaSqlParser.RULE_alterStatement); try { - this.state = 679; + this.state = 680; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 50, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 661; + this.state = 662; this.alterDatabase(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 662; + this.state = 663; this.alterUnSetOrSetViewTblproperties(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 663; + this.state = 664; this.renameTable(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 664; + this.state = 665; this.alterViewOwner(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 665; + this.state = 666; this.alterView(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 666; + this.state = 667; this.renameView(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 667; + this.state = 668; this.dropPartitionByRangeOrValue(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 668; + this.state = 669; this.alterFormat(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 669; + this.state = 670; this.recoverPartitions(); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 670; + this.state = 671; this.addPartitionByRangeOrValue(); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 671; + this.state = 672; this.alterTableNonKuduOrKuduOnly(); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 672; + this.state = 673; this.addSingleColumn(); } break; case 13: this.enterOuterAlt(localContext, 13); { - this.state = 673; + this.state = 674; this.replaceOrAddColumns(); } break; case 14: this.enterOuterAlt(localContext, 14); { - this.state = 674; + this.state = 675; this.changeColumnDefine(); } break; case 15: this.enterOuterAlt(localContext, 15); { - this.state = 675; + this.state = 676; this.alterStatsKey(); } break; case 16: this.enterOuterAlt(localContext, 16); { - this.state = 676; + this.state = 677; this.alterPartitionCache(); } break; case 17: this.enterOuterAlt(localContext, 17); { - this.state = 677; + this.state = 678; this.alterDropSingleColumn(); } break; case 18: this.enterOuterAlt(localContext, 18); { - this.state = 678; + this.state = 679; this.alterTableOwner(); } break; @@ -2071,17 +2068,17 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 681; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 682; - this.match(ImpalaSqlParser.KW_DATABASE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 683; - this.databaseNamePath(); + this.match(ImpalaSqlParser.KW_DATABASE); this.state = 684; - this.match(ImpalaSqlParser.KW_SET); + this.databaseNamePath(); this.state = 685; - this.match(ImpalaSqlParser.KW_OWNER); + this.match(ImpalaSqlParser.KW_SET); this.state = 686; + this.match(ImpalaSqlParser.KW_OWNER); + this.state = 687; _la = this.tokenStream.LA(1); if(!(_la === 166 || _la === 204)) { this.errorHandler.recoverInline(this); @@ -2090,7 +2087,7 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 687; + this.state = 688; this.identifier(); } } @@ -2115,45 +2112,45 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 689; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 690; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 691; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 692; - this.match(ImpalaSqlParser.KW_SET); + this.tableNamePath(); this.state = 693; - this.match(ImpalaSqlParser.KW_COLUMN); + this.match(ImpalaSqlParser.KW_SET); this.state = 694; - this.match(ImpalaSqlParser.KW_STATS); + this.match(ImpalaSqlParser.KW_COLUMN); this.state = 695; - this.columnNamePath(); + this.match(ImpalaSqlParser.KW_STATS); this.state = 696; - this.match(ImpalaSqlParser.LPAREN); + this.columnNamePath(); this.state = 697; - this.statsKey(); + this.match(ImpalaSqlParser.LPAREN); this.state = 698; - this.match(ImpalaSqlParser.EQ); + this.statsKey(); this.state = 699; + this.match(ImpalaSqlParser.EQ); + this.state = 700; this.stringLiteral(); - this.state = 705; + this.state = 706; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 263) { { - this.state = 700; - this.match(ImpalaSqlParser.COMMA); this.state = 701; - this.statsKey(); + this.match(ImpalaSqlParser.COMMA); this.state = 702; - this.match(ImpalaSqlParser.EQ); + this.statsKey(); this.state = 703; + this.match(ImpalaSqlParser.EQ); + this.state = 704; this.stringLiteral(); } } - this.state = 707; + this.state = 708; this.match(ImpalaSqlParser.RPAREN); } } @@ -2178,50 +2175,50 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 709; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 710; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 711; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 712; this.tableNamePath(); - this.state = 714; + this.state = 715; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 712; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 713; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 714; this.expression(); } } - this.state = 716; + this.state = 717; this.match(ImpalaSqlParser.KW_SET); - this.state = 727; + this.state = 728; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_CACHED: { { - this.state = 717; - this.match(ImpalaSqlParser.KW_CACHED); this.state = 718; - this.match(ImpalaSqlParser.KW_IN); + this.match(ImpalaSqlParser.KW_CACHED); this.state = 719; + this.match(ImpalaSqlParser.KW_IN); + this.state = 720; this.stringLiteral(); - this.state = 724; + this.state = 725; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 53, this.context) ) { case 1: { - this.state = 720; - this.match(ImpalaSqlParser.KW_WITH); this.state = 721; - this.match(ImpalaSqlParser.KW_REPLICATION); + this.match(ImpalaSqlParser.KW_WITH); this.state = 722; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_REPLICATION); this.state = 723; + this.match(ImpalaSqlParser.EQ); + this.state = 724; this.number_(); } break; @@ -2231,7 +2228,7 @@ export class ImpalaSqlParser extends SQLParserBase { break; case ImpalaSqlParser.KW_UNCACHED: { - this.state = 726; + this.state = 727; this.match(ImpalaSqlParser.KW_UNCACHED); } break; @@ -2260,17 +2257,17 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 729; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 730; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 731; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 732; - this.match(ImpalaSqlParser.KW_CHANGE); + this.tableNamePath(); this.state = 733; - this.columnNamePath(); + this.match(ImpalaSqlParser.KW_CHANGE); this.state = 734; + this.columnNamePath(); + this.state = 735; this.columnSpecWithKudu(); } } @@ -2294,25 +2291,25 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 736; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 737; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 738; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 739; + this.tableNamePath(); + this.state = 740; this.match(ImpalaSqlParser.KW_DROP); - this.state = 741; + this.state = 742; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 55, this.context) ) { case 1: { - this.state = 740; + this.state = 741; this.match(ImpalaSqlParser.KW_COLUMN); } break; } - this.state = 743; + this.state = 744; this.columnNamePath(); } } @@ -2337,17 +2334,17 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 745; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 746; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 747; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 748; - this.match(ImpalaSqlParser.KW_SET); + this.tableNamePath(); this.state = 749; - this.match(ImpalaSqlParser.KW_OWNER); + this.match(ImpalaSqlParser.KW_SET); this.state = 750; + this.match(ImpalaSqlParser.KW_OWNER); + this.state = 751; _la = this.tokenStream.LA(1); if(!(_la === 166 || _la === 204)) { this.errorHandler.recoverInline(this); @@ -2356,7 +2353,7 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 751; + this.state = 752; this.identifier(); } } @@ -2382,31 +2379,31 @@ export class ImpalaSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 753; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 754; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 755; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 756; this.tableNamePath(); - this.state = 761; + this.state = 762; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_REPLACE: { - this.state = 756; + this.state = 757; this.match(ImpalaSqlParser.KW_REPLACE); } break; case ImpalaSqlParser.KW_ADD: { - this.state = 757; + this.state = 758; this.match(ImpalaSqlParser.KW_ADD); - this.state = 759; + this.state = 760; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 758; + this.state = 759; this.ifNotExists(); } } @@ -2416,31 +2413,31 @@ export class ImpalaSqlParser extends SQLParserBase { default: throw new antlr.NoViableAltException(this); } - this.state = 763; - this.match(ImpalaSqlParser.KW_COLUMNS); this.state = 764; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_COLUMNS); this.state = 765; + this.match(ImpalaSqlParser.LPAREN); + this.state = 766; this.columnSpecWithKudu(); - this.state = 770; + this.state = 771; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 58, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 766; - this.match(ImpalaSqlParser.COMMA); this.state = 767; + this.match(ImpalaSqlParser.COMMA); + this.state = 768; this.columnSpecWithKudu(); } } } - this.state = 772; + this.state = 773; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 58, this.context); } - this.state = 773; + this.state = 774; this.match(ImpalaSqlParser.RPAREN); } } @@ -2465,27 +2462,27 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 775; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 776; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 777; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 778; - this.match(ImpalaSqlParser.KW_ADD); + this.tableNamePath(); this.state = 779; + this.match(ImpalaSqlParser.KW_ADD); + this.state = 780; this.match(ImpalaSqlParser.KW_COLUMN); - this.state = 781; + this.state = 782; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 780; + this.state = 781; this.ifNotExists(); } } - this.state = 783; + this.state = 784; this.createColumnSpecWithKudu(); } } @@ -2509,34 +2506,34 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 785; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 786; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 787; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 788; + this.tableNamePath(); + this.state = 789; this.match(ImpalaSqlParser.KW_ALTER); - this.state = 790; + this.state = 791; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 60, this.context) ) { case 1: { - this.state = 789; + this.state = 790; this.match(ImpalaSqlParser.KW_COLUMN); } break; } - this.state = 792; + this.state = 793; this.columnNamePath(); - this.state = 801; + this.state = 802; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_SET: { - this.state = 793; + this.state = 794; this.match(ImpalaSqlParser.KW_SET); - this.state = 797; + this.state = 798; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_BLOCK_SIZE: @@ -2544,15 +2541,15 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.KW_DEFAULT: case ImpalaSqlParser.KW_ENCODING: { - this.state = 794; + this.state = 795; this.kuduStorageAttr(); } break; case ImpalaSqlParser.KW_COMMENT: { - this.state = 795; - this.match(ImpalaSqlParser.KW_COMMENT); this.state = 796; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 797; this.stringLiteral(); } break; @@ -2563,9 +2560,9 @@ export class ImpalaSqlParser extends SQLParserBase { break; case ImpalaSqlParser.KW_DROP: { - this.state = 799; - this.match(ImpalaSqlParser.KW_DROP); this.state = 800; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 801; this.match(ImpalaSqlParser.KW_DEFAULT); } break; @@ -2595,51 +2592,51 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 803; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 804; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 805; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 806; + this.tableNamePath(); + this.state = 807; this.match(ImpalaSqlParser.KW_ADD); - this.state = 808; + this.state = 809; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 807; + this.state = 808; this.ifNotExists(); } } - this.state = 822; + this.state = 823; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_PARTITION: { - this.state = 810; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 811; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 812; this.expression(); - this.state = 814; + this.state = 815; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 24) { { - this.state = 812; - this.match(ImpalaSqlParser.KW_LOCATION); this.state = 813; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 814; this.stringLiteral(); } } - this.state = 817; + this.state = 818; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 30 || _la === 197) { { - this.state = 816; + this.state = 817; this.cacheSpec(); } } @@ -2648,11 +2645,11 @@ export class ImpalaSqlParser extends SQLParserBase { break; case ImpalaSqlParser.KW_RANGE: { - this.state = 819; - this.match(ImpalaSqlParser.KW_RANGE); this.state = 820; - this.match(ImpalaSqlParser.KW_PARTITION); + this.match(ImpalaSqlParser.KW_RANGE); this.state = 821; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 822; this.kuduPartitionSpec(); } break; @@ -2682,35 +2679,35 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 824; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 825; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 826; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 827; this.tableNamePath(); - this.state = 829; + this.state = 830; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 827; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 828; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 829; this.expression(); } } - this.state = 831; + this.state = 832; this.match(ImpalaSqlParser.KW_SET); - this.state = 843; + this.state = 844; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_FILEFORMAT: { { - this.state = 832; - this.match(ImpalaSqlParser.KW_FILEFORMAT); this.state = 833; + this.match(ImpalaSqlParser.KW_FILEFORMAT); + this.state = 834; this.fileFormat(); } } @@ -2718,11 +2715,11 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.KW_ROW: { { - this.state = 834; - this.match(ImpalaSqlParser.KW_ROW); this.state = 835; - this.match(ImpalaSqlParser.KW_FORMAT); + this.match(ImpalaSqlParser.KW_ROW); this.state = 836; + this.match(ImpalaSqlParser.KW_FORMAT); + this.state = 837; this.rowFormat(); } } @@ -2730,9 +2727,9 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.KW_LOCATION: { { - this.state = 837; - this.match(ImpalaSqlParser.KW_LOCATION); this.state = 838; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 839; this.stringLiteral(); } } @@ -2740,9 +2737,9 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.KW_TBLPROPERTIES: { { - this.state = 839; - this.match(ImpalaSqlParser.KW_TBLPROPERTIES); this.state = 840; + this.match(ImpalaSqlParser.KW_TBLPROPERTIES); + this.state = 841; localContext._tblProp = this.properties(); } } @@ -2750,9 +2747,9 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.KW_SERDEPROPERTIES: { { - this.state = 841; - this.match(ImpalaSqlParser.KW_SERDEPROPERTIES); this.state = 842; + this.match(ImpalaSqlParser.KW_SERDEPROPERTIES); + this.state = 843; localContext._tblProp = this.properties(); } } @@ -2782,15 +2779,15 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 845; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 846; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 847; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 848; - this.match(ImpalaSqlParser.KW_RECOVER); + this.tableNamePath(); this.state = 849; + this.match(ImpalaSqlParser.KW_RECOVER); + this.state = 850; this.match(ImpalaSqlParser.KW_PARTITIONS); } } @@ -2815,39 +2812,39 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 851; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 852; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 853; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 854; + this.tableNamePath(); + this.state = 855; this.match(ImpalaSqlParser.KW_DROP); - this.state = 856; + this.state = 857; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 855; + this.state = 856; this.ifExists(); } } - this.state = 866; + this.state = 867; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_PARTITION: { - this.state = 858; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 859; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 860; this.expression(); - this.state = 861; + this.state = 862; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 22) { { - this.state = 860; + this.state = 861; this.match(ImpalaSqlParser.KW_PURGE); } } @@ -2856,11 +2853,11 @@ export class ImpalaSqlParser extends SQLParserBase { break; case ImpalaSqlParser.KW_RANGE: { - this.state = 863; - this.match(ImpalaSqlParser.KW_RANGE); this.state = 864; - this.match(ImpalaSqlParser.KW_PARTITION); + this.match(ImpalaSqlParser.KW_RANGE); this.state = 865; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 866; this.kuduPartitionSpec(); } break; @@ -2890,25 +2887,25 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 868; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 869; - this.match(ImpalaSqlParser.KW_VIEW); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 870; + this.match(ImpalaSqlParser.KW_VIEW); + this.state = 871; this.viewNamePath(); - this.state = 872; + this.state = 873; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 265) { { - this.state = 871; + this.state = 872; this.viewColumns(); } } - this.state = 874; - this.match(ImpalaSqlParser.KW_AS); this.state = 875; + this.match(ImpalaSqlParser.KW_AS); + this.state = 876; this.queryStatement(); } } @@ -2932,17 +2929,17 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 877; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 878; - this.match(ImpalaSqlParser.KW_VIEW); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 879; - this.viewNamePath(); + this.match(ImpalaSqlParser.KW_VIEW); this.state = 880; - this.match(ImpalaSqlParser.KW_RENAME); + this.viewNamePath(); this.state = 881; - this.match(ImpalaSqlParser.KW_TO); + this.match(ImpalaSqlParser.KW_RENAME); this.state = 882; + this.match(ImpalaSqlParser.KW_TO); + this.state = 883; this.viewNamePath(); } } @@ -2967,17 +2964,17 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 884; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 885; - this.match(ImpalaSqlParser.KW_VIEW); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 886; - this.viewNamePath(); + this.match(ImpalaSqlParser.KW_VIEW); this.state = 887; - this.match(ImpalaSqlParser.KW_SET); + this.viewNamePath(); this.state = 888; - this.match(ImpalaSqlParser.KW_OWNER); + this.match(ImpalaSqlParser.KW_SET); this.state = 889; + this.match(ImpalaSqlParser.KW_OWNER); + this.state = 890; _la = this.tokenStream.LA(1); if(!(_la === 166 || _la === 204)) { this.errorHandler.recoverInline(this); @@ -2986,7 +2983,7 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 890; + this.state = 891; this.qualifiedName(); } } @@ -3010,17 +3007,17 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 892; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 893; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 894; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 895; - this.match(ImpalaSqlParser.KW_RENAME); + this.tableNamePath(); this.state = 896; - this.match(ImpalaSqlParser.KW_TO); + this.match(ImpalaSqlParser.KW_RENAME); this.state = 897; + this.match(ImpalaSqlParser.KW_TO); + this.state = 898; this.tableNamePath(); } } @@ -3045,13 +3042,13 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 899; - this.match(ImpalaSqlParser.KW_ALTER); this.state = 900; - this.match(ImpalaSqlParser.KW_VIEW); + this.match(ImpalaSqlParser.KW_ALTER); this.state = 901; - this.viewNamePath(); + this.match(ImpalaSqlParser.KW_VIEW); this.state = 902; + this.viewNamePath(); + this.state = 903; _la = this.tokenStream.LA(1); if(!(_la === 176 || _la === 202)) { this.errorHandler.recoverInline(this); @@ -3060,9 +3057,9 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 903; - this.match(ImpalaSqlParser.KW_TBLPROPERTIES); this.state = 904; + this.match(ImpalaSqlParser.KW_TBLPROPERTIES); + this.state = 905; localContext._tblProp = this.properties(); } } @@ -3087,29 +3084,29 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 906; + this.state = 907; this.match(ImpalaSqlParser.KW_TRUNCATE); - this.state = 908; + this.state = 909; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 188) { { - this.state = 907; + this.state = 908; this.match(ImpalaSqlParser.KW_TABLE); } } - this.state = 911; + this.state = 912; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 910; + this.state = 911; this.ifExists(); } } - this.state = 913; + this.state = 914; this.tableNamePath(); } } @@ -3134,24 +3131,24 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 915; + this.state = 916; this.match(ImpalaSqlParser.KW_DESCRIBE); - this.state = 917; + this.state = 918; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 46) { { - this.state = 916; + this.state = 917; this.match(ImpalaSqlParser.KW_DATABASE); } } - this.state = 920; + this.state = 921; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 69 || _la === 80) { { - this.state = 919; + this.state = 920; _la = this.tokenStream.LA(1); if(!(_la === 69 || _la === 80)) { this.errorHandler.recoverInline(this); @@ -3163,7 +3160,7 @@ export class ImpalaSqlParser extends SQLParserBase { } } - this.state = 922; + this.state = 923; this.qualifiedName(); } } @@ -3185,20 +3182,20 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new ComputeStatementContext(this.context, this.state); this.enterRule(localContext, 68, ImpalaSqlParser.RULE_computeStatement); try { - this.state = 926; + this.state = 927; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 77, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 924; + this.state = 925; this.computeStats(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 925; + this.state = 926; this.computeIncrementalStats(); } break; @@ -3225,49 +3222,49 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 928; - this.match(ImpalaSqlParser.KW_COMPUTE); this.state = 929; - this.match(ImpalaSqlParser.KW_STATS); + this.match(ImpalaSqlParser.KW_COMPUTE); this.state = 930; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 931; this.tableNamePath(); - this.state = 932; + this.state = 933; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 78, this.context) ) { case 1: { - this.state = 931; + this.state = 932; this.columnAliases(); } break; } - this.state = 946; + this.state = 947; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 190) { { - this.state = 934; - this.match(ImpalaSqlParser.KW_TABLESAMPLE); this.state = 935; - this.match(ImpalaSqlParser.KW_SYSTEM); + this.match(ImpalaSqlParser.KW_TABLESAMPLE); this.state = 936; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_SYSTEM); this.state = 937; - this.number_(); + this.match(ImpalaSqlParser.LPAREN); this.state = 938; + this.number_(); + this.state = 939; this.match(ImpalaSqlParser.RPAREN); - this.state = 944; + this.state = 945; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 157) { { - this.state = 939; - this.match(ImpalaSqlParser.KW_REPEATABLE); this.state = 940; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_REPEATABLE); this.state = 941; - this.number_(); + this.match(ImpalaSqlParser.LPAREN); this.state = 942; + this.number_(); + this.state = 943; this.match(ImpalaSqlParser.RPAREN); } } @@ -3298,26 +3295,26 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 948; - this.match(ImpalaSqlParser.KW_COMPUTE); this.state = 949; - this.match(ImpalaSqlParser.KW_INCREMENTAL); + this.match(ImpalaSqlParser.KW_COMPUTE); this.state = 950; - this.match(ImpalaSqlParser.KW_STATS); + this.match(ImpalaSqlParser.KW_INCREMENTAL); this.state = 951; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 952; this.tableNamePath(); - this.state = 957; + this.state = 958; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 952; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 953; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_PARTITION); this.state = 954; - this.expression(); + this.match(ImpalaSqlParser.LPAREN); this.state = 955; + this.expression(); + this.state = 956; this.match(ImpalaSqlParser.RPAREN); } } @@ -3342,48 +3339,48 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new DropStatementContext(this.context, this.state); this.enterRule(localContext, 74, ImpalaSqlParser.RULE_dropStatement); try { - this.state = 965; + this.state = 966; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 82, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 959; + this.state = 960; this.dropRole(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 960; + this.state = 961; this.dropFunction(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 961; + this.state = 962; this.dropIncrementalStats(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 962; + this.state = 963; this.dropView(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 963; + this.state = 964; this.dropTable(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 964; + this.state = 965; this.dropSchema(); } break; @@ -3410,9 +3407,9 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 967; - this.match(ImpalaSqlParser.KW_DROP); this.state = 968; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 969; _la = this.tokenStream.LA(1); if(!(_la === 46 || _la === 170)) { this.errorHandler.recoverInline(this); @@ -3421,24 +3418,24 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 970; + this.state = 971; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 969; + this.state = 970; this.ifExists(); } } - this.state = 972; + this.state = 973; this.databaseNamePath(); - this.state = 974; + this.state = 975; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 27 || _la === 159) { { - this.state = 973; + this.state = 974; _la = this.tokenStream.LA(1); if(!(_la === 27 || _la === 159)) { this.errorHandler.recoverInline(this); @@ -3473,21 +3470,21 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 976; - this.match(ImpalaSqlParser.KW_DROP); this.state = 977; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 978; this.match(ImpalaSqlParser.KW_VIEW); - this.state = 979; + this.state = 980; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 978; + this.state = 979; this.ifExists(); } } - this.state = 981; + this.state = 982; this.viewNamePath(); } } @@ -3512,28 +3509,28 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 983; - this.match(ImpalaSqlParser.KW_DROP); this.state = 984; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 985; this.match(ImpalaSqlParser.KW_TABLE); - this.state = 986; + this.state = 987; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 985; + this.state = 986; this.ifExists(); } } - this.state = 988; + this.state = 989; this.tableNamePath(); - this.state = 990; + this.state = 991; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 22) { { - this.state = 989; + this.state = 990; this.match(ImpalaSqlParser.KW_PURGE); } } @@ -3561,30 +3558,30 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 992; + this.state = 993; this.match(ImpalaSqlParser.KW_DROP); - this.state = 994; + this.state = 995; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 96) { { - this.state = 993; + this.state = 994; this.match(ImpalaSqlParser.KW_INCREMENTAL); } } - this.state = 996; - this.match(ImpalaSqlParser.KW_STATS); this.state = 997; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 998; this.tableNamePath(); - this.state = 1000; + this.state = 1001; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 998; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 999; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 1000; this.expression(); } } @@ -3612,66 +3609,66 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1002; + this.state = 1003; this.match(ImpalaSqlParser.KW_DROP); - this.state = 1004; + this.state = 1005; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 12) { { - this.state = 1003; + this.state = 1004; this.match(ImpalaSqlParser.KW_AGGREGATE); } } - this.state = 1006; + this.state = 1007; this.match(ImpalaSqlParser.KW_FUNCTION); - this.state = 1008; + this.state = 1009; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 93) { { - this.state = 1007; + this.state = 1008; this.ifExists(); } } - this.state = 1010; + this.state = 1011; this.functionNamePath(); - this.state = 1023; + this.state = 1024; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 94, this.context) ) { case 1: { - this.state = 1011; + this.state = 1012; this.match(ImpalaSqlParser.LPAREN); - this.state = 1020; + this.state = 1021; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 8 || _la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 4286652929) !== 0) || ((((_la - 236)) & ~0x1F) === 0 && ((1 << (_la - 236)) & 511) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 7873) !== 0)) { { - this.state = 1012; + this.state = 1013; this.type_(0); - this.state = 1017; + this.state = 1018; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 1013; - this.match(ImpalaSqlParser.COMMA); this.state = 1014; + this.match(ImpalaSqlParser.COMMA); + this.state = 1015; this.type_(0); } } - this.state = 1019; + this.state = 1020; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 1022; + this.state = 1023; this.match(ImpalaSqlParser.RPAREN); } break; @@ -3698,11 +3695,11 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1025; - this.match(ImpalaSqlParser.KW_DROP); this.state = 1026; - this.match(ImpalaSqlParser.KW_ROLE); + this.match(ImpalaSqlParser.KW_DROP); this.state = 1027; + this.match(ImpalaSqlParser.KW_ROLE); + this.state = 1028; localContext._name = this.identifier(); } } @@ -3724,20 +3721,20 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new GrantStatementContext(this.context, this.state); this.enterRule(localContext, 88, ImpalaSqlParser.RULE_grantStatement); try { - this.state = 1031; + this.state = 1032; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 95, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1029; + this.state = 1030; this.grantRole(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1030; + this.state = 1031; this.grant(); } break; @@ -3763,17 +3760,17 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1033; - this.match(ImpalaSqlParser.KW_GRANT); this.state = 1034; - this.match(ImpalaSqlParser.KW_ROLE); + this.match(ImpalaSqlParser.KW_GRANT); this.state = 1035; - this.identifier(); + this.match(ImpalaSqlParser.KW_ROLE); this.state = 1036; - this.match(ImpalaSqlParser.KW_TO); + this.identifier(); this.state = 1037; - this.match(ImpalaSqlParser.KW_GROUP); + this.match(ImpalaSqlParser.KW_TO); this.state = 1038; + this.match(ImpalaSqlParser.KW_GROUP); + this.state = 1039; this.identifier(); } } @@ -3798,27 +3795,27 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1040; - this.match(ImpalaSqlParser.KW_GRANT); this.state = 1041; - this.privilege(); + this.match(ImpalaSqlParser.KW_GRANT); this.state = 1042; - this.match(ImpalaSqlParser.KW_ON); + this.privilege(); this.state = 1043; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1044; this.objectType(); - this.state = 1045; + this.state = 1046; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 1044; + this.state = 1045; this.qualifiedName(); } } - this.state = 1047; - this.match(ImpalaSqlParser.KW_TO); this.state = 1048; + this.match(ImpalaSqlParser.KW_TO); + this.state = 1049; localContext._grantee = this.principal(); } } @@ -3840,20 +3837,20 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new RevokeStatementContext(this.context, this.state); this.enterRule(localContext, 94, ImpalaSqlParser.RULE_revokeStatement); try { - this.state = 1052; + this.state = 1053; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 97, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1050; + this.state = 1051; this.revokeRole(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1051; + this.state = 1052; this.revoke(); } break; @@ -3879,17 +3876,17 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1054; - this.match(ImpalaSqlParser.KW_REVOKE); this.state = 1055; - this.match(ImpalaSqlParser.KW_ROLE); + this.match(ImpalaSqlParser.KW_REVOKE); this.state = 1056; - this.identifier(); + this.match(ImpalaSqlParser.KW_ROLE); this.state = 1057; - this.match(ImpalaSqlParser.KW_FROM); + this.identifier(); this.state = 1058; - this.match(ImpalaSqlParser.KW_GROUP); + this.match(ImpalaSqlParser.KW_FROM); this.state = 1059; + this.match(ImpalaSqlParser.KW_GROUP); + this.state = 1060; this.identifier(); } } @@ -3914,62 +3911,62 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1061; + this.state = 1062; this.match(ImpalaSqlParser.KW_REVOKE); - this.state = 1065; + this.state = 1066; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 86) { { - this.state = 1062; - this.match(ImpalaSqlParser.KW_GRANT); this.state = 1063; - this.match(ImpalaSqlParser.KW_OPTION); + this.match(ImpalaSqlParser.KW_GRANT); this.state = 1064; + this.match(ImpalaSqlParser.KW_OPTION); + this.state = 1065; this.match(ImpalaSqlParser.KW_FOR); } } - this.state = 1067; - this.privilege(); this.state = 1068; - this.match(ImpalaSqlParser.KW_ON); + this.privilege(); this.state = 1069; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1070; this.objectType(); - this.state = 1071; + this.state = 1072; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 1070; + this.state = 1071; this.qualifiedName(); } } - this.state = 1073; + this.state = 1074; this.match(ImpalaSqlParser.KW_FROM); - this.state = 1079; + this.state = 1080; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 101, this.context) ) { case 1: { - this.state = 1074; + this.state = 1075; localContext._grantee = this.principal(); } break; case 2: { - this.state = 1076; + this.state = 1077; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 166) { { - this.state = 1075; + this.state = 1076; this.match(ImpalaSqlParser.KW_ROLE); } } - this.state = 1078; + this.state = 1079; this.identifier(); } break; @@ -3997,19 +3994,19 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1082; + this.state = 1083; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 216) { { - this.state = 1081; + this.state = 1082; this.with_(); } } - this.state = 1084; - this.match(ImpalaSqlParser.KW_INSERT); this.state = 1085; + this.match(ImpalaSqlParser.KW_INSERT); + this.state = 1086; _la = this.tokenStream.LA(1); if(!(_la === 103 || _la === 144)) { this.errorHandler.recoverInline(this); @@ -4018,61 +4015,61 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1087; + this.state = 1088; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 188) { { - this.state = 1086; + this.state = 1087; this.match(ImpalaSqlParser.KW_TABLE); } } - this.state = 1089; + this.state = 1090; this.tableNamePath(); - this.state = 1091; + this.state = 1092; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 104, this.context) ) { case 1: { - this.state = 1090; + this.state = 1091; this.columnAliases(); } break; } - this.state = 1105; + this.state = 1106; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 1093; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 1094; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_PARTITION); this.state = 1095; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1096; this.expression(); - this.state = 1100; + this.state = 1101; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 1096; - this.match(ImpalaSqlParser.COMMA); this.state = 1097; + this.match(ImpalaSqlParser.COMMA); + this.state = 1098; this.expression(); } } - this.state = 1102; + this.state = 1103; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1103; + this.state = 1104; this.match(ImpalaSqlParser.RPAREN); } } - this.state = 1107; + this.state = 1108; this.queryStatement(); } } @@ -4094,20 +4091,20 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new DeleteStatementContext(this.context, this.state); this.enterRule(localContext, 102, ImpalaSqlParser.RULE_deleteStatement); try { - this.state = 1111; + this.state = 1112; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 107, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1109; + this.state = 1110; this.delete_(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1110; + this.state = 1111; this.deleteTableRef(); } break; @@ -4134,28 +4131,28 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1113; + this.state = 1114; this.match(ImpalaSqlParser.KW_DELETE); - this.state = 1115; + this.state = 1116; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 82) { { - this.state = 1114; + this.state = 1115; this.match(ImpalaSqlParser.KW_FROM); } } - this.state = 1117; + this.state = 1118; this.tableNamePath(); - this.state = 1120; + this.state = 1121; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 215) { { - this.state = 1118; - this.match(ImpalaSqlParser.KW_WHERE); this.state = 1119; + this.match(ImpalaSqlParser.KW_WHERE); + this.state = 1120; this.booleanExpression(0); } } @@ -4183,66 +4180,66 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1122; - this.match(ImpalaSqlParser.KW_DELETE); this.state = 1123; + this.match(ImpalaSqlParser.KW_DELETE); + this.state = 1124; this.tableNamePath(); - this.state = 1128; + this.state = 1129; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9 || _la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 1125; + this.state = 1126; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 1124; + this.state = 1125; this.match(ImpalaSqlParser.KW_AS); } } - this.state = 1127; + this.state = 1128; this.identifier(); } } - this.state = 1130; + this.state = 1131; this.match(ImpalaSqlParser.KW_FROM); - this.state = 1139; + this.state = 1140; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 113, this.context) ) { case 1: { - this.state = 1131; + this.state = 1132; this.relation(0); - this.state = 1136; + this.state = 1137; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 1132; - this.match(ImpalaSqlParser.COMMA); this.state = 1133; + this.match(ImpalaSqlParser.COMMA); + this.state = 1134; this.relation(0); } } - this.state = 1138; + this.state = 1139; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } break; } - this.state = 1143; + this.state = 1144; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 215) { { - this.state = 1141; - this.match(ImpalaSqlParser.KW_WHERE); this.state = 1142; + this.match(ImpalaSqlParser.KW_WHERE); + this.state = 1143; this.booleanExpression(0); } } @@ -4270,50 +4267,50 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1145; - this.match(ImpalaSqlParser.KW_UPDATE); this.state = 1146; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_UPDATE); this.state = 1147; - this.match(ImpalaSqlParser.KW_SET); + this.tableNamePath(); this.state = 1148; + this.match(ImpalaSqlParser.KW_SET); + this.state = 1149; this.assignmentList(); - this.state = 1158; + this.state = 1159; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 82) { { - this.state = 1149; - this.match(ImpalaSqlParser.KW_FROM); this.state = 1150; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 1151; this.relation(0); - this.state = 1155; + this.state = 1156; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 1151; - this.match(ImpalaSqlParser.COMMA); this.state = 1152; + this.match(ImpalaSqlParser.COMMA); + this.state = 1153; this.relation(0); } } - this.state = 1157; + this.state = 1158; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 1162; + this.state = 1163; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 215) { { - this.state = 1160; - this.match(ImpalaSqlParser.KW_WHERE); this.state = 1161; + this.match(ImpalaSqlParser.KW_WHERE); + this.state = 1162; this.booleanExpression(0); } } @@ -4341,33 +4338,33 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1164; - this.match(ImpalaSqlParser.KW_UPSERT); this.state = 1165; + this.match(ImpalaSqlParser.KW_UPSERT); + this.state = 1166; this.match(ImpalaSqlParser.KW_INTO); - this.state = 1167; + this.state = 1168; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 188) { { - this.state = 1166; + this.state = 1167; this.match(ImpalaSqlParser.KW_TABLE); } } - this.state = 1169; + this.state = 1170; this.tableNamePath(); - this.state = 1171; + this.state = 1172; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 119, this.context) ) { case 1: { - this.state = 1170; + this.state = 1171; this.columnAliases(); } break; } - this.state = 1173; + this.state = 1174; this.queryStatement(); } } @@ -4389,90 +4386,90 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new ShowStatementContext(this.context, this.state); this.enterRule(localContext, 112, ImpalaSqlParser.RULE_showStatement); try { - this.state = 1187; + this.state = 1188; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 120, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1175; + this.state = 1176; this.showRoles(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1176; + this.state = 1177; this.showRoleGrant(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1177; + this.state = 1178; this.showGrants(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1178; + this.state = 1179; this.showFiles(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 1179; + this.state = 1180; this.showPartitions(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 1180; + this.state = 1181; this.showColumnStats(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 1181; + this.state = 1182; this.showTableStats(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 1182; + this.state = 1183; this.showCreateView(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 1183; + this.state = 1184; this.showCreateTable(); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 1184; + this.state = 1185; this.showFunctions(); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 1185; + this.state = 1186; this.showTables(); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 1186; + this.state = 1187; this.showSchemas(); } break; @@ -4499,9 +4496,9 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1189; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1190; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1191; _la = this.tokenStream.LA(1); if(!(_la === 47 || _la === 171)) { this.errorHandler.recoverInline(this); @@ -4510,36 +4507,36 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1202; + this.state = 1203; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 115 || _la === 274 || _la === 275) { { - this.state = 1192; + this.state = 1193; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 115) { { - this.state = 1191; + this.state = 1192; this.match(ImpalaSqlParser.KW_LIKE); } } - this.state = 1194; + this.state = 1195; localContext._pattern = this.stringLiteral(); - this.state = 1199; + this.state = 1200; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 271) { { { - this.state = 1195; - this.match(ImpalaSqlParser.BITWISEOR); this.state = 1196; + this.match(ImpalaSqlParser.BITWISEOR); + this.state = 1197; this.stringLiteral(); } } - this.state = 1201; + this.state = 1202; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -4569,52 +4566,52 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1204; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1205; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1206; this.match(ImpalaSqlParser.KW_TABLES); - this.state = 1208; + this.state = 1209; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 94) { { - this.state = 1206; - this.match(ImpalaSqlParser.KW_IN); this.state = 1207; + this.match(ImpalaSqlParser.KW_IN); + this.state = 1208; this.tableNamePath(); } } - this.state = 1221; + this.state = 1222; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 115 || _la === 274 || _la === 275) { { - this.state = 1211; + this.state = 1212; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 115) { { - this.state = 1210; + this.state = 1211; this.match(ImpalaSqlParser.KW_LIKE); } } - this.state = 1213; + this.state = 1214; localContext._pattern = this.stringLiteral(); - this.state = 1218; + this.state = 1219; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 271) { { { - this.state = 1214; - this.match(ImpalaSqlParser.BITWISEOR); this.state = 1215; + this.match(ImpalaSqlParser.BITWISEOR); + this.state = 1216; this.stringLiteral(); } } - this.state = 1220; + this.state = 1221; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -4644,14 +4641,14 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1223; + this.state = 1224; this.match(ImpalaSqlParser.KW_SHOW); - this.state = 1225; + this.state = 1226; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 3 || _la === 12) { { - this.state = 1224; + this.state = 1225; _la = this.tokenStream.LA(1); if(!(_la === 3 || _la === 12)) { this.errorHandler.recoverInline(this); @@ -4663,50 +4660,50 @@ export class ImpalaSqlParser extends SQLParserBase { } } - this.state = 1227; + this.state = 1228; this.match(ImpalaSqlParser.KW_FUNCTIONS); - this.state = 1230; + this.state = 1231; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 94) { { - this.state = 1228; - this.match(ImpalaSqlParser.KW_IN); this.state = 1229; + this.match(ImpalaSqlParser.KW_IN); + this.state = 1230; this.databaseNamePath(); } } - this.state = 1243; + this.state = 1244; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 115 || _la === 274 || _la === 275) { { - this.state = 1233; + this.state = 1234; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 115) { { - this.state = 1232; + this.state = 1233; this.match(ImpalaSqlParser.KW_LIKE); } } - this.state = 1235; + this.state = 1236; localContext._pattern = this.stringLiteral(); - this.state = 1240; + this.state = 1241; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 271) { { { - this.state = 1236; - this.match(ImpalaSqlParser.BITWISEOR); this.state = 1237; + this.match(ImpalaSqlParser.BITWISEOR); + this.state = 1238; this.stringLiteral(); } } - this.state = 1242; + this.state = 1243; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -4735,13 +4732,13 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1245; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1246; - this.match(ImpalaSqlParser.KW_CREATE); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1247; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_CREATE); this.state = 1248; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 1249; this.tableNamePath(); } } @@ -4765,13 +4762,13 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1250; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1251; - this.match(ImpalaSqlParser.KW_CREATE); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1252; - this.match(ImpalaSqlParser.KW_VIEW); + this.match(ImpalaSqlParser.KW_CREATE); this.state = 1253; + this.match(ImpalaSqlParser.KW_VIEW); + this.state = 1254; this.viewNamePath(); } } @@ -4795,13 +4792,13 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1255; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1256; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1257; - this.match(ImpalaSqlParser.KW_STATS); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 1258; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 1259; this.tableNamePath(); } } @@ -4825,13 +4822,13 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1260; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1261; - this.match(ImpalaSqlParser.KW_COLUMN); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1262; - this.match(ImpalaSqlParser.KW_STATS); + this.match(ImpalaSqlParser.KW_COLUMN); this.state = 1263; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 1264; this.tableNamePath(); } } @@ -4856,21 +4853,21 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1265; + this.state = 1266; this.match(ImpalaSqlParser.KW_SHOW); - this.state = 1267; + this.state = 1268; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 154) { { - this.state = 1266; + this.state = 1267; this.match(ImpalaSqlParser.KW_RANGE); } } - this.state = 1269; - this.match(ImpalaSqlParser.KW_PARTITIONS); this.state = 1270; + this.match(ImpalaSqlParser.KW_PARTITIONS); + this.state = 1271; this.tableNamePath(); } } @@ -4895,38 +4892,38 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1272; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1273; - this.match(ImpalaSqlParser.KW_FILES); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1274; - this.match(ImpalaSqlParser.KW_IN); + this.match(ImpalaSqlParser.KW_FILES); this.state = 1275; + this.match(ImpalaSqlParser.KW_IN); + this.state = 1276; this.tableNamePath(); - this.state = 1285; + this.state = 1286; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 1276; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 1277; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_PARTITION); this.state = 1278; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1279; this.expression(); - this.state = 1281; + this.state = 1282; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 263) { { - this.state = 1279; - this.match(ImpalaSqlParser.COMMA); this.state = 1280; + this.match(ImpalaSqlParser.COMMA); + this.state = 1281; this.expression(); } } - this.state = 1283; + this.state = 1284; this.match(ImpalaSqlParser.RPAREN); } } @@ -4954,19 +4951,19 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1287; + this.state = 1288; this.match(ImpalaSqlParser.KW_SHOW); - this.state = 1289; + this.state = 1290; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 39) { { - this.state = 1288; + this.state = 1289; this.match(ImpalaSqlParser.KW_CURRENT); } } - this.state = 1291; + this.state = 1292; this.match(ImpalaSqlParser.KW_ROLES); } } @@ -4990,15 +4987,15 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1293; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1294; - this.match(ImpalaSqlParser.KW_ROLE); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1295; - this.match(ImpalaSqlParser.KW_GRANT); + this.match(ImpalaSqlParser.KW_ROLE); this.state = 1296; - this.match(ImpalaSqlParser.KW_GROUP); + this.match(ImpalaSqlParser.KW_GRANT); this.state = 1297; + this.match(ImpalaSqlParser.KW_GROUP); + this.state = 1298; this.identifier(); } } @@ -5021,38 +5018,38 @@ export class ImpalaSqlParser extends SQLParserBase { this.enterRule(localContext, 136, ImpalaSqlParser.RULE_showGrants); let _la: number; try { - this.state = 1313; + this.state = 1314; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 139, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1299; + this.state = 1300; this.showDatabaseGrant(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1300; + this.state = 1301; this.showTableGrant(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1301; + this.state = 1302; this.showColumnGrant(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1302; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1303; - this.match(ImpalaSqlParser.KW_GRANT); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1304; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1305; _la = this.tokenStream.LA(1); if(!(_la === 87 || _la === 166 || _la === 204)) { this.errorHandler.recoverInline(this); @@ -5061,16 +5058,16 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1305; + this.state = 1306; this.identifier(); - this.state = 1311; + this.state = 1312; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 136) { { - this.state = 1306; - this.match(ImpalaSqlParser.KW_ON); this.state = 1307; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1308; _la = this.tokenStream.LA(1); if(!(_la === 178 || _la === 209)) { this.errorHandler.recoverInline(this); @@ -5079,12 +5076,12 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1309; + this.state = 1310; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 1308; + this.state = 1309; this.qualifiedName(); } } @@ -5117,11 +5114,11 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1315; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1316; - this.match(ImpalaSqlParser.KW_GRANT); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1317; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1318; _la = this.tokenStream.LA(1); if(!(_la === 87 || _la === 166 || _la === 204)) { this.errorHandler.recoverInline(this); @@ -5130,23 +5127,23 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1318; + this.state = 1319; this.identifier(); - this.state = 1324; + this.state = 1325; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 136) { { - this.state = 1319; - this.match(ImpalaSqlParser.KW_ON); this.state = 1320; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1321; this.match(ImpalaSqlParser.KW_DATABASE); - this.state = 1322; + this.state = 1323; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 1321; + this.state = 1322; this.databaseNamePath(); } } @@ -5177,11 +5174,11 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1326; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1327; - this.match(ImpalaSqlParser.KW_GRANT); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1328; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1329; _la = this.tokenStream.LA(1); if(!(_la === 87 || _la === 166 || _la === 204)) { this.errorHandler.recoverInline(this); @@ -5190,23 +5187,23 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1329; + this.state = 1330; this.identifier(); - this.state = 1335; + this.state = 1336; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 136) { { - this.state = 1330; - this.match(ImpalaSqlParser.KW_ON); this.state = 1331; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1332; this.match(ImpalaSqlParser.KW_TABLE); - this.state = 1333; + this.state = 1334; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 1332; + this.state = 1333; this.tableNamePath(); } } @@ -5237,11 +5234,11 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1337; - this.match(ImpalaSqlParser.KW_SHOW); this.state = 1338; - this.match(ImpalaSqlParser.KW_GRANT); + this.match(ImpalaSqlParser.KW_SHOW); this.state = 1339; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1340; _la = this.tokenStream.LA(1); if(!(_la === 87 || _la === 166 || _la === 204)) { this.errorHandler.recoverInline(this); @@ -5250,23 +5247,23 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1340; + this.state = 1341; this.identifier(); - this.state = 1346; + this.state = 1347; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 136) { { - this.state = 1341; - this.match(ImpalaSqlParser.KW_ON); this.state = 1342; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1343; this.match(ImpalaSqlParser.KW_COLUMN); - this.state = 1344; + this.state = 1345; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 144, this.context) ) { case 1: { - this.state = 1343; + this.state = 1344; this.columnNamePath(); } break; @@ -5294,27 +5291,27 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new AddCommentStatementContext(this.context, this.state); this.enterRule(localContext, 144, ImpalaSqlParser.RULE_addCommentStatement); try { - this.state = 1351; + this.state = 1352; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 146, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1348; + this.state = 1349; this.addDatabaseComments(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1349; + this.state = 1350; this.addTableComments(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1350; + this.state = 1351; this.addColumnComments(); } break; @@ -5340,29 +5337,29 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1353; - this.match(ImpalaSqlParser.KW_COMMENT); this.state = 1354; - this.match(ImpalaSqlParser.KW_ON); + this.match(ImpalaSqlParser.KW_COMMENT); this.state = 1355; - this.match(ImpalaSqlParser.KW_DATABASE); + this.match(ImpalaSqlParser.KW_ON); this.state = 1356; - this.databaseNamePath(); + this.match(ImpalaSqlParser.KW_DATABASE); this.state = 1357; + this.databaseNamePath(); + this.state = 1358; this.match(ImpalaSqlParser.KW_IS); - this.state = 1360; + this.state = 1361; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.STRING: case ImpalaSqlParser.UNICODE_STRING: { - this.state = 1358; + this.state = 1359; this.stringLiteral(); } break; case ImpalaSqlParser.KW_NULL: { - this.state = 1359; + this.state = 1360; this.match(ImpalaSqlParser.KW_NULL); } break; @@ -5391,29 +5388,29 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1362; - this.match(ImpalaSqlParser.KW_COMMENT); this.state = 1363; - this.match(ImpalaSqlParser.KW_ON); + this.match(ImpalaSqlParser.KW_COMMENT); this.state = 1364; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_ON); this.state = 1365; - this.tableNamePath(); + this.match(ImpalaSqlParser.KW_TABLE); this.state = 1366; + this.tableNamePath(); + this.state = 1367; this.match(ImpalaSqlParser.KW_IS); - this.state = 1369; + this.state = 1370; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.STRING: case ImpalaSqlParser.UNICODE_STRING: { - this.state = 1367; + this.state = 1368; this.stringLiteral(); } break; case ImpalaSqlParser.KW_NULL: { - this.state = 1368; + this.state = 1369; this.match(ImpalaSqlParser.KW_NULL); } break; @@ -5442,29 +5439,29 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1371; - this.match(ImpalaSqlParser.KW_COMMENT); this.state = 1372; - this.match(ImpalaSqlParser.KW_ON); + this.match(ImpalaSqlParser.KW_COMMENT); this.state = 1373; - this.match(ImpalaSqlParser.KW_COLUMN); + this.match(ImpalaSqlParser.KW_ON); this.state = 1374; - this.columnNamePath(); + this.match(ImpalaSqlParser.KW_COLUMN); this.state = 1375; + this.columnNamePath(); + this.state = 1376; this.match(ImpalaSqlParser.KW_IS); - this.state = 1378; + this.state = 1379; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.STRING: case ImpalaSqlParser.UNICODE_STRING: { - this.state = 1376; + this.state = 1377; this.stringLiteral(); } break; case ImpalaSqlParser.KW_NULL: { - this.state = 1377; + this.state = 1378; this.match(ImpalaSqlParser.KW_NULL); } break; @@ -5493,9 +5490,9 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1380; - this.match(ImpalaSqlParser.KW_EXPLAIN); this.state = 1381; + this.match(ImpalaSqlParser.KW_EXPLAIN); + this.state = 1382; this.sqlStatement(); } } @@ -5519,14 +5516,14 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1383; + this.state = 1384; this.match(ImpalaSqlParser.KW_SET); - this.state = 1389; + this.state = 1390; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_ALL: { - this.state = 1384; + this.state = 1385; this.match(ImpalaSqlParser.KW_ALL); } break; @@ -5569,11 +5566,11 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.DIGIT_IDENTIFIER: case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: { - this.state = 1385; - this.identifier(); this.state = 1386; - this.match(ImpalaSqlParser.EQ); + this.identifier(); this.state = 1387; + this.match(ImpalaSqlParser.EQ); + this.state = 1388; this.expression(); } break; @@ -5632,23 +5629,23 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1391; - this.match(ImpalaSqlParser.COLON); this.state = 1392; - this.match(ImpalaSqlParser.KW_SHUTDOWN); + this.match(ImpalaSqlParser.COLON); this.state = 1393; + this.match(ImpalaSqlParser.KW_SHUTDOWN); + this.state = 1394; this.match(ImpalaSqlParser.LPAREN); - this.state = 1403; + this.state = 1404; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 153, this.context) ) { case 1: { - this.state = 1395; + this.state = 1396; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 274 || _la === 275) { { - this.state = 1394; + this.state = 1395; this.stringLiteral(); } } @@ -5657,16 +5654,16 @@ export class ImpalaSqlParser extends SQLParserBase { break; case 2: { - this.state = 1397; + this.state = 1398; this.stringLiteral(); - this.state = 1400; + this.state = 1401; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 263) { { - this.state = 1398; - this.match(ImpalaSqlParser.COMMA); this.state = 1399; + this.match(ImpalaSqlParser.COMMA); + this.state = 1400; this.expression(); } } @@ -5675,12 +5672,12 @@ export class ImpalaSqlParser extends SQLParserBase { break; case 3: { - this.state = 1402; + this.state = 1403; this.expression(); } break; } - this.state = 1405; + this.state = 1406; this.match(ImpalaSqlParser.RPAREN); } } @@ -5704,11 +5701,11 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1407; - this.match(ImpalaSqlParser.KW_INVALIDATE); this.state = 1408; - this.match(ImpalaSqlParser.KW_METADATA); + this.match(ImpalaSqlParser.KW_INVALIDATE); this.state = 1409; + this.match(ImpalaSqlParser.KW_METADATA); + this.state = 1410; this.tableNamePath(); } } @@ -5733,54 +5730,54 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1411; - this.match(ImpalaSqlParser.KW_LOAD); this.state = 1412; - this.match(ImpalaSqlParser.KW_DATA); + this.match(ImpalaSqlParser.KW_LOAD); this.state = 1413; - this.match(ImpalaSqlParser.KW_INPATH); + this.match(ImpalaSqlParser.KW_DATA); this.state = 1414; + this.match(ImpalaSqlParser.KW_INPATH); + this.state = 1415; this.match(ImpalaSqlParser.STRING); - this.state = 1416; + this.state = 1417; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 144) { { - this.state = 1415; + this.state = 1416; this.match(ImpalaSqlParser.KW_OVERWRITE); } } - this.state = 1418; - this.match(ImpalaSqlParser.KW_INTO); this.state = 1419; - this.match(ImpalaSqlParser.KW_TABLE); + this.match(ImpalaSqlParser.KW_INTO); this.state = 1420; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 1421; this.tableNamePath(); - this.state = 1430; + this.state = 1431; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 1421; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 1422; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_PARTITION); this.state = 1423; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1424; this.expression(); - this.state = 1426; + this.state = 1427; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 263) { { - this.state = 1424; - this.match(ImpalaSqlParser.COMMA); this.state = 1425; + this.match(ImpalaSqlParser.COMMA); + this.state = 1426; this.expression(); } } - this.state = 1428; + this.state = 1429; this.match(ImpalaSqlParser.RPAREN); } } @@ -5805,27 +5802,27 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new RefreshStatementContext(this.context, this.state); this.enterRule(localContext, 162, ImpalaSqlParser.RULE_refreshStatement); try { - this.state = 1435; + this.state = 1436; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 157, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1432; + this.state = 1433; this.refreshMeta(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1433; + this.state = 1434; this.refreshAuth(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1434; + this.state = 1435; this.refreshFunction(); } break; @@ -5853,40 +5850,40 @@ export class ImpalaSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1437; - this.match(ImpalaSqlParser.KW_REFRESH); this.state = 1438; + this.match(ImpalaSqlParser.KW_REFRESH); + this.state = 1439; this.tableNamePath(); - this.state = 1451; + this.state = 1452; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 1439; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 1440; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_PARTITION); this.state = 1441; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1442; this.expression(); - this.state = 1446; + this.state = 1447; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 158, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 1442; - this.match(ImpalaSqlParser.COMMA); this.state = 1443; + this.match(ImpalaSqlParser.COMMA); + this.state = 1444; this.expression(); } } } - this.state = 1448; + this.state = 1449; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 158, this.context); } - this.state = 1449; + this.state = 1450; this.match(ImpalaSqlParser.RPAREN); } } @@ -5913,9 +5910,9 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1453; - this.match(ImpalaSqlParser.KW_REFRESH); this.state = 1454; + this.match(ImpalaSqlParser.KW_REFRESH); + this.state = 1455; this.match(ImpalaSqlParser.KW_AUTHORIZATION); } } @@ -5939,11 +5936,11 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1456; - this.match(ImpalaSqlParser.KW_REFRESH); this.state = 1457; - this.match(ImpalaSqlParser.KW_FUNCTIONS); + this.match(ImpalaSqlParser.KW_REFRESH); this.state = 1458; + this.match(ImpalaSqlParser.KW_FUNCTIONS); + this.state = 1459; this.functionNamePath(); } } @@ -5967,9 +5964,9 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1460; - this.match(ImpalaSqlParser.KW_IF); this.state = 1461; + this.match(ImpalaSqlParser.KW_IF); + this.state = 1462; this.match(ImpalaSqlParser.KW_EXISTS); } } @@ -5993,11 +5990,11 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1463; - this.match(ImpalaSqlParser.KW_IF); this.state = 1464; - this.match(ImpalaSqlParser.KW_NOT); + this.match(ImpalaSqlParser.KW_IF); this.state = 1465; + this.match(ImpalaSqlParser.KW_NOT); + this.state = 1466; this.match(ImpalaSqlParser.KW_EXISTS); } } @@ -6021,7 +6018,7 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1467; + this.state = 1468; this.qualifiedName(); } } @@ -6045,7 +6042,7 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1469; + this.state = 1470; this.qualifiedName(); } } @@ -6069,7 +6066,7 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1471; + this.state = 1472; this.qualifiedName(); } } @@ -6093,7 +6090,7 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1473; + this.state = 1474; this.qualifiedName(); } } @@ -6117,7 +6114,7 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1475; + this.state = 1476; this.qualifiedName(); } } @@ -6141,7 +6138,7 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1477; + this.state = 1478; this.qualifiedName(); } } @@ -6166,23 +6163,23 @@ export class ImpalaSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1479; + this.state = 1480; this.identifier(); - this.state = 1484; + this.state = 1485; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 160, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1480; - this.match(ImpalaSqlParser.DOT); this.state = 1481; + this.match(ImpalaSqlParser.DOT); + this.state = 1482; this.identifier(); } } } - this.state = 1486; + this.state = 1487; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 160, this.context); } @@ -6209,23 +6206,23 @@ export class ImpalaSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1487; + this.state = 1488; this.identifier(); - this.state = 1492; + this.state = 1493; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 161, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1488; - this.match(ImpalaSqlParser.DOT); this.state = 1489; + this.match(ImpalaSqlParser.DOT); + this.state = 1490; this.identifier(); } } } - this.state = 1494; + this.state = 1495; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 161, this.context); } @@ -6249,20 +6246,20 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new FunctionNamePathContext(this.context, this.state); this.enterRule(localContext, 190, ImpalaSqlParser.RULE_functionNamePath); try { - this.state = 1497; + this.state = 1498; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 162, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1495; + this.state = 1496; this.reservedKeywordsUsedAsFuncName(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1496; + this.state = 1497; this.qualifiedName(); } break; @@ -6286,20 +6283,20 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new ColumnNamePathContext(this.context, this.state); this.enterRule(localContext, 192, ImpalaSqlParser.RULE_columnNamePath); try { - this.state = 1501; + this.state = 1502; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 163, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1499; + this.state = 1500; this.qualifiedName(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1500; + this.state = 1501; if (!(this.shouldMatchEmpty())) { throw this.createFailedPredicateException("this.shouldMatchEmpty()"); } @@ -6325,20 +6322,20 @@ export class ImpalaSqlParser extends SQLParserBase { let localContext = new TableOrViewPathContext(this.context, this.state); this.enterRule(localContext, 194, ImpalaSqlParser.RULE_tableOrViewPath); try { - this.state = 1505; + this.state = 1506; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 164, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1503; + this.state = 1504; this.tableNamePath(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1504; + this.state = 1505; this.viewNamePath(); } break; @@ -6365,16 +6362,16 @@ export class ImpalaSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1510; + this.state = 1511; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 21) { { - this.state = 1507; - this.match(ImpalaSqlParser.KW_SORT); this.state = 1508; - this.match(ImpalaSqlParser.KW_BY); + this.match(ImpalaSqlParser.KW_SORT); this.state = 1509; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1510; this.columnAliases(); } } @@ -6384,10 +6381,8 @@ export class ImpalaSqlParser extends SQLParserBase { switch (this.interpreter.adaptivePredict(this.tokenStream, 166, this.context) ) { case 1: { - this.state = 1512; - this.match(ImpalaSqlParser.KW_COMMENT); this.state = 1513; - localContext._comment = this.stringLiteral(); + this.commentClause(); } break; } @@ -6620,49 +6615,41 @@ export class ImpalaSqlParser extends SQLParserBase { { this.state = 1563; this.match(ImpalaSqlParser.LPAREN); - this.state = 1564; - this.columnNamePathCreate(); - this.state = 1567; + this.state = 1565; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 34) { + if (_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 1565; - this.match(ImpalaSqlParser.KW_COMMENT); - this.state = 1566; - this.stringLiteral(); + this.state = 1564; + this.viewColumnItem(); } } - this.state = 1577; + this.state = 1573; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 1569; + this.state = 1567; this.match(ImpalaSqlParser.COMMA); - this.state = 1570; - this.columnNamePathCreate(); - this.state = 1573; + this.state = 1569; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 34) { + if (_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 1571; - this.match(ImpalaSqlParser.KW_COMMENT); - this.state = 1572; - this.stringLiteral(); + this.state = 1568; + this.viewColumnItem(); } } } } - this.state = 1579; + this.state = 1575; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1580; + this.state = 1576; this.match(ImpalaSqlParser.RPAREN); } } @@ -6680,9 +6667,44 @@ export class ImpalaSqlParser extends SQLParserBase { } return localContext; } + public viewColumnItem(): ViewColumnItemContext { + let localContext = new ViewColumnItemContext(this.context, this.state); + this.enterRule(localContext, 204, ImpalaSqlParser.RULE_viewColumnItem); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1578; + this.columnNamePathCreate(); + this.state = 1580; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 34) { + { + this.state = 1579; + this.commentClause(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } public queryStatement(): QueryStatementContext { let localContext = new QueryStatementContext(this.context, this.state); - this.enterRule(localContext, 204, ImpalaSqlParser.RULE_queryStatement); + this.enterRule(localContext, 206, ImpalaSqlParser.RULE_queryStatement); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -6717,7 +6739,7 @@ export class ImpalaSqlParser extends SQLParserBase { } public with_(): WithContext { let localContext = new WithContext(this.context, this.state); - this.enterRule(localContext, 206, ImpalaSqlParser.RULE_with); + this.enterRule(localContext, 208, ImpalaSqlParser.RULE_with); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -6760,7 +6782,7 @@ export class ImpalaSqlParser extends SQLParserBase { } public constraintSpecification(): ConstraintSpecificationContext { let localContext = new ConstraintSpecificationContext(this.context, this.state); - this.enterRule(localContext, 208, ImpalaSqlParser.RULE_constraintSpecification); + this.enterRule(localContext, 210, ImpalaSqlParser.RULE_constraintSpecification); let _la: number; try { let alternative: number; @@ -6784,7 +6806,7 @@ export class ImpalaSqlParser extends SQLParserBase { this.state = 1605; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 181, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 182, this.context) ) { case 1: { this.state = 1602; @@ -6802,7 +6824,7 @@ export class ImpalaSqlParser extends SQLParserBase { } this.state = 1610; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 182, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 183, this.context) ) { case 1: { this.state = 1607; @@ -6845,7 +6867,7 @@ export class ImpalaSqlParser extends SQLParserBase { } this.state = 1621; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 184, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 185, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { @@ -6859,7 +6881,7 @@ export class ImpalaSqlParser extends SQLParserBase { } this.state = 1623; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 184, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 185, this.context); } } } @@ -6882,7 +6904,7 @@ export class ImpalaSqlParser extends SQLParserBase { } public foreignKeySpecification(): ForeignKeySpecificationContext { let localContext = new ForeignKeySpecificationContext(this.context, this.state); - this.enterRule(localContext, 210, ImpalaSqlParser.RULE_foreignKeySpecification); + this.enterRule(localContext, 212, ImpalaSqlParser.RULE_foreignKeySpecification); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -6947,7 +6969,7 @@ export class ImpalaSqlParser extends SQLParserBase { } public columnSpec(): ColumnSpecContext { let localContext = new ColumnSpecContext(this.context, this.state); - this.enterRule(localContext, 212, ImpalaSqlParser.RULE_columnSpec); + this.enterRule(localContext, 214, ImpalaSqlParser.RULE_columnSpec); try { this.enterOuterAlt(localContext, 1); { @@ -6957,7 +6979,7 @@ export class ImpalaSqlParser extends SQLParserBase { this.type_(0); this.state = 1645; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 189, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 190, this.context) ) { case 1: { this.state = 1643; @@ -6985,7 +7007,7 @@ export class ImpalaSqlParser extends SQLParserBase { } public columnDefinition(): ColumnDefinitionContext { let localContext = new ColumnDefinitionContext(this.context, this.state); - this.enterRule(localContext, 214, ImpalaSqlParser.RULE_columnDefinition); + this.enterRule(localContext, 216, ImpalaSqlParser.RULE_columnDefinition); let _la: number; try { this.enterOuterAlt(localContext, 1); @@ -6993,16 +7015,14 @@ export class ImpalaSqlParser extends SQLParserBase { this.state = 1647; this.columnNamePathCreate(); this.state = 1648; - this.type_(0); - this.state = 1651; + localContext._colType = this.type_(0); + this.state = 1650; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 34) { { this.state = 1649; - this.match(ImpalaSqlParser.KW_COMMENT); - this.state = 1650; - this.stringLiteral(); + this.commentClause(); } } @@ -7024,11 +7044,11 @@ export class ImpalaSqlParser extends SQLParserBase { } public kuduTableElement(): KuduTableElementContext { let localContext = new KuduTableElementContext(this.context, this.state); - this.enterRule(localContext, 216, ImpalaSqlParser.RULE_kuduTableElement); + this.enterRule(localContext, 218, ImpalaSqlParser.RULE_kuduTableElement); try { this.enterOuterAlt(localContext, 1); { - this.state = 1653; + this.state = 1652; this.kuduColumnDefinition(); } } @@ -7048,62 +7068,60 @@ export class ImpalaSqlParser extends SQLParserBase { } public kuduColumnDefinition(): KuduColumnDefinitionContext { let localContext = new KuduColumnDefinitionContext(this.context, this.state); - this.enterRule(localContext, 218, ImpalaSqlParser.RULE_kuduColumnDefinition); + this.enterRule(localContext, 220, ImpalaSqlParser.RULE_kuduColumnDefinition); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1655; + this.state = 1654; this.columnNamePathCreate(); - this.state = 1656; - this.type_(0); - this.state = 1664; + this.state = 1655; + localContext._colType = this.type_(0); + this.state = 1663; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 16 || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 33619969) !== 0) || _la === 132 || _la === 133) { { - this.state = 1657; + this.state = 1656; this.kuduAttributes(); - this.state = 1661; + this.state = 1660; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 191, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 192, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 1658; + this.state = 1657; this.kuduAttributes(); } } } - this.state = 1663; + this.state = 1662; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 191, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 192, this.context); } } } - this.state = 1668; + this.state = 1666; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 34) { { - this.state = 1666; - this.match(ImpalaSqlParser.KW_COMMENT); - this.state = 1667; - this.stringLiteral(); + this.state = 1665; + this.commentClause(); } } - this.state = 1672; + this.state = 1670; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 150) { { - this.state = 1670; + this.state = 1668; this.match(ImpalaSqlParser.KW_PRIMARY); - this.state = 1671; + this.state = 1669; this.match(ImpalaSqlParser.KW_KEY); } } @@ -7124,38 +7142,64 @@ export class ImpalaSqlParser extends SQLParserBase { } return localContext; } + public commentClause(): CommentClauseContext { + let localContext = new CommentClauseContext(this.context, this.state); + this.enterRule(localContext, 222, ImpalaSqlParser.RULE_commentClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1672; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1673; + localContext._comment = this.stringLiteral(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } public columnSpecWithKudu(): ColumnSpecWithKuduContext { let localContext = new ColumnSpecWithKuduContext(this.context, this.state); - this.enterRule(localContext, 220, ImpalaSqlParser.RULE_columnSpecWithKudu); + this.enterRule(localContext, 224, ImpalaSqlParser.RULE_columnSpecWithKudu); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1674; + this.state = 1675; this.columnSpec(); - this.state = 1682; + this.state = 1683; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 16 || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 33619969) !== 0) || _la === 132 || _la === 133) { { - this.state = 1675; + this.state = 1676; this.kuduAttributes(); - this.state = 1679; + this.state = 1680; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 195, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 196, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 1676; + this.state = 1677; this.kuduAttributes(); } } } - this.state = 1681; + this.state = 1682; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 195, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 196, this.context); } } } @@ -7178,50 +7222,50 @@ export class ImpalaSqlParser extends SQLParserBase { } public createColumnSpecWithKudu(): CreateColumnSpecWithKuduContext { let localContext = new CreateColumnSpecWithKuduContext(this.context, this.state); - this.enterRule(localContext, 222, ImpalaSqlParser.RULE_createColumnSpecWithKudu); + this.enterRule(localContext, 226, ImpalaSqlParser.RULE_createColumnSpecWithKudu); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1684; - this.columnNamePathCreate(); this.state = 1685; + this.columnNamePathCreate(); + this.state = 1686; this.type_(0); - this.state = 1688; + this.state = 1689; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 197, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 198, this.context) ) { case 1: { - this.state = 1686; - this.match(ImpalaSqlParser.KW_COMMENT); this.state = 1687; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1688; this.stringLiteral(); } break; } - this.state = 1697; + this.state = 1698; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 16 || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 33619969) !== 0) || _la === 132 || _la === 133) { { - this.state = 1690; + this.state = 1691; this.kuduAttributes(); - this.state = 1694; + this.state = 1695; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 198, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 199, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 1691; + this.state = 1692; this.kuduAttributes(); } } } - this.state = 1696; + this.state = 1697; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 198, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 199, this.context); } } } @@ -7244,28 +7288,28 @@ export class ImpalaSqlParser extends SQLParserBase { } public kuduAttributes(): KuduAttributesContext { let localContext = new KuduAttributesContext(this.context, this.state); - this.enterRule(localContext, 224, ImpalaSqlParser.RULE_kuduAttributes); + this.enterRule(localContext, 228, ImpalaSqlParser.RULE_kuduAttributes); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1704; + this.state = 1705; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_NOT: case ImpalaSqlParser.KW_NULL: { - this.state = 1700; + this.state = 1701; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 132) { { - this.state = 1699; + this.state = 1700; this.match(ImpalaSqlParser.KW_NOT); } } - this.state = 1702; + this.state = 1703; this.match(ImpalaSqlParser.KW_NULL); } break; @@ -7274,7 +7318,7 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.KW_DEFAULT: case ImpalaSqlParser.KW_ENCODING: { - this.state = 1703; + this.state = 1704; this.kuduStorageAttr(); } break; @@ -7299,44 +7343,44 @@ export class ImpalaSqlParser extends SQLParserBase { } public kuduStorageAttr(): KuduStorageAttrContext { let localContext = new KuduStorageAttrContext(this.context, this.state); - this.enterRule(localContext, 226, ImpalaSqlParser.RULE_kuduStorageAttr); + this.enterRule(localContext, 230, ImpalaSqlParser.RULE_kuduStorageAttr); try { - this.state = 1714; + this.state = 1715; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_ENCODING: this.enterOuterAlt(localContext, 1); { - this.state = 1706; - this.match(ImpalaSqlParser.KW_ENCODING); this.state = 1707; + this.match(ImpalaSqlParser.KW_ENCODING); + this.state = 1708; this.expression(); } break; case ImpalaSqlParser.KW_COMPRESSION: this.enterOuterAlt(localContext, 2); { - this.state = 1708; - this.match(ImpalaSqlParser.KW_COMPRESSION); this.state = 1709; + this.match(ImpalaSqlParser.KW_COMPRESSION); + this.state = 1710; this.expression(); } break; case ImpalaSqlParser.KW_DEFAULT: this.enterOuterAlt(localContext, 3); { - this.state = 1710; - this.match(ImpalaSqlParser.KW_DEFAULT); this.state = 1711; + this.match(ImpalaSqlParser.KW_DEFAULT); + this.state = 1712; this.expression(); } break; case ImpalaSqlParser.KW_BLOCK_SIZE: this.enterOuterAlt(localContext, 4); { - this.state = 1712; - this.match(ImpalaSqlParser.KW_BLOCK_SIZE); this.state = 1713; + this.match(ImpalaSqlParser.KW_BLOCK_SIZE); + this.state = 1714; this.number_(); } break; @@ -7360,12 +7404,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public statsKey(): StatsKeyContext { let localContext = new StatsKeyContext(this.context, this.state); - this.enterRule(localContext, 228, ImpalaSqlParser.RULE_statsKey); + this.enterRule(localContext, 232, ImpalaSqlParser.RULE_statsKey); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1716; + this.state = 1717; _la = this.tokenStream.LA(1); if(!(((((_la - 245)) & ~0x1F) === 0 && ((1 << (_la - 245)) & 15) !== 0))) { this.errorHandler.recoverInline(this); @@ -7392,12 +7436,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public fileFormat(): FileFormatContext { let localContext = new FileFormatContext(this.context, this.state); - this.enterRule(localContext, 230, ImpalaSqlParser.RULE_fileFormat); + this.enterRule(localContext, 234, ImpalaSqlParser.RULE_fileFormat); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1718; + this.state = 1719; _la = this.tokenStream.LA(1); if(!(_la === 147 || ((((_la - 219)) & ~0x1F) === 0 && ((1 << (_la - 219)) & 31) !== 0))) { this.errorHandler.recoverInline(this); @@ -7424,45 +7468,45 @@ export class ImpalaSqlParser extends SQLParserBase { } public kuduPartitionClause(): KuduPartitionClauseContext { let localContext = new KuduPartitionClauseContext(this.context, this.state); - this.enterRule(localContext, 232, ImpalaSqlParser.RULE_kuduPartitionClause); + this.enterRule(localContext, 236, ImpalaSqlParser.RULE_kuduPartitionClause); let _la: number; try { let alternative: number; - this.state = 1733; + this.state = 1734; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_HASH: this.enterOuterAlt(localContext, 1); { { - this.state = 1720; + this.state = 1721; this.hashClause(); - this.state = 1725; + this.state = 1726; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 203, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 204, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 1721; - this.match(ImpalaSqlParser.COMMA); this.state = 1722; + this.match(ImpalaSqlParser.COMMA); + this.state = 1723; this.hashClause(); } } } - this.state = 1727; + this.state = 1728; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 203, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 204, this.context); } - this.state = 1730; + this.state = 1731; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 263) { { - this.state = 1728; - this.match(ImpalaSqlParser.COMMA); this.state = 1729; + this.match(ImpalaSqlParser.COMMA); + this.state = 1730; this.rangeClause(); } } @@ -7473,7 +7517,7 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.KW_RANGE: this.enterOuterAlt(localContext, 2); { - this.state = 1732; + this.state = 1733; this.rangeClause(); } break; @@ -7497,26 +7541,26 @@ export class ImpalaSqlParser extends SQLParserBase { } public hashClause(): HashClauseContext { let localContext = new HashClauseContext(this.context, this.state); - this.enterRule(localContext, 234, ImpalaSqlParser.RULE_hashClause); + this.enterRule(localContext, 238, ImpalaSqlParser.RULE_hashClause); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1735; + this.state = 1736; this.match(ImpalaSqlParser.KW_HASH); - this.state = 1737; + this.state = 1738; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 265) { { - this.state = 1736; + this.state = 1737; this.columnAliases(); } } - this.state = 1739; - this.match(ImpalaSqlParser.KW_PARTITIONS); this.state = 1740; + this.match(ImpalaSqlParser.KW_PARTITIONS); + this.state = 1741; this.number_(); } } @@ -7536,52 +7580,52 @@ export class ImpalaSqlParser extends SQLParserBase { } public rangeClause(): RangeClauseContext { let localContext = new RangeClauseContext(this.context, this.state); - this.enterRule(localContext, 236, ImpalaSqlParser.RULE_rangeClause); + this.enterRule(localContext, 240, ImpalaSqlParser.RULE_rangeClause); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1742; + this.state = 1743; this.match(ImpalaSqlParser.KW_RANGE); - this.state = 1744; + this.state = 1745; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 207, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 208, this.context) ) { case 1: { - this.state = 1743; + this.state = 1744; this.columnAliases(); } break; } - this.state = 1746; + this.state = 1747; this.match(ImpalaSqlParser.LPAREN); { - this.state = 1747; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 1748; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 1749; this.kuduPartitionSpec(); - this.state = 1754; + this.state = 1755; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 208, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 209, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 1749; - this.match(ImpalaSqlParser.COMMA); this.state = 1750; - this.match(ImpalaSqlParser.KW_PARTITION); + this.match(ImpalaSqlParser.COMMA); this.state = 1751; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 1752; this.kuduPartitionSpec(); } } } - this.state = 1756; + this.state = 1757; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 208, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 209, this.context); } } - this.state = 1757; + this.state = 1758; this.match(ImpalaSqlParser.RPAREN); } } @@ -7601,20 +7645,20 @@ export class ImpalaSqlParser extends SQLParserBase { } public kuduPartitionSpec(): KuduPartitionSpecContext { let localContext = new KuduPartitionSpecContext(this.context, this.state); - this.enterRule(localContext, 238, ImpalaSqlParser.RULE_kuduPartitionSpec); + this.enterRule(localContext, 242, ImpalaSqlParser.RULE_kuduPartitionSpec); let _la: number; try { - this.state = 1774; + this.state = 1775; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_VALUE: this.enterOuterAlt(localContext, 1); { - this.state = 1759; - this.match(ImpalaSqlParser.KW_VALUE); this.state = 1760; - this.partitionCol(); + this.match(ImpalaSqlParser.KW_VALUE); this.state = 1761; + this.partitionCol(); + this.state = 1762; this.expression(); } break; @@ -7690,28 +7734,28 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.DOUBLE_PRECISION: this.enterOuterAlt(localContext, 2); { - this.state = 1766; + this.state = 1767; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805323008) !== 0) || ((((_la - 40)) & ~0x1F) === 0 && ((1 << (_la - 40)) & 1442841375) !== 0) || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & 2218795145) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & 269631421) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & 271654979) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & 537926659) !== 0) || ((((_la - 217)) & ~0x1F) === 0 && ((1 << (_la - 217)) & 16393) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & 2549744643) !== 0)) { { - this.state = 1763; - this.expression(); this.state = 1764; + this.expression(); + this.state = 1765; this.rangeOperator(); } } - this.state = 1768; + this.state = 1769; this.match(ImpalaSqlParser.KW_VALUES); - this.state = 1772; + this.state = 1773; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 210, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 211, this.context) ) { case 1: { - this.state = 1769; - this.rangeOperator(); this.state = 1770; + this.rangeOperator(); + this.state = 1771; this.expression(); } break; @@ -7738,32 +7782,32 @@ export class ImpalaSqlParser extends SQLParserBase { } public cacheSpec(): CacheSpecContext { let localContext = new CacheSpecContext(this.context, this.state); - this.enterRule(localContext, 240, ImpalaSqlParser.RULE_cacheSpec); + this.enterRule(localContext, 244, ImpalaSqlParser.RULE_cacheSpec); try { - this.state = 1786; + this.state = 1787; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_CACHED: this.enterOuterAlt(localContext, 1); { - this.state = 1776; - this.match(ImpalaSqlParser.KW_CACHED); this.state = 1777; - this.match(ImpalaSqlParser.KW_IN); + this.match(ImpalaSqlParser.KW_CACHED); this.state = 1778; + this.match(ImpalaSqlParser.KW_IN); + this.state = 1779; this.identifier(); - this.state = 1783; + this.state = 1784; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 212, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 213, this.context) ) { case 1: { - this.state = 1779; - this.match(ImpalaSqlParser.KW_WITH); this.state = 1780; - this.match(ImpalaSqlParser.KW_REPLICATION); + this.match(ImpalaSqlParser.KW_WITH); this.state = 1781; - this.match(ImpalaSqlParser.EQ); + this.match(ImpalaSqlParser.KW_REPLICATION); this.state = 1782; + this.match(ImpalaSqlParser.EQ); + this.state = 1783; this.number_(); } break; @@ -7773,7 +7817,7 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.KW_UNCACHED: this.enterOuterAlt(localContext, 2); { - this.state = 1785; + this.state = 1786; this.match(ImpalaSqlParser.KW_UNCACHED); } break; @@ -7797,9 +7841,9 @@ export class ImpalaSqlParser extends SQLParserBase { } public rangeOperator(): RangeOperatorContext { let localContext = new RangeOperatorContext(this.context, this.state); - this.enterRule(localContext, 242, ImpalaSqlParser.RULE_rangeOperator); + this.enterRule(localContext, 246, ImpalaSqlParser.RULE_rangeOperator); try { - this.state = 1793; + this.state = 1794; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_ARRAY: @@ -7880,28 +7924,28 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.LT: this.enterOuterAlt(localContext, 2); { - this.state = 1789; + this.state = 1790; this.match(ImpalaSqlParser.LT); } break; case ImpalaSqlParser.LTE: this.enterOuterAlt(localContext, 3); { - this.state = 1790; + this.state = 1791; this.match(ImpalaSqlParser.LTE); } break; case ImpalaSqlParser.GT: this.enterOuterAlt(localContext, 4); { - this.state = 1791; + this.state = 1792; this.match(ImpalaSqlParser.GT); } break; case ImpalaSqlParser.GTE: this.enterOuterAlt(localContext, 5); { - this.state = 1792; + this.state = 1793; this.match(ImpalaSqlParser.GTE); } break; @@ -7925,57 +7969,57 @@ export class ImpalaSqlParser extends SQLParserBase { } public partitionCol(): PartitionColContext { let localContext = new PartitionColContext(this.context, this.state); - this.enterRule(localContext, 244, ImpalaSqlParser.RULE_partitionCol); + this.enterRule(localContext, 248, ImpalaSqlParser.RULE_partitionCol); try { - this.state = 1803; + this.state = 1804; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.EQ: this.enterOuterAlt(localContext, 1); { - this.state = 1795; + this.state = 1796; this.match(ImpalaSqlParser.EQ); } break; case ImpalaSqlParser.NEQ: this.enterOuterAlt(localContext, 2); { - this.state = 1796; + this.state = 1797; this.match(ImpalaSqlParser.NEQ); } break; case ImpalaSqlParser.KW_LIKE: this.enterOuterAlt(localContext, 3); { - this.state = 1797; + this.state = 1798; this.match(ImpalaSqlParser.KW_LIKE); } break; case ImpalaSqlParser.KW_RLIKE: this.enterOuterAlt(localContext, 4); { - this.state = 1798; + this.state = 1799; this.match(ImpalaSqlParser.KW_RLIKE); } break; case ImpalaSqlParser.KW_REGEXP: this.enterOuterAlt(localContext, 5); { - this.state = 1799; + this.state = 1800; this.match(ImpalaSqlParser.KW_REGEXP); } break; case ImpalaSqlParser.KW_BETWEEN: this.enterOuterAlt(localContext, 6); { - this.state = 1800; + this.state = 1801; this.match(ImpalaSqlParser.KW_BETWEEN); } break; case ImpalaSqlParser.KW_IN: this.enterOuterAlt(localContext, 7); { - this.state = 1801; + this.state = 1802; this.match(ImpalaSqlParser.KW_IN); } break; @@ -8054,7 +8098,7 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.DOUBLE_PRECISION: this.enterOuterAlt(localContext, 8); { - this.state = 1802; + this.state = 1803; this.rangeOperator(); } break; @@ -8078,21 +8122,21 @@ export class ImpalaSqlParser extends SQLParserBase { } public likeClause(): LikeClauseContext { let localContext = new LikeClauseContext(this.context, this.state); - this.enterRule(localContext, 246, ImpalaSqlParser.RULE_likeClause); + this.enterRule(localContext, 250, ImpalaSqlParser.RULE_likeClause); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1805; - this.match(ImpalaSqlParser.KW_LIKE); this.state = 1806; + this.match(ImpalaSqlParser.KW_LIKE); + this.state = 1807; this.qualifiedName(); - this.state = 1809; + this.state = 1810; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 65 || _la === 95) { { - this.state = 1807; + this.state = 1808; localContext._optionType = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 65 || _la === 95)) { @@ -8102,7 +8146,7 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1808; + this.state = 1809; this.match(ImpalaSqlParser.KW_PROPERTIES); } } @@ -8125,32 +8169,32 @@ export class ImpalaSqlParser extends SQLParserBase { } public properties(): PropertiesContext { let localContext = new PropertiesContext(this.context, this.state); - this.enterRule(localContext, 248, ImpalaSqlParser.RULE_properties); + this.enterRule(localContext, 252, ImpalaSqlParser.RULE_properties); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1811; - this.match(ImpalaSqlParser.LPAREN); this.state = 1812; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1813; this.property(); - this.state = 1817; + this.state = 1818; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 1813; - this.match(ImpalaSqlParser.COMMA); this.state = 1814; + this.match(ImpalaSqlParser.COMMA); + this.state = 1815; this.property(); } } - this.state = 1819; + this.state = 1820; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1820; + this.state = 1821; this.match(ImpalaSqlParser.RPAREN); } } @@ -8170,34 +8214,34 @@ export class ImpalaSqlParser extends SQLParserBase { } public partitionedBy(): PartitionedByContext { let localContext = new PartitionedByContext(this.context, this.state); - this.enterRule(localContext, 250, ImpalaSqlParser.RULE_partitionedBy); + this.enterRule(localContext, 254, ImpalaSqlParser.RULE_partitionedBy); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1822; - this.match(ImpalaSqlParser.LPAREN); this.state = 1823; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1824; this.columnSpec(); - this.state = 1828; + this.state = 1829; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 218, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 219, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 1824; - this.match(ImpalaSqlParser.COMMA); this.state = 1825; + this.match(ImpalaSqlParser.COMMA); + this.state = 1826; this.columnSpec(); } } } - this.state = 1830; + this.state = 1831; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 218, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 219, this.context); } - this.state = 1831; + this.state = 1832; this.match(ImpalaSqlParser.RPAREN); } } @@ -8217,26 +8261,26 @@ export class ImpalaSqlParser extends SQLParserBase { } public sortedBy(): SortedByContext { let localContext = new SortedByContext(this.context, this.state); - this.enterRule(localContext, 252, ImpalaSqlParser.RULE_sortedBy); + this.enterRule(localContext, 256, ImpalaSqlParser.RULE_sortedBy); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1833; + this.state = 1834; this.expression(); - this.state = 1838; + this.state = 1839; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 1834; - this.match(ImpalaSqlParser.COMMA); this.state = 1835; + this.match(ImpalaSqlParser.COMMA); + this.state = 1836; this.expression(); } } - this.state = 1840; + this.state = 1841; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -8258,36 +8302,36 @@ export class ImpalaSqlParser extends SQLParserBase { } public rowFormat(): RowFormatContext { let localContext = new RowFormatContext(this.context, this.state); - this.enterRule(localContext, 254, ImpalaSqlParser.RULE_rowFormat); + this.enterRule(localContext, 258, ImpalaSqlParser.RULE_rowFormat); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1841; + this.state = 1842; this.match(ImpalaSqlParser.KW_DELIMITED); - this.state = 1851; + this.state = 1852; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 71) { { - this.state = 1842; - this.match(ImpalaSqlParser.KW_FIELDS); this.state = 1843; - this.match(ImpalaSqlParser.KW_TERMINATED); + this.match(ImpalaSqlParser.KW_FIELDS); this.state = 1844; - this.match(ImpalaSqlParser.KW_BY); + this.match(ImpalaSqlParser.KW_TERMINATED); this.state = 1845; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1846; this.stringLiteral(); - this.state = 1849; + this.state = 1850; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 63) { { - this.state = 1846; - this.match(ImpalaSqlParser.KW_ESCAPED); this.state = 1847; - this.match(ImpalaSqlParser.KW_BY); + this.match(ImpalaSqlParser.KW_ESCAPED); this.state = 1848; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1849; this.stringLiteral(); } } @@ -8295,18 +8339,18 @@ export class ImpalaSqlParser extends SQLParserBase { } } - this.state = 1857; + this.state = 1858; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 117) { { - this.state = 1853; - this.match(ImpalaSqlParser.KW_LINES); this.state = 1854; - this.match(ImpalaSqlParser.KW_TERMINATED); + this.match(ImpalaSqlParser.KW_LINES); this.state = 1855; - this.match(ImpalaSqlParser.KW_BY); + this.match(ImpalaSqlParser.KW_TERMINATED); this.state = 1856; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1857; this.stringLiteral(); } } @@ -8329,21 +8373,21 @@ export class ImpalaSqlParser extends SQLParserBase { } public property(): PropertyContext { let localContext = new PropertyContext(this.context, this.state); - this.enterRule(localContext, 256, ImpalaSqlParser.RULE_property); + this.enterRule(localContext, 260, ImpalaSqlParser.RULE_property); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1859; + this.state = 1860; this.identifier(); - this.state = 1862; + this.state = 1863; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 249) { { - this.state = 1860; - this.match(ImpalaSqlParser.EQ); this.state = 1861; + this.match(ImpalaSqlParser.EQ); + this.state = 1862; this.expression(); } } @@ -8366,60 +8410,60 @@ export class ImpalaSqlParser extends SQLParserBase { } public queryNoWith(): QueryNoWithContext { let localContext = new QueryNoWithContext(this.context, this.state); - this.enterRule(localContext, 258, ImpalaSqlParser.RULE_queryNoWith); + this.enterRule(localContext, 262, ImpalaSqlParser.RULE_queryNoWith); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1864; + this.state = 1865; this.queryTerm(0); - this.state = 1875; + this.state = 1876; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 139) { { - this.state = 1865; - this.match(ImpalaSqlParser.KW_ORDER); this.state = 1866; - this.match(ImpalaSqlParser.KW_BY); + this.match(ImpalaSqlParser.KW_ORDER); this.state = 1867; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1868; this.sortItem(); - this.state = 1872; + this.state = 1873; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 1868; - this.match(ImpalaSqlParser.COMMA); this.state = 1869; + this.match(ImpalaSqlParser.COMMA); + this.state = 1870; this.sortItem(); } } - this.state = 1874; + this.state = 1875; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 1883; + this.state = 1884; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 116) { { - this.state = 1877; - this.match(ImpalaSqlParser.KW_LIMIT); this.state = 1878; + this.match(ImpalaSqlParser.KW_LIMIT); + this.state = 1879; localContext._rows = this.expression(); - this.state = 1881; + this.state = 1882; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 135) { { - this.state = 1879; - this.match(ImpalaSqlParser.KW_OFFSET); this.state = 1880; + this.match(ImpalaSqlParser.KW_OFFSET); + this.state = 1881; localContext._offset = this.match(ImpalaSqlParser.INTEGER_VALUE); } } @@ -8455,8 +8499,8 @@ export class ImpalaSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new QueryTermContext(this.context, parentState); let previousContext = localContext; - let _startState = 260; - this.enterRecursionRule(localContext, 260, ImpalaSqlParser.RULE_queryTerm, _p); + let _startState = 264; + this.enterRecursionRule(localContext, 264, ImpalaSqlParser.RULE_queryTerm, _p); let _la: number; try { let alternative: number; @@ -8467,13 +8511,13 @@ export class ImpalaSqlParser extends SQLParserBase { this.context = localContext; previousContext = localContext; - this.state = 1886; + this.state = 1887; this.queryPrimary(); } this.context!.stop = this.tokenStream.LT(-1); - this.state = 1902; + this.state = 1903; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 231, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 232, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { if (this._parseListeners != null) { @@ -8481,31 +8525,31 @@ export class ImpalaSqlParser extends SQLParserBase { } previousContext = localContext; { - this.state = 1900; + this.state = 1901; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 230, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 231, this.context) ) { case 1: { localContext = new SetOperationContext(new QueryTermContext(parentContext, parentState)); (localContext as SetOperationContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_queryTerm); - this.state = 1888; + this.state = 1889; if (!(this.precpred(this.context, 2))) { throw this.createFailedPredicateException("this.precpred(this.context, 2)"); } - this.state = 1889; + this.state = 1890; (localContext as SetOperationContext)._operator = this.match(ImpalaSqlParser.KW_INTERSECT); - this.state = 1891; + this.state = 1892; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2 || _la === 57) { { - this.state = 1890; + this.state = 1891; this.setQuantifier(); } } - this.state = 1893; + this.state = 1894; (localContext as SetOperationContext)._right = this.queryTerm(3); } break; @@ -8514,11 +8558,11 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SetOperationContext(new QueryTermContext(parentContext, parentState)); (localContext as SetOperationContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_queryTerm); - this.state = 1894; + this.state = 1895; if (!(this.precpred(this.context, 1))) { throw this.createFailedPredicateException("this.precpred(this.context, 1)"); } - this.state = 1895; + this.state = 1896; (localContext as SetOperationContext)._operator = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 64 || _la === 200)) { @@ -8528,26 +8572,26 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1897; + this.state = 1898; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2 || _la === 57) { { - this.state = 1896; + this.state = 1897; this.setQuantifier(); } } - this.state = 1899; + this.state = 1900; (localContext as SetOperationContext)._right = this.queryTerm(2); } break; } } } - this.state = 1904; + this.state = 1905; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 231, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 232, this.context); } } } @@ -8567,17 +8611,17 @@ export class ImpalaSqlParser extends SQLParserBase { } public queryPrimary(): QueryPrimaryContext { let localContext = new QueryPrimaryContext(this.context, this.state); - this.enterRule(localContext, 262, ImpalaSqlParser.RULE_queryPrimary); + this.enterRule(localContext, 266, ImpalaSqlParser.RULE_queryPrimary); try { let alternative: number; - this.state = 1921; + this.state = 1922; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_SELECT: localContext = new QueryPrimaryDefaultContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 1905; + this.state = 1906; this.querySpecification(); } break; @@ -8585,9 +8629,9 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new TableContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 1906; - this.match(ImpalaSqlParser.KW_TABLE); this.state = 1907; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 1908; this.tableNamePath(); } break; @@ -8595,27 +8639,27 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new InlineTableContext(localContext); this.enterOuterAlt(localContext, 3); { - this.state = 1908; - this.match(ImpalaSqlParser.KW_VALUES); this.state = 1909; + this.match(ImpalaSqlParser.KW_VALUES); + this.state = 1910; this.expression(); - this.state = 1914; + this.state = 1915; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 232, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 233, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1910; - this.match(ImpalaSqlParser.COMMA); this.state = 1911; + this.match(ImpalaSqlParser.COMMA); + this.state = 1912; this.expression(); } } } - this.state = 1916; + this.state = 1917; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 232, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 233, this.context); } } break; @@ -8623,11 +8667,11 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SubqueryContext(localContext); this.enterOuterAlt(localContext, 4); { - this.state = 1917; - this.match(ImpalaSqlParser.LPAREN); this.state = 1918; - this.queryNoWith(); + this.match(ImpalaSqlParser.LPAREN); this.state = 1919; + this.queryNoWith(); + this.state = 1920; this.match(ImpalaSqlParser.RPAREN); } break; @@ -8651,19 +8695,19 @@ export class ImpalaSqlParser extends SQLParserBase { } public sortItem(): SortItemContext { let localContext = new SortItemContext(this.context, this.state); - this.enterRule(localContext, 264, ImpalaSqlParser.RULE_sortItem); + this.enterRule(localContext, 268, ImpalaSqlParser.RULE_sortItem); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1923; + this.state = 1924; this.columnItem(); - this.state = 1925; + this.state = 1926; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 10 || _la === 55) { { - this.state = 1924; + this.state = 1925; localContext._ordering = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 10 || _la === 55)) { @@ -8676,14 +8720,14 @@ export class ImpalaSqlParser extends SQLParserBase { } } - this.state = 1929; + this.state = 1930; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 134) { { - this.state = 1927; - this.match(ImpalaSqlParser.KW_NULLS); this.state = 1928; + this.match(ImpalaSqlParser.KW_NULLS); + this.state = 1929; localContext._nullOrdering = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 75 || _la === 112)) { @@ -8714,117 +8758,117 @@ export class ImpalaSqlParser extends SQLParserBase { } public querySpecification(): QuerySpecificationContext { let localContext = new QuerySpecificationContext(this.context, this.state); - this.enterRule(localContext, 266, ImpalaSqlParser.RULE_querySpecification); + this.enterRule(localContext, 270, ImpalaSqlParser.RULE_querySpecification); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1931; + this.state = 1932; this.match(ImpalaSqlParser.KW_SELECT); - this.state = 1933; + this.state = 1934; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 236, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 237, this.context) ) { case 1: { - this.state = 1932; + this.state = 1933; this.setQuantifier(); } break; } - this.state = 1936; + this.state = 1937; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 237, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 238, this.context) ) { case 1: { - this.state = 1935; + this.state = 1936; this.match(ImpalaSqlParser.KW_STRAIGHT_JOIN); } break; } - this.state = 1938; + this.state = 1939; this.selectItem(); - this.state = 1943; + this.state = 1944; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 238, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 239, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1939; - this.match(ImpalaSqlParser.COMMA); this.state = 1940; + this.match(ImpalaSqlParser.COMMA); + this.state = 1941; this.selectItem(); } } } - this.state = 1945; + this.state = 1946; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 238, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 239, this.context); } - this.state = 1955; + this.state = 1956; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 240, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 241, this.context) ) { case 1: { - this.state = 1946; - this.match(ImpalaSqlParser.KW_FROM); this.state = 1947; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 1948; this.relation(0); - this.state = 1952; + this.state = 1953; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 239, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 240, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1948; - this.match(ImpalaSqlParser.COMMA); this.state = 1949; + this.match(ImpalaSqlParser.COMMA); + this.state = 1950; this.relation(0); } } } - this.state = 1954; + this.state = 1955; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 239, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 240, this.context); } } break; } - this.state = 1959; + this.state = 1960; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 241, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 242, this.context) ) { case 1: { - this.state = 1957; - this.match(ImpalaSqlParser.KW_WHERE); this.state = 1958; + this.match(ImpalaSqlParser.KW_WHERE); + this.state = 1959; localContext._where = this.booleanExpression(0); } break; } - this.state = 1964; + this.state = 1965; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 242, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 243, this.context) ) { case 1: { - this.state = 1961; - this.match(ImpalaSqlParser.KW_GROUP); this.state = 1962; - this.match(ImpalaSqlParser.KW_BY); + this.match(ImpalaSqlParser.KW_GROUP); this.state = 1963; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1964; this.groupBy(); } break; } - this.state = 1968; + this.state = 1969; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 243, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 244, this.context) ) { case 1: { - this.state = 1966; - this.match(ImpalaSqlParser.KW_HAVING); this.state = 1967; + this.match(ImpalaSqlParser.KW_HAVING); + this.state = 1968; localContext._having = this.booleanExpression(0); } break; @@ -8847,40 +8891,40 @@ export class ImpalaSqlParser extends SQLParserBase { } public groupBy(): GroupByContext { let localContext = new GroupByContext(this.context, this.state); - this.enterRule(localContext, 268, ImpalaSqlParser.RULE_groupBy); + this.enterRule(localContext, 272, ImpalaSqlParser.RULE_groupBy); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1971; + this.state = 1972; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 244, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 245, this.context) ) { case 1: { - this.state = 1970; + this.state = 1971; this.setQuantifier(); } break; } - this.state = 1973; + this.state = 1974; this.groupingElement(); - this.state = 1978; + this.state = 1979; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 245, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 246, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1974; - this.match(ImpalaSqlParser.COMMA); this.state = 1975; + this.match(ImpalaSqlParser.COMMA); + this.state = 1976; this.groupingElement(); } } } - this.state = 1980; + this.state = 1981; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 245, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 246, this.context); } } } @@ -8900,12 +8944,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public groupingElement(): GroupingElementContext { let localContext = new GroupingElementContext(this.context, this.state); - this.enterRule(localContext, 270, ImpalaSqlParser.RULE_groupingElement); + this.enterRule(localContext, 274, ImpalaSqlParser.RULE_groupingElement); try { localContext = new SingleGroupingSetContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 1981; + this.state = 1982; this.groupingSet(); } } @@ -8925,51 +8969,51 @@ export class ImpalaSqlParser extends SQLParserBase { } public groupingSet(): GroupingSetContext { let localContext = new GroupingSetContext(this.context, this.state); - this.enterRule(localContext, 272, ImpalaSqlParser.RULE_groupingSet); + this.enterRule(localContext, 276, ImpalaSqlParser.RULE_groupingSet); let _la: number; try { - this.state = 1996; + this.state = 1997; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 248, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 249, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1983; + this.state = 1984; this.match(ImpalaSqlParser.LPAREN); - this.state = 1992; + this.state = 1993; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 247, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 248, this.context) ) { case 1: { - this.state = 1984; + this.state = 1985; this.columnItem(); - this.state = 1989; + this.state = 1990; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 1985; - this.match(ImpalaSqlParser.COMMA); this.state = 1986; + this.match(ImpalaSqlParser.COMMA); + this.state = 1987; this.columnItem(); } } - this.state = 1991; + this.state = 1992; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } break; } - this.state = 1994; + this.state = 1995; this.match(ImpalaSqlParser.RPAREN); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1995; + this.state = 1996; this.columnItem(); } break; @@ -8991,26 +9035,26 @@ export class ImpalaSqlParser extends SQLParserBase { } public namedQuery(): NamedQueryContext { let localContext = new NamedQueryContext(this.context, this.state); - this.enterRule(localContext, 274, ImpalaSqlParser.RULE_namedQuery); + this.enterRule(localContext, 278, ImpalaSqlParser.RULE_namedQuery); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1998; + this.state = 1999; localContext._name = this.identifier(); - this.state = 2000; + this.state = 2001; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 265) { { - this.state = 1999; + this.state = 2000; this.columnAliases(); } } - this.state = 2002; - this.match(ImpalaSqlParser.KW_AS); this.state = 2003; + this.match(ImpalaSqlParser.KW_AS); + this.state = 2004; this.subQueryRelation(); } } @@ -9030,12 +9074,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public setQuantifier(): SetQuantifierContext { let localContext = new SetQuantifierContext(this.context, this.state); - this.enterRule(localContext, 276, ImpalaSqlParser.RULE_setQuantifier); + this.enterRule(localContext, 280, ImpalaSqlParser.RULE_setQuantifier); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2005; + this.state = 2006; _la = this.tokenStream.LA(1); if(!(_la === 2 || _la === 57)) { this.errorHandler.recoverInline(this); @@ -9062,34 +9106,34 @@ export class ImpalaSqlParser extends SQLParserBase { } public selectItem(): SelectItemContext { let localContext = new SelectItemContext(this.context, this.state); - this.enterRule(localContext, 278, ImpalaSqlParser.RULE_selectItem); + this.enterRule(localContext, 282, ImpalaSqlParser.RULE_selectItem); let _la: number; try { - this.state = 2019; + this.state = 2020; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 252, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 253, this.context) ) { case 1: localContext = new SelectSingleContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2007; + this.state = 2008; this.columnItem(); - this.state = 2012; + this.state = 2013; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 251, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 252, this.context) ) { case 1: { - this.state = 2009; + this.state = 2010; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 2008; + this.state = 2009; this.match(ImpalaSqlParser.KW_AS); } } - this.state = 2011; + this.state = 2012; this.identifier(); } break; @@ -9100,11 +9144,11 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SelectAllContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 2014; - this.qualifiedName(); this.state = 2015; - this.match(ImpalaSqlParser.DOT); + this.qualifiedName(); this.state = 2016; + this.match(ImpalaSqlParser.DOT); + this.state = 2017; this.match(ImpalaSqlParser.ASTERISK); } break; @@ -9112,7 +9156,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SelectAllContext(localContext); this.enterOuterAlt(localContext, 3); { - this.state = 2018; + this.state = 2019; this.match(ImpalaSqlParser.ASTERISK); } break; @@ -9144,8 +9188,8 @@ export class ImpalaSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new RelationContext(this.context, parentState); let previousContext = localContext; - let _startState = 280; - this.enterRecursionRule(localContext, 280, ImpalaSqlParser.RULE_relation, _p); + let _startState = 284; + this.enterRecursionRule(localContext, 284, ImpalaSqlParser.RULE_relation, _p); try { let alternative: number; this.enterOuterAlt(localContext, 1); @@ -9155,13 +9199,13 @@ export class ImpalaSqlParser extends SQLParserBase { this.context = localContext; previousContext = localContext; - this.state = 2022; + this.state = 2023; this.sampledRelation(); } this.context!.stop = this.tokenStream.LT(-1); - this.state = 2037; + this.state = 2038; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 254, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 255, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { if (this._parseListeners != null) { @@ -9173,20 +9217,20 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new JoinRelationContext(new RelationContext(parentContext, parentState)); (localContext as JoinRelationContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_relation); - this.state = 2024; + this.state = 2025; if (!(this.precpred(this.context, 2))) { throw this.createFailedPredicateException("this.precpred(this.context, 2)"); } - this.state = 2033; + this.state = 2034; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_CROSS: { - this.state = 2025; - this.match(ImpalaSqlParser.KW_CROSS); this.state = 2026; - this.match(ImpalaSqlParser.KW_JOIN); + this.match(ImpalaSqlParser.KW_CROSS); this.state = 2027; + this.match(ImpalaSqlParser.KW_JOIN); + this.state = 2028; (localContext as JoinRelationContext)._right = this.sampledRelation(); } break; @@ -9196,13 +9240,13 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.KW_LEFT: case ImpalaSqlParser.KW_RIGHT: { - this.state = 2028; - this.joinType(); this.state = 2029; - this.match(ImpalaSqlParser.KW_JOIN); + this.joinType(); this.state = 2030; - (localContext as JoinRelationContext)._rightRelation = this.relation(0); + this.match(ImpalaSqlParser.KW_JOIN); this.state = 2031; + (localContext as JoinRelationContext)._rightRelation = this.relation(0); + this.state = 2032; this.joinCriteria(); } break; @@ -9212,9 +9256,9 @@ export class ImpalaSqlParser extends SQLParserBase { } } } - this.state = 2039; + this.state = 2040; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 254, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 255, this.context); } } } @@ -9234,21 +9278,21 @@ export class ImpalaSqlParser extends SQLParserBase { } public joinType(): JoinTypeContext { let localContext = new JoinTypeContext(this.context, this.state); - this.enterRule(localContext, 282, ImpalaSqlParser.RULE_joinType); + this.enterRule(localContext, 286, ImpalaSqlParser.RULE_joinType); let _la: number; try { - this.state = 2071; + this.state = 2072; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 261, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 262, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2041; + this.state = 2042; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 97) { { - this.state = 2040; + this.state = 2041; this.match(ImpalaSqlParser.KW_INNER); } } @@ -9258,14 +9302,14 @@ export class ImpalaSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2043; + this.state = 2044; this.match(ImpalaSqlParser.KW_LEFT); - this.state = 2045; + this.state = 2046; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 97) { { - this.state = 2044; + this.state = 2045; this.match(ImpalaSqlParser.KW_INNER); } } @@ -9275,14 +9319,14 @@ export class ImpalaSqlParser extends SQLParserBase { case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2047; + this.state = 2048; this.match(ImpalaSqlParser.KW_RIGHT); - this.state = 2049; + this.state = 2050; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 97) { { - this.state = 2048; + this.state = 2049; this.match(ImpalaSqlParser.KW_INNER); } } @@ -9292,14 +9336,14 @@ export class ImpalaSqlParser extends SQLParserBase { case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2051; + this.state = 2052; this.match(ImpalaSqlParser.KW_LEFT); - this.state = 2053; + this.state = 2054; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 141) { { - this.state = 2052; + this.state = 2053; this.match(ImpalaSqlParser.KW_OUTER); } } @@ -9309,14 +9353,14 @@ export class ImpalaSqlParser extends SQLParserBase { case 5: this.enterOuterAlt(localContext, 5); { - this.state = 2055; + this.state = 2056; this.match(ImpalaSqlParser.KW_RIGHT); - this.state = 2057; + this.state = 2058; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 141) { { - this.state = 2056; + this.state = 2057; this.match(ImpalaSqlParser.KW_OUTER); } } @@ -9326,14 +9370,14 @@ export class ImpalaSqlParser extends SQLParserBase { case 6: this.enterOuterAlt(localContext, 6); { - this.state = 2059; + this.state = 2060; this.match(ImpalaSqlParser.KW_FULL); - this.state = 2061; + this.state = 2062; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 141) { { - this.state = 2060; + this.state = 2061; this.match(ImpalaSqlParser.KW_OUTER); } } @@ -9343,36 +9387,36 @@ export class ImpalaSqlParser extends SQLParserBase { case 7: this.enterOuterAlt(localContext, 7); { - this.state = 2063; - this.match(ImpalaSqlParser.KW_LEFT); this.state = 2064; + this.match(ImpalaSqlParser.KW_LEFT); + this.state = 2065; this.match(ImpalaSqlParser.KW_SEMI); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 2065; - this.match(ImpalaSqlParser.KW_RIGHT); this.state = 2066; + this.match(ImpalaSqlParser.KW_RIGHT); + this.state = 2067; this.match(ImpalaSqlParser.KW_SEMI); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 2067; - this.match(ImpalaSqlParser.KW_LEFT); this.state = 2068; + this.match(ImpalaSqlParser.KW_LEFT); + this.state = 2069; this.match(ImpalaSqlParser.KW_ANTI); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 2069; - this.match(ImpalaSqlParser.KW_RIGHT); this.state = 2070; + this.match(ImpalaSqlParser.KW_RIGHT); + this.state = 2071; this.match(ImpalaSqlParser.KW_ANTI); } break; @@ -9394,47 +9438,47 @@ export class ImpalaSqlParser extends SQLParserBase { } public joinCriteria(): JoinCriteriaContext { let localContext = new JoinCriteriaContext(this.context, this.state); - this.enterRule(localContext, 284, ImpalaSqlParser.RULE_joinCriteria); + this.enterRule(localContext, 288, ImpalaSqlParser.RULE_joinCriteria); let _la: number; try { - this.state = 2087; + this.state = 2088; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_ON: this.enterOuterAlt(localContext, 1); { - this.state = 2073; - this.match(ImpalaSqlParser.KW_ON); this.state = 2074; + this.match(ImpalaSqlParser.KW_ON); + this.state = 2075; this.booleanExpression(0); } break; case ImpalaSqlParser.KW_USING: this.enterOuterAlt(localContext, 2); { - this.state = 2075; - this.match(ImpalaSqlParser.KW_USING); this.state = 2076; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_USING); this.state = 2077; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2078; this.identifier(); - this.state = 2082; + this.state = 2083; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2078; - this.match(ImpalaSqlParser.COMMA); this.state = 2079; + this.match(ImpalaSqlParser.COMMA); + this.state = 2080; this.identifier(); } } - this.state = 2084; + this.state = 2085; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 2085; + this.state = 2086; this.match(ImpalaSqlParser.RPAREN); } break; @@ -9458,39 +9502,39 @@ export class ImpalaSqlParser extends SQLParserBase { } public sampledRelation(): SampledRelationContext { let localContext = new SampledRelationContext(this.context, this.state); - this.enterRule(localContext, 286, ImpalaSqlParser.RULE_sampledRelation); + this.enterRule(localContext, 290, ImpalaSqlParser.RULE_sampledRelation); try { this.enterOuterAlt(localContext, 1); { - this.state = 2089; + this.state = 2090; this.aliasedRelation(); - this.state = 2102; + this.state = 2103; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 265, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 266, this.context) ) { case 1: { - this.state = 2090; - this.match(ImpalaSqlParser.KW_TABLESAMPLE); this.state = 2091; - this.sampleType(); + this.match(ImpalaSqlParser.KW_TABLESAMPLE); this.state = 2092; - this.match(ImpalaSqlParser.LPAREN); + this.sampleType(); this.state = 2093; - localContext._percentage = this.expression(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2094; + localContext._percentage = this.expression(); + this.state = 2095; this.match(ImpalaSqlParser.RPAREN); - this.state = 2100; + this.state = 2101; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 264, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 265, this.context) ) { case 1: { - this.state = 2095; - this.match(ImpalaSqlParser.KW_REPEATABLE); this.state = 2096; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_REPEATABLE); this.state = 2097; - localContext._seed = this.expression(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2098; + localContext._seed = this.expression(); + this.state = 2099; this.match(ImpalaSqlParser.RPAREN); } break; @@ -9516,12 +9560,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public sampleType(): SampleTypeContext { let localContext = new SampleTypeContext(this.context, this.state); - this.enterRule(localContext, 288, ImpalaSqlParser.RULE_sampleType); + this.enterRule(localContext, 292, ImpalaSqlParser.RULE_sampleType); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2104; + this.state = 2105; _la = this.tokenStream.LA(1); if(!(_la === 14 || _la === 185)) { this.errorHandler.recoverInline(this); @@ -9548,36 +9592,36 @@ export class ImpalaSqlParser extends SQLParserBase { } public aliasedRelation(): AliasedRelationContext { let localContext = new AliasedRelationContext(this.context, this.state); - this.enterRule(localContext, 290, ImpalaSqlParser.RULE_aliasedRelation); + this.enterRule(localContext, 294, ImpalaSqlParser.RULE_aliasedRelation); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2106; + this.state = 2107; this.relationPrimary(); - this.state = 2114; + this.state = 2115; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 268, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 269, this.context) ) { case 1: { - this.state = 2108; + this.state = 2109; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 2107; + this.state = 2108; this.match(ImpalaSqlParser.KW_AS); } } - this.state = 2110; - this.identifier(); - this.state = 2112; + this.state = 2111; + localContext._alias = this.identifier(); + this.state = 2113; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 267, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 268, this.context) ) { case 1: { - this.state = 2111; + this.state = 2112; this.columnAliases(); } break; @@ -9603,32 +9647,32 @@ export class ImpalaSqlParser extends SQLParserBase { } public columnAliases(): ColumnAliasesContext { let localContext = new ColumnAliasesContext(this.context, this.state); - this.enterRule(localContext, 292, ImpalaSqlParser.RULE_columnAliases); + this.enterRule(localContext, 296, ImpalaSqlParser.RULE_columnAliases); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2116; - this.match(ImpalaSqlParser.LPAREN); this.state = 2117; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2118; this.columnNamePath(); - this.state = 2122; + this.state = 2123; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2118; - this.match(ImpalaSqlParser.COMMA); this.state = 2119; + this.match(ImpalaSqlParser.COMMA); + this.state = 2120; this.columnNamePath(); } } - this.state = 2124; + this.state = 2125; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 2125; + this.state = 2126; this.match(ImpalaSqlParser.RPAREN); } } @@ -9648,47 +9692,47 @@ export class ImpalaSqlParser extends SQLParserBase { } public relationPrimary(): RelationPrimaryContext { let localContext = new RelationPrimaryContext(this.context, this.state); - this.enterRule(localContext, 294, ImpalaSqlParser.RULE_relationPrimary); + this.enterRule(localContext, 298, ImpalaSqlParser.RULE_relationPrimary); let _la: number; try { - this.state = 2134; + this.state = 2135; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 271, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 272, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2127; + this.state = 2128; this.tableOrViewPath(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2129; + this.state = 2130; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 113) { { - this.state = 2128; + this.state = 2129; this.match(ImpalaSqlParser.KW_LATERAL); } } - this.state = 2131; + this.state = 2132; this.subQueryRelation(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2132; + this.state = 2133; this.unnest(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2133; + this.state = 2134; this.parenthesizedRelation(); } break; @@ -9710,15 +9754,15 @@ export class ImpalaSqlParser extends SQLParserBase { } public subQueryRelation(): SubQueryRelationContext { let localContext = new SubQueryRelationContext(this.context, this.state); - this.enterRule(localContext, 296, ImpalaSqlParser.RULE_subQueryRelation); + this.enterRule(localContext, 300, ImpalaSqlParser.RULE_subQueryRelation); try { this.enterOuterAlt(localContext, 1); { - this.state = 2136; - this.match(ImpalaSqlParser.LPAREN); this.state = 2137; - this.queryStatement(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2138; + this.queryStatement(); + this.state = 2139; this.match(ImpalaSqlParser.RPAREN); } } @@ -9738,43 +9782,43 @@ export class ImpalaSqlParser extends SQLParserBase { } public unnest(): UnnestContext { let localContext = new UnnestContext(this.context, this.state); - this.enterRule(localContext, 298, ImpalaSqlParser.RULE_unnest); + this.enterRule(localContext, 302, ImpalaSqlParser.RULE_unnest); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2140; - this.match(ImpalaSqlParser.KW_UNNEST); this.state = 2141; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_UNNEST); this.state = 2142; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2143; this.expression(); - this.state = 2147; + this.state = 2148; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2143; - this.match(ImpalaSqlParser.COMMA); this.state = 2144; + this.match(ImpalaSqlParser.COMMA); + this.state = 2145; this.expression(); } } - this.state = 2149; + this.state = 2150; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 2150; + this.state = 2151; this.match(ImpalaSqlParser.RPAREN); - this.state = 2153; + this.state = 2154; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 273, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 274, this.context) ) { case 1: { - this.state = 2151; - this.match(ImpalaSqlParser.KW_WITH); this.state = 2152; + this.match(ImpalaSqlParser.KW_WITH); + this.state = 2153; this.match(ImpalaSqlParser.KW_ORDINALITY); } break; @@ -9797,15 +9841,15 @@ export class ImpalaSqlParser extends SQLParserBase { } public parenthesizedRelation(): ParenthesizedRelationContext { let localContext = new ParenthesizedRelationContext(this.context, this.state); - this.enterRule(localContext, 300, ImpalaSqlParser.RULE_parenthesizedRelation); + this.enterRule(localContext, 304, ImpalaSqlParser.RULE_parenthesizedRelation); try { this.enterOuterAlt(localContext, 1); { - this.state = 2155; - this.match(ImpalaSqlParser.LPAREN); this.state = 2156; - this.relation(0); + this.match(ImpalaSqlParser.LPAREN); this.state = 2157; + this.relation(0); + this.state = 2158; this.match(ImpalaSqlParser.RPAREN); } } @@ -9825,22 +9869,22 @@ export class ImpalaSqlParser extends SQLParserBase { } public columnItem(): ColumnItemContext { let localContext = new ColumnItemContext(this.context, this.state); - this.enterRule(localContext, 302, ImpalaSqlParser.RULE_columnItem); + this.enterRule(localContext, 306, ImpalaSqlParser.RULE_columnItem); try { - this.state = 2161; + this.state = 2162; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 274, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 275, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2159; + this.state = 2160; this.columnNamePath(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2160; + this.state = 2161; this.expression(); } break; @@ -9862,11 +9906,11 @@ export class ImpalaSqlParser extends SQLParserBase { } public expression(): ExpressionContext { let localContext = new ExpressionContext(this.context, this.state); - this.enterRule(localContext, 304, ImpalaSqlParser.RULE_expression); + this.enterRule(localContext, 308, ImpalaSqlParser.RULE_expression); try { this.enterOuterAlt(localContext, 1); { - this.state = 2163; + this.state = 2164; this.booleanExpression(0); } } @@ -9896,13 +9940,13 @@ export class ImpalaSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new BooleanExpressionContext(this.context, parentState); let previousContext = localContext; - let _startState = 306; - this.enterRecursionRule(localContext, 306, ImpalaSqlParser.RULE_booleanExpression, _p); + let _startState = 310; + this.enterRecursionRule(localContext, 310, ImpalaSqlParser.RULE_booleanExpression, _p); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 2172; + this.state = 2173; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_ARRAY: @@ -9978,14 +10022,14 @@ export class ImpalaSqlParser extends SQLParserBase { this.context = localContext; previousContext = localContext; - this.state = 2166; + this.state = 2167; (localContext as PredicatedContext)._valueExpression = this.valueExpression(0); - this.state = 2168; + this.state = 2169; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 275, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 276, this.context) ) { case 1: { - this.state = 2167; + this.state = 2168; this.predicate((localContext as PredicatedContext)._valueExpression); } break; @@ -9997,9 +10041,9 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new LogicalNotContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2170; - this.match(ImpalaSqlParser.KW_NOT); this.state = 2171; + this.match(ImpalaSqlParser.KW_NOT); + this.state = 2172; this.booleanExpression(3); } break; @@ -10007,9 +10051,9 @@ export class ImpalaSqlParser extends SQLParserBase { throw new antlr.NoViableAltException(this); } this.context!.stop = this.tokenStream.LT(-1); - this.state = 2182; + this.state = 2183; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 278, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 279, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { if (this._parseListeners != null) { @@ -10017,21 +10061,21 @@ export class ImpalaSqlParser extends SQLParserBase { } previousContext = localContext; { - this.state = 2180; + this.state = 2181; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 277, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 278, this.context) ) { case 1: { localContext = new LogicalBinaryContext(new BooleanExpressionContext(parentContext, parentState)); (localContext as LogicalBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_booleanExpression); - this.state = 2174; + this.state = 2175; if (!(this.precpred(this.context, 2))) { throw this.createFailedPredicateException("this.precpred(this.context, 2)"); } - this.state = 2175; - (localContext as LogicalBinaryContext)._operator = this.match(ImpalaSqlParser.KW_AND); this.state = 2176; + (localContext as LogicalBinaryContext)._operator = this.match(ImpalaSqlParser.KW_AND); + this.state = 2177; (localContext as LogicalBinaryContext)._right = this.booleanExpression(3); } break; @@ -10040,22 +10084,22 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new LogicalBinaryContext(new BooleanExpressionContext(parentContext, parentState)); (localContext as LogicalBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_booleanExpression); - this.state = 2177; + this.state = 2178; if (!(this.precpred(this.context, 1))) { throw this.createFailedPredicateException("this.precpred(this.context, 1)"); } - this.state = 2178; - (localContext as LogicalBinaryContext)._operator = this.match(ImpalaSqlParser.KW_OR); this.state = 2179; + (localContext as LogicalBinaryContext)._operator = this.match(ImpalaSqlParser.KW_OR); + this.state = 2180; (localContext as LogicalBinaryContext)._right = this.booleanExpression(2); } break; } } } - this.state = 2184; + this.state = 2185; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 278, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 279, this.context); } } } @@ -10075,19 +10119,19 @@ export class ImpalaSqlParser extends SQLParserBase { } public predicate(value: antlr.ParserRuleContext): PredicateContext { let localContext = new PredicateContext(this.context, this.state, value); - this.enterRule(localContext, 308, ImpalaSqlParser.RULE_predicate); + this.enterRule(localContext, 312, ImpalaSqlParser.RULE_predicate); let _la: number; try { - this.state = 2243; + this.state = 2244; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 287, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 288, this.context) ) { case 1: localContext = new ComparisonContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2185; - this.comparisonOperator(); this.state = 2186; + this.comparisonOperator(); + this.state = 2187; (localContext as ComparisonContext)._right = this.valueExpression(0); } break; @@ -10095,11 +10139,11 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new QuantifiedComparisonContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 2188; - this.comparisonOperator(); this.state = 2189; - this.comparisonQuantifier(); + this.comparisonOperator(); this.state = 2190; + this.comparisonQuantifier(); + this.state = 2191; this.subQueryRelation(); } break; @@ -10107,23 +10151,23 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new BetweenContext(localContext); this.enterOuterAlt(localContext, 3); { - this.state = 2193; + this.state = 2194; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 132) { { - this.state = 2192; + this.state = 2193; this.match(ImpalaSqlParser.KW_NOT); } } - this.state = 2195; - this.match(ImpalaSqlParser.KW_BETWEEN); this.state = 2196; - (localContext as BetweenContext)._lower = this.valueExpression(0); + this.match(ImpalaSqlParser.KW_BETWEEN); this.state = 2197; - this.match(ImpalaSqlParser.KW_AND); + (localContext as BetweenContext)._lower = this.valueExpression(0); this.state = 2198; + this.match(ImpalaSqlParser.KW_AND); + this.state = 2199; (localContext as BetweenContext)._upper = this.valueExpression(0); } break; @@ -10131,39 +10175,39 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new InListContext(localContext); this.enterOuterAlt(localContext, 4); { - this.state = 2201; + this.state = 2202; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 132) { { - this.state = 2200; + this.state = 2201; this.match(ImpalaSqlParser.KW_NOT); } } - this.state = 2203; - this.match(ImpalaSqlParser.KW_IN); this.state = 2204; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_IN); this.state = 2205; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2206; this.expression(); - this.state = 2210; + this.state = 2211; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2206; - this.match(ImpalaSqlParser.COMMA); this.state = 2207; + this.match(ImpalaSqlParser.COMMA); + this.state = 2208; this.expression(); } } - this.state = 2212; + this.state = 2213; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 2213; + this.state = 2214; this.match(ImpalaSqlParser.RPAREN); } break; @@ -10171,19 +10215,19 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new InSubqueryContext(localContext); this.enterOuterAlt(localContext, 5); { - this.state = 2216; + this.state = 2217; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 132) { { - this.state = 2215; + this.state = 2216; this.match(ImpalaSqlParser.KW_NOT); } } - this.state = 2218; - this.match(ImpalaSqlParser.KW_IN); this.state = 2219; + this.match(ImpalaSqlParser.KW_IN); + this.state = 2220; this.subQueryRelation(); } break; @@ -10191,17 +10235,17 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new LikeContext(localContext); this.enterOuterAlt(localContext, 6); { - this.state = 2221; + this.state = 2222; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 132) { { - this.state = 2220; + this.state = 2221; this.match(ImpalaSqlParser.KW_NOT); } } - this.state = 2223; + this.state = 2224; _la = this.tokenStream.LA(1); if(!(_la === 106 || _la === 115 || _la === 164)) { this.errorHandler.recoverInline(this); @@ -10210,16 +10254,16 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 2224; + this.state = 2225; (localContext as LikeContext)._pattern = this.valueExpression(0); - this.state = 2227; + this.state = 2228; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 284, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 285, this.context) ) { case 1: { - this.state = 2225; - this.match(ImpalaSqlParser.KW_ESCAPE); this.state = 2226; + this.match(ImpalaSqlParser.KW_ESCAPE); + this.state = 2227; (localContext as LikeContext)._escape = this.valueExpression(0); } break; @@ -10230,7 +10274,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new REGEXPContext(localContext); this.enterOuterAlt(localContext, 7); { - this.state = 2229; + this.state = 2230; _la = this.tokenStream.LA(1); if(!(_la === 105 || _la === 163)) { this.errorHandler.recoverInline(this); @@ -10239,7 +10283,7 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 2230; + this.state = 2231; (localContext as REGEXPContext)._pattern = this.valueExpression(0); } break; @@ -10247,19 +10291,19 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new NullOrUnKnownOrBooleanPredicateContext(localContext); this.enterOuterAlt(localContext, 8); { - this.state = 2231; + this.state = 2232; this.match(ImpalaSqlParser.KW_IS); - this.state = 2233; + this.state = 2234; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 132) { { - this.state = 2232; + this.state = 2233; this.match(ImpalaSqlParser.KW_NOT); } } - this.state = 2235; + this.state = 2236; _la = this.tokenStream.LA(1); if(!(_la === 70 || _la === 133 || _la === 194 || _la === 208)) { this.errorHandler.recoverInline(this); @@ -10274,23 +10318,23 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new DistinctFromContext(localContext); this.enterOuterAlt(localContext, 9); { - this.state = 2236; + this.state = 2237; this.match(ImpalaSqlParser.KW_IS); - this.state = 2238; + this.state = 2239; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 132) { { - this.state = 2237; + this.state = 2238; this.match(ImpalaSqlParser.KW_NOT); } } - this.state = 2240; - this.match(ImpalaSqlParser.KW_DISTINCT); this.state = 2241; - this.match(ImpalaSqlParser.KW_FROM); + this.match(ImpalaSqlParser.KW_DISTINCT); this.state = 2242; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 2243; (localContext as DistinctFromContext)._right = this.valueExpression(0); } break; @@ -10322,23 +10366,23 @@ export class ImpalaSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new ValueExpressionContext(this.context, parentState); let previousContext = localContext; - let _startState = 310; - this.enterRecursionRule(localContext, 310, ImpalaSqlParser.RULE_valueExpression, _p); + let _startState = 314; + this.enterRecursionRule(localContext, 314, ImpalaSqlParser.RULE_valueExpression, _p); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 2249; + this.state = 2250; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 288, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 289, this.context) ) { case 1: { localContext = new ValueExpressionDefaultContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2246; + this.state = 2247; this.primaryExpression(0); } break; @@ -10347,7 +10391,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new ArithmeticUnaryContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2247; + this.state = 2248; (localContext as ArithmeticUnaryContext)._operator = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 255 || _la === 256)) { @@ -10357,15 +10401,15 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 2248; + this.state = 2249; this.valueExpression(4); } break; } this.context!.stop = this.tokenStream.LT(-1); - this.state = 2262; + this.state = 2263; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 290, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 291, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { if (this._parseListeners != null) { @@ -10373,19 +10417,19 @@ export class ImpalaSqlParser extends SQLParserBase { } previousContext = localContext; { - this.state = 2260; + this.state = 2261; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 289, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 290, this.context) ) { case 1: { localContext = new ArithmeticBinaryContext(new ValueExpressionContext(parentContext, parentState)); (localContext as ArithmeticBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_valueExpression); - this.state = 2251; + this.state = 2252; if (!(this.precpred(this.context, 3))) { throw this.createFailedPredicateException("this.precpred(this.context, 3)"); } - this.state = 2252; + this.state = 2253; (localContext as ArithmeticBinaryContext)._operator = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 7) !== 0))) { @@ -10395,7 +10439,7 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 2253; + this.state = 2254; (localContext as ArithmeticBinaryContext)._right = this.valueExpression(4); } break; @@ -10404,11 +10448,11 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new ArithmeticBinaryContext(new ValueExpressionContext(parentContext, parentState)); (localContext as ArithmeticBinaryContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_valueExpression); - this.state = 2254; + this.state = 2255; if (!(this.precpred(this.context, 2))) { throw this.createFailedPredicateException("this.precpred(this.context, 2)"); } - this.state = 2255; + this.state = 2256; (localContext as ArithmeticBinaryContext)._operator = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 255 || _la === 256)) { @@ -10418,7 +10462,7 @@ export class ImpalaSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 2256; + this.state = 2257; (localContext as ArithmeticBinaryContext)._right = this.valueExpression(3); } break; @@ -10427,22 +10471,22 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new ConcatenationContext(new ValueExpressionContext(parentContext, parentState)); (localContext as ConcatenationContext)._left = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_valueExpression); - this.state = 2257; + this.state = 2258; if (!(this.precpred(this.context, 1))) { throw this.createFailedPredicateException("this.precpred(this.context, 1)"); } - this.state = 2258; - this.match(ImpalaSqlParser.CONCAT); this.state = 2259; + this.match(ImpalaSqlParser.CONCAT); + this.state = 2260; (localContext as ConcatenationContext)._right = this.valueExpression(2); } break; } } } - this.state = 2264; + this.state = 2265; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 290, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 291, this.context); } } } @@ -10472,23 +10516,23 @@ export class ImpalaSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new PrimaryExpressionContext(this.context, parentState); let previousContext = localContext; - let _startState = 312; - this.enterRecursionRule(localContext, 312, ImpalaSqlParser.RULE_primaryExpression, _p); + let _startState = 316; + this.enterRecursionRule(localContext, 316, ImpalaSqlParser.RULE_primaryExpression, _p); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 2511; + this.state = 2512; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 320, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 321, this.context) ) { case 1: { localContext = new NullLiteralContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2266; + this.state = 2267; this.match(ImpalaSqlParser.KW_NULL); } break; @@ -10497,7 +10541,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new IntervalLiteralContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2267; + this.state = 2268; this.interval(); } break; @@ -10506,9 +10550,9 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new TypeConstructorContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2268; - this.identifier(); this.state = 2269; + this.identifier(); + this.state = 2270; this.stringLiteral(); } break; @@ -10517,9 +10561,9 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new TypeConstructorContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2271; - this.match(ImpalaSqlParser.DOUBLE_PRECISION); this.state = 2272; + this.match(ImpalaSqlParser.DOUBLE_PRECISION); + this.state = 2273; this.stringLiteral(); } break; @@ -10528,7 +10572,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new NumericLiteralContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2273; + this.state = 2274; this.number_(); } break; @@ -10537,7 +10581,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new BooleanLiteralContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2274; + this.state = 2275; this.booleanValue(); } break; @@ -10546,7 +10590,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new StringLiteralValuesContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2275; + this.state = 2276; this.stringLiteral(); } break; @@ -10555,7 +10599,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new BinaryLiteralContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2276; + this.state = 2277; this.match(ImpalaSqlParser.BINARY_LITERAL); } break; @@ -10564,7 +10608,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new ParameterContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2277; + this.state = 2278; this.match(ImpalaSqlParser.QUESTION); } break; @@ -10573,17 +10617,17 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new PositionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2278; - this.match(ImpalaSqlParser.KW_POSITION); this.state = 2279; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_POSITION); this.state = 2280; - this.valueExpression(0); + this.match(ImpalaSqlParser.LPAREN); this.state = 2281; - this.match(ImpalaSqlParser.KW_IN); - this.state = 2282; this.valueExpression(0); + this.state = 2282; + this.match(ImpalaSqlParser.KW_IN); this.state = 2283; + this.valueExpression(0); + this.state = 2284; this.match(ImpalaSqlParser.RPAREN); } break; @@ -10592,41 +10636,41 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new RowConstructorContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2285; - this.match(ImpalaSqlParser.LPAREN); this.state = 2286; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2287; this.expression(); - this.state = 2289; + this.state = 2290; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 2287; - this.match(ImpalaSqlParser.KW_AS); this.state = 2288; + this.match(ImpalaSqlParser.KW_AS); + this.state = 2289; this.type_(0); } } - this.state = 2299; + this.state = 2300; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 293, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 294, this.context); while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1 + 1) { { { - this.state = 2291; - this.match(ImpalaSqlParser.COMMA); this.state = 2292; + this.match(ImpalaSqlParser.COMMA); + this.state = 2293; this.expression(); - this.state = 2295; + this.state = 2296; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 2293; - this.match(ImpalaSqlParser.KW_AS); this.state = 2294; + this.match(ImpalaSqlParser.KW_AS); + this.state = 2295; this.type_(0); } } @@ -10634,11 +10678,11 @@ export class ImpalaSqlParser extends SQLParserBase { } } } - this.state = 2301; + this.state = 2302; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 293, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 294, this.context); } - this.state = 2302; + this.state = 2303; this.match(ImpalaSqlParser.RPAREN); } break; @@ -10647,29 +10691,29 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new RowConstructorContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2304; - this.match(ImpalaSqlParser.KW_ROW); this.state = 2305; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_ROW); this.state = 2306; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2307; this.expression(); - this.state = 2311; + this.state = 2312; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2307; - this.match(ImpalaSqlParser.COMMA); this.state = 2308; + this.match(ImpalaSqlParser.COMMA); + this.state = 2309; this.expression(); } } - this.state = 2313; + this.state = 2314; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 2314; + this.state = 2315; this.match(ImpalaSqlParser.RPAREN); } break; @@ -10678,30 +10722,30 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new FunctionCallContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2316; - this.functionNamePath(); this.state = 2317; - this.match(ImpalaSqlParser.LPAREN); + this.functionNamePath(); this.state = 2318; - this.match(ImpalaSqlParser.ASTERISK); + this.match(ImpalaSqlParser.LPAREN); this.state = 2319; + this.match(ImpalaSqlParser.ASTERISK); + this.state = 2320; this.match(ImpalaSqlParser.RPAREN); - this.state = 2321; + this.state = 2322; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 295, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 296, this.context) ) { case 1: { - this.state = 2320; + this.state = 2321; this.filter(); } break; } - this.state = 2324; + this.state = 2325; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 296, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 297, this.context) ) { case 1: { - this.state = 2323; + this.state = 2324; this.over(); } break; @@ -10713,94 +10757,94 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new FunctionCallContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2326; - this.functionNamePath(); this.state = 2327; + this.functionNamePath(); + this.state = 2328; this.match(ImpalaSqlParser.LPAREN); - this.state = 2339; + this.state = 2340; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805323012) !== 0) || ((((_la - 40)) & ~0x1F) === 0 && ((1 << (_la - 40)) & 1442972447) !== 0) || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & 2218795145) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & 269631421) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & 271654979) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & 537926659) !== 0) || ((((_la - 217)) & ~0x1F) === 0 && ((1 << (_la - 217)) & 16393) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & 2549744643) !== 0)) { { - this.state = 2329; + this.state = 2330; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2 || _la === 57) { { - this.state = 2328; + this.state = 2329; this.setQuantifier(); } } - this.state = 2331; + this.state = 2332; this.expression(); - this.state = 2336; + this.state = 2337; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2332; - this.match(ImpalaSqlParser.COMMA); this.state = 2333; + this.match(ImpalaSqlParser.COMMA); + this.state = 2334; this.expression(); } } - this.state = 2338; + this.state = 2339; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 2351; + this.state = 2352; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 139) { { - this.state = 2341; - this.match(ImpalaSqlParser.KW_ORDER); this.state = 2342; - this.match(ImpalaSqlParser.KW_BY); + this.match(ImpalaSqlParser.KW_ORDER); this.state = 2343; + this.match(ImpalaSqlParser.KW_BY); + this.state = 2344; this.sortItem(); - this.state = 2348; + this.state = 2349; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2344; - this.match(ImpalaSqlParser.COMMA); this.state = 2345; + this.match(ImpalaSqlParser.COMMA); + this.state = 2346; this.sortItem(); } } - this.state = 2350; + this.state = 2351; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 2353; + this.state = 2354; this.match(ImpalaSqlParser.RPAREN); - this.state = 2355; + this.state = 2356; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 302, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 303, this.context) ) { case 1: { - this.state = 2354; + this.state = 2355; this.filter(); } break; } - this.state = 2358; + this.state = 2359; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 303, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 304, this.context) ) { case 1: { - this.state = 2357; + this.state = 2358; this.over(); } break; @@ -10812,11 +10856,11 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new LambdaContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2360; - this.identifier(); this.state = 2361; - this.match(ImpalaSqlParser.RIGHT_ARROW); + this.identifier(); this.state = 2362; + this.match(ImpalaSqlParser.RIGHT_ARROW); + this.state = 2363; this.expression(); } break; @@ -10825,39 +10869,39 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new LambdaContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2364; + this.state = 2365; this.match(ImpalaSqlParser.LPAREN); - this.state = 2373; + this.state = 2374; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 2365; + this.state = 2366; this.identifier(); - this.state = 2370; + this.state = 2371; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2366; - this.match(ImpalaSqlParser.COMMA); this.state = 2367; + this.match(ImpalaSqlParser.COMMA); + this.state = 2368; this.identifier(); } } - this.state = 2372; + this.state = 2373; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 2375; - this.match(ImpalaSqlParser.RPAREN); this.state = 2376; - this.match(ImpalaSqlParser.RIGHT_ARROW); + this.match(ImpalaSqlParser.RPAREN); this.state = 2377; + this.match(ImpalaSqlParser.RIGHT_ARROW); + this.state = 2378; this.expression(); } break; @@ -10866,11 +10910,11 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SubqueryExpressionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2378; - this.match(ImpalaSqlParser.LPAREN); this.state = 2379; - this.queryStatement(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2380; + this.queryStatement(); + this.state = 2381; this.match(ImpalaSqlParser.RPAREN); } break; @@ -10879,13 +10923,13 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new ExistsContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2382; - this.match(ImpalaSqlParser.KW_EXISTS); this.state = 2383; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_EXISTS); this.state = 2384; - this.queryStatement(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2385; + this.queryStatement(); + this.state = 2386; this.match(ImpalaSqlParser.RPAREN); } break; @@ -10894,37 +10938,37 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SimpleCaseContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2387; - this.match(ImpalaSqlParser.KW_CASE); this.state = 2388; + this.match(ImpalaSqlParser.KW_CASE); + this.state = 2389; this.valueExpression(0); - this.state = 2390; + this.state = 2391; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 2389; + this.state = 2390; this.whenClause(); } } - this.state = 2392; + this.state = 2393; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 214); - this.state = 2396; + this.state = 2397; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 59) { { - this.state = 2394; - this.match(ImpalaSqlParser.KW_ELSE); this.state = 2395; + this.match(ImpalaSqlParser.KW_ELSE); + this.state = 2396; (localContext as SimpleCaseContext)._elseExpression = this.expression(); } } - this.state = 2398; + this.state = 2399; this.match(ImpalaSqlParser.KW_END); } break; @@ -10933,35 +10977,35 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SearchedCaseContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2400; + this.state = 2401; this.match(ImpalaSqlParser.KW_CASE); - this.state = 2402; + this.state = 2403; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 2401; + this.state = 2402; this.whenClause(); } } - this.state = 2404; + this.state = 2405; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 214); - this.state = 2408; + this.state = 2409; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 59) { { - this.state = 2406; - this.match(ImpalaSqlParser.KW_ELSE); this.state = 2407; + this.match(ImpalaSqlParser.KW_ELSE); + this.state = 2408; (localContext as SearchedCaseContext)._elseExpression = this.expression(); } } - this.state = 2410; + this.state = 2411; this.match(ImpalaSqlParser.KW_END); } break; @@ -10970,17 +11014,17 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new CastContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2412; - this.match(ImpalaSqlParser.KW_CAST); this.state = 2413; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_CAST); this.state = 2414; - this.expression(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2415; - this.match(ImpalaSqlParser.KW_AS); + this.expression(); this.state = 2416; - this.type_(0); + this.match(ImpalaSqlParser.KW_AS); this.state = 2417; + this.type_(0); + this.state = 2418; this.match(ImpalaSqlParser.RPAREN); } break; @@ -10989,17 +11033,17 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new CastContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2419; - this.match(ImpalaSqlParser.KW_TRY_CAST); this.state = 2420; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_TRY_CAST); this.state = 2421; - this.expression(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2422; - this.match(ImpalaSqlParser.KW_AS); + this.expression(); this.state = 2423; - this.type_(0); + this.match(ImpalaSqlParser.KW_AS); this.state = 2424; + this.type_(0); + this.state = 2425; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11008,37 +11052,37 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new ArrayConstructorContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2426; - this.match(ImpalaSqlParser.KW_ARRAY); this.state = 2427; + this.match(ImpalaSqlParser.KW_ARRAY); + this.state = 2428; this.match(ImpalaSqlParser.LSQUARE); - this.state = 2436; + this.state = 2437; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805323008) !== 0) || ((((_la - 40)) & ~0x1F) === 0 && ((1 << (_la - 40)) & 1442841375) !== 0) || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & 2218795145) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & 269631421) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & 271654979) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & 537926659) !== 0) || ((((_la - 217)) & ~0x1F) === 0 && ((1 << (_la - 217)) & 16393) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & 2549744643) !== 0)) { { - this.state = 2428; + this.state = 2429; this.expression(); - this.state = 2433; + this.state = 2434; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2429; - this.match(ImpalaSqlParser.COMMA); this.state = 2430; + this.match(ImpalaSqlParser.COMMA); + this.state = 2431; this.expression(); } } - this.state = 2435; + this.state = 2436; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 2438; + this.state = 2439; this.match(ImpalaSqlParser.RSQUARE); } break; @@ -11047,7 +11091,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new ColumnReferenceContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2439; + this.state = 2440; this.identifier(); } break; @@ -11056,7 +11100,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SpecialDateTimeFunctionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2440; + this.state = 2441; (localContext as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_DATE); } break; @@ -11065,18 +11109,18 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SpecialDateTimeFunctionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2441; + this.state = 2442; (localContext as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_TIME); - this.state = 2445; + this.state = 2446; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 312, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 313, this.context) ) { case 1: { - this.state = 2442; - this.match(ImpalaSqlParser.LPAREN); this.state = 2443; - (localContext as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.match(ImpalaSqlParser.LPAREN); this.state = 2444; + (localContext as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2445; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11088,18 +11132,18 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SpecialDateTimeFunctionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2447; + this.state = 2448; (localContext as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_TIMESTAMP); - this.state = 2451; + this.state = 2452; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 313, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 314, this.context) ) { case 1: { - this.state = 2448; - this.match(ImpalaSqlParser.LPAREN); this.state = 2449; - (localContext as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.match(ImpalaSqlParser.LPAREN); this.state = 2450; + (localContext as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2451; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11111,18 +11155,18 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SpecialDateTimeFunctionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2453; + this.state = 2454; (localContext as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_LOCALTIME); - this.state = 2457; + this.state = 2458; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 314, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 315, this.context) ) { case 1: { - this.state = 2454; - this.match(ImpalaSqlParser.LPAREN); this.state = 2455; - (localContext as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.match(ImpalaSqlParser.LPAREN); this.state = 2456; + (localContext as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2457; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11134,18 +11178,18 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SpecialDateTimeFunctionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2459; + this.state = 2460; (localContext as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_LOCALTIMESTAMP); - this.state = 2463; + this.state = 2464; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 315, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 316, this.context) ) { case 1: { - this.state = 2460; - this.match(ImpalaSqlParser.LPAREN); this.state = 2461; - (localContext as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.match(ImpalaSqlParser.LPAREN); this.state = 2462; + (localContext as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2463; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11157,7 +11201,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new CurrentUserContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2465; + this.state = 2466; (localContext as CurrentUserContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_USER); } break; @@ -11166,7 +11210,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new CurrentPathContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2466; + this.state = 2467; (localContext as CurrentPathContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_PATH); } break; @@ -11175,29 +11219,29 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new SubstringContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2467; - this.match(ImpalaSqlParser.KW_SUBSTRING); this.state = 2468; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_SUBSTRING); this.state = 2469; - this.valueExpression(0); + this.match(ImpalaSqlParser.LPAREN); this.state = 2470; - this.match(ImpalaSqlParser.KW_FROM); + this.valueExpression(0); this.state = 2471; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 2472; this.valueExpression(0); - this.state = 2474; + this.state = 2475; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 78) { { - this.state = 2472; - this.match(ImpalaSqlParser.KW_FOR); this.state = 2473; + this.match(ImpalaSqlParser.KW_FOR); + this.state = 2474; this.valueExpression(0); } } - this.state = 2476; + this.state = 2477; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11206,25 +11250,25 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new NormalizeContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2478; - this.match(ImpalaSqlParser.KW_NORMALIZE); this.state = 2479; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_NORMALIZE); this.state = 2480; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2481; this.valueExpression(0); - this.state = 2483; + this.state = 2484; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 263) { { - this.state = 2481; - this.match(ImpalaSqlParser.COMMA); this.state = 2482; + this.match(ImpalaSqlParser.COMMA); + this.state = 2483; this.normalForm(); } } - this.state = 2485; + this.state = 2486; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11233,17 +11277,17 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new ExtractContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2487; - this.match(ImpalaSqlParser.KW_EXTRACT); this.state = 2488; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_EXTRACT); this.state = 2489; - this.identifier(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2490; - this.match(ImpalaSqlParser.KW_FROM); + this.identifier(); this.state = 2491; - this.valueExpression(0); + this.match(ImpalaSqlParser.KW_FROM); this.state = 2492; + this.valueExpression(0); + this.state = 2493; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11252,11 +11296,11 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new ParenthesizedExpressionContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2494; - this.match(ImpalaSqlParser.LPAREN); this.state = 2495; - this.expression(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2496; + this.expression(); + this.state = 2497; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11265,45 +11309,45 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new GroupingOperationContext(localContext); this.context = localContext; previousContext = localContext; - this.state = 2498; - this.match(ImpalaSqlParser.KW_GROUPING); this.state = 2499; + this.match(ImpalaSqlParser.KW_GROUPING); + this.state = 2500; this.match(ImpalaSqlParser.LPAREN); - this.state = 2508; + this.state = 2509; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0) || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 705) !== 0)) { { - this.state = 2500; + this.state = 2501; this.qualifiedName(); - this.state = 2505; + this.state = 2506; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2501; - this.match(ImpalaSqlParser.COMMA); this.state = 2502; + this.match(ImpalaSqlParser.COMMA); + this.state = 2503; this.qualifiedName(); } } - this.state = 2507; + this.state = 2508; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 2510; + this.state = 2511; this.match(ImpalaSqlParser.RPAREN); } break; } this.context!.stop = this.tokenStream.LT(-1); - this.state = 2523; + this.state = 2524; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 322, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 323, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { if (this._parseListeners != null) { @@ -11311,23 +11355,23 @@ export class ImpalaSqlParser extends SQLParserBase { } previousContext = localContext; { - this.state = 2521; + this.state = 2522; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 321, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 322, this.context) ) { case 1: { localContext = new SubscriptContext(new PrimaryExpressionContext(parentContext, parentState)); (localContext as SubscriptContext)._value = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_primaryExpression); - this.state = 2513; + this.state = 2514; if (!(this.precpred(this.context, 15))) { throw this.createFailedPredicateException("this.precpred(this.context, 15)"); } - this.state = 2514; - this.match(ImpalaSqlParser.LSQUARE); this.state = 2515; - (localContext as SubscriptContext)._index = this.valueExpression(0); + this.match(ImpalaSqlParser.LSQUARE); this.state = 2516; + (localContext as SubscriptContext)._index = this.valueExpression(0); + this.state = 2517; this.match(ImpalaSqlParser.RSQUARE); } break; @@ -11336,22 +11380,22 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new DereferenceContext(new PrimaryExpressionContext(parentContext, parentState)); (localContext as DereferenceContext)._base = previousContext; this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_primaryExpression); - this.state = 2518; + this.state = 2519; if (!(this.precpred(this.context, 13))) { throw this.createFailedPredicateException("this.precpred(this.context, 13)"); } - this.state = 2519; - this.match(ImpalaSqlParser.DOT); this.state = 2520; + this.match(ImpalaSqlParser.DOT); + this.state = 2521; (localContext as DereferenceContext)._fieldName = this.identifier(); } break; } } } - this.state = 2525; + this.state = 2526; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 322, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 323, this.context); } } } @@ -11371,16 +11415,16 @@ export class ImpalaSqlParser extends SQLParserBase { } public stringLiteral(): StringLiteralContext { let localContext = new StringLiteralContext(this.context, this.state); - this.enterRule(localContext, 314, ImpalaSqlParser.RULE_stringLiteral); + this.enterRule(localContext, 318, ImpalaSqlParser.RULE_stringLiteral); try { - this.state = 2532; + this.state = 2533; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.STRING: localContext = new BasicStringLiteralContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2526; + this.state = 2527; this.match(ImpalaSqlParser.STRING); } break; @@ -11388,16 +11432,16 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new UnicodeStringLiteralContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 2527; + this.state = 2528; this.match(ImpalaSqlParser.UNICODE_STRING); - this.state = 2530; + this.state = 2531; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 323, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 324, this.context) ) { case 1: { - this.state = 2528; - this.match(ImpalaSqlParser.KW_UESCAPE); this.state = 2529; + this.match(ImpalaSqlParser.KW_UESCAPE); + this.state = 2530; this.match(ImpalaSqlParser.STRING); } break; @@ -11424,12 +11468,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public comparisonOperator(): ComparisonOperatorContext { let localContext = new ComparisonOperatorContext(this.context, this.state); - this.enterRule(localContext, 316, ImpalaSqlParser.RULE_comparisonOperator); + this.enterRule(localContext, 320, ImpalaSqlParser.RULE_comparisonOperator); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2534; + this.state = 2535; _la = this.tokenStream.LA(1); if(!(((((_la - 249)) & ~0x1F) === 0 && ((1 << (_la - 249)) & 63) !== 0))) { this.errorHandler.recoverInline(this); @@ -11456,12 +11500,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public comparisonQuantifier(): ComparisonQuantifierContext { let localContext = new ComparisonQuantifierContext(this.context, this.state); - this.enterRule(localContext, 318, ImpalaSqlParser.RULE_comparisonQuantifier); + this.enterRule(localContext, 322, ImpalaSqlParser.RULE_comparisonQuantifier); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2536; + this.state = 2537; _la = this.tokenStream.LA(1); if(!(_la === 2 || _la === 6 || _la === 181)) { this.errorHandler.recoverInline(this); @@ -11488,12 +11532,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public booleanValue(): BooleanValueContext { let localContext = new BooleanValueContext(this.context, this.state); - this.enterRule(localContext, 320, ImpalaSqlParser.RULE_booleanValue); + this.enterRule(localContext, 324, ImpalaSqlParser.RULE_booleanValue); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2538; + this.state = 2539; _la = this.tokenStream.LA(1); if(!(_la === 70 || _la === 194)) { this.errorHandler.recoverInline(this); @@ -11520,56 +11564,56 @@ export class ImpalaSqlParser extends SQLParserBase { } public interval(): IntervalContext { let localContext = new IntervalContext(this.context, this.state); - this.enterRule(localContext, 322, ImpalaSqlParser.RULE_interval); + this.enterRule(localContext, 326, ImpalaSqlParser.RULE_interval); try { - this.state = 2554; + this.state = 2555; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 325, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 326, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2540; - this.match(ImpalaSqlParser.INTEGER_VALUE); this.state = 2541; + this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2542; this.intervalField(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2542; - this.match(ImpalaSqlParser.LPAREN); this.state = 2543; - this.match(ImpalaSqlParser.INTEGER_VALUE); + this.match(ImpalaSqlParser.LPAREN); this.state = 2544; - this.match(ImpalaSqlParser.RPAREN); + this.match(ImpalaSqlParser.INTEGER_VALUE); this.state = 2545; + this.match(ImpalaSqlParser.RPAREN); + this.state = 2546; this.intervalField(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2546; - this.match(ImpalaSqlParser.KW_INTERVAL); this.state = 2547; - this.match(ImpalaSqlParser.INTEGER_VALUE); + this.match(ImpalaSqlParser.KW_INTERVAL); this.state = 2548; + this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2549; this.intervalField(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2549; - this.match(ImpalaSqlParser.KW_INTERVAL); this.state = 2550; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_INTERVAL); this.state = 2551; - this.match(ImpalaSqlParser.INTEGER_VALUE); + this.match(ImpalaSqlParser.LPAREN); this.state = 2552; - this.match(ImpalaSqlParser.RPAREN); + this.match(ImpalaSqlParser.INTEGER_VALUE); this.state = 2553; + this.match(ImpalaSqlParser.RPAREN); + this.state = 2554; this.intervalField(); } break; @@ -11591,12 +11635,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public intervalField(): IntervalFieldContext { let localContext = new IntervalFieldContext(this.context, this.state); - this.enterRule(localContext, 324, ImpalaSqlParser.RULE_intervalField); + this.enterRule(localContext, 328, ImpalaSqlParser.RULE_intervalField); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2556; + this.state = 2557; _la = this.tokenStream.LA(1); if(!(_la === 48 || _la === 49 || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2147483651) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 7) !== 0) || _la === 172 || _la === 173 || _la === 217 || _la === 218)) { this.errorHandler.recoverInline(this); @@ -11623,12 +11667,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public normalForm(): NormalFormContext { let localContext = new NormalFormContext(this.context, this.state); - this.enterRule(localContext, 326, ImpalaSqlParser.RULE_normalForm); + this.enterRule(localContext, 330, ImpalaSqlParser.RULE_normalForm); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2558; + this.state = 2559; _la = this.tokenStream.LA(1); if(!(((((_la - 127)) & ~0x1F) === 0 && ((1 << (_la - 127)) & 15) !== 0))) { this.errorHandler.recoverInline(this); @@ -11665,120 +11709,120 @@ export class ImpalaSqlParser extends SQLParserBase { let parentState = this.state; let localContext = new TypeContext(this.context, parentState); let previousContext = localContext; - let _startState = 328; - this.enterRecursionRule(localContext, 328, ImpalaSqlParser.RULE_type, _p); + let _startState = 332; + this.enterRecursionRule(localContext, 332, ImpalaSqlParser.RULE_type, _p); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 2605; + this.state = 2606; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 330, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 331, this.context) ) { case 1: { - this.state = 2561; - this.match(ImpalaSqlParser.KW_ARRAY); this.state = 2562; - this.match(ImpalaSqlParser.LT); + this.match(ImpalaSqlParser.KW_ARRAY); this.state = 2563; - this.type_(0); + this.match(ImpalaSqlParser.LT); this.state = 2564; + this.type_(0); + this.state = 2565; this.match(ImpalaSqlParser.GT); } break; case 2: { - this.state = 2566; - this.match(ImpalaSqlParser.KW_MAP); this.state = 2567; - this.match(ImpalaSqlParser.LT); + this.match(ImpalaSqlParser.KW_MAP); this.state = 2568; - this.type_(0); + this.match(ImpalaSqlParser.LT); this.state = 2569; - this.match(ImpalaSqlParser.COMMA); - this.state = 2570; this.type_(0); + this.state = 2570; + this.match(ImpalaSqlParser.COMMA); this.state = 2571; + this.type_(0); + this.state = 2572; this.match(ImpalaSqlParser.GT); } break; case 3: { - this.state = 2573; - this.match(ImpalaSqlParser.KW_STRUCT); this.state = 2574; - this.match(ImpalaSqlParser.LT); + this.match(ImpalaSqlParser.KW_STRUCT); this.state = 2575; - this.identifier(); + this.match(ImpalaSqlParser.LT); this.state = 2576; + this.identifier(); + this.state = 2577; this.type_(0); - this.state = 2583; + this.state = 2584; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2577; - this.match(ImpalaSqlParser.COMMA); this.state = 2578; - this.identifier(); + this.match(ImpalaSqlParser.COMMA); this.state = 2579; + this.identifier(); + this.state = 2580; this.type_(0); } } - this.state = 2585; + this.state = 2586; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 2586; + this.state = 2587; this.match(ImpalaSqlParser.GT); } break; case 4: { - this.state = 2590; + this.state = 2591; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 327, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 328, this.context) ) { case 1: { - this.state = 2588; + this.state = 2589; this.baseType(); } break; case 2: { - this.state = 2589; + this.state = 2590; this.dataType(); } break; } - this.state = 2603; + this.state = 2604; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 329, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 330, this.context) ) { case 1: { - this.state = 2592; - this.match(ImpalaSqlParser.LPAREN); this.state = 2593; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2594; this.typeParameter(); - this.state = 2598; + this.state = 2599; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2594; - this.match(ImpalaSqlParser.COMMA); this.state = 2595; + this.match(ImpalaSqlParser.COMMA); + this.state = 2596; this.typeParameter(); } } - this.state = 2600; + this.state = 2601; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 2601; + this.state = 2602; this.match(ImpalaSqlParser.RPAREN); } break; @@ -11787,9 +11831,9 @@ export class ImpalaSqlParser extends SQLParserBase { break; } this.context!.stop = this.tokenStream.LT(-1); - this.state = 2611; + this.state = 2612; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 331, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 332, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { if (this._parseListeners != null) { @@ -11800,18 +11844,18 @@ export class ImpalaSqlParser extends SQLParserBase { { localContext = new TypeContext(parentContext, parentState); this.pushNewRecursionContext(localContext, _startState, ImpalaSqlParser.RULE_type); - this.state = 2607; + this.state = 2608; if (!(this.precpred(this.context, 5))) { throw this.createFailedPredicateException("this.precpred(this.context, 5)"); } - this.state = 2608; + this.state = 2609; this.match(ImpalaSqlParser.KW_ARRAY); } } } - this.state = 2613; + this.state = 2614; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 331, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 332, this.context); } } } @@ -11831,12 +11875,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public dataType(): DataTypeContext { let localContext = new DataTypeContext(this.context, this.state); - this.enterRule(localContext, 330, ImpalaSqlParser.RULE_dataType); + this.enterRule(localContext, 334, ImpalaSqlParser.RULE_dataType); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2614; + this.state = 2615; _la = this.tokenStream.LA(1); if(!(_la === 8 || ((((_la - 227)) & ~0x1F) === 0 && ((1 << (_la - 227)) & 262143) !== 0))) { this.errorHandler.recoverInline(this); @@ -11863,15 +11907,15 @@ export class ImpalaSqlParser extends SQLParserBase { } public typeParameter(): TypeParameterContext { let localContext = new TypeParameterContext(this.context, this.state); - this.enterRule(localContext, 332, ImpalaSqlParser.RULE_typeParameter); + this.enterRule(localContext, 336, ImpalaSqlParser.RULE_typeParameter); try { - this.state = 2618; + this.state = 2619; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.INTEGER_VALUE: this.enterOuterAlt(localContext, 1); { - this.state = 2616; + this.state = 2617; this.match(ImpalaSqlParser.INTEGER_VALUE); } break; @@ -11936,7 +11980,7 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.DOUBLE_PRECISION: this.enterOuterAlt(localContext, 2); { - this.state = 2617; + this.state = 2618; this.type_(0); } break; @@ -11960,29 +12004,29 @@ export class ImpalaSqlParser extends SQLParserBase { } public baseType(): BaseTypeContext { let localContext = new BaseTypeContext(this.context, this.state); - this.enterRule(localContext, 334, ImpalaSqlParser.RULE_baseType); + this.enterRule(localContext, 338, ImpalaSqlParser.RULE_baseType); try { - this.state = 2624; + this.state = 2625; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.TIME_WITH_TIME_ZONE: this.enterOuterAlt(localContext, 1); { - this.state = 2620; + this.state = 2621; this.match(ImpalaSqlParser.TIME_WITH_TIME_ZONE); } break; case ImpalaSqlParser.TIMESTAMP_WITH_TIME_ZONE: this.enterOuterAlt(localContext, 2); { - this.state = 2621; + this.state = 2622; this.match(ImpalaSqlParser.TIMESTAMP_WITH_TIME_ZONE); } break; case ImpalaSqlParser.DOUBLE_PRECISION: this.enterOuterAlt(localContext, 3); { - this.state = 2622; + this.state = 2623; this.match(ImpalaSqlParser.DOUBLE_PRECISION); } break; @@ -12026,7 +12070,7 @@ export class ImpalaSqlParser extends SQLParserBase { case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: this.enterOuterAlt(localContext, 4); { - this.state = 2623; + this.state = 2624; this.identifier(); } break; @@ -12050,17 +12094,17 @@ export class ImpalaSqlParser extends SQLParserBase { } public whenClause(): WhenClauseContext { let localContext = new WhenClauseContext(this.context, this.state); - this.enterRule(localContext, 336, ImpalaSqlParser.RULE_whenClause); + this.enterRule(localContext, 340, ImpalaSqlParser.RULE_whenClause); try { this.enterOuterAlt(localContext, 1); { - this.state = 2626; - this.match(ImpalaSqlParser.KW_WHEN); this.state = 2627; - localContext._condition = this.expression(); + this.match(ImpalaSqlParser.KW_WHEN); this.state = 2628; - this.match(ImpalaSqlParser.KW_THEN); + localContext._condition = this.expression(); this.state = 2629; + this.match(ImpalaSqlParser.KW_THEN); + this.state = 2630; localContext._result = this.expression(); } } @@ -12080,19 +12124,19 @@ export class ImpalaSqlParser extends SQLParserBase { } public filter(): FilterContext { let localContext = new FilterContext(this.context, this.state); - this.enterRule(localContext, 338, ImpalaSqlParser.RULE_filter); + this.enterRule(localContext, 342, ImpalaSqlParser.RULE_filter); try { this.enterOuterAlt(localContext, 1); { - this.state = 2631; - this.match(ImpalaSqlParser.KW_FILTER); this.state = 2632; - this.match(ImpalaSqlParser.LPAREN); + this.match(ImpalaSqlParser.KW_FILTER); this.state = 2633; - this.match(ImpalaSqlParser.KW_WHERE); + this.match(ImpalaSqlParser.LPAREN); this.state = 2634; - this.booleanExpression(0); + this.match(ImpalaSqlParser.KW_WHERE); this.state = 2635; + this.booleanExpression(0); + this.state = 2636; this.match(ImpalaSqlParser.RPAREN); } } @@ -12112,88 +12156,88 @@ export class ImpalaSqlParser extends SQLParserBase { } public over(): OverContext { let localContext = new OverContext(this.context, this.state); - this.enterRule(localContext, 340, ImpalaSqlParser.RULE_over); + this.enterRule(localContext, 344, ImpalaSqlParser.RULE_over); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2637; - this.match(ImpalaSqlParser.KW_OVER); this.state = 2638; + this.match(ImpalaSqlParser.KW_OVER); + this.state = 2639; this.match(ImpalaSqlParser.LPAREN); - this.state = 2649; + this.state = 2650; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 145) { { - this.state = 2639; - this.match(ImpalaSqlParser.KW_PARTITION); this.state = 2640; - this.match(ImpalaSqlParser.KW_BY); + this.match(ImpalaSqlParser.KW_PARTITION); this.state = 2641; + this.match(ImpalaSqlParser.KW_BY); + this.state = 2642; localContext._expression = this.expression(); localContext._partition.push(localContext._expression); - this.state = 2646; + this.state = 2647; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2642; - this.match(ImpalaSqlParser.COMMA); this.state = 2643; + this.match(ImpalaSqlParser.COMMA); + this.state = 2644; localContext._expression = this.expression(); localContext._partition.push(localContext._expression); } } - this.state = 2648; + this.state = 2649; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 2661; + this.state = 2662; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 139) { { - this.state = 2651; - this.match(ImpalaSqlParser.KW_ORDER); this.state = 2652; - this.match(ImpalaSqlParser.KW_BY); + this.match(ImpalaSqlParser.KW_ORDER); this.state = 2653; + this.match(ImpalaSqlParser.KW_BY); + this.state = 2654; this.sortItem(); - this.state = 2658; + this.state = 2659; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2654; - this.match(ImpalaSqlParser.COMMA); this.state = 2655; + this.match(ImpalaSqlParser.COMMA); + this.state = 2656; this.sortItem(); } } - this.state = 2660; + this.state = 2661; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } } - this.state = 2664; + this.state = 2665; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 154 || _la === 169) { { - this.state = 2663; + this.state = 2664; this.windowFrame(); } } - this.state = 2666; + this.state = 2667; this.match(ImpalaSqlParser.RPAREN); } } @@ -12213,56 +12257,56 @@ export class ImpalaSqlParser extends SQLParserBase { } public windowFrame(): WindowFrameContext { let localContext = new WindowFrameContext(this.context, this.state); - this.enterRule(localContext, 342, ImpalaSqlParser.RULE_windowFrame); + this.enterRule(localContext, 346, ImpalaSqlParser.RULE_windowFrame); try { - this.state = 2684; + this.state = 2685; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 339, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 340, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2668; - localContext._frameType = this.match(ImpalaSqlParser.KW_RANGE); this.state = 2669; + localContext._frameType = this.match(ImpalaSqlParser.KW_RANGE); + this.state = 2670; localContext._start_ = this.frameBound(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2670; - localContext._frameType = this.match(ImpalaSqlParser.KW_ROWS); this.state = 2671; + localContext._frameType = this.match(ImpalaSqlParser.KW_ROWS); + this.state = 2672; localContext._start_ = this.frameBound(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2672; - localContext._frameType = this.match(ImpalaSqlParser.KW_RANGE); this.state = 2673; - this.match(ImpalaSqlParser.KW_BETWEEN); + localContext._frameType = this.match(ImpalaSqlParser.KW_RANGE); this.state = 2674; - localContext._start_ = this.frameBound(); + this.match(ImpalaSqlParser.KW_BETWEEN); this.state = 2675; - this.match(ImpalaSqlParser.KW_AND); + localContext._start_ = this.frameBound(); this.state = 2676; + this.match(ImpalaSqlParser.KW_AND); + this.state = 2677; localContext._end = this.frameBound(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2678; - localContext._frameType = this.match(ImpalaSqlParser.KW_ROWS); this.state = 2679; - this.match(ImpalaSqlParser.KW_BETWEEN); + localContext._frameType = this.match(ImpalaSqlParser.KW_ROWS); this.state = 2680; - localContext._start_ = this.frameBound(); + this.match(ImpalaSqlParser.KW_BETWEEN); this.state = 2681; - this.match(ImpalaSqlParser.KW_AND); + localContext._start_ = this.frameBound(); this.state = 2682; + this.match(ImpalaSqlParser.KW_AND); + this.state = 2683; localContext._end = this.frameBound(); } break; @@ -12284,19 +12328,19 @@ export class ImpalaSqlParser extends SQLParserBase { } public frameBound(): FrameBoundContext { let localContext = new FrameBoundContext(this.context, this.state); - this.enterRule(localContext, 344, ImpalaSqlParser.RULE_frameBound); + this.enterRule(localContext, 348, ImpalaSqlParser.RULE_frameBound); let _la: number; try { - this.state = 2695; + this.state = 2696; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 340, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 341, this.context) ) { case 1: localContext = new UnboundedFrameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2686; - this.match(ImpalaSqlParser.KW_UNBOUNDED); this.state = 2687; + this.match(ImpalaSqlParser.KW_UNBOUNDED); + this.state = 2688; (localContext as UnboundedFrameContext)._boundType = this.match(ImpalaSqlParser.KW_PRECEDING); } break; @@ -12304,9 +12348,9 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new UnboundedFrameContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 2688; - this.match(ImpalaSqlParser.KW_UNBOUNDED); this.state = 2689; + this.match(ImpalaSqlParser.KW_UNBOUNDED); + this.state = 2690; (localContext as UnboundedFrameContext)._boundType = this.match(ImpalaSqlParser.KW_FOLLOWING); } break; @@ -12314,9 +12358,9 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new CurrentRowBoundContext(localContext); this.enterOuterAlt(localContext, 3); { - this.state = 2690; - this.match(ImpalaSqlParser.KW_CURRENT); this.state = 2691; + this.match(ImpalaSqlParser.KW_CURRENT); + this.state = 2692; this.match(ImpalaSqlParser.KW_ROW); } break; @@ -12324,9 +12368,9 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new BoundedFrameContext(localContext); this.enterOuterAlt(localContext, 4); { - this.state = 2692; - this.expression(); this.state = 2693; + this.expression(); + this.state = 2694; (localContext as BoundedFrameContext)._boundType = this.tokenStream.LT(1); _la = this.tokenStream.LA(1); if(!(_la === 77 || _la === 149)) { @@ -12356,20 +12400,20 @@ export class ImpalaSqlParser extends SQLParserBase { } public pathElement(): PathElementContext { let localContext = new PathElementContext(this.context, this.state); - this.enterRule(localContext, 346, ImpalaSqlParser.RULE_pathElement); + this.enterRule(localContext, 350, ImpalaSqlParser.RULE_pathElement); try { - this.state = 2702; + this.state = 2703; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 341, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 342, this.context) ) { case 1: localContext = new QualifiedArgumentContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2697; - this.identifier(); this.state = 2698; - this.match(ImpalaSqlParser.DOT); + this.identifier(); this.state = 2699; + this.match(ImpalaSqlParser.DOT); + this.state = 2700; this.identifier(); } break; @@ -12377,7 +12421,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new UnqualifiedArgumentContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 2701; + this.state = 2702; this.identifier(); } break; @@ -12399,26 +12443,26 @@ export class ImpalaSqlParser extends SQLParserBase { } public pathSpecification(): PathSpecificationContext { let localContext = new PathSpecificationContext(this.context, this.state); - this.enterRule(localContext, 348, ImpalaSqlParser.RULE_pathSpecification); + this.enterRule(localContext, 352, ImpalaSqlParser.RULE_pathSpecification); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2704; + this.state = 2705; this.pathElement(); - this.state = 2709; + this.state = 2710; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 263) { { { - this.state = 2705; - this.match(ImpalaSqlParser.COMMA); this.state = 2706; + this.match(ImpalaSqlParser.COMMA); + this.state = 2707; this.pathElement(); } } - this.state = 2711; + this.state = 2712; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -12440,69 +12484,69 @@ export class ImpalaSqlParser extends SQLParserBase { } public privilege(): PrivilegeContext { let localContext = new PrivilegeContext(this.context, this.state); - this.enterRule(localContext, 350, ImpalaSqlParser.RULE_privilege); + this.enterRule(localContext, 354, ImpalaSqlParser.RULE_privilege); let _la: number; try { - this.state = 2725; + this.state = 2726; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_ALL: this.enterOuterAlt(localContext, 1); { - this.state = 2712; + this.state = 2713; this.match(ImpalaSqlParser.KW_ALL); } break; case ImpalaSqlParser.KW_ALTER: this.enterOuterAlt(localContext, 2); { - this.state = 2713; + this.state = 2714; this.match(ImpalaSqlParser.KW_ALTER); } break; case ImpalaSqlParser.KW_DROP: this.enterOuterAlt(localContext, 3); { - this.state = 2714; + this.state = 2715; this.match(ImpalaSqlParser.KW_DROP); } break; case ImpalaSqlParser.KW_CREATE: this.enterOuterAlt(localContext, 4); { - this.state = 2715; + this.state = 2716; this.match(ImpalaSqlParser.KW_CREATE); } break; case ImpalaSqlParser.KW_INSERT: this.enterOuterAlt(localContext, 5); { - this.state = 2716; + this.state = 2717; this.match(ImpalaSqlParser.KW_INSERT); } break; case ImpalaSqlParser.KW_REFRESH: this.enterOuterAlt(localContext, 6); { - this.state = 2717; + this.state = 2718; this.match(ImpalaSqlParser.KW_REFRESH); } break; case ImpalaSqlParser.KW_SELECT: this.enterOuterAlt(localContext, 7); { - this.state = 2718; + this.state = 2719; this.match(ImpalaSqlParser.KW_SELECT); - this.state = 2723; + this.state = 2724; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 265) { { - this.state = 2719; - this.match(ImpalaSqlParser.LPAREN); this.state = 2720; - localContext._columnName = this.identifier(); + this.match(ImpalaSqlParser.LPAREN); this.state = 2721; + localContext._columnName = this.identifier(); + this.state = 2722; this.match(ImpalaSqlParser.RPAREN); } } @@ -12529,12 +12573,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public objectType(): ObjectTypeContext { let localContext = new ObjectTypeContext(this.context, this.state); - this.enterRule(localContext, 352, ImpalaSqlParser.RULE_objectType); + this.enterRule(localContext, 356, ImpalaSqlParser.RULE_objectType); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2727; + this.state = 2728; _la = this.tokenStream.LA(1); if(!(_la === 46 || ((((_la - 178)) & ~0x1F) === 0 && ((1 << (_la - 178)) & 2147484673) !== 0))) { this.errorHandler.recoverInline(this); @@ -12561,30 +12605,30 @@ export class ImpalaSqlParser extends SQLParserBase { } public qualifiedName(): QualifiedNameContext { let localContext = new QualifiedNameContext(this.context, this.state); - this.enterRule(localContext, 354, ImpalaSqlParser.RULE_qualifiedName); + this.enterRule(localContext, 358, ImpalaSqlParser.RULE_qualifiedName); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 2729; + this.state = 2730; this.identifier(); - this.state = 2734; + this.state = 2735; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 345, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 346, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 2730; - this.match(ImpalaSqlParser.DOT); this.state = 2731; + this.match(ImpalaSqlParser.DOT); + this.state = 2732; this.identifier(); } } } - this.state = 2736; + this.state = 2737; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 345, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 346, this.context); } } } @@ -12604,18 +12648,18 @@ export class ImpalaSqlParser extends SQLParserBase { } public principal(): PrincipalContext { let localContext = new PrincipalContext(this.context, this.state); - this.enterRule(localContext, 356, ImpalaSqlParser.RULE_principal); + this.enterRule(localContext, 360, ImpalaSqlParser.RULE_principal); try { - this.state = 2743; + this.state = 2744; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.KW_ROLE: localContext = new RolePrincipalContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2737; - this.match(ImpalaSqlParser.KW_ROLE); this.state = 2738; + this.match(ImpalaSqlParser.KW_ROLE); + this.state = 2739; this.identifier(); } break; @@ -12623,9 +12667,9 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new UserPrincipalContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 2739; - this.match(ImpalaSqlParser.KW_USER); this.state = 2740; + this.match(ImpalaSqlParser.KW_USER); + this.state = 2741; this.identifier(); } break; @@ -12633,9 +12677,9 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new GroupPrincipalContext(localContext); this.enterOuterAlt(localContext, 3); { - this.state = 2741; - this.match(ImpalaSqlParser.KW_GROUP); this.state = 2742; + this.match(ImpalaSqlParser.KW_GROUP); + this.state = 2743; this.identifier(); } break; @@ -12659,16 +12703,16 @@ export class ImpalaSqlParser extends SQLParserBase { } public identifier(): IdentifierContext { let localContext = new IdentifierContext(this.context, this.state); - this.enterRule(localContext, 358, ImpalaSqlParser.RULE_identifier); + this.enterRule(localContext, 362, ImpalaSqlParser.RULE_identifier); try { - this.state = 2750; + this.state = 2751; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case ImpalaSqlParser.IDENTIFIER: localContext = new UnquotedIdentifierContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2745; + this.state = 2746; this.match(ImpalaSqlParser.IDENTIFIER); } break; @@ -12676,7 +12720,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new QuotedIdentifierContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 2746; + this.state = 2747; this.match(ImpalaSqlParser.STRING); } break; @@ -12717,7 +12761,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new UnquotedIdentifierContext(localContext); this.enterOuterAlt(localContext, 3); { - this.state = 2747; + this.state = 2748; this.nonReserved(); } break; @@ -12725,7 +12769,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new BackQuotedIdentifierContext(localContext); this.enterOuterAlt(localContext, 4); { - this.state = 2748; + this.state = 2749; this.match(ImpalaSqlParser.BACKQUOTED_IDENTIFIER); } break; @@ -12733,7 +12777,7 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new DigitIdentifierContext(localContext); this.enterOuterAlt(localContext, 5); { - this.state = 2749; + this.state = 2750; this.match(ImpalaSqlParser.DIGIT_IDENTIFIER); } break; @@ -12757,27 +12801,27 @@ export class ImpalaSqlParser extends SQLParserBase { } public number_(): NumberContext { let localContext = new NumberContext(this.context, this.state); - this.enterRule(localContext, 360, ImpalaSqlParser.RULE_number); + this.enterRule(localContext, 364, ImpalaSqlParser.RULE_number); let _la: number; try { - this.state = 2764; + this.state = 2765; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 351, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 352, this.context) ) { case 1: localContext = new DecimalLiteralContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 2753; + this.state = 2754; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 256) { { - this.state = 2752; + this.state = 2753; this.match(ImpalaSqlParser.MINUS); } } - this.state = 2755; + this.state = 2756; this.match(ImpalaSqlParser.DECIMAL_VALUE); } break; @@ -12785,17 +12829,17 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new DoubleLiteralContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 2757; + this.state = 2758; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 256) { { - this.state = 2756; + this.state = 2757; this.match(ImpalaSqlParser.MINUS); } } - this.state = 2759; + this.state = 2760; this.match(ImpalaSqlParser.DOUBLE_VALUE); } break; @@ -12803,17 +12847,17 @@ export class ImpalaSqlParser extends SQLParserBase { localContext = new IntegerLiteralContext(localContext); this.enterOuterAlt(localContext, 3); { - this.state = 2761; + this.state = 2762; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 256) { { - this.state = 2760; + this.state = 2761; this.match(ImpalaSqlParser.MINUS); } } - this.state = 2763; + this.state = 2764; this.match(ImpalaSqlParser.INTEGER_VALUE); } break; @@ -12835,12 +12879,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public reservedKeywordsUsedAsFuncName(): ReservedKeywordsUsedAsFuncNameContext { let localContext = new ReservedKeywordsUsedAsFuncNameContext(this.context, this.state); - this.enterRule(localContext, 362, ImpalaSqlParser.RULE_reservedKeywordsUsedAsFuncName); + this.enterRule(localContext, 366, ImpalaSqlParser.RULE_reservedKeywordsUsedAsFuncName); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2766; + this.state = 2767; _la = this.tokenStream.LA(1); if(!(((((_la - 28)) & ~0x1F) === 0 && ((1 << (_la - 28)) & 1085443) !== 0) || _la === 68 || _la === 91 || ((((_la - 114)) & ~0x1F) === 0 && ((1 << (_la - 114)) & 1281) !== 0) || ((((_la - 158)) & ~0x1F) === 0 && ((1 << (_la - 158)) & 67125377) !== 0) || ((((_la - 196)) & ~0x1F) === 0 && ((1 << (_la - 196)) & 2097409) !== 0))) { this.errorHandler.recoverInline(this); @@ -12867,12 +12911,12 @@ export class ImpalaSqlParser extends SQLParserBase { } public nonReserved(): NonReservedContext { let localContext = new NonReservedContext(this.context, this.state); - this.enterRule(localContext, 364, ImpalaSqlParser.RULE_nonReserved); + this.enterRule(localContext, 368, ImpalaSqlParser.RULE_nonReserved); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2768; + this.state = 2769; _la = this.tokenStream.LA(1); if(!(_la === 14 || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 37748835) !== 0) || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & 2416443409) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 1610760439) !== 0) || ((((_la - 172)) & ~0x1F) === 0 && ((1 << (_la - 172)) & 8401155) !== 0) || ((((_la - 204)) & ~0x1F) === 0 && ((1 << (_la - 204)) & 134291969) !== 0))) { this.errorHandler.recoverInline(this); @@ -12902,17 +12946,17 @@ export class ImpalaSqlParser extends SQLParserBase { switch (ruleIndex) { case 96: return this.columnNamePath_sempred(localContext as ColumnNamePathContext, predIndex); - case 130: + case 132: return this.queryTerm_sempred(localContext as QueryTermContext, predIndex); - case 140: + case 142: return this.relation_sempred(localContext as RelationContext, predIndex); - case 153: - return this.booleanExpression_sempred(localContext as BooleanExpressionContext, predIndex); case 155: + return this.booleanExpression_sempred(localContext as BooleanExpressionContext, predIndex); + case 157: return this.valueExpression_sempred(localContext as ValueExpressionContext, predIndex); - case 156: + case 158: return this.primaryExpression_sempred(localContext as PrimaryExpressionContext, predIndex); - case 164: + case 166: return this.type_sempred(localContext as TypeContext, predIndex); } return true; @@ -12978,7 +13022,7 @@ export class ImpalaSqlParser extends SQLParserBase { } public static readonly _serializedATN: number[] = [ - 4,1,289,2771,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, + 4,1,289,2772,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, @@ -13008,1162 +13052,1163 @@ export class ImpalaSqlParser extends SQLParserBase { 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,1,0,5,0,368,8,0,10,0,12,0,371,9,0,1,0,1, - 0,1,1,1,1,3,1,377,8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, - 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,3,2,401,8,2,1,3,1, - 3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,414,8,4,1,5,1,5,3,5,418, - 8,5,1,5,1,5,3,5,422,8,5,1,5,1,5,1,5,1,5,1,5,5,5,429,8,5,10,5,12, - 5,432,9,5,1,5,1,5,3,5,436,8,5,1,5,1,5,3,5,440,8,5,1,5,1,5,1,5,1, - 5,3,5,446,8,5,3,5,448,8,5,1,5,1,5,1,5,3,5,453,8,5,1,6,1,6,3,6,457, - 8,6,1,6,1,6,3,6,461,8,6,1,6,1,6,1,6,1,6,1,6,3,6,468,8,6,1,6,1,6, - 1,6,3,6,473,8,6,1,6,1,6,1,7,1,7,3,7,479,8,7,1,7,1,7,3,7,483,8,7, - 1,7,1,7,1,7,1,7,1,7,5,7,490,8,7,10,7,12,7,493,9,7,1,7,1,7,1,7,1, - 7,3,7,499,8,7,1,7,1,7,3,7,503,8,7,1,7,1,7,1,7,3,7,508,8,7,3,7,510, - 8,7,1,7,1,7,1,7,3,7,515,8,7,1,7,1,7,3,7,519,8,7,1,7,1,7,1,7,1,7, - 1,7,3,7,526,8,7,1,7,1,7,3,7,530,8,7,1,8,1,8,1,8,3,8,535,8,8,1,8, - 1,8,3,8,539,8,8,1,8,1,8,3,8,543,8,8,1,8,1,8,3,8,547,8,8,1,8,1,8, - 1,8,1,9,1,9,1,9,3,9,555,8,9,1,9,1,9,1,9,3,9,560,8,9,1,9,1,9,3,9, - 564,8,9,1,10,1,10,1,10,1,10,1,11,1,11,3,11,572,8,11,1,11,1,11,3, - 11,576,8,11,1,11,1,11,1,11,1,11,1,11,5,11,583,8,11,10,11,12,11,586, - 9,11,3,11,588,8,11,1,11,3,11,591,8,11,1,11,1,11,1,11,1,11,3,11,597, - 8,11,1,11,1,11,1,11,1,11,1,11,3,11,604,8,11,1,11,1,11,1,11,1,11, - 1,11,1,11,1,11,1,11,1,11,3,11,615,8,11,1,11,1,11,1,11,3,11,620,8, - 11,1,11,1,11,1,11,3,11,625,8,11,1,11,1,11,1,11,3,11,630,8,11,1,12, - 1,12,1,12,3,12,635,8,12,1,12,1,12,1,12,1,12,1,12,5,12,642,8,12,10, - 12,12,12,645,9,12,3,12,647,8,12,1,12,3,12,650,8,12,1,12,1,12,3,12, - 654,8,12,1,12,1,12,1,12,1,12,1,12,1,12,1,13,1,13,1,13,1,13,1,13, + 2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,1,0,5,0,372,8,0, + 10,0,12,0,375,9,0,1,0,1,0,1,1,1,1,3,1,381,8,1,1,2,1,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,2,3,2,405,8,2,1,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3, + 4,418,8,4,1,5,1,5,3,5,422,8,5,1,5,1,5,3,5,426,8,5,1,5,1,5,1,5,1, + 5,1,5,5,5,433,8,5,10,5,12,5,436,9,5,1,5,1,5,3,5,440,8,5,1,5,1,5, + 3,5,444,8,5,1,5,1,5,1,5,1,5,3,5,450,8,5,3,5,452,8,5,1,5,1,5,1,5, + 3,5,457,8,5,1,6,1,6,3,6,461,8,6,1,6,1,6,3,6,465,8,6,1,6,1,6,1,6, + 1,6,1,6,3,6,472,8,6,1,6,1,6,1,6,3,6,477,8,6,1,6,1,6,1,7,1,7,3,7, + 483,8,7,1,7,1,7,3,7,487,8,7,1,7,1,7,1,7,1,7,1,7,5,7,494,8,7,10,7, + 12,7,497,9,7,1,7,1,7,1,7,1,7,3,7,503,8,7,1,7,1,7,3,7,507,8,7,1,7, + 1,7,1,7,3,7,512,8,7,3,7,514,8,7,1,7,1,7,1,7,3,7,519,8,7,1,7,3,7, + 522,8,7,1,7,1,7,1,7,1,7,1,7,3,7,529,8,7,1,7,1,7,3,7,533,8,7,1,8, + 1,8,1,8,3,8,538,8,8,1,8,1,8,3,8,542,8,8,1,8,3,8,545,8,8,1,8,1,8, + 3,8,549,8,8,1,8,1,8,1,8,1,9,1,9,1,9,3,9,557,8,9,1,9,1,9,3,9,561, + 8,9,1,9,1,9,3,9,565,8,9,1,10,1,10,1,10,1,10,1,11,1,11,3,11,573,8, + 11,1,11,1,11,3,11,577,8,11,1,11,1,11,1,11,1,11,1,11,5,11,584,8,11, + 10,11,12,11,587,9,11,3,11,589,8,11,1,11,3,11,592,8,11,1,11,1,11, + 1,11,1,11,3,11,598,8,11,1,11,1,11,1,11,1,11,1,11,3,11,605,8,11,1, + 11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,3,11,616,8,11,1,11,1, + 11,1,11,3,11,621,8,11,1,11,1,11,1,11,3,11,626,8,11,1,11,1,11,1,11, + 3,11,631,8,11,1,12,1,12,1,12,3,12,636,8,12,1,12,1,12,1,12,1,12,1, + 12,5,12,643,8,12,10,12,12,12,646,9,12,3,12,648,8,12,1,12,3,12,651, + 8,12,1,12,1,12,3,12,655,8,12,1,12,1,12,1,12,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,13,1,13,1,13,1,13, - 3,13,680,8,13,1,14,1,14,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,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15, - 1,15,3,15,706,8,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,3,16,715,8, - 16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,725,8,16,1,16,3, - 16,728,8,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1, - 18,1,18,3,18,742,8,18,1,18,1,18,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,3,20,760,8,20,3,20,762,8,20, - 1,20,1,20,1,20,1,20,1,20,5,20,769,8,20,10,20,12,20,772,9,20,1,20, - 1,20,1,21,1,21,1,21,1,21,1,21,1,21,3,21,782,8,21,1,21,1,21,1,22, - 1,22,1,22,1,22,1,22,3,22,791,8,22,1,22,1,22,1,22,1,22,1,22,3,22, - 798,8,22,1,22,1,22,3,22,802,8,22,1,23,1,23,1,23,1,23,1,23,3,23,809, - 8,23,1,23,1,23,1,23,1,23,3,23,815,8,23,1,23,3,23,818,8,23,1,23,1, - 23,1,23,3,23,823,8,23,1,24,1,24,1,24,1,24,1,24,3,24,830,8,24,1,24, - 1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,3,24,844, - 8,24,1,25,1,25,1,25,1,25,1,25,1,25,1,26,1,26,1,26,1,26,1,26,3,26, - 857,8,26,1,26,1,26,1,26,3,26,862,8,26,1,26,1,26,1,26,3,26,867,8, - 26,1,27,1,27,1,27,1,27,3,27,873,8,27,1,27,1,27,1,27,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,31,1,31,1,31,1,31,1,31,1,31,1, - 31,1,32,1,32,3,32,909,8,32,1,32,3,32,912,8,32,1,32,1,32,1,33,1,33, - 3,33,918,8,33,1,33,3,33,921,8,33,1,33,1,33,1,34,1,34,3,34,927,8, - 34,1,35,1,35,1,35,1,35,3,35,933,8,35,1,35,1,35,1,35,1,35,1,35,1, - 35,1,35,1,35,1,35,1,35,3,35,945,8,35,3,35,947,8,35,1,36,1,36,1,36, - 1,36,1,36,1,36,1,36,1,36,1,36,3,36,958,8,36,1,37,1,37,1,37,1,37, - 1,37,1,37,3,37,966,8,37,1,38,1,38,1,38,3,38,971,8,38,1,38,1,38,3, - 38,975,8,38,1,39,1,39,1,39,3,39,980,8,39,1,39,1,39,1,40,1,40,1,40, - 3,40,987,8,40,1,40,1,40,3,40,991,8,40,1,41,1,41,3,41,995,8,41,1, - 41,1,41,1,41,1,41,3,41,1001,8,41,1,42,1,42,3,42,1005,8,42,1,42,1, - 42,3,42,1009,8,42,1,42,1,42,1,42,1,42,1,42,5,42,1016,8,42,10,42, - 12,42,1019,9,42,3,42,1021,8,42,1,42,3,42,1024,8,42,1,43,1,43,1,43, - 1,43,1,44,1,44,3,44,1032,8,44,1,45,1,45,1,45,1,45,1,45,1,45,1,45, - 1,46,1,46,1,46,1,46,1,46,3,46,1046,8,46,1,46,1,46,1,46,1,47,1,47, - 3,47,1053,8,47,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,49,1,49,1,49, - 1,49,3,49,1066,8,49,1,49,1,49,1,49,1,49,3,49,1072,8,49,1,49,1,49, - 1,49,3,49,1077,8,49,1,49,3,49,1080,8,49,1,50,3,50,1083,8,50,1,50, - 1,50,1,50,3,50,1088,8,50,1,50,1,50,3,50,1092,8,50,1,50,1,50,1,50, - 1,50,1,50,5,50,1099,8,50,10,50,12,50,1102,9,50,1,50,1,50,3,50,1106, - 8,50,1,50,1,50,1,51,1,51,3,51,1112,8,51,1,52,1,52,3,52,1116,8,52, - 1,52,1,52,1,52,3,52,1121,8,52,1,53,1,53,1,53,3,53,1126,8,53,1,53, - 3,53,1129,8,53,1,53,1,53,1,53,1,53,5,53,1135,8,53,10,53,12,53,1138, - 9,53,3,53,1140,8,53,1,53,1,53,3,53,1144,8,53,1,54,1,54,1,54,1,54, - 1,54,1,54,1,54,1,54,5,54,1154,8,54,10,54,12,54,1157,9,54,3,54,1159, - 8,54,1,54,1,54,3,54,1163,8,54,1,55,1,55,1,55,3,55,1168,8,55,1,55, - 1,55,3,55,1172,8,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,1,56,1,56, - 1,56,1,56,1,56,1,56,1,56,3,56,1188,8,56,1,57,1,57,1,57,3,57,1193, - 8,57,1,57,1,57,1,57,5,57,1198,8,57,10,57,12,57,1201,9,57,3,57,1203, - 8,57,1,58,1,58,1,58,1,58,3,58,1209,8,58,1,58,3,58,1212,8,58,1,58, - 1,58,1,58,5,58,1217,8,58,10,58,12,58,1220,9,58,3,58,1222,8,58,1, - 59,1,59,3,59,1226,8,59,1,59,1,59,1,59,3,59,1231,8,59,1,59,3,59,1234, - 8,59,1,59,1,59,1,59,5,59,1239,8,59,10,59,12,59,1242,9,59,3,59,1244, - 8,59,1,60,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,64,1,64,3,64,1268,8,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,3,65, - 1282,8,65,1,65,1,65,3,65,1286,8,65,1,66,1,66,3,66,1290,8,66,1,66, - 1,66,1,67,1,67,1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,3,68,1310,8,68,3,68,1312,8,68,3,68,1314,8,68, - 1,69,1,69,1,69,1,69,1,69,1,69,1,69,3,69,1323,8,69,3,69,1325,8,69, - 1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70,1334,8,70,3,70,1336,8,70, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1345,8,71,3,71,1347,8,71, - 1,72,1,72,1,72,3,72,1352,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73, - 3,73,1361,8,73,1,74,1,74,1,74,1,74,1,74,1,74,1,74,3,74,1370,8,74, - 1,75,1,75,1,75,1,75,1,75,1,75,1,75,3,75,1379,8,75,1,76,1,76,1,76, - 1,77,1,77,1,77,1,77,1,77,1,77,3,77,1390,8,77,1,78,1,78,1,78,1,78, - 3,78,1396,8,78,1,78,1,78,1,78,3,78,1401,8,78,1,78,3,78,1404,8,78, - 1,78,1,78,1,79,1,79,1,79,1,79,1,80,1,80,1,80,1,80,1,80,3,80,1417, - 8,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,3,80,1427,8,80,1,80, - 1,80,3,80,1431,8,80,1,81,1,81,1,81,3,81,1436,8,81,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,5,82,1445,8,82,10,82,12,82,1448,9,82,1,82,1, - 82,3,82,1452,8,82,1,83,1,83,1,83,1,84,1,84,1,84,1,84,1,85,1,85,1, - 85,1,86,1,86,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,93,5,93,1483,8,93,10,93,12,93,1486, - 9,93,1,94,1,94,1,94,5,94,1491,8,94,10,94,12,94,1494,9,94,1,95,1, - 95,3,95,1498,8,95,1,96,1,96,3,96,1502,8,96,1,97,1,97,3,97,1506,8, - 97,1,98,1,98,1,98,3,98,1511,8,98,1,98,1,98,3,98,1515,8,98,1,98,1, - 98,1,98,3,98,1520,8,98,1,98,1,98,1,98,3,98,1525,8,98,1,98,1,98,1, - 98,3,98,1530,8,98,1,98,1,98,3,98,1534,8,98,1,98,1,98,1,98,1,98,1, - 98,1,98,1,98,3,98,1543,8,98,1,98,3,98,1546,8,98,1,98,1,98,3,98,1550, - 8,98,1,99,1,99,1,99,5,99,1555,8,99,10,99,12,99,1558,9,99,1,100,1, - 100,1,100,1,100,1,101,1,101,1,101,1,101,3,101,1568,8,101,1,101,1, - 101,1,101,1,101,3,101,1574,8,101,5,101,1576,8,101,10,101,12,101, - 1579,9,101,1,101,1,101,1,102,3,102,1584,8,102,1,102,1,102,1,103, - 1,103,1,103,1,103,5,103,1592,8,103,10,103,12,103,1595,9,103,1,104, - 1,104,1,104,1,104,3,104,1601,8,104,1,104,1,104,1,104,3,104,1606, - 8,104,1,104,1,104,1,104,3,104,1611,8,104,1,104,1,104,1,104,3,104, - 1616,8,104,1,104,1,104,5,104,1620,8,104,10,104,12,104,1623,9,104, - 3,104,1625,8,104,1,105,1,105,1,105,1,105,1,105,1,105,1,105,3,105, - 1634,8,105,1,105,3,105,1637,8,105,1,105,3,105,1640,8,105,1,106,1, - 106,1,106,1,106,3,106,1646,8,106,1,107,1,107,1,107,1,107,3,107,1652, - 8,107,1,108,1,108,1,109,1,109,1,109,1,109,5,109,1660,8,109,10,109, - 12,109,1663,9,109,3,109,1665,8,109,1,109,1,109,3,109,1669,8,109, - 1,109,1,109,3,109,1673,8,109,1,110,1,110,1,110,5,110,1678,8,110, - 10,110,12,110,1681,9,110,3,110,1683,8,110,1,111,1,111,1,111,1,111, - 3,111,1689,8,111,1,111,1,111,5,111,1693,8,111,10,111,12,111,1696, - 9,111,3,111,1698,8,111,1,112,3,112,1701,8,112,1,112,1,112,3,112, - 1705,8,112,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113, - 1715,8,113,1,114,1,114,1,115,1,115,1,116,1,116,1,116,5,116,1724, - 8,116,10,116,12,116,1727,9,116,1,116,1,116,3,116,1731,8,116,1,116, - 3,116,1734,8,116,1,117,1,117,3,117,1738,8,117,1,117,1,117,1,117, - 1,118,1,118,3,118,1745,8,118,1,118,1,118,1,118,1,118,1,118,1,118, - 5,118,1753,8,118,10,118,12,118,1756,9,118,1,118,1,118,1,119,1,119, - 1,119,1,119,1,119,1,119,1,119,3,119,1767,8,119,1,119,1,119,1,119, - 1,119,3,119,1773,8,119,3,119,1775,8,119,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,3,120,1784,8,120,1,120,3,120,1787,8,120,1,121, - 1,121,1,121,1,121,1,121,3,121,1794,8,121,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,3,122,1804,8,122,1,123,1,123,1,123,1,123, - 3,123,1810,8,123,1,124,1,124,1,124,1,124,5,124,1816,8,124,10,124, - 12,124,1819,9,124,1,124,1,124,1,125,1,125,1,125,1,125,5,125,1827, - 8,125,10,125,12,125,1830,9,125,1,125,1,125,1,126,1,126,1,126,5,126, - 1837,8,126,10,126,12,126,1840,9,126,1,127,1,127,1,127,1,127,1,127, - 1,127,1,127,1,127,3,127,1850,8,127,3,127,1852,8,127,1,127,1,127, - 1,127,1,127,3,127,1858,8,127,1,128,1,128,1,128,3,128,1863,8,128, - 1,129,1,129,1,129,1,129,1,129,1,129,5,129,1871,8,129,10,129,12,129, - 1874,9,129,3,129,1876,8,129,1,129,1,129,1,129,1,129,3,129,1882,8, - 129,3,129,1884,8,129,1,130,1,130,1,130,1,130,1,130,1,130,3,130,1892, - 8,130,1,130,1,130,1,130,1,130,3,130,1898,8,130,1,130,5,130,1901, - 8,130,10,130,12,130,1904,9,130,1,131,1,131,1,131,1,131,1,131,1,131, - 1,131,5,131,1913,8,131,10,131,12,131,1916,9,131,1,131,1,131,1,131, - 1,131,3,131,1922,8,131,1,132,1,132,3,132,1926,8,132,1,132,1,132, - 3,132,1930,8,132,1,133,1,133,3,133,1934,8,133,1,133,3,133,1937,8, - 133,1,133,1,133,1,133,5,133,1942,8,133,10,133,12,133,1945,9,133, - 1,133,1,133,1,133,1,133,5,133,1951,8,133,10,133,12,133,1954,9,133, - 3,133,1956,8,133,1,133,1,133,3,133,1960,8,133,1,133,1,133,1,133, - 3,133,1965,8,133,1,133,1,133,3,133,1969,8,133,1,134,3,134,1972,8, - 134,1,134,1,134,1,134,5,134,1977,8,134,10,134,12,134,1980,9,134, - 1,135,1,135,1,136,1,136,1,136,1,136,5,136,1988,8,136,10,136,12,136, - 1991,9,136,3,136,1993,8,136,1,136,1,136,3,136,1997,8,136,1,137,1, - 137,3,137,2001,8,137,1,137,1,137,1,137,1,138,1,138,1,139,1,139,3, - 139,2010,8,139,1,139,3,139,2013,8,139,1,139,1,139,1,139,1,139,1, - 139,3,139,2020,8,139,1,140,1,140,1,140,1,140,1,140,1,140,1,140,1, - 140,1,140,1,140,1,140,1,140,3,140,2034,8,140,5,140,2036,8,140,10, - 140,12,140,2039,9,140,1,141,3,141,2042,8,141,1,141,1,141,3,141,2046, - 8,141,1,141,1,141,3,141,2050,8,141,1,141,1,141,3,141,2054,8,141, - 1,141,1,141,3,141,2058,8,141,1,141,1,141,3,141,2062,8,141,1,141, - 1,141,1,141,1,141,1,141,1,141,1,141,1,141,3,141,2072,8,141,1,142, - 1,142,1,142,1,142,1,142,1,142,1,142,5,142,2081,8,142,10,142,12,142, - 2084,9,142,1,142,1,142,3,142,2088,8,142,1,143,1,143,1,143,1,143, - 1,143,1,143,1,143,1,143,1,143,1,143,1,143,3,143,2101,8,143,3,143, - 2103,8,143,1,144,1,144,1,145,1,145,3,145,2109,8,145,1,145,1,145, - 3,145,2113,8,145,3,145,2115,8,145,1,146,1,146,1,146,1,146,5,146, - 2121,8,146,10,146,12,146,2124,9,146,1,146,1,146,1,147,1,147,3,147, - 2130,8,147,1,147,1,147,1,147,3,147,2135,8,147,1,148,1,148,1,148, - 1,148,1,149,1,149,1,149,1,149,1,149,5,149,2146,8,149,10,149,12,149, - 2149,9,149,1,149,1,149,1,149,3,149,2154,8,149,1,150,1,150,1,150, - 1,150,1,151,1,151,3,151,2162,8,151,1,152,1,152,1,153,1,153,1,153, - 3,153,2169,8,153,1,153,1,153,3,153,2173,8,153,1,153,1,153,1,153, - 1,153,1,153,1,153,5,153,2181,8,153,10,153,12,153,2184,9,153,1,154, - 1,154,1,154,1,154,1,154,1,154,1,154,1,154,3,154,2194,8,154,1,154, - 1,154,1,154,1,154,1,154,1,154,3,154,2202,8,154,1,154,1,154,1,154, - 1,154,1,154,5,154,2209,8,154,10,154,12,154,2212,9,154,1,154,1,154, - 1,154,3,154,2217,8,154,1,154,1,154,1,154,3,154,2222,8,154,1,154, - 1,154,1,154,1,154,3,154,2228,8,154,1,154,1,154,1,154,1,154,3,154, - 2234,8,154,1,154,1,154,1,154,3,154,2239,8,154,1,154,1,154,1,154, - 3,154,2244,8,154,1,155,1,155,1,155,1,155,3,155,2250,8,155,1,155, - 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,5,155,2261,8,155, - 10,155,12,155,2264,9,155,1,156,1,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,1,156,1,156,1,156,1,156,3,156,2290,8,156,1,156,1,156, - 1,156,1,156,3,156,2296,8,156,5,156,2298,8,156,10,156,12,156,2301, - 9,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,5,156,2310,8,156, - 10,156,12,156,2313,9,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156, - 3,156,2322,8,156,1,156,3,156,2325,8,156,1,156,1,156,1,156,3,156, - 2330,8,156,1,156,1,156,1,156,5,156,2335,8,156,10,156,12,156,2338, - 9,156,3,156,2340,8,156,1,156,1,156,1,156,1,156,1,156,5,156,2347, - 8,156,10,156,12,156,2350,9,156,3,156,2352,8,156,1,156,1,156,3,156, - 2356,8,156,1,156,3,156,2359,8,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,1,156,5,156,2369,8,156,10,156,12,156,2372,9,156,3,156, - 2374,8,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,1,156,1,156,1,156,1,156,4,156,2391,8,156,11,156,12,156, - 2392,1,156,1,156,3,156,2397,8,156,1,156,1,156,1,156,1,156,4,156, - 2403,8,156,11,156,12,156,2404,1,156,1,156,3,156,2409,8,156,1,156, - 1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,5,156,2432, - 8,156,10,156,12,156,2435,9,156,3,156,2437,8,156,1,156,1,156,1,156, - 1,156,1,156,1,156,1,156,3,156,2446,8,156,1,156,1,156,1,156,1,156, - 3,156,2452,8,156,1,156,1,156,1,156,1,156,3,156,2458,8,156,1,156, - 1,156,1,156,1,156,3,156,2464,8,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,1,156,1,156,3,156,2475,8,156,1,156,1,156,1,156,1,156, - 1,156,1,156,1,156,3,156,2484,8,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,5,156,2504,8,156,10,156,12,156,2507,9,156,3,156,2509, - 8,156,1,156,3,156,2512,8,156,1,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,5,156,2522,8,156,10,156,12,156,2525,9,156,1,157,1,157, - 1,157,1,157,3,157,2531,8,157,3,157,2533,8,157,1,158,1,158,1,159, - 1,159,1,160,1,160,1,161,1,161,1,161,1,161,1,161,1,161,1,161,1,161, - 1,161,1,161,1,161,1,161,1,161,1,161,3,161,2555,8,161,1,162,1,162, - 1,163,1,163,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164, - 1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164, - 1,164,5,164,2582,8,164,10,164,12,164,2585,9,164,1,164,1,164,1,164, - 1,164,3,164,2591,8,164,1,164,1,164,1,164,1,164,5,164,2597,8,164, - 10,164,12,164,2600,9,164,1,164,1,164,3,164,2604,8,164,3,164,2606, - 8,164,1,164,1,164,5,164,2610,8,164,10,164,12,164,2613,9,164,1,165, - 1,165,1,166,1,166,3,166,2619,8,166,1,167,1,167,1,167,1,167,3,167, - 2625,8,167,1,168,1,168,1,168,1,168,1,168,1,169,1,169,1,169,1,169, - 1,169,1,169,1,170,1,170,1,170,1,170,1,170,1,170,1,170,5,170,2645, - 8,170,10,170,12,170,2648,9,170,3,170,2650,8,170,1,170,1,170,1,170, - 1,170,1,170,5,170,2657,8,170,10,170,12,170,2660,9,170,3,170,2662, - 8,170,1,170,3,170,2665,8,170,1,170,1,170,1,171,1,171,1,171,1,171, - 1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171, - 1,171,3,171,2685,8,171,1,172,1,172,1,172,1,172,1,172,1,172,1,172, - 1,172,1,172,3,172,2696,8,172,1,173,1,173,1,173,1,173,1,173,3,173, - 2703,8,173,1,174,1,174,1,174,5,174,2708,8,174,10,174,12,174,2711, - 9,174,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175, - 1,175,3,175,2724,8,175,3,175,2726,8,175,1,176,1,176,1,177,1,177, - 1,177,5,177,2733,8,177,10,177,12,177,2736,9,177,1,178,1,178,1,178, - 1,178,1,178,1,178,3,178,2744,8,178,1,179,1,179,1,179,1,179,1,179, - 3,179,2751,8,179,1,180,3,180,2754,8,180,1,180,1,180,3,180,2758,8, - 180,1,180,1,180,3,180,2762,8,180,1,180,3,180,2765,8,180,1,181,1, - 181,1,182,1,182,1,182,10,770,1446,1621,1661,1679,1694,1725,1754, - 1828,2299,6,260,280,306,310,312,328,183,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,0,33,2,0,46,46,170,170,2,0,166,166,204,204,2,0,176,176,202, - 202,2,0,69,69,80,80,2,0,27,27,159,159,2,0,103,103,144,144,2,0,47, - 47,171,171,2,0,3,3,12,12,3,0,87,87,166,166,204,204,2,0,178,178,209, - 209,1,0,245,248,2,0,147,147,219,223,2,0,65,65,95,95,2,0,64,64,200, - 200,2,0,10,10,55,55,2,0,75,75,112,112,2,0,2,2,57,57,2,0,14,14,185, - 185,3,0,106,106,115,115,164,164,2,0,105,105,163,163,4,0,70,70,133, - 133,194,194,208,208,1,0,255,256,1,0,257,259,1,0,249,254,3,0,2,2, - 6,6,181,181,2,0,70,70,194,194,5,0,48,49,91,92,122,125,172,173,217, - 218,1,0,127,130,2,0,8,8,227,244,2,0,77,77,149,149,4,0,46,46,178, - 178,188,188,209,209,16,0,28,29,40,40,43,43,48,48,68,68,91,91,114, - 114,122,122,124,124,158,158,165,165,172,172,184,184,196,196,204, - 204,217,217,23,0,14,14,43,44,48,49,65,65,68,68,91,91,95,95,110,110, - 119,119,122,125,127,130,137,137,140,140,152,153,172,173,180,180, - 184,185,195,195,204,204,213,213,217,217,220,220,231,231,3093,0,369, - 1,0,0,0,2,374,1,0,0,0,4,400,1,0,0,0,6,402,1,0,0,0,8,413,1,0,0,0, - 10,415,1,0,0,0,12,454,1,0,0,0,14,476,1,0,0,0,16,531,1,0,0,0,18,551, - 1,0,0,0,20,565,1,0,0,0,22,569,1,0,0,0,24,631,1,0,0,0,26,679,1,0, - 0,0,28,681,1,0,0,0,30,689,1,0,0,0,32,709,1,0,0,0,34,729,1,0,0,0, - 36,736,1,0,0,0,38,745,1,0,0,0,40,753,1,0,0,0,42,775,1,0,0,0,44,785, - 1,0,0,0,46,803,1,0,0,0,48,824,1,0,0,0,50,845,1,0,0,0,52,851,1,0, - 0,0,54,868,1,0,0,0,56,877,1,0,0,0,58,884,1,0,0,0,60,892,1,0,0,0, - 62,899,1,0,0,0,64,906,1,0,0,0,66,915,1,0,0,0,68,926,1,0,0,0,70,928, - 1,0,0,0,72,948,1,0,0,0,74,965,1,0,0,0,76,967,1,0,0,0,78,976,1,0, - 0,0,80,983,1,0,0,0,82,992,1,0,0,0,84,1002,1,0,0,0,86,1025,1,0,0, - 0,88,1031,1,0,0,0,90,1033,1,0,0,0,92,1040,1,0,0,0,94,1052,1,0,0, - 0,96,1054,1,0,0,0,98,1061,1,0,0,0,100,1082,1,0,0,0,102,1111,1,0, - 0,0,104,1113,1,0,0,0,106,1122,1,0,0,0,108,1145,1,0,0,0,110,1164, - 1,0,0,0,112,1187,1,0,0,0,114,1189,1,0,0,0,116,1204,1,0,0,0,118,1223, - 1,0,0,0,120,1245,1,0,0,0,122,1250,1,0,0,0,124,1255,1,0,0,0,126,1260, - 1,0,0,0,128,1265,1,0,0,0,130,1272,1,0,0,0,132,1287,1,0,0,0,134,1293, - 1,0,0,0,136,1313,1,0,0,0,138,1315,1,0,0,0,140,1326,1,0,0,0,142,1337, - 1,0,0,0,144,1351,1,0,0,0,146,1353,1,0,0,0,148,1362,1,0,0,0,150,1371, - 1,0,0,0,152,1380,1,0,0,0,154,1383,1,0,0,0,156,1391,1,0,0,0,158,1407, - 1,0,0,0,160,1411,1,0,0,0,162,1435,1,0,0,0,164,1437,1,0,0,0,166,1453, - 1,0,0,0,168,1456,1,0,0,0,170,1460,1,0,0,0,172,1463,1,0,0,0,174,1467, - 1,0,0,0,176,1469,1,0,0,0,178,1471,1,0,0,0,180,1473,1,0,0,0,182,1475, - 1,0,0,0,184,1477,1,0,0,0,186,1479,1,0,0,0,188,1487,1,0,0,0,190,1497, - 1,0,0,0,192,1501,1,0,0,0,194,1505,1,0,0,0,196,1510,1,0,0,0,198,1551, - 1,0,0,0,200,1559,1,0,0,0,202,1563,1,0,0,0,204,1583,1,0,0,0,206,1587, - 1,0,0,0,208,1596,1,0,0,0,210,1626,1,0,0,0,212,1641,1,0,0,0,214,1647, - 1,0,0,0,216,1653,1,0,0,0,218,1655,1,0,0,0,220,1674,1,0,0,0,222,1684, - 1,0,0,0,224,1704,1,0,0,0,226,1714,1,0,0,0,228,1716,1,0,0,0,230,1718, - 1,0,0,0,232,1733,1,0,0,0,234,1735,1,0,0,0,236,1742,1,0,0,0,238,1774, - 1,0,0,0,240,1786,1,0,0,0,242,1793,1,0,0,0,244,1803,1,0,0,0,246,1805, - 1,0,0,0,248,1811,1,0,0,0,250,1822,1,0,0,0,252,1833,1,0,0,0,254,1841, - 1,0,0,0,256,1859,1,0,0,0,258,1864,1,0,0,0,260,1885,1,0,0,0,262,1921, - 1,0,0,0,264,1923,1,0,0,0,266,1931,1,0,0,0,268,1971,1,0,0,0,270,1981, - 1,0,0,0,272,1996,1,0,0,0,274,1998,1,0,0,0,276,2005,1,0,0,0,278,2019, - 1,0,0,0,280,2021,1,0,0,0,282,2071,1,0,0,0,284,2087,1,0,0,0,286,2089, - 1,0,0,0,288,2104,1,0,0,0,290,2106,1,0,0,0,292,2116,1,0,0,0,294,2134, - 1,0,0,0,296,2136,1,0,0,0,298,2140,1,0,0,0,300,2155,1,0,0,0,302,2161, - 1,0,0,0,304,2163,1,0,0,0,306,2172,1,0,0,0,308,2243,1,0,0,0,310,2249, - 1,0,0,0,312,2511,1,0,0,0,314,2532,1,0,0,0,316,2534,1,0,0,0,318,2536, - 1,0,0,0,320,2538,1,0,0,0,322,2554,1,0,0,0,324,2556,1,0,0,0,326,2558, - 1,0,0,0,328,2605,1,0,0,0,330,2614,1,0,0,0,332,2618,1,0,0,0,334,2624, - 1,0,0,0,336,2626,1,0,0,0,338,2631,1,0,0,0,340,2637,1,0,0,0,342,2684, - 1,0,0,0,344,2695,1,0,0,0,346,2702,1,0,0,0,348,2704,1,0,0,0,350,2725, - 1,0,0,0,352,2727,1,0,0,0,354,2729,1,0,0,0,356,2743,1,0,0,0,358,2750, - 1,0,0,0,360,2764,1,0,0,0,362,2766,1,0,0,0,364,2768,1,0,0,0,366,368, - 3,2,1,0,367,366,1,0,0,0,368,371,1,0,0,0,369,367,1,0,0,0,369,370, - 1,0,0,0,370,372,1,0,0,0,371,369,1,0,0,0,372,373,5,0,0,1,373,1,1, - 0,0,0,374,376,3,4,2,0,375,377,5,262,0,0,376,375,1,0,0,0,376,377, - 1,0,0,0,377,3,1,0,0,0,378,401,3,204,102,0,379,401,3,6,3,0,380,401, - 3,8,4,0,381,401,3,26,13,0,382,401,3,64,32,0,383,401,3,66,33,0,384, - 401,3,68,34,0,385,401,3,74,37,0,386,401,3,88,44,0,387,401,3,94,47, - 0,388,401,3,100,50,0,389,401,3,102,51,0,390,401,3,108,54,0,391,401, - 3,110,55,0,392,401,3,112,56,0,393,401,3,144,72,0,394,401,3,152,76, - 0,395,401,3,154,77,0,396,401,3,156,78,0,397,401,3,158,79,0,398,401, - 3,160,80,0,399,401,3,162,81,0,400,378,1,0,0,0,400,379,1,0,0,0,400, - 380,1,0,0,0,400,381,1,0,0,0,400,382,1,0,0,0,400,383,1,0,0,0,400, - 384,1,0,0,0,400,385,1,0,0,0,400,386,1,0,0,0,400,387,1,0,0,0,400, - 388,1,0,0,0,400,389,1,0,0,0,400,390,1,0,0,0,400,391,1,0,0,0,400, - 392,1,0,0,0,400,393,1,0,0,0,400,394,1,0,0,0,400,395,1,0,0,0,400, - 396,1,0,0,0,400,397,1,0,0,0,400,398,1,0,0,0,400,399,1,0,0,0,401, - 5,1,0,0,0,402,403,5,203,0,0,403,404,3,184,92,0,404,7,1,0,0,0,405, - 414,3,18,9,0,406,414,3,20,10,0,407,414,3,22,11,0,408,414,3,24,12, - 0,409,414,3,16,8,0,410,414,3,14,7,0,411,414,3,12,6,0,412,414,3,10, - 5,0,413,405,1,0,0,0,413,406,1,0,0,0,413,407,1,0,0,0,413,408,1,0, - 0,0,413,409,1,0,0,0,413,410,1,0,0,0,413,411,1,0,0,0,413,412,1,0, - 0,0,414,9,1,0,0,0,415,417,5,37,0,0,416,418,5,19,0,0,417,416,1,0, - 0,0,417,418,1,0,0,0,418,419,1,0,0,0,419,421,5,188,0,0,420,422,3, - 172,86,0,421,420,1,0,0,0,421,422,1,0,0,0,422,423,1,0,0,0,423,439, - 3,174,87,0,424,425,5,265,0,0,425,430,3,214,107,0,426,427,5,263,0, - 0,427,429,3,214,107,0,428,426,1,0,0,0,429,432,1,0,0,0,430,428,1, - 0,0,0,430,431,1,0,0,0,431,435,1,0,0,0,432,430,1,0,0,0,433,434,5, - 263,0,0,434,436,3,208,104,0,435,433,1,0,0,0,435,436,1,0,0,0,436, - 437,1,0,0,0,437,438,5,266,0,0,438,440,1,0,0,0,439,424,1,0,0,0,439, - 440,1,0,0,0,440,447,1,0,0,0,441,442,5,17,0,0,442,445,5,26,0,0,443, - 446,3,292,146,0,444,446,3,250,125,0,445,443,1,0,0,0,445,444,1,0, - 0,0,446,448,1,0,0,0,447,441,1,0,0,0,447,448,1,0,0,0,448,449,1,0, - 0,0,449,452,3,196,98,0,450,451,5,9,0,0,451,453,3,204,102,0,452,450, - 1,0,0,0,452,453,1,0,0,0,453,11,1,0,0,0,454,456,5,37,0,0,455,457, - 5,19,0,0,456,455,1,0,0,0,456,457,1,0,0,0,457,458,1,0,0,0,458,460, - 5,188,0,0,459,461,3,172,86,0,460,459,1,0,0,0,460,461,1,0,0,0,461, - 462,1,0,0,0,462,463,3,174,87,0,463,467,5,115,0,0,464,468,3,186,93, - 0,465,466,5,147,0,0,466,468,3,314,157,0,467,464,1,0,0,0,467,465, - 1,0,0,0,468,472,1,0,0,0,469,470,5,17,0,0,470,471,5,26,0,0,471,473, - 3,250,125,0,472,469,1,0,0,0,472,473,1,0,0,0,473,474,1,0,0,0,474, - 475,3,196,98,0,475,13,1,0,0,0,476,478,5,37,0,0,477,479,5,19,0,0, - 478,477,1,0,0,0,478,479,1,0,0,0,479,480,1,0,0,0,480,482,5,188,0, - 0,481,483,3,172,86,0,482,481,1,0,0,0,482,483,1,0,0,0,483,484,1,0, - 0,0,484,502,3,174,87,0,485,486,5,265,0,0,486,491,3,216,108,0,487, - 488,5,263,0,0,488,490,3,216,108,0,489,487,1,0,0,0,490,493,1,0,0, - 0,491,489,1,0,0,0,491,492,1,0,0,0,492,498,1,0,0,0,493,491,1,0,0, - 0,494,495,5,263,0,0,495,496,5,150,0,0,496,497,5,110,0,0,497,499, - 3,292,146,0,498,494,1,0,0,0,498,499,1,0,0,0,499,500,1,0,0,0,500, - 501,5,266,0,0,501,503,1,0,0,0,502,485,1,0,0,0,502,503,1,0,0,0,503, - 509,1,0,0,0,504,505,5,150,0,0,505,507,5,110,0,0,506,508,3,292,146, - 0,507,506,1,0,0,0,507,508,1,0,0,0,508,510,1,0,0,0,509,504,1,0,0, - 0,509,510,1,0,0,0,510,514,1,0,0,0,511,512,5,145,0,0,512,513,5,26, - 0,0,513,515,3,232,116,0,514,511,1,0,0,0,514,515,1,0,0,0,515,518, - 1,0,0,0,516,517,5,34,0,0,517,519,3,314,157,0,518,516,1,0,0,0,518, - 519,1,0,0,0,519,520,1,0,0,0,520,521,5,23,0,0,521,522,5,9,0,0,522, - 525,5,111,0,0,523,524,5,25,0,0,524,526,3,248,124,0,525,523,1,0,0, - 0,525,526,1,0,0,0,526,529,1,0,0,0,527,528,5,9,0,0,528,530,3,204, - 102,0,529,527,1,0,0,0,529,530,1,0,0,0,530,15,1,0,0,0,531,532,5,37, - 0,0,532,534,5,212,0,0,533,535,3,172,86,0,534,533,1,0,0,0,534,535, - 1,0,0,0,535,536,1,0,0,0,536,538,3,178,89,0,537,539,3,202,101,0,538, - 537,1,0,0,0,538,539,1,0,0,0,539,542,1,0,0,0,540,541,5,34,0,0,541, - 543,3,314,157,0,542,540,1,0,0,0,542,543,1,0,0,0,543,546,1,0,0,0, - 544,545,5,25,0,0,545,547,3,248,124,0,546,544,1,0,0,0,546,547,1,0, - 0,0,547,548,1,0,0,0,548,549,5,9,0,0,549,550,3,204,102,0,550,17,1, - 0,0,0,551,552,5,37,0,0,552,554,7,0,0,0,553,555,3,172,86,0,554,553, - 1,0,0,0,554,555,1,0,0,0,555,556,1,0,0,0,556,559,3,176,88,0,557,558, - 5,34,0,0,558,560,3,314,157,0,559,557,1,0,0,0,559,560,1,0,0,0,560, - 563,1,0,0,0,561,562,5,24,0,0,562,564,3,314,157,0,563,561,1,0,0,0, - 563,564,1,0,0,0,564,19,1,0,0,0,565,566,5,37,0,0,566,567,5,166,0, - 0,567,568,3,358,179,0,568,21,1,0,0,0,569,571,5,37,0,0,570,572,5, - 12,0,0,571,570,1,0,0,0,571,572,1,0,0,0,572,573,1,0,0,0,573,575,5, - 84,0,0,574,576,3,172,86,0,575,574,1,0,0,0,575,576,1,0,0,0,576,577, - 1,0,0,0,577,590,3,180,90,0,578,587,5,265,0,0,579,584,3,328,164,0, - 580,581,5,263,0,0,581,583,3,328,164,0,582,580,1,0,0,0,583,586,1, - 0,0,0,584,582,1,0,0,0,584,585,1,0,0,0,585,588,1,0,0,0,586,584,1, - 0,0,0,587,579,1,0,0,0,587,588,1,0,0,0,588,589,1,0,0,0,589,591,5, - 266,0,0,590,578,1,0,0,0,590,591,1,0,0,0,591,592,1,0,0,0,592,593, - 5,160,0,0,593,596,3,328,164,0,594,595,5,102,0,0,595,597,3,328,164, - 0,596,594,1,0,0,0,596,597,1,0,0,0,597,598,1,0,0,0,598,599,5,24,0, - 0,599,603,5,274,0,0,600,601,5,104,0,0,601,602,5,249,0,0,602,604, - 5,274,0,0,603,600,1,0,0,0,603,604,1,0,0,0,604,605,1,0,0,0,605,606, - 5,206,0,0,606,607,5,249,0,0,607,608,5,274,0,0,608,609,5,126,0,0, - 609,610,5,249,0,0,610,614,5,274,0,0,611,612,5,18,0,0,612,613,5,249, - 0,0,613,615,5,274,0,0,614,611,1,0,0,0,614,615,1,0,0,0,615,619,1, - 0,0,0,616,617,5,20,0,0,617,618,5,249,0,0,618,620,5,274,0,0,619,616, - 1,0,0,0,619,620,1,0,0,0,620,624,1,0,0,0,621,622,5,187,0,0,622,623, - 5,249,0,0,623,625,5,274,0,0,624,621,1,0,0,0,624,625,1,0,0,0,625, - 629,1,0,0,0,626,627,5,76,0,0,627,628,5,249,0,0,628,630,5,274,0,0, - 629,626,1,0,0,0,629,630,1,0,0,0,630,23,1,0,0,0,631,632,5,37,0,0, - 632,634,5,84,0,0,633,635,3,172,86,0,634,633,1,0,0,0,634,635,1,0, - 0,0,635,636,1,0,0,0,636,649,3,180,90,0,637,646,5,265,0,0,638,643, - 3,328,164,0,639,640,5,263,0,0,640,642,3,328,164,0,641,639,1,0,0, - 0,642,645,1,0,0,0,643,641,1,0,0,0,643,644,1,0,0,0,644,647,1,0,0, - 0,645,643,1,0,0,0,646,638,1,0,0,0,646,647,1,0,0,0,647,648,1,0,0, - 0,648,650,5,266,0,0,649,637,1,0,0,0,649,650,1,0,0,0,650,653,1,0, - 0,0,651,652,5,160,0,0,652,654,3,328,164,0,653,651,1,0,0,0,653,654, - 1,0,0,0,654,655,1,0,0,0,655,656,5,24,0,0,656,657,5,274,0,0,657,658, - 5,186,0,0,658,659,5,249,0,0,659,660,3,314,157,0,660,25,1,0,0,0,661, - 680,3,28,14,0,662,680,3,62,31,0,663,680,3,60,30,0,664,680,3,58,29, - 0,665,680,3,54,27,0,666,680,3,56,28,0,667,680,3,52,26,0,668,680, - 3,48,24,0,669,680,3,50,25,0,670,680,3,46,23,0,671,680,3,44,22,0, - 672,680,3,42,21,0,673,680,3,40,20,0,674,680,3,34,17,0,675,680,3, - 30,15,0,676,680,3,32,16,0,677,680,3,36,18,0,678,680,3,38,19,0,679, - 661,1,0,0,0,679,662,1,0,0,0,679,663,1,0,0,0,679,664,1,0,0,0,679, - 665,1,0,0,0,679,666,1,0,0,0,679,667,1,0,0,0,679,668,1,0,0,0,679, - 669,1,0,0,0,679,670,1,0,0,0,679,671,1,0,0,0,679,672,1,0,0,0,679, - 673,1,0,0,0,679,674,1,0,0,0,679,675,1,0,0,0,679,676,1,0,0,0,679, - 677,1,0,0,0,679,678,1,0,0,0,680,27,1,0,0,0,681,682,5,4,0,0,682,683, - 5,46,0,0,683,684,3,184,92,0,684,685,5,176,0,0,685,686,5,142,0,0, - 686,687,7,1,0,0,687,688,3,358,179,0,688,29,1,0,0,0,689,690,5,4,0, - 0,690,691,5,188,0,0,691,692,3,186,93,0,692,693,5,176,0,0,693,694, - 5,32,0,0,694,695,5,182,0,0,695,696,3,192,96,0,696,697,5,265,0,0, - 697,698,3,228,114,0,698,699,5,249,0,0,699,705,3,314,157,0,700,701, - 5,263,0,0,701,702,3,228,114,0,702,703,5,249,0,0,703,704,3,314,157, - 0,704,706,1,0,0,0,705,700,1,0,0,0,705,706,1,0,0,0,706,707,1,0,0, - 0,707,708,5,266,0,0,708,31,1,0,0,0,709,710,5,4,0,0,710,711,5,188, - 0,0,711,714,3,186,93,0,712,713,5,145,0,0,713,715,3,304,152,0,714, - 712,1,0,0,0,714,715,1,0,0,0,715,716,1,0,0,0,716,727,5,176,0,0,717, - 718,5,30,0,0,718,719,5,94,0,0,719,724,3,314,157,0,720,721,5,216, - 0,0,721,722,5,151,0,0,722,723,5,249,0,0,723,725,3,360,180,0,724, - 720,1,0,0,0,724,725,1,0,0,0,725,728,1,0,0,0,726,728,5,197,0,0,727, - 717,1,0,0,0,727,726,1,0,0,0,728,33,1,0,0,0,729,730,5,4,0,0,730,731, - 5,188,0,0,731,732,3,186,93,0,732,733,5,31,0,0,733,734,3,192,96,0, - 734,735,3,220,110,0,735,35,1,0,0,0,736,737,5,4,0,0,737,738,5,188, - 0,0,738,739,3,186,93,0,739,741,5,58,0,0,740,742,5,32,0,0,741,740, - 1,0,0,0,741,742,1,0,0,0,742,743,1,0,0,0,743,744,3,192,96,0,744,37, - 1,0,0,0,745,746,5,4,0,0,746,747,5,188,0,0,747,748,3,186,93,0,748, - 749,5,176,0,0,749,750,5,142,0,0,750,751,7,1,0,0,751,752,3,358,179, - 0,752,39,1,0,0,0,753,754,5,4,0,0,754,755,5,188,0,0,755,761,3,186, - 93,0,756,762,5,158,0,0,757,759,5,1,0,0,758,760,3,172,86,0,759,758, - 1,0,0,0,759,760,1,0,0,0,760,762,1,0,0,0,761,756,1,0,0,0,761,757, - 1,0,0,0,762,763,1,0,0,0,763,764,5,33,0,0,764,765,5,265,0,0,765,770, - 3,220,110,0,766,767,5,263,0,0,767,769,3,220,110,0,768,766,1,0,0, - 0,769,772,1,0,0,0,770,771,1,0,0,0,770,768,1,0,0,0,771,773,1,0,0, - 0,772,770,1,0,0,0,773,774,5,266,0,0,774,41,1,0,0,0,775,776,5,4,0, - 0,776,777,5,188,0,0,777,778,3,186,93,0,778,779,5,1,0,0,779,781,5, - 32,0,0,780,782,3,172,86,0,781,780,1,0,0,0,781,782,1,0,0,0,782,783, - 1,0,0,0,783,784,3,222,111,0,784,43,1,0,0,0,785,786,5,4,0,0,786,787, - 5,188,0,0,787,788,3,186,93,0,788,790,5,4,0,0,789,791,5,32,0,0,790, - 789,1,0,0,0,790,791,1,0,0,0,791,792,1,0,0,0,792,801,3,192,96,0,793, - 797,5,176,0,0,794,798,3,226,113,0,795,796,5,34,0,0,796,798,3,314, - 157,0,797,794,1,0,0,0,797,795,1,0,0,0,798,802,1,0,0,0,799,800,5, - 58,0,0,800,802,5,51,0,0,801,793,1,0,0,0,801,799,1,0,0,0,802,45,1, - 0,0,0,803,804,5,4,0,0,804,805,5,188,0,0,805,806,3,186,93,0,806,808, - 5,1,0,0,807,809,3,172,86,0,808,807,1,0,0,0,808,809,1,0,0,0,809,822, - 1,0,0,0,810,811,5,145,0,0,811,814,3,304,152,0,812,813,5,24,0,0,813, - 815,3,314,157,0,814,812,1,0,0,0,814,815,1,0,0,0,815,817,1,0,0,0, - 816,818,3,240,120,0,817,816,1,0,0,0,817,818,1,0,0,0,818,823,1,0, - 0,0,819,820,5,154,0,0,820,821,5,145,0,0,821,823,3,238,119,0,822, - 810,1,0,0,0,822,819,1,0,0,0,823,47,1,0,0,0,824,825,5,4,0,0,825,826, - 5,188,0,0,826,829,3,186,93,0,827,828,5,145,0,0,828,830,3,304,152, - 0,829,827,1,0,0,0,829,830,1,0,0,0,830,831,1,0,0,0,831,843,5,176, - 0,0,832,833,5,72,0,0,833,844,3,230,115,0,834,835,5,168,0,0,835,836, - 5,79,0,0,836,844,3,254,127,0,837,838,5,24,0,0,838,844,3,314,157, - 0,839,840,5,25,0,0,840,844,3,248,124,0,841,842,5,175,0,0,842,844, - 3,248,124,0,843,832,1,0,0,0,843,834,1,0,0,0,843,837,1,0,0,0,843, - 839,1,0,0,0,843,841,1,0,0,0,844,49,1,0,0,0,845,846,5,4,0,0,846,847, - 5,188,0,0,847,848,3,186,93,0,848,849,5,155,0,0,849,850,5,146,0,0, - 850,51,1,0,0,0,851,852,5,4,0,0,852,853,5,188,0,0,853,854,3,186,93, - 0,854,856,5,58,0,0,855,857,3,170,85,0,856,855,1,0,0,0,856,857,1, - 0,0,0,857,866,1,0,0,0,858,859,5,145,0,0,859,861,3,304,152,0,860, - 862,5,22,0,0,861,860,1,0,0,0,861,862,1,0,0,0,862,867,1,0,0,0,863, - 864,5,154,0,0,864,865,5,145,0,0,865,867,3,238,119,0,866,858,1,0, - 0,0,866,863,1,0,0,0,867,53,1,0,0,0,868,869,5,4,0,0,869,870,5,212, - 0,0,870,872,3,188,94,0,871,873,3,202,101,0,872,871,1,0,0,0,872,873, - 1,0,0,0,873,874,1,0,0,0,874,875,5,9,0,0,875,876,3,204,102,0,876, - 55,1,0,0,0,877,878,5,4,0,0,878,879,5,212,0,0,879,880,3,188,94,0, - 880,881,5,156,0,0,881,882,5,193,0,0,882,883,3,188,94,0,883,57,1, - 0,0,0,884,885,5,4,0,0,885,886,5,212,0,0,886,887,3,188,94,0,887,888, - 5,176,0,0,888,889,5,142,0,0,889,890,7,1,0,0,890,891,3,354,177,0, - 891,59,1,0,0,0,892,893,5,4,0,0,893,894,5,188,0,0,894,895,3,186,93, - 0,895,896,5,156,0,0,896,897,5,193,0,0,897,898,3,186,93,0,898,61, - 1,0,0,0,899,900,5,4,0,0,900,901,5,212,0,0,901,902,3,188,94,0,902, - 903,7,2,0,0,903,904,5,25,0,0,904,905,3,248,124,0,905,63,1,0,0,0, - 906,908,5,196,0,0,907,909,5,188,0,0,908,907,1,0,0,0,908,909,1,0, - 0,0,909,911,1,0,0,0,910,912,3,170,85,0,911,910,1,0,0,0,911,912,1, - 0,0,0,912,913,1,0,0,0,913,914,3,186,93,0,914,65,1,0,0,0,915,917, - 5,56,0,0,916,918,5,46,0,0,917,916,1,0,0,0,917,918,1,0,0,0,918,920, - 1,0,0,0,919,921,7,3,0,0,920,919,1,0,0,0,920,921,1,0,0,0,921,922, - 1,0,0,0,922,923,3,354,177,0,923,67,1,0,0,0,924,927,3,70,35,0,925, - 927,3,72,36,0,926,924,1,0,0,0,926,925,1,0,0,0,927,69,1,0,0,0,928, - 929,5,36,0,0,929,930,5,182,0,0,930,932,3,186,93,0,931,933,3,292, - 146,0,932,931,1,0,0,0,932,933,1,0,0,0,933,946,1,0,0,0,934,935,5, - 190,0,0,935,936,5,185,0,0,936,937,5,265,0,0,937,938,3,360,180,0, - 938,944,5,266,0,0,939,940,5,157,0,0,940,941,5,265,0,0,941,942,3, - 360,180,0,942,943,5,266,0,0,943,945,1,0,0,0,944,939,1,0,0,0,944, - 945,1,0,0,0,945,947,1,0,0,0,946,934,1,0,0,0,946,947,1,0,0,0,947, - 71,1,0,0,0,948,949,5,36,0,0,949,950,5,96,0,0,950,951,5,182,0,0,951, - 957,3,186,93,0,952,953,5,145,0,0,953,954,5,265,0,0,954,955,3,304, - 152,0,955,956,5,266,0,0,956,958,1,0,0,0,957,952,1,0,0,0,957,958, - 1,0,0,0,958,73,1,0,0,0,959,966,3,86,43,0,960,966,3,84,42,0,961,966, - 3,82,41,0,962,966,3,78,39,0,963,966,3,80,40,0,964,966,3,76,38,0, - 965,959,1,0,0,0,965,960,1,0,0,0,965,961,1,0,0,0,965,962,1,0,0,0, - 965,963,1,0,0,0,965,964,1,0,0,0,966,75,1,0,0,0,967,968,5,58,0,0, - 968,970,7,0,0,0,969,971,3,170,85,0,970,969,1,0,0,0,970,971,1,0,0, - 0,971,972,1,0,0,0,972,974,3,184,92,0,973,975,7,4,0,0,974,973,1,0, - 0,0,974,975,1,0,0,0,975,77,1,0,0,0,976,977,5,58,0,0,977,979,5,212, - 0,0,978,980,3,170,85,0,979,978,1,0,0,0,979,980,1,0,0,0,980,981,1, - 0,0,0,981,982,3,188,94,0,982,79,1,0,0,0,983,984,5,58,0,0,984,986, - 5,188,0,0,985,987,3,170,85,0,986,985,1,0,0,0,986,987,1,0,0,0,987, - 988,1,0,0,0,988,990,3,186,93,0,989,991,5,22,0,0,990,989,1,0,0,0, - 990,991,1,0,0,0,991,81,1,0,0,0,992,994,5,58,0,0,993,995,5,96,0,0, - 994,993,1,0,0,0,994,995,1,0,0,0,995,996,1,0,0,0,996,997,5,182,0, - 0,997,1000,3,186,93,0,998,999,5,145,0,0,999,1001,3,304,152,0,1000, - 998,1,0,0,0,1000,1001,1,0,0,0,1001,83,1,0,0,0,1002,1004,5,58,0,0, - 1003,1005,5,12,0,0,1004,1003,1,0,0,0,1004,1005,1,0,0,0,1005,1006, - 1,0,0,0,1006,1008,5,84,0,0,1007,1009,3,170,85,0,1008,1007,1,0,0, - 0,1008,1009,1,0,0,0,1009,1010,1,0,0,0,1010,1023,3,190,95,0,1011, - 1020,5,265,0,0,1012,1017,3,328,164,0,1013,1014,5,263,0,0,1014,1016, - 3,328,164,0,1015,1013,1,0,0,0,1016,1019,1,0,0,0,1017,1015,1,0,0, - 0,1017,1018,1,0,0,0,1018,1021,1,0,0,0,1019,1017,1,0,0,0,1020,1012, - 1,0,0,0,1020,1021,1,0,0,0,1021,1022,1,0,0,0,1022,1024,5,266,0,0, - 1023,1011,1,0,0,0,1023,1024,1,0,0,0,1024,85,1,0,0,0,1025,1026,5, - 58,0,0,1026,1027,5,166,0,0,1027,1028,3,358,179,0,1028,87,1,0,0,0, - 1029,1032,3,90,45,0,1030,1032,3,92,46,0,1031,1029,1,0,0,0,1031,1030, - 1,0,0,0,1032,89,1,0,0,0,1033,1034,5,86,0,0,1034,1035,5,166,0,0,1035, - 1036,3,358,179,0,1036,1037,5,193,0,0,1037,1038,5,87,0,0,1038,1039, - 3,358,179,0,1039,91,1,0,0,0,1040,1041,5,86,0,0,1041,1042,3,350,175, - 0,1042,1043,5,136,0,0,1043,1045,3,352,176,0,1044,1046,3,354,177, - 0,1045,1044,1,0,0,0,1045,1046,1,0,0,0,1046,1047,1,0,0,0,1047,1048, - 5,193,0,0,1048,1049,3,356,178,0,1049,93,1,0,0,0,1050,1053,3,96,48, - 0,1051,1053,3,98,49,0,1052,1050,1,0,0,0,1052,1051,1,0,0,0,1053,95, - 1,0,0,0,1054,1055,5,161,0,0,1055,1056,5,166,0,0,1056,1057,3,358, - 179,0,1057,1058,5,82,0,0,1058,1059,5,87,0,0,1059,1060,3,358,179, - 0,1060,97,1,0,0,0,1061,1065,5,161,0,0,1062,1063,5,86,0,0,1063,1064, - 5,137,0,0,1064,1066,5,78,0,0,1065,1062,1,0,0,0,1065,1066,1,0,0,0, - 1066,1067,1,0,0,0,1067,1068,3,350,175,0,1068,1069,5,136,0,0,1069, - 1071,3,352,176,0,1070,1072,3,354,177,0,1071,1070,1,0,0,0,1071,1072, - 1,0,0,0,1072,1073,1,0,0,0,1073,1079,5,82,0,0,1074,1080,3,356,178, - 0,1075,1077,5,166,0,0,1076,1075,1,0,0,0,1076,1077,1,0,0,0,1077,1078, - 1,0,0,0,1078,1080,3,358,179,0,1079,1074,1,0,0,0,1079,1076,1,0,0, - 0,1080,99,1,0,0,0,1081,1083,3,206,103,0,1082,1081,1,0,0,0,1082,1083, - 1,0,0,0,1083,1084,1,0,0,0,1084,1085,5,99,0,0,1085,1087,7,5,0,0,1086, - 1088,5,188,0,0,1087,1086,1,0,0,0,1087,1088,1,0,0,0,1088,1089,1,0, - 0,0,1089,1091,3,186,93,0,1090,1092,3,292,146,0,1091,1090,1,0,0,0, - 1091,1092,1,0,0,0,1092,1105,1,0,0,0,1093,1094,5,145,0,0,1094,1095, - 5,265,0,0,1095,1100,3,304,152,0,1096,1097,5,263,0,0,1097,1099,3, - 304,152,0,1098,1096,1,0,0,0,1099,1102,1,0,0,0,1100,1098,1,0,0,0, - 1100,1101,1,0,0,0,1101,1103,1,0,0,0,1102,1100,1,0,0,0,1103,1104, - 5,266,0,0,1104,1106,1,0,0,0,1105,1093,1,0,0,0,1105,1106,1,0,0,0, - 1106,1107,1,0,0,0,1107,1108,3,204,102,0,1108,101,1,0,0,0,1109,1112, - 3,104,52,0,1110,1112,3,106,53,0,1111,1109,1,0,0,0,1111,1110,1,0, - 0,0,1112,103,1,0,0,0,1113,1115,5,50,0,0,1114,1116,5,82,0,0,1115, - 1114,1,0,0,0,1115,1116,1,0,0,0,1116,1117,1,0,0,0,1117,1120,3,186, - 93,0,1118,1119,5,215,0,0,1119,1121,3,306,153,0,1120,1118,1,0,0,0, - 1120,1121,1,0,0,0,1121,105,1,0,0,0,1122,1123,5,50,0,0,1123,1128, - 3,186,93,0,1124,1126,5,9,0,0,1125,1124,1,0,0,0,1125,1126,1,0,0,0, - 1126,1127,1,0,0,0,1127,1129,3,358,179,0,1128,1125,1,0,0,0,1128,1129, - 1,0,0,0,1129,1130,1,0,0,0,1130,1139,5,82,0,0,1131,1136,3,280,140, - 0,1132,1133,5,263,0,0,1133,1135,3,280,140,0,1134,1132,1,0,0,0,1135, - 1138,1,0,0,0,1136,1134,1,0,0,0,1136,1137,1,0,0,0,1137,1140,1,0,0, - 0,1138,1136,1,0,0,0,1139,1131,1,0,0,0,1139,1140,1,0,0,0,1140,1143, - 1,0,0,0,1141,1142,5,215,0,0,1142,1144,3,306,153,0,1143,1141,1,0, - 0,0,1143,1144,1,0,0,0,1144,107,1,0,0,0,1145,1146,5,54,0,0,1146,1147, - 3,186,93,0,1147,1148,5,176,0,0,1148,1158,3,198,99,0,1149,1150,5, - 82,0,0,1150,1155,3,280,140,0,1151,1152,5,263,0,0,1152,1154,3,280, - 140,0,1153,1151,1,0,0,0,1154,1157,1,0,0,0,1155,1153,1,0,0,0,1155, - 1156,1,0,0,0,1156,1159,1,0,0,0,1157,1155,1,0,0,0,1158,1149,1,0,0, - 0,1158,1159,1,0,0,0,1159,1162,1,0,0,0,1160,1161,5,215,0,0,1161,1163, - 3,306,153,0,1162,1160,1,0,0,0,1162,1163,1,0,0,0,1163,109,1,0,0,0, - 1164,1165,5,207,0,0,1165,1167,5,103,0,0,1166,1168,5,188,0,0,1167, - 1166,1,0,0,0,1167,1168,1,0,0,0,1168,1169,1,0,0,0,1169,1171,3,186, - 93,0,1170,1172,3,292,146,0,1171,1170,1,0,0,0,1171,1172,1,0,0,0,1172, - 1173,1,0,0,0,1173,1174,3,204,102,0,1174,111,1,0,0,0,1175,1188,3, - 132,66,0,1176,1188,3,134,67,0,1177,1188,3,136,68,0,1178,1188,3,130, - 65,0,1179,1188,3,128,64,0,1180,1188,3,126,63,0,1181,1188,3,124,62, - 0,1182,1188,3,122,61,0,1183,1188,3,120,60,0,1184,1188,3,118,59,0, - 1185,1188,3,116,58,0,1186,1188,3,114,57,0,1187,1175,1,0,0,0,1187, - 1176,1,0,0,0,1187,1177,1,0,0,0,1187,1178,1,0,0,0,1187,1179,1,0,0, - 0,1187,1180,1,0,0,0,1187,1181,1,0,0,0,1187,1182,1,0,0,0,1187,1183, - 1,0,0,0,1187,1184,1,0,0,0,1187,1185,1,0,0,0,1187,1186,1,0,0,0,1188, - 113,1,0,0,0,1189,1190,5,179,0,0,1190,1202,7,6,0,0,1191,1193,5,115, - 0,0,1192,1191,1,0,0,0,1192,1193,1,0,0,0,1193,1194,1,0,0,0,1194,1199, - 3,314,157,0,1195,1196,5,271,0,0,1196,1198,3,314,157,0,1197,1195, - 1,0,0,0,1198,1201,1,0,0,0,1199,1197,1,0,0,0,1199,1200,1,0,0,0,1200, - 1203,1,0,0,0,1201,1199,1,0,0,0,1202,1192,1,0,0,0,1202,1203,1,0,0, - 0,1203,115,1,0,0,0,1204,1205,5,179,0,0,1205,1208,5,189,0,0,1206, - 1207,5,94,0,0,1207,1209,3,186,93,0,1208,1206,1,0,0,0,1208,1209,1, - 0,0,0,1209,1221,1,0,0,0,1210,1212,5,115,0,0,1211,1210,1,0,0,0,1211, - 1212,1,0,0,0,1212,1213,1,0,0,0,1213,1218,3,314,157,0,1214,1215,5, - 271,0,0,1215,1217,3,314,157,0,1216,1214,1,0,0,0,1217,1220,1,0,0, - 0,1218,1216,1,0,0,0,1218,1219,1,0,0,0,1219,1222,1,0,0,0,1220,1218, - 1,0,0,0,1221,1211,1,0,0,0,1221,1222,1,0,0,0,1222,117,1,0,0,0,1223, - 1225,5,179,0,0,1224,1226,7,7,0,0,1225,1224,1,0,0,0,1225,1226,1,0, - 0,0,1226,1227,1,0,0,0,1227,1230,5,85,0,0,1228,1229,5,94,0,0,1229, - 1231,3,184,92,0,1230,1228,1,0,0,0,1230,1231,1,0,0,0,1231,1243,1, - 0,0,0,1232,1234,5,115,0,0,1233,1232,1,0,0,0,1233,1234,1,0,0,0,1234, - 1235,1,0,0,0,1235,1240,3,314,157,0,1236,1237,5,271,0,0,1237,1239, - 3,314,157,0,1238,1236,1,0,0,0,1239,1242,1,0,0,0,1240,1238,1,0,0, - 0,1240,1241,1,0,0,0,1241,1244,1,0,0,0,1242,1240,1,0,0,0,1243,1233, - 1,0,0,0,1243,1244,1,0,0,0,1244,119,1,0,0,0,1245,1246,5,179,0,0,1246, - 1247,5,37,0,0,1247,1248,5,188,0,0,1248,1249,3,186,93,0,1249,121, - 1,0,0,0,1250,1251,5,179,0,0,1251,1252,5,37,0,0,1252,1253,5,212,0, - 0,1253,1254,3,188,94,0,1254,123,1,0,0,0,1255,1256,5,179,0,0,1256, - 1257,5,188,0,0,1257,1258,5,182,0,0,1258,1259,3,186,93,0,1259,125, - 1,0,0,0,1260,1261,5,179,0,0,1261,1262,5,32,0,0,1262,1263,5,182,0, - 0,1263,1264,3,186,93,0,1264,127,1,0,0,0,1265,1267,5,179,0,0,1266, - 1268,5,154,0,0,1267,1266,1,0,0,0,1267,1268,1,0,0,0,1268,1269,1,0, - 0,0,1269,1270,5,146,0,0,1270,1271,3,186,93,0,1271,129,1,0,0,0,1272, - 1273,5,179,0,0,1273,1274,5,73,0,0,1274,1275,5,94,0,0,1275,1285,3, - 186,93,0,1276,1277,5,145,0,0,1277,1278,5,265,0,0,1278,1281,3,304, - 152,0,1279,1280,5,263,0,0,1280,1282,3,304,152,0,1281,1279,1,0,0, - 0,1281,1282,1,0,0,0,1282,1283,1,0,0,0,1283,1284,5,266,0,0,1284,1286, - 1,0,0,0,1285,1276,1,0,0,0,1285,1286,1,0,0,0,1286,131,1,0,0,0,1287, - 1289,5,179,0,0,1288,1290,5,39,0,0,1289,1288,1,0,0,0,1289,1290,1, - 0,0,0,1290,1291,1,0,0,0,1291,1292,5,167,0,0,1292,133,1,0,0,0,1293, - 1294,5,179,0,0,1294,1295,5,166,0,0,1295,1296,5,86,0,0,1296,1297, - 5,87,0,0,1297,1298,3,358,179,0,1298,135,1,0,0,0,1299,1314,3,138, - 69,0,1300,1314,3,140,70,0,1301,1314,3,142,71,0,1302,1303,5,179,0, - 0,1303,1304,5,86,0,0,1304,1305,7,8,0,0,1305,1311,3,358,179,0,1306, - 1307,5,136,0,0,1307,1309,7,9,0,0,1308,1310,3,354,177,0,1309,1308, - 1,0,0,0,1309,1310,1,0,0,0,1310,1312,1,0,0,0,1311,1306,1,0,0,0,1311, - 1312,1,0,0,0,1312,1314,1,0,0,0,1313,1299,1,0,0,0,1313,1300,1,0,0, - 0,1313,1301,1,0,0,0,1313,1302,1,0,0,0,1314,137,1,0,0,0,1315,1316, - 5,179,0,0,1316,1317,5,86,0,0,1317,1318,7,8,0,0,1318,1324,3,358,179, - 0,1319,1320,5,136,0,0,1320,1322,5,46,0,0,1321,1323,3,184,92,0,1322, - 1321,1,0,0,0,1322,1323,1,0,0,0,1323,1325,1,0,0,0,1324,1319,1,0,0, - 0,1324,1325,1,0,0,0,1325,139,1,0,0,0,1326,1327,5,179,0,0,1327,1328, - 5,86,0,0,1328,1329,7,8,0,0,1329,1335,3,358,179,0,1330,1331,5,136, - 0,0,1331,1333,5,188,0,0,1332,1334,3,186,93,0,1333,1332,1,0,0,0,1333, - 1334,1,0,0,0,1334,1336,1,0,0,0,1335,1330,1,0,0,0,1335,1336,1,0,0, - 0,1336,141,1,0,0,0,1337,1338,5,179,0,0,1338,1339,5,86,0,0,1339,1340, - 7,8,0,0,1340,1346,3,358,179,0,1341,1342,5,136,0,0,1342,1344,5,32, - 0,0,1343,1345,3,192,96,0,1344,1343,1,0,0,0,1344,1345,1,0,0,0,1345, - 1347,1,0,0,0,1346,1341,1,0,0,0,1346,1347,1,0,0,0,1347,143,1,0,0, - 0,1348,1352,3,146,73,0,1349,1352,3,148,74,0,1350,1352,3,150,75,0, - 1351,1348,1,0,0,0,1351,1349,1,0,0,0,1351,1350,1,0,0,0,1352,145,1, - 0,0,0,1353,1354,5,34,0,0,1354,1355,5,136,0,0,1355,1356,5,46,0,0, - 1356,1357,3,184,92,0,1357,1360,5,108,0,0,1358,1361,3,314,157,0,1359, - 1361,5,133,0,0,1360,1358,1,0,0,0,1360,1359,1,0,0,0,1361,147,1,0, - 0,0,1362,1363,5,34,0,0,1363,1364,5,136,0,0,1364,1365,5,188,0,0,1365, - 1366,3,186,93,0,1366,1369,5,108,0,0,1367,1370,3,314,157,0,1368,1370, - 5,133,0,0,1369,1367,1,0,0,0,1369,1368,1,0,0,0,1370,149,1,0,0,0,1371, - 1372,5,34,0,0,1372,1373,5,136,0,0,1373,1374,5,32,0,0,1374,1375,3, - 192,96,0,1375,1378,5,108,0,0,1376,1379,3,314,157,0,1377,1379,5,133, - 0,0,1378,1376,1,0,0,0,1378,1377,1,0,0,0,1379,151,1,0,0,0,1380,1381, - 5,67,0,0,1381,1382,3,4,2,0,1382,153,1,0,0,0,1383,1389,5,176,0,0, - 1384,1390,5,2,0,0,1385,1386,3,358,179,0,1386,1387,5,249,0,0,1387, - 1388,3,304,152,0,1388,1390,1,0,0,0,1389,1384,1,0,0,0,1389,1385,1, - 0,0,0,1389,1390,1,0,0,0,1390,155,1,0,0,0,1391,1392,5,264,0,0,1392, - 1393,5,180,0,0,1393,1403,5,265,0,0,1394,1396,3,314,157,0,1395,1394, - 1,0,0,0,1395,1396,1,0,0,0,1396,1404,1,0,0,0,1397,1400,3,314,157, - 0,1398,1399,5,263,0,0,1399,1401,3,304,152,0,1400,1398,1,0,0,0,1400, - 1401,1,0,0,0,1401,1404,1,0,0,0,1402,1404,3,304,152,0,1403,1395,1, - 0,0,0,1403,1397,1,0,0,0,1403,1402,1,0,0,0,1404,1405,1,0,0,0,1405, - 1406,5,266,0,0,1406,157,1,0,0,0,1407,1408,5,107,0,0,1408,1409,5, - 121,0,0,1409,1410,3,186,93,0,1410,159,1,0,0,0,1411,1412,5,118,0, - 0,1412,1413,5,45,0,0,1413,1414,5,98,0,0,1414,1416,5,274,0,0,1415, - 1417,5,144,0,0,1416,1415,1,0,0,0,1416,1417,1,0,0,0,1417,1418,1,0, - 0,0,1418,1419,5,103,0,0,1419,1420,5,188,0,0,1420,1430,3,186,93,0, - 1421,1422,5,145,0,0,1422,1423,5,265,0,0,1423,1426,3,304,152,0,1424, - 1425,5,263,0,0,1425,1427,3,304,152,0,1426,1424,1,0,0,0,1426,1427, - 1,0,0,0,1427,1428,1,0,0,0,1428,1429,5,266,0,0,1429,1431,1,0,0,0, - 1430,1421,1,0,0,0,1430,1431,1,0,0,0,1431,161,1,0,0,0,1432,1436,3, - 164,82,0,1433,1436,3,166,83,0,1434,1436,3,168,84,0,1435,1432,1,0, - 0,0,1435,1433,1,0,0,0,1435,1434,1,0,0,0,1436,163,1,0,0,0,1437,1438, - 5,162,0,0,1438,1451,3,186,93,0,1439,1440,5,145,0,0,1440,1441,5,265, - 0,0,1441,1446,3,304,152,0,1442,1443,5,263,0,0,1443,1445,3,304,152, - 0,1444,1442,1,0,0,0,1445,1448,1,0,0,0,1446,1447,1,0,0,0,1446,1444, - 1,0,0,0,1447,1449,1,0,0,0,1448,1446,1,0,0,0,1449,1450,5,266,0,0, - 1450,1452,1,0,0,0,1451,1439,1,0,0,0,1451,1452,1,0,0,0,1452,165,1, - 0,0,0,1453,1454,5,162,0,0,1454,1455,5,13,0,0,1455,167,1,0,0,0,1456, - 1457,5,162,0,0,1457,1458,5,85,0,0,1458,1459,3,190,95,0,1459,169, - 1,0,0,0,1460,1461,5,93,0,0,1461,1462,5,66,0,0,1462,171,1,0,0,0,1463, - 1464,5,93,0,0,1464,1465,5,132,0,0,1465,1466,5,66,0,0,1466,173,1, - 0,0,0,1467,1468,3,354,177,0,1468,175,1,0,0,0,1469,1470,3,354,177, - 0,1470,177,1,0,0,0,1471,1472,3,354,177,0,1472,179,1,0,0,0,1473,1474, - 3,354,177,0,1474,181,1,0,0,0,1475,1476,3,354,177,0,1476,183,1,0, - 0,0,1477,1478,3,354,177,0,1478,185,1,0,0,0,1479,1484,3,358,179,0, - 1480,1481,5,261,0,0,1481,1483,3,358,179,0,1482,1480,1,0,0,0,1483, - 1486,1,0,0,0,1484,1482,1,0,0,0,1484,1485,1,0,0,0,1485,187,1,0,0, - 0,1486,1484,1,0,0,0,1487,1492,3,358,179,0,1488,1489,5,261,0,0,1489, - 1491,3,358,179,0,1490,1488,1,0,0,0,1491,1494,1,0,0,0,1492,1490,1, - 0,0,0,1492,1493,1,0,0,0,1493,189,1,0,0,0,1494,1492,1,0,0,0,1495, - 1498,3,362,181,0,1496,1498,3,354,177,0,1497,1495,1,0,0,0,1497,1496, - 1,0,0,0,1498,191,1,0,0,0,1499,1502,3,354,177,0,1500,1502,4,96,0, - 0,1501,1499,1,0,0,0,1501,1500,1,0,0,0,1502,193,1,0,0,0,1503,1506, - 3,186,93,0,1504,1506,3,188,94,0,1505,1503,1,0,0,0,1505,1504,1,0, - 0,0,1506,195,1,0,0,0,1507,1508,5,21,0,0,1508,1509,5,26,0,0,1509, - 1511,3,292,146,0,1510,1507,1,0,0,0,1510,1511,1,0,0,0,1511,1514,1, - 0,0,0,1512,1513,5,34,0,0,1513,1515,3,314,157,0,1514,1512,1,0,0,0, - 1514,1515,1,0,0,0,1515,1519,1,0,0,0,1516,1517,5,168,0,0,1517,1518, - 5,79,0,0,1518,1520,3,254,127,0,1519,1516,1,0,0,0,1519,1520,1,0,0, - 0,1520,1524,1,0,0,0,1521,1522,5,216,0,0,1522,1523,5,175,0,0,1523, - 1525,3,248,124,0,1524,1521,1,0,0,0,1524,1525,1,0,0,0,1525,1529,1, - 0,0,0,1526,1527,5,23,0,0,1527,1528,5,9,0,0,1528,1530,3,230,115,0, - 1529,1526,1,0,0,0,1529,1530,1,0,0,0,1530,1533,1,0,0,0,1531,1532, - 5,24,0,0,1532,1534,3,314,157,0,1533,1531,1,0,0,0,1533,1534,1,0,0, - 0,1534,1545,1,0,0,0,1535,1536,5,30,0,0,1536,1537,5,94,0,0,1537,1542, - 3,354,177,0,1538,1539,5,216,0,0,1539,1540,5,151,0,0,1540,1541,5, - 249,0,0,1541,1543,5,277,0,0,1542,1538,1,0,0,0,1542,1543,1,0,0,0, - 1543,1546,1,0,0,0,1544,1546,5,197,0,0,1545,1535,1,0,0,0,1545,1544, - 1,0,0,0,1545,1546,1,0,0,0,1546,1549,1,0,0,0,1547,1548,5,25,0,0,1548, - 1550,3,248,124,0,1549,1547,1,0,0,0,1549,1550,1,0,0,0,1550,197,1, - 0,0,0,1551,1556,3,200,100,0,1552,1553,5,263,0,0,1553,1555,3,200, - 100,0,1554,1552,1,0,0,0,1555,1558,1,0,0,0,1556,1554,1,0,0,0,1556, - 1557,1,0,0,0,1557,199,1,0,0,0,1558,1556,1,0,0,0,1559,1560,3,354, - 177,0,1560,1561,5,249,0,0,1561,1562,3,304,152,0,1562,201,1,0,0,0, - 1563,1564,5,265,0,0,1564,1567,3,182,91,0,1565,1566,5,34,0,0,1566, - 1568,3,314,157,0,1567,1565,1,0,0,0,1567,1568,1,0,0,0,1568,1577,1, - 0,0,0,1569,1570,5,263,0,0,1570,1573,3,182,91,0,1571,1572,5,34,0, - 0,1572,1574,3,314,157,0,1573,1571,1,0,0,0,1573,1574,1,0,0,0,1574, - 1576,1,0,0,0,1575,1569,1,0,0,0,1576,1579,1,0,0,0,1577,1575,1,0,0, - 0,1577,1578,1,0,0,0,1578,1580,1,0,0,0,1579,1577,1,0,0,0,1580,1581, - 5,266,0,0,1581,203,1,0,0,0,1582,1584,3,206,103,0,1583,1582,1,0,0, - 0,1583,1584,1,0,0,0,1584,1585,1,0,0,0,1585,1586,3,258,129,0,1586, - 205,1,0,0,0,1587,1588,5,216,0,0,1588,1593,3,274,137,0,1589,1590, - 5,263,0,0,1590,1592,3,274,137,0,1591,1589,1,0,0,0,1592,1595,1,0, - 0,0,1593,1591,1,0,0,0,1593,1594,1,0,0,0,1594,207,1,0,0,0,1595,1593, - 1,0,0,0,1596,1597,5,150,0,0,1597,1598,5,110,0,0,1598,1600,3,292, - 146,0,1599,1601,5,53,0,0,1600,1599,1,0,0,0,1600,1601,1,0,0,0,1601, - 1605,1,0,0,0,1602,1606,5,225,0,0,1603,1604,5,263,0,0,1604,1606,5, - 225,0,0,1605,1602,1,0,0,0,1605,1603,1,0,0,0,1605,1606,1,0,0,0,1606, - 1610,1,0,0,0,1607,1611,5,226,0,0,1608,1609,5,263,0,0,1609,1611,5, - 226,0,0,1610,1607,1,0,0,0,1610,1608,1,0,0,0,1610,1611,1,0,0,0,1611, - 1624,1,0,0,0,1612,1613,5,263,0,0,1613,1616,3,210,105,0,1614,1616, - 3,210,105,0,1615,1612,1,0,0,0,1615,1614,1,0,0,0,1616,1621,1,0,0, - 0,1617,1618,5,263,0,0,1618,1620,3,210,105,0,1619,1617,1,0,0,0,1620, - 1623,1,0,0,0,1621,1622,1,0,0,0,1621,1619,1,0,0,0,1622,1625,1,0,0, - 0,1623,1621,1,0,0,0,1624,1615,1,0,0,0,1624,1625,1,0,0,0,1625,209, - 1,0,0,0,1626,1627,5,81,0,0,1627,1628,5,110,0,0,1628,1629,3,292,146, - 0,1629,1630,5,224,0,0,1630,1631,3,186,93,0,1631,1633,3,292,146,0, - 1632,1634,5,53,0,0,1633,1632,1,0,0,0,1633,1634,1,0,0,0,1634,1636, - 1,0,0,0,1635,1637,5,225,0,0,1636,1635,1,0,0,0,1636,1637,1,0,0,0, - 1637,1639,1,0,0,0,1638,1640,5,226,0,0,1639,1638,1,0,0,0,1639,1640, - 1,0,0,0,1640,211,1,0,0,0,1641,1642,3,192,96,0,1642,1645,3,328,164, - 0,1643,1644,5,34,0,0,1644,1646,3,314,157,0,1645,1643,1,0,0,0,1645, - 1646,1,0,0,0,1646,213,1,0,0,0,1647,1648,3,182,91,0,1648,1651,3,328, - 164,0,1649,1650,5,34,0,0,1650,1652,3,314,157,0,1651,1649,1,0,0,0, - 1651,1652,1,0,0,0,1652,215,1,0,0,0,1653,1654,3,218,109,0,1654,217, - 1,0,0,0,1655,1656,3,182,91,0,1656,1664,3,328,164,0,1657,1661,3,224, - 112,0,1658,1660,3,224,112,0,1659,1658,1,0,0,0,1660,1663,1,0,0,0, - 1661,1662,1,0,0,0,1661,1659,1,0,0,0,1662,1665,1,0,0,0,1663,1661, - 1,0,0,0,1664,1657,1,0,0,0,1664,1665,1,0,0,0,1665,1668,1,0,0,0,1666, - 1667,5,34,0,0,1667,1669,3,314,157,0,1668,1666,1,0,0,0,1668,1669, - 1,0,0,0,1669,1672,1,0,0,0,1670,1671,5,150,0,0,1671,1673,5,110,0, - 0,1672,1670,1,0,0,0,1672,1673,1,0,0,0,1673,219,1,0,0,0,1674,1682, - 3,212,106,0,1675,1679,3,224,112,0,1676,1678,3,224,112,0,1677,1676, - 1,0,0,0,1678,1681,1,0,0,0,1679,1680,1,0,0,0,1679,1677,1,0,0,0,1680, - 1683,1,0,0,0,1681,1679,1,0,0,0,1682,1675,1,0,0,0,1682,1683,1,0,0, - 0,1683,221,1,0,0,0,1684,1685,3,182,91,0,1685,1688,3,328,164,0,1686, - 1687,5,34,0,0,1687,1689,3,314,157,0,1688,1686,1,0,0,0,1688,1689, - 1,0,0,0,1689,1697,1,0,0,0,1690,1694,3,224,112,0,1691,1693,3,224, - 112,0,1692,1691,1,0,0,0,1693,1696,1,0,0,0,1694,1695,1,0,0,0,1694, - 1692,1,0,0,0,1695,1698,1,0,0,0,1696,1694,1,0,0,0,1697,1690,1,0,0, - 0,1697,1698,1,0,0,0,1698,223,1,0,0,0,1699,1701,5,132,0,0,1700,1699, - 1,0,0,0,1700,1701,1,0,0,0,1701,1702,1,0,0,0,1702,1705,5,133,0,0, - 1703,1705,3,226,113,0,1704,1700,1,0,0,0,1704,1703,1,0,0,0,1705,225, - 1,0,0,0,1706,1707,5,60,0,0,1707,1715,3,304,152,0,1708,1709,5,35, - 0,0,1709,1715,3,304,152,0,1710,1711,5,51,0,0,1711,1715,3,304,152, - 0,1712,1713,5,16,0,0,1713,1715,3,360,180,0,1714,1706,1,0,0,0,1714, - 1708,1,0,0,0,1714,1710,1,0,0,0,1714,1712,1,0,0,0,1715,227,1,0,0, - 0,1716,1717,7,10,0,0,1717,229,1,0,0,0,1718,1719,7,11,0,0,1719,231, - 1,0,0,0,1720,1725,3,234,117,0,1721,1722,5,263,0,0,1722,1724,3,234, - 117,0,1723,1721,1,0,0,0,1724,1727,1,0,0,0,1725,1726,1,0,0,0,1725, - 1723,1,0,0,0,1726,1730,1,0,0,0,1727,1725,1,0,0,0,1728,1729,5,263, - 0,0,1729,1731,3,236,118,0,1730,1728,1,0,0,0,1730,1731,1,0,0,0,1731, - 1734,1,0,0,0,1732,1734,3,236,118,0,1733,1720,1,0,0,0,1733,1732,1, - 0,0,0,1734,233,1,0,0,0,1735,1737,5,89,0,0,1736,1738,3,292,146,0, - 1737,1736,1,0,0,0,1737,1738,1,0,0,0,1738,1739,1,0,0,0,1739,1740, - 5,146,0,0,1740,1741,3,360,180,0,1741,235,1,0,0,0,1742,1744,5,154, - 0,0,1743,1745,3,292,146,0,1744,1743,1,0,0,0,1744,1745,1,0,0,0,1745, - 1746,1,0,0,0,1746,1747,5,265,0,0,1747,1748,5,145,0,0,1748,1754,3, - 238,119,0,1749,1750,5,263,0,0,1750,1751,5,145,0,0,1751,1753,3,238, - 119,0,1752,1749,1,0,0,0,1753,1756,1,0,0,0,1754,1755,1,0,0,0,1754, - 1752,1,0,0,0,1755,1757,1,0,0,0,1756,1754,1,0,0,0,1757,1758,5,266, - 0,0,1758,237,1,0,0,0,1759,1760,5,210,0,0,1760,1761,3,244,122,0,1761, - 1762,3,304,152,0,1762,1775,1,0,0,0,1763,1764,3,304,152,0,1764,1765, - 3,242,121,0,1765,1767,1,0,0,0,1766,1763,1,0,0,0,1766,1767,1,0,0, - 0,1767,1768,1,0,0,0,1768,1772,5,211,0,0,1769,1770,3,242,121,0,1770, - 1771,3,304,152,0,1771,1773,1,0,0,0,1772,1769,1,0,0,0,1772,1773,1, - 0,0,0,1773,1775,1,0,0,0,1774,1759,1,0,0,0,1774,1766,1,0,0,0,1775, - 239,1,0,0,0,1776,1777,5,30,0,0,1777,1778,5,94,0,0,1778,1783,3,358, - 179,0,1779,1780,5,216,0,0,1780,1781,5,151,0,0,1781,1782,5,249,0, - 0,1782,1784,3,360,180,0,1783,1779,1,0,0,0,1783,1784,1,0,0,0,1784, - 1787,1,0,0,0,1785,1787,5,197,0,0,1786,1776,1,0,0,0,1786,1785,1,0, - 0,0,1787,241,1,0,0,0,1788,1794,1,0,0,0,1789,1794,5,251,0,0,1790, - 1794,5,252,0,0,1791,1794,5,253,0,0,1792,1794,5,254,0,0,1793,1788, - 1,0,0,0,1793,1789,1,0,0,0,1793,1790,1,0,0,0,1793,1791,1,0,0,0,1793, - 1792,1,0,0,0,1794,243,1,0,0,0,1795,1804,5,249,0,0,1796,1804,5,250, - 0,0,1797,1804,5,115,0,0,1798,1804,5,164,0,0,1799,1804,5,163,0,0, - 1800,1804,5,15,0,0,1801,1804,5,94,0,0,1802,1804,3,242,121,0,1803, - 1795,1,0,0,0,1803,1796,1,0,0,0,1803,1797,1,0,0,0,1803,1798,1,0,0, - 0,1803,1799,1,0,0,0,1803,1800,1,0,0,0,1803,1801,1,0,0,0,1803,1802, - 1,0,0,0,1804,245,1,0,0,0,1805,1806,5,115,0,0,1806,1809,3,354,177, - 0,1807,1808,7,12,0,0,1808,1810,5,153,0,0,1809,1807,1,0,0,0,1809, - 1810,1,0,0,0,1810,247,1,0,0,0,1811,1812,5,265,0,0,1812,1817,3,256, - 128,0,1813,1814,5,263,0,0,1814,1816,3,256,128,0,1815,1813,1,0,0, - 0,1816,1819,1,0,0,0,1817,1815,1,0,0,0,1817,1818,1,0,0,0,1818,1820, - 1,0,0,0,1819,1817,1,0,0,0,1820,1821,5,266,0,0,1821,249,1,0,0,0,1822, - 1823,5,265,0,0,1823,1828,3,212,106,0,1824,1825,5,263,0,0,1825,1827, - 3,212,106,0,1826,1824,1,0,0,0,1827,1830,1,0,0,0,1828,1829,1,0,0, - 0,1828,1826,1,0,0,0,1829,1831,1,0,0,0,1830,1828,1,0,0,0,1831,1832, - 5,266,0,0,1832,251,1,0,0,0,1833,1838,3,304,152,0,1834,1835,5,263, - 0,0,1835,1837,3,304,152,0,1836,1834,1,0,0,0,1837,1840,1,0,0,0,1838, - 1836,1,0,0,0,1838,1839,1,0,0,0,1839,253,1,0,0,0,1840,1838,1,0,0, - 0,1841,1851,5,52,0,0,1842,1843,5,71,0,0,1843,1844,5,191,0,0,1844, - 1845,5,26,0,0,1845,1849,3,314,157,0,1846,1847,5,63,0,0,1847,1848, - 5,26,0,0,1848,1850,3,314,157,0,1849,1846,1,0,0,0,1849,1850,1,0,0, - 0,1850,1852,1,0,0,0,1851,1842,1,0,0,0,1851,1852,1,0,0,0,1852,1857, - 1,0,0,0,1853,1854,5,117,0,0,1854,1855,5,191,0,0,1855,1856,5,26,0, - 0,1856,1858,3,314,157,0,1857,1853,1,0,0,0,1857,1858,1,0,0,0,1858, - 255,1,0,0,0,1859,1862,3,358,179,0,1860,1861,5,249,0,0,1861,1863, - 3,304,152,0,1862,1860,1,0,0,0,1862,1863,1,0,0,0,1863,257,1,0,0,0, - 1864,1875,3,260,130,0,1865,1866,5,139,0,0,1866,1867,5,26,0,0,1867, - 1872,3,264,132,0,1868,1869,5,263,0,0,1869,1871,3,264,132,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,1876,1,0,0,0,1874,1872,1,0,0,0,1875,1865,1,0,0,0,1875,1876, - 1,0,0,0,1876,1883,1,0,0,0,1877,1878,5,116,0,0,1878,1881,3,304,152, - 0,1879,1880,5,135,0,0,1880,1882,5,277,0,0,1881,1879,1,0,0,0,1881, - 1882,1,0,0,0,1882,1884,1,0,0,0,1883,1877,1,0,0,0,1883,1884,1,0,0, - 0,1884,259,1,0,0,0,1885,1886,6,130,-1,0,1886,1887,3,262,131,0,1887, - 1902,1,0,0,0,1888,1889,10,2,0,0,1889,1891,5,100,0,0,1890,1892,3, - 276,138,0,1891,1890,1,0,0,0,1891,1892,1,0,0,0,1892,1893,1,0,0,0, - 1893,1901,3,260,130,3,1894,1895,10,1,0,0,1895,1897,7,13,0,0,1896, - 1898,3,276,138,0,1897,1896,1,0,0,0,1897,1898,1,0,0,0,1898,1899,1, - 0,0,0,1899,1901,3,260,130,2,1900,1888,1,0,0,0,1900,1894,1,0,0,0, - 1901,1904,1,0,0,0,1902,1900,1,0,0,0,1902,1903,1,0,0,0,1903,261,1, - 0,0,0,1904,1902,1,0,0,0,1905,1922,3,266,133,0,1906,1907,5,188,0, - 0,1907,1922,3,186,93,0,1908,1909,5,211,0,0,1909,1914,3,304,152,0, - 1910,1911,5,263,0,0,1911,1913,3,304,152,0,1912,1910,1,0,0,0,1913, - 1916,1,0,0,0,1914,1912,1,0,0,0,1914,1915,1,0,0,0,1915,1922,1,0,0, - 0,1916,1914,1,0,0,0,1917,1918,5,265,0,0,1918,1919,3,258,129,0,1919, - 1920,5,266,0,0,1920,1922,1,0,0,0,1921,1905,1,0,0,0,1921,1906,1,0, - 0,0,1921,1908,1,0,0,0,1921,1917,1,0,0,0,1922,263,1,0,0,0,1923,1925, - 3,302,151,0,1924,1926,7,14,0,0,1925,1924,1,0,0,0,1925,1926,1,0,0, - 0,1926,1929,1,0,0,0,1927,1928,5,134,0,0,1928,1930,7,15,0,0,1929, - 1927,1,0,0,0,1929,1930,1,0,0,0,1930,265,1,0,0,0,1931,1933,5,174, - 0,0,1932,1934,3,276,138,0,1933,1932,1,0,0,0,1933,1934,1,0,0,0,1934, - 1936,1,0,0,0,1935,1937,5,183,0,0,1936,1935,1,0,0,0,1936,1937,1,0, - 0,0,1937,1938,1,0,0,0,1938,1943,3,278,139,0,1939,1940,5,263,0,0, - 1940,1942,3,278,139,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,1955,1,0,0,0,1945,1943,1,0,0,0,1946, - 1947,5,82,0,0,1947,1952,3,280,140,0,1948,1949,5,263,0,0,1949,1951, - 3,280,140,0,1950,1948,1,0,0,0,1951,1954,1,0,0,0,1952,1950,1,0,0, - 0,1952,1953,1,0,0,0,1953,1956,1,0,0,0,1954,1952,1,0,0,0,1955,1946, - 1,0,0,0,1955,1956,1,0,0,0,1956,1959,1,0,0,0,1957,1958,5,215,0,0, - 1958,1960,3,306,153,0,1959,1957,1,0,0,0,1959,1960,1,0,0,0,1960,1964, - 1,0,0,0,1961,1962,5,87,0,0,1962,1963,5,26,0,0,1963,1965,3,268,134, - 0,1964,1961,1,0,0,0,1964,1965,1,0,0,0,1965,1968,1,0,0,0,1966,1967, - 5,90,0,0,1967,1969,3,306,153,0,1968,1966,1,0,0,0,1968,1969,1,0,0, - 0,1969,267,1,0,0,0,1970,1972,3,276,138,0,1971,1970,1,0,0,0,1971, - 1972,1,0,0,0,1972,1973,1,0,0,0,1973,1978,3,270,135,0,1974,1975,5, - 263,0,0,1975,1977,3,270,135,0,1976,1974,1,0,0,0,1977,1980,1,0,0, - 0,1978,1976,1,0,0,0,1978,1979,1,0,0,0,1979,269,1,0,0,0,1980,1978, - 1,0,0,0,1981,1982,3,272,136,0,1982,271,1,0,0,0,1983,1992,5,265,0, - 0,1984,1989,3,302,151,0,1985,1986,5,263,0,0,1986,1988,3,302,151, - 0,1987,1985,1,0,0,0,1988,1991,1,0,0,0,1989,1987,1,0,0,0,1989,1990, - 1,0,0,0,1990,1993,1,0,0,0,1991,1989,1,0,0,0,1992,1984,1,0,0,0,1992, - 1993,1,0,0,0,1993,1994,1,0,0,0,1994,1997,5,266,0,0,1995,1997,3,302, - 151,0,1996,1983,1,0,0,0,1996,1995,1,0,0,0,1997,273,1,0,0,0,1998, - 2000,3,358,179,0,1999,2001,3,292,146,0,2000,1999,1,0,0,0,2000,2001, - 1,0,0,0,2001,2002,1,0,0,0,2002,2003,5,9,0,0,2003,2004,3,296,148, - 0,2004,275,1,0,0,0,2005,2006,7,16,0,0,2006,277,1,0,0,0,2007,2012, - 3,302,151,0,2008,2010,5,9,0,0,2009,2008,1,0,0,0,2009,2010,1,0,0, - 0,2010,2011,1,0,0,0,2011,2013,3,358,179,0,2012,2009,1,0,0,0,2012, - 2013,1,0,0,0,2013,2020,1,0,0,0,2014,2015,3,354,177,0,2015,2016,5, - 261,0,0,2016,2017,5,257,0,0,2017,2020,1,0,0,0,2018,2020,5,257,0, - 0,2019,2007,1,0,0,0,2019,2014,1,0,0,0,2019,2018,1,0,0,0,2020,279, - 1,0,0,0,2021,2022,6,140,-1,0,2022,2023,3,286,143,0,2023,2037,1,0, - 0,0,2024,2033,10,2,0,0,2025,2026,5,38,0,0,2026,2027,5,109,0,0,2027, - 2034,3,286,143,0,2028,2029,3,282,141,0,2029,2030,5,109,0,0,2030, - 2031,3,280,140,0,2031,2032,3,284,142,0,2032,2034,1,0,0,0,2033,2025, - 1,0,0,0,2033,2028,1,0,0,0,2034,2036,1,0,0,0,2035,2024,1,0,0,0,2036, - 2039,1,0,0,0,2037,2035,1,0,0,0,2037,2038,1,0,0,0,2038,281,1,0,0, - 0,2039,2037,1,0,0,0,2040,2042,5,97,0,0,2041,2040,1,0,0,0,2041,2042, - 1,0,0,0,2042,2072,1,0,0,0,2043,2045,5,114,0,0,2044,2046,5,97,0,0, - 2045,2044,1,0,0,0,2045,2046,1,0,0,0,2046,2072,1,0,0,0,2047,2049, - 5,165,0,0,2048,2050,5,97,0,0,2049,2048,1,0,0,0,2049,2050,1,0,0,0, - 2050,2072,1,0,0,0,2051,2053,5,114,0,0,2052,2054,5,141,0,0,2053,2052, - 1,0,0,0,2053,2054,1,0,0,0,2054,2072,1,0,0,0,2055,2057,5,165,0,0, - 2056,2058,5,141,0,0,2057,2056,1,0,0,0,2057,2058,1,0,0,0,2058,2072, - 1,0,0,0,2059,2061,5,83,0,0,2060,2062,5,141,0,0,2061,2060,1,0,0,0, - 2061,2062,1,0,0,0,2062,2072,1,0,0,0,2063,2064,5,114,0,0,2064,2072, - 5,177,0,0,2065,2066,5,165,0,0,2066,2072,5,177,0,0,2067,2068,5,114, - 0,0,2068,2072,5,7,0,0,2069,2070,5,165,0,0,2070,2072,5,7,0,0,2071, - 2041,1,0,0,0,2071,2043,1,0,0,0,2071,2047,1,0,0,0,2071,2051,1,0,0, - 0,2071,2055,1,0,0,0,2071,2059,1,0,0,0,2071,2063,1,0,0,0,2071,2065, - 1,0,0,0,2071,2067,1,0,0,0,2071,2069,1,0,0,0,2072,283,1,0,0,0,2073, - 2074,5,136,0,0,2074,2088,3,306,153,0,2075,2076,5,205,0,0,2076,2077, - 5,265,0,0,2077,2082,3,358,179,0,2078,2079,5,263,0,0,2079,2081,3, - 358,179,0,2080,2078,1,0,0,0,2081,2084,1,0,0,0,2082,2080,1,0,0,0, - 2082,2083,1,0,0,0,2083,2085,1,0,0,0,2084,2082,1,0,0,0,2085,2086, - 5,266,0,0,2086,2088,1,0,0,0,2087,2073,1,0,0,0,2087,2075,1,0,0,0, - 2088,285,1,0,0,0,2089,2102,3,290,145,0,2090,2091,5,190,0,0,2091, - 2092,3,288,144,0,2092,2093,5,265,0,0,2093,2094,3,304,152,0,2094, - 2100,5,266,0,0,2095,2096,5,157,0,0,2096,2097,5,265,0,0,2097,2098, - 3,304,152,0,2098,2099,5,266,0,0,2099,2101,1,0,0,0,2100,2095,1,0, - 0,0,2100,2101,1,0,0,0,2101,2103,1,0,0,0,2102,2090,1,0,0,0,2102,2103, - 1,0,0,0,2103,287,1,0,0,0,2104,2105,7,17,0,0,2105,289,1,0,0,0,2106, - 2114,3,294,147,0,2107,2109,5,9,0,0,2108,2107,1,0,0,0,2108,2109,1, - 0,0,0,2109,2110,1,0,0,0,2110,2112,3,358,179,0,2111,2113,3,292,146, - 0,2112,2111,1,0,0,0,2112,2113,1,0,0,0,2113,2115,1,0,0,0,2114,2108, - 1,0,0,0,2114,2115,1,0,0,0,2115,291,1,0,0,0,2116,2117,5,265,0,0,2117, - 2122,3,192,96,0,2118,2119,5,263,0,0,2119,2121,3,192,96,0,2120,2118, - 1,0,0,0,2121,2124,1,0,0,0,2122,2120,1,0,0,0,2122,2123,1,0,0,0,2123, - 2125,1,0,0,0,2124,2122,1,0,0,0,2125,2126,5,266,0,0,2126,293,1,0, - 0,0,2127,2135,3,194,97,0,2128,2130,5,113,0,0,2129,2128,1,0,0,0,2129, - 2130,1,0,0,0,2130,2131,1,0,0,0,2131,2135,3,296,148,0,2132,2135,3, - 298,149,0,2133,2135,3,300,150,0,2134,2127,1,0,0,0,2134,2129,1,0, - 0,0,2134,2132,1,0,0,0,2134,2133,1,0,0,0,2135,295,1,0,0,0,2136,2137, - 5,265,0,0,2137,2138,3,204,102,0,2138,2139,5,266,0,0,2139,297,1,0, - 0,0,2140,2141,5,201,0,0,2141,2142,5,265,0,0,2142,2147,3,304,152, - 0,2143,2144,5,263,0,0,2144,2146,3,304,152,0,2145,2143,1,0,0,0,2146, - 2149,1,0,0,0,2147,2145,1,0,0,0,2147,2148,1,0,0,0,2148,2150,1,0,0, - 0,2149,2147,1,0,0,0,2150,2153,5,266,0,0,2151,2152,5,216,0,0,2152, - 2154,5,140,0,0,2153,2151,1,0,0,0,2153,2154,1,0,0,0,2154,299,1,0, - 0,0,2155,2156,5,265,0,0,2156,2157,3,280,140,0,2157,2158,5,266,0, - 0,2158,301,1,0,0,0,2159,2162,3,192,96,0,2160,2162,3,304,152,0,2161, - 2159,1,0,0,0,2161,2160,1,0,0,0,2162,303,1,0,0,0,2163,2164,3,306, - 153,0,2164,305,1,0,0,0,2165,2166,6,153,-1,0,2166,2168,3,310,155, - 0,2167,2169,3,308,154,0,2168,2167,1,0,0,0,2168,2169,1,0,0,0,2169, - 2173,1,0,0,0,2170,2171,5,132,0,0,2171,2173,3,306,153,3,2172,2165, - 1,0,0,0,2172,2170,1,0,0,0,2173,2182,1,0,0,0,2174,2175,10,2,0,0,2175, - 2176,5,5,0,0,2176,2181,3,306,153,3,2177,2178,10,1,0,0,2178,2179, - 5,138,0,0,2179,2181,3,306,153,2,2180,2174,1,0,0,0,2180,2177,1,0, - 0,0,2181,2184,1,0,0,0,2182,2180,1,0,0,0,2182,2183,1,0,0,0,2183,307, - 1,0,0,0,2184,2182,1,0,0,0,2185,2186,3,316,158,0,2186,2187,3,310, - 155,0,2187,2244,1,0,0,0,2188,2189,3,316,158,0,2189,2190,3,318,159, - 0,2190,2191,3,296,148,0,2191,2244,1,0,0,0,2192,2194,5,132,0,0,2193, - 2192,1,0,0,0,2193,2194,1,0,0,0,2194,2195,1,0,0,0,2195,2196,5,15, - 0,0,2196,2197,3,310,155,0,2197,2198,5,5,0,0,2198,2199,3,310,155, - 0,2199,2244,1,0,0,0,2200,2202,5,132,0,0,2201,2200,1,0,0,0,2201,2202, - 1,0,0,0,2202,2203,1,0,0,0,2203,2204,5,94,0,0,2204,2205,5,265,0,0, - 2205,2210,3,304,152,0,2206,2207,5,263,0,0,2207,2209,3,304,152,0, - 2208,2206,1,0,0,0,2209,2212,1,0,0,0,2210,2208,1,0,0,0,2210,2211, - 1,0,0,0,2211,2213,1,0,0,0,2212,2210,1,0,0,0,2213,2214,5,266,0,0, - 2214,2244,1,0,0,0,2215,2217,5,132,0,0,2216,2215,1,0,0,0,2216,2217, - 1,0,0,0,2217,2218,1,0,0,0,2218,2219,5,94,0,0,2219,2244,3,296,148, - 0,2220,2222,5,132,0,0,2221,2220,1,0,0,0,2221,2222,1,0,0,0,2222,2223, - 1,0,0,0,2223,2224,7,18,0,0,2224,2227,3,310,155,0,2225,2226,5,62, - 0,0,2226,2228,3,310,155,0,2227,2225,1,0,0,0,2227,2228,1,0,0,0,2228, - 2244,1,0,0,0,2229,2230,7,19,0,0,2230,2244,3,310,155,0,2231,2233, - 5,108,0,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,2244,7,20,0,0,2236,2238,5,108,0,0,2237, - 2239,5,132,0,0,2238,2237,1,0,0,0,2238,2239,1,0,0,0,2239,2240,1,0, - 0,0,2240,2241,5,57,0,0,2241,2242,5,82,0,0,2242,2244,3,310,155,0, - 2243,2185,1,0,0,0,2243,2188,1,0,0,0,2243,2193,1,0,0,0,2243,2201, - 1,0,0,0,2243,2216,1,0,0,0,2243,2221,1,0,0,0,2243,2229,1,0,0,0,2243, - 2231,1,0,0,0,2243,2236,1,0,0,0,2244,309,1,0,0,0,2245,2246,6,155, - -1,0,2246,2250,3,312,156,0,2247,2248,7,21,0,0,2248,2250,3,310,155, - 4,2249,2245,1,0,0,0,2249,2247,1,0,0,0,2250,2262,1,0,0,0,2251,2252, - 10,3,0,0,2252,2253,7,22,0,0,2253,2261,3,310,155,4,2254,2255,10,2, - 0,0,2255,2256,7,21,0,0,2256,2261,3,310,155,3,2257,2258,10,1,0,0, - 2258,2259,5,260,0,0,2259,2261,3,310,155,2,2260,2251,1,0,0,0,2260, - 2254,1,0,0,0,2260,2257,1,0,0,0,2261,2264,1,0,0,0,2262,2260,1,0,0, - 0,2262,2263,1,0,0,0,2263,311,1,0,0,0,2264,2262,1,0,0,0,2265,2266, - 6,156,-1,0,2266,2512,5,133,0,0,2267,2512,3,322,161,0,2268,2269,3, - 358,179,0,2269,2270,3,314,157,0,2270,2512,1,0,0,0,2271,2272,5,286, - 0,0,2272,2512,3,314,157,0,2273,2512,3,360,180,0,2274,2512,3,320, - 160,0,2275,2512,3,314,157,0,2276,2512,5,276,0,0,2277,2512,5,272, - 0,0,2278,2279,5,148,0,0,2279,2280,5,265,0,0,2280,2281,3,310,155, - 0,2281,2282,5,94,0,0,2282,2283,3,310,155,0,2283,2284,5,266,0,0,2284, - 2512,1,0,0,0,2285,2286,5,265,0,0,2286,2289,3,304,152,0,2287,2288, - 5,9,0,0,2288,2290,3,328,164,0,2289,2287,1,0,0,0,2289,2290,1,0,0, - 0,2290,2299,1,0,0,0,2291,2292,5,263,0,0,2292,2295,3,304,152,0,2293, - 2294,5,9,0,0,2294,2296,3,328,164,0,2295,2293,1,0,0,0,2295,2296,1, - 0,0,0,2296,2298,1,0,0,0,2297,2291,1,0,0,0,2298,2301,1,0,0,0,2299, - 2300,1,0,0,0,2299,2297,1,0,0,0,2300,2302,1,0,0,0,2301,2299,1,0,0, - 0,2302,2303,5,266,0,0,2303,2512,1,0,0,0,2304,2305,5,168,0,0,2305, - 2306,5,265,0,0,2306,2311,3,304,152,0,2307,2308,5,263,0,0,2308,2310, - 3,304,152,0,2309,2307,1,0,0,0,2310,2313,1,0,0,0,2311,2309,1,0,0, - 0,2311,2312,1,0,0,0,2312,2314,1,0,0,0,2313,2311,1,0,0,0,2314,2315, - 5,266,0,0,2315,2512,1,0,0,0,2316,2317,3,190,95,0,2317,2318,5,265, - 0,0,2318,2319,5,257,0,0,2319,2321,5,266,0,0,2320,2322,3,338,169, - 0,2321,2320,1,0,0,0,2321,2322,1,0,0,0,2322,2324,1,0,0,0,2323,2325, - 3,340,170,0,2324,2323,1,0,0,0,2324,2325,1,0,0,0,2325,2512,1,0,0, - 0,2326,2327,3,190,95,0,2327,2339,5,265,0,0,2328,2330,3,276,138,0, - 2329,2328,1,0,0,0,2329,2330,1,0,0,0,2330,2331,1,0,0,0,2331,2336, - 3,304,152,0,2332,2333,5,263,0,0,2333,2335,3,304,152,0,2334,2332, - 1,0,0,0,2335,2338,1,0,0,0,2336,2334,1,0,0,0,2336,2337,1,0,0,0,2337, - 2340,1,0,0,0,2338,2336,1,0,0,0,2339,2329,1,0,0,0,2339,2340,1,0,0, - 0,2340,2351,1,0,0,0,2341,2342,5,139,0,0,2342,2343,5,26,0,0,2343, - 2348,3,264,132,0,2344,2345,5,263,0,0,2345,2347,3,264,132,0,2346, - 2344,1,0,0,0,2347,2350,1,0,0,0,2348,2346,1,0,0,0,2348,2349,1,0,0, - 0,2349,2352,1,0,0,0,2350,2348,1,0,0,0,2351,2341,1,0,0,0,2351,2352, - 1,0,0,0,2352,2353,1,0,0,0,2353,2355,5,266,0,0,2354,2356,3,338,169, - 0,2355,2354,1,0,0,0,2355,2356,1,0,0,0,2356,2358,1,0,0,0,2357,2359, - 3,340,170,0,2358,2357,1,0,0,0,2358,2359,1,0,0,0,2359,2512,1,0,0, - 0,2360,2361,3,358,179,0,2361,2362,5,273,0,0,2362,2363,3,304,152, - 0,2363,2512,1,0,0,0,2364,2373,5,265,0,0,2365,2370,3,358,179,0,2366, - 2367,5,263,0,0,2367,2369,3,358,179,0,2368,2366,1,0,0,0,2369,2372, - 1,0,0,0,2370,2368,1,0,0,0,2370,2371,1,0,0,0,2371,2374,1,0,0,0,2372, - 2370,1,0,0,0,2373,2365,1,0,0,0,2373,2374,1,0,0,0,2374,2375,1,0,0, - 0,2375,2376,5,266,0,0,2376,2377,5,273,0,0,2377,2512,3,304,152,0, - 2378,2379,5,265,0,0,2379,2380,3,204,102,0,2380,2381,5,266,0,0,2381, - 2512,1,0,0,0,2382,2383,5,66,0,0,2383,2384,5,265,0,0,2384,2385,3, - 204,102,0,2385,2386,5,266,0,0,2386,2512,1,0,0,0,2387,2388,5,28,0, - 0,2388,2390,3,310,155,0,2389,2391,3,336,168,0,2390,2389,1,0,0,0, - 2391,2392,1,0,0,0,2392,2390,1,0,0,0,2392,2393,1,0,0,0,2393,2396, - 1,0,0,0,2394,2395,5,59,0,0,2395,2397,3,304,152,0,2396,2394,1,0,0, - 0,2396,2397,1,0,0,0,2397,2398,1,0,0,0,2398,2399,5,61,0,0,2399,2512, - 1,0,0,0,2400,2402,5,28,0,0,2401,2403,3,336,168,0,2402,2401,1,0,0, - 0,2403,2404,1,0,0,0,2404,2402,1,0,0,0,2404,2405,1,0,0,0,2405,2408, - 1,0,0,0,2406,2407,5,59,0,0,2407,2409,3,304,152,0,2408,2406,1,0,0, - 0,2408,2409,1,0,0,0,2409,2410,1,0,0,0,2410,2411,5,61,0,0,2411,2512, - 1,0,0,0,2412,2413,5,29,0,0,2413,2414,5,265,0,0,2414,2415,3,304,152, - 0,2415,2416,5,9,0,0,2416,2417,3,328,164,0,2417,2418,5,266,0,0,2418, - 2512,1,0,0,0,2419,2420,5,195,0,0,2420,2421,5,265,0,0,2421,2422,3, - 304,152,0,2422,2423,5,9,0,0,2423,2424,3,328,164,0,2424,2425,5,266, - 0,0,2425,2512,1,0,0,0,2426,2427,5,8,0,0,2427,2436,5,267,0,0,2428, - 2433,3,304,152,0,2429,2430,5,263,0,0,2430,2432,3,304,152,0,2431, - 2429,1,0,0,0,2432,2435,1,0,0,0,2433,2431,1,0,0,0,2433,2434,1,0,0, - 0,2434,2437,1,0,0,0,2435,2433,1,0,0,0,2436,2428,1,0,0,0,2436,2437, - 1,0,0,0,2437,2438,1,0,0,0,2438,2512,5,268,0,0,2439,2512,3,358,179, - 0,2440,2512,5,40,0,0,2441,2445,5,42,0,0,2442,2443,5,265,0,0,2443, - 2444,5,277,0,0,2444,2446,5,266,0,0,2445,2442,1,0,0,0,2445,2446,1, - 0,0,0,2446,2512,1,0,0,0,2447,2451,5,43,0,0,2448,2449,5,265,0,0,2449, - 2450,5,277,0,0,2450,2452,5,266,0,0,2451,2448,1,0,0,0,2451,2452,1, - 0,0,0,2452,2512,1,0,0,0,2453,2457,5,119,0,0,2454,2455,5,265,0,0, - 2455,2456,5,277,0,0,2456,2458,5,266,0,0,2457,2454,1,0,0,0,2457,2458, - 1,0,0,0,2458,2512,1,0,0,0,2459,2463,5,120,0,0,2460,2461,5,265,0, - 0,2461,2462,5,277,0,0,2462,2464,5,266,0,0,2463,2460,1,0,0,0,2463, - 2464,1,0,0,0,2464,2512,1,0,0,0,2465,2512,5,44,0,0,2466,2512,5,41, - 0,0,2467,2468,5,184,0,0,2468,2469,5,265,0,0,2469,2470,3,310,155, - 0,2470,2471,5,82,0,0,2471,2474,3,310,155,0,2472,2473,5,78,0,0,2473, - 2475,3,310,155,0,2474,2472,1,0,0,0,2474,2475,1,0,0,0,2475,2476,1, - 0,0,0,2476,2477,5,266,0,0,2477,2512,1,0,0,0,2478,2479,5,131,0,0, - 2479,2480,5,265,0,0,2480,2483,3,310,155,0,2481,2482,5,263,0,0,2482, - 2484,3,326,163,0,2483,2481,1,0,0,0,2483,2484,1,0,0,0,2484,2485,1, - 0,0,0,2485,2486,5,266,0,0,2486,2512,1,0,0,0,2487,2488,5,68,0,0,2488, - 2489,5,265,0,0,2489,2490,3,358,179,0,2490,2491,5,82,0,0,2491,2492, - 3,310,155,0,2492,2493,5,266,0,0,2493,2512,1,0,0,0,2494,2495,5,265, - 0,0,2495,2496,3,304,152,0,2496,2497,5,266,0,0,2497,2512,1,0,0,0, - 2498,2499,5,88,0,0,2499,2508,5,265,0,0,2500,2505,3,354,177,0,2501, - 2502,5,263,0,0,2502,2504,3,354,177,0,2503,2501,1,0,0,0,2504,2507, - 1,0,0,0,2505,2503,1,0,0,0,2505,2506,1,0,0,0,2506,2509,1,0,0,0,2507, - 2505,1,0,0,0,2508,2500,1,0,0,0,2508,2509,1,0,0,0,2509,2510,1,0,0, - 0,2510,2512,5,266,0,0,2511,2265,1,0,0,0,2511,2267,1,0,0,0,2511,2268, - 1,0,0,0,2511,2271,1,0,0,0,2511,2273,1,0,0,0,2511,2274,1,0,0,0,2511, - 2275,1,0,0,0,2511,2276,1,0,0,0,2511,2277,1,0,0,0,2511,2278,1,0,0, - 0,2511,2285,1,0,0,0,2511,2304,1,0,0,0,2511,2316,1,0,0,0,2511,2326, - 1,0,0,0,2511,2360,1,0,0,0,2511,2364,1,0,0,0,2511,2378,1,0,0,0,2511, - 2382,1,0,0,0,2511,2387,1,0,0,0,2511,2400,1,0,0,0,2511,2412,1,0,0, - 0,2511,2419,1,0,0,0,2511,2426,1,0,0,0,2511,2439,1,0,0,0,2511,2440, - 1,0,0,0,2511,2441,1,0,0,0,2511,2447,1,0,0,0,2511,2453,1,0,0,0,2511, - 2459,1,0,0,0,2511,2465,1,0,0,0,2511,2466,1,0,0,0,2511,2467,1,0,0, - 0,2511,2478,1,0,0,0,2511,2487,1,0,0,0,2511,2494,1,0,0,0,2511,2498, - 1,0,0,0,2512,2523,1,0,0,0,2513,2514,10,15,0,0,2514,2515,5,267,0, - 0,2515,2516,3,310,155,0,2516,2517,5,268,0,0,2517,2522,1,0,0,0,2518, - 2519,10,13,0,0,2519,2520,5,261,0,0,2520,2522,3,358,179,0,2521,2513, - 1,0,0,0,2521,2518,1,0,0,0,2522,2525,1,0,0,0,2523,2521,1,0,0,0,2523, - 2524,1,0,0,0,2524,313,1,0,0,0,2525,2523,1,0,0,0,2526,2533,5,274, - 0,0,2527,2530,5,275,0,0,2528,2529,5,198,0,0,2529,2531,5,274,0,0, - 2530,2528,1,0,0,0,2530,2531,1,0,0,0,2531,2533,1,0,0,0,2532,2526, - 1,0,0,0,2532,2527,1,0,0,0,2533,315,1,0,0,0,2534,2535,7,23,0,0,2535, - 317,1,0,0,0,2536,2537,7,24,0,0,2537,319,1,0,0,0,2538,2539,7,25,0, - 0,2539,321,1,0,0,0,2540,2541,5,277,0,0,2541,2555,3,324,162,0,2542, - 2543,5,265,0,0,2543,2544,5,277,0,0,2544,2545,5,266,0,0,2545,2555, - 3,324,162,0,2546,2547,5,101,0,0,2547,2548,5,277,0,0,2548,2555,3, - 324,162,0,2549,2550,5,101,0,0,2550,2551,5,265,0,0,2551,2552,5,277, - 0,0,2552,2553,5,266,0,0,2553,2555,3,324,162,0,2554,2540,1,0,0,0, - 2554,2542,1,0,0,0,2554,2546,1,0,0,0,2554,2549,1,0,0,0,2555,323,1, - 0,0,0,2556,2557,7,26,0,0,2557,325,1,0,0,0,2558,2559,7,27,0,0,2559, - 327,1,0,0,0,2560,2561,6,164,-1,0,2561,2562,5,8,0,0,2562,2563,5,251, - 0,0,2563,2564,3,328,164,0,2564,2565,5,253,0,0,2565,2606,1,0,0,0, - 2566,2567,5,235,0,0,2567,2568,5,251,0,0,2568,2569,3,328,164,0,2569, - 2570,5,263,0,0,2570,2571,3,328,164,0,2571,2572,5,253,0,0,2572,2606, - 1,0,0,0,2573,2574,5,240,0,0,2574,2575,5,251,0,0,2575,2576,3,358, - 179,0,2576,2583,3,328,164,0,2577,2578,5,263,0,0,2578,2579,3,358, - 179,0,2579,2580,3,328,164,0,2580,2582,1,0,0,0,2581,2577,1,0,0,0, - 2582,2585,1,0,0,0,2583,2581,1,0,0,0,2583,2584,1,0,0,0,2584,2586, - 1,0,0,0,2585,2583,1,0,0,0,2586,2587,5,253,0,0,2587,2606,1,0,0,0, - 2588,2591,3,334,167,0,2589,2591,3,330,165,0,2590,2588,1,0,0,0,2590, - 2589,1,0,0,0,2591,2603,1,0,0,0,2592,2593,5,265,0,0,2593,2598,3,332, - 166,0,2594,2595,5,263,0,0,2595,2597,3,332,166,0,2596,2594,1,0,0, - 0,2597,2600,1,0,0,0,2598,2596,1,0,0,0,2598,2599,1,0,0,0,2599,2601, - 1,0,0,0,2600,2598,1,0,0,0,2601,2602,5,266,0,0,2602,2604,1,0,0,0, - 2603,2592,1,0,0,0,2603,2604,1,0,0,0,2604,2606,1,0,0,0,2605,2560, - 1,0,0,0,2605,2566,1,0,0,0,2605,2573,1,0,0,0,2605,2590,1,0,0,0,2606, - 2611,1,0,0,0,2607,2608,10,5,0,0,2608,2610,5,8,0,0,2609,2607,1,0, - 0,0,2610,2613,1,0,0,0,2611,2609,1,0,0,0,2611,2612,1,0,0,0,2612,329, - 1,0,0,0,2613,2611,1,0,0,0,2614,2615,7,28,0,0,2615,331,1,0,0,0,2616, - 2619,5,277,0,0,2617,2619,3,328,164,0,2618,2616,1,0,0,0,2618,2617, - 1,0,0,0,2619,333,1,0,0,0,2620,2625,5,284,0,0,2621,2625,5,285,0,0, - 2622,2625,5,286,0,0,2623,2625,3,358,179,0,2624,2620,1,0,0,0,2624, - 2621,1,0,0,0,2624,2622,1,0,0,0,2624,2623,1,0,0,0,2625,335,1,0,0, - 0,2626,2627,5,214,0,0,2627,2628,3,304,152,0,2628,2629,5,192,0,0, - 2629,2630,3,304,152,0,2630,337,1,0,0,0,2631,2632,5,74,0,0,2632,2633, - 5,265,0,0,2633,2634,5,215,0,0,2634,2635,3,306,153,0,2635,2636,5, - 266,0,0,2636,339,1,0,0,0,2637,2638,5,143,0,0,2638,2649,5,265,0,0, - 2639,2640,5,145,0,0,2640,2641,5,26,0,0,2641,2646,3,304,152,0,2642, - 2643,5,263,0,0,2643,2645,3,304,152,0,2644,2642,1,0,0,0,2645,2648, - 1,0,0,0,2646,2644,1,0,0,0,2646,2647,1,0,0,0,2647,2650,1,0,0,0,2648, - 2646,1,0,0,0,2649,2639,1,0,0,0,2649,2650,1,0,0,0,2650,2661,1,0,0, - 0,2651,2652,5,139,0,0,2652,2653,5,26,0,0,2653,2658,3,264,132,0,2654, - 2655,5,263,0,0,2655,2657,3,264,132,0,2656,2654,1,0,0,0,2657,2660, - 1,0,0,0,2658,2656,1,0,0,0,2658,2659,1,0,0,0,2659,2662,1,0,0,0,2660, - 2658,1,0,0,0,2661,2651,1,0,0,0,2661,2662,1,0,0,0,2662,2664,1,0,0, - 0,2663,2665,3,342,171,0,2664,2663,1,0,0,0,2664,2665,1,0,0,0,2665, - 2666,1,0,0,0,2666,2667,5,266,0,0,2667,341,1,0,0,0,2668,2669,5,154, - 0,0,2669,2685,3,344,172,0,2670,2671,5,169,0,0,2671,2685,3,344,172, - 0,2672,2673,5,154,0,0,2673,2674,5,15,0,0,2674,2675,3,344,172,0,2675, - 2676,5,5,0,0,2676,2677,3,344,172,0,2677,2685,1,0,0,0,2678,2679,5, - 169,0,0,2679,2680,5,15,0,0,2680,2681,3,344,172,0,2681,2682,5,5,0, - 0,2682,2683,3,344,172,0,2683,2685,1,0,0,0,2684,2668,1,0,0,0,2684, - 2670,1,0,0,0,2684,2672,1,0,0,0,2684,2678,1,0,0,0,2685,343,1,0,0, - 0,2686,2687,5,199,0,0,2687,2696,5,149,0,0,2688,2689,5,199,0,0,2689, - 2696,5,77,0,0,2690,2691,5,39,0,0,2691,2696,5,168,0,0,2692,2693,3, - 304,152,0,2693,2694,7,29,0,0,2694,2696,1,0,0,0,2695,2686,1,0,0,0, - 2695,2688,1,0,0,0,2695,2690,1,0,0,0,2695,2692,1,0,0,0,2696,345,1, - 0,0,0,2697,2698,3,358,179,0,2698,2699,5,261,0,0,2699,2700,3,358, - 179,0,2700,2703,1,0,0,0,2701,2703,3,358,179,0,2702,2697,1,0,0,0, - 2702,2701,1,0,0,0,2703,347,1,0,0,0,2704,2709,3,346,173,0,2705,2706, - 5,263,0,0,2706,2708,3,346,173,0,2707,2705,1,0,0,0,2708,2711,1,0, - 0,0,2709,2707,1,0,0,0,2709,2710,1,0,0,0,2710,349,1,0,0,0,2711,2709, - 1,0,0,0,2712,2726,5,2,0,0,2713,2726,5,4,0,0,2714,2726,5,58,0,0,2715, - 2726,5,37,0,0,2716,2726,5,99,0,0,2717,2726,5,162,0,0,2718,2723,5, - 174,0,0,2719,2720,5,265,0,0,2720,2721,3,358,179,0,2721,2722,5,266, - 0,0,2722,2724,1,0,0,0,2723,2719,1,0,0,0,2723,2724,1,0,0,0,2724,2726, - 1,0,0,0,2725,2712,1,0,0,0,2725,2713,1,0,0,0,2725,2714,1,0,0,0,2725, - 2715,1,0,0,0,2725,2716,1,0,0,0,2725,2717,1,0,0,0,2725,2718,1,0,0, - 0,2726,351,1,0,0,0,2727,2728,7,30,0,0,2728,353,1,0,0,0,2729,2734, - 3,358,179,0,2730,2731,5,261,0,0,2731,2733,3,358,179,0,2732,2730, - 1,0,0,0,2733,2736,1,0,0,0,2734,2732,1,0,0,0,2734,2735,1,0,0,0,2735, - 355,1,0,0,0,2736,2734,1,0,0,0,2737,2738,5,166,0,0,2738,2744,3,358, - 179,0,2739,2740,5,204,0,0,2740,2744,3,358,179,0,2741,2742,5,87,0, - 0,2742,2744,3,358,179,0,2743,2737,1,0,0,0,2743,2739,1,0,0,0,2743, - 2741,1,0,0,0,2744,357,1,0,0,0,2745,2751,5,280,0,0,2746,2751,5,274, - 0,0,2747,2751,3,364,182,0,2748,2751,5,283,0,0,2749,2751,5,281,0, - 0,2750,2745,1,0,0,0,2750,2746,1,0,0,0,2750,2747,1,0,0,0,2750,2748, - 1,0,0,0,2750,2749,1,0,0,0,2751,359,1,0,0,0,2752,2754,5,256,0,0,2753, - 2752,1,0,0,0,2753,2754,1,0,0,0,2754,2755,1,0,0,0,2755,2765,5,278, - 0,0,2756,2758,5,256,0,0,2757,2756,1,0,0,0,2757,2758,1,0,0,0,2758, - 2759,1,0,0,0,2759,2765,5,279,0,0,2760,2762,5,256,0,0,2761,2760,1, - 0,0,0,2761,2762,1,0,0,0,2762,2763,1,0,0,0,2763,2765,5,277,0,0,2764, - 2753,1,0,0,0,2764,2757,1,0,0,0,2764,2761,1,0,0,0,2765,361,1,0,0, - 0,2766,2767,7,31,0,0,2767,363,1,0,0,0,2768,2769,7,32,0,0,2769,365, - 1,0,0,0,352,369,376,400,413,417,421,430,435,439,445,447,452,456, - 460,467,472,478,482,491,498,502,507,509,514,518,525,529,534,538, - 542,546,554,559,563,571,575,584,587,590,596,603,614,619,624,629, - 634,643,646,649,653,679,705,714,724,727,741,759,761,770,781,790, - 797,801,808,814,817,822,829,843,856,861,866,872,908,911,917,920, - 926,932,944,946,957,965,970,974,979,986,990,994,1000,1004,1008,1017, - 1020,1023,1031,1045,1052,1065,1071,1076,1079,1082,1087,1091,1100, - 1105,1111,1115,1120,1125,1128,1136,1139,1143,1155,1158,1162,1167, - 1171,1187,1192,1199,1202,1208,1211,1218,1221,1225,1230,1233,1240, - 1243,1267,1281,1285,1289,1309,1311,1313,1322,1324,1333,1335,1344, - 1346,1351,1360,1369,1378,1389,1395,1400,1403,1416,1426,1430,1435, - 1446,1451,1484,1492,1497,1501,1505,1510,1514,1519,1524,1529,1533, - 1542,1545,1549,1556,1567,1573,1577,1583,1593,1600,1605,1610,1615, - 1621,1624,1633,1636,1639,1645,1651,1661,1664,1668,1672,1679,1682, - 1688,1694,1697,1700,1704,1714,1725,1730,1733,1737,1744,1754,1766, - 1772,1774,1783,1786,1793,1803,1809,1817,1828,1838,1849,1851,1857, - 1862,1872,1875,1881,1883,1891,1897,1900,1902,1914,1921,1925,1929, - 1933,1936,1943,1952,1955,1959,1964,1968,1971,1978,1989,1992,1996, - 2000,2009,2012,2019,2033,2037,2041,2045,2049,2053,2057,2061,2071, - 2082,2087,2100,2102,2108,2112,2114,2122,2129,2134,2147,2153,2161, - 2168,2172,2180,2182,2193,2201,2210,2216,2221,2227,2233,2238,2243, - 2249,2260,2262,2289,2295,2299,2311,2321,2324,2329,2336,2339,2348, - 2351,2355,2358,2370,2373,2392,2396,2404,2408,2433,2436,2445,2451, - 2457,2463,2474,2483,2505,2508,2511,2521,2523,2530,2532,2554,2583, - 2590,2598,2603,2605,2611,2618,2624,2646,2649,2658,2661,2664,2684, - 2695,2702,2709,2723,2725,2734,2743,2750,2753,2757,2761,2764 + 1,13,1,13,1,13,1,13,3,13,681,8,13,1,14,1,14,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,15,1,15,1,15,1,15,1,15, + 1,15,1,15,1,15,1,15,1,15,3,15,707,8,15,1,15,1,15,1,16,1,16,1,16, + 1,16,1,16,3,16,716,8,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16, + 3,16,726,8,16,1,16,3,16,729,8,16,1,17,1,17,1,17,1,17,1,17,1,17,1, + 17,1,18,1,18,1,18,1,18,1,18,3,18,743,8,18,1,18,1,18,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,3,20,761, + 8,20,3,20,763,8,20,1,20,1,20,1,20,1,20,1,20,5,20,770,8,20,10,20, + 12,20,773,9,20,1,20,1,20,1,21,1,21,1,21,1,21,1,21,1,21,3,21,783, + 8,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,3,22,792,8,22,1,22,1,22, + 1,22,1,22,1,22,3,22,799,8,22,1,22,1,22,3,22,803,8,22,1,23,1,23,1, + 23,1,23,1,23,3,23,810,8,23,1,23,1,23,1,23,1,23,3,23,816,8,23,1,23, + 3,23,819,8,23,1,23,1,23,1,23,3,23,824,8,23,1,24,1,24,1,24,1,24,1, + 24,3,24,831,8,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1, + 24,1,24,1,24,3,24,845,8,24,1,25,1,25,1,25,1,25,1,25,1,25,1,26,1, + 26,1,26,1,26,1,26,3,26,858,8,26,1,26,1,26,1,26,3,26,863,8,26,1,26, + 1,26,1,26,3,26,868,8,26,1,27,1,27,1,27,1,27,3,27,874,8,27,1,27,1, + 27,1,27,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,31,1,31,1, + 31,1,31,1,31,1,31,1,31,1,32,1,32,3,32,910,8,32,1,32,3,32,913,8,32, + 1,32,1,32,1,33,1,33,3,33,919,8,33,1,33,3,33,922,8,33,1,33,1,33,1, + 34,1,34,3,34,928,8,34,1,35,1,35,1,35,1,35,3,35,934,8,35,1,35,1,35, + 1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,35,3,35,946,8,35,3,35,948,8, + 35,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,3,36,959,8,36,1, + 37,1,37,1,37,1,37,1,37,1,37,3,37,967,8,37,1,38,1,38,1,38,3,38,972, + 8,38,1,38,1,38,3,38,976,8,38,1,39,1,39,1,39,3,39,981,8,39,1,39,1, + 39,1,40,1,40,1,40,3,40,988,8,40,1,40,1,40,3,40,992,8,40,1,41,1,41, + 3,41,996,8,41,1,41,1,41,1,41,1,41,3,41,1002,8,41,1,42,1,42,3,42, + 1006,8,42,1,42,1,42,3,42,1010,8,42,1,42,1,42,1,42,1,42,1,42,5,42, + 1017,8,42,10,42,12,42,1020,9,42,3,42,1022,8,42,1,42,3,42,1025,8, + 42,1,43,1,43,1,43,1,43,1,44,1,44,3,44,1033,8,44,1,45,1,45,1,45,1, + 45,1,45,1,45,1,45,1,46,1,46,1,46,1,46,1,46,3,46,1047,8,46,1,46,1, + 46,1,46,1,47,1,47,3,47,1054,8,47,1,48,1,48,1,48,1,48,1,48,1,48,1, + 48,1,49,1,49,1,49,1,49,3,49,1067,8,49,1,49,1,49,1,49,1,49,3,49,1073, + 8,49,1,49,1,49,1,49,3,49,1078,8,49,1,49,3,49,1081,8,49,1,50,3,50, + 1084,8,50,1,50,1,50,1,50,3,50,1089,8,50,1,50,1,50,3,50,1093,8,50, + 1,50,1,50,1,50,1,50,1,50,5,50,1100,8,50,10,50,12,50,1103,9,50,1, + 50,1,50,3,50,1107,8,50,1,50,1,50,1,51,1,51,3,51,1113,8,51,1,52,1, + 52,3,52,1117,8,52,1,52,1,52,1,52,3,52,1122,8,52,1,53,1,53,1,53,3, + 53,1127,8,53,1,53,3,53,1130,8,53,1,53,1,53,1,53,1,53,5,53,1136,8, + 53,10,53,12,53,1139,9,53,3,53,1141,8,53,1,53,1,53,3,53,1145,8,53, + 1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,5,54,1155,8,54,10,54,12, + 54,1158,9,54,3,54,1160,8,54,1,54,1,54,3,54,1164,8,54,1,55,1,55,1, + 55,3,55,1169,8,55,1,55,1,55,3,55,1173,8,55,1,55,1,55,1,56,1,56,1, + 56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,3,56,1189,8,56,1, + 57,1,57,1,57,3,57,1194,8,57,1,57,1,57,1,57,5,57,1199,8,57,10,57, + 12,57,1202,9,57,3,57,1204,8,57,1,58,1,58,1,58,1,58,3,58,1210,8,58, + 1,58,3,58,1213,8,58,1,58,1,58,1,58,5,58,1218,8,58,10,58,12,58,1221, + 9,58,3,58,1223,8,58,1,59,1,59,3,59,1227,8,59,1,59,1,59,1,59,3,59, + 1232,8,59,1,59,3,59,1235,8,59,1,59,1,59,1,59,5,59,1240,8,59,10,59, + 12,59,1243,9,59,3,59,1245,8,59,1,60,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,64,1,64,3,64,1269,8,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,3,65,1283,8,65,1,65,1,65,3,65,1287,8,65,1,66, + 1,66,3,66,1291,8,66,1,66,1,66,1,67,1,67,1,67,1,67,1,67,1,67,1,68, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68,1311,8,68,3,68, + 1313,8,68,3,68,1315,8,68,1,69,1,69,1,69,1,69,1,69,1,69,1,69,3,69, + 1324,8,69,3,69,1326,8,69,1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70, + 1335,8,70,3,70,1337,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71, + 1346,8,71,3,71,1348,8,71,1,72,1,72,1,72,3,72,1353,8,72,1,73,1,73, + 1,73,1,73,1,73,1,73,1,73,3,73,1362,8,73,1,74,1,74,1,74,1,74,1,74, + 1,74,1,74,3,74,1371,8,74,1,75,1,75,1,75,1,75,1,75,1,75,1,75,3,75, + 1380,8,75,1,76,1,76,1,76,1,77,1,77,1,77,1,77,1,77,1,77,3,77,1391, + 8,77,1,78,1,78,1,78,1,78,3,78,1397,8,78,1,78,1,78,1,78,3,78,1402, + 8,78,1,78,3,78,1405,8,78,1,78,1,78,1,79,1,79,1,79,1,79,1,80,1,80, + 1,80,1,80,1,80,3,80,1418,8,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80, + 1,80,3,80,1428,8,80,1,80,1,80,3,80,1432,8,80,1,81,1,81,1,81,3,81, + 1437,8,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,5,82,1446,8,82,10,82, + 12,82,1449,9,82,1,82,1,82,3,82,1453,8,82,1,83,1,83,1,83,1,84,1,84, + 1,84,1,84,1,85,1,85,1,85,1,86,1,86,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,93,5,93,1484, + 8,93,10,93,12,93,1487,9,93,1,94,1,94,1,94,5,94,1492,8,94,10,94,12, + 94,1495,9,94,1,95,1,95,3,95,1499,8,95,1,96,1,96,3,96,1503,8,96,1, + 97,1,97,3,97,1507,8,97,1,98,1,98,1,98,3,98,1512,8,98,1,98,3,98,1515, + 8,98,1,98,1,98,1,98,3,98,1520,8,98,1,98,1,98,1,98,3,98,1525,8,98, + 1,98,1,98,1,98,3,98,1530,8,98,1,98,1,98,3,98,1534,8,98,1,98,1,98, + 1,98,1,98,1,98,1,98,1,98,3,98,1543,8,98,1,98,3,98,1546,8,98,1,98, + 1,98,3,98,1550,8,98,1,99,1,99,1,99,5,99,1555,8,99,10,99,12,99,1558, + 9,99,1,100,1,100,1,100,1,100,1,101,1,101,3,101,1566,8,101,1,101, + 1,101,3,101,1570,8,101,5,101,1572,8,101,10,101,12,101,1575,9,101, + 1,101,1,101,1,102,1,102,3,102,1581,8,102,1,103,3,103,1584,8,103, + 1,103,1,103,1,104,1,104,1,104,1,104,5,104,1592,8,104,10,104,12,104, + 1595,9,104,1,105,1,105,1,105,1,105,3,105,1601,8,105,1,105,1,105, + 1,105,3,105,1606,8,105,1,105,1,105,1,105,3,105,1611,8,105,1,105, + 1,105,1,105,3,105,1616,8,105,1,105,1,105,5,105,1620,8,105,10,105, + 12,105,1623,9,105,3,105,1625,8,105,1,106,1,106,1,106,1,106,1,106, + 1,106,1,106,3,106,1634,8,106,1,106,3,106,1637,8,106,1,106,3,106, + 1640,8,106,1,107,1,107,1,107,1,107,3,107,1646,8,107,1,108,1,108, + 1,108,3,108,1651,8,108,1,109,1,109,1,110,1,110,1,110,1,110,5,110, + 1659,8,110,10,110,12,110,1662,9,110,3,110,1664,8,110,1,110,3,110, + 1667,8,110,1,110,1,110,3,110,1671,8,110,1,111,1,111,1,111,1,112, + 1,112,1,112,5,112,1679,8,112,10,112,12,112,1682,9,112,3,112,1684, + 8,112,1,113,1,113,1,113,1,113,3,113,1690,8,113,1,113,1,113,5,113, + 1694,8,113,10,113,12,113,1697,9,113,3,113,1699,8,113,1,114,3,114, + 1702,8,114,1,114,1,114,3,114,1706,8,114,1,115,1,115,1,115,1,115, + 1,115,1,115,1,115,1,115,3,115,1716,8,115,1,116,1,116,1,117,1,117, + 1,118,1,118,1,118,5,118,1725,8,118,10,118,12,118,1728,9,118,1,118, + 1,118,3,118,1732,8,118,1,118,3,118,1735,8,118,1,119,1,119,3,119, + 1739,8,119,1,119,1,119,1,119,1,120,1,120,3,120,1746,8,120,1,120, + 1,120,1,120,1,120,1,120,1,120,5,120,1754,8,120,10,120,12,120,1757, + 9,120,1,120,1,120,1,121,1,121,1,121,1,121,1,121,1,121,1,121,3,121, + 1768,8,121,1,121,1,121,1,121,1,121,3,121,1774,8,121,3,121,1776,8, + 121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,1785,8,122,1, + 122,3,122,1788,8,122,1,123,1,123,1,123,1,123,1,123,3,123,1795,8, + 123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,1805,8, + 124,1,125,1,125,1,125,1,125,3,125,1811,8,125,1,126,1,126,1,126,1, + 126,5,126,1817,8,126,10,126,12,126,1820,9,126,1,126,1,126,1,127, + 1,127,1,127,1,127,5,127,1828,8,127,10,127,12,127,1831,9,127,1,127, + 1,127,1,128,1,128,1,128,5,128,1838,8,128,10,128,12,128,1841,9,128, + 1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,3,129,1851,8,129, + 3,129,1853,8,129,1,129,1,129,1,129,1,129,3,129,1859,8,129,1,130, + 1,130,1,130,3,130,1864,8,130,1,131,1,131,1,131,1,131,1,131,1,131, + 5,131,1872,8,131,10,131,12,131,1875,9,131,3,131,1877,8,131,1,131, + 1,131,1,131,1,131,3,131,1883,8,131,3,131,1885,8,131,1,132,1,132, + 1,132,1,132,1,132,1,132,3,132,1893,8,132,1,132,1,132,1,132,1,132, + 3,132,1899,8,132,1,132,5,132,1902,8,132,10,132,12,132,1905,9,132, + 1,133,1,133,1,133,1,133,1,133,1,133,1,133,5,133,1914,8,133,10,133, + 12,133,1917,9,133,1,133,1,133,1,133,1,133,3,133,1923,8,133,1,134, + 1,134,3,134,1927,8,134,1,134,1,134,3,134,1931,8,134,1,135,1,135, + 3,135,1935,8,135,1,135,3,135,1938,8,135,1,135,1,135,1,135,5,135, + 1943,8,135,10,135,12,135,1946,9,135,1,135,1,135,1,135,1,135,5,135, + 1952,8,135,10,135,12,135,1955,9,135,3,135,1957,8,135,1,135,1,135, + 3,135,1961,8,135,1,135,1,135,1,135,3,135,1966,8,135,1,135,1,135, + 3,135,1970,8,135,1,136,3,136,1973,8,136,1,136,1,136,1,136,5,136, + 1978,8,136,10,136,12,136,1981,9,136,1,137,1,137,1,138,1,138,1,138, + 1,138,5,138,1989,8,138,10,138,12,138,1992,9,138,3,138,1994,8,138, + 1,138,1,138,3,138,1998,8,138,1,139,1,139,3,139,2002,8,139,1,139, + 1,139,1,139,1,140,1,140,1,141,1,141,3,141,2011,8,141,1,141,3,141, + 2014,8,141,1,141,1,141,1,141,1,141,1,141,3,141,2021,8,141,1,142, + 1,142,1,142,1,142,1,142,1,142,1,142,1,142,1,142,1,142,1,142,1,142, + 3,142,2035,8,142,5,142,2037,8,142,10,142,12,142,2040,9,142,1,143, + 3,143,2043,8,143,1,143,1,143,3,143,2047,8,143,1,143,1,143,3,143, + 2051,8,143,1,143,1,143,3,143,2055,8,143,1,143,1,143,3,143,2059,8, + 143,1,143,1,143,3,143,2063,8,143,1,143,1,143,1,143,1,143,1,143,1, + 143,1,143,1,143,3,143,2073,8,143,1,144,1,144,1,144,1,144,1,144,1, + 144,1,144,5,144,2082,8,144,10,144,12,144,2085,9,144,1,144,1,144, + 3,144,2089,8,144,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145, + 1,145,1,145,1,145,3,145,2102,8,145,3,145,2104,8,145,1,146,1,146, + 1,147,1,147,3,147,2110,8,147,1,147,1,147,3,147,2114,8,147,3,147, + 2116,8,147,1,148,1,148,1,148,1,148,5,148,2122,8,148,10,148,12,148, + 2125,9,148,1,148,1,148,1,149,1,149,3,149,2131,8,149,1,149,1,149, + 1,149,3,149,2136,8,149,1,150,1,150,1,150,1,150,1,151,1,151,1,151, + 1,151,1,151,5,151,2147,8,151,10,151,12,151,2150,9,151,1,151,1,151, + 1,151,3,151,2155,8,151,1,152,1,152,1,152,1,152,1,153,1,153,3,153, + 2163,8,153,1,154,1,154,1,155,1,155,1,155,3,155,2170,8,155,1,155, + 1,155,3,155,2174,8,155,1,155,1,155,1,155,1,155,1,155,1,155,5,155, + 2182,8,155,10,155,12,155,2185,9,155,1,156,1,156,1,156,1,156,1,156, + 1,156,1,156,1,156,3,156,2195,8,156,1,156,1,156,1,156,1,156,1,156, + 1,156,3,156,2203,8,156,1,156,1,156,1,156,1,156,1,156,5,156,2210, + 8,156,10,156,12,156,2213,9,156,1,156,1,156,1,156,3,156,2218,8,156, + 1,156,1,156,1,156,3,156,2223,8,156,1,156,1,156,1,156,1,156,3,156, + 2229,8,156,1,156,1,156,1,156,1,156,3,156,2235,8,156,1,156,1,156, + 1,156,3,156,2240,8,156,1,156,1,156,1,156,3,156,2245,8,156,1,157, + 1,157,1,157,1,157,3,157,2251,8,157,1,157,1,157,1,157,1,157,1,157, + 1,157,1,157,1,157,1,157,5,157,2262,8,157,10,157,12,157,2265,9,157, + 1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158, + 1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158, + 1,158,1,158,3,158,2291,8,158,1,158,1,158,1,158,1,158,3,158,2297, + 8,158,5,158,2299,8,158,10,158,12,158,2302,9,158,1,158,1,158,1,158, + 1,158,1,158,1,158,1,158,5,158,2311,8,158,10,158,12,158,2314,9,158, + 1,158,1,158,1,158,1,158,1,158,1,158,1,158,3,158,2323,8,158,1,158, + 3,158,2326,8,158,1,158,1,158,1,158,3,158,2331,8,158,1,158,1,158, + 1,158,5,158,2336,8,158,10,158,12,158,2339,9,158,3,158,2341,8,158, + 1,158,1,158,1,158,1,158,1,158,5,158,2348,8,158,10,158,12,158,2351, + 9,158,3,158,2353,8,158,1,158,1,158,3,158,2357,8,158,1,158,3,158, + 2360,8,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,5,158, + 2370,8,158,10,158,12,158,2373,9,158,3,158,2375,8,158,1,158,1,158, + 1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158, + 1,158,1,158,4,158,2392,8,158,11,158,12,158,2393,1,158,1,158,3,158, + 2398,8,158,1,158,1,158,1,158,1,158,4,158,2404,8,158,11,158,12,158, + 2405,1,158,1,158,3,158,2410,8,158,1,158,1,158,1,158,1,158,1,158, + 1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158, + 1,158,1,158,1,158,1,158,1,158,5,158,2433,8,158,10,158,12,158,2436, + 9,158,3,158,2438,8,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158, + 3,158,2447,8,158,1,158,1,158,1,158,1,158,3,158,2453,8,158,1,158, + 1,158,1,158,1,158,3,158,2459,8,158,1,158,1,158,1,158,1,158,3,158, + 2465,8,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158, + 3,158,2476,8,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,3,158, + 2485,8,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158, + 1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,5,158,2505, + 8,158,10,158,12,158,2508,9,158,3,158,2510,8,158,1,158,3,158,2513, + 8,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,5,158,2523, + 8,158,10,158,12,158,2526,9,158,1,159,1,159,1,159,1,159,3,159,2532, + 8,159,3,159,2534,8,159,1,160,1,160,1,161,1,161,1,162,1,162,1,163, + 1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, + 1,163,1,163,3,163,2556,8,163,1,164,1,164,1,165,1,165,1,166,1,166, + 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, + 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,5,166,2583,8,166, + 10,166,12,166,2586,9,166,1,166,1,166,1,166,1,166,3,166,2592,8,166, + 1,166,1,166,1,166,1,166,5,166,2598,8,166,10,166,12,166,2601,9,166, + 1,166,1,166,3,166,2605,8,166,3,166,2607,8,166,1,166,1,166,5,166, + 2611,8,166,10,166,12,166,2614,9,166,1,167,1,167,1,168,1,168,3,168, + 2620,8,168,1,169,1,169,1,169,1,169,3,169,2626,8,169,1,170,1,170, + 1,170,1,170,1,170,1,171,1,171,1,171,1,171,1,171,1,171,1,172,1,172, + 1,172,1,172,1,172,1,172,1,172,5,172,2646,8,172,10,172,12,172,2649, + 9,172,3,172,2651,8,172,1,172,1,172,1,172,1,172,1,172,5,172,2658, + 8,172,10,172,12,172,2661,9,172,3,172,2663,8,172,1,172,3,172,2666, + 8,172,1,172,1,172,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173, + 1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,3,173,2686,8,173, + 1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,3,174,2697, + 8,174,1,175,1,175,1,175,1,175,1,175,3,175,2704,8,175,1,176,1,176, + 1,176,5,176,2709,8,176,10,176,12,176,2712,9,176,1,177,1,177,1,177, + 1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,3,177,2725,8,177, + 3,177,2727,8,177,1,178,1,178,1,179,1,179,1,179,5,179,2734,8,179, + 10,179,12,179,2737,9,179,1,180,1,180,1,180,1,180,1,180,1,180,3,180, + 2745,8,180,1,181,1,181,1,181,1,181,1,181,3,181,2752,8,181,1,182, + 3,182,2755,8,182,1,182,1,182,3,182,2759,8,182,1,182,1,182,3,182, + 2763,8,182,1,182,3,182,2766,8,182,1,183,1,183,1,184,1,184,1,184, + 10,771,1447,1621,1660,1680,1695,1726,1755,1829,2300,6,264,284,310, + 314,316,332,185,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,0,33,2,0, + 46,46,170,170,2,0,166,166,204,204,2,0,176,176,202,202,2,0,69,69, + 80,80,2,0,27,27,159,159,2,0,103,103,144,144,2,0,47,47,171,171,2, + 0,3,3,12,12,3,0,87,87,166,166,204,204,2,0,178,178,209,209,1,0,245, + 248,2,0,147,147,219,223,2,0,65,65,95,95,2,0,64,64,200,200,2,0,10, + 10,55,55,2,0,75,75,112,112,2,0,2,2,57,57,2,0,14,14,185,185,3,0,106, + 106,115,115,164,164,2,0,105,105,163,163,4,0,70,70,133,133,194,194, + 208,208,1,0,255,256,1,0,257,259,1,0,249,254,3,0,2,2,6,6,181,181, + 2,0,70,70,194,194,5,0,48,49,91,92,122,125,172,173,217,218,1,0,127, + 130,2,0,8,8,227,244,2,0,77,77,149,149,4,0,46,46,178,178,188,188, + 209,209,16,0,28,29,40,40,43,43,48,48,68,68,91,91,114,114,122,122, + 124,124,158,158,165,165,172,172,184,184,196,196,204,204,217,217, + 23,0,14,14,43,44,48,49,65,65,68,68,91,91,95,95,110,110,119,119,122, + 125,127,130,137,137,140,140,152,153,172,173,180,180,184,185,195, + 195,204,204,213,213,217,217,220,220,231,231,3093,0,373,1,0,0,0,2, + 378,1,0,0,0,4,404,1,0,0,0,6,406,1,0,0,0,8,417,1,0,0,0,10,419,1,0, + 0,0,12,458,1,0,0,0,14,480,1,0,0,0,16,534,1,0,0,0,18,553,1,0,0,0, + 20,566,1,0,0,0,22,570,1,0,0,0,24,632,1,0,0,0,26,680,1,0,0,0,28,682, + 1,0,0,0,30,690,1,0,0,0,32,710,1,0,0,0,34,730,1,0,0,0,36,737,1,0, + 0,0,38,746,1,0,0,0,40,754,1,0,0,0,42,776,1,0,0,0,44,786,1,0,0,0, + 46,804,1,0,0,0,48,825,1,0,0,0,50,846,1,0,0,0,52,852,1,0,0,0,54,869, + 1,0,0,0,56,878,1,0,0,0,58,885,1,0,0,0,60,893,1,0,0,0,62,900,1,0, + 0,0,64,907,1,0,0,0,66,916,1,0,0,0,68,927,1,0,0,0,70,929,1,0,0,0, + 72,949,1,0,0,0,74,966,1,0,0,0,76,968,1,0,0,0,78,977,1,0,0,0,80,984, + 1,0,0,0,82,993,1,0,0,0,84,1003,1,0,0,0,86,1026,1,0,0,0,88,1032,1, + 0,0,0,90,1034,1,0,0,0,92,1041,1,0,0,0,94,1053,1,0,0,0,96,1055,1, + 0,0,0,98,1062,1,0,0,0,100,1083,1,0,0,0,102,1112,1,0,0,0,104,1114, + 1,0,0,0,106,1123,1,0,0,0,108,1146,1,0,0,0,110,1165,1,0,0,0,112,1188, + 1,0,0,0,114,1190,1,0,0,0,116,1205,1,0,0,0,118,1224,1,0,0,0,120,1246, + 1,0,0,0,122,1251,1,0,0,0,124,1256,1,0,0,0,126,1261,1,0,0,0,128,1266, + 1,0,0,0,130,1273,1,0,0,0,132,1288,1,0,0,0,134,1294,1,0,0,0,136,1314, + 1,0,0,0,138,1316,1,0,0,0,140,1327,1,0,0,0,142,1338,1,0,0,0,144,1352, + 1,0,0,0,146,1354,1,0,0,0,148,1363,1,0,0,0,150,1372,1,0,0,0,152,1381, + 1,0,0,0,154,1384,1,0,0,0,156,1392,1,0,0,0,158,1408,1,0,0,0,160,1412, + 1,0,0,0,162,1436,1,0,0,0,164,1438,1,0,0,0,166,1454,1,0,0,0,168,1457, + 1,0,0,0,170,1461,1,0,0,0,172,1464,1,0,0,0,174,1468,1,0,0,0,176,1470, + 1,0,0,0,178,1472,1,0,0,0,180,1474,1,0,0,0,182,1476,1,0,0,0,184,1478, + 1,0,0,0,186,1480,1,0,0,0,188,1488,1,0,0,0,190,1498,1,0,0,0,192,1502, + 1,0,0,0,194,1506,1,0,0,0,196,1511,1,0,0,0,198,1551,1,0,0,0,200,1559, + 1,0,0,0,202,1563,1,0,0,0,204,1578,1,0,0,0,206,1583,1,0,0,0,208,1587, + 1,0,0,0,210,1596,1,0,0,0,212,1626,1,0,0,0,214,1641,1,0,0,0,216,1647, + 1,0,0,0,218,1652,1,0,0,0,220,1654,1,0,0,0,222,1672,1,0,0,0,224,1675, + 1,0,0,0,226,1685,1,0,0,0,228,1705,1,0,0,0,230,1715,1,0,0,0,232,1717, + 1,0,0,0,234,1719,1,0,0,0,236,1734,1,0,0,0,238,1736,1,0,0,0,240,1743, + 1,0,0,0,242,1775,1,0,0,0,244,1787,1,0,0,0,246,1794,1,0,0,0,248,1804, + 1,0,0,0,250,1806,1,0,0,0,252,1812,1,0,0,0,254,1823,1,0,0,0,256,1834, + 1,0,0,0,258,1842,1,0,0,0,260,1860,1,0,0,0,262,1865,1,0,0,0,264,1886, + 1,0,0,0,266,1922,1,0,0,0,268,1924,1,0,0,0,270,1932,1,0,0,0,272,1972, + 1,0,0,0,274,1982,1,0,0,0,276,1997,1,0,0,0,278,1999,1,0,0,0,280,2006, + 1,0,0,0,282,2020,1,0,0,0,284,2022,1,0,0,0,286,2072,1,0,0,0,288,2088, + 1,0,0,0,290,2090,1,0,0,0,292,2105,1,0,0,0,294,2107,1,0,0,0,296,2117, + 1,0,0,0,298,2135,1,0,0,0,300,2137,1,0,0,0,302,2141,1,0,0,0,304,2156, + 1,0,0,0,306,2162,1,0,0,0,308,2164,1,0,0,0,310,2173,1,0,0,0,312,2244, + 1,0,0,0,314,2250,1,0,0,0,316,2512,1,0,0,0,318,2533,1,0,0,0,320,2535, + 1,0,0,0,322,2537,1,0,0,0,324,2539,1,0,0,0,326,2555,1,0,0,0,328,2557, + 1,0,0,0,330,2559,1,0,0,0,332,2606,1,0,0,0,334,2615,1,0,0,0,336,2619, + 1,0,0,0,338,2625,1,0,0,0,340,2627,1,0,0,0,342,2632,1,0,0,0,344,2638, + 1,0,0,0,346,2685,1,0,0,0,348,2696,1,0,0,0,350,2703,1,0,0,0,352,2705, + 1,0,0,0,354,2726,1,0,0,0,356,2728,1,0,0,0,358,2730,1,0,0,0,360,2744, + 1,0,0,0,362,2751,1,0,0,0,364,2765,1,0,0,0,366,2767,1,0,0,0,368,2769, + 1,0,0,0,370,372,3,2,1,0,371,370,1,0,0,0,372,375,1,0,0,0,373,371, + 1,0,0,0,373,374,1,0,0,0,374,376,1,0,0,0,375,373,1,0,0,0,376,377, + 5,0,0,1,377,1,1,0,0,0,378,380,3,4,2,0,379,381,5,262,0,0,380,379, + 1,0,0,0,380,381,1,0,0,0,381,3,1,0,0,0,382,405,3,206,103,0,383,405, + 3,6,3,0,384,405,3,8,4,0,385,405,3,26,13,0,386,405,3,64,32,0,387, + 405,3,66,33,0,388,405,3,68,34,0,389,405,3,74,37,0,390,405,3,88,44, + 0,391,405,3,94,47,0,392,405,3,100,50,0,393,405,3,102,51,0,394,405, + 3,108,54,0,395,405,3,110,55,0,396,405,3,112,56,0,397,405,3,144,72, + 0,398,405,3,152,76,0,399,405,3,154,77,0,400,405,3,156,78,0,401,405, + 3,158,79,0,402,405,3,160,80,0,403,405,3,162,81,0,404,382,1,0,0,0, + 404,383,1,0,0,0,404,384,1,0,0,0,404,385,1,0,0,0,404,386,1,0,0,0, + 404,387,1,0,0,0,404,388,1,0,0,0,404,389,1,0,0,0,404,390,1,0,0,0, + 404,391,1,0,0,0,404,392,1,0,0,0,404,393,1,0,0,0,404,394,1,0,0,0, + 404,395,1,0,0,0,404,396,1,0,0,0,404,397,1,0,0,0,404,398,1,0,0,0, + 404,399,1,0,0,0,404,400,1,0,0,0,404,401,1,0,0,0,404,402,1,0,0,0, + 404,403,1,0,0,0,405,5,1,0,0,0,406,407,5,203,0,0,407,408,3,184,92, + 0,408,7,1,0,0,0,409,418,3,18,9,0,410,418,3,20,10,0,411,418,3,22, + 11,0,412,418,3,24,12,0,413,418,3,16,8,0,414,418,3,14,7,0,415,418, + 3,12,6,0,416,418,3,10,5,0,417,409,1,0,0,0,417,410,1,0,0,0,417,411, + 1,0,0,0,417,412,1,0,0,0,417,413,1,0,0,0,417,414,1,0,0,0,417,415, + 1,0,0,0,417,416,1,0,0,0,418,9,1,0,0,0,419,421,5,37,0,0,420,422,5, + 19,0,0,421,420,1,0,0,0,421,422,1,0,0,0,422,423,1,0,0,0,423,425,5, + 188,0,0,424,426,3,172,86,0,425,424,1,0,0,0,425,426,1,0,0,0,426,427, + 1,0,0,0,427,443,3,174,87,0,428,429,5,265,0,0,429,434,3,216,108,0, + 430,431,5,263,0,0,431,433,3,216,108,0,432,430,1,0,0,0,433,436,1, + 0,0,0,434,432,1,0,0,0,434,435,1,0,0,0,435,439,1,0,0,0,436,434,1, + 0,0,0,437,438,5,263,0,0,438,440,3,210,105,0,439,437,1,0,0,0,439, + 440,1,0,0,0,440,441,1,0,0,0,441,442,5,266,0,0,442,444,1,0,0,0,443, + 428,1,0,0,0,443,444,1,0,0,0,444,451,1,0,0,0,445,446,5,17,0,0,446, + 449,5,26,0,0,447,450,3,296,148,0,448,450,3,254,127,0,449,447,1,0, + 0,0,449,448,1,0,0,0,450,452,1,0,0,0,451,445,1,0,0,0,451,452,1,0, + 0,0,452,453,1,0,0,0,453,456,3,196,98,0,454,455,5,9,0,0,455,457,3, + 206,103,0,456,454,1,0,0,0,456,457,1,0,0,0,457,11,1,0,0,0,458,460, + 5,37,0,0,459,461,5,19,0,0,460,459,1,0,0,0,460,461,1,0,0,0,461,462, + 1,0,0,0,462,464,5,188,0,0,463,465,3,172,86,0,464,463,1,0,0,0,464, + 465,1,0,0,0,465,466,1,0,0,0,466,467,3,174,87,0,467,471,5,115,0,0, + 468,472,3,186,93,0,469,470,5,147,0,0,470,472,3,318,159,0,471,468, + 1,0,0,0,471,469,1,0,0,0,472,476,1,0,0,0,473,474,5,17,0,0,474,475, + 5,26,0,0,475,477,3,254,127,0,476,473,1,0,0,0,476,477,1,0,0,0,477, + 478,1,0,0,0,478,479,3,196,98,0,479,13,1,0,0,0,480,482,5,37,0,0,481, + 483,5,19,0,0,482,481,1,0,0,0,482,483,1,0,0,0,483,484,1,0,0,0,484, + 486,5,188,0,0,485,487,3,172,86,0,486,485,1,0,0,0,486,487,1,0,0,0, + 487,488,1,0,0,0,488,506,3,174,87,0,489,490,5,265,0,0,490,495,3,218, + 109,0,491,492,5,263,0,0,492,494,3,218,109,0,493,491,1,0,0,0,494, + 497,1,0,0,0,495,493,1,0,0,0,495,496,1,0,0,0,496,502,1,0,0,0,497, + 495,1,0,0,0,498,499,5,263,0,0,499,500,5,150,0,0,500,501,5,110,0, + 0,501,503,3,296,148,0,502,498,1,0,0,0,502,503,1,0,0,0,503,504,1, + 0,0,0,504,505,5,266,0,0,505,507,1,0,0,0,506,489,1,0,0,0,506,507, + 1,0,0,0,507,513,1,0,0,0,508,509,5,150,0,0,509,511,5,110,0,0,510, + 512,3,296,148,0,511,510,1,0,0,0,511,512,1,0,0,0,512,514,1,0,0,0, + 513,508,1,0,0,0,513,514,1,0,0,0,514,518,1,0,0,0,515,516,5,145,0, + 0,516,517,5,26,0,0,517,519,3,236,118,0,518,515,1,0,0,0,518,519,1, + 0,0,0,519,521,1,0,0,0,520,522,3,222,111,0,521,520,1,0,0,0,521,522, + 1,0,0,0,522,523,1,0,0,0,523,524,5,23,0,0,524,525,5,9,0,0,525,528, + 5,111,0,0,526,527,5,25,0,0,527,529,3,252,126,0,528,526,1,0,0,0,528, + 529,1,0,0,0,529,532,1,0,0,0,530,531,5,9,0,0,531,533,3,206,103,0, + 532,530,1,0,0,0,532,533,1,0,0,0,533,15,1,0,0,0,534,535,5,37,0,0, + 535,537,5,212,0,0,536,538,3,172,86,0,537,536,1,0,0,0,537,538,1,0, + 0,0,538,539,1,0,0,0,539,541,3,178,89,0,540,542,3,202,101,0,541,540, + 1,0,0,0,541,542,1,0,0,0,542,544,1,0,0,0,543,545,3,222,111,0,544, + 543,1,0,0,0,544,545,1,0,0,0,545,548,1,0,0,0,546,547,5,25,0,0,547, + 549,3,252,126,0,548,546,1,0,0,0,548,549,1,0,0,0,549,550,1,0,0,0, + 550,551,5,9,0,0,551,552,3,206,103,0,552,17,1,0,0,0,553,554,5,37, + 0,0,554,556,7,0,0,0,555,557,3,172,86,0,556,555,1,0,0,0,556,557,1, + 0,0,0,557,558,1,0,0,0,558,560,3,176,88,0,559,561,3,222,111,0,560, + 559,1,0,0,0,560,561,1,0,0,0,561,564,1,0,0,0,562,563,5,24,0,0,563, + 565,3,318,159,0,564,562,1,0,0,0,564,565,1,0,0,0,565,19,1,0,0,0,566, + 567,5,37,0,0,567,568,5,166,0,0,568,569,3,362,181,0,569,21,1,0,0, + 0,570,572,5,37,0,0,571,573,5,12,0,0,572,571,1,0,0,0,572,573,1,0, + 0,0,573,574,1,0,0,0,574,576,5,84,0,0,575,577,3,172,86,0,576,575, + 1,0,0,0,576,577,1,0,0,0,577,578,1,0,0,0,578,591,3,180,90,0,579,588, + 5,265,0,0,580,585,3,332,166,0,581,582,5,263,0,0,582,584,3,332,166, + 0,583,581,1,0,0,0,584,587,1,0,0,0,585,583,1,0,0,0,585,586,1,0,0, + 0,586,589,1,0,0,0,587,585,1,0,0,0,588,580,1,0,0,0,588,589,1,0,0, + 0,589,590,1,0,0,0,590,592,5,266,0,0,591,579,1,0,0,0,591,592,1,0, + 0,0,592,593,1,0,0,0,593,594,5,160,0,0,594,597,3,332,166,0,595,596, + 5,102,0,0,596,598,3,332,166,0,597,595,1,0,0,0,597,598,1,0,0,0,598, + 599,1,0,0,0,599,600,5,24,0,0,600,604,5,274,0,0,601,602,5,104,0,0, + 602,603,5,249,0,0,603,605,5,274,0,0,604,601,1,0,0,0,604,605,1,0, + 0,0,605,606,1,0,0,0,606,607,5,206,0,0,607,608,5,249,0,0,608,609, + 5,274,0,0,609,610,5,126,0,0,610,611,5,249,0,0,611,615,5,274,0,0, + 612,613,5,18,0,0,613,614,5,249,0,0,614,616,5,274,0,0,615,612,1,0, + 0,0,615,616,1,0,0,0,616,620,1,0,0,0,617,618,5,20,0,0,618,619,5,249, + 0,0,619,621,5,274,0,0,620,617,1,0,0,0,620,621,1,0,0,0,621,625,1, + 0,0,0,622,623,5,187,0,0,623,624,5,249,0,0,624,626,5,274,0,0,625, + 622,1,0,0,0,625,626,1,0,0,0,626,630,1,0,0,0,627,628,5,76,0,0,628, + 629,5,249,0,0,629,631,5,274,0,0,630,627,1,0,0,0,630,631,1,0,0,0, + 631,23,1,0,0,0,632,633,5,37,0,0,633,635,5,84,0,0,634,636,3,172,86, + 0,635,634,1,0,0,0,635,636,1,0,0,0,636,637,1,0,0,0,637,650,3,180, + 90,0,638,647,5,265,0,0,639,644,3,332,166,0,640,641,5,263,0,0,641, + 643,3,332,166,0,642,640,1,0,0,0,643,646,1,0,0,0,644,642,1,0,0,0, + 644,645,1,0,0,0,645,648,1,0,0,0,646,644,1,0,0,0,647,639,1,0,0,0, + 647,648,1,0,0,0,648,649,1,0,0,0,649,651,5,266,0,0,650,638,1,0,0, + 0,650,651,1,0,0,0,651,654,1,0,0,0,652,653,5,160,0,0,653,655,3,332, + 166,0,654,652,1,0,0,0,654,655,1,0,0,0,655,656,1,0,0,0,656,657,5, + 24,0,0,657,658,5,274,0,0,658,659,5,186,0,0,659,660,5,249,0,0,660, + 661,3,318,159,0,661,25,1,0,0,0,662,681,3,28,14,0,663,681,3,62,31, + 0,664,681,3,60,30,0,665,681,3,58,29,0,666,681,3,54,27,0,667,681, + 3,56,28,0,668,681,3,52,26,0,669,681,3,48,24,0,670,681,3,50,25,0, + 671,681,3,46,23,0,672,681,3,44,22,0,673,681,3,42,21,0,674,681,3, + 40,20,0,675,681,3,34,17,0,676,681,3,30,15,0,677,681,3,32,16,0,678, + 681,3,36,18,0,679,681,3,38,19,0,680,662,1,0,0,0,680,663,1,0,0,0, + 680,664,1,0,0,0,680,665,1,0,0,0,680,666,1,0,0,0,680,667,1,0,0,0, + 680,668,1,0,0,0,680,669,1,0,0,0,680,670,1,0,0,0,680,671,1,0,0,0, + 680,672,1,0,0,0,680,673,1,0,0,0,680,674,1,0,0,0,680,675,1,0,0,0, + 680,676,1,0,0,0,680,677,1,0,0,0,680,678,1,0,0,0,680,679,1,0,0,0, + 681,27,1,0,0,0,682,683,5,4,0,0,683,684,5,46,0,0,684,685,3,184,92, + 0,685,686,5,176,0,0,686,687,5,142,0,0,687,688,7,1,0,0,688,689,3, + 362,181,0,689,29,1,0,0,0,690,691,5,4,0,0,691,692,5,188,0,0,692,693, + 3,186,93,0,693,694,5,176,0,0,694,695,5,32,0,0,695,696,5,182,0,0, + 696,697,3,192,96,0,697,698,5,265,0,0,698,699,3,232,116,0,699,700, + 5,249,0,0,700,706,3,318,159,0,701,702,5,263,0,0,702,703,3,232,116, + 0,703,704,5,249,0,0,704,705,3,318,159,0,705,707,1,0,0,0,706,701, + 1,0,0,0,706,707,1,0,0,0,707,708,1,0,0,0,708,709,5,266,0,0,709,31, + 1,0,0,0,710,711,5,4,0,0,711,712,5,188,0,0,712,715,3,186,93,0,713, + 714,5,145,0,0,714,716,3,308,154,0,715,713,1,0,0,0,715,716,1,0,0, + 0,716,717,1,0,0,0,717,728,5,176,0,0,718,719,5,30,0,0,719,720,5,94, + 0,0,720,725,3,318,159,0,721,722,5,216,0,0,722,723,5,151,0,0,723, + 724,5,249,0,0,724,726,3,364,182,0,725,721,1,0,0,0,725,726,1,0,0, + 0,726,729,1,0,0,0,727,729,5,197,0,0,728,718,1,0,0,0,728,727,1,0, + 0,0,729,33,1,0,0,0,730,731,5,4,0,0,731,732,5,188,0,0,732,733,3,186, + 93,0,733,734,5,31,0,0,734,735,3,192,96,0,735,736,3,224,112,0,736, + 35,1,0,0,0,737,738,5,4,0,0,738,739,5,188,0,0,739,740,3,186,93,0, + 740,742,5,58,0,0,741,743,5,32,0,0,742,741,1,0,0,0,742,743,1,0,0, + 0,743,744,1,0,0,0,744,745,3,192,96,0,745,37,1,0,0,0,746,747,5,4, + 0,0,747,748,5,188,0,0,748,749,3,186,93,0,749,750,5,176,0,0,750,751, + 5,142,0,0,751,752,7,1,0,0,752,753,3,362,181,0,753,39,1,0,0,0,754, + 755,5,4,0,0,755,756,5,188,0,0,756,762,3,186,93,0,757,763,5,158,0, + 0,758,760,5,1,0,0,759,761,3,172,86,0,760,759,1,0,0,0,760,761,1,0, + 0,0,761,763,1,0,0,0,762,757,1,0,0,0,762,758,1,0,0,0,763,764,1,0, + 0,0,764,765,5,33,0,0,765,766,5,265,0,0,766,771,3,224,112,0,767,768, + 5,263,0,0,768,770,3,224,112,0,769,767,1,0,0,0,770,773,1,0,0,0,771, + 772,1,0,0,0,771,769,1,0,0,0,772,774,1,0,0,0,773,771,1,0,0,0,774, + 775,5,266,0,0,775,41,1,0,0,0,776,777,5,4,0,0,777,778,5,188,0,0,778, + 779,3,186,93,0,779,780,5,1,0,0,780,782,5,32,0,0,781,783,3,172,86, + 0,782,781,1,0,0,0,782,783,1,0,0,0,783,784,1,0,0,0,784,785,3,226, + 113,0,785,43,1,0,0,0,786,787,5,4,0,0,787,788,5,188,0,0,788,789,3, + 186,93,0,789,791,5,4,0,0,790,792,5,32,0,0,791,790,1,0,0,0,791,792, + 1,0,0,0,792,793,1,0,0,0,793,802,3,192,96,0,794,798,5,176,0,0,795, + 799,3,230,115,0,796,797,5,34,0,0,797,799,3,318,159,0,798,795,1,0, + 0,0,798,796,1,0,0,0,799,803,1,0,0,0,800,801,5,58,0,0,801,803,5,51, + 0,0,802,794,1,0,0,0,802,800,1,0,0,0,803,45,1,0,0,0,804,805,5,4,0, + 0,805,806,5,188,0,0,806,807,3,186,93,0,807,809,5,1,0,0,808,810,3, + 172,86,0,809,808,1,0,0,0,809,810,1,0,0,0,810,823,1,0,0,0,811,812, + 5,145,0,0,812,815,3,308,154,0,813,814,5,24,0,0,814,816,3,318,159, + 0,815,813,1,0,0,0,815,816,1,0,0,0,816,818,1,0,0,0,817,819,3,244, + 122,0,818,817,1,0,0,0,818,819,1,0,0,0,819,824,1,0,0,0,820,821,5, + 154,0,0,821,822,5,145,0,0,822,824,3,242,121,0,823,811,1,0,0,0,823, + 820,1,0,0,0,824,47,1,0,0,0,825,826,5,4,0,0,826,827,5,188,0,0,827, + 830,3,186,93,0,828,829,5,145,0,0,829,831,3,308,154,0,830,828,1,0, + 0,0,830,831,1,0,0,0,831,832,1,0,0,0,832,844,5,176,0,0,833,834,5, + 72,0,0,834,845,3,234,117,0,835,836,5,168,0,0,836,837,5,79,0,0,837, + 845,3,258,129,0,838,839,5,24,0,0,839,845,3,318,159,0,840,841,5,25, + 0,0,841,845,3,252,126,0,842,843,5,175,0,0,843,845,3,252,126,0,844, + 833,1,0,0,0,844,835,1,0,0,0,844,838,1,0,0,0,844,840,1,0,0,0,844, + 842,1,0,0,0,845,49,1,0,0,0,846,847,5,4,0,0,847,848,5,188,0,0,848, + 849,3,186,93,0,849,850,5,155,0,0,850,851,5,146,0,0,851,51,1,0,0, + 0,852,853,5,4,0,0,853,854,5,188,0,0,854,855,3,186,93,0,855,857,5, + 58,0,0,856,858,3,170,85,0,857,856,1,0,0,0,857,858,1,0,0,0,858,867, + 1,0,0,0,859,860,5,145,0,0,860,862,3,308,154,0,861,863,5,22,0,0,862, + 861,1,0,0,0,862,863,1,0,0,0,863,868,1,0,0,0,864,865,5,154,0,0,865, + 866,5,145,0,0,866,868,3,242,121,0,867,859,1,0,0,0,867,864,1,0,0, + 0,868,53,1,0,0,0,869,870,5,4,0,0,870,871,5,212,0,0,871,873,3,188, + 94,0,872,874,3,202,101,0,873,872,1,0,0,0,873,874,1,0,0,0,874,875, + 1,0,0,0,875,876,5,9,0,0,876,877,3,206,103,0,877,55,1,0,0,0,878,879, + 5,4,0,0,879,880,5,212,0,0,880,881,3,188,94,0,881,882,5,156,0,0,882, + 883,5,193,0,0,883,884,3,188,94,0,884,57,1,0,0,0,885,886,5,4,0,0, + 886,887,5,212,0,0,887,888,3,188,94,0,888,889,5,176,0,0,889,890,5, + 142,0,0,890,891,7,1,0,0,891,892,3,358,179,0,892,59,1,0,0,0,893,894, + 5,4,0,0,894,895,5,188,0,0,895,896,3,186,93,0,896,897,5,156,0,0,897, + 898,5,193,0,0,898,899,3,186,93,0,899,61,1,0,0,0,900,901,5,4,0,0, + 901,902,5,212,0,0,902,903,3,188,94,0,903,904,7,2,0,0,904,905,5,25, + 0,0,905,906,3,252,126,0,906,63,1,0,0,0,907,909,5,196,0,0,908,910, + 5,188,0,0,909,908,1,0,0,0,909,910,1,0,0,0,910,912,1,0,0,0,911,913, + 3,170,85,0,912,911,1,0,0,0,912,913,1,0,0,0,913,914,1,0,0,0,914,915, + 3,186,93,0,915,65,1,0,0,0,916,918,5,56,0,0,917,919,5,46,0,0,918, + 917,1,0,0,0,918,919,1,0,0,0,919,921,1,0,0,0,920,922,7,3,0,0,921, + 920,1,0,0,0,921,922,1,0,0,0,922,923,1,0,0,0,923,924,3,358,179,0, + 924,67,1,0,0,0,925,928,3,70,35,0,926,928,3,72,36,0,927,925,1,0,0, + 0,927,926,1,0,0,0,928,69,1,0,0,0,929,930,5,36,0,0,930,931,5,182, + 0,0,931,933,3,186,93,0,932,934,3,296,148,0,933,932,1,0,0,0,933,934, + 1,0,0,0,934,947,1,0,0,0,935,936,5,190,0,0,936,937,5,185,0,0,937, + 938,5,265,0,0,938,939,3,364,182,0,939,945,5,266,0,0,940,941,5,157, + 0,0,941,942,5,265,0,0,942,943,3,364,182,0,943,944,5,266,0,0,944, + 946,1,0,0,0,945,940,1,0,0,0,945,946,1,0,0,0,946,948,1,0,0,0,947, + 935,1,0,0,0,947,948,1,0,0,0,948,71,1,0,0,0,949,950,5,36,0,0,950, + 951,5,96,0,0,951,952,5,182,0,0,952,958,3,186,93,0,953,954,5,145, + 0,0,954,955,5,265,0,0,955,956,3,308,154,0,956,957,5,266,0,0,957, + 959,1,0,0,0,958,953,1,0,0,0,958,959,1,0,0,0,959,73,1,0,0,0,960,967, + 3,86,43,0,961,967,3,84,42,0,962,967,3,82,41,0,963,967,3,78,39,0, + 964,967,3,80,40,0,965,967,3,76,38,0,966,960,1,0,0,0,966,961,1,0, + 0,0,966,962,1,0,0,0,966,963,1,0,0,0,966,964,1,0,0,0,966,965,1,0, + 0,0,967,75,1,0,0,0,968,969,5,58,0,0,969,971,7,0,0,0,970,972,3,170, + 85,0,971,970,1,0,0,0,971,972,1,0,0,0,972,973,1,0,0,0,973,975,3,184, + 92,0,974,976,7,4,0,0,975,974,1,0,0,0,975,976,1,0,0,0,976,77,1,0, + 0,0,977,978,5,58,0,0,978,980,5,212,0,0,979,981,3,170,85,0,980,979, + 1,0,0,0,980,981,1,0,0,0,981,982,1,0,0,0,982,983,3,188,94,0,983,79, + 1,0,0,0,984,985,5,58,0,0,985,987,5,188,0,0,986,988,3,170,85,0,987, + 986,1,0,0,0,987,988,1,0,0,0,988,989,1,0,0,0,989,991,3,186,93,0,990, + 992,5,22,0,0,991,990,1,0,0,0,991,992,1,0,0,0,992,81,1,0,0,0,993, + 995,5,58,0,0,994,996,5,96,0,0,995,994,1,0,0,0,995,996,1,0,0,0,996, + 997,1,0,0,0,997,998,5,182,0,0,998,1001,3,186,93,0,999,1000,5,145, + 0,0,1000,1002,3,308,154,0,1001,999,1,0,0,0,1001,1002,1,0,0,0,1002, + 83,1,0,0,0,1003,1005,5,58,0,0,1004,1006,5,12,0,0,1005,1004,1,0,0, + 0,1005,1006,1,0,0,0,1006,1007,1,0,0,0,1007,1009,5,84,0,0,1008,1010, + 3,170,85,0,1009,1008,1,0,0,0,1009,1010,1,0,0,0,1010,1011,1,0,0,0, + 1011,1024,3,190,95,0,1012,1021,5,265,0,0,1013,1018,3,332,166,0,1014, + 1015,5,263,0,0,1015,1017,3,332,166,0,1016,1014,1,0,0,0,1017,1020, + 1,0,0,0,1018,1016,1,0,0,0,1018,1019,1,0,0,0,1019,1022,1,0,0,0,1020, + 1018,1,0,0,0,1021,1013,1,0,0,0,1021,1022,1,0,0,0,1022,1023,1,0,0, + 0,1023,1025,5,266,0,0,1024,1012,1,0,0,0,1024,1025,1,0,0,0,1025,85, + 1,0,0,0,1026,1027,5,58,0,0,1027,1028,5,166,0,0,1028,1029,3,362,181, + 0,1029,87,1,0,0,0,1030,1033,3,90,45,0,1031,1033,3,92,46,0,1032,1030, + 1,0,0,0,1032,1031,1,0,0,0,1033,89,1,0,0,0,1034,1035,5,86,0,0,1035, + 1036,5,166,0,0,1036,1037,3,362,181,0,1037,1038,5,193,0,0,1038,1039, + 5,87,0,0,1039,1040,3,362,181,0,1040,91,1,0,0,0,1041,1042,5,86,0, + 0,1042,1043,3,354,177,0,1043,1044,5,136,0,0,1044,1046,3,356,178, + 0,1045,1047,3,358,179,0,1046,1045,1,0,0,0,1046,1047,1,0,0,0,1047, + 1048,1,0,0,0,1048,1049,5,193,0,0,1049,1050,3,360,180,0,1050,93,1, + 0,0,0,1051,1054,3,96,48,0,1052,1054,3,98,49,0,1053,1051,1,0,0,0, + 1053,1052,1,0,0,0,1054,95,1,0,0,0,1055,1056,5,161,0,0,1056,1057, + 5,166,0,0,1057,1058,3,362,181,0,1058,1059,5,82,0,0,1059,1060,5,87, + 0,0,1060,1061,3,362,181,0,1061,97,1,0,0,0,1062,1066,5,161,0,0,1063, + 1064,5,86,0,0,1064,1065,5,137,0,0,1065,1067,5,78,0,0,1066,1063,1, + 0,0,0,1066,1067,1,0,0,0,1067,1068,1,0,0,0,1068,1069,3,354,177,0, + 1069,1070,5,136,0,0,1070,1072,3,356,178,0,1071,1073,3,358,179,0, + 1072,1071,1,0,0,0,1072,1073,1,0,0,0,1073,1074,1,0,0,0,1074,1080, + 5,82,0,0,1075,1081,3,360,180,0,1076,1078,5,166,0,0,1077,1076,1,0, + 0,0,1077,1078,1,0,0,0,1078,1079,1,0,0,0,1079,1081,3,362,181,0,1080, + 1075,1,0,0,0,1080,1077,1,0,0,0,1081,99,1,0,0,0,1082,1084,3,208,104, + 0,1083,1082,1,0,0,0,1083,1084,1,0,0,0,1084,1085,1,0,0,0,1085,1086, + 5,99,0,0,1086,1088,7,5,0,0,1087,1089,5,188,0,0,1088,1087,1,0,0,0, + 1088,1089,1,0,0,0,1089,1090,1,0,0,0,1090,1092,3,186,93,0,1091,1093, + 3,296,148,0,1092,1091,1,0,0,0,1092,1093,1,0,0,0,1093,1106,1,0,0, + 0,1094,1095,5,145,0,0,1095,1096,5,265,0,0,1096,1101,3,308,154,0, + 1097,1098,5,263,0,0,1098,1100,3,308,154,0,1099,1097,1,0,0,0,1100, + 1103,1,0,0,0,1101,1099,1,0,0,0,1101,1102,1,0,0,0,1102,1104,1,0,0, + 0,1103,1101,1,0,0,0,1104,1105,5,266,0,0,1105,1107,1,0,0,0,1106,1094, + 1,0,0,0,1106,1107,1,0,0,0,1107,1108,1,0,0,0,1108,1109,3,206,103, + 0,1109,101,1,0,0,0,1110,1113,3,104,52,0,1111,1113,3,106,53,0,1112, + 1110,1,0,0,0,1112,1111,1,0,0,0,1113,103,1,0,0,0,1114,1116,5,50,0, + 0,1115,1117,5,82,0,0,1116,1115,1,0,0,0,1116,1117,1,0,0,0,1117,1118, + 1,0,0,0,1118,1121,3,186,93,0,1119,1120,5,215,0,0,1120,1122,3,310, + 155,0,1121,1119,1,0,0,0,1121,1122,1,0,0,0,1122,105,1,0,0,0,1123, + 1124,5,50,0,0,1124,1129,3,186,93,0,1125,1127,5,9,0,0,1126,1125,1, + 0,0,0,1126,1127,1,0,0,0,1127,1128,1,0,0,0,1128,1130,3,362,181,0, + 1129,1126,1,0,0,0,1129,1130,1,0,0,0,1130,1131,1,0,0,0,1131,1140, + 5,82,0,0,1132,1137,3,284,142,0,1133,1134,5,263,0,0,1134,1136,3,284, + 142,0,1135,1133,1,0,0,0,1136,1139,1,0,0,0,1137,1135,1,0,0,0,1137, + 1138,1,0,0,0,1138,1141,1,0,0,0,1139,1137,1,0,0,0,1140,1132,1,0,0, + 0,1140,1141,1,0,0,0,1141,1144,1,0,0,0,1142,1143,5,215,0,0,1143,1145, + 3,310,155,0,1144,1142,1,0,0,0,1144,1145,1,0,0,0,1145,107,1,0,0,0, + 1146,1147,5,54,0,0,1147,1148,3,186,93,0,1148,1149,5,176,0,0,1149, + 1159,3,198,99,0,1150,1151,5,82,0,0,1151,1156,3,284,142,0,1152,1153, + 5,263,0,0,1153,1155,3,284,142,0,1154,1152,1,0,0,0,1155,1158,1,0, + 0,0,1156,1154,1,0,0,0,1156,1157,1,0,0,0,1157,1160,1,0,0,0,1158,1156, + 1,0,0,0,1159,1150,1,0,0,0,1159,1160,1,0,0,0,1160,1163,1,0,0,0,1161, + 1162,5,215,0,0,1162,1164,3,310,155,0,1163,1161,1,0,0,0,1163,1164, + 1,0,0,0,1164,109,1,0,0,0,1165,1166,5,207,0,0,1166,1168,5,103,0,0, + 1167,1169,5,188,0,0,1168,1167,1,0,0,0,1168,1169,1,0,0,0,1169,1170, + 1,0,0,0,1170,1172,3,186,93,0,1171,1173,3,296,148,0,1172,1171,1,0, + 0,0,1172,1173,1,0,0,0,1173,1174,1,0,0,0,1174,1175,3,206,103,0,1175, + 111,1,0,0,0,1176,1189,3,132,66,0,1177,1189,3,134,67,0,1178,1189, + 3,136,68,0,1179,1189,3,130,65,0,1180,1189,3,128,64,0,1181,1189,3, + 126,63,0,1182,1189,3,124,62,0,1183,1189,3,122,61,0,1184,1189,3,120, + 60,0,1185,1189,3,118,59,0,1186,1189,3,116,58,0,1187,1189,3,114,57, + 0,1188,1176,1,0,0,0,1188,1177,1,0,0,0,1188,1178,1,0,0,0,1188,1179, + 1,0,0,0,1188,1180,1,0,0,0,1188,1181,1,0,0,0,1188,1182,1,0,0,0,1188, + 1183,1,0,0,0,1188,1184,1,0,0,0,1188,1185,1,0,0,0,1188,1186,1,0,0, + 0,1188,1187,1,0,0,0,1189,113,1,0,0,0,1190,1191,5,179,0,0,1191,1203, + 7,6,0,0,1192,1194,5,115,0,0,1193,1192,1,0,0,0,1193,1194,1,0,0,0, + 1194,1195,1,0,0,0,1195,1200,3,318,159,0,1196,1197,5,271,0,0,1197, + 1199,3,318,159,0,1198,1196,1,0,0,0,1199,1202,1,0,0,0,1200,1198,1, + 0,0,0,1200,1201,1,0,0,0,1201,1204,1,0,0,0,1202,1200,1,0,0,0,1203, + 1193,1,0,0,0,1203,1204,1,0,0,0,1204,115,1,0,0,0,1205,1206,5,179, + 0,0,1206,1209,5,189,0,0,1207,1208,5,94,0,0,1208,1210,3,186,93,0, + 1209,1207,1,0,0,0,1209,1210,1,0,0,0,1210,1222,1,0,0,0,1211,1213, + 5,115,0,0,1212,1211,1,0,0,0,1212,1213,1,0,0,0,1213,1214,1,0,0,0, + 1214,1219,3,318,159,0,1215,1216,5,271,0,0,1216,1218,3,318,159,0, + 1217,1215,1,0,0,0,1218,1221,1,0,0,0,1219,1217,1,0,0,0,1219,1220, + 1,0,0,0,1220,1223,1,0,0,0,1221,1219,1,0,0,0,1222,1212,1,0,0,0,1222, + 1223,1,0,0,0,1223,117,1,0,0,0,1224,1226,5,179,0,0,1225,1227,7,7, + 0,0,1226,1225,1,0,0,0,1226,1227,1,0,0,0,1227,1228,1,0,0,0,1228,1231, + 5,85,0,0,1229,1230,5,94,0,0,1230,1232,3,184,92,0,1231,1229,1,0,0, + 0,1231,1232,1,0,0,0,1232,1244,1,0,0,0,1233,1235,5,115,0,0,1234,1233, + 1,0,0,0,1234,1235,1,0,0,0,1235,1236,1,0,0,0,1236,1241,3,318,159, + 0,1237,1238,5,271,0,0,1238,1240,3,318,159,0,1239,1237,1,0,0,0,1240, + 1243,1,0,0,0,1241,1239,1,0,0,0,1241,1242,1,0,0,0,1242,1245,1,0,0, + 0,1243,1241,1,0,0,0,1244,1234,1,0,0,0,1244,1245,1,0,0,0,1245,119, + 1,0,0,0,1246,1247,5,179,0,0,1247,1248,5,37,0,0,1248,1249,5,188,0, + 0,1249,1250,3,186,93,0,1250,121,1,0,0,0,1251,1252,5,179,0,0,1252, + 1253,5,37,0,0,1253,1254,5,212,0,0,1254,1255,3,188,94,0,1255,123, + 1,0,0,0,1256,1257,5,179,0,0,1257,1258,5,188,0,0,1258,1259,5,182, + 0,0,1259,1260,3,186,93,0,1260,125,1,0,0,0,1261,1262,5,179,0,0,1262, + 1263,5,32,0,0,1263,1264,5,182,0,0,1264,1265,3,186,93,0,1265,127, + 1,0,0,0,1266,1268,5,179,0,0,1267,1269,5,154,0,0,1268,1267,1,0,0, + 0,1268,1269,1,0,0,0,1269,1270,1,0,0,0,1270,1271,5,146,0,0,1271,1272, + 3,186,93,0,1272,129,1,0,0,0,1273,1274,5,179,0,0,1274,1275,5,73,0, + 0,1275,1276,5,94,0,0,1276,1286,3,186,93,0,1277,1278,5,145,0,0,1278, + 1279,5,265,0,0,1279,1282,3,308,154,0,1280,1281,5,263,0,0,1281,1283, + 3,308,154,0,1282,1280,1,0,0,0,1282,1283,1,0,0,0,1283,1284,1,0,0, + 0,1284,1285,5,266,0,0,1285,1287,1,0,0,0,1286,1277,1,0,0,0,1286,1287, + 1,0,0,0,1287,131,1,0,0,0,1288,1290,5,179,0,0,1289,1291,5,39,0,0, + 1290,1289,1,0,0,0,1290,1291,1,0,0,0,1291,1292,1,0,0,0,1292,1293, + 5,167,0,0,1293,133,1,0,0,0,1294,1295,5,179,0,0,1295,1296,5,166,0, + 0,1296,1297,5,86,0,0,1297,1298,5,87,0,0,1298,1299,3,362,181,0,1299, + 135,1,0,0,0,1300,1315,3,138,69,0,1301,1315,3,140,70,0,1302,1315, + 3,142,71,0,1303,1304,5,179,0,0,1304,1305,5,86,0,0,1305,1306,7,8, + 0,0,1306,1312,3,362,181,0,1307,1308,5,136,0,0,1308,1310,7,9,0,0, + 1309,1311,3,358,179,0,1310,1309,1,0,0,0,1310,1311,1,0,0,0,1311,1313, + 1,0,0,0,1312,1307,1,0,0,0,1312,1313,1,0,0,0,1313,1315,1,0,0,0,1314, + 1300,1,0,0,0,1314,1301,1,0,0,0,1314,1302,1,0,0,0,1314,1303,1,0,0, + 0,1315,137,1,0,0,0,1316,1317,5,179,0,0,1317,1318,5,86,0,0,1318,1319, + 7,8,0,0,1319,1325,3,362,181,0,1320,1321,5,136,0,0,1321,1323,5,46, + 0,0,1322,1324,3,184,92,0,1323,1322,1,0,0,0,1323,1324,1,0,0,0,1324, + 1326,1,0,0,0,1325,1320,1,0,0,0,1325,1326,1,0,0,0,1326,139,1,0,0, + 0,1327,1328,5,179,0,0,1328,1329,5,86,0,0,1329,1330,7,8,0,0,1330, + 1336,3,362,181,0,1331,1332,5,136,0,0,1332,1334,5,188,0,0,1333,1335, + 3,186,93,0,1334,1333,1,0,0,0,1334,1335,1,0,0,0,1335,1337,1,0,0,0, + 1336,1331,1,0,0,0,1336,1337,1,0,0,0,1337,141,1,0,0,0,1338,1339,5, + 179,0,0,1339,1340,5,86,0,0,1340,1341,7,8,0,0,1341,1347,3,362,181, + 0,1342,1343,5,136,0,0,1343,1345,5,32,0,0,1344,1346,3,192,96,0,1345, + 1344,1,0,0,0,1345,1346,1,0,0,0,1346,1348,1,0,0,0,1347,1342,1,0,0, + 0,1347,1348,1,0,0,0,1348,143,1,0,0,0,1349,1353,3,146,73,0,1350,1353, + 3,148,74,0,1351,1353,3,150,75,0,1352,1349,1,0,0,0,1352,1350,1,0, + 0,0,1352,1351,1,0,0,0,1353,145,1,0,0,0,1354,1355,5,34,0,0,1355,1356, + 5,136,0,0,1356,1357,5,46,0,0,1357,1358,3,184,92,0,1358,1361,5,108, + 0,0,1359,1362,3,318,159,0,1360,1362,5,133,0,0,1361,1359,1,0,0,0, + 1361,1360,1,0,0,0,1362,147,1,0,0,0,1363,1364,5,34,0,0,1364,1365, + 5,136,0,0,1365,1366,5,188,0,0,1366,1367,3,186,93,0,1367,1370,5,108, + 0,0,1368,1371,3,318,159,0,1369,1371,5,133,0,0,1370,1368,1,0,0,0, + 1370,1369,1,0,0,0,1371,149,1,0,0,0,1372,1373,5,34,0,0,1373,1374, + 5,136,0,0,1374,1375,5,32,0,0,1375,1376,3,192,96,0,1376,1379,5,108, + 0,0,1377,1380,3,318,159,0,1378,1380,5,133,0,0,1379,1377,1,0,0,0, + 1379,1378,1,0,0,0,1380,151,1,0,0,0,1381,1382,5,67,0,0,1382,1383, + 3,4,2,0,1383,153,1,0,0,0,1384,1390,5,176,0,0,1385,1391,5,2,0,0,1386, + 1387,3,362,181,0,1387,1388,5,249,0,0,1388,1389,3,308,154,0,1389, + 1391,1,0,0,0,1390,1385,1,0,0,0,1390,1386,1,0,0,0,1390,1391,1,0,0, + 0,1391,155,1,0,0,0,1392,1393,5,264,0,0,1393,1394,5,180,0,0,1394, + 1404,5,265,0,0,1395,1397,3,318,159,0,1396,1395,1,0,0,0,1396,1397, + 1,0,0,0,1397,1405,1,0,0,0,1398,1401,3,318,159,0,1399,1400,5,263, + 0,0,1400,1402,3,308,154,0,1401,1399,1,0,0,0,1401,1402,1,0,0,0,1402, + 1405,1,0,0,0,1403,1405,3,308,154,0,1404,1396,1,0,0,0,1404,1398,1, + 0,0,0,1404,1403,1,0,0,0,1405,1406,1,0,0,0,1406,1407,5,266,0,0,1407, + 157,1,0,0,0,1408,1409,5,107,0,0,1409,1410,5,121,0,0,1410,1411,3, + 186,93,0,1411,159,1,0,0,0,1412,1413,5,118,0,0,1413,1414,5,45,0,0, + 1414,1415,5,98,0,0,1415,1417,5,274,0,0,1416,1418,5,144,0,0,1417, + 1416,1,0,0,0,1417,1418,1,0,0,0,1418,1419,1,0,0,0,1419,1420,5,103, + 0,0,1420,1421,5,188,0,0,1421,1431,3,186,93,0,1422,1423,5,145,0,0, + 1423,1424,5,265,0,0,1424,1427,3,308,154,0,1425,1426,5,263,0,0,1426, + 1428,3,308,154,0,1427,1425,1,0,0,0,1427,1428,1,0,0,0,1428,1429,1, + 0,0,0,1429,1430,5,266,0,0,1430,1432,1,0,0,0,1431,1422,1,0,0,0,1431, + 1432,1,0,0,0,1432,161,1,0,0,0,1433,1437,3,164,82,0,1434,1437,3,166, + 83,0,1435,1437,3,168,84,0,1436,1433,1,0,0,0,1436,1434,1,0,0,0,1436, + 1435,1,0,0,0,1437,163,1,0,0,0,1438,1439,5,162,0,0,1439,1452,3,186, + 93,0,1440,1441,5,145,0,0,1441,1442,5,265,0,0,1442,1447,3,308,154, + 0,1443,1444,5,263,0,0,1444,1446,3,308,154,0,1445,1443,1,0,0,0,1446, + 1449,1,0,0,0,1447,1448,1,0,0,0,1447,1445,1,0,0,0,1448,1450,1,0,0, + 0,1449,1447,1,0,0,0,1450,1451,5,266,0,0,1451,1453,1,0,0,0,1452,1440, + 1,0,0,0,1452,1453,1,0,0,0,1453,165,1,0,0,0,1454,1455,5,162,0,0,1455, + 1456,5,13,0,0,1456,167,1,0,0,0,1457,1458,5,162,0,0,1458,1459,5,85, + 0,0,1459,1460,3,190,95,0,1460,169,1,0,0,0,1461,1462,5,93,0,0,1462, + 1463,5,66,0,0,1463,171,1,0,0,0,1464,1465,5,93,0,0,1465,1466,5,132, + 0,0,1466,1467,5,66,0,0,1467,173,1,0,0,0,1468,1469,3,358,179,0,1469, + 175,1,0,0,0,1470,1471,3,358,179,0,1471,177,1,0,0,0,1472,1473,3,358, + 179,0,1473,179,1,0,0,0,1474,1475,3,358,179,0,1475,181,1,0,0,0,1476, + 1477,3,358,179,0,1477,183,1,0,0,0,1478,1479,3,358,179,0,1479,185, + 1,0,0,0,1480,1485,3,362,181,0,1481,1482,5,261,0,0,1482,1484,3,362, + 181,0,1483,1481,1,0,0,0,1484,1487,1,0,0,0,1485,1483,1,0,0,0,1485, + 1486,1,0,0,0,1486,187,1,0,0,0,1487,1485,1,0,0,0,1488,1493,3,362, + 181,0,1489,1490,5,261,0,0,1490,1492,3,362,181,0,1491,1489,1,0,0, + 0,1492,1495,1,0,0,0,1493,1491,1,0,0,0,1493,1494,1,0,0,0,1494,189, + 1,0,0,0,1495,1493,1,0,0,0,1496,1499,3,366,183,0,1497,1499,3,358, + 179,0,1498,1496,1,0,0,0,1498,1497,1,0,0,0,1499,191,1,0,0,0,1500, + 1503,3,358,179,0,1501,1503,4,96,0,0,1502,1500,1,0,0,0,1502,1501, + 1,0,0,0,1503,193,1,0,0,0,1504,1507,3,186,93,0,1505,1507,3,188,94, + 0,1506,1504,1,0,0,0,1506,1505,1,0,0,0,1507,195,1,0,0,0,1508,1509, + 5,21,0,0,1509,1510,5,26,0,0,1510,1512,3,296,148,0,1511,1508,1,0, + 0,0,1511,1512,1,0,0,0,1512,1514,1,0,0,0,1513,1515,3,222,111,0,1514, + 1513,1,0,0,0,1514,1515,1,0,0,0,1515,1519,1,0,0,0,1516,1517,5,168, + 0,0,1517,1518,5,79,0,0,1518,1520,3,258,129,0,1519,1516,1,0,0,0,1519, + 1520,1,0,0,0,1520,1524,1,0,0,0,1521,1522,5,216,0,0,1522,1523,5,175, + 0,0,1523,1525,3,252,126,0,1524,1521,1,0,0,0,1524,1525,1,0,0,0,1525, + 1529,1,0,0,0,1526,1527,5,23,0,0,1527,1528,5,9,0,0,1528,1530,3,234, + 117,0,1529,1526,1,0,0,0,1529,1530,1,0,0,0,1530,1533,1,0,0,0,1531, + 1532,5,24,0,0,1532,1534,3,318,159,0,1533,1531,1,0,0,0,1533,1534, + 1,0,0,0,1534,1545,1,0,0,0,1535,1536,5,30,0,0,1536,1537,5,94,0,0, + 1537,1542,3,358,179,0,1538,1539,5,216,0,0,1539,1540,5,151,0,0,1540, + 1541,5,249,0,0,1541,1543,5,277,0,0,1542,1538,1,0,0,0,1542,1543,1, + 0,0,0,1543,1546,1,0,0,0,1544,1546,5,197,0,0,1545,1535,1,0,0,0,1545, + 1544,1,0,0,0,1545,1546,1,0,0,0,1546,1549,1,0,0,0,1547,1548,5,25, + 0,0,1548,1550,3,252,126,0,1549,1547,1,0,0,0,1549,1550,1,0,0,0,1550, + 197,1,0,0,0,1551,1556,3,200,100,0,1552,1553,5,263,0,0,1553,1555, + 3,200,100,0,1554,1552,1,0,0,0,1555,1558,1,0,0,0,1556,1554,1,0,0, + 0,1556,1557,1,0,0,0,1557,199,1,0,0,0,1558,1556,1,0,0,0,1559,1560, + 3,358,179,0,1560,1561,5,249,0,0,1561,1562,3,308,154,0,1562,201,1, + 0,0,0,1563,1565,5,265,0,0,1564,1566,3,204,102,0,1565,1564,1,0,0, + 0,1565,1566,1,0,0,0,1566,1573,1,0,0,0,1567,1569,5,263,0,0,1568,1570, + 3,204,102,0,1569,1568,1,0,0,0,1569,1570,1,0,0,0,1570,1572,1,0,0, + 0,1571,1567,1,0,0,0,1572,1575,1,0,0,0,1573,1571,1,0,0,0,1573,1574, + 1,0,0,0,1574,1576,1,0,0,0,1575,1573,1,0,0,0,1576,1577,5,266,0,0, + 1577,203,1,0,0,0,1578,1580,3,182,91,0,1579,1581,3,222,111,0,1580, + 1579,1,0,0,0,1580,1581,1,0,0,0,1581,205,1,0,0,0,1582,1584,3,208, + 104,0,1583,1582,1,0,0,0,1583,1584,1,0,0,0,1584,1585,1,0,0,0,1585, + 1586,3,262,131,0,1586,207,1,0,0,0,1587,1588,5,216,0,0,1588,1593, + 3,278,139,0,1589,1590,5,263,0,0,1590,1592,3,278,139,0,1591,1589, + 1,0,0,0,1592,1595,1,0,0,0,1593,1591,1,0,0,0,1593,1594,1,0,0,0,1594, + 209,1,0,0,0,1595,1593,1,0,0,0,1596,1597,5,150,0,0,1597,1598,5,110, + 0,0,1598,1600,3,296,148,0,1599,1601,5,53,0,0,1600,1599,1,0,0,0,1600, + 1601,1,0,0,0,1601,1605,1,0,0,0,1602,1606,5,225,0,0,1603,1604,5,263, + 0,0,1604,1606,5,225,0,0,1605,1602,1,0,0,0,1605,1603,1,0,0,0,1605, + 1606,1,0,0,0,1606,1610,1,0,0,0,1607,1611,5,226,0,0,1608,1609,5,263, + 0,0,1609,1611,5,226,0,0,1610,1607,1,0,0,0,1610,1608,1,0,0,0,1610, + 1611,1,0,0,0,1611,1624,1,0,0,0,1612,1613,5,263,0,0,1613,1616,3,212, + 106,0,1614,1616,3,212,106,0,1615,1612,1,0,0,0,1615,1614,1,0,0,0, + 1616,1621,1,0,0,0,1617,1618,5,263,0,0,1618,1620,3,212,106,0,1619, + 1617,1,0,0,0,1620,1623,1,0,0,0,1621,1622,1,0,0,0,1621,1619,1,0,0, + 0,1622,1625,1,0,0,0,1623,1621,1,0,0,0,1624,1615,1,0,0,0,1624,1625, + 1,0,0,0,1625,211,1,0,0,0,1626,1627,5,81,0,0,1627,1628,5,110,0,0, + 1628,1629,3,296,148,0,1629,1630,5,224,0,0,1630,1631,3,186,93,0,1631, + 1633,3,296,148,0,1632,1634,5,53,0,0,1633,1632,1,0,0,0,1633,1634, + 1,0,0,0,1634,1636,1,0,0,0,1635,1637,5,225,0,0,1636,1635,1,0,0,0, + 1636,1637,1,0,0,0,1637,1639,1,0,0,0,1638,1640,5,226,0,0,1639,1638, + 1,0,0,0,1639,1640,1,0,0,0,1640,213,1,0,0,0,1641,1642,3,192,96,0, + 1642,1645,3,332,166,0,1643,1644,5,34,0,0,1644,1646,3,318,159,0,1645, + 1643,1,0,0,0,1645,1646,1,0,0,0,1646,215,1,0,0,0,1647,1648,3,182, + 91,0,1648,1650,3,332,166,0,1649,1651,3,222,111,0,1650,1649,1,0,0, + 0,1650,1651,1,0,0,0,1651,217,1,0,0,0,1652,1653,3,220,110,0,1653, + 219,1,0,0,0,1654,1655,3,182,91,0,1655,1663,3,332,166,0,1656,1660, + 3,228,114,0,1657,1659,3,228,114,0,1658,1657,1,0,0,0,1659,1662,1, + 0,0,0,1660,1661,1,0,0,0,1660,1658,1,0,0,0,1661,1664,1,0,0,0,1662, + 1660,1,0,0,0,1663,1656,1,0,0,0,1663,1664,1,0,0,0,1664,1666,1,0,0, + 0,1665,1667,3,222,111,0,1666,1665,1,0,0,0,1666,1667,1,0,0,0,1667, + 1670,1,0,0,0,1668,1669,5,150,0,0,1669,1671,5,110,0,0,1670,1668,1, + 0,0,0,1670,1671,1,0,0,0,1671,221,1,0,0,0,1672,1673,5,34,0,0,1673, + 1674,3,318,159,0,1674,223,1,0,0,0,1675,1683,3,214,107,0,1676,1680, + 3,228,114,0,1677,1679,3,228,114,0,1678,1677,1,0,0,0,1679,1682,1, + 0,0,0,1680,1681,1,0,0,0,1680,1678,1,0,0,0,1681,1684,1,0,0,0,1682, + 1680,1,0,0,0,1683,1676,1,0,0,0,1683,1684,1,0,0,0,1684,225,1,0,0, + 0,1685,1686,3,182,91,0,1686,1689,3,332,166,0,1687,1688,5,34,0,0, + 1688,1690,3,318,159,0,1689,1687,1,0,0,0,1689,1690,1,0,0,0,1690,1698, + 1,0,0,0,1691,1695,3,228,114,0,1692,1694,3,228,114,0,1693,1692,1, + 0,0,0,1694,1697,1,0,0,0,1695,1696,1,0,0,0,1695,1693,1,0,0,0,1696, + 1699,1,0,0,0,1697,1695,1,0,0,0,1698,1691,1,0,0,0,1698,1699,1,0,0, + 0,1699,227,1,0,0,0,1700,1702,5,132,0,0,1701,1700,1,0,0,0,1701,1702, + 1,0,0,0,1702,1703,1,0,0,0,1703,1706,5,133,0,0,1704,1706,3,230,115, + 0,1705,1701,1,0,0,0,1705,1704,1,0,0,0,1706,229,1,0,0,0,1707,1708, + 5,60,0,0,1708,1716,3,308,154,0,1709,1710,5,35,0,0,1710,1716,3,308, + 154,0,1711,1712,5,51,0,0,1712,1716,3,308,154,0,1713,1714,5,16,0, + 0,1714,1716,3,364,182,0,1715,1707,1,0,0,0,1715,1709,1,0,0,0,1715, + 1711,1,0,0,0,1715,1713,1,0,0,0,1716,231,1,0,0,0,1717,1718,7,10,0, + 0,1718,233,1,0,0,0,1719,1720,7,11,0,0,1720,235,1,0,0,0,1721,1726, + 3,238,119,0,1722,1723,5,263,0,0,1723,1725,3,238,119,0,1724,1722, + 1,0,0,0,1725,1728,1,0,0,0,1726,1727,1,0,0,0,1726,1724,1,0,0,0,1727, + 1731,1,0,0,0,1728,1726,1,0,0,0,1729,1730,5,263,0,0,1730,1732,3,240, + 120,0,1731,1729,1,0,0,0,1731,1732,1,0,0,0,1732,1735,1,0,0,0,1733, + 1735,3,240,120,0,1734,1721,1,0,0,0,1734,1733,1,0,0,0,1735,237,1, + 0,0,0,1736,1738,5,89,0,0,1737,1739,3,296,148,0,1738,1737,1,0,0,0, + 1738,1739,1,0,0,0,1739,1740,1,0,0,0,1740,1741,5,146,0,0,1741,1742, + 3,364,182,0,1742,239,1,0,0,0,1743,1745,5,154,0,0,1744,1746,3,296, + 148,0,1745,1744,1,0,0,0,1745,1746,1,0,0,0,1746,1747,1,0,0,0,1747, + 1748,5,265,0,0,1748,1749,5,145,0,0,1749,1755,3,242,121,0,1750,1751, + 5,263,0,0,1751,1752,5,145,0,0,1752,1754,3,242,121,0,1753,1750,1, + 0,0,0,1754,1757,1,0,0,0,1755,1756,1,0,0,0,1755,1753,1,0,0,0,1756, + 1758,1,0,0,0,1757,1755,1,0,0,0,1758,1759,5,266,0,0,1759,241,1,0, + 0,0,1760,1761,5,210,0,0,1761,1762,3,248,124,0,1762,1763,3,308,154, + 0,1763,1776,1,0,0,0,1764,1765,3,308,154,0,1765,1766,3,246,123,0, + 1766,1768,1,0,0,0,1767,1764,1,0,0,0,1767,1768,1,0,0,0,1768,1769, + 1,0,0,0,1769,1773,5,211,0,0,1770,1771,3,246,123,0,1771,1772,3,308, + 154,0,1772,1774,1,0,0,0,1773,1770,1,0,0,0,1773,1774,1,0,0,0,1774, + 1776,1,0,0,0,1775,1760,1,0,0,0,1775,1767,1,0,0,0,1776,243,1,0,0, + 0,1777,1778,5,30,0,0,1778,1779,5,94,0,0,1779,1784,3,362,181,0,1780, + 1781,5,216,0,0,1781,1782,5,151,0,0,1782,1783,5,249,0,0,1783,1785, + 3,364,182,0,1784,1780,1,0,0,0,1784,1785,1,0,0,0,1785,1788,1,0,0, + 0,1786,1788,5,197,0,0,1787,1777,1,0,0,0,1787,1786,1,0,0,0,1788,245, + 1,0,0,0,1789,1795,1,0,0,0,1790,1795,5,251,0,0,1791,1795,5,252,0, + 0,1792,1795,5,253,0,0,1793,1795,5,254,0,0,1794,1789,1,0,0,0,1794, + 1790,1,0,0,0,1794,1791,1,0,0,0,1794,1792,1,0,0,0,1794,1793,1,0,0, + 0,1795,247,1,0,0,0,1796,1805,5,249,0,0,1797,1805,5,250,0,0,1798, + 1805,5,115,0,0,1799,1805,5,164,0,0,1800,1805,5,163,0,0,1801,1805, + 5,15,0,0,1802,1805,5,94,0,0,1803,1805,3,246,123,0,1804,1796,1,0, + 0,0,1804,1797,1,0,0,0,1804,1798,1,0,0,0,1804,1799,1,0,0,0,1804,1800, + 1,0,0,0,1804,1801,1,0,0,0,1804,1802,1,0,0,0,1804,1803,1,0,0,0,1805, + 249,1,0,0,0,1806,1807,5,115,0,0,1807,1810,3,358,179,0,1808,1809, + 7,12,0,0,1809,1811,5,153,0,0,1810,1808,1,0,0,0,1810,1811,1,0,0,0, + 1811,251,1,0,0,0,1812,1813,5,265,0,0,1813,1818,3,260,130,0,1814, + 1815,5,263,0,0,1815,1817,3,260,130,0,1816,1814,1,0,0,0,1817,1820, + 1,0,0,0,1818,1816,1,0,0,0,1818,1819,1,0,0,0,1819,1821,1,0,0,0,1820, + 1818,1,0,0,0,1821,1822,5,266,0,0,1822,253,1,0,0,0,1823,1824,5,265, + 0,0,1824,1829,3,214,107,0,1825,1826,5,263,0,0,1826,1828,3,214,107, + 0,1827,1825,1,0,0,0,1828,1831,1,0,0,0,1829,1830,1,0,0,0,1829,1827, + 1,0,0,0,1830,1832,1,0,0,0,1831,1829,1,0,0,0,1832,1833,5,266,0,0, + 1833,255,1,0,0,0,1834,1839,3,308,154,0,1835,1836,5,263,0,0,1836, + 1838,3,308,154,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,257,1,0,0,0,1841,1839,1,0,0,0,1842, + 1852,5,52,0,0,1843,1844,5,71,0,0,1844,1845,5,191,0,0,1845,1846,5, + 26,0,0,1846,1850,3,318,159,0,1847,1848,5,63,0,0,1848,1849,5,26,0, + 0,1849,1851,3,318,159,0,1850,1847,1,0,0,0,1850,1851,1,0,0,0,1851, + 1853,1,0,0,0,1852,1843,1,0,0,0,1852,1853,1,0,0,0,1853,1858,1,0,0, + 0,1854,1855,5,117,0,0,1855,1856,5,191,0,0,1856,1857,5,26,0,0,1857, + 1859,3,318,159,0,1858,1854,1,0,0,0,1858,1859,1,0,0,0,1859,259,1, + 0,0,0,1860,1863,3,362,181,0,1861,1862,5,249,0,0,1862,1864,3,308, + 154,0,1863,1861,1,0,0,0,1863,1864,1,0,0,0,1864,261,1,0,0,0,1865, + 1876,3,264,132,0,1866,1867,5,139,0,0,1867,1868,5,26,0,0,1868,1873, + 3,268,134,0,1869,1870,5,263,0,0,1870,1872,3,268,134,0,1871,1869, + 1,0,0,0,1872,1875,1,0,0,0,1873,1871,1,0,0,0,1873,1874,1,0,0,0,1874, + 1877,1,0,0,0,1875,1873,1,0,0,0,1876,1866,1,0,0,0,1876,1877,1,0,0, + 0,1877,1884,1,0,0,0,1878,1879,5,116,0,0,1879,1882,3,308,154,0,1880, + 1881,5,135,0,0,1881,1883,5,277,0,0,1882,1880,1,0,0,0,1882,1883,1, + 0,0,0,1883,1885,1,0,0,0,1884,1878,1,0,0,0,1884,1885,1,0,0,0,1885, + 263,1,0,0,0,1886,1887,6,132,-1,0,1887,1888,3,266,133,0,1888,1903, + 1,0,0,0,1889,1890,10,2,0,0,1890,1892,5,100,0,0,1891,1893,3,280,140, + 0,1892,1891,1,0,0,0,1892,1893,1,0,0,0,1893,1894,1,0,0,0,1894,1902, + 3,264,132,3,1895,1896,10,1,0,0,1896,1898,7,13,0,0,1897,1899,3,280, + 140,0,1898,1897,1,0,0,0,1898,1899,1,0,0,0,1899,1900,1,0,0,0,1900, + 1902,3,264,132,2,1901,1889,1,0,0,0,1901,1895,1,0,0,0,1902,1905,1, + 0,0,0,1903,1901,1,0,0,0,1903,1904,1,0,0,0,1904,265,1,0,0,0,1905, + 1903,1,0,0,0,1906,1923,3,270,135,0,1907,1908,5,188,0,0,1908,1923, + 3,186,93,0,1909,1910,5,211,0,0,1910,1915,3,308,154,0,1911,1912,5, + 263,0,0,1912,1914,3,308,154,0,1913,1911,1,0,0,0,1914,1917,1,0,0, + 0,1915,1913,1,0,0,0,1915,1916,1,0,0,0,1916,1923,1,0,0,0,1917,1915, + 1,0,0,0,1918,1919,5,265,0,0,1919,1920,3,262,131,0,1920,1921,5,266, + 0,0,1921,1923,1,0,0,0,1922,1906,1,0,0,0,1922,1907,1,0,0,0,1922,1909, + 1,0,0,0,1922,1918,1,0,0,0,1923,267,1,0,0,0,1924,1926,3,306,153,0, + 1925,1927,7,14,0,0,1926,1925,1,0,0,0,1926,1927,1,0,0,0,1927,1930, + 1,0,0,0,1928,1929,5,134,0,0,1929,1931,7,15,0,0,1930,1928,1,0,0,0, + 1930,1931,1,0,0,0,1931,269,1,0,0,0,1932,1934,5,174,0,0,1933,1935, + 3,280,140,0,1934,1933,1,0,0,0,1934,1935,1,0,0,0,1935,1937,1,0,0, + 0,1936,1938,5,183,0,0,1937,1936,1,0,0,0,1937,1938,1,0,0,0,1938,1939, + 1,0,0,0,1939,1944,3,282,141,0,1940,1941,5,263,0,0,1941,1943,3,282, + 141,0,1942,1940,1,0,0,0,1943,1946,1,0,0,0,1944,1942,1,0,0,0,1944, + 1945,1,0,0,0,1945,1956,1,0,0,0,1946,1944,1,0,0,0,1947,1948,5,82, + 0,0,1948,1953,3,284,142,0,1949,1950,5,263,0,0,1950,1952,3,284,142, + 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,1947,1,0,0,0,1956, + 1957,1,0,0,0,1957,1960,1,0,0,0,1958,1959,5,215,0,0,1959,1961,3,310, + 155,0,1960,1958,1,0,0,0,1960,1961,1,0,0,0,1961,1965,1,0,0,0,1962, + 1963,5,87,0,0,1963,1964,5,26,0,0,1964,1966,3,272,136,0,1965,1962, + 1,0,0,0,1965,1966,1,0,0,0,1966,1969,1,0,0,0,1967,1968,5,90,0,0,1968, + 1970,3,310,155,0,1969,1967,1,0,0,0,1969,1970,1,0,0,0,1970,271,1, + 0,0,0,1971,1973,3,280,140,0,1972,1971,1,0,0,0,1972,1973,1,0,0,0, + 1973,1974,1,0,0,0,1974,1979,3,274,137,0,1975,1976,5,263,0,0,1976, + 1978,3,274,137,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,273,1,0,0,0,1981,1979,1,0,0,0,1982, + 1983,3,276,138,0,1983,275,1,0,0,0,1984,1993,5,265,0,0,1985,1990, + 3,306,153,0,1986,1987,5,263,0,0,1987,1989,3,306,153,0,1988,1986, + 1,0,0,0,1989,1992,1,0,0,0,1990,1988,1,0,0,0,1990,1991,1,0,0,0,1991, + 1994,1,0,0,0,1992,1990,1,0,0,0,1993,1985,1,0,0,0,1993,1994,1,0,0, + 0,1994,1995,1,0,0,0,1995,1998,5,266,0,0,1996,1998,3,306,153,0,1997, + 1984,1,0,0,0,1997,1996,1,0,0,0,1998,277,1,0,0,0,1999,2001,3,362, + 181,0,2000,2002,3,296,148,0,2001,2000,1,0,0,0,2001,2002,1,0,0,0, + 2002,2003,1,0,0,0,2003,2004,5,9,0,0,2004,2005,3,300,150,0,2005,279, + 1,0,0,0,2006,2007,7,16,0,0,2007,281,1,0,0,0,2008,2013,3,306,153, + 0,2009,2011,5,9,0,0,2010,2009,1,0,0,0,2010,2011,1,0,0,0,2011,2012, + 1,0,0,0,2012,2014,3,362,181,0,2013,2010,1,0,0,0,2013,2014,1,0,0, + 0,2014,2021,1,0,0,0,2015,2016,3,358,179,0,2016,2017,5,261,0,0,2017, + 2018,5,257,0,0,2018,2021,1,0,0,0,2019,2021,5,257,0,0,2020,2008,1, + 0,0,0,2020,2015,1,0,0,0,2020,2019,1,0,0,0,2021,283,1,0,0,0,2022, + 2023,6,142,-1,0,2023,2024,3,290,145,0,2024,2038,1,0,0,0,2025,2034, + 10,2,0,0,2026,2027,5,38,0,0,2027,2028,5,109,0,0,2028,2035,3,290, + 145,0,2029,2030,3,286,143,0,2030,2031,5,109,0,0,2031,2032,3,284, + 142,0,2032,2033,3,288,144,0,2033,2035,1,0,0,0,2034,2026,1,0,0,0, + 2034,2029,1,0,0,0,2035,2037,1,0,0,0,2036,2025,1,0,0,0,2037,2040, + 1,0,0,0,2038,2036,1,0,0,0,2038,2039,1,0,0,0,2039,285,1,0,0,0,2040, + 2038,1,0,0,0,2041,2043,5,97,0,0,2042,2041,1,0,0,0,2042,2043,1,0, + 0,0,2043,2073,1,0,0,0,2044,2046,5,114,0,0,2045,2047,5,97,0,0,2046, + 2045,1,0,0,0,2046,2047,1,0,0,0,2047,2073,1,0,0,0,2048,2050,5,165, + 0,0,2049,2051,5,97,0,0,2050,2049,1,0,0,0,2050,2051,1,0,0,0,2051, + 2073,1,0,0,0,2052,2054,5,114,0,0,2053,2055,5,141,0,0,2054,2053,1, + 0,0,0,2054,2055,1,0,0,0,2055,2073,1,0,0,0,2056,2058,5,165,0,0,2057, + 2059,5,141,0,0,2058,2057,1,0,0,0,2058,2059,1,0,0,0,2059,2073,1,0, + 0,0,2060,2062,5,83,0,0,2061,2063,5,141,0,0,2062,2061,1,0,0,0,2062, + 2063,1,0,0,0,2063,2073,1,0,0,0,2064,2065,5,114,0,0,2065,2073,5,177, + 0,0,2066,2067,5,165,0,0,2067,2073,5,177,0,0,2068,2069,5,114,0,0, + 2069,2073,5,7,0,0,2070,2071,5,165,0,0,2071,2073,5,7,0,0,2072,2042, + 1,0,0,0,2072,2044,1,0,0,0,2072,2048,1,0,0,0,2072,2052,1,0,0,0,2072, + 2056,1,0,0,0,2072,2060,1,0,0,0,2072,2064,1,0,0,0,2072,2066,1,0,0, + 0,2072,2068,1,0,0,0,2072,2070,1,0,0,0,2073,287,1,0,0,0,2074,2075, + 5,136,0,0,2075,2089,3,310,155,0,2076,2077,5,205,0,0,2077,2078,5, + 265,0,0,2078,2083,3,362,181,0,2079,2080,5,263,0,0,2080,2082,3,362, + 181,0,2081,2079,1,0,0,0,2082,2085,1,0,0,0,2083,2081,1,0,0,0,2083, + 2084,1,0,0,0,2084,2086,1,0,0,0,2085,2083,1,0,0,0,2086,2087,5,266, + 0,0,2087,2089,1,0,0,0,2088,2074,1,0,0,0,2088,2076,1,0,0,0,2089,289, + 1,0,0,0,2090,2103,3,294,147,0,2091,2092,5,190,0,0,2092,2093,3,292, + 146,0,2093,2094,5,265,0,0,2094,2095,3,308,154,0,2095,2101,5,266, + 0,0,2096,2097,5,157,0,0,2097,2098,5,265,0,0,2098,2099,3,308,154, + 0,2099,2100,5,266,0,0,2100,2102,1,0,0,0,2101,2096,1,0,0,0,2101,2102, + 1,0,0,0,2102,2104,1,0,0,0,2103,2091,1,0,0,0,2103,2104,1,0,0,0,2104, + 291,1,0,0,0,2105,2106,7,17,0,0,2106,293,1,0,0,0,2107,2115,3,298, + 149,0,2108,2110,5,9,0,0,2109,2108,1,0,0,0,2109,2110,1,0,0,0,2110, + 2111,1,0,0,0,2111,2113,3,362,181,0,2112,2114,3,296,148,0,2113,2112, + 1,0,0,0,2113,2114,1,0,0,0,2114,2116,1,0,0,0,2115,2109,1,0,0,0,2115, + 2116,1,0,0,0,2116,295,1,0,0,0,2117,2118,5,265,0,0,2118,2123,3,192, + 96,0,2119,2120,5,263,0,0,2120,2122,3,192,96,0,2121,2119,1,0,0,0, + 2122,2125,1,0,0,0,2123,2121,1,0,0,0,2123,2124,1,0,0,0,2124,2126, + 1,0,0,0,2125,2123,1,0,0,0,2126,2127,5,266,0,0,2127,297,1,0,0,0,2128, + 2136,3,194,97,0,2129,2131,5,113,0,0,2130,2129,1,0,0,0,2130,2131, + 1,0,0,0,2131,2132,1,0,0,0,2132,2136,3,300,150,0,2133,2136,3,302, + 151,0,2134,2136,3,304,152,0,2135,2128,1,0,0,0,2135,2130,1,0,0,0, + 2135,2133,1,0,0,0,2135,2134,1,0,0,0,2136,299,1,0,0,0,2137,2138,5, + 265,0,0,2138,2139,3,206,103,0,2139,2140,5,266,0,0,2140,301,1,0,0, + 0,2141,2142,5,201,0,0,2142,2143,5,265,0,0,2143,2148,3,308,154,0, + 2144,2145,5,263,0,0,2145,2147,3,308,154,0,2146,2144,1,0,0,0,2147, + 2150,1,0,0,0,2148,2146,1,0,0,0,2148,2149,1,0,0,0,2149,2151,1,0,0, + 0,2150,2148,1,0,0,0,2151,2154,5,266,0,0,2152,2153,5,216,0,0,2153, + 2155,5,140,0,0,2154,2152,1,0,0,0,2154,2155,1,0,0,0,2155,303,1,0, + 0,0,2156,2157,5,265,0,0,2157,2158,3,284,142,0,2158,2159,5,266,0, + 0,2159,305,1,0,0,0,2160,2163,3,192,96,0,2161,2163,3,308,154,0,2162, + 2160,1,0,0,0,2162,2161,1,0,0,0,2163,307,1,0,0,0,2164,2165,3,310, + 155,0,2165,309,1,0,0,0,2166,2167,6,155,-1,0,2167,2169,3,314,157, + 0,2168,2170,3,312,156,0,2169,2168,1,0,0,0,2169,2170,1,0,0,0,2170, + 2174,1,0,0,0,2171,2172,5,132,0,0,2172,2174,3,310,155,3,2173,2166, + 1,0,0,0,2173,2171,1,0,0,0,2174,2183,1,0,0,0,2175,2176,10,2,0,0,2176, + 2177,5,5,0,0,2177,2182,3,310,155,3,2178,2179,10,1,0,0,2179,2180, + 5,138,0,0,2180,2182,3,310,155,2,2181,2175,1,0,0,0,2181,2178,1,0, + 0,0,2182,2185,1,0,0,0,2183,2181,1,0,0,0,2183,2184,1,0,0,0,2184,311, + 1,0,0,0,2185,2183,1,0,0,0,2186,2187,3,320,160,0,2187,2188,3,314, + 157,0,2188,2245,1,0,0,0,2189,2190,3,320,160,0,2190,2191,3,322,161, + 0,2191,2192,3,300,150,0,2192,2245,1,0,0,0,2193,2195,5,132,0,0,2194, + 2193,1,0,0,0,2194,2195,1,0,0,0,2195,2196,1,0,0,0,2196,2197,5,15, + 0,0,2197,2198,3,314,157,0,2198,2199,5,5,0,0,2199,2200,3,314,157, + 0,2200,2245,1,0,0,0,2201,2203,5,132,0,0,2202,2201,1,0,0,0,2202,2203, + 1,0,0,0,2203,2204,1,0,0,0,2204,2205,5,94,0,0,2205,2206,5,265,0,0, + 2206,2211,3,308,154,0,2207,2208,5,263,0,0,2208,2210,3,308,154,0, + 2209,2207,1,0,0,0,2210,2213,1,0,0,0,2211,2209,1,0,0,0,2211,2212, + 1,0,0,0,2212,2214,1,0,0,0,2213,2211,1,0,0,0,2214,2215,5,266,0,0, + 2215,2245,1,0,0,0,2216,2218,5,132,0,0,2217,2216,1,0,0,0,2217,2218, + 1,0,0,0,2218,2219,1,0,0,0,2219,2220,5,94,0,0,2220,2245,3,300,150, + 0,2221,2223,5,132,0,0,2222,2221,1,0,0,0,2222,2223,1,0,0,0,2223,2224, + 1,0,0,0,2224,2225,7,18,0,0,2225,2228,3,314,157,0,2226,2227,5,62, + 0,0,2227,2229,3,314,157,0,2228,2226,1,0,0,0,2228,2229,1,0,0,0,2229, + 2245,1,0,0,0,2230,2231,7,19,0,0,2231,2245,3,314,157,0,2232,2234, + 5,108,0,0,2233,2235,5,132,0,0,2234,2233,1,0,0,0,2234,2235,1,0,0, + 0,2235,2236,1,0,0,0,2236,2245,7,20,0,0,2237,2239,5,108,0,0,2238, + 2240,5,132,0,0,2239,2238,1,0,0,0,2239,2240,1,0,0,0,2240,2241,1,0, + 0,0,2241,2242,5,57,0,0,2242,2243,5,82,0,0,2243,2245,3,314,157,0, + 2244,2186,1,0,0,0,2244,2189,1,0,0,0,2244,2194,1,0,0,0,2244,2202, + 1,0,0,0,2244,2217,1,0,0,0,2244,2222,1,0,0,0,2244,2230,1,0,0,0,2244, + 2232,1,0,0,0,2244,2237,1,0,0,0,2245,313,1,0,0,0,2246,2247,6,157, + -1,0,2247,2251,3,316,158,0,2248,2249,7,21,0,0,2249,2251,3,314,157, + 4,2250,2246,1,0,0,0,2250,2248,1,0,0,0,2251,2263,1,0,0,0,2252,2253, + 10,3,0,0,2253,2254,7,22,0,0,2254,2262,3,314,157,4,2255,2256,10,2, + 0,0,2256,2257,7,21,0,0,2257,2262,3,314,157,3,2258,2259,10,1,0,0, + 2259,2260,5,260,0,0,2260,2262,3,314,157,2,2261,2252,1,0,0,0,2261, + 2255,1,0,0,0,2261,2258,1,0,0,0,2262,2265,1,0,0,0,2263,2261,1,0,0, + 0,2263,2264,1,0,0,0,2264,315,1,0,0,0,2265,2263,1,0,0,0,2266,2267, + 6,158,-1,0,2267,2513,5,133,0,0,2268,2513,3,326,163,0,2269,2270,3, + 362,181,0,2270,2271,3,318,159,0,2271,2513,1,0,0,0,2272,2273,5,286, + 0,0,2273,2513,3,318,159,0,2274,2513,3,364,182,0,2275,2513,3,324, + 162,0,2276,2513,3,318,159,0,2277,2513,5,276,0,0,2278,2513,5,272, + 0,0,2279,2280,5,148,0,0,2280,2281,5,265,0,0,2281,2282,3,314,157, + 0,2282,2283,5,94,0,0,2283,2284,3,314,157,0,2284,2285,5,266,0,0,2285, + 2513,1,0,0,0,2286,2287,5,265,0,0,2287,2290,3,308,154,0,2288,2289, + 5,9,0,0,2289,2291,3,332,166,0,2290,2288,1,0,0,0,2290,2291,1,0,0, + 0,2291,2300,1,0,0,0,2292,2293,5,263,0,0,2293,2296,3,308,154,0,2294, + 2295,5,9,0,0,2295,2297,3,332,166,0,2296,2294,1,0,0,0,2296,2297,1, + 0,0,0,2297,2299,1,0,0,0,2298,2292,1,0,0,0,2299,2302,1,0,0,0,2300, + 2301,1,0,0,0,2300,2298,1,0,0,0,2301,2303,1,0,0,0,2302,2300,1,0,0, + 0,2303,2304,5,266,0,0,2304,2513,1,0,0,0,2305,2306,5,168,0,0,2306, + 2307,5,265,0,0,2307,2312,3,308,154,0,2308,2309,5,263,0,0,2309,2311, + 3,308,154,0,2310,2308,1,0,0,0,2311,2314,1,0,0,0,2312,2310,1,0,0, + 0,2312,2313,1,0,0,0,2313,2315,1,0,0,0,2314,2312,1,0,0,0,2315,2316, + 5,266,0,0,2316,2513,1,0,0,0,2317,2318,3,190,95,0,2318,2319,5,265, + 0,0,2319,2320,5,257,0,0,2320,2322,5,266,0,0,2321,2323,3,342,171, + 0,2322,2321,1,0,0,0,2322,2323,1,0,0,0,2323,2325,1,0,0,0,2324,2326, + 3,344,172,0,2325,2324,1,0,0,0,2325,2326,1,0,0,0,2326,2513,1,0,0, + 0,2327,2328,3,190,95,0,2328,2340,5,265,0,0,2329,2331,3,280,140,0, + 2330,2329,1,0,0,0,2330,2331,1,0,0,0,2331,2332,1,0,0,0,2332,2337, + 3,308,154,0,2333,2334,5,263,0,0,2334,2336,3,308,154,0,2335,2333, + 1,0,0,0,2336,2339,1,0,0,0,2337,2335,1,0,0,0,2337,2338,1,0,0,0,2338, + 2341,1,0,0,0,2339,2337,1,0,0,0,2340,2330,1,0,0,0,2340,2341,1,0,0, + 0,2341,2352,1,0,0,0,2342,2343,5,139,0,0,2343,2344,5,26,0,0,2344, + 2349,3,268,134,0,2345,2346,5,263,0,0,2346,2348,3,268,134,0,2347, + 2345,1,0,0,0,2348,2351,1,0,0,0,2349,2347,1,0,0,0,2349,2350,1,0,0, + 0,2350,2353,1,0,0,0,2351,2349,1,0,0,0,2352,2342,1,0,0,0,2352,2353, + 1,0,0,0,2353,2354,1,0,0,0,2354,2356,5,266,0,0,2355,2357,3,342,171, + 0,2356,2355,1,0,0,0,2356,2357,1,0,0,0,2357,2359,1,0,0,0,2358,2360, + 3,344,172,0,2359,2358,1,0,0,0,2359,2360,1,0,0,0,2360,2513,1,0,0, + 0,2361,2362,3,362,181,0,2362,2363,5,273,0,0,2363,2364,3,308,154, + 0,2364,2513,1,0,0,0,2365,2374,5,265,0,0,2366,2371,3,362,181,0,2367, + 2368,5,263,0,0,2368,2370,3,362,181,0,2369,2367,1,0,0,0,2370,2373, + 1,0,0,0,2371,2369,1,0,0,0,2371,2372,1,0,0,0,2372,2375,1,0,0,0,2373, + 2371,1,0,0,0,2374,2366,1,0,0,0,2374,2375,1,0,0,0,2375,2376,1,0,0, + 0,2376,2377,5,266,0,0,2377,2378,5,273,0,0,2378,2513,3,308,154,0, + 2379,2380,5,265,0,0,2380,2381,3,206,103,0,2381,2382,5,266,0,0,2382, + 2513,1,0,0,0,2383,2384,5,66,0,0,2384,2385,5,265,0,0,2385,2386,3, + 206,103,0,2386,2387,5,266,0,0,2387,2513,1,0,0,0,2388,2389,5,28,0, + 0,2389,2391,3,314,157,0,2390,2392,3,340,170,0,2391,2390,1,0,0,0, + 2392,2393,1,0,0,0,2393,2391,1,0,0,0,2393,2394,1,0,0,0,2394,2397, + 1,0,0,0,2395,2396,5,59,0,0,2396,2398,3,308,154,0,2397,2395,1,0,0, + 0,2397,2398,1,0,0,0,2398,2399,1,0,0,0,2399,2400,5,61,0,0,2400,2513, + 1,0,0,0,2401,2403,5,28,0,0,2402,2404,3,340,170,0,2403,2402,1,0,0, + 0,2404,2405,1,0,0,0,2405,2403,1,0,0,0,2405,2406,1,0,0,0,2406,2409, + 1,0,0,0,2407,2408,5,59,0,0,2408,2410,3,308,154,0,2409,2407,1,0,0, + 0,2409,2410,1,0,0,0,2410,2411,1,0,0,0,2411,2412,5,61,0,0,2412,2513, + 1,0,0,0,2413,2414,5,29,0,0,2414,2415,5,265,0,0,2415,2416,3,308,154, + 0,2416,2417,5,9,0,0,2417,2418,3,332,166,0,2418,2419,5,266,0,0,2419, + 2513,1,0,0,0,2420,2421,5,195,0,0,2421,2422,5,265,0,0,2422,2423,3, + 308,154,0,2423,2424,5,9,0,0,2424,2425,3,332,166,0,2425,2426,5,266, + 0,0,2426,2513,1,0,0,0,2427,2428,5,8,0,0,2428,2437,5,267,0,0,2429, + 2434,3,308,154,0,2430,2431,5,263,0,0,2431,2433,3,308,154,0,2432, + 2430,1,0,0,0,2433,2436,1,0,0,0,2434,2432,1,0,0,0,2434,2435,1,0,0, + 0,2435,2438,1,0,0,0,2436,2434,1,0,0,0,2437,2429,1,0,0,0,2437,2438, + 1,0,0,0,2438,2439,1,0,0,0,2439,2513,5,268,0,0,2440,2513,3,362,181, + 0,2441,2513,5,40,0,0,2442,2446,5,42,0,0,2443,2444,5,265,0,0,2444, + 2445,5,277,0,0,2445,2447,5,266,0,0,2446,2443,1,0,0,0,2446,2447,1, + 0,0,0,2447,2513,1,0,0,0,2448,2452,5,43,0,0,2449,2450,5,265,0,0,2450, + 2451,5,277,0,0,2451,2453,5,266,0,0,2452,2449,1,0,0,0,2452,2453,1, + 0,0,0,2453,2513,1,0,0,0,2454,2458,5,119,0,0,2455,2456,5,265,0,0, + 2456,2457,5,277,0,0,2457,2459,5,266,0,0,2458,2455,1,0,0,0,2458,2459, + 1,0,0,0,2459,2513,1,0,0,0,2460,2464,5,120,0,0,2461,2462,5,265,0, + 0,2462,2463,5,277,0,0,2463,2465,5,266,0,0,2464,2461,1,0,0,0,2464, + 2465,1,0,0,0,2465,2513,1,0,0,0,2466,2513,5,44,0,0,2467,2513,5,41, + 0,0,2468,2469,5,184,0,0,2469,2470,5,265,0,0,2470,2471,3,314,157, + 0,2471,2472,5,82,0,0,2472,2475,3,314,157,0,2473,2474,5,78,0,0,2474, + 2476,3,314,157,0,2475,2473,1,0,0,0,2475,2476,1,0,0,0,2476,2477,1, + 0,0,0,2477,2478,5,266,0,0,2478,2513,1,0,0,0,2479,2480,5,131,0,0, + 2480,2481,5,265,0,0,2481,2484,3,314,157,0,2482,2483,5,263,0,0,2483, + 2485,3,330,165,0,2484,2482,1,0,0,0,2484,2485,1,0,0,0,2485,2486,1, + 0,0,0,2486,2487,5,266,0,0,2487,2513,1,0,0,0,2488,2489,5,68,0,0,2489, + 2490,5,265,0,0,2490,2491,3,362,181,0,2491,2492,5,82,0,0,2492,2493, + 3,314,157,0,2493,2494,5,266,0,0,2494,2513,1,0,0,0,2495,2496,5,265, + 0,0,2496,2497,3,308,154,0,2497,2498,5,266,0,0,2498,2513,1,0,0,0, + 2499,2500,5,88,0,0,2500,2509,5,265,0,0,2501,2506,3,358,179,0,2502, + 2503,5,263,0,0,2503,2505,3,358,179,0,2504,2502,1,0,0,0,2505,2508, + 1,0,0,0,2506,2504,1,0,0,0,2506,2507,1,0,0,0,2507,2510,1,0,0,0,2508, + 2506,1,0,0,0,2509,2501,1,0,0,0,2509,2510,1,0,0,0,2510,2511,1,0,0, + 0,2511,2513,5,266,0,0,2512,2266,1,0,0,0,2512,2268,1,0,0,0,2512,2269, + 1,0,0,0,2512,2272,1,0,0,0,2512,2274,1,0,0,0,2512,2275,1,0,0,0,2512, + 2276,1,0,0,0,2512,2277,1,0,0,0,2512,2278,1,0,0,0,2512,2279,1,0,0, + 0,2512,2286,1,0,0,0,2512,2305,1,0,0,0,2512,2317,1,0,0,0,2512,2327, + 1,0,0,0,2512,2361,1,0,0,0,2512,2365,1,0,0,0,2512,2379,1,0,0,0,2512, + 2383,1,0,0,0,2512,2388,1,0,0,0,2512,2401,1,0,0,0,2512,2413,1,0,0, + 0,2512,2420,1,0,0,0,2512,2427,1,0,0,0,2512,2440,1,0,0,0,2512,2441, + 1,0,0,0,2512,2442,1,0,0,0,2512,2448,1,0,0,0,2512,2454,1,0,0,0,2512, + 2460,1,0,0,0,2512,2466,1,0,0,0,2512,2467,1,0,0,0,2512,2468,1,0,0, + 0,2512,2479,1,0,0,0,2512,2488,1,0,0,0,2512,2495,1,0,0,0,2512,2499, + 1,0,0,0,2513,2524,1,0,0,0,2514,2515,10,15,0,0,2515,2516,5,267,0, + 0,2516,2517,3,314,157,0,2517,2518,5,268,0,0,2518,2523,1,0,0,0,2519, + 2520,10,13,0,0,2520,2521,5,261,0,0,2521,2523,3,362,181,0,2522,2514, + 1,0,0,0,2522,2519,1,0,0,0,2523,2526,1,0,0,0,2524,2522,1,0,0,0,2524, + 2525,1,0,0,0,2525,317,1,0,0,0,2526,2524,1,0,0,0,2527,2534,5,274, + 0,0,2528,2531,5,275,0,0,2529,2530,5,198,0,0,2530,2532,5,274,0,0, + 2531,2529,1,0,0,0,2531,2532,1,0,0,0,2532,2534,1,0,0,0,2533,2527, + 1,0,0,0,2533,2528,1,0,0,0,2534,319,1,0,0,0,2535,2536,7,23,0,0,2536, + 321,1,0,0,0,2537,2538,7,24,0,0,2538,323,1,0,0,0,2539,2540,7,25,0, + 0,2540,325,1,0,0,0,2541,2542,5,277,0,0,2542,2556,3,328,164,0,2543, + 2544,5,265,0,0,2544,2545,5,277,0,0,2545,2546,5,266,0,0,2546,2556, + 3,328,164,0,2547,2548,5,101,0,0,2548,2549,5,277,0,0,2549,2556,3, + 328,164,0,2550,2551,5,101,0,0,2551,2552,5,265,0,0,2552,2553,5,277, + 0,0,2553,2554,5,266,0,0,2554,2556,3,328,164,0,2555,2541,1,0,0,0, + 2555,2543,1,0,0,0,2555,2547,1,0,0,0,2555,2550,1,0,0,0,2556,327,1, + 0,0,0,2557,2558,7,26,0,0,2558,329,1,0,0,0,2559,2560,7,27,0,0,2560, + 331,1,0,0,0,2561,2562,6,166,-1,0,2562,2563,5,8,0,0,2563,2564,5,251, + 0,0,2564,2565,3,332,166,0,2565,2566,5,253,0,0,2566,2607,1,0,0,0, + 2567,2568,5,235,0,0,2568,2569,5,251,0,0,2569,2570,3,332,166,0,2570, + 2571,5,263,0,0,2571,2572,3,332,166,0,2572,2573,5,253,0,0,2573,2607, + 1,0,0,0,2574,2575,5,240,0,0,2575,2576,5,251,0,0,2576,2577,3,362, + 181,0,2577,2584,3,332,166,0,2578,2579,5,263,0,0,2579,2580,3,362, + 181,0,2580,2581,3,332,166,0,2581,2583,1,0,0,0,2582,2578,1,0,0,0, + 2583,2586,1,0,0,0,2584,2582,1,0,0,0,2584,2585,1,0,0,0,2585,2587, + 1,0,0,0,2586,2584,1,0,0,0,2587,2588,5,253,0,0,2588,2607,1,0,0,0, + 2589,2592,3,338,169,0,2590,2592,3,334,167,0,2591,2589,1,0,0,0,2591, + 2590,1,0,0,0,2592,2604,1,0,0,0,2593,2594,5,265,0,0,2594,2599,3,336, + 168,0,2595,2596,5,263,0,0,2596,2598,3,336,168,0,2597,2595,1,0,0, + 0,2598,2601,1,0,0,0,2599,2597,1,0,0,0,2599,2600,1,0,0,0,2600,2602, + 1,0,0,0,2601,2599,1,0,0,0,2602,2603,5,266,0,0,2603,2605,1,0,0,0, + 2604,2593,1,0,0,0,2604,2605,1,0,0,0,2605,2607,1,0,0,0,2606,2561, + 1,0,0,0,2606,2567,1,0,0,0,2606,2574,1,0,0,0,2606,2591,1,0,0,0,2607, + 2612,1,0,0,0,2608,2609,10,5,0,0,2609,2611,5,8,0,0,2610,2608,1,0, + 0,0,2611,2614,1,0,0,0,2612,2610,1,0,0,0,2612,2613,1,0,0,0,2613,333, + 1,0,0,0,2614,2612,1,0,0,0,2615,2616,7,28,0,0,2616,335,1,0,0,0,2617, + 2620,5,277,0,0,2618,2620,3,332,166,0,2619,2617,1,0,0,0,2619,2618, + 1,0,0,0,2620,337,1,0,0,0,2621,2626,5,284,0,0,2622,2626,5,285,0,0, + 2623,2626,5,286,0,0,2624,2626,3,362,181,0,2625,2621,1,0,0,0,2625, + 2622,1,0,0,0,2625,2623,1,0,0,0,2625,2624,1,0,0,0,2626,339,1,0,0, + 0,2627,2628,5,214,0,0,2628,2629,3,308,154,0,2629,2630,5,192,0,0, + 2630,2631,3,308,154,0,2631,341,1,0,0,0,2632,2633,5,74,0,0,2633,2634, + 5,265,0,0,2634,2635,5,215,0,0,2635,2636,3,310,155,0,2636,2637,5, + 266,0,0,2637,343,1,0,0,0,2638,2639,5,143,0,0,2639,2650,5,265,0,0, + 2640,2641,5,145,0,0,2641,2642,5,26,0,0,2642,2647,3,308,154,0,2643, + 2644,5,263,0,0,2644,2646,3,308,154,0,2645,2643,1,0,0,0,2646,2649, + 1,0,0,0,2647,2645,1,0,0,0,2647,2648,1,0,0,0,2648,2651,1,0,0,0,2649, + 2647,1,0,0,0,2650,2640,1,0,0,0,2650,2651,1,0,0,0,2651,2662,1,0,0, + 0,2652,2653,5,139,0,0,2653,2654,5,26,0,0,2654,2659,3,268,134,0,2655, + 2656,5,263,0,0,2656,2658,3,268,134,0,2657,2655,1,0,0,0,2658,2661, + 1,0,0,0,2659,2657,1,0,0,0,2659,2660,1,0,0,0,2660,2663,1,0,0,0,2661, + 2659,1,0,0,0,2662,2652,1,0,0,0,2662,2663,1,0,0,0,2663,2665,1,0,0, + 0,2664,2666,3,346,173,0,2665,2664,1,0,0,0,2665,2666,1,0,0,0,2666, + 2667,1,0,0,0,2667,2668,5,266,0,0,2668,345,1,0,0,0,2669,2670,5,154, + 0,0,2670,2686,3,348,174,0,2671,2672,5,169,0,0,2672,2686,3,348,174, + 0,2673,2674,5,154,0,0,2674,2675,5,15,0,0,2675,2676,3,348,174,0,2676, + 2677,5,5,0,0,2677,2678,3,348,174,0,2678,2686,1,0,0,0,2679,2680,5, + 169,0,0,2680,2681,5,15,0,0,2681,2682,3,348,174,0,2682,2683,5,5,0, + 0,2683,2684,3,348,174,0,2684,2686,1,0,0,0,2685,2669,1,0,0,0,2685, + 2671,1,0,0,0,2685,2673,1,0,0,0,2685,2679,1,0,0,0,2686,347,1,0,0, + 0,2687,2688,5,199,0,0,2688,2697,5,149,0,0,2689,2690,5,199,0,0,2690, + 2697,5,77,0,0,2691,2692,5,39,0,0,2692,2697,5,168,0,0,2693,2694,3, + 308,154,0,2694,2695,7,29,0,0,2695,2697,1,0,0,0,2696,2687,1,0,0,0, + 2696,2689,1,0,0,0,2696,2691,1,0,0,0,2696,2693,1,0,0,0,2697,349,1, + 0,0,0,2698,2699,3,362,181,0,2699,2700,5,261,0,0,2700,2701,3,362, + 181,0,2701,2704,1,0,0,0,2702,2704,3,362,181,0,2703,2698,1,0,0,0, + 2703,2702,1,0,0,0,2704,351,1,0,0,0,2705,2710,3,350,175,0,2706,2707, + 5,263,0,0,2707,2709,3,350,175,0,2708,2706,1,0,0,0,2709,2712,1,0, + 0,0,2710,2708,1,0,0,0,2710,2711,1,0,0,0,2711,353,1,0,0,0,2712,2710, + 1,0,0,0,2713,2727,5,2,0,0,2714,2727,5,4,0,0,2715,2727,5,58,0,0,2716, + 2727,5,37,0,0,2717,2727,5,99,0,0,2718,2727,5,162,0,0,2719,2724,5, + 174,0,0,2720,2721,5,265,0,0,2721,2722,3,362,181,0,2722,2723,5,266, + 0,0,2723,2725,1,0,0,0,2724,2720,1,0,0,0,2724,2725,1,0,0,0,2725,2727, + 1,0,0,0,2726,2713,1,0,0,0,2726,2714,1,0,0,0,2726,2715,1,0,0,0,2726, + 2716,1,0,0,0,2726,2717,1,0,0,0,2726,2718,1,0,0,0,2726,2719,1,0,0, + 0,2727,355,1,0,0,0,2728,2729,7,30,0,0,2729,357,1,0,0,0,2730,2735, + 3,362,181,0,2731,2732,5,261,0,0,2732,2734,3,362,181,0,2733,2731, + 1,0,0,0,2734,2737,1,0,0,0,2735,2733,1,0,0,0,2735,2736,1,0,0,0,2736, + 359,1,0,0,0,2737,2735,1,0,0,0,2738,2739,5,166,0,0,2739,2745,3,362, + 181,0,2740,2741,5,204,0,0,2741,2745,3,362,181,0,2742,2743,5,87,0, + 0,2743,2745,3,362,181,0,2744,2738,1,0,0,0,2744,2740,1,0,0,0,2744, + 2742,1,0,0,0,2745,361,1,0,0,0,2746,2752,5,280,0,0,2747,2752,5,274, + 0,0,2748,2752,3,368,184,0,2749,2752,5,283,0,0,2750,2752,5,281,0, + 0,2751,2746,1,0,0,0,2751,2747,1,0,0,0,2751,2748,1,0,0,0,2751,2749, + 1,0,0,0,2751,2750,1,0,0,0,2752,363,1,0,0,0,2753,2755,5,256,0,0,2754, + 2753,1,0,0,0,2754,2755,1,0,0,0,2755,2756,1,0,0,0,2756,2766,5,278, + 0,0,2757,2759,5,256,0,0,2758,2757,1,0,0,0,2758,2759,1,0,0,0,2759, + 2760,1,0,0,0,2760,2766,5,279,0,0,2761,2763,5,256,0,0,2762,2761,1, + 0,0,0,2762,2763,1,0,0,0,2763,2764,1,0,0,0,2764,2766,5,277,0,0,2765, + 2754,1,0,0,0,2765,2758,1,0,0,0,2765,2762,1,0,0,0,2766,365,1,0,0, + 0,2767,2768,7,31,0,0,2768,367,1,0,0,0,2769,2770,7,32,0,0,2770,369, + 1,0,0,0,353,373,380,404,417,421,425,434,439,443,449,451,456,460, + 464,471,476,482,486,495,502,506,511,513,518,521,528,532,537,541, + 544,548,556,560,564,572,576,585,588,591,597,604,615,620,625,630, + 635,644,647,650,654,680,706,715,725,728,742,760,762,771,782,791, + 798,802,809,815,818,823,830,844,857,862,867,873,909,912,918,921, + 927,933,945,947,958,966,971,975,980,987,991,995,1001,1005,1009,1018, + 1021,1024,1032,1046,1053,1066,1072,1077,1080,1083,1088,1092,1101, + 1106,1112,1116,1121,1126,1129,1137,1140,1144,1156,1159,1163,1168, + 1172,1188,1193,1200,1203,1209,1212,1219,1222,1226,1231,1234,1241, + 1244,1268,1282,1286,1290,1310,1312,1314,1323,1325,1334,1336,1345, + 1347,1352,1361,1370,1379,1390,1396,1401,1404,1417,1427,1431,1436, + 1447,1452,1485,1493,1498,1502,1506,1511,1514,1519,1524,1529,1533, + 1542,1545,1549,1556,1565,1569,1573,1580,1583,1593,1600,1605,1610, + 1615,1621,1624,1633,1636,1639,1645,1650,1660,1663,1666,1670,1680, + 1683,1689,1695,1698,1701,1705,1715,1726,1731,1734,1738,1745,1755, + 1767,1773,1775,1784,1787,1794,1804,1810,1818,1829,1839,1850,1852, + 1858,1863,1873,1876,1882,1884,1892,1898,1901,1903,1915,1922,1926, + 1930,1934,1937,1944,1953,1956,1960,1965,1969,1972,1979,1990,1993, + 1997,2001,2010,2013,2020,2034,2038,2042,2046,2050,2054,2058,2062, + 2072,2083,2088,2101,2103,2109,2113,2115,2123,2130,2135,2148,2154, + 2162,2169,2173,2181,2183,2194,2202,2211,2217,2222,2228,2234,2239, + 2244,2250,2261,2263,2290,2296,2300,2312,2322,2325,2330,2337,2340, + 2349,2352,2356,2359,2371,2374,2393,2397,2405,2409,2434,2437,2446, + 2452,2458,2464,2475,2484,2506,2509,2512,2522,2524,2531,2533,2555, + 2584,2591,2599,2604,2606,2612,2619,2625,2647,2650,2659,2662,2665, + 2685,2696,2703,2710,2724,2726,2735,2744,2751,2754,2758,2762,2765 ]; private static __ATN: antlr.ATN; @@ -14668,11 +14713,8 @@ export class CreateKuduTableAsSelectContext extends antlr.ParserRuleContext { public kuduPartitionClause(): KuduPartitionClauseContext | null { return this.getRuleContext(0, KuduPartitionClauseContext); } - public KW_COMMENT(): antlr.TerminalNode | null { - return this.getToken(ImpalaSqlParser.KW_COMMENT, 0); - } - public stringLiteral(): StringLiteralContext | null { - return this.getRuleContext(0, StringLiteralContext); + public commentClause(): CommentClauseContext | null { + return this.getRuleContext(0, CommentClauseContext); } public KW_TBLPROPERTIES(): antlr.TerminalNode | null { return this.getToken(ImpalaSqlParser.KW_TBLPROPERTIES, 0); @@ -14750,11 +14792,8 @@ export class CreateViewContext extends antlr.ParserRuleContext { public viewColumns(): ViewColumnsContext | null { return this.getRuleContext(0, ViewColumnsContext); } - public KW_COMMENT(): antlr.TerminalNode | null { - return this.getToken(ImpalaSqlParser.KW_COMMENT, 0); - } - public stringLiteral(): StringLiteralContext | null { - return this.getRuleContext(0, StringLiteralContext); + public commentClause(): CommentClauseContext | null { + return this.getRuleContext(0, CommentClauseContext); } public KW_TBLPROPERTIES(): antlr.TerminalNode | null { return this.getToken(ImpalaSqlParser.KW_TBLPROPERTIES, 0); @@ -14786,7 +14825,6 @@ export class CreateViewContext extends antlr.ParserRuleContext { export class CreateSchemaContext extends antlr.ParserRuleContext { - public _comment?: StringLiteralContext; public _location?: StringLiteralContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -14806,20 +14844,14 @@ export class CreateSchemaContext extends antlr.ParserRuleContext { public ifNotExists(): IfNotExistsContext | null { return this.getRuleContext(0, IfNotExistsContext); } - public KW_COMMENT(): antlr.TerminalNode | null { - return this.getToken(ImpalaSqlParser.KW_COMMENT, 0); + public commentClause(): CommentClauseContext | null { + return this.getRuleContext(0, CommentClauseContext); } public KW_LOCATION(): antlr.TerminalNode | null { return this.getToken(ImpalaSqlParser.KW_LOCATION, 0); } - public stringLiteral(): StringLiteralContext[]; - public stringLiteral(i: number): StringLiteralContext | null; - public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null { - if (i === undefined) { - return this.getRuleContexts(StringLiteralContext); - } - - return this.getRuleContext(i, StringLiteralContext); + public stringLiteral(): StringLiteralContext | null { + return this.getRuleContext(0, StringLiteralContext); } public override get ruleIndex(): number { return ImpalaSqlParser.RULE_createSchema; @@ -14882,6 +14914,7 @@ export class CreateRoleContext extends antlr.ParserRuleContext { export class CreateAggregateFunctionContext extends antlr.ParserRuleContext { + public _returnType?: TypeContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -14897,15 +14930,6 @@ export class CreateAggregateFunctionContext extends antlr.ParserRuleContext { public KW_RETURNS(): antlr.TerminalNode { return this.getToken(ImpalaSqlParser.KW_RETURNS, 0)!; } - public type_(): TypeContext[]; - public type_(i: number): TypeContext | null; - public type_(i?: number): TypeContext[] | TypeContext | null { - if (i === undefined) { - return this.getRuleContexts(TypeContext); - } - - return this.getRuleContext(i, TypeContext); - } public KW_LOCATION(): antlr.TerminalNode { return this.getToken(ImpalaSqlParser.KW_LOCATION, 0)!; } @@ -14933,6 +14957,15 @@ export class CreateAggregateFunctionContext extends antlr.ParserRuleContext { public KW_MERGE_FN(): antlr.TerminalNode { return this.getToken(ImpalaSqlParser.KW_MERGE_FN, 0)!; } + public type_(): TypeContext[]; + public type_(i: number): TypeContext | null; + public type_(i?: number): TypeContext[] | TypeContext | null { + if (i === undefined) { + return this.getRuleContexts(TypeContext); + } + + return this.getRuleContext(i, TypeContext); + } public KW_AGGREGATE(): antlr.TerminalNode | null { return this.getToken(ImpalaSqlParser.KW_AGGREGATE, 0); } @@ -14996,6 +15029,7 @@ export class CreateAggregateFunctionContext extends antlr.ParserRuleContext { export class CreateFunctionContext extends antlr.ParserRuleContext { + public _returnType?: TypeContext; public _symbol_?: StringLiteralContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -19157,7 +19191,6 @@ export class TableOrViewPathContext extends antlr.ParserRuleContext { export class CreateCommonItemContext extends antlr.ParserRuleContext { - public _comment?: StringLiteralContext; public _serdProp?: PropertiesContext; public _location?: StringLiteralContext; public _cacheName?: QualifiedNameContext; @@ -19174,8 +19207,8 @@ export class CreateCommonItemContext extends antlr.ParserRuleContext { public columnAliases(): ColumnAliasesContext | null { return this.getRuleContext(0, ColumnAliasesContext); } - public KW_COMMENT(): antlr.TerminalNode | null { - return this.getToken(ImpalaSqlParser.KW_COMMENT, 0); + public commentClause(): CommentClauseContext | null { + return this.getRuleContext(0, CommentClauseContext); } public KW_ROW(): antlr.TerminalNode | null { return this.getToken(ImpalaSqlParser.KW_ROW, 0); @@ -19222,15 +19255,6 @@ export class CreateCommonItemContext extends antlr.ParserRuleContext { public KW_TBLPROPERTIES(): antlr.TerminalNode | null { return this.getToken(ImpalaSqlParser.KW_TBLPROPERTIES, 0); } - public stringLiteral(): StringLiteralContext[]; - public stringLiteral(i: number): StringLiteralContext | null; - public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null { - if (i === undefined) { - return this.getRuleContexts(StringLiteralContext); - } - - return this.getRuleContext(i, StringLiteralContext); - } public properties(): PropertiesContext[]; public properties(i: number): PropertiesContext | null; public properties(i?: number): PropertiesContext[] | PropertiesContext | null { @@ -19240,6 +19264,9 @@ export class CreateCommonItemContext extends antlr.ParserRuleContext { return this.getRuleContext(i, PropertiesContext); } + public stringLiteral(): StringLiteralContext | null { + return this.getRuleContext(0, StringLiteralContext); + } public qualifiedName(): QualifiedNameContext | null { return this.getRuleContext(0, QualifiedNameContext); } @@ -19363,35 +19390,17 @@ export class ViewColumnsContext extends antlr.ParserRuleContext { public LPAREN(): antlr.TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0)!; } - public columnNamePathCreate(): ColumnNamePathCreateContext[]; - public columnNamePathCreate(i: number): ColumnNamePathCreateContext | null; - public columnNamePathCreate(i?: number): ColumnNamePathCreateContext[] | ColumnNamePathCreateContext | null { - if (i === undefined) { - return this.getRuleContexts(ColumnNamePathCreateContext); - } - - return this.getRuleContext(i, ColumnNamePathCreateContext); - } public RPAREN(): antlr.TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0)!; } - public KW_COMMENT(): antlr.TerminalNode[]; - public KW_COMMENT(i: number): antlr.TerminalNode | null; - public KW_COMMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(ImpalaSqlParser.KW_COMMENT); - } else { - return this.getToken(ImpalaSqlParser.KW_COMMENT, i); - } - } - public stringLiteral(): StringLiteralContext[]; - public stringLiteral(i: number): StringLiteralContext | null; - public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null { + public viewColumnItem(): ViewColumnItemContext[]; + public viewColumnItem(i: number): ViewColumnItemContext | null; + public viewColumnItem(i?: number): ViewColumnItemContext[] | ViewColumnItemContext | null { if (i === undefined) { - return this.getRuleContexts(StringLiteralContext); + return this.getRuleContexts(ViewColumnItemContext); } - return this.getRuleContext(i, StringLiteralContext); + return this.getRuleContext(i, ViewColumnItemContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -19425,6 +19434,39 @@ export class ViewColumnsContext extends antlr.ParserRuleContext { } +export class ViewColumnItemContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public columnNamePathCreate(): ColumnNamePathCreateContext { + return this.getRuleContext(0, ColumnNamePathCreateContext)!; + } + public commentClause(): CommentClauseContext | null { + return this.getRuleContext(0, CommentClauseContext); + } + public override get ruleIndex(): number { + return ImpalaSqlParser.RULE_viewColumnItem; + } + public override enterRule(listener: ImpalaSqlParserListener): void { + if(listener.enterViewColumnItem) { + listener.enterViewColumnItem(this); + } + } + public override exitRule(listener: ImpalaSqlParserListener): void { + if(listener.exitViewColumnItem) { + listener.exitViewColumnItem(this); + } + } + public override accept(visitor: ImpalaSqlParserVisitor): Result | null { + if (visitor.visitViewColumnItem) { + return visitor.visitViewColumnItem(this); + } else { + return visitor.visitChildren(this); + } + } +} + + export class QueryStatementContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -19666,6 +19708,7 @@ export class ColumnSpecContext extends antlr.ParserRuleContext { export class ColumnDefinitionContext extends antlr.ParserRuleContext { + public _colType?: TypeContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -19675,11 +19718,8 @@ export class ColumnDefinitionContext extends antlr.ParserRuleContext { public type(): TypeContext { return this.getRuleContext(0, TypeContext)!; } - public KW_COMMENT(): antlr.TerminalNode | null { - return this.getToken(ImpalaSqlParser.KW_COMMENT, 0); - } - public stringLiteral(): StringLiteralContext | null { - return this.getRuleContext(0, StringLiteralContext); + public commentClause(): CommentClauseContext | null { + return this.getRuleContext(0, CommentClauseContext); } public override get ruleIndex(): number { return ImpalaSqlParser.RULE_columnDefinition; @@ -19735,6 +19775,7 @@ export class KuduTableElementContext extends antlr.ParserRuleContext { export class KuduColumnDefinitionContext extends antlr.ParserRuleContext { + public _colType?: TypeContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -19753,11 +19794,8 @@ export class KuduColumnDefinitionContext extends antlr.ParserRuleContext { return this.getRuleContext(i, KuduAttributesContext); } - public KW_COMMENT(): antlr.TerminalNode | null { - return this.getToken(ImpalaSqlParser.KW_COMMENT, 0); - } - public stringLiteral(): StringLiteralContext | null { - return this.getRuleContext(0, StringLiteralContext); + public commentClause(): CommentClauseContext | null { + return this.getRuleContext(0, CommentClauseContext); } public KW_PRIMARY(): antlr.TerminalNode | null { return this.getToken(ImpalaSqlParser.KW_PRIMARY, 0); @@ -19788,6 +19826,40 @@ export class KuduColumnDefinitionContext extends antlr.ParserRuleContext { } +export class CommentClauseContext extends antlr.ParserRuleContext { + public _comment?: StringLiteralContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_COMMENT(): antlr.TerminalNode { + return this.getToken(ImpalaSqlParser.KW_COMMENT, 0)!; + } + public stringLiteral(): StringLiteralContext { + return this.getRuleContext(0, StringLiteralContext)!; + } + public override get ruleIndex(): number { + return ImpalaSqlParser.RULE_commentClause; + } + public override enterRule(listener: ImpalaSqlParserListener): void { + if(listener.enterCommentClause) { + listener.enterCommentClause(this); + } + } + public override exitRule(listener: ImpalaSqlParserListener): void { + if(listener.exitCommentClause) { + listener.exitCommentClause(this); + } + } + public override accept(visitor: ImpalaSqlParserVisitor): Result | null { + if (visitor.visitCommentClause) { + return visitor.visitCommentClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + export class ColumnSpecWithKuduContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -21704,6 +21776,7 @@ export class SampleTypeContext extends antlr.ParserRuleContext { export class AliasedRelationContext extends antlr.ParserRuleContext { + public _alias?: IdentifierContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } diff --git a/src/lib/impala/ImpalaSqlParserListener.ts b/src/lib/impala/ImpalaSqlParserListener.ts index 1856fd2c..bb825fcf 100644 --- a/src/lib/impala/ImpalaSqlParserListener.ts +++ b/src/lib/impala/ImpalaSqlParserListener.ts @@ -110,6 +110,7 @@ import { CreateCommonItemContext } from "./ImpalaSqlParser.js"; import { AssignmentListContext } from "./ImpalaSqlParser.js"; import { AssignmentItemContext } from "./ImpalaSqlParser.js"; import { ViewColumnsContext } from "./ImpalaSqlParser.js"; +import { ViewColumnItemContext } from "./ImpalaSqlParser.js"; import { QueryStatementContext } from "./ImpalaSqlParser.js"; import { WithContext } from "./ImpalaSqlParser.js"; import { ConstraintSpecificationContext } from "./ImpalaSqlParser.js"; @@ -118,6 +119,7 @@ import { ColumnSpecContext } from "./ImpalaSqlParser.js"; import { ColumnDefinitionContext } from "./ImpalaSqlParser.js"; import { KuduTableElementContext } from "./ImpalaSqlParser.js"; import { KuduColumnDefinitionContext } from "./ImpalaSqlParser.js"; +import { CommentClauseContext } from "./ImpalaSqlParser.js"; import { ColumnSpecWithKuduContext } from "./ImpalaSqlParser.js"; import { CreateColumnSpecWithKuduContext } from "./ImpalaSqlParser.js"; import { KuduAttributesContext } from "./ImpalaSqlParser.js"; @@ -1276,6 +1278,16 @@ export class ImpalaSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitViewColumns?: (ctx: ViewColumnsContext) => void; + /** + * Enter a parse tree produced by `ImpalaSqlParser.viewColumnItem`. + * @param ctx the parse tree + */ + enterViewColumnItem?: (ctx: ViewColumnItemContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.viewColumnItem`. + * @param ctx the parse tree + */ + exitViewColumnItem?: (ctx: ViewColumnItemContext) => void; /** * Enter a parse tree produced by `ImpalaSqlParser.queryStatement`. * @param ctx the parse tree @@ -1356,6 +1368,16 @@ export class ImpalaSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitKuduColumnDefinition?: (ctx: KuduColumnDefinitionContext) => void; + /** + * Enter a parse tree produced by `ImpalaSqlParser.commentClause`. + * @param ctx the parse tree + */ + enterCommentClause?: (ctx: CommentClauseContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.commentClause`. + * @param ctx the parse tree + */ + exitCommentClause?: (ctx: CommentClauseContext) => void; /** * Enter a parse tree produced by `ImpalaSqlParser.columnSpecWithKudu`. * @param ctx the parse tree diff --git a/src/lib/impala/ImpalaSqlParserVisitor.ts b/src/lib/impala/ImpalaSqlParserVisitor.ts index bf441a95..b97a3764 100644 --- a/src/lib/impala/ImpalaSqlParserVisitor.ts +++ b/src/lib/impala/ImpalaSqlParserVisitor.ts @@ -110,6 +110,7 @@ import { CreateCommonItemContext } from "./ImpalaSqlParser.js"; import { AssignmentListContext } from "./ImpalaSqlParser.js"; import { AssignmentItemContext } from "./ImpalaSqlParser.js"; import { ViewColumnsContext } from "./ImpalaSqlParser.js"; +import { ViewColumnItemContext } from "./ImpalaSqlParser.js"; import { QueryStatementContext } from "./ImpalaSqlParser.js"; import { WithContext } from "./ImpalaSqlParser.js"; import { ConstraintSpecificationContext } from "./ImpalaSqlParser.js"; @@ -118,6 +119,7 @@ import { ColumnSpecContext } from "./ImpalaSqlParser.js"; import { ColumnDefinitionContext } from "./ImpalaSqlParser.js"; import { KuduTableElementContext } from "./ImpalaSqlParser.js"; import { KuduColumnDefinitionContext } from "./ImpalaSqlParser.js"; +import { CommentClauseContext } from "./ImpalaSqlParser.js"; import { ColumnSpecWithKuduContext } from "./ImpalaSqlParser.js"; import { CreateColumnSpecWithKuduContext } from "./ImpalaSqlParser.js"; import { KuduAttributesContext } from "./ImpalaSqlParser.js"; @@ -871,6 +873,12 @@ export class ImpalaSqlParserVisitor extends AbstractParseTreeVisitor Result; + /** + * Visit a parse tree produced by `ImpalaSqlParser.viewColumnItem`. + * @param ctx the parse tree + * @return the visitor result + */ + visitViewColumnItem?: (ctx: ViewColumnItemContext) => Result; /** * Visit a parse tree produced by `ImpalaSqlParser.queryStatement`. * @param ctx the parse tree @@ -919,6 +927,12 @@ export class ImpalaSqlParserVisitor extends AbstractParseTreeVisitor Result; + /** + * Visit a parse tree produced by `ImpalaSqlParser.commentClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCommentClause?: (ctx: CommentClauseContext) => Result; /** * Visit a parse tree produced by `ImpalaSqlParser.columnSpecWithKudu`. * @param ctx the parse tree diff --git a/src/lib/index.ts b/src/lib/index.ts index c2b48709..6dde0824 100644 --- a/src/lib/index.ts +++ b/src/lib/index.ts @@ -17,4 +17,7 @@ export { TrinoSqlListener } from './trino/TrinoSqlListener'; export { TrinoSqlVisitor } from './trino/TrinoSqlVisitor'; export { ImpalaSqlParserListener } from './impala/ImpalaSqlParserListener'; -export { ImpalaSqlParserVisitor } from './impala/ImpalaSqlParserVisitor'; \ No newline at end of file +export { ImpalaSqlParserVisitor } from './impala/ImpalaSqlParserVisitor'; + +export { SqlParserListener } from './sql/SqlParserListener'; +export { SqlParserVisitor } from './sql/SqlParserVisitor'; diff --git a/src/lib/mysql/MySqlParser.ts b/src/lib/mysql/MySqlParser.ts index 91a3913e..e298265c 100644 --- a/src/lib/mysql/MySqlParser.ts +++ b/src/lib/mysql/MySqlParser.ts @@ -6703,7 +6703,7 @@ export class MySqlParser extends SQLParserBase { this.state = 1697; this.match(MySqlParser.KW_COMMENT); this.state = 1698; - this.match(MySqlParser.STRING_LITERAL); + (localContext as RoutineCommentContext)._comment = this.match(MySqlParser.STRING_LITERAL); } break; case MySqlParser.KW_LANGUAGE: @@ -7368,7 +7368,7 @@ export class MySqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 1); { this.state = 1851; - this.dataType(); + localContext._colType = this.dataType(); this.state = 1855; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 172, this.context); @@ -7518,7 +7518,7 @@ export class MySqlParser extends SQLParserBase { this.state = 1877; this.match(MySqlParser.KW_COMMENT); this.state = 1878; - this.match(MySqlParser.STRING_LITERAL); + (localContext as CommentColumnConstraintContext)._comment = this.match(MySqlParser.STRING_LITERAL); } break; case MySqlParser.KW_COLUMN_FORMAT: @@ -8149,7 +8149,7 @@ export class MySqlParser extends SQLParserBase { } this.state = 1998; - this.match(MySqlParser.STRING_LITERAL); + (localContext as TableOptionCommentContext)._comment = this.match(MySqlParser.STRING_LITERAL); } break; case 10: @@ -55075,6 +55075,7 @@ export class RoutineLanguageContext extends RoutineOptionContext { } } export class RoutineCommentContext extends RoutineOptionContext { + public _comment?: Token | null; public constructor(ctx: RoutineOptionContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); @@ -55463,6 +55464,7 @@ export class ConstraintSymbolContext extends antlr.ParserRuleContext { export class ColumnDefinitionContext extends antlr.ParserRuleContext { + public _colType?: DataTypeContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -55610,6 +55612,7 @@ export class AutoIncrementColumnConstraintContext extends ColumnConstraintContex } } export class CommentColumnConstraintContext extends ColumnConstraintContext { + public _comment?: Token | null; public constructor(ctx: ColumnConstraintContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); @@ -57075,6 +57078,7 @@ export class TableOptionSecondaryEngineAttributeContext extends TableOptionConte } } export class TableOptionCommentContext extends TableOptionContext { + public _comment?: Token | null; public constructor(ctx: TableOptionContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); diff --git a/src/lib/postgresql/PostgreSqlParser.interp b/src/lib/postgresql/PostgreSqlParser.interp index 1a1329b5..6074781b 100644 --- a/src/lib/postgresql/PostgreSqlParser.interp +++ b/src/lib/postgresql/PostgreSqlParser.interp @@ -1654,4 +1654,4 @@ sql_expression atn: -[4, 1, 590, 8495, 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, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, 464, 7, 464, 2, 465, 7, 465, 1, 0, 5, 0, 934, 8, 0, 10, 0, 12, 0, 937, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 943, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1063, 8, 2, 3, 2, 1065, 8, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1074, 8, 4, 1, 4, 5, 4, 1077, 8, 4, 10, 4, 12, 4, 1080, 9, 4, 1, 5, 1, 5, 1, 5, 3, 5, 1085, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1120, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 1130, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 1136, 8, 7, 1, 7, 5, 7, 1139, 8, 7, 10, 7, 12, 7, 1142, 9, 7, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1148, 8, 8, 1, 8, 5, 8, 1151, 8, 8, 10, 8, 12, 8, 1154, 9, 8, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 1160, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 1171, 8, 10, 1, 10, 1, 10, 1, 11, 1, 11, 5, 11, 1177, 8, 11, 10, 11, 12, 11, 1180, 9, 11, 1, 11, 3, 11, 1183, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1195, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1201, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1207, 8, 12, 1, 12, 1, 12, 3, 12, 1211, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1216, 8, 12, 1, 12, 1, 12, 3, 12, 1220, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1233, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1243, 8, 12, 3, 12, 1245, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1251, 8, 13, 1, 13, 5, 13, 1254, 8, 13, 10, 13, 12, 13, 1257, 9, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 3, 15, 1269, 8, 15, 1, 15, 3, 15, 1272, 8, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1277, 8, 15, 1, 15, 5, 15, 1280, 8, 15, 10, 15, 12, 15, 1283, 9, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1293, 8, 17, 1, 18, 1, 18, 3, 18, 1297, 8, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 1309, 8, 19, 1, 20, 1, 20, 3, 20, 1313, 8, 20, 1, 20, 3, 20, 1316, 8, 20, 1, 20, 1, 20, 3, 20, 1320, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 1332, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 1350, 8, 21, 1, 22, 1, 22, 1, 22, 5, 22, 1355, 8, 22, 10, 22, 12, 22, 1358, 9, 22, 1, 23, 1, 23, 1, 23, 5, 23, 1363, 8, 23, 10, 23, 12, 23, 1366, 9, 23, 1, 24, 1, 24, 3, 24, 1370, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1377, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 1385, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 1391, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1399, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1407, 8, 28, 1, 29, 1, 29, 3, 29, 1411, 8, 29, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 1425, 8, 31, 1, 32, 1, 32, 1, 32, 3, 32, 1430, 8, 32, 1, 33, 1, 33, 1, 33, 3, 33, 1435, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1447, 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 1453, 8, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 3, 38, 1465, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1470, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1480, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1486, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1491, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1499, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1504, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1511, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1516, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1521, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1531, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1536, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1541, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1548, 8, 38, 1, 38, 1, 38, 3, 38, 1552, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1566, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1572, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1578, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1583, 8, 38, 1, 39, 1, 39, 1, 39, 5, 39, 1588, 8, 39, 10, 39, 12, 39, 1591, 9, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1602, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 5, 41, 1608, 8, 41, 10, 41, 12, 41, 1611, 9, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 3, 42, 1618, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1634, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 3, 46, 1643, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 5, 46, 1650, 8, 46, 10, 46, 12, 46, 1653, 9, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1661, 8, 46, 1, 46, 1, 46, 3, 46, 1665, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1677, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1685, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1695, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1715, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1720, 8, 46, 1, 46, 3, 46, 1723, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1730, 8, 46, 1, 46, 3, 46, 1733, 8, 46, 1, 46, 1, 46, 3, 46, 1737, 8, 46, 1, 46, 1, 46, 3, 46, 1741, 8, 46, 1, 46, 3, 46, 1744, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1749, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1754, 8, 46, 1, 46, 1, 46, 3, 46, 1758, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1767, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1773, 8, 46, 1, 46, 1, 46, 3, 46, 1777, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1786, 8, 46, 1, 46, 3, 46, 1789, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1795, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1804, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 4, 46, 1814, 8, 46, 11, 46, 12, 46, 1815, 1, 46, 1, 46, 3, 46, 1820, 8, 46, 1, 46, 1, 46, 3, 46, 1824, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1829, 8, 46, 1, 46, 3, 46, 1832, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1838, 8, 46, 4, 46, 1840, 8, 46, 11, 46, 12, 46, 1841, 1, 46, 1, 46, 3, 46, 1846, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1852, 8, 46, 1, 46, 1, 46, 3, 46, 1856, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1861, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1866, 8, 46, 1, 46, 1, 46, 3, 46, 1870, 8, 46, 1, 46, 3, 46, 1873, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1880, 8, 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 5, 50, 1891, 8, 50, 10, 50, 12, 50, 1894, 9, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1906, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 5, 53, 1918, 8, 53, 10, 53, 12, 53, 1921, 9, 53, 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, 53, 1, 53, 3, 53, 1937, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1945, 8, 54, 10, 54, 12, 54, 1948, 9, 54, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1954, 8, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1959, 8, 55, 1, 55, 1, 55, 3, 55, 1963, 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1970, 8, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1975, 8, 55, 1, 55, 3, 55, 1978, 8, 55, 3, 55, 1980, 8, 55, 1, 56, 1, 56, 1, 56, 3, 56, 1985, 8, 56, 1, 57, 1, 57, 3, 57, 1989, 8, 57, 1, 57, 1, 57, 3, 57, 1993, 8, 57, 1, 57, 1, 57, 3, 57, 1997, 8, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2002, 8, 57, 1, 57, 3, 57, 2005, 8, 57, 1, 57, 1, 57, 3, 57, 2009, 8, 57, 1, 57, 3, 57, 2012, 8, 57, 1, 57, 1, 57, 3, 57, 2016, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2024, 8, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2029, 8, 57, 1, 57, 3, 57, 2032, 8, 57, 1, 57, 1, 57, 3, 57, 2036, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 2042, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 2051, 8, 58, 1, 58, 1, 58, 3, 58, 2055, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 5, 58, 2061, 8, 58, 10, 58, 12, 58, 2064, 9, 58, 1, 58, 1, 58, 1, 58, 1, 58, 5, 58, 2070, 8, 58, 10, 58, 12, 58, 2073, 9, 58, 1, 58, 1, 58, 3, 58, 2077, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2087, 8, 59, 10, 59, 12, 59, 2090, 9, 59, 1, 59, 1, 59, 3, 59, 2094, 8, 59, 1, 60, 1, 60, 3, 60, 2098, 8, 60, 1, 60, 1, 60, 3, 60, 2102, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2107, 8, 60, 1, 60, 1, 60, 3, 60, 2111, 8, 60, 1, 60, 3, 60, 2114, 8, 60, 1, 60, 3, 60, 2117, 8, 60, 1, 60, 3, 60, 2120, 8, 60, 1, 60, 3, 60, 2123, 8, 60, 1, 60, 3, 60, 2126, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2131, 8, 60, 1, 60, 3, 60, 2134, 8, 60, 1, 60, 3, 60, 2137, 8, 60, 1, 60, 3, 60, 2140, 8, 60, 1, 60, 3, 60, 2143, 8, 60, 1, 60, 3, 60, 2146, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2152, 8, 60, 1, 60, 1, 60, 3, 60, 2156, 8, 60, 1, 60, 3, 60, 2159, 8, 60, 1, 60, 3, 60, 2162, 8, 60, 1, 60, 3, 60, 2165, 8, 60, 1, 60, 3, 60, 2168, 8, 60, 3, 60, 2170, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 2177, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 5, 62, 2183, 8, 62, 10, 62, 12, 62, 2186, 9, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 5, 63, 2193, 8, 63, 10, 63, 12, 63, 2196, 9, 63, 1, 64, 1, 64, 3, 64, 2200, 8, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 5, 64, 2208, 8, 64, 10, 64, 12, 64, 2211, 9, 64, 3, 64, 2213, 8, 64, 1, 65, 1, 65, 1, 65, 3, 65, 2218, 8, 65, 1, 65, 5, 65, 2221, 8, 65, 10, 65, 12, 65, 2224, 9, 65, 1, 65, 1, 65, 3, 65, 2228, 8, 65, 1, 65, 3, 65, 2231, 8, 65, 1, 66, 1, 66, 1, 66, 3, 66, 2236, 8, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 2245, 8, 66, 3, 66, 2247, 8, 66, 1, 66, 1, 66, 3, 66, 2251, 8, 66, 1, 66, 3, 66, 2254, 8, 66, 1, 66, 1, 66, 3, 66, 2258, 8, 66, 1, 66, 5, 66, 2261, 8, 66, 10, 66, 12, 66, 2264, 9, 66, 1, 67, 1, 67, 3, 67, 2268, 8, 67, 1, 67, 1, 67, 3, 67, 2272, 8, 67, 1, 67, 3, 67, 2275, 8, 67, 1, 67, 1, 67, 3, 67, 2279, 8, 67, 1, 68, 3, 68, 2282, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2287, 8, 68, 1, 68, 3, 68, 2290, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2295, 8, 68, 1, 68, 3, 68, 2298, 8, 68, 1, 68, 1, 68, 3, 68, 2302, 8, 68, 1, 68, 3, 68, 2305, 8, 68, 1, 68, 3, 68, 2308, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2313, 8, 68, 1, 68, 3, 68, 2316, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2324, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 4, 68, 2334, 8, 68, 11, 68, 12, 68, 2335, 1, 68, 1, 68, 3, 68, 2340, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2347, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2352, 8, 68, 1, 68, 3, 68, 2355, 8, 68, 1, 68, 3, 68, 2358, 8, 68, 1, 68, 3, 68, 2361, 8, 68, 1, 69, 1, 69, 1, 69, 3, 69, 2366, 8, 69, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2375, 8, 71, 10, 71, 12, 71, 2378, 9, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2383, 8, 71, 1, 71, 1, 71, 3, 71, 2387, 8, 71, 1, 71, 3, 71, 2390, 8, 71, 1, 71, 3, 71, 2393, 8, 71, 1, 71, 5, 71, 2396, 8, 71, 10, 71, 12, 71, 2399, 9, 71, 1, 71, 1, 71, 5, 71, 2403, 8, 71, 10, 71, 12, 71, 2406, 9, 71, 3, 71, 2408, 8, 71, 1, 71, 1, 71, 3, 71, 2412, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2418, 8, 71, 10, 71, 12, 71, 2421, 9, 71, 1, 71, 1, 71, 3, 71, 2425, 8, 71, 1, 71, 3, 71, 2428, 8, 71, 1, 71, 3, 71, 2431, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2438, 8, 71, 1, 71, 5, 71, 2441, 8, 71, 10, 71, 12, 71, 2444, 9, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2452, 8, 71, 1, 71, 3, 71, 2455, 8, 71, 1, 71, 3, 71, 2458, 8, 71, 1, 71, 5, 71, 2461, 8, 71, 10, 71, 12, 71, 2464, 9, 71, 3, 71, 2466, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 5, 73, 2476, 8, 73, 10, 73, 12, 73, 2479, 9, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 5, 74, 2486, 8, 74, 10, 74, 12, 74, 2489, 9, 74, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2505, 8, 77, 1, 78, 1, 78, 3, 78, 2509, 8, 78, 1, 78, 1, 78, 3, 78, 2513, 8, 78, 3, 78, 2515, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2532, 8, 81, 3, 81, 2534, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 5, 83, 2548, 8, 83, 10, 83, 12, 83, 2551, 9, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 2561, 8, 84, 1, 84, 3, 84, 2564, 8, 84, 1, 84, 3, 84, 2567, 8, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 2576, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2585, 8, 87, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 3, 91, 2601, 8, 91, 1, 91, 3, 91, 2604, 8, 91, 1, 91, 3, 91, 2607, 8, 91, 1, 91, 1, 91, 1, 91, 1, 91, 5, 91, 2613, 8, 91, 10, 91, 12, 91, 2616, 9, 91, 1, 91, 3, 91, 2619, 8, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 3, 92, 2626, 8, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 3, 93, 2635, 8, 93, 1, 93, 1, 93, 3, 93, 2639, 8, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 2645, 8, 93, 1, 94, 1, 94, 3, 94, 2649, 8, 94, 1, 94, 3, 94, 2652, 8, 94, 1, 94, 3, 94, 2655, 8, 94, 1, 94, 3, 94, 2658, 8, 94, 1, 94, 3, 94, 2661, 8, 94, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 2667, 8, 95, 1, 96, 1, 96, 3, 96, 2671, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2676, 8, 96, 1, 96, 1, 96, 3, 96, 2680, 8, 96, 1, 96, 3, 96, 2683, 8, 96, 1, 96, 3, 96, 2686, 8, 96, 1, 96, 3, 96, 2689, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2694, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 2700, 8, 97, 1, 97, 1, 97, 3, 97, 2704, 8, 97, 1, 98, 1, 98, 3, 98, 2708, 8, 98, 1, 98, 1, 98, 3, 98, 2712, 8, 98, 1, 98, 1, 98, 4, 98, 2716, 8, 98, 11, 98, 12, 98, 2717, 3, 98, 2720, 8, 98, 1, 99, 1, 99, 1, 99, 3, 99, 2725, 8, 99, 1, 99, 1, 99, 4, 99, 2729, 8, 99, 11, 99, 12, 99, 2730, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2737, 8, 100, 1, 100, 1, 100, 3, 100, 2741, 8, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2756, 8, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2761, 8, 100, 1, 100, 3, 100, 2764, 8, 100, 3, 100, 2766, 8, 100, 1, 101, 3, 101, 2769, 8, 101, 1, 101, 1, 101, 3, 101, 2773, 8, 101, 1, 102, 1, 102, 3, 102, 2777, 8, 102, 1, 102, 3, 102, 2780, 8, 102, 1, 102, 3, 102, 2783, 8, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2791, 8, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2797, 8, 102, 3, 102, 2799, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2805, 8, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2810, 8, 103, 1, 104, 1, 104, 1, 104, 3, 104, 2815, 8, 104, 1, 104, 1, 104, 3, 104, 2819, 8, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 5, 104, 2826, 8, 104, 10, 104, 12, 104, 2829, 9, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2837, 8, 105, 10, 105, 12, 105, 2840, 9, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2878, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 4, 107, 2886, 8, 107, 11, 107, 12, 107, 2887, 3, 107, 2890, 8, 107, 1, 107, 3, 107, 2893, 8, 107, 1, 108, 1, 108, 3, 108, 2897, 8, 108, 1, 108, 1, 108, 3, 108, 2901, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 4, 109, 2909, 8, 109, 11, 109, 12, 109, 2910, 3, 109, 2913, 8, 109, 1, 109, 1, 109, 4, 109, 2917, 8, 109, 11, 109, 12, 109, 2918, 3, 109, 2921, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 2928, 8, 110, 10, 110, 12, 110, 2931, 9, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 2940, 8, 111, 10, 111, 12, 111, 2943, 9, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 3, 114, 2956, 8, 114, 1, 114, 1, 114, 1, 114, 3, 114, 2961, 8, 114, 1, 114, 3, 114, 2964, 8, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 2971, 8, 114, 1, 115, 1, 115, 1, 115, 3, 115, 2976, 8, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2984, 8, 116, 3, 116, 2986, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2992, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2997, 8, 117, 1, 117, 1, 117, 3, 117, 3001, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3006, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3012, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3019, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3025, 8, 117, 3, 117, 3027, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3036, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3042, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3050, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3056, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3061, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3066, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 3074, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 3089, 8, 121, 3, 121, 3091, 8, 121, 1, 121, 1, 121, 3, 121, 3095, 8, 121, 1, 121, 1, 121, 3, 121, 3099, 8, 121, 1, 121, 3, 121, 3102, 8, 121, 1, 121, 3, 121, 3105, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3114, 8, 122, 1, 122, 3, 122, 3117, 8, 122, 1, 122, 3, 122, 3120, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3126, 8, 123, 1, 123, 1, 123, 5, 123, 3130, 8, 123, 10, 123, 12, 123, 3133, 9, 123, 1, 123, 3, 123, 3136, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3148, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3154, 8, 123, 1, 124, 3, 124, 3157, 8, 124, 1, 124, 1, 124, 1, 124, 3, 124, 3162, 8, 124, 1, 124, 1, 124, 3, 124, 3166, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 3173, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 3183, 8, 124, 3, 124, 3185, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 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, 127, 1, 128, 1, 128, 3, 128, 3209, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3221, 8, 128, 1, 128, 4, 128, 3224, 8, 128, 11, 128, 12, 128, 3225, 3, 128, 3228, 8, 128, 1, 128, 1, 128, 3, 128, 3232, 8, 128, 1, 128, 3, 128, 3235, 8, 128, 1, 128, 3, 128, 3238, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3248, 8, 128, 1, 128, 3, 128, 3251, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3261, 8, 128, 1, 128, 5, 128, 3264, 8, 128, 10, 128, 12, 128, 3267, 9, 128, 1, 128, 1, 128, 3, 128, 3271, 8, 128, 1, 128, 3, 128, 3274, 8, 128, 1, 128, 3, 128, 3277, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3285, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 3291, 8, 129, 1, 130, 1, 130, 1, 130, 5, 130, 3296, 8, 130, 10, 130, 12, 130, 3299, 9, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 3306, 8, 131, 1, 131, 3, 131, 3309, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 3320, 8, 133, 1, 134, 1, 134, 3, 134, 3324, 8, 134, 1, 134, 1, 134, 5, 134, 3328, 8, 134, 10, 134, 12, 134, 3331, 9, 134, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 3337, 8, 135, 1, 136, 3, 136, 3340, 8, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 3349, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 5, 137, 3361, 8, 137, 10, 137, 12, 137, 3364, 9, 137, 3, 137, 3366, 8, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 5, 138, 3378, 8, 138, 10, 138, 12, 138, 3381, 9, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 3391, 8, 139, 1, 139, 3, 139, 3394, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 5, 140, 3404, 8, 140, 10, 140, 12, 140, 3407, 9, 140, 1, 141, 1, 141, 3, 141, 3411, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 5, 141, 3422, 8, 141, 10, 141, 12, 141, 3425, 9, 141, 1, 141, 1, 141, 3, 141, 3429, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3442, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 5, 141, 3449, 8, 141, 10, 141, 12, 141, 3452, 9, 141, 3, 141, 3454, 8, 141, 1, 141, 3, 141, 3457, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3464, 8, 141, 1, 141, 3, 141, 3467, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3479, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3485, 8, 141, 3, 141, 3487, 8, 141, 1, 142, 1, 142, 1, 142, 1, 142, 5, 142, 3493, 8, 142, 10, 142, 12, 142, 3496, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 3, 143, 3503, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 3511, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3523, 8, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3528, 8, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3539, 8, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3550, 8, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3558, 8, 148, 1, 148, 1, 148, 1, 148, 1, 148, 5, 148, 3564, 8, 148, 10, 148, 12, 148, 3567, 9, 148, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3573, 8, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3580, 8, 149, 3, 149, 3582, 8, 149, 1, 149, 3, 149, 3585, 8, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3590, 8, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3595, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 3612, 8, 151, 10, 151, 12, 151, 3615, 9, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 3621, 8, 151, 10, 151, 12, 151, 3624, 9, 151, 3, 151, 3626, 8, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3653, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3662, 8, 154, 1, 154, 3, 154, 3665, 8, 154, 1, 154, 1, 154, 3, 154, 3669, 8, 154, 1, 154, 1, 154, 3, 154, 3673, 8, 154, 1, 154, 1, 154, 3, 154, 3677, 8, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3682, 8, 154, 10, 154, 12, 154, 3685, 9, 154, 1, 154, 3, 154, 3688, 8, 154, 1, 154, 1, 154, 3, 154, 3692, 8, 154, 1, 154, 1, 154, 3, 154, 3696, 8, 154, 1, 154, 1, 154, 3, 154, 3700, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3705, 8, 154, 1, 154, 1, 154, 3, 154, 3709, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3714, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3720, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3725, 8, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3730, 8, 154, 10, 154, 12, 154, 3733, 9, 154, 1, 154, 3, 154, 3736, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3742, 8, 154, 1, 154, 1, 154, 3, 154, 3746, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3751, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3759, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3765, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3770, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3777, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3782, 8, 154, 1, 154, 1, 154, 3, 154, 3786, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3791, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3797, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3804, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3809, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3816, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3821, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3828, 8, 154, 1, 154, 1, 154, 3, 154, 3832, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3838, 8, 154, 10, 154, 12, 154, 3841, 9, 154, 1, 154, 3, 154, 3844, 8, 154, 3, 154, 3846, 8, 154, 1, 155, 3, 155, 3849, 8, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3854, 8, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3864, 8, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 3879, 8, 156, 1, 156, 3, 156, 3882, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 3890, 8, 156, 1, 157, 1, 157, 1, 157, 5, 157, 3895, 8, 157, 10, 157, 12, 157, 3898, 9, 157, 1, 158, 1, 158, 3, 158, 3902, 8, 158, 1, 159, 1, 159, 4, 159, 3906, 8, 159, 11, 159, 12, 159, 3907, 1, 160, 1, 160, 3, 160, 3912, 8, 160, 1, 160, 1, 160, 1, 160, 5, 160, 3917, 8, 160, 10, 160, 12, 160, 3920, 9, 160, 1, 160, 1, 160, 3, 160, 3924, 8, 160, 1, 160, 3, 160, 3927, 8, 160, 1, 161, 3, 161, 3930, 8, 161, 1, 161, 1, 161, 3, 161, 3934, 8, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 3943, 8, 162, 1, 162, 1, 162, 1, 162, 1, 162, 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, 3961, 8, 162, 1, 162, 3, 162, 3964, 8, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 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, 3996, 8, 162, 1, 162, 1, 162, 1, 162, 3, 162, 4001, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4007, 8, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4027, 8, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4032, 8, 163, 1, 164, 1, 164, 1, 164, 1, 165, 3, 165, 4038, 8, 165, 1, 165, 3, 165, 4041, 8, 165, 1, 165, 1, 165, 3, 165, 4045, 8, 165, 1, 165, 1, 165, 3, 165, 4049, 8, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4055, 8, 165, 1, 165, 3, 165, 4058, 8, 165, 1, 165, 1, 165, 3, 165, 4062, 8, 165, 1, 165, 1, 165, 3, 165, 4066, 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4071, 8, 165, 1, 165, 3, 165, 4074, 8, 165, 1, 165, 3, 165, 4077, 8, 165, 1, 165, 3, 165, 4080, 8, 165, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 4093, 8, 167, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 4099, 8, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 4107, 8, 168, 1, 169, 1, 169, 1, 169, 5, 169, 4112, 8, 169, 10, 169, 12, 169, 4115, 9, 169, 1, 169, 1, 169, 3, 169, 4119, 8, 169, 1, 169, 3, 169, 4122, 8, 169, 1, 169, 1, 169, 1, 169, 5, 169, 4127, 8, 169, 10, 169, 12, 169, 4130, 9, 169, 3, 169, 4132, 8, 169, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 4140, 8, 171, 1, 171, 3, 171, 4143, 8, 171, 1, 172, 1, 172, 1, 172, 3, 172, 4148, 8, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 4155, 8, 172, 1, 172, 3, 172, 4158, 8, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 5, 172, 4176, 8, 172, 10, 172, 12, 172, 4179, 9, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 4190, 8, 172, 1, 173, 3, 173, 4193, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 4199, 8, 173, 1, 173, 5, 173, 4202, 8, 173, 10, 173, 12, 173, 4205, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 5, 174, 4211, 8, 174, 10, 174, 12, 174, 4214, 9, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 4221, 8, 174, 1, 174, 1, 174, 1, 174, 3, 174, 4226, 8, 174, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 4232, 8, 175, 1, 175, 1, 175, 1, 175, 5, 175, 4237, 8, 175, 10, 175, 12, 175, 4240, 9, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 4247, 8, 175, 1, 175, 3, 175, 4250, 8, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 5, 176, 4261, 8, 176, 10, 176, 12, 176, 4264, 9, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4277, 8, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4283, 8, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4291, 8, 177, 3, 177, 4293, 8, 177, 1, 178, 1, 178, 1, 179, 1, 179, 3, 179, 4299, 8, 179, 1, 179, 1, 179, 3, 179, 4303, 8, 179, 1, 179, 3, 179, 4306, 8, 179, 1, 179, 3, 179, 4309, 8, 179, 1, 179, 1, 179, 1, 179, 3, 179, 4314, 8, 179, 1, 179, 1, 179, 1, 179, 3, 179, 4319, 8, 179, 1, 179, 1, 179, 3, 179, 4323, 8, 179, 1, 179, 3, 179, 4326, 8, 179, 1, 179, 3, 179, 4329, 8, 179, 1, 179, 3, 179, 4332, 8, 179, 1, 179, 3, 179, 4335, 8, 179, 1, 180, 1, 180, 1, 180, 1, 180, 5, 180, 4341, 8, 180, 10, 180, 12, 180, 4344, 9, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 4354, 8, 181, 1, 181, 3, 181, 4357, 8, 181, 1, 181, 3, 181, 4360, 8, 181, 1, 181, 1, 181, 1, 181, 3, 181, 4365, 8, 181, 1, 181, 3, 181, 4368, 8, 181, 1, 181, 1, 181, 3, 181, 4372, 8, 181, 1, 182, 1, 182, 3, 182, 4376, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 4382, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 4388, 8, 182, 10, 182, 12, 182, 4391, 9, 182, 3, 182, 4393, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 4404, 8, 182, 10, 182, 12, 182, 4407, 9, 182, 1, 182, 1, 182, 3, 182, 4411, 8, 182, 3, 182, 4413, 8, 182, 1, 182, 4, 182, 4416, 8, 182, 11, 182, 12, 182, 4417, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 4425, 8, 182, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 3, 184, 4432, 8, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 5, 185, 4439, 8, 185, 10, 185, 12, 185, 4442, 9, 185, 1, 186, 1, 186, 1, 186, 5, 186, 4447, 8, 186, 10, 186, 12, 186, 4450, 9, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 4457, 8, 187, 1, 188, 1, 188, 1, 188, 5, 188, 4462, 8, 188, 10, 188, 12, 188, 4465, 9, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 4472, 8, 189, 1, 190, 1, 190, 1, 190, 5, 190, 4477, 8, 190, 10, 190, 12, 190, 4480, 9, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, 4487, 8, 191, 1, 192, 1, 192, 3, 192, 4491, 8, 192, 1, 192, 1, 192, 3, 192, 4495, 8, 192, 3, 192, 4497, 8, 192, 1, 192, 1, 192, 1, 193, 1, 193, 3, 193, 4503, 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 4508, 8, 193, 1, 194, 1, 194, 3, 194, 4512, 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, 4519, 8, 194, 1, 195, 1, 195, 1, 195, 3, 195, 4524, 8, 195, 1, 196, 1, 196, 1, 196, 3, 196, 4529, 8, 196, 1, 196, 1, 196, 1, 196, 3, 196, 4534, 8, 196, 3, 196, 4536, 8, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 3, 198, 4546, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 4556, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 4572, 8, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 5, 199, 4588, 8, 199, 10, 199, 12, 199, 4591, 9, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4602, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4609, 8, 199, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 4624, 8, 202, 1, 202, 4, 202, 4627, 8, 202, 11, 202, 12, 202, 4628, 1, 202, 3, 202, 4632, 8, 202, 1, 203, 1, 203, 1, 203, 3, 203, 4637, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 4642, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 4647, 8, 203, 1, 203, 3, 203, 4650, 8, 203, 1, 203, 3, 203, 4653, 8, 203, 1, 204, 1, 204, 1, 204, 3, 204, 4658, 8, 204, 1, 204, 1, 204, 1, 204, 5, 204, 4663, 8, 204, 10, 204, 12, 204, 4666, 9, 204, 1, 204, 3, 204, 4669, 8, 204, 1, 205, 1, 205, 1, 205, 3, 205, 4674, 8, 205, 1, 205, 1, 205, 1, 205, 5, 205, 4679, 8, 205, 10, 205, 12, 205, 4682, 9, 205, 1, 205, 3, 205, 4685, 8, 205, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 4691, 8, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 4700, 8, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 5, 207, 4707, 8, 207, 10, 207, 12, 207, 4710, 9, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 4, 209, 4721, 8, 209, 11, 209, 12, 209, 4722, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, 210, 4736, 8, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, 210, 4742, 8, 210, 1, 210, 1, 210, 3, 210, 4746, 8, 210, 3, 210, 4748, 8, 210, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 3, 212, 4755, 8, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 4768, 8, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 4775, 8, 212, 3, 212, 4777, 8, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 5, 214, 4791, 8, 214, 10, 214, 12, 214, 4794, 9, 214, 1, 214, 3, 214, 4797, 8, 214, 1, 214, 1, 214, 3, 214, 4801, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4806, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4811, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4816, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4821, 8, 214, 1, 214, 3, 214, 4824, 8, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4836, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4889, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4898, 8, 216, 1, 216, 1, 216, 3, 216, 4902, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4911, 8, 216, 1, 216, 1, 216, 3, 216, 4915, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4924, 8, 216, 1, 216, 1, 216, 3, 216, 4928, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4933, 8, 216, 1, 216, 3, 216, 4936, 8, 216, 1, 216, 1, 216, 3, 216, 4940, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4945, 8, 216, 3, 216, 4947, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4956, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4961, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4972, 8, 216, 1, 216, 1, 216, 3, 216, 4976, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4990, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4998, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5036, 8, 216, 3, 216, 5038, 8, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 3, 217, 5057, 8, 217, 1, 217, 3, 217, 5060, 8, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 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, 3, 218, 5087, 8, 218, 1, 218, 1, 218, 3, 218, 5091, 8, 218, 1, 218, 1, 218, 3, 218, 5095, 8, 218, 1, 218, 1, 218, 3, 218, 5099, 8, 218, 1, 218, 1, 218, 3, 218, 5103, 8, 218, 1, 218, 3, 218, 5106, 8, 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, 5121, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 5128, 8, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5140, 8, 220, 10, 220, 12, 220, 5143, 9, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 5155, 8, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5180, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5199, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5214, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5230, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5237, 8, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 5248, 8, 224, 1, 224, 3, 224, 5251, 8, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 5, 225, 5268, 8, 225, 10, 225, 12, 225, 5271, 9, 225, 3, 225, 5273, 8, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 5, 226, 5284, 8, 226, 10, 226, 12, 226, 5287, 9, 226, 1, 226, 3, 226, 5290, 8, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 5310, 8, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 5, 227, 5320, 8, 227, 10, 227, 12, 227, 5323, 9, 227, 1, 227, 3, 227, 5326, 8, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 5348, 8, 227, 1, 228, 1, 228, 3, 228, 5352, 8, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, 5362, 8, 228, 1, 228, 1, 228, 3, 228, 5366, 8, 228, 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, 5372, 8, 228, 1, 228, 1, 228, 3, 228, 5376, 8, 228, 5, 228, 5378, 8, 228, 10, 228, 12, 228, 5381, 9, 228, 1, 228, 3, 228, 5384, 8, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5391, 8, 229, 1, 230, 1, 230, 1, 230, 3, 230, 5396, 8, 230, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 3, 233, 5407, 8, 233, 1, 234, 1, 234, 3, 234, 5411, 8, 234, 1, 234, 3, 234, 5414, 8, 234, 1, 234, 1, 234, 1, 234, 3, 234, 5419, 8, 234, 1, 234, 1, 234, 1, 234, 1, 234, 3, 234, 5425, 8, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 3, 234, 5436, 8, 234, 1, 234, 1, 234, 3, 234, 5440, 8, 234, 1, 234, 3, 234, 5443, 8, 234, 1, 234, 1, 234, 3, 234, 5447, 8, 234, 1, 234, 1, 234, 3, 234, 5451, 8, 234, 1, 234, 3, 234, 5454, 8, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 3, 236, 5464, 8, 236, 1, 236, 3, 236, 5467, 8, 236, 1, 237, 1, 237, 3, 237, 5471, 8, 237, 1, 237, 5, 237, 5474, 8, 237, 10, 237, 12, 237, 5477, 9, 237, 1, 238, 1, 238, 1, 238, 3, 238, 5482, 8, 238, 1, 238, 3, 238, 5485, 8, 238, 1, 238, 1, 238, 1, 238, 3, 238, 5490, 8, 238, 1, 238, 3, 238, 5493, 8, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, 5500, 8, 238, 3, 238, 5502, 8, 238, 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, 5508, 8, 238, 1, 238, 1, 238, 3, 238, 5512, 8, 238, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 3, 240, 5521, 8, 240, 1, 240, 4, 240, 5524, 8, 240, 11, 240, 12, 240, 5525, 3, 240, 5528, 8, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 3, 241, 5538, 8, 241, 1, 241, 3, 241, 5541, 8, 241, 1, 241, 1, 241, 1, 241, 3, 241, 5546, 8, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 3, 242, 5554, 8, 242, 1, 242, 3, 242, 5557, 8, 242, 1, 242, 4, 242, 5560, 8, 242, 11, 242, 12, 242, 5561, 3, 242, 5564, 8, 242, 3, 242, 5566, 8, 242, 1, 243, 1, 243, 1, 243, 1, 243, 3, 243, 5572, 8, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 3, 246, 5589, 8, 246, 1, 246, 1, 246, 5, 246, 5593, 8, 246, 10, 246, 12, 246, 5596, 9, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5608, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5614, 8, 247, 1, 247, 1, 247, 3, 247, 5618, 8, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5623, 8, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5653, 8, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5668, 8, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5673, 8, 249, 1, 250, 1, 250, 3, 250, 5677, 8, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 3, 251, 5690, 8, 251, 1, 251, 1, 251, 3, 251, 5694, 8, 251, 3, 251, 5696, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 5, 251, 5703, 8, 251, 10, 251, 12, 251, 5706, 9, 251, 1, 251, 1, 251, 1, 251, 3, 251, 5711, 8, 251, 3, 251, 5713, 8, 251, 1, 252, 1, 252, 3, 252, 5717, 8, 252, 1, 252, 3, 252, 5720, 8, 252, 1, 252, 3, 252, 5723, 8, 252, 1, 252, 3, 252, 5726, 8, 252, 1, 252, 3, 252, 5729, 8, 252, 3, 252, 5731, 8, 252, 1, 252, 3, 252, 5734, 8, 252, 1, 253, 1, 253, 3, 253, 5738, 8, 253, 1, 253, 1, 253, 1, 253, 1, 253, 5, 253, 5744, 8, 253, 10, 253, 12, 253, 5747, 9, 253, 1, 253, 1, 253, 3, 253, 5751, 8, 253, 1, 253, 3, 253, 5754, 8, 253, 1, 254, 1, 254, 1, 255, 1, 255, 3, 255, 5760, 8, 255, 1, 255, 1, 255, 3, 255, 5764, 8, 255, 1, 256, 1, 256, 3, 256, 5768, 8, 256, 1, 256, 1, 256, 1, 256, 3, 256, 5773, 8, 256, 3, 256, 5775, 8, 256, 1, 257, 1, 257, 3, 257, 5779, 8, 257, 1, 258, 1, 258, 3, 258, 5783, 8, 258, 1, 259, 1, 259, 1, 259, 5, 259, 5788, 8, 259, 10, 259, 12, 259, 5791, 9, 259, 1, 260, 1, 260, 1, 260, 3, 260, 5796, 8, 260, 1, 260, 1, 260, 3, 260, 5800, 8, 260, 3, 260, 5802, 8, 260, 3, 260, 5804, 8, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 5817, 8, 261, 1, 262, 1, 262, 1, 262, 1, 262, 5, 262, 5823, 8, 262, 10, 262, 12, 262, 5826, 9, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 3, 263, 5833, 8, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 5, 264, 5842, 8, 264, 10, 264, 12, 264, 5845, 9, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 3, 265, 5853, 8, 265, 1, 266, 1, 266, 1, 266, 3, 266, 5858, 8, 266, 1, 266, 1, 266, 3, 266, 5862, 8, 266, 1, 266, 1, 266, 3, 266, 5866, 8, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 3, 266, 5873, 8, 266, 1, 266, 3, 266, 5876, 8, 266, 3, 266, 5878, 8, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 3, 268, 5886, 8, 268, 1, 268, 1, 268, 3, 268, 5890, 8, 268, 1, 269, 3, 269, 5893, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5900, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5907, 8, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5912, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5919, 8, 269, 1, 269, 3, 269, 5922, 8, 269, 3, 269, 5924, 8, 269, 1, 269, 3, 269, 5927, 8, 269, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 5933, 8, 270, 1, 270, 1, 270, 1, 270, 3, 270, 5938, 8, 270, 1, 270, 1, 270, 3, 270, 5942, 8, 270, 1, 271, 1, 271, 1, 271, 5, 271, 5947, 8, 271, 10, 271, 12, 271, 5950, 9, 271, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 274, 3, 274, 5959, 8, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 5966, 8, 274, 1, 274, 3, 274, 5969, 8, 274, 1, 274, 3, 274, 5972, 8, 274, 1, 275, 1, 275, 3, 275, 5976, 8, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275, 5987, 8, 275, 1, 275, 3, 275, 5990, 8, 275, 1, 275, 3, 275, 5993, 8, 275, 1, 275, 3, 275, 5996, 8, 275, 1, 276, 3, 276, 5999, 8, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, 6006, 8, 276, 1, 276, 3, 276, 6009, 8, 276, 1, 276, 3, 276, 6012, 8, 276, 1, 277, 1, 277, 1, 277, 5, 277, 6017, 8, 277, 10, 277, 12, 277, 6020, 9, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 6031, 8, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 6038, 8, 278, 3, 278, 6040, 8, 278, 1, 279, 1, 279, 1, 279, 3, 279, 6045, 8, 279, 1, 279, 1, 279, 1, 279, 5, 279, 6050, 8, 279, 10, 279, 12, 279, 6053, 9, 279, 1, 279, 1, 279, 1, 279, 3, 279, 6058, 8, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 3, 280, 6065, 8, 280, 1, 281, 1, 281, 1, 281, 3, 281, 6070, 8, 281, 1, 281, 1, 281, 1, 282, 3, 282, 6075, 8, 282, 1, 282, 1, 282, 3, 282, 6079, 8, 282, 1, 282, 1, 282, 3, 282, 6083, 8, 282, 1, 282, 1, 282, 3, 282, 6087, 8, 282, 3, 282, 6089, 8, 282, 1, 283, 1, 283, 3, 283, 6093, 8, 283, 1, 284, 1, 284, 3, 284, 6097, 8, 284, 1, 284, 3, 284, 6100, 8, 284, 1, 284, 3, 284, 6103, 8, 284, 3, 284, 6105, 8, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 6115, 8, 284, 3, 284, 6117, 8, 284, 1, 284, 1, 284, 1, 284, 3, 284, 6122, 8, 284, 5, 284, 6124, 8, 284, 10, 284, 12, 284, 6127, 9, 284, 1, 285, 1, 285, 3, 285, 6131, 8, 285, 1, 286, 1, 286, 3, 286, 6135, 8, 286, 1, 286, 1, 286, 1, 286, 5, 286, 6140, 8, 286, 10, 286, 12, 286, 6143, 9, 286, 1, 287, 1, 287, 3, 287, 6147, 8, 287, 1, 287, 1, 287, 3, 287, 6151, 8, 287, 1, 287, 3, 287, 6154, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 6160, 8, 287, 1, 287, 3, 287, 6163, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 3, 289, 6182, 8, 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 3, 290, 6189, 8, 290, 1, 290, 1, 290, 3, 290, 6193, 8, 290, 1, 291, 3, 291, 6196, 8, 291, 1, 291, 1, 291, 3, 291, 6200, 8, 291, 1, 291, 1, 291, 3, 291, 6204, 8, 291, 1, 291, 3, 291, 6207, 8, 291, 1, 291, 3, 291, 6210, 8, 291, 1, 292, 1, 292, 1, 292, 3, 292, 6215, 8, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 5, 293, 6222, 8, 293, 10, 293, 12, 293, 6225, 9, 293, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 6231, 8, 294, 1, 294, 1, 294, 3, 294, 6235, 8, 294, 1, 295, 1, 295, 3, 295, 6239, 8, 295, 1, 295, 1, 295, 3, 295, 6243, 8, 295, 1, 295, 3, 295, 6246, 8, 295, 3, 295, 6248, 8, 295, 1, 296, 1, 296, 1, 296, 3, 296, 6253, 8, 296, 1, 296, 1, 296, 3, 296, 6257, 8, 296, 1, 297, 1, 297, 1, 297, 3, 297, 6262, 8, 297, 1, 297, 1, 297, 1, 297, 1, 297, 3, 297, 6268, 8, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 6275, 8, 298, 1, 299, 1, 299, 1, 299, 3, 299, 6280, 8, 299, 1, 300, 1, 300, 1, 300, 3, 300, 6285, 8, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 5, 301, 6292, 8, 301, 10, 301, 12, 301, 6295, 9, 301, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6301, 8, 302, 1, 302, 1, 302, 1, 302, 1, 302, 5, 302, 6307, 8, 302, 10, 302, 12, 302, 6310, 9, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6320, 8, 302, 1, 303, 1, 303, 1, 303, 3, 303, 6325, 8, 303, 1, 303, 1, 303, 3, 303, 6329, 8, 303, 1, 303, 3, 303, 6332, 8, 303, 1, 303, 1, 303, 3, 303, 6336, 8, 303, 1, 303, 1, 303, 1, 303, 3, 303, 6341, 8, 303, 4, 303, 6343, 8, 303, 11, 303, 12, 303, 6344, 1, 303, 1, 303, 1, 303, 3, 303, 6350, 8, 303, 1, 304, 1, 304, 1, 304, 1, 304, 5, 304, 6356, 8, 304, 10, 304, 12, 304, 6359, 9, 304, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 5, 306, 6367, 8, 306, 10, 306, 12, 306, 6370, 9, 306, 1, 307, 1, 307, 3, 307, 6374, 8, 307, 1, 307, 1, 307, 3, 307, 6378, 8, 307, 1, 307, 3, 307, 6381, 8, 307, 1, 307, 3, 307, 6384, 8, 307, 3, 307, 6386, 8, 307, 1, 307, 3, 307, 6389, 8, 307, 1, 307, 3, 307, 6392, 8, 307, 1, 307, 3, 307, 6395, 8, 307, 1, 307, 1, 307, 3, 307, 6399, 8, 307, 1, 307, 1, 307, 3, 307, 6403, 8, 307, 1, 307, 1, 307, 3, 307, 6407, 8, 307, 3, 307, 6409, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6418, 8, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6423, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6429, 8, 307, 1, 307, 1, 307, 3, 307, 6433, 8, 307, 3, 307, 6435, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6442, 8, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6447, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 5, 307, 6453, 8, 307, 10, 307, 12, 307, 6456, 9, 307, 1, 308, 3, 308, 6459, 8, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 6466, 8, 308, 1, 309, 1, 309, 1, 309, 3, 309, 6471, 8, 309, 1, 309, 3, 309, 6474, 8, 309, 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, 6480, 8, 309, 1, 310, 1, 310, 3, 310, 6484, 8, 310, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 6490, 8, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 6499, 8, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 6505, 8, 312, 3, 312, 6507, 8, 312, 1, 313, 1, 313, 1, 313, 3, 313, 6512, 8, 313, 1, 313, 3, 313, 6515, 8, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 6524, 8, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 6531, 8, 313, 3, 313, 6533, 8, 313, 1, 314, 1, 314, 1, 314, 5, 314, 6538, 8, 314, 10, 314, 12, 314, 6541, 9, 314, 1, 315, 1, 315, 3, 315, 6545, 8, 315, 1, 315, 3, 315, 6548, 8, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 3, 316, 6558, 8, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 5, 317, 6567, 8, 317, 10, 317, 12, 317, 6570, 9, 317, 1, 317, 1, 317, 3, 317, 6574, 8, 317, 1, 317, 1, 317, 3, 317, 6578, 8, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 3, 318, 6586, 8, 318, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 6596, 8, 320, 1, 321, 1, 321, 1, 321, 5, 321, 6601, 8, 321, 10, 321, 12, 321, 6604, 9, 321, 1, 322, 1, 322, 1, 322, 3, 322, 6609, 8, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 5, 323, 6618, 8, 323, 10, 323, 12, 323, 6621, 9, 323, 1, 323, 1, 323, 1, 323, 3, 323, 6626, 8, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 5, 323, 6634, 8, 323, 10, 323, 12, 323, 6637, 9, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 3, 324, 6645, 8, 324, 1, 324, 1, 324, 3, 324, 6649, 8, 324, 1, 324, 4, 324, 6652, 8, 324, 11, 324, 12, 324, 6653, 3, 324, 6656, 8, 324, 1, 324, 1, 324, 3, 324, 6660, 8, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6668, 8, 325, 1, 326, 3, 326, 6671, 8, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6676, 8, 326, 1, 326, 5, 326, 6679, 8, 326, 10, 326, 12, 326, 6682, 9, 326, 1, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6688, 8, 326, 3, 326, 6690, 8, 326, 1, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6696, 8, 326, 1, 327, 1, 327, 3, 327, 6700, 8, 327, 1, 327, 3, 327, 6703, 8, 327, 1, 327, 1, 327, 1, 327, 3, 327, 6708, 8, 327, 1, 327, 3, 327, 6711, 8, 327, 3, 327, 6713, 8, 327, 1, 328, 1, 328, 1, 328, 1, 328, 3, 328, 6719, 8, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 6728, 8, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 6734, 8, 329, 1, 329, 3, 329, 6737, 8, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 3, 331, 6745, 8, 331, 1, 331, 3, 331, 6748, 8, 331, 1, 332, 1, 332, 3, 332, 6752, 8, 332, 1, 332, 1, 332, 1, 332, 1, 332, 3, 332, 6758, 8, 332, 3, 332, 6760, 8, 332, 1, 332, 3, 332, 6763, 8, 332, 1, 333, 1, 333, 3, 333, 6767, 8, 333, 1, 333, 1, 333, 1, 333, 3, 333, 6772, 8, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6779, 8, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6786, 8, 334, 3, 334, 6788, 8, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6794, 8, 334, 3, 334, 6796, 8, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6801, 8, 334, 3, 334, 6803, 8, 334, 1, 335, 1, 335, 3, 335, 6807, 8, 335, 1, 336, 1, 336, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 3, 338, 6816, 8, 338, 1, 338, 1, 338, 3, 338, 6820, 8, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 5, 338, 6828, 8, 338, 10, 338, 12, 338, 6831, 9, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6844, 8, 339, 1, 339, 3, 339, 6847, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6855, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 5, 339, 6862, 8, 339, 10, 339, 12, 339, 6865, 9, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6870, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6875, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6883, 8, 339, 3, 339, 6885, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6890, 8, 339, 1, 339, 1, 339, 3, 339, 6894, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6899, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6904, 8, 339, 1, 340, 1, 340, 1, 340, 1, 340, 3, 340, 6910, 8, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 5, 340, 6926, 8, 340, 10, 340, 12, 340, 6929, 9, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6937, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6952, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6957, 8, 341, 1, 341, 3, 341, 6960, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6966, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6971, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6984, 8, 341, 1, 341, 4, 341, 6987, 8, 341, 11, 341, 12, 341, 6988, 1, 341, 1, 341, 3, 341, 6993, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7000, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7019, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7031, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7036, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7044, 8, 341, 5, 341, 7046, 8, 341, 10, 341, 12, 341, 7049, 9, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7057, 8, 342, 1, 342, 3, 342, 7060, 8, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7065, 8, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7070, 8, 342, 1, 342, 3, 342, 7073, 8, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7084, 8, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7092, 8, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7097, 8, 343, 3, 343, 7099, 8, 343, 1, 343, 3, 343, 7102, 8, 343, 1, 344, 1, 344, 3, 344, 7106, 8, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7117, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7138, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7146, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7159, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7169, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7175, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7181, 8, 345, 1, 345, 3, 345, 7184, 8, 345, 1, 345, 3, 345, 7187, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7213, 8, 345, 3, 345, 7215, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7236, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7246, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7259, 8, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7264, 8, 345, 1, 345, 1, 345, 3, 345, 7268, 8, 345, 3, 345, 7270, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7282, 8, 345, 1, 346, 1, 346, 1, 346, 5, 346, 7287, 8, 346, 10, 346, 12, 346, 7290, 9, 346, 1, 347, 1, 347, 1, 347, 3, 347, 7295, 8, 347, 1, 348, 1, 348, 1, 349, 1, 349, 3, 349, 7301, 8, 349, 1, 349, 1, 349, 3, 349, 7305, 8, 349, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 5, 351, 7314, 8, 351, 10, 351, 12, 351, 7317, 9, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 3, 353, 7326, 8, 353, 1, 354, 1, 354, 3, 354, 7330, 8, 354, 1, 354, 1, 354, 1, 354, 3, 354, 7335, 8, 354, 1, 354, 3, 354, 7338, 8, 354, 1, 354, 3, 354, 7341, 8, 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 3, 355, 7350, 8, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 3, 355, 7361, 8, 355, 3, 355, 7363, 8, 355, 1, 356, 1, 356, 3, 356, 7367, 8, 356, 1, 356, 1, 356, 1, 356, 3, 356, 7372, 8, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 3, 357, 7381, 8, 357, 1, 358, 1, 358, 1, 358, 3, 358, 7386, 8, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 360, 1, 360, 3, 360, 7394, 8, 360, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 3, 362, 7404, 8, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 3, 363, 7412, 8, 363, 1, 364, 1, 364, 3, 364, 7416, 8, 364, 1, 364, 3, 364, 7419, 8, 364, 1, 365, 1, 365, 1, 365, 5, 365, 7424, 8, 365, 10, 365, 12, 365, 7427, 9, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 3, 366, 7434, 8, 366, 1, 367, 1, 367, 3, 367, 7438, 8, 367, 1, 368, 1, 368, 1, 368, 5, 368, 7443, 8, 368, 10, 368, 12, 368, 7446, 9, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 3, 369, 7454, 8, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 5, 370, 7461, 8, 370, 10, 370, 12, 370, 7464, 9, 370, 3, 370, 7466, 8, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 7478, 8, 371, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7487, 8, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7494, 8, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7503, 8, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 3, 375, 7513, 8, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7518, 8, 375, 1, 375, 1, 375, 3, 375, 7522, 8, 375, 3, 375, 7524, 8, 375, 1, 375, 3, 375, 7527, 8, 375, 1, 376, 4, 376, 7530, 8, 376, 11, 376, 12, 376, 7531, 1, 377, 5, 377, 7535, 8, 377, 10, 377, 12, 377, 7538, 9, 377, 1, 378, 1, 378, 1, 378, 5, 378, 7543, 8, 378, 10, 378, 12, 378, 7546, 9, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 3, 379, 7553, 8, 379, 1, 379, 3, 379, 7556, 8, 379, 1, 380, 1, 380, 1, 380, 5, 380, 7561, 8, 380, 10, 380, 12, 380, 7564, 9, 380, 1, 381, 1, 381, 1, 381, 5, 381, 7569, 8, 381, 10, 381, 12, 381, 7572, 9, 381, 1, 382, 1, 382, 1, 382, 5, 382, 7577, 8, 382, 10, 382, 12, 382, 7580, 9, 382, 1, 383, 1, 383, 1, 383, 5, 383, 7585, 8, 383, 10, 383, 12, 383, 7588, 9, 383, 1, 384, 1, 384, 1, 385, 1, 385, 1, 386, 1, 386, 1, 387, 1, 387, 1, 388, 1, 388, 1, 389, 1, 389, 1, 390, 1, 390, 3, 390, 7604, 8, 390, 1, 391, 1, 391, 1, 391, 5, 391, 7609, 8, 391, 10, 391, 12, 391, 7612, 9, 391, 1, 392, 1, 392, 1, 392, 5, 392, 7617, 8, 392, 10, 392, 12, 392, 7620, 9, 392, 1, 393, 1, 393, 1, 394, 1, 394, 1, 395, 1, 395, 1, 396, 1, 396, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 7636, 8, 398, 1, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7642, 8, 399, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 7648, 8, 400, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 3, 402, 7656, 8, 402, 1, 403, 1, 403, 1, 403, 1, 403, 3, 403, 7662, 8, 403, 1, 404, 1, 404, 1, 404, 3, 404, 7667, 8, 404, 1, 405, 1, 405, 1, 405, 1, 405, 5, 405, 7673, 8, 405, 10, 405, 12, 405, 7676, 9, 405, 1, 405, 1, 405, 3, 405, 7680, 8, 405, 1, 406, 3, 406, 7683, 8, 406, 1, 406, 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 3, 407, 7692, 8, 407, 1, 408, 1, 408, 1, 408, 5, 408, 7697, 8, 408, 10, 408, 12, 408, 7700, 9, 408, 1, 409, 1, 409, 3, 409, 7704, 8, 409, 1, 410, 1, 410, 3, 410, 7708, 8, 410, 1, 411, 1, 411, 1, 411, 3, 411, 7713, 8, 411, 1, 412, 1, 412, 1, 412, 1, 412, 3, 412, 7719, 8, 412, 1, 413, 1, 413, 1, 413, 3, 413, 7724, 8, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 3, 413, 7732, 8, 413, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 3, 415, 7787, 8, 415, 1, 416, 1, 416, 1, 417, 1, 417, 1, 418, 3, 418, 7794, 8, 418, 1, 418, 1, 418, 1, 418, 1, 418, 4, 418, 7800, 8, 418, 11, 418, 12, 418, 7801, 3, 418, 7804, 8, 418, 3, 418, 7806, 8, 418, 1, 418, 1, 418, 5, 418, 7810, 8, 418, 10, 418, 12, 418, 7813, 9, 418, 1, 418, 3, 418, 7816, 8, 418, 1, 418, 1, 418, 3, 418, 7820, 8, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 3, 420, 7831, 8, 420, 1, 420, 3, 420, 7834, 8, 420, 1, 420, 1, 420, 3, 420, 7838, 8, 420, 1, 420, 1, 420, 3, 420, 7842, 8, 420, 1, 420, 1, 420, 3, 420, 7846, 8, 420, 1, 420, 3, 420, 7849, 8, 420, 1, 420, 3, 420, 7852, 8, 420, 1, 420, 3, 420, 7855, 8, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 5, 420, 7862, 8, 420, 10, 420, 12, 420, 7865, 9, 420, 1, 420, 1, 420, 3, 420, 7869, 8, 420, 1, 420, 1, 420, 3, 420, 7873, 8, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 3, 423, 7906, 8, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7916, 8, 425, 1, 425, 1, 425, 3, 425, 7920, 8, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7926, 8, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7931, 8, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 3, 427, 7940, 8, 427, 1, 427, 1, 427, 1, 427, 1, 427, 5, 427, 7946, 8, 427, 10, 427, 12, 427, 7949, 9, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 3, 429, 7959, 8, 429, 1, 429, 1, 429, 1, 429, 1, 429, 5, 429, 7965, 8, 429, 10, 429, 12, 429, 7968, 9, 429, 1, 430, 1, 430, 1, 430, 1, 430, 5, 430, 7974, 8, 430, 10, 430, 12, 430, 7977, 9, 430, 1, 430, 1, 430, 1, 430, 1, 430, 5, 430, 7983, 8, 430, 10, 430, 12, 430, 7986, 9, 430, 5, 430, 7988, 8, 430, 10, 430, 12, 430, 7991, 9, 430, 1, 430, 3, 430, 7994, 8, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 5, 431, 8002, 8, 431, 10, 431, 12, 431, 8005, 9, 431, 1, 432, 1, 432, 3, 432, 8009, 8, 432, 1, 432, 1, 432, 1, 432, 1, 432, 5, 432, 8015, 8, 432, 10, 432, 12, 432, 8018, 9, 432, 4, 432, 8020, 8, 432, 11, 432, 12, 432, 8021, 1, 432, 3, 432, 8025, 8, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 3, 433, 8032, 8, 433, 1, 433, 1, 433, 1, 433, 1, 433, 3, 433, 8038, 8, 433, 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8046, 8, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8054, 8, 434, 1, 434, 3, 434, 8057, 8, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8064, 8, 434, 3, 434, 8066, 8, 434, 1, 435, 3, 435, 8069, 8, 435, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 8075, 8, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 3, 436, 8084, 8, 436, 1, 436, 1, 436, 3, 436, 8088, 8, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 3, 437, 8102, 8, 437, 1, 437, 3, 437, 8105, 8, 437, 3, 437, 8107, 8, 437, 1, 437, 1, 437, 1, 438, 1, 438, 3, 438, 8113, 8, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 4, 438, 8121, 8, 438, 11, 438, 12, 438, 8122, 3, 438, 8125, 8, 438, 3, 438, 8127, 8, 438, 1, 438, 1, 438, 1, 438, 1, 438, 5, 438, 8133, 8, 438, 10, 438, 12, 438, 8136, 9, 438, 3, 438, 8138, 8, 438, 1, 438, 3, 438, 8141, 8, 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, 1, 440, 3, 440, 8151, 8, 440, 1, 440, 1, 440, 1, 441, 1, 441, 5, 441, 8157, 8, 441, 10, 441, 12, 441, 8160, 9, 441, 1, 441, 1, 441, 1, 441, 3, 441, 8165, 8, 441, 1, 441, 1, 441, 1, 442, 1, 442, 3, 442, 8171, 8, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 3, 443, 8178, 8, 443, 1, 443, 1, 443, 3, 443, 8182, 8, 443, 1, 443, 1, 443, 3, 443, 8186, 8, 443, 1, 443, 3, 443, 8189, 8, 443, 1, 443, 3, 443, 8192, 8, 443, 1, 443, 1, 443, 1, 444, 1, 444, 3, 444, 8198, 8, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 3, 445, 8205, 8, 445, 1, 445, 3, 445, 8208, 8, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 3, 445, 8216, 8, 445, 3, 445, 8218, 8, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 5, 445, 8225, 8, 445, 10, 445, 12, 445, 8228, 9, 445, 1, 445, 1, 445, 3, 445, 8232, 8, 445, 3, 445, 8234, 8, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 3, 446, 8241, 8, 446, 1, 446, 1, 446, 1, 447, 1, 447, 3, 447, 8247, 8, 447, 1, 447, 3, 447, 8250, 8, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8262, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8269, 8, 448, 3, 448, 8271, 8, 448, 1, 449, 1, 449, 3, 449, 8275, 8, 449, 1, 449, 1, 449, 1, 449, 1, 450, 3, 450, 8281, 8, 450, 1, 450, 1, 450, 1, 450, 3, 450, 8286, 8, 450, 1, 450, 1, 450, 3, 450, 8290, 8, 450, 1, 450, 3, 450, 8293, 8, 450, 1, 450, 3, 450, 8296, 8, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 4, 450, 8303, 8, 450, 11, 450, 12, 450, 8304, 1, 451, 3, 451, 8308, 8, 451, 1, 451, 1, 451, 3, 451, 8312, 8, 451, 1, 451, 1, 451, 3, 451, 8316, 8, 451, 3, 451, 8318, 8, 451, 1, 451, 3, 451, 8321, 8, 451, 1, 451, 3, 451, 8324, 8, 451, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8330, 8, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8337, 8, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8344, 8, 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8350, 8, 452, 3, 452, 8352, 8, 452, 1, 453, 1, 453, 3, 453, 8356, 8, 453, 1, 453, 1, 453, 1, 453, 3, 453, 8361, 8, 453, 1, 453, 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 5, 454, 8377, 8, 454, 10, 454, 12, 454, 8380, 9, 454, 1, 454, 1, 454, 4, 454, 8384, 8, 454, 11, 454, 12, 454, 8385, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 5, 455, 8393, 8, 455, 10, 455, 12, 455, 8396, 9, 455, 1, 455, 1, 455, 1, 455, 1, 455, 3, 455, 8402, 8, 455, 1, 456, 1, 456, 3, 456, 8406, 8, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 3, 459, 8418, 8, 459, 1, 459, 3, 459, 8421, 8, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 3, 460, 8434, 8, 460, 1, 460, 3, 460, 8437, 8, 460, 1, 461, 1, 461, 3, 461, 8441, 8, 461, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 5, 462, 8448, 8, 462, 10, 462, 12, 462, 8451, 9, 462, 1, 462, 1, 462, 5, 462, 8455, 8, 462, 10, 462, 12, 462, 8458, 9, 462, 4, 462, 8460, 8, 462, 11, 462, 12, 462, 8461, 1, 463, 1, 463, 1, 463, 3, 463, 8467, 8, 463, 1, 464, 1, 464, 3, 464, 8471, 8, 464, 1, 465, 3, 465, 8474, 8, 465, 1, 465, 3, 465, 8477, 8, 465, 1, 465, 3, 465, 8480, 8, 465, 1, 465, 3, 465, 8483, 8, 465, 1, 465, 3, 465, 8486, 8, 465, 1, 465, 1, 465, 3, 465, 8490, 8, 465, 1, 465, 3, 465, 8493, 8, 465, 1, 465, 0, 3, 676, 680, 682, 466, 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, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 928, 930, 0, 118, 2, 0, 195, 195, 364, 364, 2, 0, 66, 66, 318, 318, 2, 0, 99, 99, 318, 318, 2, 0, 134, 134, 318, 318, 1, 0, 529, 531, 2, 0, 10, 10, 94, 94, 2, 0, 133, 133, 191, 191, 2, 0, 254, 254, 332, 332, 2, 0, 162, 162, 363, 363, 2, 0, 180, 180, 221, 221, 5, 0, 30, 30, 288, 288, 329, 329, 352, 352, 354, 354, 2, 0, 109, 109, 532, 532, 2, 0, 158, 158, 277, 277, 2, 0, 367, 367, 439, 439, 2, 0, 139, 139, 312, 312, 2, 0, 191, 191, 333, 333, 2, 0, 313, 313, 333, 333, 2, 0, 150, 150, 315, 315, 2, 0, 64, 64, 94, 94, 4, 0, 78, 78, 183, 183, 197, 197, 298, 298, 2, 0, 213, 213, 254, 254, 2, 0, 352, 352, 354, 354, 2, 0, 200, 200, 224, 224, 9, 0, 30, 30, 160, 160, 165, 165, 179, 179, 219, 219, 227, 227, 342, 342, 345, 345, 438, 438, 3, 0, 113, 113, 284, 284, 336, 336, 2, 0, 53, 53, 78, 78, 2, 0, 105, 105, 379, 379, 2, 0, 260, 260, 262, 262, 3, 0, 173, 173, 260, 260, 262, 262, 1, 0, 12, 13, 2, 0, 64, 64, 375, 375, 2, 0, 156, 156, 206, 206, 2, 0, 189, 189, 360, 360, 2, 0, 215, 215, 373, 373, 3, 0, 133, 133, 191, 191, 333, 333, 5, 0, 30, 30, 88, 88, 182, 182, 241, 241, 369, 369, 2, 0, 9, 9, 94, 94, 2, 0, 92, 92, 226, 226, 1, 0, 448, 449, 2, 0, 92, 92, 414, 414, 2, 0, 341, 341, 414, 414, 4, 0, 163, 163, 185, 185, 283, 283, 353, 353, 2, 0, 135, 135, 145, 145, 2, 0, 211, 211, 278, 278, 3, 0, 321, 321, 357, 357, 445, 445, 3, 0, 66, 66, 99, 99, 318, 318, 5, 0, 108, 108, 168, 168, 226, 226, 328, 328, 342, 342, 2, 0, 167, 167, 314, 314, 2, 0, 61, 61, 265, 265, 4, 0, 207, 207, 249, 249, 268, 268, 293, 293, 2, 0, 130, 130, 307, 307, 2, 0, 64, 64, 68, 68, 10, 0, 46, 46, 88, 88, 182, 182, 202, 202, 241, 241, 352, 352, 354, 354, 357, 358, 369, 369, 521, 523, 5, 0, 212, 212, 329, 329, 350, 350, 455, 455, 457, 457, 5, 0, 212, 212, 329, 329, 350, 350, 361, 361, 455, 456, 2, 0, 37, 37, 55, 55, 2, 0, 207, 207, 249, 249, 2, 0, 10, 10, 53, 53, 2, 0, 181, 181, 243, 243, 2, 0, 170, 170, 320, 320, 2, 0, 141, 141, 223, 223, 5, 0, 108, 108, 168, 168, 189, 189, 342, 342, 360, 360, 2, 0, 226, 226, 328, 328, 2, 0, 163, 163, 185, 185, 2, 0, 186, 186, 193, 193, 4, 0, 88, 88, 182, 182, 241, 241, 369, 369, 2, 0, 137, 137, 242, 242, 2, 0, 161, 161, 319, 319, 4, 0, 129, 129, 161, 161, 319, 319, 454, 454, 2, 0, 356, 356, 380, 380, 2, 0, 81, 81, 382, 382, 2, 0, 151, 151, 254, 254, 2, 0, 133, 133, 138, 138, 1, 0, 31, 32, 2, 0, 128, 128, 547, 547, 2, 0, 60, 60, 96, 96, 2, 0, 99, 99, 349, 349, 2, 0, 131, 131, 414, 414, 2, 0, 201, 201, 334, 334, 3, 0, 59, 59, 70, 70, 97, 97, 2, 0, 30, 30, 56, 56, 1, 0, 527, 528, 2, 0, 207, 207, 268, 268, 2, 0, 320, 320, 414, 414, 2, 0, 571, 571, 573, 573, 1, 0, 468, 469, 4, 0, 113, 113, 115, 115, 119, 119, 126, 126, 2, 0, 360, 360, 477, 477, 2, 0, 394, 395, 409, 409, 2, 0, 391, 392, 406, 406, 1, 0, 391, 392, 1, 0, 418, 419, 5, 0, 10, 10, 16, 17, 21, 21, 23, 23, 25, 25, 3, 0, 9, 9, 14, 14, 27, 27, 2, 0, 98, 98, 396, 396, 2, 0, 50, 51, 75, 76, 2, 0, 41, 41, 420, 420, 3, 0, 39, 39, 73, 73, 95, 95, 4, 0, 393, 393, 399, 399, 404, 404, 425, 425, 2, 0, 292, 292, 347, 347, 2, 0, 166, 166, 188, 188, 2, 0, 304, 304, 450, 450, 3, 0, 299, 299, 320, 320, 481, 481, 2, 0, 208, 208, 289, 289, 3, 0, 30, 30, 34, 34, 90, 90, 6, 0, 9, 10, 12, 17, 21, 21, 23, 23, 25, 25, 27, 27, 2, 0, 114, 114, 120, 120, 2, 0, 20, 20, 22, 22, 1, 0, 483, 486, 17, 0, 53, 53, 116, 116, 123, 124, 129, 228, 238, 386, 433, 452, 455, 469, 471, 471, 473, 473, 475, 475, 477, 488, 490, 502, 504, 504, 506, 518, 520, 520, 524, 524, 547, 548, 3, 0, 106, 123, 125, 128, 472, 472, 4, 0, 30, 52, 54, 70, 72, 105, 454, 454, 2, 0, 62, 62, 116, 116, 2, 0, 10, 10, 20, 20, 2, 0, 434, 434, 501, 501, 2, 0, 167, 167, 507, 507, 1, 0, 512, 517, 2, 0, 144, 144, 210, 210, 9929, 0, 935, 1, 0, 0, 0, 2, 940, 1, 0, 0, 0, 4, 1064, 1, 0, 0, 0, 6, 1066, 1, 0, 0, 0, 8, 1069, 1, 0, 0, 0, 10, 1119, 1, 0, 0, 0, 12, 1129, 1, 0, 0, 0, 14, 1131, 1, 0, 0, 0, 16, 1143, 1, 0, 0, 0, 18, 1155, 1, 0, 0, 0, 20, 1166, 1, 0, 0, 0, 22, 1200, 1, 0, 0, 0, 24, 1244, 1, 0, 0, 0, 26, 1246, 1, 0, 0, 0, 28, 1258, 1, 0, 0, 0, 30, 1265, 1, 0, 0, 0, 32, 1284, 1, 0, 0, 0, 34, 1292, 1, 0, 0, 0, 36, 1294, 1, 0, 0, 0, 38, 1308, 1, 0, 0, 0, 40, 1312, 1, 0, 0, 0, 42, 1349, 1, 0, 0, 0, 44, 1351, 1, 0, 0, 0, 46, 1359, 1, 0, 0, 0, 48, 1369, 1, 0, 0, 0, 50, 1376, 1, 0, 0, 0, 52, 1384, 1, 0, 0, 0, 54, 1390, 1, 0, 0, 0, 56, 1406, 1, 0, 0, 0, 58, 1410, 1, 0, 0, 0, 60, 1412, 1, 0, 0, 0, 62, 1424, 1, 0, 0, 0, 64, 1429, 1, 0, 0, 0, 66, 1434, 1, 0, 0, 0, 68, 1436, 1, 0, 0, 0, 70, 1448, 1, 0, 0, 0, 72, 1456, 1, 0, 0, 0, 74, 1458, 1, 0, 0, 0, 76, 1582, 1, 0, 0, 0, 78, 1584, 1, 0, 0, 0, 80, 1601, 1, 0, 0, 0, 82, 1603, 1, 0, 0, 0, 84, 1617, 1, 0, 0, 0, 86, 1619, 1, 0, 0, 0, 88, 1633, 1, 0, 0, 0, 90, 1635, 1, 0, 0, 0, 92, 1872, 1, 0, 0, 0, 94, 1879, 1, 0, 0, 0, 96, 1881, 1, 0, 0, 0, 98, 1883, 1, 0, 0, 0, 100, 1886, 1, 0, 0, 0, 102, 1897, 1, 0, 0, 0, 104, 1900, 1, 0, 0, 0, 106, 1936, 1, 0, 0, 0, 108, 1938, 1, 0, 0, 0, 110, 1979, 1, 0, 0, 0, 112, 1981, 1, 0, 0, 0, 114, 2035, 1, 0, 0, 0, 116, 2076, 1, 0, 0, 0, 118, 2078, 1, 0, 0, 0, 120, 2095, 1, 0, 0, 0, 122, 2176, 1, 0, 0, 0, 124, 2178, 1, 0, 0, 0, 126, 2189, 1, 0, 0, 0, 128, 2212, 1, 0, 0, 0, 130, 2230, 1, 0, 0, 0, 132, 2232, 1, 0, 0, 0, 134, 2267, 1, 0, 0, 0, 136, 2360, 1, 0, 0, 0, 138, 2365, 1, 0, 0, 0, 140, 2367, 1, 0, 0, 0, 142, 2465, 1, 0, 0, 0, 144, 2467, 1, 0, 0, 0, 146, 2471, 1, 0, 0, 0, 148, 2482, 1, 0, 0, 0, 150, 2490, 1, 0, 0, 0, 152, 2493, 1, 0, 0, 0, 154, 2496, 1, 0, 0, 0, 156, 2514, 1, 0, 0, 0, 158, 2516, 1, 0, 0, 0, 160, 2520, 1, 0, 0, 0, 162, 2533, 1, 0, 0, 0, 164, 2535, 1, 0, 0, 0, 166, 2540, 1, 0, 0, 0, 168, 2560, 1, 0, 0, 0, 170, 2568, 1, 0, 0, 0, 172, 2575, 1, 0, 0, 0, 174, 2577, 1, 0, 0, 0, 176, 2586, 1, 0, 0, 0, 178, 2589, 1, 0, 0, 0, 180, 2593, 1, 0, 0, 0, 182, 2597, 1, 0, 0, 0, 184, 2622, 1, 0, 0, 0, 186, 2632, 1, 0, 0, 0, 188, 2646, 1, 0, 0, 0, 190, 2662, 1, 0, 0, 0, 192, 2668, 1, 0, 0, 0, 194, 2695, 1, 0, 0, 0, 196, 2705, 1, 0, 0, 0, 198, 2721, 1, 0, 0, 0, 200, 2765, 1, 0, 0, 0, 202, 2772, 1, 0, 0, 0, 204, 2774, 1, 0, 0, 0, 206, 2800, 1, 0, 0, 0, 208, 2811, 1, 0, 0, 0, 210, 2830, 1, 0, 0, 0, 212, 2841, 1, 0, 0, 0, 214, 2879, 1, 0, 0, 0, 216, 2900, 1, 0, 0, 0, 218, 2902, 1, 0, 0, 0, 220, 2922, 1, 0, 0, 0, 222, 2934, 1, 0, 0, 0, 224, 2946, 1, 0, 0, 0, 226, 2949, 1, 0, 0, 0, 228, 2952, 1, 0, 0, 0, 230, 2972, 1, 0, 0, 0, 232, 2977, 1, 0, 0, 0, 234, 3026, 1, 0, 0, 0, 236, 3028, 1, 0, 0, 0, 238, 3051, 1, 0, 0, 0, 240, 3067, 1, 0, 0, 0, 242, 3079, 1, 0, 0, 0, 244, 3106, 1, 0, 0, 0, 246, 3121, 1, 0, 0, 0, 248, 3184, 1, 0, 0, 0, 250, 3186, 1, 0, 0, 0, 252, 3191, 1, 0, 0, 0, 254, 3197, 1, 0, 0, 0, 256, 3284, 1, 0, 0, 0, 258, 3290, 1, 0, 0, 0, 260, 3292, 1, 0, 0, 0, 262, 3308, 1, 0, 0, 0, 264, 3310, 1, 0, 0, 0, 266, 3319, 1, 0, 0, 0, 268, 3323, 1, 0, 0, 0, 270, 3336, 1, 0, 0, 0, 272, 3348, 1, 0, 0, 0, 274, 3350, 1, 0, 0, 0, 276, 3372, 1, 0, 0, 0, 278, 3384, 1, 0, 0, 0, 280, 3395, 1, 0, 0, 0, 282, 3486, 1, 0, 0, 0, 284, 3488, 1, 0, 0, 0, 286, 3499, 1, 0, 0, 0, 288, 3510, 1, 0, 0, 0, 290, 3512, 1, 0, 0, 0, 292, 3538, 1, 0, 0, 0, 294, 3540, 1, 0, 0, 0, 296, 3544, 1, 0, 0, 0, 298, 3594, 1, 0, 0, 0, 300, 3596, 1, 0, 0, 0, 302, 3602, 1, 0, 0, 0, 304, 3627, 1, 0, 0, 0, 306, 3631, 1, 0, 0, 0, 308, 3845, 1, 0, 0, 0, 310, 3863, 1, 0, 0, 0, 312, 3889, 1, 0, 0, 0, 314, 3891, 1, 0, 0, 0, 316, 3899, 1, 0, 0, 0, 318, 3905, 1, 0, 0, 0, 320, 3909, 1, 0, 0, 0, 322, 3929, 1, 0, 0, 0, 324, 3935, 1, 0, 0, 0, 326, 4002, 1, 0, 0, 0, 328, 4033, 1, 0, 0, 0, 330, 4079, 1, 0, 0, 0, 332, 4081, 1, 0, 0, 0, 334, 4083, 1, 0, 0, 0, 336, 4094, 1, 0, 0, 0, 338, 4131, 1, 0, 0, 0, 340, 4133, 1, 0, 0, 0, 342, 4139, 1, 0, 0, 0, 344, 4189, 1, 0, 0, 0, 346, 4192, 1, 0, 0, 0, 348, 4206, 1, 0, 0, 0, 350, 4227, 1, 0, 0, 0, 352, 4251, 1, 0, 0, 0, 354, 4292, 1, 0, 0, 0, 356, 4294, 1, 0, 0, 0, 358, 4296, 1, 0, 0, 0, 360, 4336, 1, 0, 0, 0, 362, 4353, 1, 0, 0, 0, 364, 4373, 1, 0, 0, 0, 366, 4426, 1, 0, 0, 0, 368, 4429, 1, 0, 0, 0, 370, 4435, 1, 0, 0, 0, 372, 4443, 1, 0, 0, 0, 374, 4456, 1, 0, 0, 0, 376, 4458, 1, 0, 0, 0, 378, 4471, 1, 0, 0, 0, 380, 4473, 1, 0, 0, 0, 382, 4486, 1, 0, 0, 0, 384, 4496, 1, 0, 0, 0, 386, 4507, 1, 0, 0, 0, 388, 4518, 1, 0, 0, 0, 390, 4520, 1, 0, 0, 0, 392, 4525, 1, 0, 0, 0, 394, 4539, 1, 0, 0, 0, 396, 4571, 1, 0, 0, 0, 398, 4608, 1, 0, 0, 0, 400, 4610, 1, 0, 0, 0, 402, 4613, 1, 0, 0, 0, 404, 4616, 1, 0, 0, 0, 406, 4633, 1, 0, 0, 0, 408, 4654, 1, 0, 0, 0, 410, 4670, 1, 0, 0, 0, 412, 4686, 1, 0, 0, 0, 414, 4708, 1, 0, 0, 0, 416, 4713, 1, 0, 0, 0, 418, 4716, 1, 0, 0, 0, 420, 4724, 1, 0, 0, 0, 422, 4749, 1, 0, 0, 0, 424, 4752, 1, 0, 0, 0, 426, 4780, 1, 0, 0, 0, 428, 4785, 1, 0, 0, 0, 430, 4825, 1, 0, 0, 0, 432, 5037, 1, 0, 0, 0, 434, 5039, 1, 0, 0, 0, 436, 5127, 1, 0, 0, 0, 438, 5129, 1, 0, 0, 0, 440, 5135, 1, 0, 0, 0, 442, 5146, 1, 0, 0, 0, 444, 5156, 1, 0, 0, 0, 446, 5236, 1, 0, 0, 0, 448, 5238, 1, 0, 0, 0, 450, 5252, 1, 0, 0, 0, 452, 5274, 1, 0, 0, 0, 454, 5347, 1, 0, 0, 0, 456, 5349, 1, 0, 0, 0, 458, 5390, 1, 0, 0, 0, 460, 5392, 1, 0, 0, 0, 462, 5397, 1, 0, 0, 0, 464, 5400, 1, 0, 0, 0, 466, 5403, 1, 0, 0, 0, 468, 5453, 1, 0, 0, 0, 470, 5455, 1, 0, 0, 0, 472, 5466, 1, 0, 0, 0, 474, 5468, 1, 0, 0, 0, 476, 5478, 1, 0, 0, 0, 478, 5513, 1, 0, 0, 0, 480, 5516, 1, 0, 0, 0, 482, 5537, 1, 0, 0, 0, 484, 5547, 1, 0, 0, 0, 486, 5567, 1, 0, 0, 0, 488, 5573, 1, 0, 0, 0, 490, 5579, 1, 0, 0, 0, 492, 5584, 1, 0, 0, 0, 494, 5597, 1, 0, 0, 0, 496, 5624, 1, 0, 0, 0, 498, 5672, 1, 0, 0, 0, 500, 5674, 1, 0, 0, 0, 502, 5712, 1, 0, 0, 0, 504, 5714, 1, 0, 0, 0, 506, 5735, 1, 0, 0, 0, 508, 5755, 1, 0, 0, 0, 510, 5759, 1, 0, 0, 0, 512, 5774, 1, 0, 0, 0, 514, 5776, 1, 0, 0, 0, 516, 5780, 1, 0, 0, 0, 518, 5784, 1, 0, 0, 0, 520, 5792, 1, 0, 0, 0, 522, 5816, 1, 0, 0, 0, 524, 5818, 1, 0, 0, 0, 526, 5829, 1, 0, 0, 0, 528, 5837, 1, 0, 0, 0, 530, 5852, 1, 0, 0, 0, 532, 5877, 1, 0, 0, 0, 534, 5879, 1, 0, 0, 0, 536, 5883, 1, 0, 0, 0, 538, 5892, 1, 0, 0, 0, 540, 5932, 1, 0, 0, 0, 542, 5943, 1, 0, 0, 0, 544, 5951, 1, 0, 0, 0, 546, 5954, 1, 0, 0, 0, 548, 5958, 1, 0, 0, 0, 550, 5973, 1, 0, 0, 0, 552, 5998, 1, 0, 0, 0, 554, 6013, 1, 0, 0, 0, 556, 6039, 1, 0, 0, 0, 558, 6041, 1, 0, 0, 0, 560, 6064, 1, 0, 0, 0, 562, 6066, 1, 0, 0, 0, 564, 6074, 1, 0, 0, 0, 566, 6092, 1, 0, 0, 0, 568, 6116, 1, 0, 0, 0, 570, 6128, 1, 0, 0, 0, 572, 6132, 1, 0, 0, 0, 574, 6144, 1, 0, 0, 0, 576, 6164, 1, 0, 0, 0, 578, 6172, 1, 0, 0, 0, 580, 6186, 1, 0, 0, 0, 582, 6209, 1, 0, 0, 0, 584, 6211, 1, 0, 0, 0, 586, 6216, 1, 0, 0, 0, 588, 6226, 1, 0, 0, 0, 590, 6247, 1, 0, 0, 0, 592, 6249, 1, 0, 0, 0, 594, 6258, 1, 0, 0, 0, 596, 6269, 1, 0, 0, 0, 598, 6279, 1, 0, 0, 0, 600, 6281, 1, 0, 0, 0, 602, 6288, 1, 0, 0, 0, 604, 6319, 1, 0, 0, 0, 606, 6349, 1, 0, 0, 0, 608, 6351, 1, 0, 0, 0, 610, 6360, 1, 0, 0, 0, 612, 6363, 1, 0, 0, 0, 614, 6434, 1, 0, 0, 0, 616, 6458, 1, 0, 0, 0, 618, 6479, 1, 0, 0, 0, 620, 6481, 1, 0, 0, 0, 622, 6489, 1, 0, 0, 0, 624, 6506, 1, 0, 0, 0, 626, 6532, 1, 0, 0, 0, 628, 6534, 1, 0, 0, 0, 630, 6542, 1, 0, 0, 0, 632, 6549, 1, 0, 0, 0, 634, 6573, 1, 0, 0, 0, 636, 6579, 1, 0, 0, 0, 638, 6587, 1, 0, 0, 0, 640, 6590, 1, 0, 0, 0, 642, 6597, 1, 0, 0, 0, 644, 6605, 1, 0, 0, 0, 646, 6610, 1, 0, 0, 0, 648, 6640, 1, 0, 0, 0, 650, 6667, 1, 0, 0, 0, 652, 6695, 1, 0, 0, 0, 654, 6712, 1, 0, 0, 0, 656, 6718, 1, 0, 0, 0, 658, 6736, 1, 0, 0, 0, 660, 6738, 1, 0, 0, 0, 662, 6742, 1, 0, 0, 0, 664, 6759, 1, 0, 0, 0, 666, 6764, 1, 0, 0, 0, 668, 6802, 1, 0, 0, 0, 670, 6804, 1, 0, 0, 0, 672, 6808, 1, 0, 0, 0, 674, 6810, 1, 0, 0, 0, 676, 6819, 1, 0, 0, 0, 678, 6903, 1, 0, 0, 0, 680, 6909, 1, 0, 0, 0, 682, 7018, 1, 0, 0, 0, 684, 7050, 1, 0, 0, 0, 686, 7101, 1, 0, 0, 0, 688, 7105, 1, 0, 0, 0, 690, 7281, 1, 0, 0, 0, 692, 7283, 1, 0, 0, 0, 694, 7291, 1, 0, 0, 0, 696, 7296, 1, 0, 0, 0, 698, 7298, 1, 0, 0, 0, 700, 7306, 1, 0, 0, 0, 702, 7309, 1, 0, 0, 0, 704, 7318, 1, 0, 0, 0, 706, 7322, 1, 0, 0, 0, 708, 7327, 1, 0, 0, 0, 710, 7344, 1, 0, 0, 0, 712, 7371, 1, 0, 0, 0, 714, 7380, 1, 0, 0, 0, 716, 7382, 1, 0, 0, 0, 718, 7389, 1, 0, 0, 0, 720, 7393, 1, 0, 0, 0, 722, 7395, 1, 0, 0, 0, 724, 7403, 1, 0, 0, 0, 726, 7411, 1, 0, 0, 0, 728, 7418, 1, 0, 0, 0, 730, 7420, 1, 0, 0, 0, 732, 7433, 1, 0, 0, 0, 734, 7437, 1, 0, 0, 0, 736, 7439, 1, 0, 0, 0, 738, 7453, 1, 0, 0, 0, 740, 7455, 1, 0, 0, 0, 742, 7477, 1, 0, 0, 0, 744, 7479, 1, 0, 0, 0, 746, 7502, 1, 0, 0, 0, 748, 7504, 1, 0, 0, 0, 750, 7526, 1, 0, 0, 0, 752, 7529, 1, 0, 0, 0, 754, 7536, 1, 0, 0, 0, 756, 7539, 1, 0, 0, 0, 758, 7555, 1, 0, 0, 0, 760, 7557, 1, 0, 0, 0, 762, 7565, 1, 0, 0, 0, 764, 7573, 1, 0, 0, 0, 766, 7581, 1, 0, 0, 0, 768, 7589, 1, 0, 0, 0, 770, 7591, 1, 0, 0, 0, 772, 7593, 1, 0, 0, 0, 774, 7595, 1, 0, 0, 0, 776, 7597, 1, 0, 0, 0, 778, 7599, 1, 0, 0, 0, 780, 7601, 1, 0, 0, 0, 782, 7605, 1, 0, 0, 0, 784, 7613, 1, 0, 0, 0, 786, 7621, 1, 0, 0, 0, 788, 7623, 1, 0, 0, 0, 790, 7625, 1, 0, 0, 0, 792, 7627, 1, 0, 0, 0, 794, 7629, 1, 0, 0, 0, 796, 7635, 1, 0, 0, 0, 798, 7641, 1, 0, 0, 0, 800, 7647, 1, 0, 0, 0, 802, 7649, 1, 0, 0, 0, 804, 7655, 1, 0, 0, 0, 806, 7661, 1, 0, 0, 0, 808, 7663, 1, 0, 0, 0, 810, 7679, 1, 0, 0, 0, 812, 7682, 1, 0, 0, 0, 814, 7691, 1, 0, 0, 0, 816, 7693, 1, 0, 0, 0, 818, 7703, 1, 0, 0, 0, 820, 7707, 1, 0, 0, 0, 822, 7712, 1, 0, 0, 0, 824, 7718, 1, 0, 0, 0, 826, 7731, 1, 0, 0, 0, 828, 7733, 1, 0, 0, 0, 830, 7786, 1, 0, 0, 0, 832, 7788, 1, 0, 0, 0, 834, 7790, 1, 0, 0, 0, 836, 7793, 1, 0, 0, 0, 838, 7821, 1, 0, 0, 0, 840, 7825, 1, 0, 0, 0, 842, 7876, 1, 0, 0, 0, 844, 7879, 1, 0, 0, 0, 846, 7905, 1, 0, 0, 0, 848, 7907, 1, 0, 0, 0, 850, 7930, 1, 0, 0, 0, 852, 7932, 1, 0, 0, 0, 854, 7937, 1, 0, 0, 0, 856, 7952, 1, 0, 0, 0, 858, 7958, 1, 0, 0, 0, 860, 7969, 1, 0, 0, 0, 862, 7999, 1, 0, 0, 0, 864, 8006, 1, 0, 0, 0, 866, 8031, 1, 0, 0, 0, 868, 8041, 1, 0, 0, 0, 870, 8068, 1, 0, 0, 0, 872, 8081, 1, 0, 0, 0, 874, 8091, 1, 0, 0, 0, 876, 8110, 1, 0, 0, 0, 878, 8142, 1, 0, 0, 0, 880, 8146, 1, 0, 0, 0, 882, 8154, 1, 0, 0, 0, 884, 8168, 1, 0, 0, 0, 886, 8174, 1, 0, 0, 0, 888, 8195, 1, 0, 0, 0, 890, 8201, 1, 0, 0, 0, 892, 8240, 1, 0, 0, 0, 894, 8244, 1, 0, 0, 0, 896, 8270, 1, 0, 0, 0, 898, 8272, 1, 0, 0, 0, 900, 8280, 1, 0, 0, 0, 902, 8317, 1, 0, 0, 0, 904, 8351, 1, 0, 0, 0, 906, 8353, 1, 0, 0, 0, 908, 8364, 1, 0, 0, 0, 910, 8401, 1, 0, 0, 0, 912, 8405, 1, 0, 0, 0, 914, 8407, 1, 0, 0, 0, 916, 8411, 1, 0, 0, 0, 918, 8414, 1, 0, 0, 0, 920, 8436, 1, 0, 0, 0, 922, 8440, 1, 0, 0, 0, 924, 8442, 1, 0, 0, 0, 926, 8466, 1, 0, 0, 0, 928, 8470, 1, 0, 0, 0, 930, 8473, 1, 0, 0, 0, 932, 934, 3, 2, 1, 0, 933, 932, 1, 0, 0, 0, 934, 937, 1, 0, 0, 0, 935, 933, 1, 0, 0, 0, 935, 936, 1, 0, 0, 0, 936, 938, 1, 0, 0, 0, 937, 935, 1, 0, 0, 0, 938, 939, 5, 0, 0, 1, 939, 1, 1, 0, 0, 0, 940, 942, 3, 4, 2, 0, 941, 943, 5, 7, 0, 0, 942, 941, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 3, 1, 0, 0, 0, 944, 1065, 3, 278, 139, 0, 945, 1065, 3, 488, 244, 0, 946, 1065, 3, 484, 242, 0, 947, 1065, 3, 486, 243, 0, 948, 1065, 3, 352, 176, 0, 949, 1065, 3, 494, 247, 0, 950, 1065, 3, 292, 146, 0, 951, 1065, 3, 210, 105, 0, 952, 1065, 3, 212, 106, 0, 953, 1065, 3, 218, 109, 0, 954, 1065, 3, 232, 116, 0, 955, 1065, 3, 404, 202, 0, 956, 1065, 3, 28, 14, 0, 957, 1065, 3, 434, 217, 0, 958, 1065, 3, 436, 218, 0, 959, 1065, 3, 446, 223, 0, 960, 1065, 3, 438, 219, 0, 961, 1065, 3, 444, 222, 0, 962, 1065, 3, 244, 122, 0, 963, 1065, 3, 246, 123, 0, 964, 1065, 3, 198, 99, 0, 965, 1065, 3, 490, 245, 0, 966, 1065, 3, 76, 38, 0, 967, 1065, 3, 430, 215, 0, 968, 1065, 3, 108, 54, 0, 969, 1065, 3, 450, 225, 0, 970, 1065, 3, 18, 9, 0, 971, 1065, 3, 20, 10, 0, 972, 1065, 3, 16, 8, 0, 973, 1065, 3, 454, 227, 0, 974, 1065, 3, 184, 92, 0, 975, 1065, 3, 498, 249, 0, 976, 1065, 3, 496, 248, 0, 977, 1065, 3, 240, 120, 0, 978, 1065, 3, 506, 253, 0, 979, 1065, 3, 6, 3, 0, 980, 1065, 3, 72, 36, 0, 981, 1065, 3, 112, 56, 0, 982, 1065, 3, 502, 251, 0, 983, 1065, 3, 324, 162, 0, 984, 1065, 3, 70, 35, 0, 985, 1065, 3, 114, 57, 0, 986, 1065, 3, 254, 127, 0, 987, 1065, 3, 186, 93, 0, 988, 1065, 3, 280, 140, 0, 989, 1065, 3, 420, 210, 0, 990, 1065, 3, 500, 250, 0, 991, 1065, 3, 492, 246, 0, 992, 1065, 3, 208, 104, 0, 993, 1065, 3, 214, 107, 0, 994, 1065, 3, 228, 114, 0, 995, 1065, 3, 234, 117, 0, 996, 1065, 3, 364, 182, 0, 997, 1065, 3, 26, 13, 0, 998, 1065, 3, 192, 96, 0, 999, 1065, 3, 296, 148, 0, 1000, 1065, 3, 300, 150, 0, 1001, 1065, 3, 448, 224, 0, 1002, 1065, 3, 302, 151, 0, 1003, 1065, 3, 242, 121, 0, 1004, 1065, 3, 204, 102, 0, 1005, 1065, 3, 30, 15, 0, 1006, 1065, 3, 196, 98, 0, 1007, 1065, 3, 120, 60, 0, 1008, 1065, 3, 452, 226, 0, 1009, 1065, 3, 182, 91, 0, 1010, 1065, 3, 206, 103, 0, 1011, 1065, 3, 424, 212, 0, 1012, 1065, 3, 256, 128, 0, 1013, 1065, 3, 274, 137, 0, 1014, 1065, 3, 8, 4, 0, 1015, 1065, 3, 14, 7, 0, 1016, 1065, 3, 238, 119, 0, 1017, 1065, 3, 480, 240, 0, 1018, 1065, 3, 536, 268, 0, 1019, 1065, 3, 558, 279, 0, 1020, 1065, 3, 282, 141, 0, 1021, 1065, 3, 548, 274, 0, 1022, 1065, 3, 74, 37, 0, 1023, 1065, 3, 418, 209, 0, 1024, 1065, 3, 308, 154, 0, 1025, 1065, 3, 532, 266, 0, 1026, 1065, 3, 520, 260, 0, 1027, 1065, 3, 328, 164, 0, 1028, 1065, 3, 334, 167, 0, 1029, 1065, 3, 348, 174, 0, 1030, 1065, 3, 900, 450, 0, 1031, 1065, 3, 236, 118, 0, 1032, 1065, 3, 358, 179, 0, 1033, 1065, 3, 538, 269, 0, 1034, 1065, 3, 464, 232, 0, 1035, 1065, 3, 194, 97, 0, 1036, 1065, 3, 478, 239, 0, 1037, 1065, 3, 550, 275, 0, 1038, 1065, 3, 460, 230, 0, 1039, 1065, 3, 526, 263, 0, 1040, 1065, 3, 306, 153, 0, 1041, 1065, 3, 428, 214, 0, 1042, 1065, 3, 408, 204, 0, 1043, 1065, 3, 406, 203, 0, 1044, 1065, 3, 410, 205, 0, 1045, 1065, 3, 432, 216, 0, 1046, 1065, 3, 336, 168, 0, 1047, 1065, 3, 350, 175, 0, 1048, 1065, 3, 456, 228, 0, 1049, 1065, 3, 326, 163, 0, 1050, 1065, 3, 560, 280, 0, 1051, 1065, 3, 468, 234, 0, 1052, 1065, 3, 320, 160, 0, 1053, 1065, 3, 466, 233, 0, 1054, 1065, 3, 552, 276, 0, 1055, 1065, 3, 504, 252, 0, 1056, 1065, 3, 60, 30, 0, 1057, 1065, 3, 36, 18, 0, 1058, 1065, 3, 68, 34, 0, 1059, 1065, 3, 476, 238, 0, 1060, 1062, 5, 581, 0, 0, 1061, 1063, 5, 582, 0, 0, 1062, 1061, 1, 0, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1065, 1, 0, 0, 0, 1064, 944, 1, 0, 0, 0, 1064, 945, 1, 0, 0, 0, 1064, 946, 1, 0, 0, 0, 1064, 947, 1, 0, 0, 0, 1064, 948, 1, 0, 0, 0, 1064, 949, 1, 0, 0, 0, 1064, 950, 1, 0, 0, 0, 1064, 951, 1, 0, 0, 0, 1064, 952, 1, 0, 0, 0, 1064, 953, 1, 0, 0, 0, 1064, 954, 1, 0, 0, 0, 1064, 955, 1, 0, 0, 0, 1064, 956, 1, 0, 0, 0, 1064, 957, 1, 0, 0, 0, 1064, 958, 1, 0, 0, 0, 1064, 959, 1, 0, 0, 0, 1064, 960, 1, 0, 0, 0, 1064, 961, 1, 0, 0, 0, 1064, 962, 1, 0, 0, 0, 1064, 963, 1, 0, 0, 0, 1064, 964, 1, 0, 0, 0, 1064, 965, 1, 0, 0, 0, 1064, 966, 1, 0, 0, 0, 1064, 967, 1, 0, 0, 0, 1064, 968, 1, 0, 0, 0, 1064, 969, 1, 0, 0, 0, 1064, 970, 1, 0, 0, 0, 1064, 971, 1, 0, 0, 0, 1064, 972, 1, 0, 0, 0, 1064, 973, 1, 0, 0, 0, 1064, 974, 1, 0, 0, 0, 1064, 975, 1, 0, 0, 0, 1064, 976, 1, 0, 0, 0, 1064, 977, 1, 0, 0, 0, 1064, 978, 1, 0, 0, 0, 1064, 979, 1, 0, 0, 0, 1064, 980, 1, 0, 0, 0, 1064, 981, 1, 0, 0, 0, 1064, 982, 1, 0, 0, 0, 1064, 983, 1, 0, 0, 0, 1064, 984, 1, 0, 0, 0, 1064, 985, 1, 0, 0, 0, 1064, 986, 1, 0, 0, 0, 1064, 987, 1, 0, 0, 0, 1064, 988, 1, 0, 0, 0, 1064, 989, 1, 0, 0, 0, 1064, 990, 1, 0, 0, 0, 1064, 991, 1, 0, 0, 0, 1064, 992, 1, 0, 0, 0, 1064, 993, 1, 0, 0, 0, 1064, 994, 1, 0, 0, 0, 1064, 995, 1, 0, 0, 0, 1064, 996, 1, 0, 0, 0, 1064, 997, 1, 0, 0, 0, 1064, 998, 1, 0, 0, 0, 1064, 999, 1, 0, 0, 0, 1064, 1000, 1, 0, 0, 0, 1064, 1001, 1, 0, 0, 0, 1064, 1002, 1, 0, 0, 0, 1064, 1003, 1, 0, 0, 0, 1064, 1004, 1, 0, 0, 0, 1064, 1005, 1, 0, 0, 0, 1064, 1006, 1, 0, 0, 0, 1064, 1007, 1, 0, 0, 0, 1064, 1008, 1, 0, 0, 0, 1064, 1009, 1, 0, 0, 0, 1064, 1010, 1, 0, 0, 0, 1064, 1011, 1, 0, 0, 0, 1064, 1012, 1, 0, 0, 0, 1064, 1013, 1, 0, 0, 0, 1064, 1014, 1, 0, 0, 0, 1064, 1015, 1, 0, 0, 0, 1064, 1016, 1, 0, 0, 0, 1064, 1017, 1, 0, 0, 0, 1064, 1018, 1, 0, 0, 0, 1064, 1019, 1, 0, 0, 0, 1064, 1020, 1, 0, 0, 0, 1064, 1021, 1, 0, 0, 0, 1064, 1022, 1, 0, 0, 0, 1064, 1023, 1, 0, 0, 0, 1064, 1024, 1, 0, 0, 0, 1064, 1025, 1, 0, 0, 0, 1064, 1026, 1, 0, 0, 0, 1064, 1027, 1, 0, 0, 0, 1064, 1028, 1, 0, 0, 0, 1064, 1029, 1, 0, 0, 0, 1064, 1030, 1, 0, 0, 0, 1064, 1031, 1, 0, 0, 0, 1064, 1032, 1, 0, 0, 0, 1064, 1033, 1, 0, 0, 0, 1064, 1034, 1, 0, 0, 0, 1064, 1035, 1, 0, 0, 0, 1064, 1036, 1, 0, 0, 0, 1064, 1037, 1, 0, 0, 0, 1064, 1038, 1, 0, 0, 0, 1064, 1039, 1, 0, 0, 0, 1064, 1040, 1, 0, 0, 0, 1064, 1041, 1, 0, 0, 0, 1064, 1042, 1, 0, 0, 0, 1064, 1043, 1, 0, 0, 0, 1064, 1044, 1, 0, 0, 0, 1064, 1045, 1, 0, 0, 0, 1064, 1046, 1, 0, 0, 0, 1064, 1047, 1, 0, 0, 0, 1064, 1048, 1, 0, 0, 0, 1064, 1049, 1, 0, 0, 0, 1064, 1050, 1, 0, 0, 0, 1064, 1051, 1, 0, 0, 0, 1064, 1052, 1, 0, 0, 0, 1064, 1053, 1, 0, 0, 0, 1064, 1054, 1, 0, 0, 0, 1064, 1055, 1, 0, 0, 0, 1064, 1056, 1, 0, 0, 0, 1064, 1057, 1, 0, 0, 0, 1064, 1058, 1, 0, 0, 0, 1064, 1059, 1, 0, 0, 0, 1064, 1060, 1, 0, 0, 0, 1065, 5, 1, 0, 0, 0, 1066, 1067, 5, 433, 0, 0, 1067, 1068, 3, 684, 342, 0, 1068, 7, 1, 0, 0, 0, 1069, 1070, 5, 46, 0, 0, 1070, 1071, 5, 318, 0, 0, 1071, 1073, 3, 814, 407, 0, 1072, 1074, 5, 105, 0, 0, 1073, 1072, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1078, 1, 0, 0, 0, 1075, 1077, 3, 12, 6, 0, 1076, 1075, 1, 0, 0, 0, 1077, 1080, 1, 0, 0, 0, 1078, 1076, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 9, 1, 0, 0, 0, 1080, 1078, 1, 0, 0, 0, 1081, 1084, 5, 287, 0, 0, 1082, 1085, 3, 808, 404, 0, 1083, 1085, 5, 78, 0, 0, 1084, 1082, 1, 0, 0, 0, 1084, 1083, 1, 0, 0, 0, 1085, 1120, 1, 0, 0, 0, 1086, 1087, 7, 0, 0, 0, 1087, 1088, 5, 287, 0, 0, 1088, 1120, 3, 808, 404, 0, 1089, 1120, 5, 228, 0, 0, 1090, 1120, 5, 229, 0, 0, 1091, 1120, 5, 236, 0, 0, 1092, 1120, 5, 237, 0, 0, 1093, 1120, 5, 234, 0, 0, 1094, 1120, 5, 235, 0, 0, 1095, 1120, 5, 232, 0, 0, 1096, 1120, 5, 233, 0, 0, 1097, 1120, 5, 230, 0, 0, 1098, 1120, 5, 231, 0, 0, 1099, 1120, 5, 535, 0, 0, 1100, 1120, 5, 536, 0, 0, 1101, 1120, 5, 537, 0, 0, 1102, 1120, 5, 538, 0, 0, 1103, 1120, 5, 539, 0, 0, 1104, 1120, 5, 540, 0, 0, 1105, 1106, 5, 164, 0, 0, 1106, 1107, 5, 74, 0, 0, 1107, 1120, 3, 812, 406, 0, 1108, 1109, 5, 371, 0, 0, 1109, 1110, 5, 368, 0, 0, 1110, 1120, 3, 808, 404, 0, 1111, 1112, 5, 68, 0, 0, 1112, 1113, 7, 1, 0, 0, 1113, 1120, 3, 784, 392, 0, 1114, 1115, 7, 2, 0, 0, 1115, 1120, 3, 816, 408, 0, 1116, 1117, 5, 134, 0, 0, 1117, 1120, 3, 784, 392, 0, 1118, 1120, 3, 826, 413, 0, 1119, 1081, 1, 0, 0, 0, 1119, 1086, 1, 0, 0, 0, 1119, 1089, 1, 0, 0, 0, 1119, 1090, 1, 0, 0, 0, 1119, 1091, 1, 0, 0, 0, 1119, 1092, 1, 0, 0, 0, 1119, 1093, 1, 0, 0, 0, 1119, 1094, 1, 0, 0, 0, 1119, 1095, 1, 0, 0, 0, 1119, 1096, 1, 0, 0, 0, 1119, 1097, 1, 0, 0, 0, 1119, 1098, 1, 0, 0, 0, 1119, 1099, 1, 0, 0, 0, 1119, 1100, 1, 0, 0, 0, 1119, 1101, 1, 0, 0, 0, 1119, 1102, 1, 0, 0, 0, 1119, 1103, 1, 0, 0, 0, 1119, 1104, 1, 0, 0, 0, 1119, 1105, 1, 0, 0, 0, 1119, 1108, 1, 0, 0, 0, 1119, 1111, 1, 0, 0, 0, 1119, 1114, 1, 0, 0, 0, 1119, 1116, 1, 0, 0, 0, 1119, 1118, 1, 0, 0, 0, 1120, 11, 1, 0, 0, 0, 1121, 1130, 3, 10, 5, 0, 1122, 1123, 5, 348, 0, 0, 1123, 1130, 5, 571, 0, 0, 1124, 1125, 7, 3, 0, 0, 1125, 1130, 3, 816, 408, 0, 1126, 1127, 5, 68, 0, 0, 1127, 1128, 7, 1, 0, 0, 1128, 1130, 3, 816, 408, 0, 1129, 1121, 1, 0, 0, 0, 1129, 1122, 1, 0, 0, 0, 1129, 1124, 1, 0, 0, 0, 1129, 1126, 1, 0, 0, 0, 1130, 13, 1, 0, 0, 0, 1131, 1132, 5, 46, 0, 0, 1132, 1133, 5, 99, 0, 0, 1133, 1135, 3, 814, 407, 0, 1134, 1136, 5, 105, 0, 0, 1135, 1134, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1140, 1, 0, 0, 0, 1137, 1139, 3, 12, 6, 0, 1138, 1137, 1, 0, 0, 0, 1139, 1142, 1, 0, 0, 0, 1140, 1138, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 15, 1, 0, 0, 0, 1142, 1140, 1, 0, 0, 0, 1143, 1144, 5, 138, 0, 0, 1144, 1145, 7, 2, 0, 0, 1145, 1147, 3, 814, 407, 0, 1146, 1148, 5, 105, 0, 0, 1147, 1146, 1, 0, 0, 0, 1147, 1148, 1, 0, 0, 0, 1148, 1152, 1, 0, 0, 0, 1149, 1151, 3, 10, 5, 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, 17, 1, 0, 0, 0, 1154, 1152, 1, 0, 0, 0, 1155, 1156, 5, 138, 0, 0, 1156, 1159, 7, 2, 0, 0, 1157, 1160, 5, 30, 0, 0, 1158, 1160, 3, 814, 407, 0, 1159, 1157, 1, 0, 0, 0, 1159, 1158, 1, 0, 0, 0, 1160, 1161, 1, 0, 0, 0, 1161, 1162, 5, 68, 0, 0, 1162, 1163, 5, 175, 0, 0, 1163, 1164, 3, 788, 394, 0, 1164, 1165, 3, 64, 32, 0, 1165, 19, 1, 0, 0, 0, 1166, 1167, 5, 138, 0, 0, 1167, 1168, 5, 442, 0, 0, 1168, 1170, 3, 794, 397, 0, 1169, 1171, 3, 368, 184, 0, 1170, 1169, 1, 0, 0, 0, 1170, 1171, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 1173, 3, 22, 11, 0, 1173, 21, 1, 0, 0, 0, 1174, 1178, 3, 24, 12, 0, 1175, 1177, 3, 24, 12, 0, 1176, 1175, 1, 0, 0, 0, 1177, 1180, 1, 0, 0, 0, 1178, 1176, 1, 0, 0, 0, 1178, 1179, 1, 0, 0, 0, 1179, 1182, 1, 0, 0, 0, 1180, 1178, 1, 0, 0, 0, 1181, 1183, 5, 315, 0, 0, 1182, 1181, 1, 0, 0, 0, 1182, 1183, 1, 0, 0, 0, 1183, 1201, 1, 0, 0, 0, 1184, 1185, 5, 309, 0, 0, 1185, 1186, 5, 94, 0, 0, 1186, 1201, 3, 792, 396, 0, 1187, 1188, 5, 282, 0, 0, 1188, 1189, 5, 94, 0, 0, 1189, 1201, 3, 814, 407, 0, 1190, 1191, 5, 333, 0, 0, 1191, 1192, 5, 323, 0, 0, 1192, 1201, 3, 32, 16, 0, 1193, 1195, 5, 269, 0, 0, 1194, 1193, 1, 0, 0, 0, 1194, 1195, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1197, 5, 462, 0, 0, 1197, 1198, 5, 80, 0, 0, 1198, 1199, 5, 204, 0, 0, 1199, 1201, 3, 818, 409, 0, 1200, 1174, 1, 0, 0, 0, 1200, 1184, 1, 0, 0, 0, 1200, 1187, 1, 0, 0, 0, 1200, 1190, 1, 0, 0, 0, 1200, 1194, 1, 0, 0, 0, 1201, 23, 1, 0, 0, 0, 1202, 1245, 5, 222, 0, 0, 1203, 1245, 5, 338, 0, 0, 1204, 1245, 5, 377, 0, 0, 1205, 1207, 5, 77, 0, 0, 1206, 1205, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1245, 5, 250, 0, 0, 1209, 1211, 5, 205, 0, 0, 1210, 1209, 1, 0, 0, 0, 1210, 1211, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1213, 5, 327, 0, 0, 1213, 1220, 5, 243, 0, 0, 1214, 1216, 5, 205, 0, 0, 1215, 1214, 1, 0, 0, 0, 1215, 1216, 1, 0, 0, 0, 1216, 1217, 1, 0, 0, 0, 1217, 1218, 5, 327, 0, 0, 1218, 1220, 5, 181, 0, 0, 1219, 1210, 1, 0, 0, 0, 1219, 1215, 1, 0, 0, 0, 1220, 1245, 1, 0, 0, 0, 1221, 1222, 5, 460, 0, 0, 1222, 1245, 7, 4, 0, 0, 1223, 1224, 5, 170, 0, 0, 1224, 1245, 3, 824, 412, 0, 1225, 1226, 5, 320, 0, 0, 1226, 1245, 3, 818, 409, 0, 1227, 1228, 5, 333, 0, 0, 1228, 1229, 3, 818, 409, 0, 1229, 1232, 7, 5, 0, 0, 1230, 1233, 3, 818, 409, 0, 1231, 1233, 5, 53, 0, 0, 1232, 1230, 1, 0, 0, 0, 1232, 1231, 1, 0, 0, 0, 1233, 1245, 1, 0, 0, 0, 1234, 1235, 5, 333, 0, 0, 1235, 1236, 3, 818, 409, 0, 1236, 1237, 5, 64, 0, 0, 1237, 1238, 5, 434, 0, 0, 1238, 1245, 1, 0, 0, 0, 1239, 1242, 5, 313, 0, 0, 1240, 1243, 3, 818, 409, 0, 1241, 1243, 5, 30, 0, 0, 1242, 1240, 1, 0, 0, 0, 1242, 1241, 1, 0, 0, 0, 1243, 1245, 1, 0, 0, 0, 1244, 1202, 1, 0, 0, 0, 1244, 1203, 1, 0, 0, 0, 1244, 1204, 1, 0, 0, 0, 1244, 1206, 1, 0, 0, 0, 1244, 1219, 1, 0, 0, 0, 1244, 1221, 1, 0, 0, 0, 1244, 1223, 1, 0, 0, 0, 1244, 1225, 1, 0, 0, 0, 1244, 1227, 1, 0, 0, 0, 1244, 1234, 1, 0, 0, 0, 1244, 1239, 1, 0, 0, 0, 1245, 25, 1, 0, 0, 0, 1246, 1247, 5, 46, 0, 0, 1247, 1248, 5, 66, 0, 0, 1248, 1250, 3, 814, 407, 0, 1249, 1251, 5, 105, 0, 0, 1250, 1249, 1, 0, 0, 0, 1250, 1251, 1, 0, 0, 0, 1251, 1255, 1, 0, 0, 0, 1252, 1254, 3, 12, 6, 0, 1253, 1252, 1, 0, 0, 0, 1254, 1257, 1, 0, 0, 0, 1255, 1253, 1, 0, 0, 0, 1255, 1256, 1, 0, 0, 0, 1256, 27, 1, 0, 0, 0, 1257, 1255, 1, 0, 0, 0, 1258, 1259, 5, 138, 0, 0, 1259, 1260, 5, 66, 0, 0, 1260, 1261, 3, 814, 407, 0, 1261, 1262, 7, 6, 0, 0, 1262, 1263, 5, 99, 0, 0, 1263, 1264, 3, 816, 408, 0, 1264, 29, 1, 0, 0, 0, 1265, 1266, 5, 46, 0, 0, 1266, 1268, 5, 323, 0, 0, 1267, 1269, 3, 294, 147, 0, 1268, 1267, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, 1276, 1, 0, 0, 0, 1270, 1272, 3, 32, 16, 0, 1271, 1270, 1, 0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 1273, 1, 0, 0, 0, 1273, 1274, 5, 106, 0, 0, 1274, 1277, 3, 814, 407, 0, 1275, 1277, 3, 32, 16, 0, 1276, 1271, 1, 0, 0, 0, 1276, 1275, 1, 0, 0, 0, 1277, 1281, 1, 0, 0, 0, 1278, 1280, 3, 34, 17, 0, 1279, 1278, 1, 0, 0, 0, 1280, 1283, 1, 0, 0, 0, 1281, 1279, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 31, 1, 0, 0, 0, 1283, 1281, 1, 0, 0, 0, 1284, 1285, 3, 316, 158, 0, 1285, 33, 1, 0, 0, 0, 1286, 1293, 3, 120, 60, 0, 1287, 1293, 3, 358, 179, 0, 1288, 1293, 3, 196, 98, 0, 1289, 1293, 3, 256, 128, 0, 1290, 1293, 3, 334, 167, 0, 1291, 1293, 3, 476, 238, 0, 1292, 1286, 1, 0, 0, 0, 1292, 1287, 1, 0, 0, 0, 1292, 1288, 1, 0, 0, 0, 1292, 1289, 1, 0, 0, 0, 1292, 1290, 1, 0, 0, 0, 1292, 1291, 1, 0, 0, 0, 1293, 35, 1, 0, 0, 0, 1294, 1296, 5, 333, 0, 0, 1295, 1297, 7, 7, 0, 0, 1296, 1295, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 1298, 1, 0, 0, 0, 1298, 1299, 3, 38, 19, 0, 1299, 37, 1, 0, 0, 0, 1300, 1301, 5, 356, 0, 0, 1301, 1309, 3, 474, 237, 0, 1302, 1303, 5, 332, 0, 0, 1303, 1304, 5, 154, 0, 0, 1304, 1305, 5, 36, 0, 0, 1305, 1306, 5, 356, 0, 0, 1306, 1309, 3, 474, 237, 0, 1307, 1309, 3, 42, 21, 0, 1308, 1300, 1, 0, 0, 0, 1308, 1302, 1, 0, 0, 0, 1308, 1307, 1, 0, 0, 0, 1309, 39, 1, 0, 0, 0, 1310, 1313, 5, 30, 0, 0, 1311, 1313, 3, 44, 22, 0, 1312, 1310, 1, 0, 0, 0, 1312, 1311, 1, 0, 0, 0, 1313, 1315, 1, 0, 0, 0, 1314, 1316, 7, 5, 0, 0, 1315, 1314, 1, 0, 0, 0, 1315, 1316, 1, 0, 0, 0, 1316, 1319, 1, 0, 0, 0, 1317, 1320, 5, 53, 0, 0, 1318, 1320, 3, 46, 23, 0, 1319, 1317, 1, 0, 0, 0, 1319, 1318, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 41, 1, 0, 0, 0, 1321, 1322, 5, 418, 0, 0, 1322, 1323, 5, 386, 0, 0, 1323, 1350, 3, 56, 28, 0, 1324, 1325, 5, 152, 0, 0, 1325, 1350, 3, 808, 404, 0, 1326, 1327, 5, 323, 0, 0, 1327, 1350, 3, 790, 395, 0, 1328, 1331, 5, 267, 0, 0, 1329, 1332, 3, 808, 404, 0, 1330, 1332, 5, 53, 0, 0, 1331, 1329, 1, 0, 0, 0, 1331, 1330, 1, 0, 0, 0, 1331, 1332, 1, 0, 0, 0, 1332, 1350, 1, 0, 0, 0, 1333, 1334, 5, 318, 0, 0, 1334, 1350, 3, 58, 29, 0, 1335, 1336, 5, 332, 0, 0, 1336, 1337, 5, 106, 0, 0, 1337, 1350, 3, 58, 29, 0, 1338, 1339, 5, 383, 0, 0, 1339, 1340, 5, 279, 0, 0, 1340, 1350, 3, 696, 348, 0, 1341, 1342, 5, 356, 0, 0, 1342, 1343, 5, 337, 0, 0, 1343, 1350, 3, 808, 404, 0, 1344, 1345, 3, 44, 22, 0, 1345, 1346, 5, 64, 0, 0, 1346, 1347, 5, 434, 0, 0, 1347, 1350, 1, 0, 0, 0, 1348, 1350, 3, 40, 20, 0, 1349, 1321, 1, 0, 0, 0, 1349, 1324, 1, 0, 0, 0, 1349, 1326, 1, 0, 0, 0, 1349, 1328, 1, 0, 0, 0, 1349, 1333, 1, 0, 0, 0, 1349, 1335, 1, 0, 0, 0, 1349, 1338, 1, 0, 0, 0, 1349, 1341, 1, 0, 0, 0, 1349, 1344, 1, 0, 0, 0, 1349, 1348, 1, 0, 0, 0, 1350, 43, 1, 0, 0, 0, 1351, 1356, 3, 818, 409, 0, 1352, 1353, 5, 11, 0, 0, 1353, 1355, 3, 818, 409, 0, 1354, 1352, 1, 0, 0, 0, 1355, 1358, 1, 0, 0, 0, 1356, 1354, 1, 0, 0, 0, 1356, 1357, 1, 0, 0, 0, 1357, 45, 1, 0, 0, 0, 1358, 1356, 1, 0, 0, 0, 1359, 1364, 3, 48, 24, 0, 1360, 1361, 5, 6, 0, 0, 1361, 1363, 3, 48, 24, 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, 47, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1367, 1370, 3, 54, 27, 0, 1368, 1370, 3, 202, 101, 0, 1369, 1367, 1, 0, 0, 0, 1369, 1368, 1, 0, 0, 0, 1370, 49, 1, 0, 0, 0, 1371, 1372, 5, 300, 0, 0, 1372, 1377, 7, 8, 0, 0, 1373, 1374, 5, 310, 0, 0, 1374, 1377, 5, 300, 0, 0, 1375, 1377, 5, 330, 0, 0, 1376, 1371, 1, 0, 0, 0, 1376, 1373, 1, 0, 0, 0, 1376, 1375, 1, 0, 0, 0, 1377, 51, 1, 0, 0, 0, 1378, 1385, 5, 96, 0, 0, 1379, 1385, 5, 60, 0, 0, 1380, 1385, 5, 80, 0, 0, 1381, 1385, 3, 800, 400, 0, 1382, 1385, 3, 832, 416, 0, 1383, 1385, 3, 808, 404, 0, 1384, 1378, 1, 0, 0, 0, 1384, 1379, 1, 0, 0, 0, 1384, 1380, 1, 0, 0, 0, 1384, 1381, 1, 0, 0, 0, 1384, 1382, 1, 0, 0, 0, 1384, 1383, 1, 0, 0, 0, 1385, 53, 1, 0, 0, 0, 1386, 1391, 5, 96, 0, 0, 1387, 1391, 5, 60, 0, 0, 1388, 1391, 5, 80, 0, 0, 1389, 1391, 3, 58, 29, 0, 1390, 1386, 1, 0, 0, 0, 1390, 1387, 1, 0, 0, 0, 1390, 1388, 1, 0, 0, 0, 1390, 1389, 1, 0, 0, 0, 1391, 55, 1, 0, 0, 0, 1392, 1407, 3, 808, 404, 0, 1393, 1407, 5, 53, 0, 0, 1394, 1407, 3, 826, 413, 0, 1395, 1396, 5, 403, 0, 0, 1396, 1398, 3, 808, 404, 0, 1397, 1399, 3, 668, 334, 0, 1398, 1397, 1, 0, 0, 0, 1398, 1399, 1, 0, 0, 0, 1399, 1407, 1, 0, 0, 0, 1400, 1401, 5, 403, 0, 0, 1401, 1402, 3, 660, 330, 0, 1402, 1403, 3, 808, 404, 0, 1403, 1407, 1, 0, 0, 0, 1404, 1407, 3, 202, 101, 0, 1405, 1407, 5, 254, 0, 0, 1406, 1392, 1, 0, 0, 0, 1406, 1393, 1, 0, 0, 0, 1406, 1394, 1, 0, 0, 0, 1406, 1395, 1, 0, 0, 0, 1406, 1400, 1, 0, 0, 0, 1406, 1404, 1, 0, 0, 0, 1406, 1405, 1, 0, 0, 0, 1407, 57, 1, 0, 0, 0, 1408, 1411, 3, 822, 411, 0, 1409, 1411, 3, 808, 404, 0, 1410, 1408, 1, 0, 0, 0, 1410, 1409, 1, 0, 0, 0, 1411, 59, 1, 0, 0, 0, 1412, 1413, 5, 313, 0, 0, 1413, 1414, 3, 62, 31, 0, 1414, 61, 1, 0, 0, 0, 1415, 1416, 5, 418, 0, 0, 1416, 1425, 5, 386, 0, 0, 1417, 1418, 5, 356, 0, 0, 1418, 1419, 5, 244, 0, 0, 1419, 1425, 5, 251, 0, 0, 1420, 1421, 5, 332, 0, 0, 1421, 1425, 5, 106, 0, 0, 1422, 1425, 5, 30, 0, 0, 1423, 1425, 3, 44, 22, 0, 1424, 1415, 1, 0, 0, 0, 1424, 1417, 1, 0, 0, 0, 1424, 1420, 1, 0, 0, 0, 1424, 1422, 1, 0, 0, 0, 1424, 1423, 1, 0, 0, 0, 1425, 63, 1, 0, 0, 0, 1426, 1427, 5, 333, 0, 0, 1427, 1430, 3, 38, 19, 0, 1428, 1430, 3, 60, 30, 0, 1429, 1426, 1, 0, 0, 0, 1429, 1428, 1, 0, 0, 0, 1430, 65, 1, 0, 0, 0, 1431, 1432, 5, 333, 0, 0, 1432, 1435, 3, 42, 21, 0, 1433, 1435, 3, 60, 30, 0, 1434, 1431, 1, 0, 0, 0, 1434, 1433, 1, 0, 0, 0, 1435, 67, 1, 0, 0, 0, 1436, 1446, 5, 335, 0, 0, 1437, 1447, 3, 44, 22, 0, 1438, 1439, 5, 418, 0, 0, 1439, 1447, 5, 386, 0, 0, 1440, 1441, 5, 356, 0, 0, 1441, 1442, 5, 244, 0, 0, 1442, 1447, 5, 251, 0, 0, 1443, 1444, 5, 332, 0, 0, 1444, 1447, 5, 106, 0, 0, 1445, 1447, 5, 30, 0, 0, 1446, 1437, 1, 0, 0, 0, 1446, 1438, 1, 0, 0, 0, 1446, 1440, 1, 0, 0, 0, 1446, 1443, 1, 0, 0, 0, 1446, 1445, 1, 0, 0, 0, 1447, 69, 1, 0, 0, 0, 1448, 1449, 5, 333, 0, 0, 1449, 1452, 5, 165, 0, 0, 1450, 1453, 5, 30, 0, 0, 1451, 1453, 3, 760, 380, 0, 1452, 1450, 1, 0, 0, 0, 1452, 1451, 1, 0, 0, 0, 1453, 1454, 1, 0, 0, 0, 1454, 1455, 7, 9, 0, 0, 1455, 71, 1, 0, 0, 0, 1456, 1457, 5, 155, 0, 0, 1457, 73, 1, 0, 0, 0, 1458, 1459, 5, 187, 0, 0, 1459, 1460, 7, 10, 0, 0, 1460, 75, 1, 0, 0, 0, 1461, 1462, 5, 138, 0, 0, 1462, 1464, 5, 92, 0, 0, 1463, 1465, 3, 422, 211, 0, 1464, 1463, 1, 0, 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1469, 3, 624, 312, 0, 1467, 1470, 3, 78, 39, 0, 1468, 1470, 3, 88, 44, 0, 1469, 1467, 1, 0, 0, 0, 1469, 1468, 1, 0, 0, 0, 1470, 1583, 1, 0, 0, 0, 1471, 1472, 5, 138, 0, 0, 1472, 1473, 5, 92, 0, 0, 1473, 1474, 5, 30, 0, 0, 1474, 1475, 5, 68, 0, 0, 1475, 1479, 3, 176, 88, 0, 1476, 1477, 5, 281, 0, 0, 1477, 1478, 5, 147, 0, 0, 1478, 1480, 3, 816, 408, 0, 1479, 1476, 1, 0, 0, 0, 1479, 1480, 1, 0, 0, 0, 1480, 1481, 1, 0, 0, 0, 1481, 1482, 5, 333, 0, 0, 1482, 1483, 5, 351, 0, 0, 1483, 1485, 3, 768, 384, 0, 1484, 1486, 5, 272, 0, 0, 1485, 1484, 1, 0, 0, 0, 1485, 1486, 1, 0, 0, 0, 1486, 1583, 1, 0, 0, 0, 1487, 1488, 5, 138, 0, 0, 1488, 1490, 5, 92, 0, 0, 1489, 1491, 3, 422, 211, 0, 1490, 1489, 1, 0, 0, 0, 1490, 1491, 1, 0, 0, 0, 1491, 1492, 1, 0, 0, 0, 1492, 1493, 3, 774, 387, 0, 1493, 1498, 3, 90, 45, 0, 1494, 1495, 5, 62, 0, 0, 1495, 1496, 5, 422, 0, 0, 1496, 1499, 3, 80, 40, 0, 1497, 1499, 5, 53, 0, 0, 1498, 1494, 1, 0, 0, 0, 1498, 1497, 1, 0, 0, 0, 1499, 1583, 1, 0, 0, 0, 1500, 1501, 5, 138, 0, 0, 1501, 1503, 5, 92, 0, 0, 1502, 1504, 3, 422, 211, 0, 1503, 1502, 1, 0, 0, 0, 1503, 1504, 1, 0, 0, 0, 1504, 1505, 1, 0, 0, 0, 1505, 1506, 3, 774, 387, 0, 1506, 1507, 5, 436, 0, 0, 1507, 1508, 5, 285, 0, 0, 1508, 1510, 3, 780, 390, 0, 1509, 1511, 7, 11, 0, 0, 1510, 1509, 1, 0, 0, 0, 1510, 1511, 1, 0, 0, 0, 1511, 1583, 1, 0, 0, 0, 1512, 1513, 5, 138, 0, 0, 1513, 1515, 5, 226, 0, 0, 1514, 1516, 3, 422, 211, 0, 1515, 1514, 1, 0, 0, 0, 1515, 1516, 1, 0, 0, 0, 1516, 1517, 1, 0, 0, 0, 1517, 1520, 3, 780, 390, 0, 1518, 1521, 3, 78, 39, 0, 1519, 1521, 3, 90, 45, 0, 1520, 1518, 1, 0, 0, 0, 1520, 1519, 1, 0, 0, 0, 1521, 1583, 1, 0, 0, 0, 1522, 1523, 5, 138, 0, 0, 1523, 1524, 5, 226, 0, 0, 1524, 1525, 5, 30, 0, 0, 1525, 1526, 5, 68, 0, 0, 1526, 1530, 3, 176, 88, 0, 1527, 1528, 5, 281, 0, 0, 1528, 1529, 5, 147, 0, 0, 1529, 1531, 3, 816, 408, 0, 1530, 1527, 1, 0, 0, 0, 1530, 1531, 1, 0, 0, 0, 1531, 1532, 1, 0, 0, 0, 1532, 1533, 5, 333, 0, 0, 1533, 1535, 3, 176, 88, 0, 1534, 1536, 5, 272, 0, 0, 1535, 1534, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, 1583, 1, 0, 0, 0, 1537, 1538, 5, 138, 0, 0, 1538, 1540, 5, 328, 0, 0, 1539, 1541, 3, 422, 211, 0, 1540, 1539, 1, 0, 0, 0, 1540, 1541, 1, 0, 0, 0, 1541, 1542, 1, 0, 0, 0, 1542, 1543, 3, 780, 390, 0, 1543, 1544, 3, 78, 39, 0, 1544, 1583, 1, 0, 0, 0, 1545, 1547, 5, 138, 0, 0, 1546, 1548, 5, 259, 0, 0, 1547, 1546, 1, 0, 0, 0, 1547, 1548, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1551, 5, 376, 0, 0, 1550, 1552, 3, 422, 211, 0, 1551, 1550, 1, 0, 0, 0, 1551, 1552, 1, 0, 0, 0, 1552, 1553, 1, 0, 0, 0, 1553, 1554, 3, 778, 389, 0, 1554, 1555, 3, 78, 39, 0, 1555, 1583, 1, 0, 0, 0, 1556, 1557, 5, 138, 0, 0, 1557, 1558, 5, 259, 0, 0, 1558, 1559, 5, 376, 0, 0, 1559, 1560, 5, 30, 0, 0, 1560, 1561, 5, 68, 0, 0, 1561, 1565, 3, 176, 88, 0, 1562, 1563, 5, 281, 0, 0, 1563, 1564, 5, 147, 0, 0, 1564, 1566, 3, 816, 408, 0, 1565, 1562, 1, 0, 0, 0, 1565, 1566, 1, 0, 0, 0, 1566, 1567, 1, 0, 0, 0, 1567, 1568, 5, 333, 0, 0, 1568, 1569, 5, 351, 0, 0, 1569, 1571, 3, 768, 384, 0, 1570, 1572, 5, 272, 0, 0, 1571, 1570, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 1583, 1, 0, 0, 0, 1573, 1574, 5, 138, 0, 0, 1574, 1575, 5, 63, 0, 0, 1575, 1577, 5, 92, 0, 0, 1576, 1578, 3, 422, 211, 0, 1577, 1576, 1, 0, 0, 0, 1577, 1578, 1, 0, 0, 0, 1578, 1579, 1, 0, 0, 0, 1579, 1580, 3, 624, 312, 0, 1580, 1581, 3, 78, 39, 0, 1581, 1583, 1, 0, 0, 0, 1582, 1461, 1, 0, 0, 0, 1582, 1471, 1, 0, 0, 0, 1582, 1487, 1, 0, 0, 0, 1582, 1500, 1, 0, 0, 0, 1582, 1512, 1, 0, 0, 0, 1582, 1522, 1, 0, 0, 0, 1582, 1537, 1, 0, 0, 0, 1582, 1545, 1, 0, 0, 0, 1582, 1556, 1, 0, 0, 0, 1582, 1573, 1, 0, 0, 0, 1583, 77, 1, 0, 0, 0, 1584, 1589, 3, 92, 46, 0, 1585, 1586, 5, 6, 0, 0, 1586, 1588, 3, 92, 46, 0, 1587, 1585, 1, 0, 0, 0, 1588, 1591, 1, 0, 0, 0, 1589, 1587, 1, 0, 0, 0, 1589, 1590, 1, 0, 0, 0, 1590, 79, 1, 0, 0, 0, 1591, 1589, 1, 0, 0, 0, 1592, 1593, 5, 68, 0, 0, 1593, 1602, 3, 534, 267, 0, 1594, 1595, 5, 64, 0, 0, 1595, 1596, 3, 82, 41, 0, 1596, 1597, 5, 94, 0, 0, 1597, 1598, 3, 82, 41, 0, 1598, 1602, 1, 0, 0, 0, 1599, 1600, 5, 105, 0, 0, 1600, 1602, 3, 86, 43, 0, 1601, 1592, 1, 0, 0, 0, 1601, 1594, 1, 0, 0, 0, 1601, 1599, 1, 0, 0, 0, 1602, 81, 1, 0, 0, 0, 1603, 1604, 5, 2, 0, 0, 1604, 1609, 3, 84, 42, 0, 1605, 1606, 5, 6, 0, 0, 1606, 1608, 3, 84, 42, 0, 1607, 1605, 1, 0, 0, 0, 1608, 1611, 1, 0, 0, 0, 1609, 1607, 1, 0, 0, 0, 1609, 1610, 1, 0, 0, 0, 1610, 1612, 1, 0, 0, 0, 1611, 1609, 1, 0, 0, 0, 1612, 1613, 5, 3, 0, 0, 1613, 83, 1, 0, 0, 0, 1614, 1618, 3, 534, 267, 0, 1615, 1618, 5, 262, 0, 0, 1616, 1618, 5, 260, 0, 0, 1617, 1614, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1616, 1, 0, 0, 0, 1618, 85, 1, 0, 0, 0, 1619, 1620, 5, 2, 0, 0, 1620, 1621, 5, 533, 0, 0, 1621, 1622, 3, 202, 101, 0, 1622, 1623, 5, 6, 0, 0, 1623, 1624, 5, 534, 0, 0, 1624, 1625, 3, 202, 101, 0, 1625, 1626, 5, 3, 0, 0, 1626, 87, 1, 0, 0, 0, 1627, 1628, 3, 90, 45, 0, 1628, 1629, 3, 106, 53, 0, 1629, 1634, 1, 0, 0, 0, 1630, 1631, 5, 436, 0, 0, 1631, 1632, 5, 285, 0, 0, 1632, 1634, 3, 780, 390, 0, 1633, 1627, 1, 0, 0, 0, 1633, 1630, 1, 0, 0, 0, 1634, 89, 1, 0, 0, 0, 1635, 1636, 5, 435, 0, 0, 1636, 1637, 5, 285, 0, 0, 1637, 1638, 3, 780, 390, 0, 1638, 91, 1, 0, 0, 0, 1639, 1642, 5, 133, 0, 0, 1640, 1641, 5, 45, 0, 0, 1641, 1643, 3, 818, 409, 0, 1642, 1640, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1873, 3, 142, 71, 0, 1645, 1646, 5, 138, 0, 0, 1646, 1647, 5, 45, 0, 0, 1647, 1651, 3, 818, 409, 0, 1648, 1650, 3, 272, 136, 0, 1649, 1648, 1, 0, 0, 0, 1650, 1653, 1, 0, 0, 0, 1651, 1649, 1, 0, 0, 0, 1651, 1652, 1, 0, 0, 0, 1652, 1873, 1, 0, 0, 0, 1653, 1651, 1, 0, 0, 0, 1654, 1655, 5, 372, 0, 0, 1655, 1656, 5, 45, 0, 0, 1656, 1873, 3, 818, 409, 0, 1657, 1658, 5, 191, 0, 0, 1658, 1660, 5, 45, 0, 0, 1659, 1661, 3, 422, 211, 0, 1660, 1659, 1, 0, 0, 0, 1660, 1661, 1, 0, 0, 0, 1661, 1662, 1, 0, 0, 0, 1662, 1664, 3, 818, 409, 0, 1663, 1665, 3, 96, 48, 0, 1664, 1663, 1, 0, 0, 0, 1664, 1665, 1, 0, 0, 0, 1665, 1873, 1, 0, 0, 0, 1666, 1667, 5, 333, 0, 0, 1667, 1668, 5, 379, 0, 0, 1668, 1873, 7, 12, 0, 0, 1669, 1670, 5, 158, 0, 0, 1670, 1671, 5, 80, 0, 0, 1671, 1873, 3, 818, 409, 0, 1672, 1673, 5, 333, 0, 0, 1673, 1873, 7, 13, 0, 0, 1674, 1676, 5, 193, 0, 0, 1675, 1677, 7, 14, 0, 0, 1676, 1675, 1, 0, 0, 0, 1676, 1677, 1, 0, 0, 0, 1677, 1678, 1, 0, 0, 0, 1678, 1873, 5, 357, 0, 0, 1679, 1680, 5, 186, 0, 0, 1680, 1684, 5, 357, 0, 0, 1681, 1685, 5, 30, 0, 0, 1682, 1685, 5, 99, 0, 0, 1683, 1685, 3, 818, 409, 0, 1684, 1681, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 1873, 1, 0, 0, 0, 1686, 1687, 5, 193, 0, 0, 1687, 1688, 7, 14, 0, 0, 1688, 1689, 5, 321, 0, 0, 1689, 1873, 3, 818, 409, 0, 1690, 1691, 5, 186, 0, 0, 1691, 1692, 5, 321, 0, 0, 1692, 1873, 3, 818, 409, 0, 1693, 1695, 5, 269, 0, 0, 1694, 1693, 1, 0, 0, 0, 1694, 1695, 1, 0, 0, 0, 1695, 1696, 1, 0, 0, 0, 1696, 1697, 5, 228, 0, 0, 1697, 1873, 3, 780, 390, 0, 1698, 1699, 5, 275, 0, 0, 1699, 1873, 3, 316, 158, 0, 1700, 1701, 5, 77, 0, 0, 1701, 1873, 5, 275, 0, 0, 1702, 1703, 5, 282, 0, 0, 1703, 1704, 5, 94, 0, 0, 1704, 1873, 3, 814, 407, 0, 1705, 1706, 5, 333, 0, 0, 1706, 1707, 5, 351, 0, 0, 1707, 1873, 3, 768, 384, 0, 1708, 1709, 5, 312, 0, 0, 1709, 1714, 5, 219, 0, 0, 1710, 1715, 5, 270, 0, 0, 1711, 1715, 5, 113, 0, 0, 1712, 1715, 5, 53, 0, 0, 1713, 1715, 3, 180, 90, 0, 1714, 1710, 1, 0, 0, 0, 1714, 1711, 1, 0, 0, 0, 1714, 1712, 1, 0, 0, 0, 1714, 1713, 1, 0, 0, 0, 1715, 1873, 1, 0, 0, 0, 1716, 1723, 5, 193, 0, 0, 1717, 1723, 5, 186, 0, 0, 1718, 1720, 5, 269, 0, 0, 1719, 1718, 1, 0, 0, 0, 1719, 1720, 1, 0, 0, 0, 1720, 1721, 1, 0, 0, 0, 1721, 1723, 5, 209, 0, 0, 1722, 1716, 1, 0, 0, 0, 1722, 1717, 1, 0, 0, 0, 1722, 1719, 1, 0, 0, 0, 1723, 1724, 1, 0, 0, 0, 1724, 1725, 5, 414, 0, 0, 1725, 1726, 5, 251, 0, 0, 1726, 1873, 5, 327, 0, 0, 1727, 1729, 5, 191, 0, 0, 1728, 1730, 5, 44, 0, 0, 1729, 1728, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, 1732, 1, 0, 0, 0, 1731, 1733, 3, 422, 211, 0, 1732, 1731, 1, 0, 0, 0, 1732, 1733, 1, 0, 0, 0, 1733, 1734, 1, 0, 0, 0, 1734, 1736, 3, 800, 400, 0, 1735, 1737, 3, 96, 48, 0, 1736, 1735, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, 1873, 1, 0, 0, 0, 1738, 1740, 5, 133, 0, 0, 1739, 1741, 5, 44, 0, 0, 1740, 1739, 1, 0, 0, 0, 1740, 1741, 1, 0, 0, 0, 1741, 1743, 1, 0, 0, 0, 1742, 1744, 3, 294, 147, 0, 1743, 1742, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1745, 1, 0, 0, 0, 1745, 1873, 3, 132, 66, 0, 1746, 1748, 5, 138, 0, 0, 1747, 1749, 5, 44, 0, 0, 1748, 1747, 1, 0, 0, 0, 1748, 1749, 1, 0, 0, 0, 1749, 1750, 1, 0, 0, 0, 1750, 1753, 3, 800, 400, 0, 1751, 1754, 3, 94, 47, 0, 1752, 1754, 3, 222, 111, 0, 1753, 1751, 1, 0, 0, 0, 1753, 1752, 1, 0, 0, 0, 1754, 1873, 1, 0, 0, 0, 1755, 1757, 5, 138, 0, 0, 1756, 1758, 5, 44, 0, 0, 1757, 1756, 1, 0, 0, 0, 1757, 1758, 1, 0, 0, 0, 1758, 1759, 1, 0, 0, 0, 1759, 1760, 3, 800, 400, 0, 1760, 1761, 7, 15, 0, 0, 1761, 1762, 5, 77, 0, 0, 1762, 1763, 5, 78, 0, 0, 1763, 1873, 1, 0, 0, 0, 1764, 1766, 5, 138, 0, 0, 1765, 1767, 5, 44, 0, 0, 1766, 1765, 1, 0, 0, 0, 1766, 1767, 1, 0, 0, 0, 1767, 1768, 1, 0, 0, 0, 1768, 1769, 3, 800, 400, 0, 1769, 1770, 5, 191, 0, 0, 1770, 1772, 5, 437, 0, 0, 1771, 1773, 3, 422, 211, 0, 1772, 1771, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1873, 1, 0, 0, 0, 1774, 1776, 5, 138, 0, 0, 1775, 1777, 5, 44, 0, 0, 1776, 1775, 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1778, 1, 0, 0, 0, 1778, 1779, 3, 800, 400, 0, 1779, 1780, 5, 333, 0, 0, 1780, 1781, 5, 342, 0, 0, 1781, 1782, 3, 812, 406, 0, 1782, 1873, 1, 0, 0, 0, 1783, 1785, 5, 138, 0, 0, 1784, 1786, 5, 44, 0, 0, 1785, 1784, 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 1789, 3, 800, 400, 0, 1788, 1783, 1, 0, 0, 0, 1788, 1789, 1, 0, 0, 0, 1789, 1790, 1, 0, 0, 0, 1790, 1791, 7, 16, 0, 0, 1791, 1873, 3, 100, 50, 0, 1792, 1794, 5, 138, 0, 0, 1793, 1795, 5, 44, 0, 0, 1794, 1793, 1, 0, 0, 0, 1794, 1795, 1, 0, 0, 0, 1795, 1796, 1, 0, 0, 0, 1796, 1797, 3, 800, 400, 0, 1797, 1798, 5, 333, 0, 0, 1798, 1799, 5, 345, 0, 0, 1799, 1800, 3, 818, 409, 0, 1800, 1873, 1, 0, 0, 0, 1801, 1803, 5, 138, 0, 0, 1802, 1804, 5, 44, 0, 0, 1803, 1802, 1, 0, 0, 0, 1803, 1804, 1, 0, 0, 0, 1804, 1805, 1, 0, 0, 0, 1805, 1806, 3, 800, 400, 0, 1806, 1807, 5, 133, 0, 0, 1807, 1808, 5, 438, 0, 0, 1808, 1809, 3, 138, 69, 0, 1809, 1810, 5, 36, 0, 0, 1810, 1819, 5, 219, 0, 0, 1811, 1813, 5, 2, 0, 0, 1812, 1814, 3, 200, 100, 0, 1813, 1812, 1, 0, 0, 0, 1814, 1815, 1, 0, 0, 0, 1815, 1813, 1, 0, 0, 0, 1815, 1816, 1, 0, 0, 0, 1816, 1817, 1, 0, 0, 0, 1817, 1818, 5, 3, 0, 0, 1818, 1820, 1, 0, 0, 0, 1819, 1811, 1, 0, 0, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1873, 1, 0, 0, 0, 1821, 1823, 5, 138, 0, 0, 1822, 1824, 5, 44, 0, 0, 1823, 1822, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1825, 1, 0, 0, 0, 1825, 1839, 3, 800, 400, 0, 1826, 1831, 5, 314, 0, 0, 1827, 1829, 5, 105, 0, 0, 1828, 1827, 1, 0, 0, 0, 1828, 1829, 1, 0, 0, 0, 1829, 1830, 1, 0, 0, 0, 1830, 1832, 3, 202, 101, 0, 1831, 1828, 1, 0, 0, 0, 1831, 1832, 1, 0, 0, 0, 1832, 1840, 1, 0, 0, 0, 1833, 1837, 5, 333, 0, 0, 1834, 1838, 3, 200, 100, 0, 1835, 1836, 5, 438, 0, 0, 1836, 1838, 3, 138, 69, 0, 1837, 1834, 1, 0, 0, 0, 1837, 1835, 1, 0, 0, 0, 1838, 1840, 1, 0, 0, 0, 1839, 1826, 1, 0, 0, 0, 1839, 1833, 1, 0, 0, 0, 1840, 1841, 1, 0, 0, 0, 1841, 1839, 1, 0, 0, 0, 1841, 1842, 1, 0, 0, 0, 1842, 1873, 1, 0, 0, 0, 1843, 1845, 5, 138, 0, 0, 1844, 1846, 5, 44, 0, 0, 1845, 1844, 1, 0, 0, 0, 1845, 1846, 1, 0, 0, 0, 1846, 1847, 1, 0, 0, 0, 1847, 1848, 3, 800, 400, 0, 1848, 1849, 5, 191, 0, 0, 1849, 1851, 5, 219, 0, 0, 1850, 1852, 3, 422, 211, 0, 1851, 1850, 1, 0, 0, 0, 1851, 1852, 1, 0, 0, 0, 1852, 1873, 1, 0, 0, 0, 1853, 1855, 5, 138, 0, 0, 1854, 1856, 5, 44, 0, 0, 1855, 1854, 1, 0, 0, 0, 1855, 1856, 1, 0, 0, 0, 1856, 1857, 1, 0, 0, 0, 1857, 1860, 3, 800, 400, 0, 1858, 1859, 5, 333, 0, 0, 1859, 1861, 5, 174, 0, 0, 1860, 1858, 1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1862, 1, 0, 0, 0, 1862, 1863, 5, 360, 0, 0, 1863, 1865, 3, 652, 326, 0, 1864, 1866, 3, 98, 49, 0, 1865, 1864, 1, 0, 0, 0, 1865, 1866, 1, 0, 0, 0, 1866, 1869, 1, 0, 0, 0, 1867, 1868, 5, 100, 0, 0, 1868, 1870, 3, 674, 337, 0, 1869, 1867, 1, 0, 0, 0, 1869, 1870, 1, 0, 0, 0, 1870, 1873, 1, 0, 0, 0, 1871, 1873, 3, 222, 111, 0, 1872, 1639, 1, 0, 0, 0, 1872, 1645, 1, 0, 0, 0, 1872, 1654, 1, 0, 0, 0, 1872, 1657, 1, 0, 0, 0, 1872, 1666, 1, 0, 0, 0, 1872, 1669, 1, 0, 0, 0, 1872, 1672, 1, 0, 0, 0, 1872, 1674, 1, 0, 0, 0, 1872, 1679, 1, 0, 0, 0, 1872, 1686, 1, 0, 0, 0, 1872, 1690, 1, 0, 0, 0, 1872, 1694, 1, 0, 0, 0, 1872, 1698, 1, 0, 0, 0, 1872, 1700, 1, 0, 0, 0, 1872, 1702, 1, 0, 0, 0, 1872, 1705, 1, 0, 0, 0, 1872, 1708, 1, 0, 0, 0, 1872, 1722, 1, 0, 0, 0, 1872, 1727, 1, 0, 0, 0, 1872, 1738, 1, 0, 0, 0, 1872, 1746, 1, 0, 0, 0, 1872, 1755, 1, 0, 0, 0, 1872, 1764, 1, 0, 0, 0, 1872, 1774, 1, 0, 0, 0, 1872, 1788, 1, 0, 0, 0, 1872, 1792, 1, 0, 0, 0, 1872, 1801, 1, 0, 0, 0, 1872, 1821, 1, 0, 0, 0, 1872, 1843, 1, 0, 0, 0, 1872, 1853, 1, 0, 0, 0, 1872, 1871, 1, 0, 0, 0, 1873, 93, 1, 0, 0, 0, 1874, 1875, 5, 333, 0, 0, 1875, 1876, 5, 53, 0, 0, 1876, 1880, 3, 674, 337, 0, 1877, 1878, 5, 191, 0, 0, 1878, 1880, 5, 53, 0, 0, 1879, 1874, 1, 0, 0, 0, 1879, 1877, 1, 0, 0, 0, 1880, 95, 1, 0, 0, 0, 1881, 1882, 7, 17, 0, 0, 1882, 97, 1, 0, 0, 0, 1883, 1884, 5, 43, 0, 0, 1884, 1885, 3, 316, 158, 0, 1885, 99, 1, 0, 0, 0, 1886, 1887, 5, 2, 0, 0, 1887, 1892, 3, 104, 52, 0, 1888, 1889, 5, 6, 0, 0, 1889, 1891, 3, 104, 52, 0, 1890, 1888, 1, 0, 0, 0, 1891, 1894, 1, 0, 0, 0, 1892, 1890, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1895, 1, 0, 0, 0, 1894, 1892, 1, 0, 0, 0, 1895, 1896, 5, 3, 0, 0, 1896, 101, 1, 0, 0, 0, 1897, 1898, 5, 105, 0, 0, 1898, 1899, 3, 100, 50, 0, 1899, 103, 1, 0, 0, 0, 1900, 1905, 3, 824, 412, 0, 1901, 1902, 5, 10, 0, 0, 1902, 1906, 3, 288, 144, 0, 1903, 1904, 5, 11, 0, 0, 1904, 1906, 3, 286, 143, 0, 1905, 1901, 1, 0, 0, 0, 1905, 1903, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 105, 1, 0, 0, 0, 1907, 1908, 5, 62, 0, 0, 1908, 1909, 5, 422, 0, 0, 1909, 1910, 5, 105, 0, 0, 1910, 1911, 5, 2, 0, 0, 1911, 1912, 3, 822, 411, 0, 1912, 1919, 5, 571, 0, 0, 1913, 1914, 5, 6, 0, 0, 1914, 1915, 3, 822, 411, 0, 1915, 1916, 5, 571, 0, 0, 1916, 1918, 1, 0, 0, 0, 1917, 1913, 1, 0, 0, 0, 1918, 1921, 1, 0, 0, 0, 1919, 1917, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1922, 1, 0, 0, 0, 1921, 1919, 1, 0, 0, 0, 1922, 1923, 5, 3, 0, 0, 1923, 1937, 1, 0, 0, 0, 1924, 1925, 5, 62, 0, 0, 1925, 1926, 5, 422, 0, 0, 1926, 1927, 5, 68, 0, 0, 1927, 1937, 3, 534, 267, 0, 1928, 1929, 5, 62, 0, 0, 1929, 1930, 5, 422, 0, 0, 1930, 1931, 5, 64, 0, 0, 1931, 1932, 3, 534, 267, 0, 1932, 1933, 5, 94, 0, 0, 1933, 1934, 3, 534, 267, 0, 1934, 1937, 1, 0, 0, 0, 1935, 1937, 5, 53, 0, 0, 1936, 1907, 1, 0, 0, 0, 1936, 1924, 1, 0, 0, 0, 1936, 1928, 1, 0, 0, 0, 1936, 1935, 1, 0, 0, 0, 1937, 107, 1, 0, 0, 0, 1938, 1939, 5, 138, 0, 0, 1939, 1940, 5, 360, 0, 0, 1940, 1941, 3, 316, 158, 0, 1941, 1946, 3, 110, 55, 0, 1942, 1943, 5, 6, 0, 0, 1943, 1945, 3, 110, 55, 0, 1944, 1942, 1, 0, 0, 0, 1945, 1948, 1, 0, 0, 0, 1946, 1944, 1, 0, 0, 0, 1946, 1947, 1, 0, 0, 0, 1947, 109, 1, 0, 0, 0, 1948, 1946, 1, 0, 0, 0, 1949, 1950, 5, 133, 0, 0, 1950, 1951, 5, 143, 0, 0, 1951, 1953, 3, 644, 322, 0, 1952, 1954, 3, 96, 48, 0, 1953, 1952, 1, 0, 0, 0, 1953, 1954, 1, 0, 0, 0, 1954, 1980, 1, 0, 0, 0, 1955, 1956, 5, 191, 0, 0, 1956, 1958, 5, 143, 0, 0, 1957, 1959, 3, 422, 211, 0, 1958, 1957, 1, 0, 0, 0, 1958, 1959, 1, 0, 0, 0, 1959, 1960, 1, 0, 0, 0, 1960, 1962, 3, 818, 409, 0, 1961, 1963, 3, 96, 48, 0, 1962, 1961, 1, 0, 0, 0, 1962, 1963, 1, 0, 0, 0, 1963, 1980, 1, 0, 0, 0, 1964, 1965, 5, 138, 0, 0, 1965, 1966, 5, 143, 0, 0, 1966, 1969, 3, 818, 409, 0, 1967, 1968, 5, 333, 0, 0, 1968, 1970, 5, 174, 0, 0, 1969, 1967, 1, 0, 0, 0, 1969, 1970, 1, 0, 0, 0, 1970, 1971, 1, 0, 0, 0, 1971, 1972, 5, 360, 0, 0, 1972, 1974, 3, 652, 326, 0, 1973, 1975, 3, 98, 49, 0, 1974, 1973, 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 1977, 1, 0, 0, 0, 1976, 1978, 3, 96, 48, 0, 1977, 1976, 1, 0, 0, 0, 1977, 1978, 1, 0, 0, 0, 1978, 1980, 1, 0, 0, 0, 1979, 1949, 1, 0, 0, 0, 1979, 1955, 1, 0, 0, 0, 1979, 1964, 1, 0, 0, 0, 1980, 111, 1, 0, 0, 0, 1981, 1984, 5, 157, 0, 0, 1982, 1985, 3, 818, 409, 0, 1983, 1985, 5, 30, 0, 0, 1984, 1982, 1, 0, 0, 0, 1984, 1983, 1, 0, 0, 0, 1985, 113, 1, 0, 0, 0, 1986, 1988, 5, 169, 0, 0, 1987, 1989, 5, 107, 0, 0, 1988, 1987, 1, 0, 0, 0, 1988, 1989, 1, 0, 0, 0, 1989, 1990, 1, 0, 0, 0, 1990, 1992, 3, 774, 387, 0, 1991, 1993, 3, 144, 72, 0, 1992, 1991, 1, 0, 0, 0, 1992, 1993, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 1996, 7, 18, 0, 0, 1995, 1997, 5, 297, 0, 0, 1996, 1995, 1, 0, 0, 0, 1996, 1997, 1, 0, 0, 0, 1997, 2001, 1, 0, 0, 0, 1998, 2002, 3, 808, 404, 0, 1999, 2002, 5, 343, 0, 0, 2000, 2002, 5, 344, 0, 0, 2001, 1998, 1, 0, 0, 0, 2001, 1999, 1, 0, 0, 0, 2001, 2000, 1, 0, 0, 0, 2002, 2008, 1, 0, 0, 0, 2003, 2005, 5, 100, 0, 0, 2004, 2003, 1, 0, 0, 0, 2004, 2005, 1, 0, 0, 0, 2005, 2006, 1, 0, 0, 0, 2006, 2007, 5, 184, 0, 0, 2007, 2009, 3, 808, 404, 0, 2008, 2004, 1, 0, 0, 0, 2008, 2009, 1, 0, 0, 0, 2009, 2011, 1, 0, 0, 0, 2010, 2012, 5, 105, 0, 0, 2011, 2010, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2013, 1, 0, 0, 0, 2013, 2015, 3, 116, 58, 0, 2014, 2016, 3, 638, 319, 0, 2015, 2014, 1, 0, 0, 0, 2015, 2016, 1, 0, 0, 0, 2016, 2036, 1, 0, 0, 0, 2017, 2018, 5, 169, 0, 0, 2018, 2019, 5, 2, 0, 0, 2019, 2020, 3, 530, 265, 0, 2020, 2021, 5, 3, 0, 0, 2021, 2023, 5, 94, 0, 0, 2022, 2024, 5, 297, 0, 0, 2023, 2022, 1, 0, 0, 0, 2023, 2024, 1, 0, 0, 0, 2024, 2028, 1, 0, 0, 0, 2025, 2029, 3, 808, 404, 0, 2026, 2029, 5, 343, 0, 0, 2027, 2029, 5, 344, 0, 0, 2028, 2025, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2028, 2027, 1, 0, 0, 0, 2029, 2031, 1, 0, 0, 0, 2030, 2032, 5, 105, 0, 0, 2031, 2030, 1, 0, 0, 0, 2031, 2032, 1, 0, 0, 0, 2032, 2033, 1, 0, 0, 0, 2033, 2034, 3, 116, 58, 0, 2034, 2036, 1, 0, 0, 0, 2035, 1986, 1, 0, 0, 0, 2035, 2017, 1, 0, 0, 0, 2036, 115, 1, 0, 0, 0, 2037, 2061, 5, 107, 0, 0, 2038, 2061, 5, 112, 0, 0, 2039, 2041, 7, 19, 0, 0, 2040, 2042, 5, 36, 0, 0, 2041, 2040, 1, 0, 0, 0, 2041, 2042, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, 0, 2043, 2061, 3, 808, 404, 0, 2044, 2061, 5, 171, 0, 0, 2045, 2061, 5, 216, 0, 0, 2046, 2047, 5, 209, 0, 0, 2047, 2050, 5, 298, 0, 0, 2048, 2051, 3, 148, 74, 0, 2049, 2051, 5, 9, 0, 0, 2050, 2048, 1, 0, 0, 0, 2050, 2049, 1, 0, 0, 0, 2051, 2061, 1, 0, 0, 0, 2052, 2054, 5, 209, 0, 0, 2053, 2055, 5, 77, 0, 0, 2054, 2053, 1, 0, 0, 0, 2054, 2055, 1, 0, 0, 0, 2055, 2056, 1, 0, 0, 0, 2056, 2057, 5, 78, 0, 0, 2057, 2061, 3, 148, 74, 0, 2058, 2059, 5, 194, 0, 0, 2059, 2061, 3, 808, 404, 0, 2060, 2037, 1, 0, 0, 0, 2060, 2038, 1, 0, 0, 0, 2060, 2039, 1, 0, 0, 0, 2060, 2044, 1, 0, 0, 0, 2060, 2045, 1, 0, 0, 0, 2060, 2046, 1, 0, 0, 0, 2060, 2052, 1, 0, 0, 0, 2060, 2058, 1, 0, 0, 0, 2061, 2064, 1, 0, 0, 0, 2062, 2060, 1, 0, 0, 0, 2062, 2063, 1, 0, 0, 0, 2063, 2077, 1, 0, 0, 0, 2064, 2062, 1, 0, 0, 0, 2065, 2066, 5, 2, 0, 0, 2066, 2071, 3, 118, 59, 0, 2067, 2068, 5, 6, 0, 0, 2068, 2070, 3, 118, 59, 0, 2069, 2067, 1, 0, 0, 0, 2070, 2073, 1, 0, 0, 0, 2071, 2069, 1, 0, 0, 0, 2071, 2072, 1, 0, 0, 0, 2072, 2074, 1, 0, 0, 0, 2073, 2071, 1, 0, 0, 0, 2074, 2075, 5, 3, 0, 0, 2075, 2077, 1, 0, 0, 0, 2076, 2062, 1, 0, 0, 0, 2076, 2065, 1, 0, 0, 0, 2077, 117, 1, 0, 0, 0, 2078, 2093, 3, 824, 412, 0, 2079, 2094, 3, 54, 27, 0, 2080, 2094, 3, 202, 101, 0, 2081, 2094, 5, 9, 0, 0, 2082, 2083, 5, 2, 0, 0, 2083, 2088, 3, 52, 26, 0, 2084, 2085, 5, 6, 0, 0, 2085, 2087, 3, 52, 26, 0, 2086, 2084, 1, 0, 0, 0, 2087, 2090, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2088, 2089, 1, 0, 0, 0, 2089, 2091, 1, 0, 0, 0, 2090, 2088, 1, 0, 0, 0, 2091, 2092, 5, 3, 0, 0, 2092, 2094, 1, 0, 0, 0, 2093, 2079, 1, 0, 0, 0, 2093, 2080, 1, 0, 0, 0, 2093, 2081, 1, 0, 0, 0, 2093, 2082, 1, 0, 0, 0, 2093, 2094, 1, 0, 0, 0, 2094, 119, 1, 0, 0, 0, 2095, 2097, 5, 46, 0, 0, 2096, 2098, 3, 122, 61, 0, 2097, 2096, 1, 0, 0, 0, 2097, 2098, 1, 0, 0, 0, 2098, 2099, 1, 0, 0, 0, 2099, 2101, 5, 92, 0, 0, 2100, 2102, 3, 294, 147, 0, 2101, 2100, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2103, 1, 0, 0, 0, 2103, 2169, 3, 772, 386, 0, 2104, 2106, 5, 2, 0, 0, 2105, 2107, 3, 126, 63, 0, 2106, 2105, 1, 0, 0, 0, 2106, 2107, 1, 0, 0, 0, 2107, 2108, 1, 0, 0, 0, 2108, 2110, 5, 3, 0, 0, 2109, 2111, 3, 164, 82, 0, 2110, 2109, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2113, 1, 0, 0, 0, 2112, 2114, 3, 166, 83, 0, 2113, 2112, 1, 0, 0, 0, 2113, 2114, 1, 0, 0, 0, 2114, 2116, 1, 0, 0, 0, 2115, 2117, 3, 170, 85, 0, 2116, 2115, 1, 0, 0, 0, 2116, 2117, 1, 0, 0, 0, 2117, 2119, 1, 0, 0, 0, 2118, 2120, 3, 172, 86, 0, 2119, 2118, 1, 0, 0, 0, 2119, 2120, 1, 0, 0, 0, 2120, 2122, 1, 0, 0, 0, 2121, 2123, 3, 174, 87, 0, 2122, 2121, 1, 0, 0, 0, 2122, 2123, 1, 0, 0, 0, 2123, 2125, 1, 0, 0, 0, 2124, 2126, 3, 176, 88, 0, 2125, 2124, 1, 0, 0, 0, 2125, 2126, 1, 0, 0, 0, 2126, 2170, 1, 0, 0, 0, 2127, 2128, 5, 275, 0, 0, 2128, 2130, 3, 316, 158, 0, 2129, 2131, 3, 124, 62, 0, 2130, 2129, 1, 0, 0, 0, 2130, 2131, 1, 0, 0, 0, 2131, 2133, 1, 0, 0, 0, 2132, 2134, 3, 166, 83, 0, 2133, 2132, 1, 0, 0, 0, 2133, 2134, 1, 0, 0, 0, 2134, 2136, 1, 0, 0, 0, 2135, 2137, 3, 170, 85, 0, 2136, 2135, 1, 0, 0, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2139, 1, 0, 0, 0, 2138, 2140, 3, 172, 86, 0, 2139, 2138, 1, 0, 0, 0, 2139, 2140, 1, 0, 0, 0, 2140, 2142, 1, 0, 0, 0, 2141, 2143, 3, 174, 87, 0, 2142, 2141, 1, 0, 0, 0, 2142, 2143, 1, 0, 0, 0, 2143, 2145, 1, 0, 0, 0, 2144, 2146, 3, 176, 88, 0, 2145, 2144, 1, 0, 0, 0, 2145, 2146, 1, 0, 0, 0, 2146, 2170, 1, 0, 0, 0, 2147, 2148, 5, 285, 0, 0, 2148, 2149, 5, 275, 0, 0, 2149, 2151, 3, 780, 390, 0, 2150, 2152, 3, 124, 62, 0, 2151, 2150, 1, 0, 0, 0, 2151, 2152, 1, 0, 0, 0, 2152, 2153, 1, 0, 0, 0, 2153, 2155, 3, 106, 53, 0, 2154, 2156, 3, 166, 83, 0, 2155, 2154, 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2158, 1, 0, 0, 0, 2157, 2159, 3, 170, 85, 0, 2158, 2157, 1, 0, 0, 0, 2158, 2159, 1, 0, 0, 0, 2159, 2161, 1, 0, 0, 0, 2160, 2162, 3, 172, 86, 0, 2161, 2160, 1, 0, 0, 0, 2161, 2162, 1, 0, 0, 0, 2162, 2164, 1, 0, 0, 0, 2163, 2165, 3, 174, 87, 0, 2164, 2163, 1, 0, 0, 0, 2164, 2165, 1, 0, 0, 0, 2165, 2167, 1, 0, 0, 0, 2166, 2168, 3, 176, 88, 0, 2167, 2166, 1, 0, 0, 0, 2167, 2168, 1, 0, 0, 0, 2168, 2170, 1, 0, 0, 0, 2169, 2104, 1, 0, 0, 0, 2169, 2127, 1, 0, 0, 0, 2169, 2147, 1, 0, 0, 0, 2170, 121, 1, 0, 0, 0, 2171, 2177, 5, 354, 0, 0, 2172, 2177, 5, 352, 0, 0, 2173, 2174, 7, 20, 0, 0, 2174, 2177, 7, 21, 0, 0, 2175, 2177, 5, 367, 0, 0, 2176, 2171, 1, 0, 0, 0, 2176, 2172, 1, 0, 0, 0, 2176, 2173, 1, 0, 0, 0, 2176, 2175, 1, 0, 0, 0, 2177, 123, 1, 0, 0, 0, 2178, 2179, 5, 2, 0, 0, 2179, 2184, 3, 130, 65, 0, 2180, 2181, 5, 6, 0, 0, 2181, 2183, 3, 130, 65, 0, 2182, 2180, 1, 0, 0, 0, 2183, 2186, 1, 0, 0, 0, 2184, 2182, 1, 0, 0, 0, 2184, 2185, 1, 0, 0, 0, 2185, 2187, 1, 0, 0, 0, 2186, 2184, 1, 0, 0, 0, 2187, 2188, 5, 3, 0, 0, 2188, 125, 1, 0, 0, 0, 2189, 2194, 3, 128, 64, 0, 2190, 2191, 5, 6, 0, 0, 2191, 2193, 3, 128, 64, 0, 2192, 2190, 1, 0, 0, 0, 2193, 2196, 1, 0, 0, 0, 2194, 2192, 1, 0, 0, 0, 2194, 2195, 1, 0, 0, 0, 2195, 127, 1, 0, 0, 0, 2196, 2194, 1, 0, 0, 0, 2197, 2198, 5, 45, 0, 0, 2198, 2200, 3, 818, 409, 0, 2199, 2197, 1, 0, 0, 0, 2199, 2200, 1, 0, 0, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2213, 3, 142, 71, 0, 2202, 2213, 3, 132, 66, 0, 2203, 2204, 5, 120, 0, 0, 2204, 2209, 3, 780, 390, 0, 2205, 2206, 7, 22, 0, 0, 2206, 2208, 3, 140, 70, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2211, 1, 0, 0, 0, 2209, 2207, 1, 0, 0, 0, 2209, 2210, 1, 0, 0, 0, 2210, 2213, 1, 0, 0, 0, 2211, 2209, 1, 0, 0, 0, 2212, 2199, 1, 0, 0, 0, 2212, 2202, 1, 0, 0, 0, 2212, 2203, 1, 0, 0, 0, 2213, 129, 1, 0, 0, 0, 2214, 2217, 3, 802, 401, 0, 2215, 2216, 5, 105, 0, 0, 2216, 2218, 5, 280, 0, 0, 2217, 2215, 1, 0, 0, 0, 2217, 2218, 1, 0, 0, 0, 2218, 2222, 1, 0, 0, 0, 2219, 2221, 3, 134, 67, 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, 2231, 1, 0, 0, 0, 2224, 2222, 1, 0, 0, 0, 2225, 2226, 5, 45, 0, 0, 2226, 2228, 3, 818, 409, 0, 2227, 2225, 1, 0, 0, 0, 2227, 2228, 1, 0, 0, 0, 2228, 2229, 1, 0, 0, 0, 2229, 2231, 3, 142, 71, 0, 2230, 2214, 1, 0, 0, 0, 2230, 2227, 1, 0, 0, 0, 2231, 131, 1, 0, 0, 0, 2232, 2233, 3, 802, 401, 0, 2233, 2235, 3, 652, 326, 0, 2234, 2236, 3, 220, 110, 0, 2235, 2234, 1, 0, 0, 0, 2235, 2236, 1, 0, 0, 0, 2236, 2246, 1, 0, 0, 0, 2237, 2244, 5, 345, 0, 0, 2238, 2245, 5, 544, 0, 0, 2239, 2245, 5, 205, 0, 0, 2240, 2245, 5, 545, 0, 0, 2241, 2245, 5, 546, 0, 0, 2242, 2245, 5, 53, 0, 0, 2243, 2245, 3, 818, 409, 0, 2244, 2238, 1, 0, 0, 0, 2244, 2239, 1, 0, 0, 0, 2244, 2240, 1, 0, 0, 0, 2244, 2241, 1, 0, 0, 0, 2244, 2242, 1, 0, 0, 0, 2244, 2243, 1, 0, 0, 0, 2245, 2247, 1, 0, 0, 0, 2246, 2237, 1, 0, 0, 0, 2246, 2247, 1, 0, 0, 0, 2247, 2250, 1, 0, 0, 0, 2248, 2249, 5, 543, 0, 0, 2249, 2251, 3, 818, 409, 0, 2250, 2248, 1, 0, 0, 0, 2250, 2251, 1, 0, 0, 0, 2251, 2253, 1, 0, 0, 0, 2252, 2254, 3, 98, 49, 0, 2253, 2252, 1, 0, 0, 0, 2253, 2254, 1, 0, 0, 0, 2254, 2257, 1, 0, 0, 0, 2255, 2256, 5, 105, 0, 0, 2256, 2258, 5, 280, 0, 0, 2257, 2255, 1, 0, 0, 0, 2257, 2258, 1, 0, 0, 0, 2258, 2262, 1, 0, 0, 0, 2259, 2261, 3, 134, 67, 0, 2260, 2259, 1, 0, 0, 0, 2261, 2264, 1, 0, 0, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 133, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2265, 2266, 5, 45, 0, 0, 2266, 2268, 3, 818, 409, 0, 2267, 2265, 1, 0, 0, 0, 2267, 2268, 1, 0, 0, 0, 2268, 2269, 1, 0, 0, 0, 2269, 2274, 3, 136, 68, 0, 2270, 2272, 5, 77, 0, 0, 2271, 2270, 1, 0, 0, 0, 2271, 2272, 1, 0, 0, 0, 2272, 2273, 1, 0, 0, 0, 2273, 2275, 5, 54, 0, 0, 2274, 2271, 1, 0, 0, 0, 2274, 2275, 1, 0, 0, 0, 2275, 2278, 1, 0, 0, 0, 2276, 2277, 5, 69, 0, 0, 2277, 2279, 7, 9, 0, 0, 2278, 2276, 1, 0, 0, 0, 2278, 2279, 1, 0, 0, 0, 2279, 135, 1, 0, 0, 0, 2280, 2282, 5, 77, 0, 0, 2281, 2280, 1, 0, 0, 0, 2281, 2282, 1, 0, 0, 0, 2282, 2283, 1, 0, 0, 0, 2283, 2361, 5, 78, 0, 0, 2284, 2286, 5, 98, 0, 0, 2285, 2287, 3, 400, 200, 0, 2286, 2285, 1, 0, 0, 0, 2286, 2287, 1, 0, 0, 0, 2287, 2289, 1, 0, 0, 0, 2288, 2290, 3, 178, 89, 0, 2289, 2288, 1, 0, 0, 0, 2289, 2290, 1, 0, 0, 0, 2290, 2361, 1, 0, 0, 0, 2291, 2297, 5, 98, 0, 0, 2292, 2294, 5, 273, 0, 0, 2293, 2295, 5, 77, 0, 0, 2294, 2293, 1, 0, 0, 0, 2294, 2295, 1, 0, 0, 0, 2295, 2296, 1, 0, 0, 0, 2296, 2298, 5, 56, 0, 0, 2297, 2292, 1, 0, 0, 0, 2297, 2298, 1, 0, 0, 0, 2298, 2301, 1, 0, 0, 0, 2299, 2300, 5, 441, 0, 0, 2300, 2302, 3, 360, 180, 0, 2301, 2299, 1, 0, 0, 0, 2301, 2302, 1, 0, 0, 0, 2302, 2304, 1, 0, 0, 0, 2303, 2305, 3, 572, 286, 0, 2304, 2303, 1, 0, 0, 0, 2304, 2305, 1, 0, 0, 0, 2305, 2307, 1, 0, 0, 0, 2306, 2308, 3, 178, 89, 0, 2307, 2306, 1, 0, 0, 0, 2307, 2308, 1, 0, 0, 0, 2308, 2361, 1, 0, 0, 0, 2309, 2310, 5, 85, 0, 0, 2310, 2312, 5, 245, 0, 0, 2311, 2313, 3, 400, 200, 0, 2312, 2311, 1, 0, 0, 0, 2312, 2313, 1, 0, 0, 0, 2313, 2315, 1, 0, 0, 0, 2314, 2316, 3, 178, 89, 0, 2315, 2314, 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, 2316, 2361, 1, 0, 0, 0, 2317, 2318, 5, 42, 0, 0, 2318, 2319, 5, 2, 0, 0, 2319, 2320, 3, 674, 337, 0, 2320, 2323, 5, 3, 0, 0, 2321, 2322, 5, 269, 0, 0, 2322, 2324, 5, 228, 0, 0, 2323, 2321, 1, 0, 0, 0, 2323, 2324, 1, 0, 0, 0, 2324, 2361, 1, 0, 0, 0, 2325, 2326, 5, 53, 0, 0, 2326, 2361, 3, 682, 341, 0, 2327, 2328, 5, 438, 0, 0, 2328, 2329, 3, 138, 69, 0, 2329, 2346, 5, 36, 0, 0, 2330, 2339, 5, 219, 0, 0, 2331, 2333, 5, 2, 0, 0, 2332, 2334, 3, 200, 100, 0, 2333, 2332, 1, 0, 0, 0, 2334, 2335, 1, 0, 0, 0, 2335, 2333, 1, 0, 0, 0, 2335, 2336, 1, 0, 0, 0, 2336, 2337, 1, 0, 0, 0, 2337, 2338, 5, 3, 0, 0, 2338, 2340, 1, 0, 0, 0, 2339, 2331, 1, 0, 0, 0, 2339, 2340, 1, 0, 0, 0, 2340, 2347, 1, 0, 0, 0, 2341, 2342, 5, 2, 0, 0, 2342, 2343, 3, 674, 337, 0, 2343, 2344, 5, 3, 0, 0, 2344, 2345, 5, 440, 0, 0, 2345, 2347, 1, 0, 0, 0, 2346, 2330, 1, 0, 0, 0, 2346, 2341, 1, 0, 0, 0, 2347, 2361, 1, 0, 0, 0, 2348, 2349, 5, 86, 0, 0, 2349, 2351, 3, 780, 390, 0, 2350, 2352, 3, 144, 72, 0, 2351, 2350, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2354, 1, 0, 0, 0, 2353, 2355, 3, 152, 76, 0, 2354, 2353, 1, 0, 0, 0, 2354, 2355, 1, 0, 0, 0, 2355, 2357, 1, 0, 0, 0, 2356, 2358, 3, 156, 78, 0, 2357, 2356, 1, 0, 0, 0, 2357, 2358, 1, 0, 0, 0, 2358, 2361, 1, 0, 0, 0, 2359, 2361, 3, 98, 49, 0, 2360, 2281, 1, 0, 0, 0, 2360, 2284, 1, 0, 0, 0, 2360, 2291, 1, 0, 0, 0, 2360, 2309, 1, 0, 0, 0, 2360, 2317, 1, 0, 0, 0, 2360, 2325, 1, 0, 0, 0, 2360, 2327, 1, 0, 0, 0, 2360, 2348, 1, 0, 0, 0, 2360, 2359, 1, 0, 0, 0, 2361, 137, 1, 0, 0, 0, 2362, 2366, 5, 139, 0, 0, 2363, 2364, 5, 147, 0, 0, 2364, 2366, 5, 53, 0, 0, 2365, 2362, 1, 0, 0, 0, 2365, 2363, 1, 0, 0, 0, 2366, 139, 1, 0, 0, 0, 2367, 2368, 7, 23, 0, 0, 2368, 141, 1, 0, 0, 0, 2369, 2370, 5, 42, 0, 0, 2370, 2371, 5, 2, 0, 0, 2371, 2372, 3, 674, 337, 0, 2372, 2376, 5, 3, 0, 0, 2373, 2375, 3, 272, 136, 0, 2374, 2373, 1, 0, 0, 0, 2375, 2378, 1, 0, 0, 0, 2376, 2374, 1, 0, 0, 0, 2376, 2377, 1, 0, 0, 0, 2377, 2466, 1, 0, 0, 0, 2378, 2376, 1, 0, 0, 0, 2379, 2383, 5, 98, 0, 0, 2380, 2381, 5, 85, 0, 0, 2381, 2383, 5, 245, 0, 0, 2382, 2379, 1, 0, 0, 0, 2382, 2380, 1, 0, 0, 0, 2383, 2407, 1, 0, 0, 0, 2384, 2386, 3, 144, 72, 0, 2385, 2387, 3, 150, 75, 0, 2386, 2385, 1, 0, 0, 0, 2386, 2387, 1, 0, 0, 0, 2387, 2389, 1, 0, 0, 0, 2388, 2390, 3, 400, 200, 0, 2389, 2388, 1, 0, 0, 0, 2389, 2390, 1, 0, 0, 0, 2390, 2392, 1, 0, 0, 0, 2391, 2393, 3, 178, 89, 0, 2392, 2391, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2397, 1, 0, 0, 0, 2394, 2396, 3, 272, 136, 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, 2408, 1, 0, 0, 0, 2399, 2397, 1, 0, 0, 0, 2400, 2404, 3, 180, 90, 0, 2401, 2403, 3, 272, 136, 0, 2402, 2401, 1, 0, 0, 0, 2403, 2406, 1, 0, 0, 0, 2404, 2402, 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 2408, 1, 0, 0, 0, 2406, 2404, 1, 0, 0, 0, 2407, 2384, 1, 0, 0, 0, 2407, 2400, 1, 0, 0, 0, 2408, 2466, 1, 0, 0, 0, 2409, 2411, 5, 199, 0, 0, 2410, 2412, 3, 170, 85, 0, 2411, 2410, 1, 0, 0, 0, 2411, 2412, 1, 0, 0, 0, 2412, 2413, 1, 0, 0, 0, 2413, 2414, 5, 2, 0, 0, 2414, 2419, 3, 154, 77, 0, 2415, 2416, 5, 6, 0, 0, 2416, 2418, 3, 154, 77, 0, 2417, 2415, 1, 0, 0, 0, 2418, 2421, 1, 0, 0, 0, 2419, 2417, 1, 0, 0, 0, 2419, 2420, 1, 0, 0, 0, 2420, 2422, 1, 0, 0, 0, 2421, 2419, 1, 0, 0, 0, 2422, 2424, 5, 3, 0, 0, 2423, 2425, 3, 150, 75, 0, 2424, 2423, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2427, 1, 0, 0, 0, 2426, 2428, 3, 400, 200, 0, 2427, 2426, 1, 0, 0, 0, 2427, 2428, 1, 0, 0, 0, 2428, 2430, 1, 0, 0, 0, 2429, 2431, 3, 178, 89, 0, 2430, 2429, 1, 0, 0, 0, 2430, 2431, 1, 0, 0, 0, 2431, 2437, 1, 0, 0, 0, 2432, 2433, 5, 103, 0, 0, 2433, 2434, 5, 2, 0, 0, 2434, 2435, 3, 674, 337, 0, 2435, 2436, 5, 3, 0, 0, 2436, 2438, 1, 0, 0, 0, 2437, 2432, 1, 0, 0, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2442, 1, 0, 0, 0, 2439, 2441, 3, 272, 136, 0, 2440, 2439, 1, 0, 0, 0, 2441, 2444, 1, 0, 0, 0, 2442, 2440, 1, 0, 0, 0, 2442, 2443, 1, 0, 0, 0, 2443, 2466, 1, 0, 0, 0, 2444, 2442, 1, 0, 0, 0, 2445, 2446, 5, 63, 0, 0, 2446, 2447, 5, 245, 0, 0, 2447, 2448, 3, 144, 72, 0, 2448, 2449, 5, 86, 0, 0, 2449, 2451, 3, 780, 390, 0, 2450, 2452, 3, 144, 72, 0, 2451, 2450, 1, 0, 0, 0, 2451, 2452, 1, 0, 0, 0, 2452, 2454, 1, 0, 0, 0, 2453, 2455, 3, 152, 76, 0, 2454, 2453, 1, 0, 0, 0, 2454, 2455, 1, 0, 0, 0, 2455, 2457, 1, 0, 0, 0, 2456, 2458, 3, 156, 78, 0, 2457, 2456, 1, 0, 0, 0, 2457, 2458, 1, 0, 0, 0, 2458, 2462, 1, 0, 0, 0, 2459, 2461, 3, 272, 136, 0, 2460, 2459, 1, 0, 0, 0, 2461, 2464, 1, 0, 0, 0, 2462, 2460, 1, 0, 0, 0, 2462, 2463, 1, 0, 0, 0, 2463, 2466, 1, 0, 0, 0, 2464, 2462, 1, 0, 0, 0, 2465, 2369, 1, 0, 0, 0, 2465, 2382, 1, 0, 0, 0, 2465, 2409, 1, 0, 0, 0, 2465, 2445, 1, 0, 0, 0, 2466, 143, 1, 0, 0, 0, 2467, 2468, 5, 2, 0, 0, 2468, 2469, 3, 148, 74, 0, 2469, 2470, 5, 3, 0, 0, 2470, 145, 1, 0, 0, 0, 2471, 2472, 5, 2, 0, 0, 2472, 2477, 3, 802, 401, 0, 2473, 2474, 5, 6, 0, 0, 2474, 2476, 3, 802, 401, 0, 2475, 2473, 1, 0, 0, 0, 2476, 2479, 1, 0, 0, 0, 2477, 2475, 1, 0, 0, 0, 2477, 2478, 1, 0, 0, 0, 2478, 2480, 1, 0, 0, 0, 2479, 2477, 1, 0, 0, 0, 2480, 2481, 5, 3, 0, 0, 2481, 147, 1, 0, 0, 0, 2482, 2487, 3, 800, 400, 0, 2483, 2484, 5, 6, 0, 0, 2484, 2486, 3, 800, 400, 0, 2485, 2483, 1, 0, 0, 0, 2486, 2489, 1, 0, 0, 0, 2487, 2485, 1, 0, 0, 0, 2487, 2488, 1, 0, 0, 0, 2488, 149, 1, 0, 0, 0, 2489, 2487, 1, 0, 0, 0, 2490, 2491, 5, 441, 0, 0, 2491, 2492, 3, 144, 72, 0, 2492, 151, 1, 0, 0, 0, 2493, 2494, 5, 258, 0, 0, 2494, 2495, 7, 24, 0, 0, 2495, 153, 1, 0, 0, 0, 2496, 2497, 3, 362, 181, 0, 2497, 2504, 5, 105, 0, 0, 2498, 2505, 3, 414, 207, 0, 2499, 2500, 5, 278, 0, 0, 2500, 2501, 5, 2, 0, 0, 2501, 2502, 3, 414, 207, 0, 2502, 2503, 5, 3, 0, 0, 2503, 2505, 1, 0, 0, 0, 2504, 2498, 1, 0, 0, 0, 2504, 2499, 1, 0, 0, 0, 2505, 155, 1, 0, 0, 0, 2506, 2508, 3, 158, 79, 0, 2507, 2509, 3, 160, 80, 0, 2508, 2507, 1, 0, 0, 0, 2508, 2509, 1, 0, 0, 0, 2509, 2515, 1, 0, 0, 0, 2510, 2512, 3, 160, 80, 0, 2511, 2513, 3, 158, 79, 0, 2512, 2511, 1, 0, 0, 0, 2512, 2513, 1, 0, 0, 0, 2513, 2515, 1, 0, 0, 0, 2514, 2506, 1, 0, 0, 0, 2514, 2510, 1, 0, 0, 0, 2515, 157, 1, 0, 0, 0, 2516, 2517, 5, 80, 0, 0, 2517, 2518, 5, 369, 0, 0, 2518, 2519, 3, 162, 81, 0, 2519, 159, 1, 0, 0, 0, 2520, 2521, 5, 80, 0, 0, 2521, 2522, 5, 182, 0, 0, 2522, 2523, 3, 162, 81, 0, 2523, 161, 1, 0, 0, 0, 2524, 2525, 5, 269, 0, 0, 2525, 2534, 5, 132, 0, 0, 2526, 2534, 5, 315, 0, 0, 2527, 2534, 5, 150, 0, 0, 2528, 2529, 5, 333, 0, 0, 2529, 2531, 7, 25, 0, 0, 2530, 2532, 3, 148, 74, 0, 2531, 2530, 1, 0, 0, 0, 2531, 2532, 1, 0, 0, 0, 2532, 2534, 1, 0, 0, 0, 2533, 2524, 1, 0, 0, 0, 2533, 2526, 1, 0, 0, 0, 2533, 2527, 1, 0, 0, 0, 2533, 2528, 1, 0, 0, 0, 2534, 163, 1, 0, 0, 0, 2535, 2536, 5, 238, 0, 0, 2536, 2537, 5, 2, 0, 0, 2537, 2538, 3, 760, 380, 0, 2538, 2539, 5, 3, 0, 0, 2539, 165, 1, 0, 0, 0, 2540, 2541, 5, 285, 0, 0, 2541, 2542, 5, 147, 0, 0, 2542, 2543, 3, 818, 409, 0, 2543, 2544, 5, 2, 0, 0, 2544, 2549, 3, 168, 84, 0, 2545, 2546, 5, 6, 0, 0, 2546, 2548, 3, 168, 84, 0, 2547, 2545, 1, 0, 0, 0, 2548, 2551, 1, 0, 0, 0, 2549, 2547, 1, 0, 0, 0, 2549, 2550, 1, 0, 0, 0, 2550, 2552, 1, 0, 0, 0, 2551, 2549, 1, 0, 0, 0, 2552, 2553, 5, 3, 0, 0, 2553, 167, 1, 0, 0, 0, 2554, 2561, 3, 800, 400, 0, 2555, 2561, 3, 688, 344, 0, 2556, 2557, 5, 2, 0, 0, 2557, 2558, 3, 674, 337, 0, 2558, 2559, 5, 3, 0, 0, 2559, 2561, 1, 0, 0, 0, 2560, 2554, 1, 0, 0, 0, 2560, 2555, 1, 0, 0, 0, 2560, 2556, 1, 0, 0, 0, 2561, 2563, 1, 0, 0, 0, 2562, 2564, 3, 98, 49, 0, 2563, 2562, 1, 0, 0, 0, 2563, 2564, 1, 0, 0, 0, 2564, 2566, 1, 0, 0, 0, 2565, 2567, 3, 316, 158, 0, 2566, 2565, 1, 0, 0, 0, 2566, 2567, 1, 0, 0, 0, 2567, 169, 1, 0, 0, 0, 2568, 2569, 5, 100, 0, 0, 2569, 2570, 3, 818, 409, 0, 2570, 171, 1, 0, 0, 0, 2571, 2572, 5, 105, 0, 0, 2572, 2576, 3, 100, 50, 0, 2573, 2574, 7, 26, 0, 0, 2574, 2576, 5, 277, 0, 0, 2575, 2571, 1, 0, 0, 0, 2575, 2573, 1, 0, 0, 0, 2576, 173, 1, 0, 0, 0, 2577, 2578, 5, 80, 0, 0, 2578, 2584, 5, 161, 0, 0, 2579, 2585, 5, 191, 0, 0, 2580, 2581, 5, 182, 0, 0, 2581, 2585, 5, 320, 0, 0, 2582, 2583, 5, 292, 0, 0, 2583, 2585, 5, 320, 0, 0, 2584, 2579, 1, 0, 0, 0, 2584, 2580, 1, 0, 0, 0, 2584, 2582, 1, 0, 0, 0, 2585, 175, 1, 0, 0, 0, 2586, 2587, 5, 351, 0, 0, 2587, 2588, 3, 770, 385, 0, 2588, 177, 1, 0, 0, 0, 2589, 2590, 5, 100, 0, 0, 2590, 2591, 5, 226, 0, 0, 2591, 2592, 3, 176, 88, 0, 2592, 179, 1, 0, 0, 0, 2593, 2594, 5, 100, 0, 0, 2594, 2595, 5, 226, 0, 0, 2595, 2596, 3, 818, 409, 0, 2596, 181, 1, 0, 0, 0, 2597, 2598, 5, 46, 0, 0, 2598, 2603, 5, 342, 0, 0, 2599, 2601, 3, 294, 147, 0, 2600, 2599, 1, 0, 0, 0, 2600, 2601, 1, 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 2604, 3, 316, 158, 0, 2603, 2600, 1, 0, 0, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2606, 1, 0, 0, 0, 2605, 2607, 3, 144, 72, 0, 2606, 2605, 1, 0, 0, 0, 2606, 2607, 1, 0, 0, 0, 2607, 2608, 1, 0, 0, 0, 2608, 2618, 5, 80, 0, 0, 2609, 2614, 3, 732, 366, 0, 2610, 2611, 5, 6, 0, 0, 2611, 2613, 3, 732, 366, 0, 2612, 2610, 1, 0, 0, 0, 2613, 2616, 1, 0, 0, 0, 2614, 2612, 1, 0, 0, 0, 2614, 2615, 1, 0, 0, 0, 2615, 2619, 1, 0, 0, 0, 2616, 2614, 1, 0, 0, 0, 2617, 2619, 3, 730, 365, 0, 2618, 2609, 1, 0, 0, 0, 2618, 2617, 1, 0, 0, 0, 2619, 2620, 1, 0, 0, 0, 2620, 2621, 3, 610, 305, 0, 2621, 183, 1, 0, 0, 0, 2622, 2623, 5, 138, 0, 0, 2623, 2625, 5, 342, 0, 0, 2624, 2626, 3, 422, 211, 0, 2625, 2624, 1, 0, 0, 0, 2625, 2626, 1, 0, 0, 0, 2626, 2627, 1, 0, 0, 0, 2627, 2628, 3, 316, 158, 0, 2628, 2629, 5, 333, 0, 0, 2629, 2630, 5, 342, 0, 0, 2630, 2631, 3, 812, 406, 0, 2631, 185, 1, 0, 0, 0, 2632, 2634, 5, 46, 0, 0, 2633, 2635, 3, 122, 61, 0, 2634, 2633, 1, 0, 0, 0, 2634, 2635, 1, 0, 0, 0, 2635, 2636, 1, 0, 0, 0, 2636, 2638, 5, 92, 0, 0, 2637, 2639, 3, 294, 147, 0, 2638, 2637, 1, 0, 0, 0, 2638, 2639, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, 2641, 3, 188, 94, 0, 2641, 2642, 5, 36, 0, 0, 2642, 2644, 3, 560, 280, 0, 2643, 2645, 3, 190, 95, 0, 2644, 2643, 1, 0, 0, 0, 2644, 2645, 1, 0, 0, 0, 2645, 187, 1, 0, 0, 0, 2646, 2648, 3, 772, 386, 0, 2647, 2649, 3, 146, 73, 0, 2648, 2647, 1, 0, 0, 0, 2648, 2649, 1, 0, 0, 0, 2649, 2651, 1, 0, 0, 0, 2650, 2652, 3, 170, 85, 0, 2651, 2650, 1, 0, 0, 0, 2651, 2652, 1, 0, 0, 0, 2652, 2654, 1, 0, 0, 0, 2653, 2655, 3, 172, 86, 0, 2654, 2653, 1, 0, 0, 0, 2654, 2655, 1, 0, 0, 0, 2655, 2657, 1, 0, 0, 0, 2656, 2658, 3, 174, 87, 0, 2657, 2656, 1, 0, 0, 0, 2657, 2658, 1, 0, 0, 0, 2658, 2660, 1, 0, 0, 0, 2659, 2661, 3, 176, 88, 0, 2660, 2659, 1, 0, 0, 0, 2660, 2661, 1, 0, 0, 0, 2661, 189, 1, 0, 0, 0, 2662, 2666, 5, 105, 0, 0, 2663, 2667, 5, 174, 0, 0, 2664, 2665, 5, 269, 0, 0, 2665, 2667, 5, 174, 0, 0, 2666, 2663, 1, 0, 0, 0, 2666, 2664, 1, 0, 0, 0, 2667, 191, 1, 0, 0, 0, 2668, 2670, 5, 46, 0, 0, 2669, 2671, 5, 367, 0, 0, 2670, 2669, 1, 0, 0, 0, 2670, 2671, 1, 0, 0, 0, 2671, 2672, 1, 0, 0, 0, 2672, 2673, 5, 259, 0, 0, 2673, 2675, 5, 376, 0, 0, 2674, 2676, 3, 294, 147, 0, 2675, 2674, 1, 0, 0, 0, 2675, 2676, 1, 0, 0, 0, 2676, 2677, 1, 0, 0, 0, 2677, 2679, 3, 776, 388, 0, 2678, 2680, 3, 146, 73, 0, 2679, 2678, 1, 0, 0, 0, 2679, 2680, 1, 0, 0, 0, 2680, 2682, 1, 0, 0, 0, 2681, 2683, 3, 170, 85, 0, 2682, 2681, 1, 0, 0, 0, 2682, 2683, 1, 0, 0, 0, 2683, 2685, 1, 0, 0, 0, 2684, 2686, 3, 102, 51, 0, 2685, 2684, 1, 0, 0, 0, 2685, 2686, 1, 0, 0, 0, 2686, 2688, 1, 0, 0, 0, 2687, 2689, 3, 176, 88, 0, 2688, 2687, 1, 0, 0, 0, 2688, 2689, 1, 0, 0, 0, 2689, 2690, 1, 0, 0, 0, 2690, 2691, 5, 36, 0, 0, 2691, 2693, 3, 560, 280, 0, 2692, 2694, 3, 190, 95, 0, 2693, 2692, 1, 0, 0, 0, 2693, 2694, 1, 0, 0, 0, 2694, 193, 1, 0, 0, 0, 2695, 2696, 5, 305, 0, 0, 2696, 2697, 5, 259, 0, 0, 2697, 2699, 5, 376, 0, 0, 2698, 2700, 5, 109, 0, 0, 2699, 2698, 1, 0, 0, 0, 2699, 2700, 1, 0, 0, 0, 2700, 2701, 1, 0, 0, 0, 2701, 2703, 3, 778, 389, 0, 2702, 2704, 3, 190, 95, 0, 2703, 2702, 1, 0, 0, 0, 2703, 2704, 1, 0, 0, 0, 2704, 195, 1, 0, 0, 0, 2705, 2707, 5, 46, 0, 0, 2706, 2708, 3, 122, 61, 0, 2707, 2706, 1, 0, 0, 0, 2707, 2708, 1, 0, 0, 0, 2708, 2709, 1, 0, 0, 0, 2709, 2711, 5, 328, 0, 0, 2710, 2712, 3, 294, 147, 0, 2711, 2710, 1, 0, 0, 0, 2711, 2712, 1, 0, 0, 0, 2712, 2713, 1, 0, 0, 0, 2713, 2719, 3, 780, 390, 0, 2714, 2716, 3, 200, 100, 0, 2715, 2714, 1, 0, 0, 0, 2716, 2717, 1, 0, 0, 0, 2717, 2715, 1, 0, 0, 0, 2717, 2718, 1, 0, 0, 0, 2718, 2720, 1, 0, 0, 0, 2719, 2715, 1, 0, 0, 0, 2719, 2720, 1, 0, 0, 0, 2720, 197, 1, 0, 0, 0, 2721, 2722, 5, 138, 0, 0, 2722, 2724, 5, 328, 0, 0, 2723, 2725, 3, 422, 211, 0, 2724, 2723, 1, 0, 0, 0, 2724, 2725, 1, 0, 0, 0, 2725, 2726, 1, 0, 0, 0, 2726, 2728, 3, 780, 390, 0, 2727, 2729, 3, 200, 100, 0, 2728, 2727, 1, 0, 0, 0, 2729, 2730, 1, 0, 0, 0, 2730, 2728, 1, 0, 0, 0, 2730, 2731, 1, 0, 0, 0, 2731, 199, 1, 0, 0, 0, 2732, 2733, 5, 36, 0, 0, 2733, 2766, 3, 654, 327, 0, 2734, 2736, 5, 148, 0, 0, 2735, 2737, 3, 202, 101, 0, 2736, 2735, 1, 0, 0, 0, 2736, 2737, 1, 0, 0, 0, 2737, 2766, 1, 0, 0, 0, 2738, 2740, 5, 225, 0, 0, 2739, 2741, 5, 147, 0, 0, 2740, 2739, 1, 0, 0, 0, 2740, 2741, 1, 0, 0, 0, 2741, 2742, 1, 0, 0, 0, 2742, 2766, 3, 202, 101, 0, 2743, 2744, 7, 27, 0, 0, 2744, 2766, 3, 202, 101, 0, 2745, 2746, 5, 269, 0, 0, 2746, 2766, 7, 28, 0, 0, 2747, 2748, 5, 281, 0, 0, 2748, 2749, 5, 147, 0, 0, 2749, 2766, 3, 800, 400, 0, 2750, 2751, 5, 328, 0, 0, 2751, 2752, 5, 266, 0, 0, 2752, 2766, 3, 316, 158, 0, 2753, 2755, 5, 340, 0, 0, 2754, 2756, 5, 105, 0, 0, 2755, 2754, 1, 0, 0, 0, 2755, 2756, 1, 0, 0, 0, 2756, 2757, 1, 0, 0, 0, 2757, 2766, 3, 202, 101, 0, 2758, 2760, 5, 314, 0, 0, 2759, 2761, 5, 105, 0, 0, 2760, 2759, 1, 0, 0, 0, 2760, 2761, 1, 0, 0, 0, 2761, 2763, 1, 0, 0, 0, 2762, 2764, 3, 202, 101, 0, 2763, 2762, 1, 0, 0, 0, 2763, 2764, 1, 0, 0, 0, 2764, 2766, 1, 0, 0, 0, 2765, 2732, 1, 0, 0, 0, 2765, 2734, 1, 0, 0, 0, 2765, 2738, 1, 0, 0, 0, 2765, 2743, 1, 0, 0, 0, 2765, 2745, 1, 0, 0, 0, 2765, 2747, 1, 0, 0, 0, 2765, 2750, 1, 0, 0, 0, 2765, 2753, 1, 0, 0, 0, 2765, 2758, 1, 0, 0, 0, 2766, 201, 1, 0, 0, 0, 2767, 2769, 7, 29, 0, 0, 2768, 2767, 1, 0, 0, 0, 2768, 2769, 1, 0, 0, 0, 2769, 2770, 1, 0, 0, 0, 2770, 2773, 5, 573, 0, 0, 2771, 2773, 3, 812, 406, 0, 2772, 2768, 1, 0, 0, 0, 2772, 2771, 1, 0, 0, 0, 2773, 203, 1, 0, 0, 0, 2774, 2776, 5, 46, 0, 0, 2775, 2777, 3, 366, 183, 0, 2776, 2775, 1, 0, 0, 0, 2776, 2777, 1, 0, 0, 0, 2777, 2779, 1, 0, 0, 0, 2778, 2780, 5, 359, 0, 0, 2779, 2778, 1, 0, 0, 0, 2779, 2780, 1, 0, 0, 0, 2780, 2782, 1, 0, 0, 0, 2781, 2783, 5, 295, 0, 0, 2782, 2781, 1, 0, 0, 0, 2782, 2783, 1, 0, 0, 0, 2783, 2784, 1, 0, 0, 0, 2784, 2785, 5, 247, 0, 0, 2785, 2798, 3, 818, 409, 0, 2786, 2787, 5, 215, 0, 0, 2787, 2790, 3, 316, 158, 0, 2788, 2789, 5, 239, 0, 0, 2789, 2791, 3, 316, 158, 0, 2790, 2788, 1, 0, 0, 0, 2790, 2791, 1, 0, 0, 0, 2791, 2796, 1, 0, 0, 0, 2792, 2793, 5, 373, 0, 0, 2793, 2797, 3, 316, 158, 0, 2794, 2795, 5, 269, 0, 0, 2795, 2797, 5, 373, 0, 0, 2796, 2792, 1, 0, 0, 0, 2796, 2794, 1, 0, 0, 0, 2796, 2797, 1, 0, 0, 0, 2797, 2799, 1, 0, 0, 0, 2798, 2786, 1, 0, 0, 0, 2798, 2799, 1, 0, 0, 0, 2799, 205, 1, 0, 0, 0, 2800, 2801, 5, 46, 0, 0, 2801, 2804, 3, 176, 88, 0, 2802, 2803, 5, 282, 0, 0, 2803, 2805, 3, 814, 407, 0, 2804, 2802, 1, 0, 0, 0, 2804, 2805, 1, 0, 0, 0, 2805, 2806, 1, 0, 0, 0, 2806, 2807, 5, 255, 0, 0, 2807, 2809, 3, 808, 404, 0, 2808, 2810, 3, 102, 51, 0, 2809, 2808, 1, 0, 0, 0, 2809, 2810, 1, 0, 0, 0, 2810, 207, 1, 0, 0, 0, 2811, 2812, 5, 46, 0, 0, 2812, 2814, 5, 204, 0, 0, 2813, 2815, 3, 294, 147, 0, 2814, 2813, 1, 0, 0, 0, 2814, 2815, 1, 0, 0, 0, 2815, 2816, 1, 0, 0, 0, 2816, 2818, 3, 818, 409, 0, 2817, 2819, 5, 105, 0, 0, 2818, 2817, 1, 0, 0, 0, 2818, 2819, 1, 0, 0, 0, 2819, 2827, 1, 0, 0, 0, 2820, 2821, 5, 323, 0, 0, 2821, 2826, 3, 790, 395, 0, 2822, 2823, 7, 30, 0, 0, 2823, 2826, 3, 58, 29, 0, 2824, 2826, 5, 150, 0, 0, 2825, 2820, 1, 0, 0, 0, 2825, 2822, 1, 0, 0, 0, 2825, 2824, 1, 0, 0, 0, 2826, 2829, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2827, 2828, 1, 0, 0, 0, 2828, 209, 1, 0, 0, 0, 2829, 2827, 1, 0, 0, 0, 2830, 2831, 5, 138, 0, 0, 2831, 2832, 5, 204, 0, 0, 2832, 2833, 3, 818, 409, 0, 2833, 2838, 5, 369, 0, 0, 2834, 2835, 5, 94, 0, 0, 2835, 2837, 3, 58, 29, 0, 2836, 2834, 1, 0, 0, 0, 2837, 2840, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2838, 2839, 1, 0, 0, 0, 2839, 211, 1, 0, 0, 0, 2840, 2838, 1, 0, 0, 0, 2841, 2842, 5, 138, 0, 0, 2842, 2843, 5, 204, 0, 0, 2843, 2844, 3, 818, 409, 0, 2844, 2877, 7, 6, 0, 0, 2845, 2846, 5, 443, 0, 0, 2846, 2847, 5, 62, 0, 0, 2847, 2848, 3, 652, 326, 0, 2848, 2849, 5, 247, 0, 0, 2849, 2850, 3, 818, 409, 0, 2850, 2878, 1, 0, 0, 0, 2851, 2852, 5, 442, 0, 0, 2852, 2878, 3, 374, 187, 0, 2853, 2854, 5, 296, 0, 0, 2854, 2878, 3, 378, 189, 0, 2855, 2856, 5, 278, 0, 0, 2856, 2857, 7, 31, 0, 0, 2857, 2858, 3, 316, 158, 0, 2858, 2859, 3, 170, 85, 0, 2859, 2878, 1, 0, 0, 0, 2860, 2861, 5, 278, 0, 0, 2861, 2878, 3, 416, 208, 0, 2862, 2863, 5, 211, 0, 0, 2863, 2878, 3, 382, 191, 0, 2864, 2865, 7, 32, 0, 0, 2865, 2878, 3, 652, 326, 0, 2866, 2867, 5, 41, 0, 0, 2867, 2868, 5, 2, 0, 0, 2868, 2869, 3, 652, 326, 0, 2869, 2870, 5, 36, 0, 0, 2870, 2871, 3, 652, 326, 0, 2871, 2872, 5, 3, 0, 0, 2872, 2878, 1, 0, 0, 0, 2873, 2874, 5, 136, 0, 0, 2874, 2878, 3, 394, 197, 0, 2875, 2878, 3, 312, 156, 0, 2876, 2878, 3, 310, 155, 0, 2877, 2845, 1, 0, 0, 0, 2877, 2851, 1, 0, 0, 0, 2877, 2853, 1, 0, 0, 0, 2877, 2855, 1, 0, 0, 0, 2877, 2860, 1, 0, 0, 0, 2877, 2862, 1, 0, 0, 0, 2877, 2864, 1, 0, 0, 0, 2877, 2866, 1, 0, 0, 0, 2877, 2873, 1, 0, 0, 0, 2877, 2875, 1, 0, 0, 0, 2877, 2876, 1, 0, 0, 0, 2878, 213, 1, 0, 0, 0, 2879, 2880, 5, 46, 0, 0, 2880, 2881, 5, 63, 0, 0, 2881, 2882, 5, 174, 0, 0, 2882, 2883, 5, 381, 0, 0, 2883, 2889, 3, 818, 409, 0, 2884, 2886, 3, 216, 108, 0, 2885, 2884, 1, 0, 0, 0, 2886, 2887, 1, 0, 0, 0, 2887, 2885, 1, 0, 0, 0, 2887, 2888, 1, 0, 0, 0, 2888, 2890, 1, 0, 0, 0, 2889, 2885, 1, 0, 0, 0, 2889, 2890, 1, 0, 0, 0, 2890, 2892, 1, 0, 0, 0, 2891, 2893, 3, 220, 110, 0, 2892, 2891, 1, 0, 0, 0, 2892, 2893, 1, 0, 0, 0, 2893, 215, 1, 0, 0, 0, 2894, 2896, 7, 33, 0, 0, 2895, 2897, 3, 316, 158, 0, 2896, 2895, 1, 0, 0, 0, 2896, 2897, 1, 0, 0, 0, 2897, 2901, 1, 0, 0, 0, 2898, 2899, 5, 269, 0, 0, 2899, 2901, 7, 33, 0, 0, 2900, 2894, 1, 0, 0, 0, 2900, 2898, 1, 0, 0, 0, 2901, 217, 1, 0, 0, 0, 2902, 2903, 5, 138, 0, 0, 2903, 2904, 5, 63, 0, 0, 2904, 2905, 5, 174, 0, 0, 2905, 2906, 5, 381, 0, 0, 2906, 2920, 3, 818, 409, 0, 2907, 2909, 3, 216, 108, 0, 2908, 2907, 1, 0, 0, 0, 2909, 2910, 1, 0, 0, 0, 2910, 2908, 1, 0, 0, 0, 2910, 2911, 1, 0, 0, 0, 2911, 2913, 1, 0, 0, 0, 2912, 2908, 1, 0, 0, 0, 2912, 2913, 1, 0, 0, 0, 2913, 2914, 1, 0, 0, 0, 2914, 2921, 3, 222, 111, 0, 2915, 2917, 3, 216, 108, 0, 2916, 2915, 1, 0, 0, 0, 2917, 2918, 1, 0, 0, 0, 2918, 2916, 1, 0, 0, 0, 2918, 2919, 1, 0, 0, 0, 2919, 2921, 1, 0, 0, 0, 2920, 2912, 1, 0, 0, 0, 2920, 2916, 1, 0, 0, 0, 2921, 219, 1, 0, 0, 0, 2922, 2923, 5, 280, 0, 0, 2923, 2924, 5, 2, 0, 0, 2924, 2929, 3, 226, 113, 0, 2925, 2926, 5, 6, 0, 0, 2926, 2928, 3, 226, 113, 0, 2927, 2925, 1, 0, 0, 0, 2928, 2931, 1, 0, 0, 0, 2929, 2927, 1, 0, 0, 0, 2929, 2930, 1, 0, 0, 0, 2930, 2932, 1, 0, 0, 0, 2931, 2929, 1, 0, 0, 0, 2932, 2933, 5, 3, 0, 0, 2933, 221, 1, 0, 0, 0, 2934, 2935, 5, 280, 0, 0, 2935, 2936, 5, 2, 0, 0, 2936, 2941, 3, 224, 112, 0, 2937, 2938, 5, 6, 0, 0, 2938, 2940, 3, 224, 112, 0, 2939, 2937, 1, 0, 0, 0, 2940, 2943, 1, 0, 0, 0, 2941, 2939, 1, 0, 0, 0, 2941, 2942, 1, 0, 0, 0, 2942, 2944, 1, 0, 0, 0, 2943, 2941, 1, 0, 0, 0, 2944, 2945, 5, 3, 0, 0, 2945, 223, 1, 0, 0, 0, 2946, 2947, 7, 34, 0, 0, 2947, 2948, 3, 226, 113, 0, 2948, 225, 1, 0, 0, 0, 2949, 2950, 3, 824, 412, 0, 2950, 2951, 3, 808, 404, 0, 2951, 227, 1, 0, 0, 0, 2952, 2953, 5, 46, 0, 0, 2953, 2955, 5, 331, 0, 0, 2954, 2956, 3, 294, 147, 0, 2955, 2954, 1, 0, 0, 0, 2955, 2956, 1, 0, 0, 0, 2956, 2957, 1, 0, 0, 0, 2957, 2960, 3, 818, 409, 0, 2958, 2959, 5, 360, 0, 0, 2959, 2961, 3, 808, 404, 0, 2960, 2958, 1, 0, 0, 0, 2960, 2961, 1, 0, 0, 0, 2961, 2963, 1, 0, 0, 0, 2962, 2964, 3, 230, 115, 0, 2963, 2962, 1, 0, 0, 0, 2963, 2964, 1, 0, 0, 0, 2964, 2965, 1, 0, 0, 0, 2965, 2966, 5, 63, 0, 0, 2966, 2967, 5, 174, 0, 0, 2967, 2968, 5, 381, 0, 0, 2968, 2970, 3, 818, 409, 0, 2969, 2971, 3, 220, 110, 0, 2970, 2969, 1, 0, 0, 0, 2970, 2971, 1, 0, 0, 0, 2971, 229, 1, 0, 0, 0, 2972, 2975, 5, 375, 0, 0, 2973, 2976, 3, 808, 404, 0, 2974, 2976, 5, 78, 0, 0, 2975, 2973, 1, 0, 0, 0, 2975, 2974, 1, 0, 0, 0, 2976, 231, 1, 0, 0, 0, 2977, 2978, 5, 138, 0, 0, 2978, 2979, 5, 331, 0, 0, 2979, 2985, 3, 818, 409, 0, 2980, 2986, 3, 222, 111, 0, 2981, 2983, 3, 230, 115, 0, 2982, 2984, 3, 222, 111, 0, 2983, 2982, 1, 0, 0, 0, 2983, 2984, 1, 0, 0, 0, 2984, 2986, 1, 0, 0, 0, 2985, 2980, 1, 0, 0, 0, 2985, 2981, 1, 0, 0, 0, 2986, 233, 1, 0, 0, 0, 2987, 2988, 5, 46, 0, 0, 2988, 2989, 5, 63, 0, 0, 2989, 2991, 5, 92, 0, 0, 2990, 2992, 3, 294, 147, 0, 2991, 2990, 1, 0, 0, 0, 2991, 2992, 1, 0, 0, 0, 2992, 2993, 1, 0, 0, 0, 2993, 2994, 3, 772, 386, 0, 2994, 2996, 5, 2, 0, 0, 2995, 2997, 3, 126, 63, 0, 2996, 2995, 1, 0, 0, 0, 2996, 2997, 1, 0, 0, 0, 2997, 2998, 1, 0, 0, 0, 2998, 3000, 5, 3, 0, 0, 2999, 3001, 3, 164, 82, 0, 3000, 2999, 1, 0, 0, 0, 3000, 3001, 1, 0, 0, 0, 3001, 3002, 1, 0, 0, 0, 3002, 3003, 5, 331, 0, 0, 3003, 3005, 3, 818, 409, 0, 3004, 3006, 3, 220, 110, 0, 3005, 3004, 1, 0, 0, 0, 3005, 3006, 1, 0, 0, 0, 3006, 3027, 1, 0, 0, 0, 3007, 3008, 5, 46, 0, 0, 3008, 3009, 5, 63, 0, 0, 3009, 3011, 5, 92, 0, 0, 3010, 3012, 3, 294, 147, 0, 3011, 3010, 1, 0, 0, 0, 3011, 3012, 1, 0, 0, 0, 3012, 3013, 1, 0, 0, 0, 3013, 3014, 3, 772, 386, 0, 3014, 3015, 5, 285, 0, 0, 3015, 3016, 5, 275, 0, 0, 3016, 3018, 3, 774, 387, 0, 3017, 3019, 3, 124, 62, 0, 3018, 3017, 1, 0, 0, 0, 3018, 3019, 1, 0, 0, 0, 3019, 3020, 1, 0, 0, 0, 3020, 3021, 3, 106, 53, 0, 3021, 3022, 5, 331, 0, 0, 3022, 3024, 3, 818, 409, 0, 3023, 3025, 3, 220, 110, 0, 3024, 3023, 1, 0, 0, 0, 3024, 3025, 1, 0, 0, 0, 3025, 3027, 1, 0, 0, 0, 3026, 2987, 1, 0, 0, 0, 3026, 3007, 1, 0, 0, 0, 3027, 235, 1, 0, 0, 0, 3028, 3029, 5, 444, 0, 0, 3029, 3030, 5, 63, 0, 0, 3030, 3031, 5, 323, 0, 0, 3031, 3041, 3, 790, 395, 0, 3032, 3033, 5, 74, 0, 0, 3033, 3036, 5, 94, 0, 0, 3034, 3036, 5, 59, 0, 0, 3035, 3032, 1, 0, 0, 0, 3035, 3034, 1, 0, 0, 0, 3036, 3037, 1, 0, 0, 0, 3037, 3038, 5, 2, 0, 0, 3038, 3039, 3, 628, 314, 0, 3039, 3040, 5, 3, 0, 0, 3040, 3042, 1, 0, 0, 0, 3041, 3035, 1, 0, 0, 0, 3041, 3042, 1, 0, 0, 0, 3042, 3043, 1, 0, 0, 0, 3043, 3044, 5, 64, 0, 0, 3044, 3045, 5, 331, 0, 0, 3045, 3046, 3, 818, 409, 0, 3046, 3047, 5, 71, 0, 0, 3047, 3049, 3, 818, 409, 0, 3048, 3050, 3, 220, 110, 0, 3049, 3048, 1, 0, 0, 0, 3049, 3050, 1, 0, 0, 0, 3050, 237, 1, 0, 0, 0, 3051, 3052, 5, 46, 0, 0, 3052, 3053, 5, 99, 0, 0, 3053, 3055, 5, 257, 0, 0, 3054, 3056, 3, 294, 147, 0, 3055, 3054, 1, 0, 0, 0, 3055, 3056, 1, 0, 0, 0, 3056, 3057, 1, 0, 0, 0, 3057, 3060, 5, 62, 0, 0, 3058, 3061, 3, 814, 407, 0, 3059, 3061, 5, 99, 0, 0, 3060, 3058, 1, 0, 0, 0, 3060, 3059, 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 3063, 5, 331, 0, 0, 3063, 3065, 3, 818, 409, 0, 3064, 3066, 3, 220, 110, 0, 3065, 3064, 1, 0, 0, 0, 3065, 3066, 1, 0, 0, 0, 3066, 239, 1, 0, 0, 0, 3067, 3068, 5, 138, 0, 0, 3068, 3069, 5, 99, 0, 0, 3069, 3070, 5, 257, 0, 0, 3070, 3073, 5, 62, 0, 0, 3071, 3074, 3, 814, 407, 0, 3072, 3074, 5, 99, 0, 0, 3073, 3071, 1, 0, 0, 0, 3073, 3072, 1, 0, 0, 0, 3074, 3075, 1, 0, 0, 0, 3075, 3076, 5, 331, 0, 0, 3076, 3077, 3, 818, 409, 0, 3077, 3078, 3, 222, 111, 0, 3078, 241, 1, 0, 0, 0, 3079, 3080, 5, 46, 0, 0, 3080, 3081, 5, 445, 0, 0, 3081, 3082, 3, 818, 409, 0, 3082, 3083, 5, 80, 0, 0, 3083, 3090, 3, 780, 390, 0, 3084, 3088, 5, 36, 0, 0, 3085, 3089, 5, 541, 0, 0, 3086, 3089, 5, 542, 0, 0, 3087, 3089, 3, 826, 413, 0, 3088, 3085, 1, 0, 0, 0, 3088, 3086, 1, 0, 0, 0, 3088, 3087, 1, 0, 0, 0, 3089, 3091, 1, 0, 0, 0, 3090, 3084, 1, 0, 0, 0, 3090, 3091, 1, 0, 0, 0, 3091, 3094, 1, 0, 0, 0, 3092, 3093, 5, 62, 0, 0, 3093, 3095, 7, 35, 0, 0, 3094, 3092, 1, 0, 0, 0, 3094, 3095, 1, 0, 0, 0, 3095, 3098, 1, 0, 0, 0, 3096, 3097, 5, 94, 0, 0, 3097, 3099, 3, 816, 408, 0, 3098, 3096, 1, 0, 0, 0, 3098, 3099, 1, 0, 0, 0, 3099, 3101, 1, 0, 0, 0, 3100, 3102, 3, 250, 125, 0, 3101, 3100, 1, 0, 0, 0, 3101, 3102, 1, 0, 0, 0, 3102, 3104, 1, 0, 0, 0, 3103, 3105, 3, 252, 126, 0, 3104, 3103, 1, 0, 0, 0, 3104, 3105, 1, 0, 0, 0, 3105, 243, 1, 0, 0, 0, 3106, 3107, 5, 138, 0, 0, 3107, 3108, 5, 445, 0, 0, 3108, 3109, 3, 818, 409, 0, 3109, 3110, 5, 80, 0, 0, 3110, 3113, 3, 780, 390, 0, 3111, 3112, 5, 94, 0, 0, 3112, 3114, 3, 816, 408, 0, 3113, 3111, 1, 0, 0, 0, 3113, 3114, 1, 0, 0, 0, 3114, 3116, 1, 0, 0, 0, 3115, 3117, 3, 250, 125, 0, 3116, 3115, 1, 0, 0, 0, 3116, 3117, 1, 0, 0, 0, 3117, 3119, 1, 0, 0, 0, 3118, 3120, 3, 252, 126, 0, 3119, 3118, 1, 0, 0, 0, 3119, 3120, 1, 0, 0, 0, 3120, 245, 1, 0, 0, 0, 3121, 3122, 5, 138, 0, 0, 3122, 3123, 5, 296, 0, 0, 3123, 3125, 3, 796, 398, 0, 3124, 3126, 3, 368, 184, 0, 3125, 3124, 1, 0, 0, 0, 3125, 3126, 1, 0, 0, 0, 3126, 3153, 1, 0, 0, 0, 3127, 3131, 3, 248, 124, 0, 3128, 3130, 3, 248, 124, 0, 3129, 3128, 1, 0, 0, 0, 3130, 3133, 1, 0, 0, 0, 3131, 3129, 1, 0, 0, 0, 3131, 3132, 1, 0, 0, 0, 3132, 3135, 1, 0, 0, 0, 3133, 3131, 1, 0, 0, 0, 3134, 3136, 5, 315, 0, 0, 3135, 3134, 1, 0, 0, 0, 3135, 3136, 1, 0, 0, 0, 3136, 3154, 1, 0, 0, 0, 3137, 3138, 5, 309, 0, 0, 3138, 3139, 5, 94, 0, 0, 3139, 3154, 3, 798, 399, 0, 3140, 3141, 5, 282, 0, 0, 3141, 3142, 5, 94, 0, 0, 3142, 3154, 3, 814, 407, 0, 3143, 3144, 5, 333, 0, 0, 3144, 3145, 5, 323, 0, 0, 3145, 3154, 3, 32, 16, 0, 3146, 3148, 5, 269, 0, 0, 3147, 3146, 1, 0, 0, 0, 3147, 3148, 1, 0, 0, 0, 3148, 3149, 1, 0, 0, 0, 3149, 3150, 5, 462, 0, 0, 3150, 3151, 5, 80, 0, 0, 3151, 3152, 5, 204, 0, 0, 3152, 3154, 3, 818, 409, 0, 3153, 3127, 1, 0, 0, 0, 3153, 3137, 1, 0, 0, 0, 3153, 3140, 1, 0, 0, 0, 3153, 3143, 1, 0, 0, 0, 3153, 3147, 1, 0, 0, 0, 3154, 247, 1, 0, 0, 0, 3155, 3157, 5, 205, 0, 0, 3156, 3155, 1, 0, 0, 0, 3156, 3157, 1, 0, 0, 0, 3157, 3158, 1, 0, 0, 0, 3158, 3159, 5, 327, 0, 0, 3159, 3166, 5, 243, 0, 0, 3160, 3162, 5, 205, 0, 0, 3161, 3160, 1, 0, 0, 0, 3161, 3162, 1, 0, 0, 0, 3162, 3163, 1, 0, 0, 0, 3163, 3164, 5, 327, 0, 0, 3164, 3166, 5, 181, 0, 0, 3165, 3156, 1, 0, 0, 0, 3165, 3161, 1, 0, 0, 0, 3166, 3185, 1, 0, 0, 0, 3167, 3168, 5, 333, 0, 0, 3168, 3169, 3, 818, 409, 0, 3169, 3172, 7, 36, 0, 0, 3170, 3173, 3, 818, 409, 0, 3171, 3173, 5, 53, 0, 0, 3172, 3170, 1, 0, 0, 0, 3172, 3171, 1, 0, 0, 0, 3173, 3185, 1, 0, 0, 0, 3174, 3175, 5, 333, 0, 0, 3175, 3176, 3, 818, 409, 0, 3176, 3177, 5, 64, 0, 0, 3177, 3178, 5, 434, 0, 0, 3178, 3185, 1, 0, 0, 0, 3179, 3182, 5, 313, 0, 0, 3180, 3183, 3, 818, 409, 0, 3181, 3183, 5, 30, 0, 0, 3182, 3180, 1, 0, 0, 0, 3182, 3181, 1, 0, 0, 0, 3183, 3185, 1, 0, 0, 0, 3184, 3165, 1, 0, 0, 0, 3184, 3167, 1, 0, 0, 0, 3184, 3174, 1, 0, 0, 0, 3184, 3179, 1, 0, 0, 0, 3185, 249, 1, 0, 0, 0, 3186, 3187, 5, 100, 0, 0, 3187, 3188, 5, 2, 0, 0, 3188, 3189, 3, 674, 337, 0, 3189, 3190, 5, 3, 0, 0, 3190, 251, 1, 0, 0, 0, 3191, 3192, 5, 105, 0, 0, 3192, 3193, 5, 42, 0, 0, 3193, 3194, 5, 2, 0, 0, 3194, 3195, 3, 674, 337, 0, 3195, 3196, 5, 3, 0, 0, 3196, 253, 1, 0, 0, 0, 3197, 3198, 5, 46, 0, 0, 3198, 3199, 5, 131, 0, 0, 3199, 3200, 5, 446, 0, 0, 3200, 3201, 3, 818, 409, 0, 3201, 3202, 5, 360, 0, 0, 3202, 3203, 7, 37, 0, 0, 3203, 3204, 5, 215, 0, 0, 3204, 3205, 3, 316, 158, 0, 3205, 255, 1, 0, 0, 0, 3206, 3208, 5, 46, 0, 0, 3207, 3209, 3, 366, 183, 0, 3208, 3207, 1, 0, 0, 0, 3208, 3209, 1, 0, 0, 0, 3209, 3210, 1, 0, 0, 0, 3210, 3211, 5, 357, 0, 0, 3211, 3212, 3, 818, 409, 0, 3212, 3213, 3, 258, 129, 0, 3213, 3214, 3, 260, 130, 0, 3214, 3215, 5, 80, 0, 0, 3215, 3227, 3, 774, 387, 0, 3216, 3223, 5, 447, 0, 0, 3217, 3218, 7, 38, 0, 0, 3218, 3220, 7, 39, 0, 0, 3219, 3221, 5, 36, 0, 0, 3220, 3219, 1, 0, 0, 0, 3220, 3221, 1, 0, 0, 0, 3221, 3222, 1, 0, 0, 0, 3222, 3224, 3, 818, 409, 0, 3223, 3217, 1, 0, 0, 0, 3224, 3225, 1, 0, 0, 0, 3225, 3223, 1, 0, 0, 0, 3225, 3226, 1, 0, 0, 0, 3226, 3228, 1, 0, 0, 0, 3227, 3216, 1, 0, 0, 0, 3227, 3228, 1, 0, 0, 0, 3228, 3234, 1, 0, 0, 0, 3229, 3231, 5, 62, 0, 0, 3230, 3232, 5, 192, 0, 0, 3231, 3230, 1, 0, 0, 0, 3231, 3232, 1, 0, 0, 0, 3232, 3233, 1, 0, 0, 0, 3233, 3235, 7, 40, 0, 0, 3234, 3229, 1, 0, 0, 0, 3234, 3235, 1, 0, 0, 0, 3235, 3237, 1, 0, 0, 0, 3236, 3238, 3, 264, 132, 0, 3237, 3236, 1, 0, 0, 0, 3237, 3238, 1, 0, 0, 0, 3238, 3239, 1, 0, 0, 0, 3239, 3240, 5, 202, 0, 0, 3240, 3241, 3, 266, 133, 0, 3241, 3242, 5, 2, 0, 0, 3242, 3243, 3, 268, 134, 0, 3243, 3244, 5, 3, 0, 0, 3244, 3285, 1, 0, 0, 0, 3245, 3247, 5, 46, 0, 0, 3246, 3248, 3, 366, 183, 0, 3247, 3246, 1, 0, 0, 0, 3247, 3248, 1, 0, 0, 0, 3248, 3250, 1, 0, 0, 0, 3249, 3251, 5, 45, 0, 0, 3250, 3249, 1, 0, 0, 0, 3250, 3251, 1, 0, 0, 0, 3251, 3252, 1, 0, 0, 0, 3252, 3253, 5, 357, 0, 0, 3253, 3254, 3, 818, 409, 0, 3254, 3255, 3, 258, 129, 0, 3255, 3256, 3, 260, 130, 0, 3256, 3257, 5, 80, 0, 0, 3257, 3260, 3, 774, 387, 0, 3258, 3259, 5, 64, 0, 0, 3259, 3261, 3, 780, 390, 0, 3260, 3258, 1, 0, 0, 0, 3260, 3261, 1, 0, 0, 0, 3261, 3265, 1, 0, 0, 0, 3262, 3264, 3, 272, 136, 0, 3263, 3262, 1, 0, 0, 0, 3264, 3267, 1, 0, 0, 0, 3265, 3263, 1, 0, 0, 0, 3265, 3266, 1, 0, 0, 0, 3266, 3273, 1, 0, 0, 0, 3267, 3265, 1, 0, 0, 0, 3268, 3270, 5, 62, 0, 0, 3269, 3271, 5, 192, 0, 0, 3270, 3269, 1, 0, 0, 0, 3270, 3271, 1, 0, 0, 0, 3271, 3272, 1, 0, 0, 0, 3272, 3274, 7, 40, 0, 0, 3273, 3268, 1, 0, 0, 0, 3273, 3274, 1, 0, 0, 0, 3274, 3276, 1, 0, 0, 0, 3275, 3277, 3, 264, 132, 0, 3276, 3275, 1, 0, 0, 0, 3276, 3277, 1, 0, 0, 0, 3277, 3278, 1, 0, 0, 0, 3278, 3279, 5, 202, 0, 0, 3279, 3280, 3, 266, 133, 0, 3280, 3281, 5, 2, 0, 0, 3281, 3282, 3, 268, 134, 0, 3282, 3283, 5, 3, 0, 0, 3283, 3285, 1, 0, 0, 0, 3284, 3206, 1, 0, 0, 0, 3284, 3245, 1, 0, 0, 0, 3285, 257, 1, 0, 0, 0, 3286, 3291, 5, 145, 0, 0, 3287, 3291, 5, 135, 0, 0, 3288, 3289, 5, 242, 0, 0, 3289, 3291, 5, 275, 0, 0, 3290, 3286, 1, 0, 0, 0, 3290, 3287, 1, 0, 0, 0, 3290, 3288, 1, 0, 0, 0, 3291, 259, 1, 0, 0, 0, 3292, 3297, 3, 262, 131, 0, 3293, 3294, 5, 82, 0, 0, 3294, 3296, 3, 262, 131, 0, 3295, 3293, 1, 0, 0, 0, 3296, 3299, 1, 0, 0, 0, 3297, 3295, 1, 0, 0, 0, 3297, 3298, 1, 0, 0, 0, 3298, 261, 1, 0, 0, 0, 3299, 3297, 1, 0, 0, 0, 3300, 3309, 5, 241, 0, 0, 3301, 3309, 5, 182, 0, 0, 3302, 3305, 5, 369, 0, 0, 3303, 3304, 5, 275, 0, 0, 3304, 3306, 3, 148, 74, 0, 3305, 3303, 1, 0, 0, 0, 3305, 3306, 1, 0, 0, 0, 3306, 3309, 1, 0, 0, 0, 3307, 3309, 5, 358, 0, 0, 3308, 3300, 1, 0, 0, 0, 3308, 3301, 1, 0, 0, 0, 3308, 3302, 1, 0, 0, 0, 3308, 3307, 1, 0, 0, 0, 3309, 263, 1, 0, 0, 0, 3310, 3311, 5, 102, 0, 0, 3311, 3312, 5, 2, 0, 0, 3312, 3313, 3, 674, 337, 0, 3313, 3314, 5, 3, 0, 0, 3314, 265, 1, 0, 0, 0, 3315, 3316, 5, 211, 0, 0, 3316, 3320, 3, 806, 403, 0, 3317, 3318, 5, 296, 0, 0, 3318, 3320, 3, 796, 398, 0, 3319, 3315, 1, 0, 0, 0, 3319, 3317, 1, 0, 0, 0, 3320, 267, 1, 0, 0, 0, 3321, 3324, 3, 270, 135, 0, 3322, 3324, 1, 0, 0, 0, 3323, 3321, 1, 0, 0, 0, 3323, 3322, 1, 0, 0, 0, 3324, 3329, 1, 0, 0, 0, 3325, 3326, 5, 6, 0, 0, 3326, 3328, 3, 270, 135, 0, 3327, 3325, 1, 0, 0, 0, 3328, 3331, 1, 0, 0, 0, 3329, 3327, 1, 0, 0, 0, 3329, 3330, 1, 0, 0, 0, 3330, 269, 1, 0, 0, 0, 3331, 3329, 1, 0, 0, 0, 3332, 3337, 5, 571, 0, 0, 3333, 3337, 5, 573, 0, 0, 3334, 3337, 3, 808, 404, 0, 3335, 3337, 3, 824, 412, 0, 3336, 3332, 1, 0, 0, 0, 3336, 3333, 1, 0, 0, 0, 3336, 3334, 1, 0, 0, 0, 3336, 3335, 1, 0, 0, 0, 3337, 271, 1, 0, 0, 0, 3338, 3340, 5, 77, 0, 0, 3339, 3338, 1, 0, 0, 0, 3339, 3340, 1, 0, 0, 0, 3340, 3341, 1, 0, 0, 0, 3341, 3349, 5, 54, 0, 0, 3342, 3343, 5, 69, 0, 0, 3343, 3349, 7, 9, 0, 0, 3344, 3345, 5, 77, 0, 0, 3345, 3349, 5, 371, 0, 0, 3346, 3347, 5, 269, 0, 0, 3347, 3349, 5, 228, 0, 0, 3348, 3339, 1, 0, 0, 0, 3348, 3342, 1, 0, 0, 0, 3348, 3344, 1, 0, 0, 0, 3348, 3346, 1, 0, 0, 0, 3349, 273, 1, 0, 0, 0, 3350, 3351, 5, 46, 0, 0, 3351, 3352, 5, 198, 0, 0, 3352, 3353, 5, 357, 0, 0, 3353, 3354, 3, 818, 409, 0, 3354, 3355, 5, 80, 0, 0, 3355, 3365, 3, 824, 412, 0, 3356, 3357, 5, 102, 0, 0, 3357, 3362, 3, 276, 138, 0, 3358, 3359, 5, 33, 0, 0, 3359, 3361, 3, 276, 138, 0, 3360, 3358, 1, 0, 0, 0, 3361, 3364, 1, 0, 0, 0, 3362, 3360, 1, 0, 0, 0, 3362, 3363, 1, 0, 0, 0, 3363, 3366, 1, 0, 0, 0, 3364, 3362, 1, 0, 0, 0, 3365, 3356, 1, 0, 0, 0, 3365, 3366, 1, 0, 0, 0, 3366, 3367, 1, 0, 0, 0, 3367, 3368, 5, 202, 0, 0, 3368, 3369, 3, 266, 133, 0, 3369, 3370, 5, 2, 0, 0, 3370, 3371, 5, 3, 0, 0, 3371, 275, 1, 0, 0, 0, 3372, 3373, 3, 818, 409, 0, 3373, 3374, 5, 68, 0, 0, 3374, 3375, 5, 2, 0, 0, 3375, 3379, 3, 808, 404, 0, 3376, 3378, 3, 462, 231, 0, 3377, 3376, 1, 0, 0, 0, 3378, 3381, 1, 0, 0, 0, 3379, 3377, 1, 0, 0, 0, 3379, 3380, 1, 0, 0, 0, 3380, 3382, 1, 0, 0, 0, 3381, 3379, 1, 0, 0, 0, 3382, 3383, 5, 3, 0, 0, 3383, 277, 1, 0, 0, 0, 3384, 3385, 5, 138, 0, 0, 3385, 3386, 5, 198, 0, 0, 3386, 3387, 5, 357, 0, 0, 3387, 3393, 3, 818, 409, 0, 3388, 3390, 5, 193, 0, 0, 3389, 3391, 7, 14, 0, 0, 3390, 3389, 1, 0, 0, 0, 3390, 3391, 1, 0, 0, 0, 3391, 3394, 1, 0, 0, 0, 3392, 3394, 5, 186, 0, 0, 3393, 3388, 1, 0, 0, 0, 3393, 3392, 1, 0, 0, 0, 3394, 279, 1, 0, 0, 0, 3395, 3396, 5, 46, 0, 0, 3396, 3397, 5, 140, 0, 0, 3397, 3398, 3, 316, 158, 0, 3398, 3399, 5, 42, 0, 0, 3399, 3400, 5, 2, 0, 0, 3400, 3401, 3, 674, 337, 0, 3401, 3405, 5, 3, 0, 0, 3402, 3404, 3, 272, 136, 0, 3403, 3402, 1, 0, 0, 0, 3404, 3407, 1, 0, 0, 0, 3405, 3403, 1, 0, 0, 0, 3405, 3406, 1, 0, 0, 0, 3406, 281, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3408, 3410, 5, 46, 0, 0, 3409, 3411, 3, 366, 183, 0, 3410, 3409, 1, 0, 0, 0, 3410, 3411, 1, 0, 0, 0, 3411, 3412, 1, 0, 0, 0, 3412, 3413, 5, 136, 0, 0, 3413, 3428, 3, 806, 403, 0, 3414, 3415, 3, 392, 196, 0, 3415, 3416, 3, 284, 142, 0, 3416, 3429, 1, 0, 0, 0, 3417, 3418, 5, 2, 0, 0, 3418, 3423, 3, 290, 145, 0, 3419, 3420, 5, 6, 0, 0, 3420, 3422, 3, 290, 145, 0, 3421, 3419, 1, 0, 0, 0, 3422, 3425, 1, 0, 0, 0, 3423, 3421, 1, 0, 0, 0, 3423, 3424, 1, 0, 0, 0, 3424, 3426, 1, 0, 0, 0, 3425, 3423, 1, 0, 0, 0, 3426, 3427, 5, 3, 0, 0, 3427, 3429, 1, 0, 0, 0, 3428, 3414, 1, 0, 0, 0, 3428, 3417, 1, 0, 0, 0, 3429, 3487, 1, 0, 0, 0, 3430, 3431, 5, 46, 0, 0, 3431, 3432, 5, 278, 0, 0, 3432, 3433, 3, 414, 207, 0, 3433, 3434, 3, 284, 142, 0, 3434, 3487, 1, 0, 0, 0, 3435, 3436, 5, 46, 0, 0, 3436, 3437, 5, 360, 0, 0, 3437, 3438, 3, 316, 158, 0, 3438, 3456, 5, 36, 0, 0, 3439, 3441, 5, 2, 0, 0, 3440, 3442, 3, 642, 321, 0, 3441, 3440, 1, 0, 0, 0, 3441, 3442, 1, 0, 0, 0, 3442, 3443, 1, 0, 0, 0, 3443, 3457, 5, 3, 0, 0, 3444, 3445, 5, 196, 0, 0, 3445, 3453, 5, 2, 0, 0, 3446, 3450, 3, 808, 404, 0, 3447, 3449, 3, 462, 231, 0, 3448, 3447, 1, 0, 0, 0, 3449, 3452, 1, 0, 0, 0, 3450, 3448, 1, 0, 0, 0, 3450, 3451, 1, 0, 0, 0, 3451, 3454, 1, 0, 0, 0, 3452, 3450, 1, 0, 0, 0, 3453, 3446, 1, 0, 0, 0, 3453, 3454, 1, 0, 0, 0, 3454, 3455, 1, 0, 0, 0, 3455, 3457, 5, 3, 0, 0, 3456, 3439, 1, 0, 0, 0, 3456, 3444, 1, 0, 0, 0, 3457, 3487, 1, 0, 0, 0, 3458, 3459, 5, 46, 0, 0, 3459, 3460, 5, 360, 0, 0, 3460, 3466, 3, 316, 158, 0, 3461, 3462, 5, 36, 0, 0, 3462, 3464, 5, 299, 0, 0, 3463, 3461, 1, 0, 0, 0, 3463, 3464, 1, 0, 0, 0, 3464, 3465, 1, 0, 0, 0, 3465, 3467, 3, 284, 142, 0, 3466, 3463, 1, 0, 0, 0, 3466, 3467, 1, 0, 0, 0, 3467, 3487, 1, 0, 0, 0, 3468, 3469, 5, 46, 0, 0, 3469, 3470, 5, 355, 0, 0, 3470, 3471, 5, 325, 0, 0, 3471, 3472, 7, 41, 0, 0, 3472, 3473, 3, 316, 158, 0, 3473, 3474, 3, 284, 142, 0, 3474, 3487, 1, 0, 0, 0, 3475, 3476, 5, 46, 0, 0, 3476, 3478, 5, 108, 0, 0, 3477, 3479, 3, 294, 147, 0, 3478, 3477, 1, 0, 0, 0, 3478, 3479, 1, 0, 0, 0, 3479, 3480, 1, 0, 0, 0, 3480, 3484, 3, 316, 158, 0, 3481, 3485, 3, 284, 142, 0, 3482, 3483, 5, 64, 0, 0, 3483, 3485, 3, 316, 158, 0, 3484, 3481, 1, 0, 0, 0, 3484, 3482, 1, 0, 0, 0, 3485, 3487, 1, 0, 0, 0, 3486, 3408, 1, 0, 0, 0, 3486, 3430, 1, 0, 0, 0, 3486, 3435, 1, 0, 0, 0, 3486, 3458, 1, 0, 0, 0, 3486, 3468, 1, 0, 0, 0, 3486, 3475, 1, 0, 0, 0, 3487, 283, 1, 0, 0, 0, 3488, 3489, 5, 2, 0, 0, 3489, 3494, 3, 286, 143, 0, 3490, 3491, 5, 6, 0, 0, 3491, 3493, 3, 286, 143, 0, 3492, 3490, 1, 0, 0, 0, 3493, 3496, 1, 0, 0, 0, 3494, 3492, 1, 0, 0, 0, 3494, 3495, 1, 0, 0, 0, 3495, 3497, 1, 0, 0, 0, 3496, 3494, 1, 0, 0, 0, 3497, 3498, 5, 3, 0, 0, 3498, 285, 1, 0, 0, 0, 3499, 3502, 3, 824, 412, 0, 3500, 3501, 5, 10, 0, 0, 3501, 3503, 3, 288, 144, 0, 3502, 3500, 1, 0, 0, 0, 3502, 3503, 1, 0, 0, 0, 3503, 287, 1, 0, 0, 0, 3504, 3511, 3, 388, 194, 0, 3505, 3511, 3, 834, 417, 0, 3506, 3511, 3, 726, 363, 0, 3507, 3511, 3, 202, 101, 0, 3508, 3511, 3, 808, 404, 0, 3509, 3511, 5, 407, 0, 0, 3510, 3504, 1, 0, 0, 0, 3510, 3505, 1, 0, 0, 0, 3510, 3506, 1, 0, 0, 0, 3510, 3507, 1, 0, 0, 0, 3510, 3508, 1, 0, 0, 0, 3510, 3509, 1, 0, 0, 0, 3511, 289, 1, 0, 0, 0, 3512, 3513, 3, 826, 413, 0, 3513, 3514, 5, 10, 0, 0, 3514, 3515, 3, 288, 144, 0, 3515, 291, 1, 0, 0, 0, 3516, 3517, 5, 138, 0, 0, 3517, 3518, 5, 360, 0, 0, 3518, 3519, 3, 316, 158, 0, 3519, 3520, 5, 133, 0, 0, 3520, 3522, 5, 450, 0, 0, 3521, 3523, 3, 294, 147, 0, 3522, 3521, 1, 0, 0, 0, 3522, 3523, 1, 0, 0, 0, 3523, 3524, 1, 0, 0, 0, 3524, 3527, 3, 808, 404, 0, 3525, 3526, 7, 42, 0, 0, 3526, 3528, 3, 808, 404, 0, 3527, 3525, 1, 0, 0, 0, 3527, 3528, 1, 0, 0, 0, 3528, 3539, 1, 0, 0, 0, 3529, 3530, 5, 138, 0, 0, 3530, 3531, 5, 360, 0, 0, 3531, 3532, 3, 316, 158, 0, 3532, 3533, 5, 309, 0, 0, 3533, 3534, 5, 450, 0, 0, 3534, 3535, 3, 808, 404, 0, 3535, 3536, 5, 94, 0, 0, 3536, 3537, 3, 808, 404, 0, 3537, 3539, 1, 0, 0, 0, 3538, 3516, 1, 0, 0, 0, 3538, 3529, 1, 0, 0, 0, 3539, 293, 1, 0, 0, 0, 3540, 3541, 5, 220, 0, 0, 3541, 3542, 5, 77, 0, 0, 3542, 3543, 5, 396, 0, 0, 3543, 295, 1, 0, 0, 0, 3544, 3545, 5, 46, 0, 0, 3545, 3546, 5, 278, 0, 0, 3546, 3547, 5, 156, 0, 0, 3547, 3549, 3, 316, 158, 0, 3548, 3550, 5, 53, 0, 0, 3549, 3548, 1, 0, 0, 0, 3549, 3550, 1, 0, 0, 0, 3550, 3551, 1, 0, 0, 0, 3551, 3552, 5, 62, 0, 0, 3552, 3553, 5, 360, 0, 0, 3553, 3554, 3, 652, 326, 0, 3554, 3557, 3, 170, 85, 0, 3555, 3556, 5, 206, 0, 0, 3556, 3558, 3, 316, 158, 0, 3557, 3555, 1, 0, 0, 0, 3557, 3558, 1, 0, 0, 0, 3558, 3559, 1, 0, 0, 0, 3559, 3560, 5, 36, 0, 0, 3560, 3565, 3, 298, 149, 0, 3561, 3562, 5, 6, 0, 0, 3562, 3564, 3, 298, 149, 0, 3563, 3561, 1, 0, 0, 0, 3564, 3567, 1, 0, 0, 0, 3565, 3563, 1, 0, 0, 0, 3565, 3566, 1, 0, 0, 0, 3566, 297, 1, 0, 0, 0, 3567, 3565, 1, 0, 0, 0, 3568, 3569, 5, 278, 0, 0, 3569, 3570, 5, 571, 0, 0, 3570, 3572, 3, 414, 207, 0, 3571, 3573, 3, 412, 206, 0, 3572, 3571, 1, 0, 0, 0, 3572, 3573, 1, 0, 0, 0, 3573, 3581, 1, 0, 0, 0, 3574, 3579, 5, 62, 0, 0, 3575, 3580, 5, 325, 0, 0, 3576, 3577, 5, 83, 0, 0, 3577, 3578, 5, 147, 0, 0, 3578, 3580, 3, 316, 158, 0, 3579, 3575, 1, 0, 0, 0, 3579, 3576, 1, 0, 0, 0, 3580, 3582, 1, 0, 0, 0, 3581, 3574, 1, 0, 0, 0, 3581, 3582, 1, 0, 0, 0, 3582, 3584, 1, 0, 0, 0, 3583, 3585, 5, 302, 0, 0, 3584, 3583, 1, 0, 0, 0, 3584, 3585, 1, 0, 0, 0, 3585, 3595, 1, 0, 0, 0, 3586, 3587, 5, 211, 0, 0, 3587, 3589, 5, 571, 0, 0, 3588, 3590, 3, 528, 264, 0, 3589, 3588, 1, 0, 0, 0, 3589, 3590, 1, 0, 0, 0, 3590, 3591, 1, 0, 0, 0, 3591, 3595, 3, 382, 191, 0, 3592, 3593, 5, 345, 0, 0, 3593, 3595, 3, 652, 326, 0, 3594, 3568, 1, 0, 0, 0, 3594, 3586, 1, 0, 0, 0, 3594, 3592, 1, 0, 0, 0, 3595, 299, 1, 0, 0, 0, 3596, 3597, 5, 46, 0, 0, 3597, 3598, 5, 278, 0, 0, 3598, 3599, 5, 206, 0, 0, 3599, 3600, 3, 316, 158, 0, 3600, 3601, 3, 170, 85, 0, 3601, 301, 1, 0, 0, 0, 3602, 3603, 5, 138, 0, 0, 3603, 3604, 5, 278, 0, 0, 3604, 3605, 5, 206, 0, 0, 3605, 3606, 3, 316, 158, 0, 3606, 3625, 3, 170, 85, 0, 3607, 3608, 5, 133, 0, 0, 3608, 3613, 3, 298, 149, 0, 3609, 3610, 5, 6, 0, 0, 3610, 3612, 3, 298, 149, 0, 3611, 3609, 1, 0, 0, 0, 3612, 3615, 1, 0, 0, 0, 3613, 3611, 1, 0, 0, 0, 3613, 3614, 1, 0, 0, 0, 3614, 3626, 1, 0, 0, 0, 3615, 3613, 1, 0, 0, 0, 3616, 3617, 5, 191, 0, 0, 3617, 3622, 3, 304, 152, 0, 3618, 3619, 5, 6, 0, 0, 3619, 3621, 3, 304, 152, 0, 3620, 3618, 1, 0, 0, 0, 3621, 3624, 1, 0, 0, 0, 3622, 3620, 1, 0, 0, 0, 3622, 3623, 1, 0, 0, 0, 3623, 3626, 1, 0, 0, 0, 3624, 3622, 1, 0, 0, 0, 3625, 3607, 1, 0, 0, 0, 3625, 3616, 1, 0, 0, 0, 3626, 303, 1, 0, 0, 0, 3627, 3628, 7, 43, 0, 0, 3628, 3629, 5, 571, 0, 0, 3629, 3630, 3, 528, 264, 0, 3630, 305, 1, 0, 0, 0, 3631, 3632, 5, 301, 0, 0, 3632, 3633, 5, 281, 0, 0, 3633, 3634, 5, 147, 0, 0, 3634, 3635, 3, 816, 408, 0, 3635, 3636, 5, 94, 0, 0, 3636, 3637, 3, 814, 407, 0, 3637, 307, 1, 0, 0, 0, 3638, 3661, 5, 191, 0, 0, 3639, 3662, 5, 328, 0, 0, 3640, 3662, 5, 226, 0, 0, 3641, 3662, 5, 108, 0, 0, 3642, 3662, 5, 168, 0, 0, 3643, 3662, 5, 342, 0, 0, 3644, 3662, 5, 452, 0, 0, 3645, 3662, 5, 331, 0, 0, 3646, 3647, 5, 131, 0, 0, 3647, 3662, 5, 446, 0, 0, 3648, 3649, 5, 198, 0, 0, 3649, 3662, 5, 357, 0, 0, 3650, 3662, 5, 204, 0, 0, 3651, 3653, 5, 295, 0, 0, 3652, 3651, 1, 0, 0, 0, 3652, 3653, 1, 0, 0, 0, 3653, 3654, 1, 0, 0, 0, 3654, 3662, 5, 247, 0, 0, 3655, 3656, 5, 63, 0, 0, 3656, 3657, 5, 174, 0, 0, 3657, 3662, 5, 381, 0, 0, 3658, 3659, 5, 355, 0, 0, 3659, 3660, 5, 325, 0, 0, 3660, 3662, 7, 41, 0, 0, 3661, 3639, 1, 0, 0, 0, 3661, 3640, 1, 0, 0, 0, 3661, 3641, 1, 0, 0, 0, 3661, 3642, 1, 0, 0, 0, 3661, 3643, 1, 0, 0, 0, 3661, 3644, 1, 0, 0, 0, 3661, 3645, 1, 0, 0, 0, 3661, 3646, 1, 0, 0, 0, 3661, 3648, 1, 0, 0, 0, 3661, 3650, 1, 0, 0, 0, 3661, 3652, 1, 0, 0, 0, 3661, 3655, 1, 0, 0, 0, 3661, 3658, 1, 0, 0, 0, 3662, 3664, 1, 0, 0, 0, 3663, 3665, 3, 422, 211, 0, 3664, 3663, 1, 0, 0, 0, 3664, 3665, 1, 0, 0, 0, 3665, 3666, 1, 0, 0, 0, 3666, 3668, 3, 784, 392, 0, 3667, 3669, 3, 96, 48, 0, 3668, 3667, 1, 0, 0, 0, 3668, 3669, 1, 0, 0, 0, 3669, 3846, 1, 0, 0, 0, 3670, 3672, 5, 191, 0, 0, 3671, 3673, 5, 259, 0, 0, 3672, 3671, 1, 0, 0, 0, 3672, 3673, 1, 0, 0, 0, 3673, 3674, 1, 0, 0, 0, 3674, 3676, 5, 376, 0, 0, 3675, 3677, 3, 422, 211, 0, 3676, 3675, 1, 0, 0, 0, 3676, 3677, 1, 0, 0, 0, 3677, 3678, 1, 0, 0, 0, 3678, 3683, 3, 778, 389, 0, 3679, 3680, 5, 6, 0, 0, 3680, 3682, 3, 778, 389, 0, 3681, 3679, 1, 0, 0, 0, 3682, 3685, 1, 0, 0, 0, 3683, 3681, 1, 0, 0, 0, 3683, 3684, 1, 0, 0, 0, 3684, 3687, 1, 0, 0, 0, 3685, 3683, 1, 0, 0, 0, 3686, 3688, 3, 96, 48, 0, 3687, 3686, 1, 0, 0, 0, 3687, 3688, 1, 0, 0, 0, 3688, 3846, 1, 0, 0, 0, 3689, 3691, 5, 191, 0, 0, 3690, 3692, 5, 63, 0, 0, 3691, 3690, 1, 0, 0, 0, 3691, 3692, 1, 0, 0, 0, 3692, 3693, 1, 0, 0, 0, 3693, 3695, 5, 92, 0, 0, 3694, 3696, 3, 422, 211, 0, 3695, 3694, 1, 0, 0, 0, 3695, 3696, 1, 0, 0, 0, 3696, 3697, 1, 0, 0, 0, 3697, 3699, 3, 762, 381, 0, 3698, 3700, 3, 96, 48, 0, 3699, 3698, 1, 0, 0, 0, 3699, 3700, 1, 0, 0, 0, 3700, 3846, 1, 0, 0, 0, 3701, 3702, 5, 191, 0, 0, 3702, 3704, 5, 323, 0, 0, 3703, 3705, 3, 422, 211, 0, 3704, 3703, 1, 0, 0, 0, 3704, 3705, 1, 0, 0, 0, 3705, 3706, 1, 0, 0, 0, 3706, 3708, 3, 764, 382, 0, 3707, 3709, 3, 96, 48, 0, 3708, 3707, 1, 0, 0, 0, 3708, 3709, 1, 0, 0, 0, 3709, 3846, 1, 0, 0, 0, 3710, 3711, 5, 191, 0, 0, 3711, 3713, 7, 44, 0, 0, 3712, 3714, 3, 422, 211, 0, 3713, 3712, 1, 0, 0, 0, 3713, 3714, 1, 0, 0, 0, 3714, 3715, 1, 0, 0, 0, 3715, 3716, 3, 818, 409, 0, 3716, 3717, 5, 80, 0, 0, 3717, 3719, 3, 316, 158, 0, 3718, 3720, 3, 96, 48, 0, 3719, 3718, 1, 0, 0, 0, 3719, 3720, 1, 0, 0, 0, 3720, 3846, 1, 0, 0, 0, 3721, 3722, 5, 191, 0, 0, 3722, 3724, 7, 32, 0, 0, 3723, 3725, 3, 422, 211, 0, 3724, 3723, 1, 0, 0, 0, 3724, 3725, 1, 0, 0, 0, 3725, 3726, 1, 0, 0, 0, 3726, 3731, 3, 652, 326, 0, 3727, 3728, 5, 6, 0, 0, 3728, 3730, 3, 652, 326, 0, 3729, 3727, 1, 0, 0, 0, 3730, 3733, 1, 0, 0, 0, 3731, 3729, 1, 0, 0, 0, 3731, 3732, 1, 0, 0, 0, 3732, 3735, 1, 0, 0, 0, 3733, 3731, 1, 0, 0, 0, 3734, 3736, 3, 96, 48, 0, 3735, 3734, 1, 0, 0, 0, 3735, 3736, 1, 0, 0, 0, 3736, 3846, 1, 0, 0, 0, 3737, 3738, 5, 191, 0, 0, 3738, 3739, 5, 226, 0, 0, 3739, 3741, 5, 109, 0, 0, 3740, 3742, 3, 422, 211, 0, 3741, 3740, 1, 0, 0, 0, 3741, 3742, 1, 0, 0, 0, 3742, 3743, 1, 0, 0, 0, 3743, 3745, 3, 314, 157, 0, 3744, 3746, 3, 96, 48, 0, 3745, 3744, 1, 0, 0, 0, 3745, 3746, 1, 0, 0, 0, 3746, 3846, 1, 0, 0, 0, 3747, 3748, 5, 191, 0, 0, 3748, 3750, 5, 41, 0, 0, 3749, 3751, 3, 422, 211, 0, 3750, 3749, 1, 0, 0, 0, 3750, 3751, 1, 0, 0, 0, 3751, 3752, 1, 0, 0, 0, 3752, 3753, 5, 2, 0, 0, 3753, 3754, 3, 652, 326, 0, 3754, 3755, 5, 36, 0, 0, 3755, 3756, 3, 652, 326, 0, 3756, 3758, 5, 3, 0, 0, 3757, 3759, 3, 96, 48, 0, 3758, 3757, 1, 0, 0, 0, 3758, 3759, 1, 0, 0, 0, 3759, 3846, 1, 0, 0, 0, 3760, 3761, 5, 191, 0, 0, 3761, 3762, 5, 278, 0, 0, 3762, 3764, 7, 31, 0, 0, 3763, 3765, 3, 422, 211, 0, 3764, 3763, 1, 0, 0, 0, 3764, 3765, 1, 0, 0, 0, 3765, 3766, 1, 0, 0, 0, 3766, 3767, 3, 316, 158, 0, 3767, 3769, 3, 170, 85, 0, 3768, 3770, 3, 96, 48, 0, 3769, 3768, 1, 0, 0, 0, 3769, 3770, 1, 0, 0, 0, 3770, 3846, 1, 0, 0, 0, 3771, 3772, 5, 191, 0, 0, 3772, 3773, 5, 281, 0, 0, 3773, 3774, 5, 147, 0, 0, 3774, 3776, 3, 816, 408, 0, 3775, 3777, 3, 96, 48, 0, 3776, 3775, 1, 0, 0, 0, 3776, 3777, 1, 0, 0, 0, 3777, 3846, 1, 0, 0, 0, 3778, 3779, 5, 191, 0, 0, 3779, 3781, 5, 451, 0, 0, 3780, 3782, 3, 422, 211, 0, 3781, 3780, 1, 0, 0, 0, 3781, 3782, 1, 0, 0, 0, 3782, 3783, 1, 0, 0, 0, 3783, 3785, 3, 818, 409, 0, 3784, 3786, 3, 96, 48, 0, 3785, 3784, 1, 0, 0, 0, 3785, 3786, 1, 0, 0, 0, 3786, 3846, 1, 0, 0, 0, 3787, 3788, 5, 191, 0, 0, 3788, 3790, 5, 351, 0, 0, 3789, 3791, 3, 422, 211, 0, 3790, 3789, 1, 0, 0, 0, 3790, 3791, 1, 0, 0, 0, 3791, 3792, 1, 0, 0, 0, 3792, 3846, 3, 770, 385, 0, 3793, 3794, 5, 191, 0, 0, 3794, 3796, 5, 443, 0, 0, 3795, 3797, 3, 422, 211, 0, 3796, 3795, 1, 0, 0, 0, 3796, 3797, 1, 0, 0, 0, 3797, 3798, 1, 0, 0, 0, 3798, 3799, 5, 62, 0, 0, 3799, 3800, 3, 652, 326, 0, 3800, 3801, 5, 247, 0, 0, 3801, 3803, 3, 818, 409, 0, 3802, 3804, 3, 96, 48, 0, 3803, 3802, 1, 0, 0, 0, 3803, 3804, 1, 0, 0, 0, 3804, 3846, 1, 0, 0, 0, 3805, 3806, 5, 191, 0, 0, 3806, 3808, 7, 45, 0, 0, 3807, 3809, 3, 422, 211, 0, 3808, 3807, 1, 0, 0, 0, 3808, 3809, 1, 0, 0, 0, 3809, 3810, 1, 0, 0, 0, 3810, 3846, 3, 816, 408, 0, 3811, 3812, 5, 191, 0, 0, 3812, 3813, 5, 99, 0, 0, 3813, 3815, 5, 257, 0, 0, 3814, 3816, 3, 422, 211, 0, 3815, 3814, 1, 0, 0, 0, 3815, 3816, 1, 0, 0, 0, 3816, 3817, 1, 0, 0, 0, 3817, 3820, 5, 62, 0, 0, 3818, 3821, 3, 814, 407, 0, 3819, 3821, 5, 99, 0, 0, 3820, 3818, 1, 0, 0, 0, 3820, 3819, 1, 0, 0, 0, 3821, 3822, 1, 0, 0, 0, 3822, 3823, 5, 331, 0, 0, 3823, 3846, 3, 818, 409, 0, 3824, 3825, 5, 191, 0, 0, 3825, 3827, 5, 175, 0, 0, 3826, 3828, 3, 422, 211, 0, 3827, 3826, 1, 0, 0, 0, 3827, 3828, 1, 0, 0, 0, 3828, 3829, 1, 0, 0, 0, 3829, 3843, 3, 788, 394, 0, 3830, 3832, 5, 105, 0, 0, 3831, 3830, 1, 0, 0, 0, 3831, 3832, 1, 0, 0, 0, 3832, 3833, 1, 0, 0, 0, 3833, 3834, 5, 2, 0, 0, 3834, 3839, 5, 209, 0, 0, 3835, 3836, 5, 6, 0, 0, 3836, 3838, 5, 209, 0, 0, 3837, 3835, 1, 0, 0, 0, 3838, 3841, 1, 0, 0, 0, 3839, 3837, 1, 0, 0, 0, 3839, 3840, 1, 0, 0, 0, 3840, 3842, 1, 0, 0, 0, 3841, 3839, 1, 0, 0, 0, 3842, 3844, 5, 3, 0, 0, 3843, 3831, 1, 0, 0, 0, 3843, 3844, 1, 0, 0, 0, 3844, 3846, 1, 0, 0, 0, 3845, 3638, 1, 0, 0, 0, 3845, 3670, 1, 0, 0, 0, 3845, 3689, 1, 0, 0, 0, 3845, 3701, 1, 0, 0, 0, 3845, 3710, 1, 0, 0, 0, 3845, 3721, 1, 0, 0, 0, 3845, 3737, 1, 0, 0, 0, 3845, 3747, 1, 0, 0, 0, 3845, 3760, 1, 0, 0, 0, 3845, 3771, 1, 0, 0, 0, 3845, 3778, 1, 0, 0, 0, 3845, 3787, 1, 0, 0, 0, 3845, 3793, 1, 0, 0, 0, 3845, 3805, 1, 0, 0, 0, 3845, 3811, 1, 0, 0, 0, 3845, 3824, 1, 0, 0, 0, 3846, 309, 1, 0, 0, 0, 3847, 3849, 5, 63, 0, 0, 3848, 3847, 1, 0, 0, 0, 3848, 3849, 1, 0, 0, 0, 3849, 3850, 1, 0, 0, 0, 3850, 3851, 5, 92, 0, 0, 3851, 3864, 3, 774, 387, 0, 3852, 3854, 5, 259, 0, 0, 3853, 3852, 1, 0, 0, 0, 3853, 3854, 1, 0, 0, 0, 3854, 3855, 1, 0, 0, 0, 3855, 3856, 5, 376, 0, 0, 3856, 3864, 3, 778, 389, 0, 3857, 3858, 7, 46, 0, 0, 3858, 3864, 3, 316, 158, 0, 3859, 3860, 5, 355, 0, 0, 3860, 3861, 5, 325, 0, 0, 3861, 3862, 7, 41, 0, 0, 3862, 3864, 3, 316, 158, 0, 3863, 3848, 1, 0, 0, 0, 3863, 3853, 1, 0, 0, 0, 3863, 3857, 1, 0, 0, 0, 3863, 3859, 1, 0, 0, 0, 3864, 311, 1, 0, 0, 0, 3865, 3866, 5, 198, 0, 0, 3866, 3882, 5, 357, 0, 0, 3867, 3868, 5, 131, 0, 0, 3868, 3882, 5, 446, 0, 0, 3869, 3882, 5, 204, 0, 0, 3870, 3882, 5, 452, 0, 0, 3871, 3882, 5, 331, 0, 0, 3872, 3882, 5, 318, 0, 0, 3873, 3882, 5, 451, 0, 0, 3874, 3875, 5, 63, 0, 0, 3875, 3876, 5, 174, 0, 0, 3876, 3882, 5, 381, 0, 0, 3877, 3879, 5, 295, 0, 0, 3878, 3877, 1, 0, 0, 0, 3878, 3879, 1, 0, 0, 0, 3879, 3880, 1, 0, 0, 0, 3880, 3882, 5, 247, 0, 0, 3881, 3865, 1, 0, 0, 0, 3881, 3867, 1, 0, 0, 0, 3881, 3869, 1, 0, 0, 0, 3881, 3870, 1, 0, 0, 0, 3881, 3871, 1, 0, 0, 0, 3881, 3872, 1, 0, 0, 0, 3881, 3873, 1, 0, 0, 0, 3881, 3874, 1, 0, 0, 0, 3881, 3878, 1, 0, 0, 0, 3882, 3883, 1, 0, 0, 0, 3883, 3890, 3, 818, 409, 0, 3884, 3885, 5, 323, 0, 0, 3885, 3890, 3, 790, 395, 0, 3886, 3887, 5, 175, 0, 0, 3887, 3890, 3, 788, 394, 0, 3888, 3890, 3, 176, 88, 0, 3889, 3881, 1, 0, 0, 0, 3889, 3884, 1, 0, 0, 0, 3889, 3886, 1, 0, 0, 0, 3889, 3888, 1, 0, 0, 0, 3890, 313, 1, 0, 0, 0, 3891, 3896, 3, 316, 158, 0, 3892, 3893, 5, 6, 0, 0, 3893, 3895, 3, 316, 158, 0, 3894, 3892, 1, 0, 0, 0, 3895, 3898, 1, 0, 0, 0, 3896, 3894, 1, 0, 0, 0, 3896, 3897, 1, 0, 0, 0, 3897, 315, 1, 0, 0, 0, 3898, 3896, 1, 0, 0, 0, 3899, 3901, 3, 818, 409, 0, 3900, 3902, 3, 318, 159, 0, 3901, 3900, 1, 0, 0, 0, 3901, 3902, 1, 0, 0, 0, 3902, 317, 1, 0, 0, 0, 3903, 3904, 5, 11, 0, 0, 3904, 3906, 3, 824, 412, 0, 3905, 3903, 1, 0, 0, 0, 3906, 3907, 1, 0, 0, 0, 3907, 3905, 1, 0, 0, 0, 3907, 3908, 1, 0, 0, 0, 3908, 319, 1, 0, 0, 0, 3909, 3911, 5, 358, 0, 0, 3910, 3912, 5, 92, 0, 0, 3911, 3910, 1, 0, 0, 0, 3911, 3912, 1, 0, 0, 0, 3912, 3913, 1, 0, 0, 0, 3913, 3918, 3, 322, 161, 0, 3914, 3915, 5, 6, 0, 0, 3915, 3917, 3, 322, 161, 0, 3916, 3914, 1, 0, 0, 0, 3917, 3920, 1, 0, 0, 0, 3918, 3916, 1, 0, 0, 0, 3918, 3919, 1, 0, 0, 0, 3919, 3923, 1, 0, 0, 0, 3920, 3918, 1, 0, 0, 0, 3921, 3922, 7, 47, 0, 0, 3922, 3924, 5, 219, 0, 0, 3923, 3921, 1, 0, 0, 0, 3923, 3924, 1, 0, 0, 0, 3924, 3926, 1, 0, 0, 0, 3925, 3927, 3, 96, 48, 0, 3926, 3925, 1, 0, 0, 0, 3926, 3927, 1, 0, 0, 0, 3927, 321, 1, 0, 0, 0, 3928, 3930, 5, 81, 0, 0, 3929, 3928, 1, 0, 0, 0, 3929, 3930, 1, 0, 0, 0, 3930, 3931, 1, 0, 0, 0, 3931, 3933, 3, 774, 387, 0, 3932, 3934, 5, 9, 0, 0, 3933, 3932, 1, 0, 0, 0, 3933, 3934, 1, 0, 0, 0, 3934, 323, 1, 0, 0, 0, 3935, 3936, 5, 159, 0, 0, 3936, 3995, 5, 80, 0, 0, 3937, 3996, 3, 310, 155, 0, 3938, 3996, 3, 312, 156, 0, 3939, 3940, 5, 44, 0, 0, 3940, 3942, 3, 818, 409, 0, 3941, 3943, 3, 318, 159, 0, 3942, 3941, 1, 0, 0, 0, 3942, 3943, 1, 0, 0, 0, 3943, 3944, 1, 0, 0, 0, 3944, 3945, 5, 11, 0, 0, 3945, 3946, 3, 800, 400, 0, 3946, 3996, 1, 0, 0, 0, 3947, 3948, 7, 32, 0, 0, 3948, 3996, 3, 652, 326, 0, 3949, 3950, 5, 136, 0, 0, 3950, 3996, 3, 394, 197, 0, 3951, 3952, 5, 211, 0, 0, 3952, 3996, 3, 382, 191, 0, 3953, 3954, 5, 278, 0, 0, 3954, 3996, 3, 416, 208, 0, 3955, 3956, 5, 45, 0, 0, 3956, 3957, 3, 818, 409, 0, 3957, 3963, 5, 80, 0, 0, 3958, 3964, 3, 774, 387, 0, 3959, 3961, 5, 189, 0, 0, 3960, 3959, 1, 0, 0, 0, 3960, 3961, 1, 0, 0, 0, 3961, 3962, 1, 0, 0, 0, 3962, 3964, 3, 316, 158, 0, 3963, 3958, 1, 0, 0, 0, 3963, 3960, 1, 0, 0, 0, 3964, 3996, 1, 0, 0, 0, 3965, 3966, 7, 44, 0, 0, 3966, 3967, 3, 818, 409, 0, 3967, 3968, 5, 80, 0, 0, 3968, 3969, 3, 316, 158, 0, 3969, 3996, 1, 0, 0, 0, 3970, 3971, 5, 296, 0, 0, 3971, 3996, 3, 378, 189, 0, 3972, 3973, 5, 442, 0, 0, 3973, 3996, 3, 374, 187, 0, 3974, 3975, 5, 443, 0, 0, 3975, 3976, 5, 62, 0, 0, 3976, 3977, 3, 652, 326, 0, 3977, 3978, 5, 247, 0, 0, 3978, 3979, 3, 818, 409, 0, 3979, 3996, 1, 0, 0, 0, 3980, 3981, 5, 278, 0, 0, 3981, 3982, 7, 31, 0, 0, 3982, 3983, 3, 316, 158, 0, 3983, 3984, 3, 170, 85, 0, 3984, 3996, 1, 0, 0, 0, 3985, 3986, 5, 248, 0, 0, 3986, 3987, 5, 274, 0, 0, 3987, 3996, 3, 202, 101, 0, 3988, 3989, 5, 41, 0, 0, 3989, 3990, 5, 2, 0, 0, 3990, 3991, 3, 652, 326, 0, 3991, 3992, 5, 36, 0, 0, 3992, 3993, 3, 652, 326, 0, 3993, 3994, 5, 3, 0, 0, 3994, 3996, 1, 0, 0, 0, 3995, 3937, 1, 0, 0, 0, 3995, 3938, 1, 0, 0, 0, 3995, 3939, 1, 0, 0, 0, 3995, 3947, 1, 0, 0, 0, 3995, 3949, 1, 0, 0, 0, 3995, 3951, 1, 0, 0, 0, 3995, 3953, 1, 0, 0, 0, 3995, 3955, 1, 0, 0, 0, 3995, 3965, 1, 0, 0, 0, 3995, 3970, 1, 0, 0, 0, 3995, 3972, 1, 0, 0, 0, 3995, 3974, 1, 0, 0, 0, 3995, 3980, 1, 0, 0, 0, 3995, 3985, 1, 0, 0, 0, 3995, 3988, 1, 0, 0, 0, 3996, 3997, 1, 0, 0, 0, 3997, 4000, 5, 116, 0, 0, 3998, 4001, 3, 808, 404, 0, 3999, 4001, 5, 78, 0, 0, 4000, 3998, 1, 0, 0, 0, 4000, 3999, 1, 0, 0, 0, 4001, 325, 1, 0, 0, 0, 4002, 4003, 5, 327, 0, 0, 4003, 4006, 5, 246, 0, 0, 4004, 4005, 5, 62, 0, 0, 4005, 4007, 3, 58, 29, 0, 4006, 4004, 1, 0, 0, 0, 4006, 4007, 1, 0, 0, 0, 4007, 4008, 1, 0, 0, 0, 4008, 4026, 5, 80, 0, 0, 4009, 4010, 7, 32, 0, 0, 4010, 4027, 3, 652, 326, 0, 4011, 4012, 5, 136, 0, 0, 4012, 4027, 3, 394, 197, 0, 4013, 4014, 5, 44, 0, 0, 4014, 4027, 3, 800, 400, 0, 4015, 4016, 5, 211, 0, 0, 4016, 4027, 3, 382, 191, 0, 4017, 4018, 5, 248, 0, 0, 4018, 4019, 5, 274, 0, 0, 4019, 4027, 3, 202, 101, 0, 4020, 4021, 5, 296, 0, 0, 4021, 4027, 3, 378, 189, 0, 4022, 4023, 5, 442, 0, 0, 4023, 4027, 3, 374, 187, 0, 4024, 4027, 3, 310, 155, 0, 4025, 4027, 3, 312, 156, 0, 4026, 4009, 1, 0, 0, 0, 4026, 4011, 1, 0, 0, 0, 4026, 4013, 1, 0, 0, 0, 4026, 4015, 1, 0, 0, 0, 4026, 4017, 1, 0, 0, 0, 4026, 4020, 1, 0, 0, 0, 4026, 4022, 1, 0, 0, 0, 4026, 4024, 1, 0, 0, 0, 4026, 4025, 1, 0, 0, 0, 4027, 4028, 1, 0, 0, 0, 4028, 4031, 5, 116, 0, 0, 4029, 4032, 3, 808, 404, 0, 4030, 4032, 5, 78, 0, 0, 4031, 4029, 1, 0, 0, 0, 4031, 4030, 1, 0, 0, 0, 4032, 327, 1, 0, 0, 0, 4033, 4034, 7, 48, 0, 0, 4034, 4035, 3, 330, 165, 0, 4035, 329, 1, 0, 0, 0, 4036, 4038, 7, 49, 0, 0, 4037, 4036, 1, 0, 0, 0, 4037, 4038, 1, 0, 0, 0, 4038, 4040, 1, 0, 0, 0, 4039, 4041, 3, 332, 166, 0, 4040, 4039, 1, 0, 0, 0, 4040, 4041, 1, 0, 0, 0, 4041, 4042, 1, 0, 0, 0, 4042, 4080, 3, 818, 409, 0, 4043, 4045, 7, 50, 0, 0, 4044, 4043, 1, 0, 0, 0, 4044, 4045, 1, 0, 0, 0, 4045, 4046, 1, 0, 0, 0, 4046, 4048, 3, 812, 406, 0, 4047, 4049, 3, 332, 166, 0, 4048, 4047, 1, 0, 0, 0, 4048, 4049, 1, 0, 0, 0, 4049, 4050, 1, 0, 0, 0, 4050, 4051, 3, 818, 409, 0, 4051, 4080, 1, 0, 0, 0, 4052, 4054, 5, 210, 0, 0, 4053, 4055, 3, 812, 406, 0, 4054, 4053, 1, 0, 0, 0, 4054, 4055, 1, 0, 0, 0, 4055, 4057, 1, 0, 0, 0, 4056, 4058, 3, 332, 166, 0, 4057, 4056, 1, 0, 0, 0, 4057, 4058, 1, 0, 0, 0, 4058, 4059, 1, 0, 0, 0, 4059, 4080, 3, 818, 409, 0, 4060, 4062, 5, 210, 0, 0, 4061, 4060, 1, 0, 0, 0, 4061, 4062, 1, 0, 0, 0, 4062, 4063, 1, 0, 0, 0, 4063, 4065, 5, 30, 0, 0, 4064, 4066, 3, 332, 166, 0, 4065, 4064, 1, 0, 0, 0, 4065, 4066, 1, 0, 0, 0, 4066, 4067, 1, 0, 0, 0, 4067, 4080, 3, 818, 409, 0, 4068, 4073, 5, 144, 0, 0, 4069, 4071, 5, 30, 0, 0, 4070, 4069, 1, 0, 0, 0, 4070, 4071, 1, 0, 0, 0, 4071, 4074, 1, 0, 0, 0, 4072, 4074, 3, 812, 406, 0, 4073, 4070, 1, 0, 0, 0, 4073, 4072, 1, 0, 0, 0, 4074, 4076, 1, 0, 0, 0, 4075, 4077, 3, 332, 166, 0, 4076, 4075, 1, 0, 0, 0, 4076, 4077, 1, 0, 0, 0, 4077, 4078, 1, 0, 0, 0, 4078, 4080, 3, 818, 409, 0, 4079, 4037, 1, 0, 0, 0, 4079, 4044, 1, 0, 0, 0, 4079, 4052, 1, 0, 0, 0, 4079, 4061, 1, 0, 0, 0, 4079, 4068, 1, 0, 0, 0, 4080, 331, 1, 0, 0, 0, 4081, 4082, 7, 51, 0, 0, 4082, 333, 1, 0, 0, 0, 4083, 4084, 5, 65, 0, 0, 4084, 4085, 3, 338, 169, 0, 4085, 4086, 5, 80, 0, 0, 4086, 4087, 3, 344, 172, 0, 4087, 4088, 5, 94, 0, 0, 4088, 4092, 3, 346, 173, 0, 4089, 4090, 5, 105, 0, 0, 4090, 4091, 5, 65, 0, 0, 4091, 4093, 5, 279, 0, 0, 4092, 4089, 1, 0, 0, 0, 4092, 4093, 1, 0, 0, 0, 4093, 335, 1, 0, 0, 0, 4094, 4098, 5, 317, 0, 0, 4095, 4096, 5, 65, 0, 0, 4096, 4097, 5, 279, 0, 0, 4097, 4099, 5, 62, 0, 0, 4098, 4095, 1, 0, 0, 0, 4098, 4099, 1, 0, 0, 0, 4099, 4100, 1, 0, 0, 0, 4100, 4101, 3, 338, 169, 0, 4101, 4102, 5, 80, 0, 0, 4102, 4103, 3, 344, 172, 0, 4103, 4104, 5, 64, 0, 0, 4104, 4106, 3, 346, 173, 0, 4105, 4107, 3, 96, 48, 0, 4106, 4105, 1, 0, 0, 0, 4106, 4107, 1, 0, 0, 0, 4107, 337, 1, 0, 0, 0, 4108, 4113, 3, 342, 171, 0, 4109, 4110, 5, 6, 0, 0, 4110, 4112, 3, 342, 171, 0, 4111, 4109, 1, 0, 0, 0, 4112, 4115, 1, 0, 0, 0, 4113, 4111, 1, 0, 0, 0, 4113, 4114, 1, 0, 0, 0, 4114, 4132, 1, 0, 0, 0, 4115, 4113, 1, 0, 0, 0, 4116, 4118, 5, 30, 0, 0, 4117, 4119, 5, 294, 0, 0, 4118, 4117, 1, 0, 0, 0, 4118, 4119, 1, 0, 0, 0, 4119, 4121, 1, 0, 0, 0, 4120, 4122, 3, 144, 72, 0, 4121, 4120, 1, 0, 0, 0, 4121, 4122, 1, 0, 0, 0, 4122, 4132, 1, 0, 0, 0, 4123, 4128, 3, 340, 170, 0, 4124, 4125, 5, 6, 0, 0, 4125, 4127, 3, 340, 170, 0, 4126, 4124, 1, 0, 0, 0, 4127, 4130, 1, 0, 0, 0, 4128, 4126, 1, 0, 0, 0, 4128, 4129, 1, 0, 0, 0, 4129, 4132, 1, 0, 0, 0, 4130, 4128, 1, 0, 0, 0, 4131, 4108, 1, 0, 0, 0, 4131, 4116, 1, 0, 0, 0, 4131, 4123, 1, 0, 0, 0, 4132, 339, 1, 0, 0, 0, 4133, 4134, 7, 52, 0, 0, 4134, 341, 1, 0, 0, 0, 4135, 4140, 5, 88, 0, 0, 4136, 4140, 5, 86, 0, 0, 4137, 4140, 5, 46, 0, 0, 4138, 4140, 3, 818, 409, 0, 4139, 4135, 1, 0, 0, 0, 4139, 4136, 1, 0, 0, 0, 4139, 4137, 1, 0, 0, 0, 4139, 4138, 1, 0, 0, 0, 4140, 4142, 1, 0, 0, 0, 4141, 4143, 3, 144, 72, 0, 4142, 4141, 1, 0, 0, 0, 4142, 4143, 1, 0, 0, 0, 4143, 343, 1, 0, 0, 0, 4144, 4145, 5, 92, 0, 0, 4145, 4190, 3, 762, 381, 0, 4146, 4148, 5, 328, 0, 0, 4147, 4146, 1, 0, 0, 0, 4147, 4148, 1, 0, 0, 0, 4148, 4149, 1, 0, 0, 0, 4149, 4190, 3, 760, 380, 0, 4150, 4154, 5, 63, 0, 0, 4151, 4152, 5, 174, 0, 0, 4152, 4155, 5, 381, 0, 0, 4153, 4155, 5, 331, 0, 0, 4154, 4151, 1, 0, 0, 0, 4154, 4153, 1, 0, 0, 0, 4155, 4158, 1, 0, 0, 0, 4156, 4158, 5, 247, 0, 0, 4157, 4150, 1, 0, 0, 0, 4157, 4156, 1, 0, 0, 0, 4158, 4159, 1, 0, 0, 0, 4159, 4190, 3, 784, 392, 0, 4160, 4161, 5, 211, 0, 0, 4161, 4190, 3, 380, 190, 0, 4162, 4163, 5, 296, 0, 0, 4163, 4190, 3, 376, 188, 0, 4164, 4165, 5, 442, 0, 0, 4165, 4190, 3, 372, 186, 0, 4166, 4167, 5, 175, 0, 0, 4167, 4190, 3, 766, 383, 0, 4168, 4169, 7, 32, 0, 0, 4169, 4190, 3, 314, 157, 0, 4170, 4171, 5, 248, 0, 0, 4171, 4172, 5, 274, 0, 0, 4172, 4177, 3, 202, 101, 0, 4173, 4174, 5, 6, 0, 0, 4174, 4176, 3, 202, 101, 0, 4175, 4173, 1, 0, 0, 0, 4176, 4179, 1, 0, 0, 0, 4177, 4175, 1, 0, 0, 0, 4177, 4178, 1, 0, 0, 0, 4178, 4190, 1, 0, 0, 0, 4179, 4177, 1, 0, 0, 0, 4180, 4181, 5, 323, 0, 0, 4181, 4190, 3, 764, 382, 0, 4182, 4183, 5, 351, 0, 0, 4183, 4190, 3, 782, 391, 0, 4184, 4185, 5, 30, 0, 0, 4185, 4186, 7, 53, 0, 0, 4186, 4187, 5, 68, 0, 0, 4187, 4188, 5, 323, 0, 0, 4188, 4190, 3, 764, 382, 0, 4189, 4144, 1, 0, 0, 0, 4189, 4147, 1, 0, 0, 0, 4189, 4157, 1, 0, 0, 0, 4189, 4160, 1, 0, 0, 0, 4189, 4162, 1, 0, 0, 0, 4189, 4164, 1, 0, 0, 0, 4189, 4166, 1, 0, 0, 0, 4189, 4168, 1, 0, 0, 0, 4189, 4170, 1, 0, 0, 0, 4189, 4180, 1, 0, 0, 0, 4189, 4182, 1, 0, 0, 0, 4189, 4184, 1, 0, 0, 0, 4190, 345, 1, 0, 0, 0, 4191, 4193, 5, 66, 0, 0, 4192, 4191, 1, 0, 0, 0, 4192, 4193, 1, 0, 0, 0, 4193, 4194, 1, 0, 0, 0, 4194, 4195, 3, 814, 407, 0, 4195, 4203, 1, 0, 0, 0, 4196, 4198, 5, 6, 0, 0, 4197, 4199, 5, 66, 0, 0, 4198, 4197, 1, 0, 0, 0, 4198, 4199, 1, 0, 0, 0, 4199, 4200, 1, 0, 0, 0, 4200, 4202, 3, 814, 407, 0, 4201, 4196, 1, 0, 0, 0, 4202, 4205, 1, 0, 0, 0, 4203, 4201, 1, 0, 0, 0, 4203, 4204, 1, 0, 0, 0, 4204, 347, 1, 0, 0, 0, 4205, 4203, 1, 0, 0, 0, 4206, 4207, 5, 65, 0, 0, 4207, 4212, 3, 342, 171, 0, 4208, 4209, 5, 6, 0, 0, 4209, 4211, 3, 342, 171, 0, 4210, 4208, 1, 0, 0, 0, 4211, 4214, 1, 0, 0, 0, 4212, 4210, 1, 0, 0, 0, 4212, 4213, 1, 0, 0, 0, 4213, 4215, 1, 0, 0, 0, 4214, 4212, 1, 0, 0, 0, 4215, 4216, 5, 94, 0, 0, 4216, 4220, 3, 816, 408, 0, 4217, 4218, 5, 105, 0, 0, 4218, 4219, 5, 134, 0, 0, 4219, 4221, 5, 279, 0, 0, 4220, 4217, 1, 0, 0, 0, 4220, 4221, 1, 0, 0, 0, 4221, 4225, 1, 0, 0, 0, 4222, 4223, 5, 214, 0, 0, 4223, 4224, 5, 147, 0, 0, 4224, 4226, 3, 814, 407, 0, 4225, 4222, 1, 0, 0, 0, 4225, 4226, 1, 0, 0, 0, 4226, 349, 1, 0, 0, 0, 4227, 4231, 5, 317, 0, 0, 4228, 4229, 5, 134, 0, 0, 4229, 4230, 5, 279, 0, 0, 4230, 4232, 5, 62, 0, 0, 4231, 4228, 1, 0, 0, 0, 4231, 4232, 1, 0, 0, 0, 4232, 4233, 1, 0, 0, 0, 4233, 4238, 3, 342, 171, 0, 4234, 4235, 5, 6, 0, 0, 4235, 4237, 3, 342, 171, 0, 4236, 4234, 1, 0, 0, 0, 4237, 4240, 1, 0, 0, 0, 4238, 4236, 1, 0, 0, 0, 4238, 4239, 1, 0, 0, 0, 4239, 4241, 1, 0, 0, 0, 4240, 4238, 1, 0, 0, 0, 4241, 4242, 5, 64, 0, 0, 4242, 4246, 3, 816, 408, 0, 4243, 4244, 5, 214, 0, 0, 4244, 4245, 5, 147, 0, 0, 4245, 4247, 3, 814, 407, 0, 4246, 4243, 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, 4249, 1, 0, 0, 0, 4248, 4250, 3, 96, 48, 0, 4249, 4248, 1, 0, 0, 0, 4249, 4250, 1, 0, 0, 0, 4250, 351, 1, 0, 0, 0, 4251, 4252, 5, 138, 0, 0, 4252, 4253, 5, 53, 0, 0, 4253, 4262, 5, 294, 0, 0, 4254, 4255, 5, 68, 0, 0, 4255, 4256, 5, 323, 0, 0, 4256, 4261, 3, 764, 382, 0, 4257, 4258, 5, 62, 0, 0, 4258, 4259, 7, 2, 0, 0, 4259, 4261, 3, 816, 408, 0, 4260, 4254, 1, 0, 0, 0, 4260, 4257, 1, 0, 0, 0, 4261, 4264, 1, 0, 0, 0, 4262, 4260, 1, 0, 0, 0, 4262, 4263, 1, 0, 0, 0, 4263, 4265, 1, 0, 0, 0, 4264, 4262, 1, 0, 0, 0, 4265, 4266, 3, 354, 177, 0, 4266, 353, 1, 0, 0, 0, 4267, 4268, 5, 65, 0, 0, 4268, 4269, 3, 338, 169, 0, 4269, 4270, 5, 80, 0, 0, 4270, 4271, 3, 356, 178, 0, 4271, 4272, 5, 94, 0, 0, 4272, 4276, 3, 346, 173, 0, 4273, 4274, 5, 105, 0, 0, 4274, 4275, 5, 65, 0, 0, 4275, 4277, 5, 279, 0, 0, 4276, 4273, 1, 0, 0, 0, 4276, 4277, 1, 0, 0, 0, 4277, 4293, 1, 0, 0, 0, 4278, 4282, 5, 317, 0, 0, 4279, 4280, 5, 65, 0, 0, 4280, 4281, 5, 279, 0, 0, 4281, 4283, 5, 62, 0, 0, 4282, 4279, 1, 0, 0, 0, 4282, 4283, 1, 0, 0, 0, 4283, 4284, 1, 0, 0, 0, 4284, 4285, 3, 338, 169, 0, 4285, 4286, 5, 80, 0, 0, 4286, 4287, 3, 356, 178, 0, 4287, 4288, 5, 64, 0, 0, 4288, 4290, 3, 346, 173, 0, 4289, 4291, 3, 96, 48, 0, 4290, 4289, 1, 0, 0, 0, 4290, 4291, 1, 0, 0, 0, 4291, 4293, 1, 0, 0, 0, 4292, 4267, 1, 0, 0, 0, 4292, 4278, 1, 0, 0, 0, 4293, 355, 1, 0, 0, 0, 4294, 4295, 7, 54, 0, 0, 4295, 357, 1, 0, 0, 0, 4296, 4298, 5, 46, 0, 0, 4297, 4299, 5, 98, 0, 0, 4298, 4297, 1, 0, 0, 0, 4298, 4299, 1, 0, 0, 0, 4299, 4300, 1, 0, 0, 0, 4300, 4302, 5, 226, 0, 0, 4301, 4303, 5, 109, 0, 0, 4302, 4301, 1, 0, 0, 0, 4302, 4303, 1, 0, 0, 0, 4303, 4305, 1, 0, 0, 0, 4304, 4306, 3, 294, 147, 0, 4305, 4304, 1, 0, 0, 0, 4305, 4306, 1, 0, 0, 0, 4306, 4308, 1, 0, 0, 0, 4307, 4309, 3, 818, 409, 0, 4308, 4307, 1, 0, 0, 0, 4308, 4309, 1, 0, 0, 0, 4309, 4310, 1, 0, 0, 0, 4310, 4311, 5, 80, 0, 0, 4311, 4313, 3, 624, 312, 0, 4312, 4314, 3, 170, 85, 0, 4313, 4312, 1, 0, 0, 0, 4313, 4314, 1, 0, 0, 0, 4314, 4315, 1, 0, 0, 0, 4315, 4318, 3, 360, 180, 0, 4316, 4317, 5, 441, 0, 0, 4317, 4319, 3, 360, 180, 0, 4318, 4316, 1, 0, 0, 0, 4318, 4319, 1, 0, 0, 0, 4319, 4325, 1, 0, 0, 0, 4320, 4322, 5, 273, 0, 0, 4321, 4323, 5, 77, 0, 0, 4322, 4321, 1, 0, 0, 0, 4322, 4323, 1, 0, 0, 0, 4323, 4324, 1, 0, 0, 0, 4324, 4326, 5, 56, 0, 0, 4325, 4320, 1, 0, 0, 0, 4325, 4326, 1, 0, 0, 0, 4326, 4328, 1, 0, 0, 0, 4327, 4329, 3, 102, 51, 0, 4328, 4327, 1, 0, 0, 0, 4328, 4329, 1, 0, 0, 0, 4329, 4331, 1, 0, 0, 0, 4330, 4332, 3, 176, 88, 0, 4331, 4330, 1, 0, 0, 0, 4331, 4332, 1, 0, 0, 0, 4332, 4334, 1, 0, 0, 0, 4333, 4335, 3, 638, 319, 0, 4334, 4333, 1, 0, 0, 0, 4334, 4335, 1, 0, 0, 0, 4335, 359, 1, 0, 0, 0, 4336, 4337, 5, 2, 0, 0, 4337, 4342, 3, 362, 181, 0, 4338, 4339, 5, 6, 0, 0, 4339, 4341, 3, 362, 181, 0, 4340, 4338, 1, 0, 0, 0, 4341, 4344, 1, 0, 0, 0, 4342, 4340, 1, 0, 0, 0, 4342, 4343, 1, 0, 0, 0, 4343, 4345, 1, 0, 0, 0, 4344, 4342, 1, 0, 0, 0, 4345, 4346, 5, 3, 0, 0, 4346, 361, 1, 0, 0, 0, 4347, 4354, 3, 800, 400, 0, 4348, 4354, 3, 688, 344, 0, 4349, 4350, 5, 2, 0, 0, 4350, 4351, 3, 674, 337, 0, 4351, 4352, 5, 3, 0, 0, 4352, 4354, 1, 0, 0, 0, 4353, 4347, 1, 0, 0, 0, 4353, 4348, 1, 0, 0, 0, 4353, 4349, 1, 0, 0, 0, 4354, 4356, 1, 0, 0, 0, 4355, 4357, 3, 98, 49, 0, 4356, 4355, 1, 0, 0, 0, 4356, 4357, 1, 0, 0, 0, 4357, 4364, 1, 0, 0, 0, 4358, 4360, 3, 316, 158, 0, 4359, 4358, 1, 0, 0, 0, 4359, 4360, 1, 0, 0, 0, 4360, 4365, 1, 0, 0, 0, 4361, 4362, 3, 316, 158, 0, 4362, 4363, 3, 100, 50, 0, 4363, 4365, 1, 0, 0, 0, 4364, 4359, 1, 0, 0, 0, 4364, 4361, 1, 0, 0, 0, 4365, 4367, 1, 0, 0, 0, 4366, 4368, 7, 55, 0, 0, 4367, 4366, 1, 0, 0, 0, 4367, 4368, 1, 0, 0, 0, 4368, 4371, 1, 0, 0, 0, 4369, 4370, 5, 273, 0, 0, 4370, 4372, 7, 56, 0, 0, 4371, 4369, 1, 0, 0, 0, 4371, 4372, 1, 0, 0, 0, 4372, 363, 1, 0, 0, 0, 4373, 4375, 5, 46, 0, 0, 4374, 4376, 3, 366, 183, 0, 4375, 4374, 1, 0, 0, 0, 4375, 4376, 1, 0, 0, 0, 4376, 4381, 1, 0, 0, 0, 4377, 4378, 5, 211, 0, 0, 4378, 4382, 3, 804, 402, 0, 4379, 4380, 5, 296, 0, 0, 4380, 4382, 3, 798, 399, 0, 4381, 4377, 1, 0, 0, 0, 4381, 4379, 1, 0, 0, 0, 4382, 4383, 1, 0, 0, 0, 4383, 4392, 5, 2, 0, 0, 4384, 4389, 3, 390, 195, 0, 4385, 4386, 5, 6, 0, 0, 4386, 4388, 3, 390, 195, 0, 4387, 4385, 1, 0, 0, 0, 4388, 4391, 1, 0, 0, 0, 4389, 4387, 1, 0, 0, 0, 4389, 4390, 1, 0, 0, 0, 4390, 4393, 1, 0, 0, 0, 4391, 4389, 1, 0, 0, 0, 4392, 4384, 1, 0, 0, 0, 4392, 4393, 1, 0, 0, 0, 4393, 4394, 1, 0, 0, 0, 4394, 4395, 5, 3, 0, 0, 4395, 4412, 1, 0, 0, 0, 4396, 4410, 5, 316, 0, 0, 4397, 4411, 3, 388, 194, 0, 4398, 4399, 5, 92, 0, 0, 4399, 4400, 5, 2, 0, 0, 4400, 4405, 3, 402, 201, 0, 4401, 4402, 5, 6, 0, 0, 4402, 4404, 3, 402, 201, 0, 4403, 4401, 1, 0, 0, 0, 4404, 4407, 1, 0, 0, 0, 4405, 4403, 1, 0, 0, 0, 4405, 4406, 1, 0, 0, 0, 4406, 4408, 1, 0, 0, 0, 4407, 4405, 1, 0, 0, 0, 4408, 4409, 5, 3, 0, 0, 4409, 4411, 1, 0, 0, 0, 4410, 4397, 1, 0, 0, 0, 4410, 4398, 1, 0, 0, 0, 4411, 4413, 1, 0, 0, 0, 4412, 4396, 1, 0, 0, 0, 4412, 4413, 1, 0, 0, 0, 4413, 4415, 1, 0, 0, 0, 4414, 4416, 3, 398, 199, 0, 4415, 4414, 1, 0, 0, 0, 4416, 4417, 1, 0, 0, 0, 4417, 4415, 1, 0, 0, 0, 4417, 4418, 1, 0, 0, 0, 4418, 4424, 1, 0, 0, 0, 4419, 4420, 5, 105, 0, 0, 4420, 4421, 5, 2, 0, 0, 4421, 4422, 3, 784, 392, 0, 4422, 4423, 5, 3, 0, 0, 4423, 4425, 1, 0, 0, 0, 4424, 4419, 1, 0, 0, 0, 4424, 4425, 1, 0, 0, 0, 4425, 365, 1, 0, 0, 0, 4426, 4427, 5, 82, 0, 0, 4427, 4428, 5, 311, 0, 0, 4428, 367, 1, 0, 0, 0, 4429, 4431, 5, 2, 0, 0, 4430, 4432, 3, 370, 185, 0, 4431, 4430, 1, 0, 0, 0, 4431, 4432, 1, 0, 0, 0, 4432, 4433, 1, 0, 0, 0, 4433, 4434, 5, 3, 0, 0, 4434, 369, 1, 0, 0, 0, 4435, 4440, 3, 384, 192, 0, 4436, 4437, 5, 6, 0, 0, 4437, 4439, 3, 384, 192, 0, 4438, 4436, 1, 0, 0, 0, 4439, 4442, 1, 0, 0, 0, 4440, 4438, 1, 0, 0, 0, 4440, 4441, 1, 0, 0, 0, 4441, 371, 1, 0, 0, 0, 4442, 4440, 1, 0, 0, 0, 4443, 4448, 3, 374, 187, 0, 4444, 4445, 5, 6, 0, 0, 4445, 4447, 3, 374, 187, 0, 4446, 4444, 1, 0, 0, 0, 4447, 4450, 1, 0, 0, 0, 4448, 4446, 1, 0, 0, 0, 4448, 4449, 1, 0, 0, 0, 4449, 373, 1, 0, 0, 0, 4450, 4448, 1, 0, 0, 0, 4451, 4452, 3, 794, 397, 0, 4452, 4453, 3, 368, 184, 0, 4453, 4457, 1, 0, 0, 0, 4454, 4457, 3, 832, 416, 0, 4455, 4457, 3, 780, 390, 0, 4456, 4451, 1, 0, 0, 0, 4456, 4454, 1, 0, 0, 0, 4456, 4455, 1, 0, 0, 0, 4457, 375, 1, 0, 0, 0, 4458, 4463, 3, 378, 189, 0, 4459, 4460, 5, 6, 0, 0, 4460, 4462, 3, 378, 189, 0, 4461, 4459, 1, 0, 0, 0, 4462, 4465, 1, 0, 0, 0, 4463, 4461, 1, 0, 0, 0, 4463, 4464, 1, 0, 0, 0, 4464, 377, 1, 0, 0, 0, 4465, 4463, 1, 0, 0, 0, 4466, 4467, 3, 796, 398, 0, 4467, 4468, 3, 368, 184, 0, 4468, 4472, 1, 0, 0, 0, 4469, 4472, 3, 832, 416, 0, 4470, 4472, 3, 780, 390, 0, 4471, 4466, 1, 0, 0, 0, 4471, 4469, 1, 0, 0, 0, 4471, 4470, 1, 0, 0, 0, 4472, 379, 1, 0, 0, 0, 4473, 4478, 3, 382, 191, 0, 4474, 4475, 5, 6, 0, 0, 4475, 4477, 3, 382, 191, 0, 4476, 4474, 1, 0, 0, 0, 4477, 4480, 1, 0, 0, 0, 4478, 4476, 1, 0, 0, 0, 4478, 4479, 1, 0, 0, 0, 4479, 381, 1, 0, 0, 0, 4480, 4478, 1, 0, 0, 0, 4481, 4482, 3, 806, 403, 0, 4482, 4483, 3, 368, 184, 0, 4483, 4487, 1, 0, 0, 0, 4484, 4487, 3, 832, 416, 0, 4485, 4487, 3, 780, 390, 0, 4486, 4481, 1, 0, 0, 0, 4486, 4484, 1, 0, 0, 0, 4486, 4485, 1, 0, 0, 0, 4487, 383, 1, 0, 0, 0, 4488, 4490, 3, 386, 193, 0, 4489, 4491, 3, 820, 410, 0, 4490, 4489, 1, 0, 0, 0, 4490, 4491, 1, 0, 0, 0, 4491, 4497, 1, 0, 0, 0, 4492, 4494, 3, 820, 410, 0, 4493, 4495, 3, 386, 193, 0, 4494, 4493, 1, 0, 0, 0, 4494, 4495, 1, 0, 0, 0, 4495, 4497, 1, 0, 0, 0, 4496, 4488, 1, 0, 0, 0, 4496, 4492, 1, 0, 0, 0, 4496, 4497, 1, 0, 0, 0, 4497, 4498, 1, 0, 0, 0, 4498, 4499, 3, 388, 194, 0, 4499, 385, 1, 0, 0, 0, 4500, 4502, 5, 68, 0, 0, 4501, 4503, 5, 453, 0, 0, 4502, 4501, 1, 0, 0, 0, 4502, 4503, 1, 0, 0, 0, 4503, 4508, 1, 0, 0, 0, 4504, 4508, 5, 453, 0, 0, 4505, 4508, 5, 400, 0, 0, 4506, 4508, 5, 101, 0, 0, 4507, 4500, 1, 0, 0, 0, 4507, 4504, 1, 0, 0, 0, 4507, 4505, 1, 0, 0, 0, 4507, 4506, 1, 0, 0, 0, 4508, 387, 1, 0, 0, 0, 4509, 4519, 3, 652, 326, 0, 4510, 4512, 5, 415, 0, 0, 4511, 4510, 1, 0, 0, 0, 4511, 4512, 1, 0, 0, 0, 4512, 4513, 1, 0, 0, 0, 4513, 4514, 3, 820, 410, 0, 4514, 4515, 3, 318, 159, 0, 4515, 4516, 5, 27, 0, 0, 4516, 4517, 5, 360, 0, 0, 4517, 4519, 1, 0, 0, 0, 4518, 4509, 1, 0, 0, 0, 4518, 4511, 1, 0, 0, 0, 4519, 389, 1, 0, 0, 0, 4520, 4523, 3, 384, 192, 0, 4521, 4522, 7, 57, 0, 0, 4522, 4524, 3, 674, 337, 0, 4523, 4521, 1, 0, 0, 0, 4523, 4524, 1, 0, 0, 0, 4524, 391, 1, 0, 0, 0, 4525, 4535, 5, 2, 0, 0, 4526, 4536, 5, 9, 0, 0, 4527, 4529, 3, 370, 185, 0, 4528, 4527, 1, 0, 0, 0, 4528, 4529, 1, 0, 0, 0, 4529, 4533, 1, 0, 0, 0, 4530, 4531, 5, 83, 0, 0, 4531, 4532, 5, 147, 0, 0, 4532, 4534, 3, 370, 185, 0, 4533, 4530, 1, 0, 0, 0, 4533, 4534, 1, 0, 0, 0, 4534, 4536, 1, 0, 0, 0, 4535, 4526, 1, 0, 0, 0, 4535, 4528, 1, 0, 0, 0, 4536, 4537, 1, 0, 0, 0, 4537, 4538, 5, 3, 0, 0, 4538, 393, 1, 0, 0, 0, 4539, 4540, 3, 806, 403, 0, 4540, 4541, 3, 392, 196, 0, 4541, 395, 1, 0, 0, 0, 4542, 4543, 5, 316, 0, 0, 4543, 4546, 5, 78, 0, 0, 4544, 4546, 5, 149, 0, 0, 4545, 4542, 1, 0, 0, 0, 4545, 4544, 1, 0, 0, 0, 4546, 4547, 1, 0, 0, 0, 4547, 4548, 5, 80, 0, 0, 4548, 4549, 5, 78, 0, 0, 4549, 4572, 5, 458, 0, 0, 4550, 4572, 5, 346, 0, 0, 4551, 4572, 5, 222, 0, 0, 4552, 4572, 5, 338, 0, 0, 4553, 4572, 5, 377, 0, 0, 4554, 4556, 5, 205, 0, 0, 4555, 4554, 1, 0, 0, 0, 4555, 4556, 1, 0, 0, 0, 4556, 4557, 1, 0, 0, 0, 4557, 4558, 5, 327, 0, 0, 4558, 4572, 7, 58, 0, 0, 4559, 4572, 5, 250, 0, 0, 4560, 4561, 5, 77, 0, 0, 4561, 4572, 5, 250, 0, 0, 4562, 4563, 7, 59, 0, 0, 4563, 4572, 3, 202, 101, 0, 4564, 4565, 5, 459, 0, 0, 4565, 4572, 3, 316, 158, 0, 4566, 4567, 5, 333, 0, 0, 4567, 4572, 3, 42, 21, 0, 4568, 4572, 3, 60, 30, 0, 4569, 4570, 5, 460, 0, 0, 4570, 4572, 3, 818, 409, 0, 4571, 4545, 1, 0, 0, 0, 4571, 4550, 1, 0, 0, 0, 4571, 4551, 1, 0, 0, 0, 4571, 4552, 1, 0, 0, 0, 4571, 4553, 1, 0, 0, 0, 4571, 4555, 1, 0, 0, 0, 4571, 4559, 1, 0, 0, 0, 4571, 4560, 1, 0, 0, 0, 4571, 4562, 1, 0, 0, 0, 4571, 4564, 1, 0, 0, 0, 4571, 4566, 1, 0, 0, 0, 4571, 4568, 1, 0, 0, 0, 4571, 4569, 1, 0, 0, 0, 4572, 397, 1, 0, 0, 0, 4573, 4574, 5, 36, 0, 0, 4574, 4575, 3, 808, 404, 0, 4575, 4576, 3, 462, 231, 0, 4576, 4609, 1, 0, 0, 0, 4577, 4578, 5, 247, 0, 0, 4578, 4609, 3, 58, 29, 0, 4579, 4580, 5, 443, 0, 0, 4580, 4581, 5, 62, 0, 0, 4581, 4582, 5, 360, 0, 0, 4582, 4589, 3, 652, 326, 0, 4583, 4584, 5, 6, 0, 0, 4584, 4585, 5, 62, 0, 0, 4585, 4586, 5, 360, 0, 0, 4586, 4588, 3, 652, 326, 0, 4587, 4583, 1, 0, 0, 0, 4588, 4591, 1, 0, 0, 0, 4589, 4587, 1, 0, 0, 0, 4589, 4590, 1, 0, 0, 0, 4590, 4609, 1, 0, 0, 0, 4591, 4589, 1, 0, 0, 0, 4592, 4609, 5, 104, 0, 0, 4593, 4594, 5, 333, 0, 0, 4594, 4601, 3, 818, 409, 0, 4595, 4596, 5, 94, 0, 0, 4596, 4602, 3, 818, 409, 0, 4597, 4598, 5, 10, 0, 0, 4598, 4602, 3, 818, 409, 0, 4599, 4600, 5, 64, 0, 0, 4600, 4602, 5, 434, 0, 0, 4601, 4595, 1, 0, 0, 0, 4601, 4597, 1, 0, 0, 0, 4601, 4599, 1, 0, 0, 0, 4602, 4609, 1, 0, 0, 0, 4603, 4604, 5, 36, 0, 0, 4604, 4609, 3, 818, 409, 0, 4605, 4609, 3, 4, 2, 0, 4606, 4609, 3, 396, 198, 0, 4607, 4609, 3, 818, 409, 0, 4608, 4573, 1, 0, 0, 0, 4608, 4577, 1, 0, 0, 0, 4608, 4579, 1, 0, 0, 0, 4608, 4592, 1, 0, 0, 0, 4608, 4593, 1, 0, 0, 0, 4608, 4603, 1, 0, 0, 0, 4608, 4605, 1, 0, 0, 0, 4608, 4606, 1, 0, 0, 0, 4608, 4607, 1, 0, 0, 0, 4609, 399, 1, 0, 0, 0, 4610, 4611, 5, 105, 0, 0, 4611, 4612, 3, 284, 142, 0, 4612, 401, 1, 0, 0, 0, 4613, 4614, 3, 800, 400, 0, 4614, 4615, 3, 388, 194, 0, 4615, 403, 1, 0, 0, 0, 4616, 4623, 5, 138, 0, 0, 4617, 4618, 5, 211, 0, 0, 4618, 4624, 3, 382, 191, 0, 4619, 4620, 5, 296, 0, 0, 4620, 4624, 3, 378, 189, 0, 4621, 4622, 5, 442, 0, 0, 4622, 4624, 3, 374, 187, 0, 4623, 4617, 1, 0, 0, 0, 4623, 4619, 1, 0, 0, 0, 4623, 4621, 1, 0, 0, 0, 4624, 4626, 1, 0, 0, 0, 4625, 4627, 3, 396, 198, 0, 4626, 4625, 1, 0, 0, 0, 4627, 4628, 1, 0, 0, 0, 4628, 4626, 1, 0, 0, 0, 4628, 4629, 1, 0, 0, 0, 4629, 4631, 1, 0, 0, 0, 4630, 4632, 5, 315, 0, 0, 4631, 4630, 1, 0, 0, 0, 4631, 4632, 1, 0, 0, 0, 4632, 405, 1, 0, 0, 0, 4633, 4649, 5, 191, 0, 0, 4634, 4636, 5, 211, 0, 0, 4635, 4637, 3, 422, 211, 0, 4636, 4635, 1, 0, 0, 0, 4636, 4637, 1, 0, 0, 0, 4637, 4638, 1, 0, 0, 0, 4638, 4650, 3, 380, 190, 0, 4639, 4641, 5, 296, 0, 0, 4640, 4642, 3, 422, 211, 0, 4641, 4640, 1, 0, 0, 0, 4641, 4642, 1, 0, 0, 0, 4642, 4643, 1, 0, 0, 0, 4643, 4650, 3, 376, 188, 0, 4644, 4646, 5, 442, 0, 0, 4645, 4647, 3, 422, 211, 0, 4646, 4645, 1, 0, 0, 0, 4646, 4647, 1, 0, 0, 0, 4647, 4648, 1, 0, 0, 0, 4648, 4650, 3, 372, 186, 0, 4649, 4634, 1, 0, 0, 0, 4649, 4639, 1, 0, 0, 0, 4649, 4644, 1, 0, 0, 0, 4650, 4652, 1, 0, 0, 0, 4651, 4653, 3, 96, 48, 0, 4652, 4651, 1, 0, 0, 0, 4652, 4653, 1, 0, 0, 0, 4653, 407, 1, 0, 0, 0, 4654, 4655, 5, 191, 0, 0, 4655, 4657, 5, 136, 0, 0, 4656, 4658, 3, 422, 211, 0, 4657, 4656, 1, 0, 0, 0, 4657, 4658, 1, 0, 0, 0, 4658, 4659, 1, 0, 0, 0, 4659, 4664, 3, 394, 197, 0, 4660, 4661, 5, 6, 0, 0, 4661, 4663, 3, 394, 197, 0, 4662, 4660, 1, 0, 0, 0, 4663, 4666, 1, 0, 0, 0, 4664, 4662, 1, 0, 0, 0, 4664, 4665, 1, 0, 0, 0, 4665, 4668, 1, 0, 0, 0, 4666, 4664, 1, 0, 0, 0, 4667, 4669, 3, 96, 48, 0, 4668, 4667, 1, 0, 0, 0, 4668, 4669, 1, 0, 0, 0, 4669, 409, 1, 0, 0, 0, 4670, 4671, 5, 191, 0, 0, 4671, 4673, 5, 278, 0, 0, 4672, 4674, 3, 422, 211, 0, 4673, 4672, 1, 0, 0, 0, 4673, 4674, 1, 0, 0, 0, 4674, 4675, 1, 0, 0, 0, 4675, 4680, 3, 416, 208, 0, 4676, 4677, 5, 6, 0, 0, 4677, 4679, 3, 416, 208, 0, 4678, 4676, 1, 0, 0, 0, 4679, 4682, 1, 0, 0, 0, 4680, 4678, 1, 0, 0, 0, 4680, 4681, 1, 0, 0, 0, 4681, 4684, 1, 0, 0, 0, 4682, 4680, 1, 0, 0, 0, 4683, 4685, 3, 96, 48, 0, 4684, 4683, 1, 0, 0, 0, 4684, 4685, 1, 0, 0, 0, 4685, 411, 1, 0, 0, 0, 4686, 4699, 5, 2, 0, 0, 4687, 4690, 3, 652, 326, 0, 4688, 4689, 5, 6, 0, 0, 4689, 4691, 3, 652, 326, 0, 4690, 4688, 1, 0, 0, 0, 4690, 4691, 1, 0, 0, 0, 4691, 4700, 1, 0, 0, 0, 4692, 4693, 5, 407, 0, 0, 4693, 4694, 5, 6, 0, 0, 4694, 4700, 3, 652, 326, 0, 4695, 4696, 3, 652, 326, 0, 4696, 4697, 5, 6, 0, 0, 4697, 4698, 5, 407, 0, 0, 4698, 4700, 1, 0, 0, 0, 4699, 4687, 1, 0, 0, 0, 4699, 4692, 1, 0, 0, 0, 4699, 4695, 1, 0, 0, 0, 4700, 4701, 1, 0, 0, 0, 4701, 4702, 5, 3, 0, 0, 4702, 413, 1, 0, 0, 0, 4703, 4704, 3, 818, 409, 0, 4704, 4705, 5, 11, 0, 0, 4705, 4707, 1, 0, 0, 0, 4706, 4703, 1, 0, 0, 0, 4707, 4710, 1, 0, 0, 0, 4708, 4706, 1, 0, 0, 0, 4708, 4709, 1, 0, 0, 0, 4709, 4711, 1, 0, 0, 0, 4710, 4708, 1, 0, 0, 0, 4711, 4712, 3, 720, 360, 0, 4712, 415, 1, 0, 0, 0, 4713, 4714, 3, 414, 207, 0, 4714, 4715, 3, 412, 206, 0, 4715, 417, 1, 0, 0, 0, 4716, 4720, 5, 57, 0, 0, 4717, 4721, 3, 808, 404, 0, 4718, 4719, 5, 247, 0, 0, 4719, 4721, 3, 58, 29, 0, 4720, 4717, 1, 0, 0, 0, 4720, 4718, 1, 0, 0, 0, 4721, 4722, 1, 0, 0, 0, 4722, 4720, 1, 0, 0, 0, 4722, 4723, 1, 0, 0, 0, 4723, 419, 1, 0, 0, 0, 4724, 4725, 5, 46, 0, 0, 4725, 4726, 5, 41, 0, 0, 4726, 4727, 5, 2, 0, 0, 4727, 4728, 3, 652, 326, 0, 4728, 4729, 5, 36, 0, 0, 4729, 4730, 3, 652, 326, 0, 4730, 4747, 5, 3, 0, 0, 4731, 4732, 5, 379, 0, 0, 4732, 4735, 5, 211, 0, 0, 4733, 4734, 5, 36, 0, 0, 4734, 4736, 7, 60, 0, 0, 4735, 4733, 1, 0, 0, 0, 4735, 4736, 1, 0, 0, 0, 4736, 4748, 1, 0, 0, 0, 4737, 4741, 5, 105, 0, 0, 4738, 4739, 5, 211, 0, 0, 4739, 4742, 3, 382, 191, 0, 4740, 4742, 5, 400, 0, 0, 4741, 4738, 1, 0, 0, 0, 4741, 4740, 1, 0, 0, 0, 4742, 4745, 1, 0, 0, 0, 4743, 4744, 5, 36, 0, 0, 4744, 4746, 7, 60, 0, 0, 4745, 4743, 1, 0, 0, 0, 4745, 4746, 1, 0, 0, 0, 4746, 4748, 1, 0, 0, 0, 4747, 4731, 1, 0, 0, 0, 4747, 4737, 1, 0, 0, 0, 4748, 421, 1, 0, 0, 0, 4749, 4750, 5, 220, 0, 0, 4750, 4751, 5, 396, 0, 0, 4751, 423, 1, 0, 0, 0, 4752, 4754, 5, 46, 0, 0, 4753, 4755, 3, 366, 183, 0, 4754, 4753, 1, 0, 0, 0, 4754, 4755, 1, 0, 0, 0, 4755, 4756, 1, 0, 0, 0, 4756, 4757, 5, 443, 0, 0, 4757, 4758, 5, 62, 0, 0, 4758, 4759, 3, 652, 326, 0, 4759, 4760, 5, 247, 0, 0, 4760, 4761, 3, 818, 409, 0, 4761, 4776, 5, 2, 0, 0, 4762, 4763, 5, 64, 0, 0, 4763, 4767, 3, 426, 213, 0, 4764, 4765, 5, 6, 0, 0, 4765, 4766, 5, 94, 0, 0, 4766, 4768, 3, 426, 213, 0, 4767, 4764, 1, 0, 0, 0, 4767, 4768, 1, 0, 0, 0, 4768, 4777, 1, 0, 0, 0, 4769, 4770, 5, 94, 0, 0, 4770, 4774, 3, 426, 213, 0, 4771, 4772, 5, 6, 0, 0, 4772, 4773, 5, 64, 0, 0, 4773, 4775, 3, 426, 213, 0, 4774, 4771, 1, 0, 0, 0, 4774, 4775, 1, 0, 0, 0, 4775, 4777, 1, 0, 0, 0, 4776, 4762, 1, 0, 0, 0, 4776, 4769, 1, 0, 0, 0, 4777, 4778, 1, 0, 0, 0, 4778, 4779, 5, 3, 0, 0, 4779, 425, 1, 0, 0, 0, 4780, 4781, 5, 461, 0, 0, 4781, 4782, 5, 105, 0, 0, 4782, 4783, 5, 211, 0, 0, 4783, 4784, 3, 382, 191, 0, 4784, 427, 1, 0, 0, 0, 4785, 4796, 5, 306, 0, 0, 4786, 4787, 5, 2, 0, 0, 4787, 4792, 5, 128, 0, 0, 4788, 4789, 5, 6, 0, 0, 4789, 4791, 5, 128, 0, 0, 4790, 4788, 1, 0, 0, 0, 4791, 4794, 1, 0, 0, 0, 4792, 4790, 1, 0, 0, 0, 4792, 4793, 1, 0, 0, 0, 4793, 4795, 1, 0, 0, 0, 4794, 4792, 1, 0, 0, 0, 4795, 4797, 5, 3, 0, 0, 4796, 4786, 1, 0, 0, 0, 4796, 4797, 1, 0, 0, 0, 4797, 4823, 1, 0, 0, 0, 4798, 4800, 5, 226, 0, 0, 4799, 4801, 5, 109, 0, 0, 4800, 4799, 1, 0, 0, 0, 4800, 4801, 1, 0, 0, 0, 4801, 4802, 1, 0, 0, 0, 4802, 4824, 3, 780, 390, 0, 4803, 4805, 5, 92, 0, 0, 4804, 4806, 5, 109, 0, 0, 4805, 4804, 1, 0, 0, 0, 4805, 4806, 1, 0, 0, 0, 4806, 4807, 1, 0, 0, 0, 4807, 4824, 3, 774, 387, 0, 4808, 4810, 5, 323, 0, 0, 4809, 4811, 5, 109, 0, 0, 4810, 4809, 1, 0, 0, 0, 4810, 4811, 1, 0, 0, 0, 4811, 4812, 1, 0, 0, 0, 4812, 4824, 3, 790, 395, 0, 4813, 4815, 5, 349, 0, 0, 4814, 4816, 5, 109, 0, 0, 4815, 4814, 1, 0, 0, 0, 4815, 4816, 1, 0, 0, 0, 4816, 4817, 1, 0, 0, 0, 4817, 4824, 3, 818, 409, 0, 4818, 4820, 5, 175, 0, 0, 4819, 4821, 5, 109, 0, 0, 4820, 4819, 1, 0, 0, 0, 4820, 4821, 1, 0, 0, 0, 4821, 4822, 1, 0, 0, 0, 4822, 4824, 3, 788, 394, 0, 4823, 4798, 1, 0, 0, 0, 4823, 4803, 1, 0, 0, 0, 4823, 4808, 1, 0, 0, 0, 4823, 4813, 1, 0, 0, 0, 4823, 4818, 1, 0, 0, 0, 4824, 429, 1, 0, 0, 0, 4825, 4826, 5, 138, 0, 0, 4826, 4827, 3, 176, 88, 0, 4827, 4828, 7, 16, 0, 0, 4828, 4829, 3, 100, 50, 0, 4829, 431, 1, 0, 0, 0, 4830, 4835, 5, 138, 0, 0, 4831, 4832, 5, 136, 0, 0, 4832, 4836, 3, 394, 197, 0, 4833, 4834, 5, 442, 0, 0, 4834, 4836, 3, 374, 187, 0, 4835, 4831, 1, 0, 0, 0, 4835, 4833, 1, 0, 0, 0, 4836, 4837, 1, 0, 0, 0, 4837, 4838, 5, 309, 0, 0, 4838, 4839, 5, 94, 0, 0, 4839, 4840, 3, 818, 409, 0, 4840, 5038, 1, 0, 0, 0, 4841, 4842, 5, 138, 0, 0, 4842, 4843, 5, 175, 0, 0, 4843, 4844, 3, 788, 394, 0, 4844, 4845, 5, 309, 0, 0, 4845, 4846, 5, 94, 0, 0, 4846, 4847, 3, 786, 393, 0, 4847, 5038, 1, 0, 0, 0, 4848, 4849, 5, 138, 0, 0, 4849, 4850, 7, 61, 0, 0, 4850, 4851, 3, 316, 158, 0, 4851, 4852, 5, 309, 0, 0, 4852, 4853, 5, 94, 0, 0, 4853, 4854, 3, 818, 409, 0, 4854, 5038, 1, 0, 0, 0, 4855, 4856, 5, 138, 0, 0, 4856, 4857, 5, 211, 0, 0, 4857, 4858, 3, 382, 191, 0, 4858, 4859, 5, 309, 0, 0, 4859, 4860, 5, 94, 0, 0, 4860, 4861, 3, 804, 402, 0, 4861, 5038, 1, 0, 0, 0, 4862, 4863, 5, 138, 0, 0, 4863, 4864, 5, 278, 0, 0, 4864, 4865, 7, 31, 0, 0, 4865, 4866, 3, 316, 158, 0, 4866, 4867, 3, 170, 85, 0, 4867, 4868, 5, 309, 0, 0, 4868, 4869, 5, 94, 0, 0, 4869, 4870, 3, 818, 409, 0, 4870, 5038, 1, 0, 0, 0, 4871, 4872, 5, 138, 0, 0, 4872, 4873, 5, 296, 0, 0, 4873, 4874, 3, 378, 189, 0, 4874, 4875, 5, 309, 0, 0, 4875, 4876, 5, 94, 0, 0, 4876, 4877, 3, 798, 399, 0, 4877, 5038, 1, 0, 0, 0, 4878, 4879, 5, 138, 0, 0, 4879, 4880, 5, 323, 0, 0, 4880, 4881, 3, 790, 395, 0, 4881, 4882, 5, 309, 0, 0, 4882, 4883, 5, 94, 0, 0, 4883, 4884, 3, 32, 16, 0, 4884, 5038, 1, 0, 0, 0, 4885, 4886, 5, 138, 0, 0, 4886, 4888, 7, 62, 0, 0, 4887, 4889, 3, 422, 211, 0, 4888, 4887, 1, 0, 0, 0, 4888, 4889, 1, 0, 0, 0, 4889, 4890, 1, 0, 0, 0, 4890, 4891, 3, 780, 390, 0, 4891, 4892, 5, 309, 0, 0, 4892, 4893, 5, 94, 0, 0, 4893, 4894, 3, 818, 409, 0, 4894, 5038, 1, 0, 0, 0, 4895, 4897, 5, 138, 0, 0, 4896, 4898, 5, 259, 0, 0, 4897, 4896, 1, 0, 0, 0, 4897, 4898, 1, 0, 0, 0, 4898, 4899, 1, 0, 0, 0, 4899, 4901, 5, 376, 0, 0, 4900, 4902, 3, 422, 211, 0, 4901, 4900, 1, 0, 0, 0, 4901, 4902, 1, 0, 0, 0, 4902, 4903, 1, 0, 0, 0, 4903, 4904, 3, 778, 389, 0, 4904, 4905, 5, 309, 0, 0, 4905, 4906, 5, 94, 0, 0, 4906, 4907, 3, 776, 388, 0, 4907, 5038, 1, 0, 0, 0, 4908, 4910, 5, 138, 0, 0, 4909, 4911, 5, 63, 0, 0, 4910, 4909, 1, 0, 0, 0, 4910, 4911, 1, 0, 0, 0, 4911, 4912, 1, 0, 0, 0, 4912, 4914, 5, 92, 0, 0, 4913, 4915, 3, 422, 211, 0, 4914, 4913, 1, 0, 0, 0, 4914, 4915, 1, 0, 0, 0, 4915, 4916, 1, 0, 0, 0, 4916, 4917, 3, 624, 312, 0, 4917, 4918, 5, 309, 0, 0, 4918, 4919, 5, 94, 0, 0, 4919, 4920, 3, 772, 386, 0, 4920, 5038, 1, 0, 0, 0, 4921, 4946, 5, 138, 0, 0, 4922, 4924, 5, 63, 0, 0, 4923, 4922, 1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 4925, 1, 0, 0, 0, 4925, 4927, 5, 92, 0, 0, 4926, 4928, 3, 422, 211, 0, 4927, 4926, 1, 0, 0, 0, 4927, 4928, 1, 0, 0, 0, 4928, 4929, 1, 0, 0, 0, 4929, 4930, 3, 624, 312, 0, 4930, 4932, 5, 309, 0, 0, 4931, 4933, 5, 44, 0, 0, 4932, 4931, 1, 0, 0, 0, 4932, 4933, 1, 0, 0, 0, 4933, 4947, 1, 0, 0, 0, 4934, 4936, 5, 259, 0, 0, 4935, 4934, 1, 0, 0, 0, 4935, 4936, 1, 0, 0, 0, 4936, 4937, 1, 0, 0, 0, 4937, 4939, 5, 376, 0, 0, 4938, 4940, 3, 422, 211, 0, 4939, 4938, 1, 0, 0, 0, 4939, 4940, 1, 0, 0, 0, 4940, 4941, 1, 0, 0, 0, 4941, 4942, 3, 778, 389, 0, 4942, 4944, 5, 309, 0, 0, 4943, 4945, 5, 44, 0, 0, 4944, 4943, 1, 0, 0, 0, 4944, 4945, 1, 0, 0, 0, 4945, 4947, 1, 0, 0, 0, 4946, 4923, 1, 0, 0, 0, 4946, 4935, 1, 0, 0, 0, 4947, 4948, 1, 0, 0, 0, 4948, 4949, 3, 800, 400, 0, 4949, 4950, 5, 94, 0, 0, 4950, 4951, 3, 802, 401, 0, 4951, 5038, 1, 0, 0, 0, 4952, 4960, 5, 138, 0, 0, 4953, 4955, 5, 92, 0, 0, 4954, 4956, 3, 422, 211, 0, 4955, 4954, 1, 0, 0, 0, 4955, 4956, 1, 0, 0, 0, 4956, 4957, 1, 0, 0, 0, 4957, 4961, 3, 624, 312, 0, 4958, 4959, 5, 189, 0, 0, 4959, 4961, 3, 316, 158, 0, 4960, 4953, 1, 0, 0, 0, 4960, 4958, 1, 0, 0, 0, 4961, 4962, 1, 0, 0, 0, 4962, 4963, 5, 309, 0, 0, 4963, 4964, 5, 45, 0, 0, 4964, 4965, 3, 818, 409, 0, 4965, 4966, 5, 94, 0, 0, 4966, 4967, 3, 818, 409, 0, 4967, 5038, 1, 0, 0, 0, 4968, 4975, 5, 138, 0, 0, 4969, 4971, 5, 445, 0, 0, 4970, 4972, 3, 422, 211, 0, 4971, 4970, 1, 0, 0, 0, 4971, 4972, 1, 0, 0, 0, 4972, 4976, 1, 0, 0, 0, 4973, 4976, 5, 321, 0, 0, 4974, 4976, 5, 357, 0, 0, 4975, 4969, 1, 0, 0, 0, 4975, 4973, 1, 0, 0, 0, 4975, 4974, 1, 0, 0, 0, 4976, 4977, 1, 0, 0, 0, 4977, 4978, 3, 818, 409, 0, 4978, 4979, 5, 80, 0, 0, 4979, 4980, 3, 780, 390, 0, 4980, 4981, 5, 309, 0, 0, 4981, 4982, 5, 94, 0, 0, 4982, 4983, 3, 818, 409, 0, 4983, 5038, 1, 0, 0, 0, 4984, 4997, 5, 138, 0, 0, 4985, 4986, 5, 63, 0, 0, 4986, 4987, 5, 174, 0, 0, 4987, 4998, 5, 381, 0, 0, 4988, 4990, 5, 295, 0, 0, 4989, 4988, 1, 0, 0, 0, 4989, 4990, 1, 0, 0, 0, 4990, 4991, 1, 0, 0, 0, 4991, 4998, 5, 247, 0, 0, 4992, 4998, 5, 452, 0, 0, 4993, 4998, 5, 331, 0, 0, 4994, 4998, 5, 451, 0, 0, 4995, 4996, 5, 198, 0, 0, 4996, 4998, 5, 357, 0, 0, 4997, 4985, 1, 0, 0, 0, 4997, 4989, 1, 0, 0, 0, 4997, 4992, 1, 0, 0, 0, 4997, 4993, 1, 0, 0, 0, 4997, 4994, 1, 0, 0, 0, 4997, 4995, 1, 0, 0, 0, 4998, 4999, 1, 0, 0, 0, 4999, 5000, 3, 818, 409, 0, 5000, 5001, 5, 309, 0, 0, 5001, 5002, 5, 94, 0, 0, 5002, 5003, 3, 818, 409, 0, 5003, 5038, 1, 0, 0, 0, 5004, 5005, 5, 138, 0, 0, 5005, 5006, 7, 45, 0, 0, 5006, 5007, 3, 814, 407, 0, 5007, 5008, 5, 309, 0, 0, 5008, 5009, 5, 94, 0, 0, 5009, 5010, 3, 814, 407, 0, 5010, 5038, 1, 0, 0, 0, 5011, 5012, 5, 138, 0, 0, 5012, 5013, 3, 176, 88, 0, 5013, 5014, 5, 309, 0, 0, 5014, 5015, 5, 94, 0, 0, 5015, 5016, 3, 768, 384, 0, 5016, 5038, 1, 0, 0, 0, 5017, 5018, 5, 138, 0, 0, 5018, 5019, 5, 355, 0, 0, 5019, 5020, 5, 325, 0, 0, 5020, 5021, 7, 41, 0, 0, 5021, 5022, 3, 316, 158, 0, 5022, 5023, 5, 309, 0, 0, 5023, 5024, 5, 94, 0, 0, 5024, 5025, 3, 818, 409, 0, 5025, 5038, 1, 0, 0, 0, 5026, 5027, 5, 138, 0, 0, 5027, 5028, 5, 360, 0, 0, 5028, 5029, 3, 316, 158, 0, 5029, 5030, 5, 309, 0, 0, 5030, 5031, 5, 143, 0, 0, 5031, 5032, 3, 818, 409, 0, 5032, 5033, 5, 94, 0, 0, 5033, 5035, 3, 818, 409, 0, 5034, 5036, 3, 96, 48, 0, 5035, 5034, 1, 0, 0, 0, 5035, 5036, 1, 0, 0, 0, 5036, 5038, 1, 0, 0, 0, 5037, 4830, 1, 0, 0, 0, 5037, 4841, 1, 0, 0, 0, 5037, 4848, 1, 0, 0, 0, 5037, 4855, 1, 0, 0, 0, 5037, 4862, 1, 0, 0, 0, 5037, 4871, 1, 0, 0, 0, 5037, 4878, 1, 0, 0, 0, 5037, 4885, 1, 0, 0, 0, 5037, 4895, 1, 0, 0, 0, 5037, 4908, 1, 0, 0, 0, 5037, 4921, 1, 0, 0, 0, 5037, 4952, 1, 0, 0, 0, 5037, 4968, 1, 0, 0, 0, 5037, 4984, 1, 0, 0, 0, 5037, 5004, 1, 0, 0, 0, 5037, 5011, 1, 0, 0, 0, 5037, 5017, 1, 0, 0, 0, 5037, 5026, 1, 0, 0, 0, 5038, 433, 1, 0, 0, 0, 5039, 5056, 5, 138, 0, 0, 5040, 5041, 5, 211, 0, 0, 5041, 5057, 3, 382, 191, 0, 5042, 5043, 5, 296, 0, 0, 5043, 5057, 3, 378, 189, 0, 5044, 5045, 5, 442, 0, 0, 5045, 5057, 3, 374, 187, 0, 5046, 5047, 5, 357, 0, 0, 5047, 5048, 3, 818, 409, 0, 5048, 5049, 5, 80, 0, 0, 5049, 5050, 3, 780, 390, 0, 5050, 5057, 1, 0, 0, 0, 5051, 5052, 5, 259, 0, 0, 5052, 5053, 5, 376, 0, 0, 5053, 5057, 3, 778, 389, 0, 5054, 5055, 5, 226, 0, 0, 5055, 5057, 3, 780, 390, 0, 5056, 5040, 1, 0, 0, 0, 5056, 5042, 1, 0, 0, 0, 5056, 5044, 1, 0, 0, 0, 5056, 5046, 1, 0, 0, 0, 5056, 5051, 1, 0, 0, 0, 5056, 5054, 1, 0, 0, 0, 5057, 5059, 1, 0, 0, 0, 5058, 5060, 5, 269, 0, 0, 5059, 5058, 1, 0, 0, 0, 5059, 5060, 1, 0, 0, 0, 5060, 5061, 1, 0, 0, 0, 5061, 5062, 5, 462, 0, 0, 5062, 5063, 5, 80, 0, 0, 5063, 5064, 5, 204, 0, 0, 5064, 5065, 3, 818, 409, 0, 5065, 435, 1, 0, 0, 0, 5066, 5105, 5, 138, 0, 0, 5067, 5068, 5, 136, 0, 0, 5068, 5106, 3, 394, 197, 0, 5069, 5070, 5, 204, 0, 0, 5070, 5106, 3, 818, 409, 0, 5071, 5072, 5, 211, 0, 0, 5072, 5106, 3, 382, 191, 0, 5073, 5074, 5, 278, 0, 0, 5074, 5106, 3, 416, 208, 0, 5075, 5076, 5, 278, 0, 0, 5076, 5077, 7, 31, 0, 0, 5077, 5078, 3, 316, 158, 0, 5078, 5079, 3, 170, 85, 0, 5079, 5106, 1, 0, 0, 0, 5080, 5081, 5, 296, 0, 0, 5081, 5106, 3, 378, 189, 0, 5082, 5083, 5, 442, 0, 0, 5083, 5106, 3, 374, 187, 0, 5084, 5086, 5, 328, 0, 0, 5085, 5087, 3, 422, 211, 0, 5086, 5085, 1, 0, 0, 0, 5086, 5087, 1, 0, 0, 0, 5087, 5088, 1, 0, 0, 0, 5088, 5106, 3, 780, 390, 0, 5089, 5091, 5, 259, 0, 0, 5090, 5089, 1, 0, 0, 0, 5090, 5091, 1, 0, 0, 0, 5091, 5092, 1, 0, 0, 0, 5092, 5094, 5, 376, 0, 0, 5093, 5095, 3, 422, 211, 0, 5094, 5093, 1, 0, 0, 0, 5094, 5095, 1, 0, 0, 0, 5095, 5096, 1, 0, 0, 0, 5096, 5106, 3, 778, 389, 0, 5097, 5099, 5, 63, 0, 0, 5098, 5097, 1, 0, 0, 0, 5098, 5099, 1, 0, 0, 0, 5099, 5100, 1, 0, 0, 0, 5100, 5102, 5, 92, 0, 0, 5101, 5103, 3, 422, 211, 0, 5102, 5101, 1, 0, 0, 0, 5102, 5103, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5106, 3, 624, 312, 0, 5105, 5067, 1, 0, 0, 0, 5105, 5069, 1, 0, 0, 0, 5105, 5071, 1, 0, 0, 0, 5105, 5073, 1, 0, 0, 0, 5105, 5075, 1, 0, 0, 0, 5105, 5080, 1, 0, 0, 0, 5105, 5082, 1, 0, 0, 0, 5105, 5084, 1, 0, 0, 0, 5105, 5090, 1, 0, 0, 0, 5105, 5098, 1, 0, 0, 0, 5106, 5107, 1, 0, 0, 0, 5107, 5108, 5, 333, 0, 0, 5108, 5109, 5, 323, 0, 0, 5109, 5110, 3, 790, 395, 0, 5110, 5128, 1, 0, 0, 0, 5111, 5120, 5, 138, 0, 0, 5112, 5113, 5, 355, 0, 0, 5113, 5114, 5, 325, 0, 0, 5114, 5121, 7, 41, 0, 0, 5115, 5121, 5, 108, 0, 0, 5116, 5121, 5, 168, 0, 0, 5117, 5121, 5, 189, 0, 0, 5118, 5121, 5, 342, 0, 0, 5119, 5121, 5, 360, 0, 0, 5120, 5112, 1, 0, 0, 0, 5120, 5115, 1, 0, 0, 0, 5120, 5116, 1, 0, 0, 0, 5120, 5117, 1, 0, 0, 0, 5120, 5118, 1, 0, 0, 0, 5120, 5119, 1, 0, 0, 0, 5121, 5122, 1, 0, 0, 0, 5122, 5123, 3, 316, 158, 0, 5123, 5124, 5, 333, 0, 0, 5124, 5125, 5, 323, 0, 0, 5125, 5126, 3, 790, 395, 0, 5126, 5128, 1, 0, 0, 0, 5127, 5066, 1, 0, 0, 0, 5127, 5111, 1, 0, 0, 0, 5128, 437, 1, 0, 0, 0, 5129, 5130, 5, 138, 0, 0, 5130, 5131, 5, 278, 0, 0, 5131, 5132, 3, 416, 208, 0, 5132, 5133, 5, 333, 0, 0, 5133, 5134, 3, 440, 220, 0, 5134, 439, 1, 0, 0, 0, 5135, 5136, 5, 2, 0, 0, 5136, 5141, 3, 442, 221, 0, 5137, 5138, 5, 6, 0, 0, 5138, 5140, 3, 442, 221, 0, 5139, 5137, 1, 0, 0, 0, 5140, 5143, 1, 0, 0, 0, 5141, 5139, 1, 0, 0, 0, 5141, 5142, 1, 0, 0, 0, 5142, 5144, 1, 0, 0, 0, 5143, 5141, 1, 0, 0, 0, 5144, 5145, 5, 3, 0, 0, 5145, 441, 1, 0, 0, 0, 5146, 5147, 3, 824, 412, 0, 5147, 5154, 5, 10, 0, 0, 5148, 5155, 5, 407, 0, 0, 5149, 5155, 3, 388, 194, 0, 5150, 5155, 3, 834, 417, 0, 5151, 5155, 3, 726, 363, 0, 5152, 5155, 3, 202, 101, 0, 5153, 5155, 3, 808, 404, 0, 5154, 5148, 1, 0, 0, 0, 5154, 5149, 1, 0, 0, 0, 5154, 5150, 1, 0, 0, 0, 5154, 5151, 1, 0, 0, 0, 5154, 5152, 1, 0, 0, 0, 5154, 5153, 1, 0, 0, 0, 5155, 443, 1, 0, 0, 0, 5156, 5157, 5, 138, 0, 0, 5157, 5158, 5, 360, 0, 0, 5158, 5159, 3, 316, 158, 0, 5159, 5160, 5, 333, 0, 0, 5160, 5161, 3, 440, 220, 0, 5161, 445, 1, 0, 0, 0, 5162, 5163, 5, 138, 0, 0, 5163, 5164, 5, 278, 0, 0, 5164, 5165, 7, 31, 0, 0, 5165, 5166, 3, 316, 158, 0, 5166, 5167, 3, 170, 85, 0, 5167, 5168, 5, 282, 0, 0, 5168, 5169, 5, 94, 0, 0, 5169, 5170, 3, 814, 407, 0, 5170, 5237, 1, 0, 0, 0, 5171, 5198, 5, 138, 0, 0, 5172, 5173, 5, 136, 0, 0, 5173, 5199, 3, 394, 197, 0, 5174, 5175, 5, 175, 0, 0, 5175, 5199, 3, 788, 394, 0, 5176, 5177, 5, 211, 0, 0, 5177, 5199, 3, 382, 191, 0, 5178, 5180, 5, 295, 0, 0, 5179, 5178, 1, 0, 0, 0, 5179, 5180, 1, 0, 0, 0, 5180, 5181, 1, 0, 0, 0, 5181, 5182, 5, 247, 0, 0, 5182, 5199, 3, 818, 409, 0, 5183, 5184, 5, 248, 0, 0, 5184, 5185, 5, 274, 0, 0, 5185, 5199, 3, 202, 101, 0, 5186, 5187, 5, 248, 0, 0, 5187, 5188, 5, 274, 0, 0, 5188, 5199, 3, 202, 101, 0, 5189, 5190, 5, 278, 0, 0, 5190, 5199, 3, 416, 208, 0, 5191, 5192, 5, 296, 0, 0, 5192, 5199, 3, 378, 189, 0, 5193, 5194, 5, 442, 0, 0, 5194, 5199, 3, 374, 187, 0, 5195, 5196, 5, 323, 0, 0, 5196, 5199, 3, 790, 395, 0, 5197, 5199, 3, 176, 88, 0, 5198, 5172, 1, 0, 0, 0, 5198, 5174, 1, 0, 0, 0, 5198, 5176, 1, 0, 0, 0, 5198, 5179, 1, 0, 0, 0, 5198, 5183, 1, 0, 0, 0, 5198, 5186, 1, 0, 0, 0, 5198, 5189, 1, 0, 0, 0, 5198, 5191, 1, 0, 0, 0, 5198, 5193, 1, 0, 0, 0, 5198, 5195, 1, 0, 0, 0, 5198, 5197, 1, 0, 0, 0, 5199, 5200, 1, 0, 0, 0, 5200, 5201, 5, 282, 0, 0, 5201, 5202, 5, 94, 0, 0, 5202, 5203, 3, 814, 407, 0, 5203, 5237, 1, 0, 0, 0, 5204, 5213, 5, 138, 0, 0, 5205, 5206, 5, 355, 0, 0, 5206, 5207, 5, 325, 0, 0, 5207, 5214, 7, 63, 0, 0, 5208, 5214, 5, 108, 0, 0, 5209, 5214, 5, 168, 0, 0, 5210, 5214, 5, 189, 0, 0, 5211, 5214, 5, 360, 0, 0, 5212, 5214, 5, 342, 0, 0, 5213, 5205, 1, 0, 0, 0, 5213, 5208, 1, 0, 0, 0, 5213, 5209, 1, 0, 0, 0, 5213, 5210, 1, 0, 0, 0, 5213, 5211, 1, 0, 0, 0, 5213, 5212, 1, 0, 0, 0, 5214, 5215, 1, 0, 0, 0, 5215, 5216, 3, 316, 158, 0, 5216, 5217, 5, 282, 0, 0, 5217, 5218, 5, 94, 0, 0, 5218, 5219, 3, 814, 407, 0, 5219, 5237, 1, 0, 0, 0, 5220, 5229, 5, 138, 0, 0, 5221, 5230, 5, 331, 0, 0, 5222, 5223, 5, 63, 0, 0, 5223, 5224, 5, 174, 0, 0, 5224, 5230, 5, 381, 0, 0, 5225, 5226, 5, 198, 0, 0, 5226, 5230, 5, 357, 0, 0, 5227, 5230, 5, 452, 0, 0, 5228, 5230, 5, 451, 0, 0, 5229, 5221, 1, 0, 0, 0, 5229, 5222, 1, 0, 0, 0, 5229, 5225, 1, 0, 0, 0, 5229, 5227, 1, 0, 0, 0, 5229, 5228, 1, 0, 0, 0, 5230, 5231, 1, 0, 0, 0, 5231, 5232, 3, 818, 409, 0, 5232, 5233, 5, 282, 0, 0, 5233, 5234, 5, 94, 0, 0, 5234, 5235, 3, 814, 407, 0, 5235, 5237, 1, 0, 0, 0, 5236, 5162, 1, 0, 0, 0, 5236, 5171, 1, 0, 0, 0, 5236, 5204, 1, 0, 0, 0, 5236, 5220, 1, 0, 0, 0, 5237, 447, 1, 0, 0, 0, 5238, 5239, 5, 46, 0, 0, 5239, 5240, 5, 452, 0, 0, 5240, 5247, 3, 818, 409, 0, 5241, 5242, 5, 62, 0, 0, 5242, 5243, 5, 92, 0, 0, 5243, 5248, 3, 628, 314, 0, 5244, 5245, 5, 62, 0, 0, 5245, 5246, 5, 30, 0, 0, 5246, 5248, 5, 350, 0, 0, 5247, 5241, 1, 0, 0, 0, 5247, 5244, 1, 0, 0, 0, 5247, 5248, 1, 0, 0, 0, 5248, 5250, 1, 0, 0, 0, 5249, 5251, 3, 400, 200, 0, 5250, 5249, 1, 0, 0, 0, 5250, 5251, 1, 0, 0, 0, 5251, 449, 1, 0, 0, 0, 5252, 5253, 5, 138, 0, 0, 5253, 5254, 5, 452, 0, 0, 5254, 5272, 3, 818, 409, 0, 5255, 5256, 5, 282, 0, 0, 5256, 5257, 5, 94, 0, 0, 5257, 5273, 3, 814, 407, 0, 5258, 5259, 5, 333, 0, 0, 5259, 5273, 3, 284, 142, 0, 5260, 5261, 5, 309, 0, 0, 5261, 5262, 5, 94, 0, 0, 5262, 5273, 3, 818, 409, 0, 5263, 5264, 7, 34, 0, 0, 5264, 5269, 3, 626, 313, 0, 5265, 5266, 5, 6, 0, 0, 5266, 5268, 3, 626, 313, 0, 5267, 5265, 1, 0, 0, 0, 5268, 5271, 1, 0, 0, 0, 5269, 5267, 1, 0, 0, 0, 5269, 5270, 1, 0, 0, 0, 5270, 5273, 1, 0, 0, 0, 5271, 5269, 1, 0, 0, 0, 5272, 5255, 1, 0, 0, 0, 5272, 5258, 1, 0, 0, 0, 5272, 5260, 1, 0, 0, 0, 5272, 5263, 1, 0, 0, 0, 5273, 451, 1, 0, 0, 0, 5274, 5275, 5, 46, 0, 0, 5275, 5276, 5, 451, 0, 0, 5276, 5277, 3, 818, 409, 0, 5277, 5278, 5, 164, 0, 0, 5278, 5279, 3, 808, 404, 0, 5279, 5280, 5, 452, 0, 0, 5280, 5285, 3, 824, 412, 0, 5281, 5282, 5, 6, 0, 0, 5282, 5284, 3, 824, 412, 0, 5283, 5281, 1, 0, 0, 0, 5284, 5287, 1, 0, 0, 0, 5285, 5283, 1, 0, 0, 0, 5285, 5286, 1, 0, 0, 0, 5286, 5289, 1, 0, 0, 0, 5287, 5285, 1, 0, 0, 0, 5288, 5290, 3, 400, 200, 0, 5289, 5288, 1, 0, 0, 0, 5289, 5290, 1, 0, 0, 0, 5290, 453, 1, 0, 0, 0, 5291, 5292, 5, 138, 0, 0, 5292, 5293, 5, 451, 0, 0, 5293, 5294, 3, 818, 409, 0, 5294, 5295, 5, 333, 0, 0, 5295, 5296, 3, 284, 142, 0, 5296, 5348, 1, 0, 0, 0, 5297, 5298, 5, 138, 0, 0, 5298, 5299, 5, 451, 0, 0, 5299, 5300, 3, 818, 409, 0, 5300, 5301, 5, 164, 0, 0, 5301, 5302, 3, 808, 404, 0, 5302, 5348, 1, 0, 0, 0, 5303, 5304, 5, 138, 0, 0, 5304, 5305, 5, 451, 0, 0, 5305, 5306, 3, 818, 409, 0, 5306, 5307, 5, 305, 0, 0, 5307, 5309, 5, 452, 0, 0, 5308, 5310, 3, 400, 200, 0, 5309, 5308, 1, 0, 0, 0, 5309, 5310, 1, 0, 0, 0, 5310, 5348, 1, 0, 0, 0, 5311, 5312, 5, 138, 0, 0, 5312, 5313, 5, 451, 0, 0, 5313, 5314, 3, 818, 409, 0, 5314, 5315, 7, 34, 0, 0, 5315, 5316, 5, 452, 0, 0, 5316, 5321, 3, 824, 412, 0, 5317, 5318, 5, 6, 0, 0, 5318, 5320, 3, 824, 412, 0, 5319, 5317, 1, 0, 0, 0, 5320, 5323, 1, 0, 0, 0, 5321, 5319, 1, 0, 0, 0, 5321, 5322, 1, 0, 0, 0, 5322, 5325, 1, 0, 0, 0, 5323, 5321, 1, 0, 0, 0, 5324, 5326, 3, 400, 200, 0, 5325, 5324, 1, 0, 0, 0, 5325, 5326, 1, 0, 0, 0, 5326, 5348, 1, 0, 0, 0, 5327, 5328, 5, 138, 0, 0, 5328, 5329, 5, 451, 0, 0, 5329, 5330, 3, 818, 409, 0, 5330, 5331, 7, 64, 0, 0, 5331, 5348, 1, 0, 0, 0, 5332, 5333, 5, 138, 0, 0, 5333, 5334, 5, 451, 0, 0, 5334, 5335, 3, 818, 409, 0, 5335, 5336, 5, 465, 0, 0, 5336, 5337, 5, 2, 0, 0, 5337, 5338, 3, 290, 145, 0, 5338, 5339, 5, 3, 0, 0, 5339, 5348, 1, 0, 0, 0, 5340, 5341, 5, 138, 0, 0, 5341, 5342, 5, 451, 0, 0, 5342, 5343, 3, 818, 409, 0, 5343, 5344, 5, 282, 0, 0, 5344, 5345, 5, 94, 0, 0, 5345, 5346, 3, 814, 407, 0, 5346, 5348, 1, 0, 0, 0, 5347, 5291, 1, 0, 0, 0, 5347, 5297, 1, 0, 0, 0, 5347, 5303, 1, 0, 0, 0, 5347, 5311, 1, 0, 0, 0, 5347, 5327, 1, 0, 0, 0, 5347, 5332, 1, 0, 0, 0, 5347, 5340, 1, 0, 0, 0, 5348, 455, 1, 0, 0, 0, 5349, 5351, 5, 46, 0, 0, 5350, 5352, 3, 366, 183, 0, 5351, 5350, 1, 0, 0, 0, 5351, 5352, 1, 0, 0, 0, 5352, 5353, 1, 0, 0, 0, 5353, 5354, 5, 321, 0, 0, 5354, 5355, 3, 818, 409, 0, 5355, 5356, 5, 36, 0, 0, 5356, 5357, 5, 80, 0, 0, 5357, 5358, 7, 65, 0, 0, 5358, 5359, 5, 94, 0, 0, 5359, 5361, 3, 780, 390, 0, 5360, 5362, 3, 638, 319, 0, 5361, 5360, 1, 0, 0, 0, 5361, 5362, 1, 0, 0, 0, 5362, 5363, 1, 0, 0, 0, 5363, 5365, 5, 57, 0, 0, 5364, 5366, 7, 66, 0, 0, 5365, 5364, 1, 0, 0, 0, 5365, 5366, 1, 0, 0, 0, 5366, 5383, 1, 0, 0, 0, 5367, 5384, 5, 270, 0, 0, 5368, 5384, 3, 458, 229, 0, 5369, 5371, 5, 2, 0, 0, 5370, 5372, 3, 458, 229, 0, 5371, 5370, 1, 0, 0, 0, 5371, 5372, 1, 0, 0, 0, 5372, 5379, 1, 0, 0, 0, 5373, 5375, 5, 7, 0, 0, 5374, 5376, 3, 458, 229, 0, 5375, 5374, 1, 0, 0, 0, 5375, 5376, 1, 0, 0, 0, 5376, 5378, 1, 0, 0, 0, 5377, 5373, 1, 0, 0, 0, 5378, 5381, 1, 0, 0, 0, 5379, 5377, 1, 0, 0, 0, 5379, 5380, 1, 0, 0, 0, 5380, 5382, 1, 0, 0, 0, 5381, 5379, 1, 0, 0, 0, 5382, 5384, 5, 3, 0, 0, 5383, 5367, 1, 0, 0, 0, 5383, 5368, 1, 0, 0, 0, 5383, 5369, 1, 0, 0, 0, 5384, 457, 1, 0, 0, 0, 5385, 5391, 3, 560, 280, 0, 5386, 5391, 3, 538, 269, 0, 5387, 5391, 3, 552, 276, 0, 5388, 5391, 3, 548, 274, 0, 5389, 5391, 3, 460, 230, 0, 5390, 5385, 1, 0, 0, 0, 5390, 5386, 1, 0, 0, 0, 5390, 5387, 1, 0, 0, 0, 5390, 5388, 1, 0, 0, 0, 5390, 5389, 1, 0, 0, 0, 5391, 459, 1, 0, 0, 0, 5392, 5393, 5, 271, 0, 0, 5393, 5395, 3, 818, 409, 0, 5394, 5396, 3, 462, 231, 0, 5395, 5394, 1, 0, 0, 0, 5395, 5396, 1, 0, 0, 0, 5396, 461, 1, 0, 0, 0, 5397, 5398, 5, 6, 0, 0, 5398, 5399, 3, 808, 404, 0, 5399, 463, 1, 0, 0, 0, 5400, 5401, 5, 252, 0, 0, 5401, 5402, 3, 818, 409, 0, 5402, 465, 1, 0, 0, 0, 5403, 5406, 5, 366, 0, 0, 5404, 5407, 3, 818, 409, 0, 5405, 5407, 5, 9, 0, 0, 5406, 5404, 1, 0, 0, 0, 5406, 5405, 1, 0, 0, 0, 5407, 467, 1, 0, 0, 0, 5408, 5410, 5, 146, 0, 0, 5409, 5411, 3, 470, 235, 0, 5410, 5409, 1, 0, 0, 0, 5410, 5411, 1, 0, 0, 0, 5411, 5413, 1, 0, 0, 0, 5412, 5414, 3, 474, 237, 0, 5413, 5412, 1, 0, 0, 0, 5413, 5414, 1, 0, 0, 0, 5414, 5454, 1, 0, 0, 0, 5415, 5416, 5, 340, 0, 0, 5416, 5418, 5, 356, 0, 0, 5417, 5419, 3, 474, 237, 0, 5418, 5417, 1, 0, 0, 0, 5418, 5419, 1, 0, 0, 0, 5419, 5454, 1, 0, 0, 0, 5420, 5421, 5, 322, 0, 0, 5421, 5454, 3, 818, 409, 0, 5422, 5424, 5, 308, 0, 0, 5423, 5425, 5, 322, 0, 0, 5424, 5423, 1, 0, 0, 0, 5424, 5425, 1, 0, 0, 0, 5425, 5426, 1, 0, 0, 0, 5426, 5454, 3, 818, 409, 0, 5427, 5428, 5, 290, 0, 0, 5428, 5429, 5, 356, 0, 0, 5429, 5454, 3, 808, 404, 0, 5430, 5431, 7, 67, 0, 0, 5431, 5432, 5, 291, 0, 0, 5432, 5454, 3, 808, 404, 0, 5433, 5435, 7, 68, 0, 0, 5434, 5436, 3, 470, 235, 0, 5435, 5434, 1, 0, 0, 0, 5435, 5436, 1, 0, 0, 0, 5436, 5442, 1, 0, 0, 0, 5437, 5439, 5, 33, 0, 0, 5438, 5440, 5, 269, 0, 0, 5439, 5438, 1, 0, 0, 0, 5439, 5440, 1, 0, 0, 0, 5440, 5441, 1, 0, 0, 0, 5441, 5443, 5, 153, 0, 0, 5442, 5437, 1, 0, 0, 0, 5442, 5443, 1, 0, 0, 0, 5443, 5454, 1, 0, 0, 0, 5444, 5446, 5, 319, 0, 0, 5445, 5447, 3, 470, 235, 0, 5446, 5445, 1, 0, 0, 0, 5446, 5447, 1, 0, 0, 0, 5447, 5448, 1, 0, 0, 0, 5448, 5450, 5, 94, 0, 0, 5449, 5451, 5, 322, 0, 0, 5450, 5449, 1, 0, 0, 0, 5450, 5451, 1, 0, 0, 0, 5451, 5452, 1, 0, 0, 0, 5452, 5454, 3, 818, 409, 0, 5453, 5408, 1, 0, 0, 0, 5453, 5415, 1, 0, 0, 0, 5453, 5420, 1, 0, 0, 0, 5453, 5422, 1, 0, 0, 0, 5453, 5427, 1, 0, 0, 0, 5453, 5430, 1, 0, 0, 0, 5453, 5433, 1, 0, 0, 0, 5453, 5444, 1, 0, 0, 0, 5454, 469, 1, 0, 0, 0, 5455, 5456, 7, 69, 0, 0, 5456, 471, 1, 0, 0, 0, 5457, 5458, 5, 244, 0, 0, 5458, 5459, 5, 251, 0, 0, 5459, 5467, 3, 50, 25, 0, 5460, 5461, 5, 300, 0, 0, 5461, 5467, 7, 70, 0, 0, 5462, 5464, 5, 77, 0, 0, 5463, 5462, 1, 0, 0, 0, 5463, 5464, 1, 0, 0, 0, 5464, 5465, 1, 0, 0, 0, 5465, 5467, 5, 54, 0, 0, 5466, 5457, 1, 0, 0, 0, 5466, 5460, 1, 0, 0, 0, 5466, 5463, 1, 0, 0, 0, 5467, 473, 1, 0, 0, 0, 5468, 5475, 3, 472, 236, 0, 5469, 5471, 5, 6, 0, 0, 5470, 5469, 1, 0, 0, 0, 5470, 5471, 1, 0, 0, 0, 5471, 5472, 1, 0, 0, 0, 5472, 5474, 3, 472, 236, 0, 5473, 5470, 1, 0, 0, 0, 5474, 5477, 1, 0, 0, 0, 5475, 5473, 1, 0, 0, 0, 5475, 5476, 1, 0, 0, 0, 5476, 475, 1, 0, 0, 0, 5477, 5475, 1, 0, 0, 0, 5478, 5481, 5, 46, 0, 0, 5479, 5480, 5, 82, 0, 0, 5480, 5482, 5, 311, 0, 0, 5481, 5479, 1, 0, 0, 0, 5481, 5482, 1, 0, 0, 0, 5482, 5484, 1, 0, 0, 0, 5483, 5485, 3, 122, 61, 0, 5484, 5483, 1, 0, 0, 0, 5484, 5485, 1, 0, 0, 0, 5485, 5501, 1, 0, 0, 0, 5486, 5487, 5, 376, 0, 0, 5487, 5489, 3, 776, 388, 0, 5488, 5490, 3, 146, 73, 0, 5489, 5488, 1, 0, 0, 0, 5489, 5490, 1, 0, 0, 0, 5490, 5492, 1, 0, 0, 0, 5491, 5493, 3, 102, 51, 0, 5492, 5491, 1, 0, 0, 0, 5492, 5493, 1, 0, 0, 0, 5493, 5502, 1, 0, 0, 0, 5494, 5495, 5, 303, 0, 0, 5495, 5496, 5, 376, 0, 0, 5496, 5497, 3, 776, 388, 0, 5497, 5499, 3, 144, 72, 0, 5498, 5500, 3, 102, 51, 0, 5499, 5498, 1, 0, 0, 0, 5499, 5500, 1, 0, 0, 0, 5500, 5502, 1, 0, 0, 0, 5501, 5486, 1, 0, 0, 0, 5501, 5494, 1, 0, 0, 0, 5502, 5503, 1, 0, 0, 0, 5503, 5504, 5, 36, 0, 0, 5504, 5511, 3, 560, 280, 0, 5505, 5507, 5, 105, 0, 0, 5506, 5508, 7, 71, 0, 0, 5507, 5506, 1, 0, 0, 0, 5507, 5508, 1, 0, 0, 0, 5508, 5509, 1, 0, 0, 0, 5509, 5510, 5, 42, 0, 0, 5510, 5512, 5, 279, 0, 0, 5511, 5505, 1, 0, 0, 0, 5511, 5512, 1, 0, 0, 0, 5512, 477, 1, 0, 0, 0, 5513, 5514, 5, 253, 0, 0, 5514, 5515, 3, 808, 404, 0, 5515, 479, 1, 0, 0, 0, 5516, 5517, 5, 46, 0, 0, 5517, 5518, 5, 175, 0, 0, 5518, 5520, 3, 786, 393, 0, 5519, 5521, 5, 105, 0, 0, 5520, 5519, 1, 0, 0, 0, 5520, 5521, 1, 0, 0, 0, 5521, 5527, 1, 0, 0, 0, 5522, 5524, 3, 482, 241, 0, 5523, 5522, 1, 0, 0, 0, 5524, 5525, 1, 0, 0, 0, 5525, 5523, 1, 0, 0, 0, 5525, 5526, 1, 0, 0, 0, 5526, 5528, 1, 0, 0, 0, 5527, 5523, 1, 0, 0, 0, 5527, 5528, 1, 0, 0, 0, 5528, 481, 1, 0, 0, 0, 5529, 5530, 5, 164, 0, 0, 5530, 5538, 5, 74, 0, 0, 5531, 5538, 5, 194, 0, 0, 5532, 5538, 5, 255, 0, 0, 5533, 5538, 5, 282, 0, 0, 5534, 5538, 5, 351, 0, 0, 5535, 5538, 5, 353, 0, 0, 5536, 5538, 3, 826, 413, 0, 5537, 5529, 1, 0, 0, 0, 5537, 5531, 1, 0, 0, 0, 5537, 5532, 1, 0, 0, 0, 5537, 5533, 1, 0, 0, 0, 5537, 5534, 1, 0, 0, 0, 5537, 5535, 1, 0, 0, 0, 5537, 5536, 1, 0, 0, 0, 5538, 5540, 1, 0, 0, 0, 5539, 5541, 5, 10, 0, 0, 5540, 5539, 1, 0, 0, 0, 5540, 5541, 1, 0, 0, 0, 5541, 5545, 1, 0, 0, 0, 5542, 5546, 3, 812, 406, 0, 5543, 5546, 3, 54, 27, 0, 5544, 5546, 5, 53, 0, 0, 5545, 5542, 1, 0, 0, 0, 5545, 5543, 1, 0, 0, 0, 5545, 5544, 1, 0, 0, 0, 5546, 483, 1, 0, 0, 0, 5547, 5548, 5, 138, 0, 0, 5548, 5549, 5, 175, 0, 0, 5549, 5565, 3, 788, 394, 0, 5550, 5551, 5, 333, 0, 0, 5551, 5552, 5, 351, 0, 0, 5552, 5554, 3, 768, 384, 0, 5553, 5550, 1, 0, 0, 0, 5553, 5554, 1, 0, 0, 0, 5554, 5566, 1, 0, 0, 0, 5555, 5557, 5, 105, 0, 0, 5556, 5555, 1, 0, 0, 0, 5556, 5557, 1, 0, 0, 0, 5557, 5559, 1, 0, 0, 0, 5558, 5560, 3, 482, 241, 0, 5559, 5558, 1, 0, 0, 0, 5560, 5561, 1, 0, 0, 0, 5561, 5559, 1, 0, 0, 0, 5561, 5562, 1, 0, 0, 0, 5562, 5564, 1, 0, 0, 0, 5563, 5556, 1, 0, 0, 0, 5563, 5564, 1, 0, 0, 0, 5564, 5566, 1, 0, 0, 0, 5565, 5553, 1, 0, 0, 0, 5565, 5563, 1, 0, 0, 0, 5566, 485, 1, 0, 0, 0, 5567, 5568, 5, 138, 0, 0, 5568, 5569, 5, 175, 0, 0, 5569, 5571, 3, 788, 394, 0, 5570, 5572, 3, 64, 32, 0, 5571, 5570, 1, 0, 0, 0, 5571, 5572, 1, 0, 0, 0, 5572, 487, 1, 0, 0, 0, 5573, 5574, 5, 138, 0, 0, 5574, 5575, 5, 108, 0, 0, 5575, 5576, 3, 316, 158, 0, 5576, 5577, 5, 305, 0, 0, 5577, 5578, 5, 375, 0, 0, 5578, 489, 1, 0, 0, 0, 5579, 5580, 5, 138, 0, 0, 5580, 5581, 5, 349, 0, 0, 5581, 5582, 7, 16, 0, 0, 5582, 5583, 3, 40, 20, 0, 5583, 491, 1, 0, 0, 0, 5584, 5585, 5, 46, 0, 0, 5585, 5586, 5, 189, 0, 0, 5586, 5588, 3, 316, 158, 0, 5587, 5589, 5, 36, 0, 0, 5588, 5587, 1, 0, 0, 0, 5588, 5589, 1, 0, 0, 0, 5589, 5590, 1, 0, 0, 0, 5590, 5594, 3, 652, 326, 0, 5591, 5593, 3, 134, 67, 0, 5592, 5591, 1, 0, 0, 0, 5593, 5596, 1, 0, 0, 0, 5594, 5592, 1, 0, 0, 0, 5594, 5595, 1, 0, 0, 0, 5595, 493, 1, 0, 0, 0, 5596, 5594, 1, 0, 0, 0, 5597, 5598, 5, 138, 0, 0, 5598, 5599, 5, 189, 0, 0, 5599, 5622, 3, 316, 158, 0, 5600, 5623, 3, 94, 47, 0, 5601, 5602, 7, 15, 0, 0, 5602, 5603, 5, 77, 0, 0, 5603, 5623, 5, 78, 0, 0, 5604, 5607, 5, 133, 0, 0, 5605, 5606, 5, 45, 0, 0, 5606, 5608, 3, 818, 409, 0, 5607, 5605, 1, 0, 0, 0, 5607, 5608, 1, 0, 0, 0, 5608, 5609, 1, 0, 0, 0, 5609, 5623, 3, 142, 71, 0, 5610, 5611, 5, 191, 0, 0, 5611, 5613, 5, 45, 0, 0, 5612, 5614, 3, 422, 211, 0, 5613, 5612, 1, 0, 0, 0, 5613, 5614, 1, 0, 0, 0, 5614, 5615, 1, 0, 0, 0, 5615, 5617, 3, 818, 409, 0, 5616, 5618, 3, 96, 48, 0, 5617, 5616, 1, 0, 0, 0, 5617, 5618, 1, 0, 0, 0, 5618, 5623, 1, 0, 0, 0, 5619, 5620, 5, 372, 0, 0, 5620, 5621, 5, 45, 0, 0, 5621, 5623, 3, 818, 409, 0, 5622, 5600, 1, 0, 0, 0, 5622, 5601, 1, 0, 0, 0, 5622, 5604, 1, 0, 0, 0, 5622, 5610, 1, 0, 0, 0, 5622, 5619, 1, 0, 0, 0, 5623, 495, 1, 0, 0, 0, 5624, 5625, 5, 138, 0, 0, 5625, 5626, 5, 355, 0, 0, 5626, 5627, 5, 325, 0, 0, 5627, 5628, 5, 185, 0, 0, 5628, 5629, 3, 316, 158, 0, 5629, 5630, 3, 284, 142, 0, 5630, 497, 1, 0, 0, 0, 5631, 5632, 5, 138, 0, 0, 5632, 5633, 5, 355, 0, 0, 5633, 5634, 5, 325, 0, 0, 5634, 5635, 5, 163, 0, 0, 5635, 5636, 3, 316, 158, 0, 5636, 5637, 7, 72, 0, 0, 5637, 5638, 5, 257, 0, 0, 5638, 5639, 5, 62, 0, 0, 5639, 5640, 3, 784, 392, 0, 5640, 5641, 5, 105, 0, 0, 5641, 5642, 3, 314, 157, 0, 5642, 5673, 1, 0, 0, 0, 5643, 5644, 5, 138, 0, 0, 5644, 5645, 5, 355, 0, 0, 5645, 5646, 5, 325, 0, 0, 5646, 5647, 5, 163, 0, 0, 5647, 5648, 3, 316, 158, 0, 5648, 5649, 5, 138, 0, 0, 5649, 5652, 5, 257, 0, 0, 5650, 5651, 5, 62, 0, 0, 5651, 5653, 3, 784, 392, 0, 5652, 5650, 1, 0, 0, 0, 5652, 5653, 1, 0, 0, 0, 5653, 5654, 1, 0, 0, 0, 5654, 5655, 5, 311, 0, 0, 5655, 5656, 3, 316, 158, 0, 5656, 5657, 5, 105, 0, 0, 5657, 5658, 3, 316, 158, 0, 5658, 5673, 1, 0, 0, 0, 5659, 5660, 5, 138, 0, 0, 5660, 5661, 5, 355, 0, 0, 5661, 5662, 5, 325, 0, 0, 5662, 5663, 5, 163, 0, 0, 5663, 5664, 3, 316, 158, 0, 5664, 5665, 5, 191, 0, 0, 5665, 5667, 5, 257, 0, 0, 5666, 5668, 3, 422, 211, 0, 5667, 5666, 1, 0, 0, 0, 5667, 5668, 1, 0, 0, 0, 5668, 5669, 1, 0, 0, 0, 5669, 5670, 5, 62, 0, 0, 5670, 5671, 3, 784, 392, 0, 5671, 5673, 1, 0, 0, 0, 5672, 5631, 1, 0, 0, 0, 5672, 5643, 1, 0, 0, 0, 5672, 5659, 1, 0, 0, 0, 5673, 499, 1, 0, 0, 0, 5674, 5676, 5, 46, 0, 0, 5675, 5677, 5, 53, 0, 0, 5676, 5675, 1, 0, 0, 0, 5676, 5677, 1, 0, 0, 0, 5677, 5678, 1, 0, 0, 0, 5678, 5679, 5, 168, 0, 0, 5679, 5680, 3, 316, 158, 0, 5680, 5681, 5, 62, 0, 0, 5681, 5682, 3, 808, 404, 0, 5682, 5683, 5, 94, 0, 0, 5683, 5684, 3, 808, 404, 0, 5684, 5685, 5, 64, 0, 0, 5685, 5686, 3, 316, 158, 0, 5686, 501, 1, 0, 0, 0, 5687, 5689, 5, 158, 0, 0, 5688, 5690, 3, 514, 257, 0, 5689, 5688, 1, 0, 0, 0, 5689, 5690, 1, 0, 0, 0, 5690, 5695, 1, 0, 0, 0, 5691, 5693, 3, 774, 387, 0, 5692, 5694, 3, 170, 85, 0, 5693, 5692, 1, 0, 0, 0, 5693, 5694, 1, 0, 0, 0, 5694, 5696, 1, 0, 0, 0, 5695, 5691, 1, 0, 0, 0, 5695, 5696, 1, 0, 0, 0, 5696, 5713, 1, 0, 0, 0, 5697, 5698, 5, 158, 0, 0, 5698, 5699, 5, 2, 0, 0, 5699, 5704, 3, 514, 257, 0, 5700, 5701, 5, 6, 0, 0, 5701, 5703, 3, 514, 257, 0, 5702, 5700, 1, 0, 0, 0, 5703, 5706, 1, 0, 0, 0, 5704, 5702, 1, 0, 0, 0, 5704, 5705, 1, 0, 0, 0, 5705, 5707, 1, 0, 0, 0, 5706, 5704, 1, 0, 0, 0, 5707, 5708, 5, 3, 0, 0, 5708, 5710, 3, 774, 387, 0, 5709, 5711, 3, 170, 85, 0, 5710, 5709, 1, 0, 0, 0, 5710, 5711, 1, 0, 0, 0, 5711, 5713, 1, 0, 0, 0, 5712, 5687, 1, 0, 0, 0, 5712, 5697, 1, 0, 0, 0, 5713, 503, 1, 0, 0, 0, 5714, 5730, 5, 370, 0, 0, 5715, 5717, 5, 113, 0, 0, 5716, 5715, 1, 0, 0, 0, 5716, 5717, 1, 0, 0, 0, 5717, 5719, 1, 0, 0, 0, 5718, 5720, 5, 112, 0, 0, 5719, 5718, 1, 0, 0, 0, 5719, 5720, 1, 0, 0, 0, 5720, 5722, 1, 0, 0, 0, 5721, 5723, 3, 514, 257, 0, 5722, 5721, 1, 0, 0, 0, 5722, 5723, 1, 0, 0, 0, 5723, 5725, 1, 0, 0, 0, 5724, 5726, 3, 508, 254, 0, 5725, 5724, 1, 0, 0, 0, 5725, 5726, 1, 0, 0, 0, 5726, 5731, 1, 0, 0, 0, 5727, 5729, 3, 524, 262, 0, 5728, 5727, 1, 0, 0, 0, 5728, 5729, 1, 0, 0, 0, 5729, 5731, 1, 0, 0, 0, 5730, 5716, 1, 0, 0, 0, 5730, 5728, 1, 0, 0, 0, 5731, 5733, 1, 0, 0, 0, 5732, 5734, 3, 518, 259, 0, 5733, 5732, 1, 0, 0, 0, 5733, 5734, 1, 0, 0, 0, 5734, 505, 1, 0, 0, 0, 5735, 5750, 3, 508, 254, 0, 5736, 5738, 3, 514, 257, 0, 5737, 5736, 1, 0, 0, 0, 5737, 5738, 1, 0, 0, 0, 5738, 5751, 1, 0, 0, 0, 5739, 5740, 5, 2, 0, 0, 5740, 5745, 3, 512, 256, 0, 5741, 5742, 5, 6, 0, 0, 5742, 5744, 3, 512, 256, 0, 5743, 5741, 1, 0, 0, 0, 5744, 5747, 1, 0, 0, 0, 5745, 5743, 1, 0, 0, 0, 5745, 5746, 1, 0, 0, 0, 5746, 5748, 1, 0, 0, 0, 5747, 5745, 1, 0, 0, 0, 5748, 5749, 5, 3, 0, 0, 5749, 5751, 1, 0, 0, 0, 5750, 5737, 1, 0, 0, 0, 5750, 5739, 1, 0, 0, 0, 5751, 5753, 1, 0, 0, 0, 5752, 5754, 3, 518, 259, 0, 5753, 5752, 1, 0, 0, 0, 5753, 5754, 1, 0, 0, 0, 5754, 507, 1, 0, 0, 0, 5755, 5756, 7, 73, 0, 0, 5756, 509, 1, 0, 0, 0, 5757, 5760, 3, 822, 411, 0, 5758, 5760, 3, 508, 254, 0, 5759, 5757, 1, 0, 0, 0, 5759, 5758, 1, 0, 0, 0, 5760, 5763, 1, 0, 0, 0, 5761, 5764, 3, 54, 27, 0, 5762, 5764, 3, 202, 101, 0, 5763, 5761, 1, 0, 0, 0, 5763, 5762, 1, 0, 0, 0, 5763, 5764, 1, 0, 0, 0, 5764, 511, 1, 0, 0, 0, 5765, 5767, 7, 74, 0, 0, 5766, 5768, 7, 75, 0, 0, 5767, 5766, 1, 0, 0, 0, 5767, 5768, 1, 0, 0, 0, 5768, 5775, 1, 0, 0, 0, 5769, 5772, 5, 548, 0, 0, 5770, 5773, 3, 202, 101, 0, 5771, 5773, 3, 808, 404, 0, 5772, 5770, 1, 0, 0, 0, 5772, 5771, 1, 0, 0, 0, 5773, 5775, 1, 0, 0, 0, 5774, 5765, 1, 0, 0, 0, 5774, 5769, 1, 0, 0, 0, 5775, 513, 1, 0, 0, 0, 5776, 5778, 5, 128, 0, 0, 5777, 5779, 7, 75, 0, 0, 5778, 5777, 1, 0, 0, 0, 5778, 5779, 1, 0, 0, 0, 5779, 515, 1, 0, 0, 0, 5780, 5782, 3, 774, 387, 0, 5781, 5783, 3, 144, 72, 0, 5782, 5781, 1, 0, 0, 0, 5782, 5783, 1, 0, 0, 0, 5783, 517, 1, 0, 0, 0, 5784, 5789, 3, 516, 258, 0, 5785, 5786, 5, 6, 0, 0, 5786, 5788, 3, 516, 258, 0, 5787, 5785, 1, 0, 0, 0, 5788, 5791, 1, 0, 0, 0, 5789, 5787, 1, 0, 0, 0, 5789, 5790, 1, 0, 0, 0, 5790, 519, 1, 0, 0, 0, 5791, 5789, 1, 0, 0, 0, 5792, 5803, 5, 203, 0, 0, 5793, 5804, 3, 524, 262, 0, 5794, 5796, 5, 128, 0, 0, 5795, 5794, 1, 0, 0, 0, 5795, 5796, 1, 0, 0, 0, 5796, 5804, 1, 0, 0, 0, 5797, 5799, 3, 508, 254, 0, 5798, 5800, 3, 514, 257, 0, 5799, 5798, 1, 0, 0, 0, 5799, 5800, 1, 0, 0, 0, 5800, 5802, 1, 0, 0, 0, 5801, 5797, 1, 0, 0, 0, 5801, 5802, 1, 0, 0, 0, 5802, 5804, 1, 0, 0, 0, 5803, 5793, 1, 0, 0, 0, 5803, 5795, 1, 0, 0, 0, 5803, 5801, 1, 0, 0, 0, 5804, 5805, 1, 0, 0, 0, 5805, 5806, 3, 522, 261, 0, 5806, 521, 1, 0, 0, 0, 5807, 5817, 3, 560, 280, 0, 5808, 5817, 3, 538, 269, 0, 5809, 5817, 3, 552, 276, 0, 5810, 5817, 3, 548, 274, 0, 5811, 5817, 3, 558, 279, 0, 5812, 5817, 3, 186, 93, 0, 5813, 5817, 3, 192, 96, 0, 5814, 5817, 3, 194, 97, 0, 5815, 5817, 3, 532, 266, 0, 5816, 5807, 1, 0, 0, 0, 5816, 5808, 1, 0, 0, 0, 5816, 5809, 1, 0, 0, 0, 5816, 5810, 1, 0, 0, 0, 5816, 5811, 1, 0, 0, 0, 5816, 5812, 1, 0, 0, 0, 5816, 5813, 1, 0, 0, 0, 5816, 5814, 1, 0, 0, 0, 5816, 5815, 1, 0, 0, 0, 5817, 523, 1, 0, 0, 0, 5818, 5819, 5, 2, 0, 0, 5819, 5824, 3, 510, 255, 0, 5820, 5821, 5, 6, 0, 0, 5821, 5823, 3, 510, 255, 0, 5822, 5820, 1, 0, 0, 0, 5823, 5826, 1, 0, 0, 0, 5824, 5822, 1, 0, 0, 0, 5824, 5825, 1, 0, 0, 0, 5825, 5827, 1, 0, 0, 0, 5826, 5824, 1, 0, 0, 0, 5827, 5828, 5, 3, 0, 0, 5828, 525, 1, 0, 0, 0, 5829, 5830, 5, 290, 0, 0, 5830, 5832, 3, 818, 409, 0, 5831, 5833, 3, 528, 264, 0, 5832, 5831, 1, 0, 0, 0, 5832, 5833, 1, 0, 0, 0, 5833, 5834, 1, 0, 0, 0, 5834, 5835, 5, 36, 0, 0, 5835, 5836, 3, 530, 265, 0, 5836, 527, 1, 0, 0, 0, 5837, 5838, 5, 2, 0, 0, 5838, 5843, 3, 652, 326, 0, 5839, 5840, 5, 6, 0, 0, 5840, 5842, 3, 652, 326, 0, 5841, 5839, 1, 0, 0, 0, 5842, 5845, 1, 0, 0, 0, 5843, 5841, 1, 0, 0, 0, 5843, 5844, 1, 0, 0, 0, 5844, 5846, 1, 0, 0, 0, 5845, 5843, 1, 0, 0, 0, 5846, 5847, 5, 3, 0, 0, 5847, 529, 1, 0, 0, 0, 5848, 5853, 3, 560, 280, 0, 5849, 5853, 3, 538, 269, 0, 5850, 5853, 3, 552, 276, 0, 5851, 5853, 3, 548, 274, 0, 5852, 5848, 1, 0, 0, 0, 5852, 5849, 1, 0, 0, 0, 5852, 5850, 1, 0, 0, 0, 5852, 5851, 1, 0, 0, 0, 5853, 531, 1, 0, 0, 0, 5854, 5855, 5, 202, 0, 0, 5855, 5857, 3, 818, 409, 0, 5856, 5858, 3, 534, 267, 0, 5857, 5856, 1, 0, 0, 0, 5857, 5858, 1, 0, 0, 0, 5858, 5878, 1, 0, 0, 0, 5859, 5861, 5, 46, 0, 0, 5860, 5862, 3, 122, 61, 0, 5861, 5860, 1, 0, 0, 0, 5861, 5862, 1, 0, 0, 0, 5862, 5863, 1, 0, 0, 0, 5863, 5865, 5, 92, 0, 0, 5864, 5866, 3, 294, 147, 0, 5865, 5864, 1, 0, 0, 0, 5865, 5866, 1, 0, 0, 0, 5866, 5867, 1, 0, 0, 0, 5867, 5868, 3, 188, 94, 0, 5868, 5869, 5, 36, 0, 0, 5869, 5870, 5, 202, 0, 0, 5870, 5872, 3, 818, 409, 0, 5871, 5873, 3, 534, 267, 0, 5872, 5871, 1, 0, 0, 0, 5872, 5873, 1, 0, 0, 0, 5873, 5875, 1, 0, 0, 0, 5874, 5876, 3, 190, 95, 0, 5875, 5874, 1, 0, 0, 0, 5875, 5876, 1, 0, 0, 0, 5876, 5878, 1, 0, 0, 0, 5877, 5854, 1, 0, 0, 0, 5877, 5859, 1, 0, 0, 0, 5878, 533, 1, 0, 0, 0, 5879, 5880, 5, 2, 0, 0, 5880, 5881, 3, 730, 365, 0, 5881, 5882, 5, 3, 0, 0, 5882, 535, 1, 0, 0, 0, 5883, 5885, 5, 177, 0, 0, 5884, 5886, 5, 290, 0, 0, 5885, 5884, 1, 0, 0, 0, 5885, 5886, 1, 0, 0, 0, 5886, 5889, 1, 0, 0, 0, 5887, 5890, 3, 818, 409, 0, 5888, 5890, 5, 30, 0, 0, 5889, 5887, 1, 0, 0, 0, 5889, 5888, 1, 0, 0, 0, 5890, 537, 1, 0, 0, 0, 5891, 5893, 3, 572, 286, 0, 5892, 5891, 1, 0, 0, 0, 5892, 5893, 1, 0, 0, 0, 5893, 5894, 1, 0, 0, 0, 5894, 5895, 5, 241, 0, 0, 5895, 5896, 5, 71, 0, 0, 5896, 5899, 3, 774, 387, 0, 5897, 5898, 5, 36, 0, 0, 5898, 5900, 3, 818, 409, 0, 5899, 5897, 1, 0, 0, 0, 5899, 5900, 1, 0, 0, 0, 5900, 5901, 1, 0, 0, 0, 5901, 5923, 3, 540, 270, 0, 5902, 5903, 5, 80, 0, 0, 5903, 5911, 5, 464, 0, 0, 5904, 5906, 3, 360, 180, 0, 5905, 5907, 3, 638, 319, 0, 5906, 5905, 1, 0, 0, 0, 5906, 5907, 1, 0, 0, 0, 5907, 5912, 1, 0, 0, 0, 5908, 5909, 5, 80, 0, 0, 5909, 5910, 5, 45, 0, 0, 5910, 5912, 3, 818, 409, 0, 5911, 5904, 1, 0, 0, 0, 5911, 5908, 1, 0, 0, 0, 5911, 5912, 1, 0, 0, 0, 5912, 5913, 1, 0, 0, 0, 5913, 5921, 5, 57, 0, 0, 5914, 5915, 5, 369, 0, 0, 5915, 5916, 5, 333, 0, 0, 5916, 5918, 3, 554, 277, 0, 5917, 5919, 3, 638, 319, 0, 5918, 5917, 1, 0, 0, 0, 5918, 5919, 1, 0, 0, 0, 5919, 5922, 1, 0, 0, 0, 5920, 5922, 5, 270, 0, 0, 5921, 5914, 1, 0, 0, 0, 5921, 5920, 1, 0, 0, 0, 5922, 5924, 1, 0, 0, 0, 5923, 5902, 1, 0, 0, 0, 5923, 5924, 1, 0, 0, 0, 5924, 5926, 1, 0, 0, 0, 5925, 5927, 3, 546, 273, 0, 5926, 5925, 1, 0, 0, 0, 5926, 5927, 1, 0, 0, 0, 5927, 539, 1, 0, 0, 0, 5928, 5929, 5, 2, 0, 0, 5929, 5930, 3, 542, 271, 0, 5930, 5931, 5, 3, 0, 0, 5931, 5933, 1, 0, 0, 0, 5932, 5928, 1, 0, 0, 0, 5932, 5933, 1, 0, 0, 0, 5933, 5937, 1, 0, 0, 0, 5934, 5935, 5, 463, 0, 0, 5935, 5936, 7, 76, 0, 0, 5936, 5938, 5, 450, 0, 0, 5937, 5934, 1, 0, 0, 0, 5937, 5938, 1, 0, 0, 0, 5938, 5941, 1, 0, 0, 0, 5939, 5942, 3, 910, 455, 0, 5940, 5942, 3, 560, 280, 0, 5941, 5939, 1, 0, 0, 0, 5941, 5940, 1, 0, 0, 0, 5942, 541, 1, 0, 0, 0, 5943, 5948, 3, 544, 272, 0, 5944, 5945, 5, 6, 0, 0, 5945, 5947, 3, 544, 272, 0, 5946, 5944, 1, 0, 0, 0, 5947, 5950, 1, 0, 0, 0, 5948, 5946, 1, 0, 0, 0, 5948, 5949, 1, 0, 0, 0, 5949, 543, 1, 0, 0, 0, 5950, 5948, 1, 0, 0, 0, 5951, 5952, 3, 800, 400, 0, 5952, 5953, 3, 754, 377, 0, 5953, 545, 1, 0, 0, 0, 5954, 5955, 5, 87, 0, 0, 5955, 5956, 3, 756, 378, 0, 5956, 547, 1, 0, 0, 0, 5957, 5959, 3, 572, 286, 0, 5958, 5957, 1, 0, 0, 0, 5958, 5959, 1, 0, 0, 0, 5959, 5960, 1, 0, 0, 0, 5960, 5961, 5, 182, 0, 0, 5961, 5962, 5, 64, 0, 0, 5962, 5965, 3, 630, 315, 0, 5963, 5964, 5, 100, 0, 0, 5964, 5966, 3, 612, 306, 0, 5965, 5963, 1, 0, 0, 0, 5965, 5966, 1, 0, 0, 0, 5966, 5968, 1, 0, 0, 0, 5967, 5969, 3, 640, 320, 0, 5968, 5967, 1, 0, 0, 0, 5968, 5969, 1, 0, 0, 0, 5969, 5971, 1, 0, 0, 0, 5970, 5972, 3, 546, 273, 0, 5971, 5970, 1, 0, 0, 0, 5971, 5972, 1, 0, 0, 0, 5972, 549, 1, 0, 0, 0, 5973, 5975, 5, 256, 0, 0, 5974, 5976, 5, 92, 0, 0, 5975, 5974, 1, 0, 0, 0, 5975, 5976, 1, 0, 0, 0, 5976, 5977, 1, 0, 0, 0, 5977, 5992, 3, 628, 314, 0, 5978, 5989, 5, 68, 0, 0, 5979, 5980, 7, 77, 0, 0, 5980, 5990, 7, 78, 0, 0, 5981, 5986, 5, 334, 0, 0, 5982, 5983, 5, 369, 0, 0, 5983, 5987, 5, 201, 0, 0, 5984, 5985, 5, 414, 0, 0, 5985, 5987, 5, 201, 0, 0, 5986, 5982, 1, 0, 0, 0, 5986, 5984, 1, 0, 0, 0, 5986, 5987, 1, 0, 0, 0, 5987, 5990, 1, 0, 0, 0, 5988, 5990, 5, 201, 0, 0, 5989, 5979, 1, 0, 0, 0, 5989, 5981, 1, 0, 0, 0, 5989, 5988, 1, 0, 0, 0, 5990, 5991, 1, 0, 0, 0, 5991, 5993, 5, 263, 0, 0, 5992, 5978, 1, 0, 0, 0, 5992, 5993, 1, 0, 0, 0, 5993, 5995, 1, 0, 0, 0, 5994, 5996, 5, 272, 0, 0, 5995, 5994, 1, 0, 0, 0, 5995, 5996, 1, 0, 0, 0, 5996, 551, 1, 0, 0, 0, 5997, 5999, 3, 572, 286, 0, 5998, 5997, 1, 0, 0, 0, 5998, 5999, 1, 0, 0, 0, 5999, 6000, 1, 0, 0, 0, 6000, 6001, 5, 369, 0, 0, 6001, 6002, 3, 630, 315, 0, 6002, 6003, 5, 333, 0, 0, 6003, 6005, 3, 554, 277, 0, 6004, 6006, 3, 610, 305, 0, 6005, 6004, 1, 0, 0, 0, 6005, 6006, 1, 0, 0, 0, 6006, 6008, 1, 0, 0, 0, 6007, 6009, 3, 640, 320, 0, 6008, 6007, 1, 0, 0, 0, 6008, 6009, 1, 0, 0, 0, 6009, 6011, 1, 0, 0, 0, 6010, 6012, 3, 546, 273, 0, 6011, 6010, 1, 0, 0, 0, 6011, 6012, 1, 0, 0, 0, 6012, 553, 1, 0, 0, 0, 6013, 6018, 3, 556, 278, 0, 6014, 6015, 5, 6, 0, 0, 6015, 6017, 3, 556, 278, 0, 6016, 6014, 1, 0, 0, 0, 6017, 6020, 1, 0, 0, 0, 6018, 6016, 1, 0, 0, 0, 6018, 6019, 1, 0, 0, 0, 6019, 555, 1, 0, 0, 0, 6020, 6018, 1, 0, 0, 0, 6021, 6022, 3, 544, 272, 0, 6022, 6023, 5, 10, 0, 0, 6023, 6024, 3, 674, 337, 0, 6024, 6040, 1, 0, 0, 0, 6025, 6026, 5, 2, 0, 0, 6026, 6027, 3, 542, 271, 0, 6027, 6028, 5, 3, 0, 0, 6028, 6037, 5, 10, 0, 0, 6029, 6031, 5, 414, 0, 0, 6030, 6029, 1, 0, 0, 0, 6030, 6031, 1, 0, 0, 0, 6031, 6032, 1, 0, 0, 0, 6032, 6038, 3, 674, 337, 0, 6033, 6034, 5, 2, 0, 0, 6034, 6035, 3, 566, 283, 0, 6035, 6036, 5, 3, 0, 0, 6036, 6038, 1, 0, 0, 0, 6037, 6030, 1, 0, 0, 0, 6037, 6033, 1, 0, 0, 0, 6038, 6040, 1, 0, 0, 0, 6039, 6021, 1, 0, 0, 0, 6039, 6025, 1, 0, 0, 0, 6040, 557, 1, 0, 0, 0, 6041, 6042, 5, 178, 0, 0, 6042, 6051, 3, 818, 409, 0, 6043, 6045, 5, 269, 0, 0, 6044, 6043, 1, 0, 0, 0, 6044, 6045, 1, 0, 0, 0, 6045, 6046, 1, 0, 0, 0, 6046, 6050, 5, 324, 0, 0, 6047, 6050, 5, 107, 0, 0, 6048, 6050, 5, 240, 0, 0, 6049, 6044, 1, 0, 0, 0, 6049, 6047, 1, 0, 0, 0, 6049, 6048, 1, 0, 0, 0, 6050, 6053, 1, 0, 0, 0, 6051, 6049, 1, 0, 0, 0, 6051, 6052, 1, 0, 0, 0, 6052, 6054, 1, 0, 0, 0, 6053, 6051, 1, 0, 0, 0, 6054, 6057, 5, 172, 0, 0, 6055, 6056, 7, 26, 0, 0, 6056, 6058, 5, 217, 0, 0, 6057, 6055, 1, 0, 0, 0, 6057, 6058, 1, 0, 0, 0, 6058, 6059, 1, 0, 0, 0, 6059, 6060, 5, 62, 0, 0, 6060, 6061, 3, 560, 280, 0, 6061, 559, 1, 0, 0, 0, 6062, 6065, 3, 564, 282, 0, 6063, 6065, 3, 562, 281, 0, 6064, 6062, 1, 0, 0, 0, 6064, 6063, 1, 0, 0, 0, 6065, 561, 1, 0, 0, 0, 6066, 6069, 5, 2, 0, 0, 6067, 6070, 3, 564, 282, 0, 6068, 6070, 3, 562, 281, 0, 6069, 6067, 1, 0, 0, 0, 6069, 6068, 1, 0, 0, 0, 6070, 6071, 1, 0, 0, 0, 6071, 6072, 5, 3, 0, 0, 6072, 563, 1, 0, 0, 0, 6073, 6075, 3, 572, 286, 0, 6074, 6073, 1, 0, 0, 0, 6074, 6075, 1, 0, 0, 0, 6075, 6076, 1, 0, 0, 0, 6076, 6078, 3, 566, 283, 0, 6077, 6079, 3, 586, 293, 0, 6078, 6077, 1, 0, 0, 0, 6078, 6079, 1, 0, 0, 0, 6079, 6088, 1, 0, 0, 0, 6080, 6082, 3, 606, 303, 0, 6081, 6083, 3, 590, 295, 0, 6082, 6081, 1, 0, 0, 0, 6082, 6083, 1, 0, 0, 0, 6083, 6089, 1, 0, 0, 0, 6084, 6086, 3, 590, 295, 0, 6085, 6087, 3, 606, 303, 0, 6086, 6085, 1, 0, 0, 0, 6086, 6087, 1, 0, 0, 0, 6087, 6089, 1, 0, 0, 0, 6088, 6080, 1, 0, 0, 0, 6088, 6084, 1, 0, 0, 0, 6088, 6089, 1, 0, 0, 0, 6089, 565, 1, 0, 0, 0, 6090, 6093, 3, 568, 284, 0, 6091, 6093, 3, 562, 281, 0, 6092, 6090, 1, 0, 0, 0, 6092, 6091, 1, 0, 0, 0, 6093, 567, 1, 0, 0, 0, 6094, 6104, 5, 88, 0, 0, 6095, 6097, 5, 30, 0, 0, 6096, 6095, 1, 0, 0, 0, 6096, 6097, 1, 0, 0, 0, 6097, 6099, 1, 0, 0, 0, 6098, 6100, 3, 580, 290, 0, 6099, 6098, 1, 0, 0, 0, 6099, 6100, 1, 0, 0, 0, 6100, 6105, 1, 0, 0, 0, 6101, 6103, 3, 584, 292, 0, 6102, 6101, 1, 0, 0, 0, 6102, 6103, 1, 0, 0, 0, 6103, 6105, 1, 0, 0, 0, 6104, 6096, 1, 0, 0, 0, 6104, 6102, 1, 0, 0, 0, 6105, 6106, 1, 0, 0, 0, 6106, 6117, 3, 930, 465, 0, 6107, 6117, 3, 608, 304, 0, 6108, 6109, 5, 92, 0, 0, 6109, 6117, 3, 624, 312, 0, 6110, 6111, 3, 562, 281, 0, 6111, 6114, 3, 570, 285, 0, 6112, 6115, 3, 568, 284, 0, 6113, 6115, 3, 562, 281, 0, 6114, 6112, 1, 0, 0, 0, 6114, 6113, 1, 0, 0, 0, 6115, 6117, 1, 0, 0, 0, 6116, 6094, 1, 0, 0, 0, 6116, 6107, 1, 0, 0, 0, 6116, 6108, 1, 0, 0, 0, 6116, 6110, 1, 0, 0, 0, 6117, 6125, 1, 0, 0, 0, 6118, 6121, 3, 570, 285, 0, 6119, 6122, 3, 568, 284, 0, 6120, 6122, 3, 562, 281, 0, 6121, 6119, 1, 0, 0, 0, 6121, 6120, 1, 0, 0, 0, 6122, 6124, 1, 0, 0, 0, 6123, 6118, 1, 0, 0, 0, 6124, 6127, 1, 0, 0, 0, 6125, 6123, 1, 0, 0, 0, 6125, 6126, 1, 0, 0, 0, 6126, 569, 1, 0, 0, 0, 6127, 6125, 1, 0, 0, 0, 6128, 6130, 7, 79, 0, 0, 6129, 6131, 7, 80, 0, 0, 6130, 6129, 1, 0, 0, 0, 6130, 6131, 1, 0, 0, 0, 6131, 571, 1, 0, 0, 0, 6132, 6134, 5, 105, 0, 0, 6133, 6135, 5, 303, 0, 0, 6134, 6133, 1, 0, 0, 0, 6134, 6135, 1, 0, 0, 0, 6135, 6136, 1, 0, 0, 0, 6136, 6141, 3, 574, 287, 0, 6137, 6138, 5, 6, 0, 0, 6138, 6140, 3, 574, 287, 0, 6139, 6137, 1, 0, 0, 0, 6140, 6143, 1, 0, 0, 0, 6141, 6139, 1, 0, 0, 0, 6141, 6142, 1, 0, 0, 0, 6142, 573, 1, 0, 0, 0, 6143, 6141, 1, 0, 0, 0, 6144, 6146, 3, 818, 409, 0, 6145, 6147, 3, 144, 72, 0, 6146, 6145, 1, 0, 0, 0, 6146, 6147, 1, 0, 0, 0, 6147, 6148, 1, 0, 0, 0, 6148, 6153, 5, 36, 0, 0, 6149, 6151, 5, 77, 0, 0, 6150, 6149, 1, 0, 0, 0, 6150, 6151, 1, 0, 0, 0, 6151, 6152, 1, 0, 0, 0, 6152, 6154, 5, 259, 0, 0, 6153, 6150, 1, 0, 0, 0, 6153, 6154, 1, 0, 0, 0, 6154, 6155, 1, 0, 0, 0, 6155, 6156, 5, 2, 0, 0, 6156, 6157, 3, 530, 265, 0, 6157, 6159, 5, 3, 0, 0, 6158, 6160, 3, 576, 288, 0, 6159, 6158, 1, 0, 0, 0, 6159, 6160, 1, 0, 0, 0, 6160, 6162, 1, 0, 0, 0, 6161, 6163, 3, 578, 289, 0, 6162, 6161, 1, 0, 0, 0, 6162, 6163, 1, 0, 0, 0, 6163, 575, 1, 0, 0, 0, 6164, 6165, 5, 325, 0, 0, 6165, 6166, 7, 81, 0, 0, 6166, 6167, 5, 207, 0, 0, 6167, 6168, 5, 147, 0, 0, 6168, 6169, 3, 148, 74, 0, 6169, 6170, 5, 333, 0, 0, 6170, 6171, 3, 800, 400, 0, 6171, 577, 1, 0, 0, 0, 6172, 6173, 5, 173, 0, 0, 6173, 6174, 3, 148, 74, 0, 6174, 6175, 5, 333, 0, 0, 6175, 6181, 3, 800, 400, 0, 6176, 6177, 5, 94, 0, 0, 6177, 6178, 3, 818, 409, 0, 6178, 6179, 5, 53, 0, 0, 6179, 6180, 3, 818, 409, 0, 6180, 6182, 1, 0, 0, 0, 6181, 6176, 1, 0, 0, 0, 6181, 6182, 1, 0, 0, 0, 6182, 6183, 1, 0, 0, 0, 6183, 6184, 5, 100, 0, 0, 6184, 6185, 3, 800, 400, 0, 6185, 579, 1, 0, 0, 0, 6186, 6192, 5, 71, 0, 0, 6187, 6189, 5, 346, 0, 0, 6188, 6187, 1, 0, 0, 0, 6188, 6189, 1, 0, 0, 0, 6189, 6190, 1, 0, 0, 0, 6190, 6193, 3, 582, 291, 0, 6191, 6193, 3, 730, 365, 0, 6192, 6188, 1, 0, 0, 0, 6192, 6191, 1, 0, 0, 0, 6193, 581, 1, 0, 0, 0, 6194, 6196, 7, 20, 0, 0, 6195, 6194, 1, 0, 0, 0, 6195, 6196, 1, 0, 0, 0, 6196, 6197, 1, 0, 0, 0, 6197, 6199, 7, 21, 0, 0, 6198, 6200, 5, 92, 0, 0, 6199, 6198, 1, 0, 0, 0, 6199, 6200, 1, 0, 0, 0, 6200, 6201, 1, 0, 0, 0, 6201, 6210, 3, 772, 386, 0, 6202, 6204, 5, 367, 0, 0, 6203, 6202, 1, 0, 0, 0, 6203, 6204, 1, 0, 0, 0, 6204, 6206, 1, 0, 0, 0, 6205, 6207, 5, 92, 0, 0, 6206, 6205, 1, 0, 0, 0, 6206, 6207, 1, 0, 0, 0, 6207, 6208, 1, 0, 0, 0, 6208, 6210, 3, 772, 386, 0, 6209, 6195, 1, 0, 0, 0, 6209, 6203, 1, 0, 0, 0, 6210, 583, 1, 0, 0, 0, 6211, 6214, 5, 56, 0, 0, 6212, 6213, 5, 80, 0, 0, 6213, 6215, 3, 534, 267, 0, 6214, 6212, 1, 0, 0, 0, 6214, 6215, 1, 0, 0, 0, 6215, 585, 1, 0, 0, 0, 6216, 6217, 5, 83, 0, 0, 6217, 6218, 5, 147, 0, 0, 6218, 6223, 3, 588, 294, 0, 6219, 6220, 5, 6, 0, 0, 6220, 6222, 3, 588, 294, 0, 6221, 6219, 1, 0, 0, 0, 6222, 6225, 1, 0, 0, 0, 6223, 6221, 1, 0, 0, 0, 6223, 6224, 1, 0, 0, 0, 6224, 587, 1, 0, 0, 0, 6225, 6223, 1, 0, 0, 0, 6226, 6230, 3, 734, 367, 0, 6227, 6228, 5, 100, 0, 0, 6228, 6231, 3, 726, 363, 0, 6229, 6231, 7, 55, 0, 0, 6230, 6227, 1, 0, 0, 0, 6230, 6229, 1, 0, 0, 0, 6230, 6231, 1, 0, 0, 0, 6231, 6234, 1, 0, 0, 0, 6232, 6233, 5, 273, 0, 0, 6233, 6235, 7, 56, 0, 0, 6234, 6232, 1, 0, 0, 0, 6234, 6235, 1, 0, 0, 0, 6235, 589, 1, 0, 0, 0, 6236, 6238, 3, 596, 298, 0, 6237, 6239, 3, 594, 297, 0, 6238, 6237, 1, 0, 0, 0, 6238, 6239, 1, 0, 0, 0, 6239, 6248, 1, 0, 0, 0, 6240, 6243, 3, 592, 296, 0, 6241, 6243, 3, 594, 297, 0, 6242, 6240, 1, 0, 0, 0, 6242, 6241, 1, 0, 0, 0, 6243, 6245, 1, 0, 0, 0, 6244, 6246, 3, 596, 298, 0, 6245, 6244, 1, 0, 0, 0, 6245, 6246, 1, 0, 0, 0, 6246, 6248, 1, 0, 0, 0, 6247, 6236, 1, 0, 0, 0, 6247, 6242, 1, 0, 0, 0, 6248, 591, 1, 0, 0, 0, 6249, 6252, 5, 74, 0, 0, 6250, 6253, 3, 674, 337, 0, 6251, 6253, 5, 30, 0, 0, 6252, 6250, 1, 0, 0, 0, 6252, 6251, 1, 0, 0, 0, 6253, 6256, 1, 0, 0, 0, 6254, 6255, 5, 6, 0, 0, 6255, 6257, 3, 674, 337, 0, 6256, 6254, 1, 0, 0, 0, 6256, 6257, 1, 0, 0, 0, 6257, 593, 1, 0, 0, 0, 6258, 6259, 5, 61, 0, 0, 6259, 6261, 7, 82, 0, 0, 6260, 6262, 3, 598, 299, 0, 6261, 6260, 1, 0, 0, 0, 6261, 6262, 1, 0, 0, 0, 6262, 6263, 1, 0, 0, 0, 6263, 6267, 7, 83, 0, 0, 6264, 6268, 5, 81, 0, 0, 6265, 6266, 5, 105, 0, 0, 6266, 6268, 5, 467, 0, 0, 6267, 6264, 1, 0, 0, 0, 6267, 6265, 1, 0, 0, 0, 6268, 595, 1, 0, 0, 0, 6269, 6274, 5, 79, 0, 0, 6270, 6271, 3, 598, 299, 0, 6271, 6272, 7, 83, 0, 0, 6272, 6275, 1, 0, 0, 0, 6273, 6275, 3, 674, 337, 0, 6274, 6270, 1, 0, 0, 0, 6274, 6273, 1, 0, 0, 0, 6275, 597, 1, 0, 0, 0, 6276, 6277, 7, 29, 0, 0, 6277, 6280, 7, 84, 0, 0, 6278, 6280, 3, 682, 341, 0, 6279, 6276, 1, 0, 0, 0, 6279, 6278, 1, 0, 0, 0, 6280, 599, 1, 0, 0, 0, 6281, 6282, 5, 66, 0, 0, 6282, 6284, 5, 147, 0, 0, 6283, 6285, 7, 80, 0, 0, 6284, 6283, 1, 0, 0, 0, 6284, 6285, 1, 0, 0, 0, 6285, 6286, 1, 0, 0, 0, 6286, 6287, 3, 602, 301, 0, 6287, 601, 1, 0, 0, 0, 6288, 6293, 3, 604, 302, 0, 6289, 6290, 5, 6, 0, 0, 6290, 6292, 3, 604, 302, 0, 6291, 6289, 1, 0, 0, 0, 6292, 6295, 1, 0, 0, 0, 6293, 6291, 1, 0, 0, 0, 6293, 6294, 1, 0, 0, 0, 6294, 603, 1, 0, 0, 0, 6295, 6293, 1, 0, 0, 0, 6296, 6320, 3, 734, 367, 0, 6297, 6298, 5, 2, 0, 0, 6298, 6320, 5, 3, 0, 0, 6299, 6301, 7, 85, 0, 0, 6300, 6299, 1, 0, 0, 0, 6300, 6301, 1, 0, 0, 0, 6301, 6302, 1, 0, 0, 0, 6302, 6303, 5, 2, 0, 0, 6303, 6308, 3, 734, 367, 0, 6304, 6305, 5, 6, 0, 0, 6305, 6307, 3, 734, 367, 0, 6306, 6304, 1, 0, 0, 0, 6307, 6310, 1, 0, 0, 0, 6308, 6306, 1, 0, 0, 0, 6308, 6309, 1, 0, 0, 0, 6309, 6311, 1, 0, 0, 0, 6310, 6308, 1, 0, 0, 0, 6311, 6312, 5, 3, 0, 0, 6312, 6320, 1, 0, 0, 0, 6313, 6314, 5, 470, 0, 0, 6314, 6315, 5, 471, 0, 0, 6315, 6316, 5, 2, 0, 0, 6316, 6317, 3, 602, 301, 0, 6317, 6318, 5, 3, 0, 0, 6318, 6320, 1, 0, 0, 0, 6319, 6296, 1, 0, 0, 0, 6319, 6297, 1, 0, 0, 0, 6319, 6300, 1, 0, 0, 0, 6319, 6313, 1, 0, 0, 0, 6320, 605, 1, 0, 0, 0, 6321, 6331, 5, 62, 0, 0, 6322, 6323, 5, 269, 0, 0, 6323, 6325, 5, 245, 0, 0, 6324, 6322, 1, 0, 0, 0, 6324, 6325, 1, 0, 0, 0, 6325, 6326, 1, 0, 0, 0, 6326, 6332, 5, 369, 0, 0, 6327, 6329, 5, 245, 0, 0, 6328, 6327, 1, 0, 0, 0, 6328, 6329, 1, 0, 0, 0, 6329, 6330, 1, 0, 0, 0, 6330, 6332, 5, 334, 0, 0, 6331, 6324, 1, 0, 0, 0, 6331, 6328, 1, 0, 0, 0, 6332, 6335, 1, 0, 0, 0, 6333, 6334, 5, 275, 0, 0, 6334, 6336, 3, 760, 380, 0, 6335, 6333, 1, 0, 0, 0, 6335, 6336, 1, 0, 0, 0, 6336, 6340, 1, 0, 0, 0, 6337, 6341, 5, 272, 0, 0, 6338, 6339, 5, 465, 0, 0, 6339, 6341, 5, 466, 0, 0, 6340, 6337, 1, 0, 0, 0, 6340, 6338, 1, 0, 0, 0, 6340, 6341, 1, 0, 0, 0, 6341, 6343, 1, 0, 0, 0, 6342, 6321, 1, 0, 0, 0, 6343, 6344, 1, 0, 0, 0, 6344, 6342, 1, 0, 0, 0, 6344, 6345, 1, 0, 0, 0, 6345, 6350, 1, 0, 0, 0, 6346, 6347, 5, 62, 0, 0, 6347, 6348, 5, 300, 0, 0, 6348, 6350, 5, 81, 0, 0, 6349, 6342, 1, 0, 0, 0, 6349, 6346, 1, 0, 0, 0, 6350, 607, 1, 0, 0, 0, 6351, 6352, 5, 422, 0, 0, 6352, 6357, 3, 534, 267, 0, 6353, 6354, 5, 6, 0, 0, 6354, 6356, 3, 534, 267, 0, 6355, 6353, 1, 0, 0, 0, 6356, 6359, 1, 0, 0, 0, 6357, 6355, 1, 0, 0, 0, 6357, 6358, 1, 0, 0, 0, 6358, 609, 1, 0, 0, 0, 6359, 6357, 1, 0, 0, 0, 6360, 6361, 5, 64, 0, 0, 6361, 6362, 3, 612, 306, 0, 6362, 611, 1, 0, 0, 0, 6363, 6368, 3, 614, 307, 0, 6364, 6365, 5, 6, 0, 0, 6365, 6367, 3, 614, 307, 0, 6366, 6364, 1, 0, 0, 0, 6367, 6370, 1, 0, 0, 0, 6368, 6366, 1, 0, 0, 0, 6368, 6369, 1, 0, 0, 0, 6369, 613, 1, 0, 0, 0, 6370, 6368, 1, 0, 0, 0, 6371, 6386, 3, 624, 312, 0, 6372, 6374, 5, 81, 0, 0, 6373, 6372, 1, 0, 0, 0, 6373, 6374, 1, 0, 0, 0, 6374, 6375, 1, 0, 0, 0, 6375, 6377, 3, 778, 389, 0, 6376, 6378, 5, 9, 0, 0, 6377, 6376, 1, 0, 0, 0, 6377, 6378, 1, 0, 0, 0, 6378, 6380, 1, 0, 0, 0, 6379, 6381, 3, 148, 74, 0, 6380, 6379, 1, 0, 0, 0, 6380, 6381, 1, 0, 0, 0, 6381, 6383, 1, 0, 0, 0, 6382, 6384, 3, 638, 319, 0, 6383, 6382, 1, 0, 0, 0, 6383, 6384, 1, 0, 0, 0, 6384, 6386, 1, 0, 0, 0, 6385, 6371, 1, 0, 0, 0, 6385, 6373, 1, 0, 0, 0, 6386, 6388, 1, 0, 0, 0, 6387, 6389, 3, 616, 308, 0, 6388, 6387, 1, 0, 0, 0, 6388, 6389, 1, 0, 0, 0, 6389, 6391, 1, 0, 0, 0, 6390, 6392, 3, 632, 316, 0, 6391, 6390, 1, 0, 0, 0, 6391, 6392, 1, 0, 0, 0, 6392, 6435, 1, 0, 0, 0, 6393, 6395, 5, 72, 0, 0, 6394, 6393, 1, 0, 0, 0, 6394, 6395, 1, 0, 0, 0, 6395, 6408, 1, 0, 0, 0, 6396, 6398, 3, 646, 323, 0, 6397, 6399, 3, 616, 308, 0, 6398, 6397, 1, 0, 0, 0, 6398, 6399, 1, 0, 0, 0, 6399, 6409, 1, 0, 0, 0, 6400, 6402, 3, 634, 317, 0, 6401, 6403, 3, 618, 309, 0, 6402, 6401, 1, 0, 0, 0, 6402, 6403, 1, 0, 0, 0, 6403, 6409, 1, 0, 0, 0, 6404, 6406, 3, 562, 281, 0, 6405, 6407, 3, 616, 308, 0, 6406, 6405, 1, 0, 0, 0, 6406, 6407, 1, 0, 0, 0, 6407, 6409, 1, 0, 0, 0, 6408, 6396, 1, 0, 0, 0, 6408, 6400, 1, 0, 0, 0, 6408, 6404, 1, 0, 0, 0, 6409, 6435, 1, 0, 0, 0, 6410, 6411, 5, 2, 0, 0, 6411, 6428, 3, 614, 307, 0, 6412, 6413, 5, 110, 0, 0, 6413, 6414, 5, 118, 0, 0, 6414, 6429, 3, 614, 307, 0, 6415, 6417, 5, 121, 0, 0, 6416, 6418, 3, 620, 310, 0, 6417, 6416, 1, 0, 0, 0, 6417, 6418, 1, 0, 0, 0, 6418, 6419, 1, 0, 0, 0, 6419, 6420, 5, 118, 0, 0, 6420, 6429, 3, 614, 307, 0, 6421, 6423, 3, 620, 310, 0, 6422, 6421, 1, 0, 0, 0, 6422, 6423, 1, 0, 0, 0, 6423, 6424, 1, 0, 0, 0, 6424, 6425, 5, 118, 0, 0, 6425, 6426, 3, 614, 307, 0, 6426, 6427, 3, 622, 311, 0, 6427, 6429, 1, 0, 0, 0, 6428, 6412, 1, 0, 0, 0, 6428, 6415, 1, 0, 0, 0, 6428, 6422, 1, 0, 0, 0, 6428, 6429, 1, 0, 0, 0, 6429, 6430, 1, 0, 0, 0, 6430, 6432, 5, 3, 0, 0, 6431, 6433, 3, 616, 308, 0, 6432, 6431, 1, 0, 0, 0, 6432, 6433, 1, 0, 0, 0, 6433, 6435, 1, 0, 0, 0, 6434, 6385, 1, 0, 0, 0, 6434, 6394, 1, 0, 0, 0, 6434, 6410, 1, 0, 0, 0, 6435, 6454, 1, 0, 0, 0, 6436, 6437, 5, 110, 0, 0, 6437, 6438, 5, 118, 0, 0, 6438, 6453, 3, 614, 307, 0, 6439, 6441, 5, 121, 0, 0, 6440, 6442, 3, 620, 310, 0, 6441, 6440, 1, 0, 0, 0, 6441, 6442, 1, 0, 0, 0, 6442, 6443, 1, 0, 0, 0, 6443, 6444, 5, 118, 0, 0, 6444, 6453, 3, 614, 307, 0, 6445, 6447, 3, 620, 310, 0, 6446, 6445, 1, 0, 0, 0, 6446, 6447, 1, 0, 0, 0, 6447, 6448, 1, 0, 0, 0, 6448, 6449, 5, 118, 0, 0, 6449, 6450, 3, 614, 307, 0, 6450, 6451, 3, 622, 311, 0, 6451, 6453, 1, 0, 0, 0, 6452, 6436, 1, 0, 0, 0, 6452, 6439, 1, 0, 0, 0, 6452, 6446, 1, 0, 0, 0, 6453, 6456, 1, 0, 0, 0, 6454, 6452, 1, 0, 0, 0, 6454, 6455, 1, 0, 0, 0, 6455, 615, 1, 0, 0, 0, 6456, 6454, 1, 0, 0, 0, 6457, 6459, 5, 36, 0, 0, 6458, 6457, 1, 0, 0, 0, 6458, 6459, 1, 0, 0, 0, 6459, 6460, 1, 0, 0, 0, 6460, 6465, 3, 818, 409, 0, 6461, 6462, 5, 2, 0, 0, 6462, 6463, 3, 784, 392, 0, 6463, 6464, 5, 3, 0, 0, 6464, 6466, 1, 0, 0, 0, 6465, 6461, 1, 0, 0, 0, 6465, 6466, 1, 0, 0, 0, 6466, 617, 1, 0, 0, 0, 6467, 6480, 3, 616, 308, 0, 6468, 6470, 5, 36, 0, 0, 6469, 6471, 3, 818, 409, 0, 6470, 6469, 1, 0, 0, 0, 6470, 6471, 1, 0, 0, 0, 6471, 6474, 1, 0, 0, 0, 6472, 6474, 3, 818, 409, 0, 6473, 6468, 1, 0, 0, 0, 6473, 6472, 1, 0, 0, 0, 6474, 6475, 1, 0, 0, 0, 6475, 6476, 5, 2, 0, 0, 6476, 6477, 3, 642, 321, 0, 6477, 6478, 5, 3, 0, 0, 6478, 6480, 1, 0, 0, 0, 6479, 6467, 1, 0, 0, 0, 6479, 6473, 1, 0, 0, 0, 6480, 619, 1, 0, 0, 0, 6481, 6483, 7, 86, 0, 0, 6482, 6484, 5, 123, 0, 0, 6483, 6482, 1, 0, 0, 0, 6483, 6484, 1, 0, 0, 0, 6484, 621, 1, 0, 0, 0, 6485, 6486, 5, 100, 0, 0, 6486, 6490, 3, 144, 72, 0, 6487, 6488, 5, 80, 0, 0, 6488, 6490, 3, 674, 337, 0, 6489, 6485, 1, 0, 0, 0, 6489, 6487, 1, 0, 0, 0, 6490, 623, 1, 0, 0, 0, 6491, 6507, 3, 322, 161, 0, 6492, 6498, 5, 81, 0, 0, 6493, 6499, 3, 774, 387, 0, 6494, 6495, 5, 2, 0, 0, 6495, 6496, 3, 774, 387, 0, 6496, 6497, 5, 3, 0, 0, 6497, 6499, 1, 0, 0, 0, 6498, 6493, 1, 0, 0, 0, 6498, 6494, 1, 0, 0, 0, 6499, 6507, 1, 0, 0, 0, 6500, 6501, 5, 68, 0, 0, 6501, 6504, 5, 323, 0, 0, 6502, 6505, 3, 790, 395, 0, 6503, 6505, 5, 111, 0, 0, 6504, 6502, 1, 0, 0, 0, 6504, 6503, 1, 0, 0, 0, 6505, 6507, 1, 0, 0, 0, 6506, 6491, 1, 0, 0, 0, 6506, 6492, 1, 0, 0, 0, 6506, 6500, 1, 0, 0, 0, 6507, 625, 1, 0, 0, 0, 6508, 6509, 5, 92, 0, 0, 6509, 6511, 3, 322, 161, 0, 6510, 6512, 3, 144, 72, 0, 6511, 6510, 1, 0, 0, 0, 6511, 6512, 1, 0, 0, 0, 6512, 6514, 1, 0, 0, 0, 6513, 6515, 3, 638, 319, 0, 6514, 6513, 1, 0, 0, 0, 6514, 6515, 1, 0, 0, 0, 6515, 6533, 1, 0, 0, 0, 6516, 6517, 5, 92, 0, 0, 6517, 6523, 5, 81, 0, 0, 6518, 6524, 3, 774, 387, 0, 6519, 6520, 5, 2, 0, 0, 6520, 6521, 3, 774, 387, 0, 6521, 6522, 5, 3, 0, 0, 6522, 6524, 1, 0, 0, 0, 6523, 6518, 1, 0, 0, 0, 6523, 6519, 1, 0, 0, 0, 6524, 6533, 1, 0, 0, 0, 6525, 6526, 5, 350, 0, 0, 6526, 6527, 5, 68, 0, 0, 6527, 6530, 5, 323, 0, 0, 6528, 6531, 3, 790, 395, 0, 6529, 6531, 5, 111, 0, 0, 6530, 6528, 1, 0, 0, 0, 6530, 6529, 1, 0, 0, 0, 6531, 6533, 1, 0, 0, 0, 6532, 6508, 1, 0, 0, 0, 6532, 6516, 1, 0, 0, 0, 6532, 6525, 1, 0, 0, 0, 6533, 627, 1, 0, 0, 0, 6534, 6539, 3, 624, 312, 0, 6535, 6536, 5, 6, 0, 0, 6536, 6538, 3, 624, 312, 0, 6537, 6535, 1, 0, 0, 0, 6538, 6541, 1, 0, 0, 0, 6539, 6537, 1, 0, 0, 0, 6539, 6540, 1, 0, 0, 0, 6540, 629, 1, 0, 0, 0, 6541, 6539, 1, 0, 0, 0, 6542, 6547, 3, 624, 312, 0, 6543, 6545, 5, 36, 0, 0, 6544, 6543, 1, 0, 0, 0, 6544, 6545, 1, 0, 0, 0, 6545, 6546, 1, 0, 0, 0, 6546, 6548, 3, 818, 409, 0, 6547, 6544, 1, 0, 0, 0, 6547, 6548, 1, 0, 0, 0, 6548, 631, 1, 0, 0, 0, 6549, 6550, 5, 472, 0, 0, 6550, 6551, 3, 806, 403, 0, 6551, 6557, 3, 534, 267, 0, 6552, 6553, 5, 310, 0, 0, 6553, 6554, 5, 2, 0, 0, 6554, 6555, 3, 674, 337, 0, 6555, 6556, 5, 3, 0, 0, 6556, 6558, 1, 0, 0, 0, 6557, 6552, 1, 0, 0, 0, 6557, 6558, 1, 0, 0, 0, 6558, 633, 1, 0, 0, 0, 6559, 6574, 3, 688, 344, 0, 6560, 6561, 5, 320, 0, 0, 6561, 6562, 5, 64, 0, 0, 6562, 6563, 5, 2, 0, 0, 6563, 6568, 3, 636, 318, 0, 6564, 6565, 5, 6, 0, 0, 6565, 6567, 3, 636, 318, 0, 6566, 6564, 1, 0, 0, 0, 6567, 6570, 1, 0, 0, 0, 6568, 6566, 1, 0, 0, 0, 6568, 6569, 1, 0, 0, 0, 6569, 6571, 1, 0, 0, 0, 6570, 6568, 1, 0, 0, 0, 6571, 6572, 5, 3, 0, 0, 6572, 6574, 1, 0, 0, 0, 6573, 6559, 1, 0, 0, 0, 6573, 6560, 1, 0, 0, 0, 6574, 6577, 1, 0, 0, 0, 6575, 6576, 5, 105, 0, 0, 6576, 6578, 5, 473, 0, 0, 6577, 6575, 1, 0, 0, 0, 6577, 6578, 1, 0, 0, 0, 6578, 635, 1, 0, 0, 0, 6579, 6585, 3, 688, 344, 0, 6580, 6581, 5, 36, 0, 0, 6581, 6582, 5, 2, 0, 0, 6582, 6583, 3, 642, 321, 0, 6583, 6584, 5, 3, 0, 0, 6584, 6586, 1, 0, 0, 0, 6585, 6580, 1, 0, 0, 0, 6585, 6586, 1, 0, 0, 0, 6586, 637, 1, 0, 0, 0, 6587, 6588, 5, 103, 0, 0, 6588, 6589, 3, 734, 367, 0, 6589, 639, 1, 0, 0, 0, 6590, 6595, 5, 103, 0, 0, 6591, 6592, 5, 434, 0, 0, 6592, 6593, 5, 275, 0, 0, 6593, 6596, 3, 818, 409, 0, 6594, 6596, 3, 674, 337, 0, 6595, 6591, 1, 0, 0, 0, 6595, 6594, 1, 0, 0, 0, 6596, 641, 1, 0, 0, 0, 6597, 6602, 3, 644, 322, 0, 6598, 6599, 5, 6, 0, 0, 6599, 6601, 3, 644, 322, 0, 6600, 6598, 1, 0, 0, 0, 6601, 6604, 1, 0, 0, 0, 6602, 6600, 1, 0, 0, 0, 6602, 6603, 1, 0, 0, 0, 6603, 643, 1, 0, 0, 0, 6604, 6602, 1, 0, 0, 0, 6605, 6606, 3, 818, 409, 0, 6606, 6608, 3, 652, 326, 0, 6607, 6609, 3, 98, 49, 0, 6608, 6607, 1, 0, 0, 0, 6608, 6609, 1, 0, 0, 0, 6609, 645, 1, 0, 0, 0, 6610, 6611, 5, 474, 0, 0, 6611, 6625, 5, 2, 0, 0, 6612, 6613, 5, 476, 0, 0, 6613, 6614, 5, 2, 0, 0, 6614, 6619, 3, 650, 325, 0, 6615, 6616, 5, 6, 0, 0, 6616, 6618, 3, 650, 325, 0, 6617, 6615, 1, 0, 0, 0, 6618, 6621, 1, 0, 0, 0, 6619, 6617, 1, 0, 0, 0, 6619, 6620, 1, 0, 0, 0, 6620, 6622, 1, 0, 0, 0, 6621, 6619, 1, 0, 0, 0, 6622, 6623, 5, 3, 0, 0, 6623, 6624, 5, 6, 0, 0, 6624, 6626, 1, 0, 0, 0, 6625, 6612, 1, 0, 0, 0, 6625, 6626, 1, 0, 0, 0, 6626, 6627, 1, 0, 0, 0, 6627, 6628, 3, 682, 341, 0, 6628, 6629, 3, 698, 349, 0, 6629, 6630, 5, 475, 0, 0, 6630, 6635, 3, 648, 324, 0, 6631, 6632, 5, 6, 0, 0, 6632, 6634, 3, 648, 324, 0, 6633, 6631, 1, 0, 0, 0, 6634, 6637, 1, 0, 0, 0, 6635, 6633, 1, 0, 0, 0, 6635, 6636, 1, 0, 0, 0, 6636, 6638, 1, 0, 0, 0, 6637, 6635, 1, 0, 0, 0, 6638, 6639, 5, 3, 0, 0, 6639, 647, 1, 0, 0, 0, 6640, 6659, 3, 818, 409, 0, 6641, 6655, 3, 652, 326, 0, 6642, 6645, 5, 53, 0, 0, 6643, 6645, 3, 826, 413, 0, 6644, 6642, 1, 0, 0, 0, 6644, 6643, 1, 0, 0, 0, 6645, 6646, 1, 0, 0, 0, 6646, 6652, 3, 674, 337, 0, 6647, 6649, 5, 77, 0, 0, 6648, 6647, 1, 0, 0, 0, 6648, 6649, 1, 0, 0, 0, 6649, 6650, 1, 0, 0, 0, 6650, 6652, 5, 78, 0, 0, 6651, 6644, 1, 0, 0, 0, 6651, 6648, 1, 0, 0, 0, 6652, 6653, 1, 0, 0, 0, 6653, 6651, 1, 0, 0, 0, 6653, 6654, 1, 0, 0, 0, 6654, 6656, 1, 0, 0, 0, 6655, 6651, 1, 0, 0, 0, 6655, 6656, 1, 0, 0, 0, 6656, 6660, 1, 0, 0, 0, 6657, 6658, 5, 62, 0, 0, 6658, 6660, 5, 473, 0, 0, 6659, 6641, 1, 0, 0, 0, 6659, 6657, 1, 0, 0, 0, 6660, 649, 1, 0, 0, 0, 6661, 6662, 3, 682, 341, 0, 6662, 6663, 5, 36, 0, 0, 6663, 6664, 3, 824, 412, 0, 6664, 6668, 1, 0, 0, 0, 6665, 6666, 5, 53, 0, 0, 6666, 6668, 3, 682, 341, 0, 6667, 6661, 1, 0, 0, 0, 6667, 6665, 1, 0, 0, 0, 6668, 651, 1, 0, 0, 0, 6669, 6671, 5, 415, 0, 0, 6670, 6669, 1, 0, 0, 0, 6670, 6671, 1, 0, 0, 0, 6671, 6672, 1, 0, 0, 0, 6672, 6689, 3, 654, 327, 0, 6673, 6675, 5, 4, 0, 0, 6674, 6676, 5, 571, 0, 0, 6675, 6674, 1, 0, 0, 0, 6675, 6676, 1, 0, 0, 0, 6676, 6677, 1, 0, 0, 0, 6677, 6679, 5, 5, 0, 0, 6678, 6673, 1, 0, 0, 0, 6679, 6682, 1, 0, 0, 0, 6680, 6678, 1, 0, 0, 0, 6680, 6681, 1, 0, 0, 0, 6681, 6690, 1, 0, 0, 0, 6682, 6680, 1, 0, 0, 0, 6683, 6687, 5, 35, 0, 0, 6684, 6685, 5, 4, 0, 0, 6685, 6686, 5, 571, 0, 0, 6686, 6688, 5, 5, 0, 0, 6687, 6684, 1, 0, 0, 0, 6687, 6688, 1, 0, 0, 0, 6688, 6690, 1, 0, 0, 0, 6689, 6680, 1, 0, 0, 0, 6689, 6683, 1, 0, 0, 0, 6690, 6696, 1, 0, 0, 0, 6691, 6692, 3, 780, 390, 0, 6692, 6693, 5, 27, 0, 0, 6693, 6694, 7, 87, 0, 0, 6694, 6696, 1, 0, 0, 0, 6695, 6670, 1, 0, 0, 0, 6695, 6691, 1, 0, 0, 0, 6696, 653, 1, 0, 0, 0, 6697, 6699, 3, 820, 410, 0, 6698, 6700, 3, 318, 159, 0, 6699, 6698, 1, 0, 0, 0, 6699, 6700, 1, 0, 0, 0, 6700, 6702, 1, 0, 0, 0, 6701, 6703, 3, 534, 267, 0, 6702, 6701, 1, 0, 0, 0, 6702, 6703, 1, 0, 0, 0, 6703, 6713, 1, 0, 0, 0, 6704, 6713, 3, 656, 328, 0, 6705, 6710, 5, 403, 0, 0, 6706, 6708, 3, 668, 334, 0, 6707, 6706, 1, 0, 0, 0, 6707, 6708, 1, 0, 0, 0, 6708, 6711, 1, 0, 0, 0, 6709, 6711, 3, 660, 330, 0, 6710, 6707, 1, 0, 0, 0, 6710, 6709, 1, 0, 0, 0, 6711, 6713, 1, 0, 0, 0, 6712, 6697, 1, 0, 0, 0, 6712, 6704, 1, 0, 0, 0, 6712, 6705, 1, 0, 0, 0, 6713, 655, 1, 0, 0, 0, 6714, 6719, 3, 658, 329, 0, 6715, 6719, 3, 662, 331, 0, 6716, 6719, 3, 664, 332, 0, 6717, 6719, 3, 666, 333, 0, 6718, 6714, 1, 0, 0, 0, 6718, 6715, 1, 0, 0, 0, 6718, 6716, 1, 0, 0, 0, 6718, 6717, 1, 0, 0, 0, 6719, 657, 1, 0, 0, 0, 6720, 6737, 5, 401, 0, 0, 6721, 6737, 5, 402, 0, 0, 6722, 6737, 5, 416, 0, 0, 6723, 6737, 5, 388, 0, 0, 6724, 6737, 5, 413, 0, 0, 6725, 6727, 5, 398, 0, 0, 6726, 6728, 3, 660, 330, 0, 6727, 6726, 1, 0, 0, 0, 6727, 6728, 1, 0, 0, 0, 6728, 6737, 1, 0, 0, 0, 6729, 6730, 5, 190, 0, 0, 6730, 6737, 5, 412, 0, 0, 6731, 6733, 7, 88, 0, 0, 6732, 6734, 3, 534, 267, 0, 6733, 6732, 1, 0, 0, 0, 6733, 6734, 1, 0, 0, 0, 6734, 6737, 1, 0, 0, 0, 6735, 6737, 5, 390, 0, 0, 6736, 6720, 1, 0, 0, 0, 6736, 6721, 1, 0, 0, 0, 6736, 6722, 1, 0, 0, 0, 6736, 6723, 1, 0, 0, 0, 6736, 6724, 1, 0, 0, 0, 6736, 6725, 1, 0, 0, 0, 6736, 6729, 1, 0, 0, 0, 6736, 6731, 1, 0, 0, 0, 6736, 6735, 1, 0, 0, 0, 6737, 659, 1, 0, 0, 0, 6738, 6739, 5, 2, 0, 0, 6739, 6740, 5, 571, 0, 0, 6740, 6741, 5, 3, 0, 0, 6741, 661, 1, 0, 0, 0, 6742, 6744, 5, 389, 0, 0, 6743, 6745, 5, 374, 0, 0, 6744, 6743, 1, 0, 0, 0, 6744, 6745, 1, 0, 0, 0, 6745, 6747, 1, 0, 0, 0, 6746, 6748, 3, 534, 267, 0, 6747, 6746, 1, 0, 0, 0, 6747, 6748, 1, 0, 0, 0, 6748, 663, 1, 0, 0, 0, 6749, 6751, 7, 89, 0, 0, 6750, 6752, 5, 374, 0, 0, 6751, 6750, 1, 0, 0, 0, 6751, 6752, 1, 0, 0, 0, 6752, 6760, 1, 0, 0, 0, 6753, 6760, 5, 423, 0, 0, 6754, 6755, 5, 405, 0, 0, 6755, 6757, 7, 90, 0, 0, 6756, 6758, 5, 374, 0, 0, 6757, 6756, 1, 0, 0, 0, 6757, 6758, 1, 0, 0, 0, 6758, 6760, 1, 0, 0, 0, 6759, 6749, 1, 0, 0, 0, 6759, 6753, 1, 0, 0, 0, 6759, 6754, 1, 0, 0, 0, 6760, 6762, 1, 0, 0, 0, 6761, 6763, 3, 660, 330, 0, 6762, 6761, 1, 0, 0, 0, 6762, 6763, 1, 0, 0, 0, 6763, 665, 1, 0, 0, 0, 6764, 6766, 7, 91, 0, 0, 6765, 6767, 3, 660, 330, 0, 6766, 6765, 1, 0, 0, 0, 6766, 6767, 1, 0, 0, 0, 6767, 6771, 1, 0, 0, 0, 6768, 6769, 7, 26, 0, 0, 6769, 6770, 5, 418, 0, 0, 6770, 6772, 5, 386, 0, 0, 6771, 6768, 1, 0, 0, 0, 6771, 6772, 1, 0, 0, 0, 6772, 667, 1, 0, 0, 0, 6773, 6803, 5, 264, 0, 0, 6774, 6803, 3, 670, 335, 0, 6775, 6778, 5, 384, 0, 0, 6776, 6777, 5, 94, 0, 0, 6777, 6779, 5, 264, 0, 0, 6778, 6776, 1, 0, 0, 0, 6778, 6779, 1, 0, 0, 0, 6779, 6803, 1, 0, 0, 0, 6780, 6787, 5, 176, 0, 0, 6781, 6785, 5, 94, 0, 0, 6782, 6786, 5, 218, 0, 0, 6783, 6786, 5, 261, 0, 0, 6784, 6786, 3, 670, 335, 0, 6785, 6782, 1, 0, 0, 0, 6785, 6783, 1, 0, 0, 0, 6785, 6784, 1, 0, 0, 0, 6786, 6788, 1, 0, 0, 0, 6787, 6781, 1, 0, 0, 0, 6787, 6788, 1, 0, 0, 0, 6788, 6803, 1, 0, 0, 0, 6789, 6795, 5, 218, 0, 0, 6790, 6793, 5, 94, 0, 0, 6791, 6794, 5, 261, 0, 0, 6792, 6794, 3, 670, 335, 0, 6793, 6791, 1, 0, 0, 0, 6793, 6792, 1, 0, 0, 0, 6794, 6796, 1, 0, 0, 0, 6795, 6790, 1, 0, 0, 0, 6795, 6796, 1, 0, 0, 0, 6796, 6803, 1, 0, 0, 0, 6797, 6800, 5, 261, 0, 0, 6798, 6799, 5, 94, 0, 0, 6799, 6801, 3, 670, 335, 0, 6800, 6798, 1, 0, 0, 0, 6800, 6801, 1, 0, 0, 0, 6801, 6803, 1, 0, 0, 0, 6802, 6773, 1, 0, 0, 0, 6802, 6774, 1, 0, 0, 0, 6802, 6775, 1, 0, 0, 0, 6802, 6780, 1, 0, 0, 0, 6802, 6789, 1, 0, 0, 0, 6802, 6797, 1, 0, 0, 0, 6803, 669, 1, 0, 0, 0, 6804, 6806, 5, 326, 0, 0, 6805, 6807, 3, 660, 330, 0, 6806, 6805, 1, 0, 0, 0, 6806, 6807, 1, 0, 0, 0, 6807, 671, 1, 0, 0, 0, 6808, 6809, 7, 92, 0, 0, 6809, 673, 1, 0, 0, 0, 6810, 6811, 3, 676, 338, 0, 6811, 675, 1, 0, 0, 0, 6812, 6813, 6, 338, -1, 0, 6813, 6815, 3, 680, 340, 0, 6814, 6816, 3, 678, 339, 0, 6815, 6814, 1, 0, 0, 0, 6815, 6816, 1, 0, 0, 0, 6816, 6820, 1, 0, 0, 0, 6817, 6818, 5, 77, 0, 0, 6818, 6820, 3, 676, 338, 3, 6819, 6812, 1, 0, 0, 0, 6819, 6817, 1, 0, 0, 0, 6820, 6829, 1, 0, 0, 0, 6821, 6822, 10, 2, 0, 0, 6822, 6823, 5, 33, 0, 0, 6823, 6828, 3, 676, 338, 3, 6824, 6825, 10, 1, 0, 0, 6825, 6826, 5, 82, 0, 0, 6826, 6828, 3, 676, 338, 2, 6827, 6821, 1, 0, 0, 0, 6827, 6824, 1, 0, 0, 0, 6828, 6831, 1, 0, 0, 0, 6829, 6827, 1, 0, 0, 0, 6829, 6830, 1, 0, 0, 0, 6830, 677, 1, 0, 0, 0, 6831, 6829, 1, 0, 0, 0, 6832, 6833, 3, 672, 336, 0, 6833, 6834, 3, 680, 340, 0, 6834, 6904, 1, 0, 0, 0, 6835, 6836, 3, 672, 336, 0, 6836, 6837, 3, 728, 364, 0, 6837, 6843, 3, 718, 359, 0, 6838, 6844, 3, 562, 281, 0, 6839, 6840, 5, 2, 0, 0, 6840, 6841, 3, 674, 337, 0, 6841, 6842, 5, 3, 0, 0, 6842, 6844, 1, 0, 0, 0, 6843, 6838, 1, 0, 0, 0, 6843, 6839, 1, 0, 0, 0, 6844, 6904, 1, 0, 0, 0, 6845, 6847, 5, 77, 0, 0, 6846, 6845, 1, 0, 0, 0, 6846, 6847, 1, 0, 0, 0, 6847, 6848, 1, 0, 0, 0, 6848, 6849, 5, 387, 0, 0, 6849, 6850, 3, 680, 340, 0, 6850, 6851, 5, 33, 0, 0, 6851, 6852, 3, 680, 340, 0, 6852, 6904, 1, 0, 0, 0, 6853, 6855, 5, 77, 0, 0, 6854, 6853, 1, 0, 0, 0, 6854, 6855, 1, 0, 0, 0, 6855, 6856, 1, 0, 0, 0, 6856, 6857, 5, 68, 0, 0, 6857, 6858, 5, 2, 0, 0, 6858, 6863, 3, 674, 337, 0, 6859, 6860, 5, 6, 0, 0, 6860, 6862, 3, 674, 337, 0, 6861, 6859, 1, 0, 0, 0, 6862, 6865, 1, 0, 0, 0, 6863, 6861, 1, 0, 0, 0, 6863, 6864, 1, 0, 0, 0, 6864, 6866, 1, 0, 0, 0, 6865, 6863, 1, 0, 0, 0, 6866, 6867, 5, 3, 0, 0, 6867, 6904, 1, 0, 0, 0, 6868, 6870, 5, 77, 0, 0, 6869, 6868, 1, 0, 0, 0, 6869, 6870, 1, 0, 0, 0, 6870, 6871, 1, 0, 0, 0, 6871, 6872, 5, 68, 0, 0, 6872, 6904, 3, 562, 281, 0, 6873, 6875, 5, 77, 0, 0, 6874, 6873, 1, 0, 0, 0, 6874, 6875, 1, 0, 0, 0, 6875, 6884, 1, 0, 0, 0, 6876, 6885, 5, 120, 0, 0, 6877, 6885, 5, 114, 0, 0, 6878, 6879, 5, 127, 0, 0, 6879, 6885, 5, 94, 0, 0, 6880, 6882, 5, 387, 0, 0, 6881, 6883, 5, 91, 0, 0, 6882, 6881, 1, 0, 0, 0, 6882, 6883, 1, 0, 0, 0, 6883, 6885, 1, 0, 0, 0, 6884, 6876, 1, 0, 0, 0, 6884, 6877, 1, 0, 0, 0, 6884, 6878, 1, 0, 0, 0, 6884, 6880, 1, 0, 0, 0, 6885, 6886, 1, 0, 0, 0, 6886, 6889, 3, 680, 340, 0, 6887, 6888, 5, 197, 0, 0, 6888, 6890, 3, 680, 340, 0, 6889, 6887, 1, 0, 0, 0, 6889, 6890, 1, 0, 0, 0, 6890, 6904, 1, 0, 0, 0, 6891, 6893, 5, 116, 0, 0, 6892, 6894, 5, 77, 0, 0, 6893, 6892, 1, 0, 0, 0, 6893, 6894, 1, 0, 0, 0, 6894, 6895, 1, 0, 0, 0, 6895, 6904, 5, 78, 0, 0, 6896, 6898, 5, 116, 0, 0, 6897, 6899, 5, 77, 0, 0, 6898, 6897, 1, 0, 0, 0, 6898, 6899, 1, 0, 0, 0, 6899, 6900, 1, 0, 0, 0, 6900, 6901, 5, 56, 0, 0, 6901, 6902, 5, 64, 0, 0, 6902, 6904, 3, 680, 340, 0, 6903, 6832, 1, 0, 0, 0, 6903, 6835, 1, 0, 0, 0, 6903, 6846, 1, 0, 0, 0, 6903, 6854, 1, 0, 0, 0, 6903, 6869, 1, 0, 0, 0, 6903, 6874, 1, 0, 0, 0, 6903, 6891, 1, 0, 0, 0, 6903, 6896, 1, 0, 0, 0, 6904, 679, 1, 0, 0, 0, 6905, 6906, 6, 340, -1, 0, 6906, 6910, 3, 682, 341, 0, 6907, 6908, 7, 29, 0, 0, 6908, 6910, 3, 680, 340, 4, 6909, 6905, 1, 0, 0, 0, 6909, 6907, 1, 0, 0, 0, 6910, 6927, 1, 0, 0, 0, 6911, 6912, 10, 3, 0, 0, 6912, 6913, 7, 93, 0, 0, 6913, 6926, 3, 680, 340, 4, 6914, 6915, 10, 2, 0, 0, 6915, 6916, 7, 29, 0, 0, 6916, 6926, 3, 680, 340, 3, 6917, 6918, 10, 1, 0, 0, 6918, 6919, 5, 15, 0, 0, 6919, 6926, 3, 680, 340, 2, 6920, 6921, 10, 5, 0, 0, 6921, 6922, 5, 142, 0, 0, 6922, 6923, 5, 418, 0, 0, 6923, 6924, 5, 386, 0, 0, 6924, 6926, 3, 674, 337, 0, 6925, 6911, 1, 0, 0, 0, 6925, 6914, 1, 0, 0, 0, 6925, 6917, 1, 0, 0, 0, 6925, 6920, 1, 0, 0, 0, 6926, 6929, 1, 0, 0, 0, 6927, 6925, 1, 0, 0, 0, 6927, 6928, 1, 0, 0, 0, 6928, 681, 1, 0, 0, 0, 6929, 6927, 1, 0, 0, 0, 6930, 6931, 6, 341, -1, 0, 6931, 6932, 7, 94, 0, 0, 6932, 7019, 3, 562, 281, 0, 6933, 6936, 5, 35, 0, 0, 6934, 6937, 3, 562, 281, 0, 6935, 6937, 3, 740, 370, 0, 6936, 6934, 1, 0, 0, 0, 6936, 6935, 1, 0, 0, 0, 6937, 7019, 1, 0, 0, 0, 6938, 6939, 5, 28, 0, 0, 6939, 7019, 3, 754, 377, 0, 6940, 6941, 5, 470, 0, 0, 6941, 7019, 3, 534, 267, 0, 6942, 7019, 5, 571, 0, 0, 6943, 7019, 5, 573, 0, 0, 6944, 7019, 5, 563, 0, 0, 6945, 7019, 5, 567, 0, 0, 6946, 6956, 3, 806, 403, 0, 6947, 6957, 3, 808, 404, 0, 6948, 6949, 5, 2, 0, 0, 6949, 6951, 3, 736, 368, 0, 6950, 6952, 3, 586, 293, 0, 6951, 6950, 1, 0, 0, 0, 6951, 6952, 1, 0, 0, 0, 6952, 6953, 1, 0, 0, 0, 6953, 6954, 5, 3, 0, 0, 6954, 6955, 3, 808, 404, 0, 6955, 6957, 1, 0, 0, 0, 6956, 6947, 1, 0, 0, 0, 6956, 6948, 1, 0, 0, 0, 6957, 7019, 1, 0, 0, 0, 6958, 6960, 3, 656, 328, 0, 6959, 6958, 1, 0, 0, 0, 6959, 6960, 1, 0, 0, 0, 6960, 6961, 1, 0, 0, 0, 6961, 7019, 3, 808, 404, 0, 6962, 6970, 5, 403, 0, 0, 6963, 6965, 3, 808, 404, 0, 6964, 6966, 3, 668, 334, 0, 6965, 6964, 1, 0, 0, 0, 6965, 6966, 1, 0, 0, 0, 6966, 6971, 1, 0, 0, 0, 6967, 6968, 3, 660, 330, 0, 6968, 6969, 3, 808, 404, 0, 6969, 6971, 1, 0, 0, 0, 6970, 6963, 1, 0, 0, 0, 6970, 6967, 1, 0, 0, 0, 6971, 7019, 1, 0, 0, 0, 6972, 7019, 5, 96, 0, 0, 6973, 7019, 5, 60, 0, 0, 6974, 7019, 5, 78, 0, 0, 6975, 7019, 5, 574, 0, 0, 6976, 6977, 5, 2, 0, 0, 6977, 6978, 3, 674, 337, 0, 6978, 6979, 5, 3, 0, 0, 6979, 6980, 3, 754, 377, 0, 6980, 7019, 1, 0, 0, 0, 6981, 6983, 5, 40, 0, 0, 6982, 6984, 3, 674, 337, 0, 6983, 6982, 1, 0, 0, 0, 6983, 6984, 1, 0, 0, 0, 6984, 6986, 1, 0, 0, 0, 6985, 6987, 3, 748, 374, 0, 6986, 6985, 1, 0, 0, 0, 6987, 6988, 1, 0, 0, 0, 6988, 6986, 1, 0, 0, 0, 6988, 6989, 1, 0, 0, 0, 6989, 6992, 1, 0, 0, 0, 6990, 6991, 5, 58, 0, 0, 6991, 6993, 3, 674, 337, 0, 6992, 6990, 1, 0, 0, 0, 6992, 6993, 1, 0, 0, 0, 6993, 6994, 1, 0, 0, 0, 6994, 6995, 5, 454, 0, 0, 6995, 7019, 1, 0, 0, 0, 6996, 7019, 3, 686, 343, 0, 6997, 6999, 3, 562, 281, 0, 6998, 7000, 3, 752, 376, 0, 6999, 6998, 1, 0, 0, 0, 6999, 7000, 1, 0, 0, 0, 7000, 7019, 1, 0, 0, 0, 7001, 7019, 3, 716, 358, 0, 7002, 7003, 5, 2, 0, 0, 7003, 7004, 3, 674, 337, 0, 7004, 7005, 5, 6, 0, 0, 7005, 7006, 3, 730, 365, 0, 7006, 7007, 5, 3, 0, 0, 7007, 7019, 1, 0, 0, 0, 7008, 7009, 3, 714, 357, 0, 7009, 7010, 5, 125, 0, 0, 7010, 7011, 3, 714, 357, 0, 7011, 7019, 1, 0, 0, 0, 7012, 7019, 3, 780, 390, 0, 7013, 7014, 7, 29, 0, 0, 7014, 7019, 3, 682, 341, 5, 7015, 7016, 3, 724, 362, 0, 7016, 7017, 3, 682, 341, 2, 7017, 7019, 1, 0, 0, 0, 7018, 6930, 1, 0, 0, 0, 7018, 6933, 1, 0, 0, 0, 7018, 6938, 1, 0, 0, 0, 7018, 6940, 1, 0, 0, 0, 7018, 6942, 1, 0, 0, 0, 7018, 6943, 1, 0, 0, 0, 7018, 6944, 1, 0, 0, 0, 7018, 6945, 1, 0, 0, 0, 7018, 6946, 1, 0, 0, 0, 7018, 6959, 1, 0, 0, 0, 7018, 6962, 1, 0, 0, 0, 7018, 6972, 1, 0, 0, 0, 7018, 6973, 1, 0, 0, 0, 7018, 6974, 1, 0, 0, 0, 7018, 6975, 1, 0, 0, 0, 7018, 6976, 1, 0, 0, 0, 7018, 6981, 1, 0, 0, 0, 7018, 6996, 1, 0, 0, 0, 7018, 6997, 1, 0, 0, 0, 7018, 7001, 1, 0, 0, 0, 7018, 7002, 1, 0, 0, 0, 7018, 7008, 1, 0, 0, 0, 7018, 7012, 1, 0, 0, 0, 7018, 7013, 1, 0, 0, 0, 7018, 7015, 1, 0, 0, 0, 7019, 7047, 1, 0, 0, 0, 7020, 7021, 10, 3, 0, 0, 7021, 7022, 3, 722, 361, 0, 7022, 7023, 3, 682, 341, 4, 7023, 7046, 1, 0, 0, 0, 7024, 7025, 10, 6, 0, 0, 7025, 7026, 5, 26, 0, 0, 7026, 7046, 3, 652, 326, 0, 7027, 7028, 10, 4, 0, 0, 7028, 7030, 3, 724, 362, 0, 7029, 7031, 3, 682, 341, 0, 7030, 7029, 1, 0, 0, 0, 7030, 7031, 1, 0, 0, 0, 7031, 7046, 1, 0, 0, 0, 7032, 7033, 10, 1, 0, 0, 7033, 7035, 5, 116, 0, 0, 7034, 7036, 5, 77, 0, 0, 7035, 7034, 1, 0, 0, 0, 7035, 7036, 1, 0, 0, 0, 7036, 7043, 1, 0, 0, 0, 7037, 7038, 5, 56, 0, 0, 7038, 7039, 5, 64, 0, 0, 7039, 7044, 3, 682, 341, 0, 7040, 7041, 5, 275, 0, 0, 7041, 7044, 3, 528, 264, 0, 7042, 7044, 5, 188, 0, 0, 7043, 7037, 1, 0, 0, 0, 7043, 7040, 1, 0, 0, 0, 7043, 7042, 1, 0, 0, 0, 7044, 7046, 1, 0, 0, 0, 7045, 7020, 1, 0, 0, 0, 7045, 7024, 1, 0, 0, 0, 7045, 7027, 1, 0, 0, 0, 7045, 7032, 1, 0, 0, 0, 7046, 7049, 1, 0, 0, 0, 7047, 7045, 1, 0, 0, 0, 7047, 7048, 1, 0, 0, 0, 7048, 683, 1, 0, 0, 0, 7049, 7047, 1, 0, 0, 0, 7050, 7051, 3, 806, 403, 0, 7051, 7072, 5, 2, 0, 0, 7052, 7056, 3, 736, 368, 0, 7053, 7054, 5, 6, 0, 0, 7054, 7055, 5, 101, 0, 0, 7055, 7057, 3, 738, 369, 0, 7056, 7053, 1, 0, 0, 0, 7056, 7057, 1, 0, 0, 0, 7057, 7059, 1, 0, 0, 0, 7058, 7060, 3, 586, 293, 0, 7059, 7058, 1, 0, 0, 0, 7059, 7060, 1, 0, 0, 0, 7060, 7073, 1, 0, 0, 0, 7061, 7062, 5, 101, 0, 0, 7062, 7064, 3, 738, 369, 0, 7063, 7065, 3, 586, 293, 0, 7064, 7063, 1, 0, 0, 0, 7064, 7065, 1, 0, 0, 0, 7065, 7073, 1, 0, 0, 0, 7066, 7067, 7, 80, 0, 0, 7067, 7069, 3, 736, 368, 0, 7068, 7070, 3, 586, 293, 0, 7069, 7068, 1, 0, 0, 0, 7069, 7070, 1, 0, 0, 0, 7070, 7073, 1, 0, 0, 0, 7071, 7073, 5, 9, 0, 0, 7072, 7052, 1, 0, 0, 0, 7072, 7061, 1, 0, 0, 0, 7072, 7066, 1, 0, 0, 0, 7072, 7071, 1, 0, 0, 0, 7072, 7073, 1, 0, 0, 0, 7073, 7074, 1, 0, 0, 0, 7074, 7075, 5, 3, 0, 0, 7075, 685, 1, 0, 0, 0, 7076, 7083, 3, 684, 342, 0, 7077, 7078, 5, 479, 0, 0, 7078, 7079, 5, 66, 0, 0, 7079, 7080, 5, 2, 0, 0, 7080, 7081, 3, 586, 293, 0, 7081, 7082, 5, 3, 0, 0, 7082, 7084, 1, 0, 0, 0, 7083, 7077, 1, 0, 0, 0, 7083, 7084, 1, 0, 0, 0, 7084, 7091, 1, 0, 0, 0, 7085, 7086, 5, 480, 0, 0, 7086, 7087, 5, 2, 0, 0, 7087, 7088, 5, 103, 0, 0, 7088, 7089, 3, 674, 337, 0, 7089, 7090, 5, 3, 0, 0, 7090, 7092, 1, 0, 0, 0, 7091, 7085, 1, 0, 0, 0, 7091, 7092, 1, 0, 0, 0, 7092, 7098, 1, 0, 0, 0, 7093, 7096, 5, 124, 0, 0, 7094, 7097, 3, 708, 354, 0, 7095, 7097, 3, 818, 409, 0, 7096, 7094, 1, 0, 0, 0, 7096, 7095, 1, 0, 0, 0, 7097, 7099, 1, 0, 0, 0, 7098, 7093, 1, 0, 0, 0, 7098, 7099, 1, 0, 0, 0, 7099, 7102, 1, 0, 0, 0, 7100, 7102, 3, 690, 345, 0, 7101, 7076, 1, 0, 0, 0, 7101, 7100, 1, 0, 0, 0, 7102, 687, 1, 0, 0, 0, 7103, 7106, 3, 684, 342, 0, 7104, 7106, 3, 690, 345, 0, 7105, 7103, 1, 0, 0, 0, 7105, 7104, 1, 0, 0, 0, 7106, 689, 1, 0, 0, 0, 7107, 7108, 5, 108, 0, 0, 7108, 7109, 5, 62, 0, 0, 7109, 7110, 5, 2, 0, 0, 7110, 7111, 3, 674, 337, 0, 7111, 7112, 5, 3, 0, 0, 7112, 7282, 1, 0, 0, 0, 7113, 7282, 5, 48, 0, 0, 7114, 7116, 7, 95, 0, 0, 7115, 7117, 3, 660, 330, 0, 7116, 7115, 1, 0, 0, 0, 7116, 7117, 1, 0, 0, 0, 7117, 7282, 1, 0, 0, 0, 7118, 7282, 5, 49, 0, 0, 7119, 7282, 5, 52, 0, 0, 7120, 7282, 5, 89, 0, 0, 7121, 7282, 5, 99, 0, 0, 7122, 7282, 5, 47, 0, 0, 7123, 7282, 5, 111, 0, 0, 7124, 7125, 7, 96, 0, 0, 7125, 7126, 5, 2, 0, 0, 7126, 7127, 3, 674, 337, 0, 7127, 7128, 5, 36, 0, 0, 7128, 7129, 3, 652, 326, 0, 7129, 7130, 5, 3, 0, 0, 7130, 7282, 1, 0, 0, 0, 7131, 7132, 5, 397, 0, 0, 7132, 7137, 5, 2, 0, 0, 7133, 7134, 3, 742, 371, 0, 7134, 7135, 5, 64, 0, 0, 7135, 7136, 3, 674, 337, 0, 7136, 7138, 1, 0, 0, 0, 7137, 7133, 1, 0, 0, 0, 7137, 7138, 1, 0, 0, 0, 7138, 7139, 1, 0, 0, 0, 7139, 7282, 5, 3, 0, 0, 7140, 7141, 5, 489, 0, 0, 7141, 7142, 5, 2, 0, 0, 7142, 7145, 3, 674, 337, 0, 7143, 7144, 5, 6, 0, 0, 7144, 7146, 3, 744, 372, 0, 7145, 7143, 1, 0, 0, 0, 7145, 7146, 1, 0, 0, 0, 7146, 7147, 1, 0, 0, 0, 7147, 7148, 5, 3, 0, 0, 7148, 7282, 1, 0, 0, 0, 7149, 7150, 5, 410, 0, 0, 7150, 7151, 5, 2, 0, 0, 7151, 7152, 3, 674, 337, 0, 7152, 7153, 5, 84, 0, 0, 7153, 7154, 3, 674, 337, 0, 7154, 7155, 5, 64, 0, 0, 7155, 7158, 3, 674, 337, 0, 7156, 7157, 5, 62, 0, 0, 7157, 7159, 3, 674, 337, 0, 7158, 7156, 1, 0, 0, 0, 7158, 7159, 1, 0, 0, 0, 7159, 7160, 1, 0, 0, 0, 7160, 7161, 5, 3, 0, 0, 7161, 7282, 1, 0, 0, 0, 7162, 7163, 5, 411, 0, 0, 7163, 7168, 5, 2, 0, 0, 7164, 7165, 3, 682, 341, 0, 7165, 7166, 5, 68, 0, 0, 7166, 7167, 3, 682, 341, 0, 7167, 7169, 1, 0, 0, 0, 7168, 7164, 1, 0, 0, 0, 7168, 7169, 1, 0, 0, 0, 7169, 7170, 1, 0, 0, 0, 7170, 7282, 5, 3, 0, 0, 7171, 7172, 5, 417, 0, 0, 7172, 7174, 5, 2, 0, 0, 7173, 7175, 3, 746, 373, 0, 7174, 7173, 1, 0, 0, 0, 7174, 7175, 1, 0, 0, 0, 7175, 7176, 1, 0, 0, 0, 7176, 7282, 5, 3, 0, 0, 7177, 7178, 5, 421, 0, 0, 7178, 7180, 5, 2, 0, 0, 7179, 7181, 7, 97, 0, 0, 7180, 7179, 1, 0, 0, 0, 7180, 7181, 1, 0, 0, 0, 7181, 7186, 1, 0, 0, 0, 7182, 7184, 3, 674, 337, 0, 7183, 7182, 1, 0, 0, 0, 7183, 7184, 1, 0, 0, 0, 7184, 7185, 1, 0, 0, 0, 7185, 7187, 5, 64, 0, 0, 7186, 7183, 1, 0, 0, 0, 7186, 7187, 1, 0, 0, 0, 7187, 7188, 1, 0, 0, 0, 7188, 7189, 3, 730, 365, 0, 7189, 7190, 1, 0, 0, 0, 7190, 7191, 5, 3, 0, 0, 7191, 7282, 1, 0, 0, 0, 7192, 7193, 5, 408, 0, 0, 7193, 7194, 5, 2, 0, 0, 7194, 7195, 3, 674, 337, 0, 7195, 7196, 5, 6, 0, 0, 7196, 7197, 3, 674, 337, 0, 7197, 7198, 5, 3, 0, 0, 7198, 7282, 1, 0, 0, 0, 7199, 7200, 7, 98, 0, 0, 7200, 7282, 3, 534, 267, 0, 7201, 7202, 5, 426, 0, 0, 7202, 7203, 5, 2, 0, 0, 7203, 7204, 5, 266, 0, 0, 7204, 7214, 3, 824, 412, 0, 7205, 7212, 5, 6, 0, 0, 7206, 7207, 5, 424, 0, 0, 7207, 7208, 5, 2, 0, 0, 7208, 7209, 3, 692, 346, 0, 7209, 7210, 5, 3, 0, 0, 7210, 7213, 1, 0, 0, 0, 7211, 7213, 3, 730, 365, 0, 7212, 7206, 1, 0, 0, 0, 7212, 7211, 1, 0, 0, 0, 7213, 7215, 1, 0, 0, 0, 7214, 7205, 1, 0, 0, 0, 7214, 7215, 1, 0, 0, 0, 7215, 7216, 1, 0, 0, 0, 7216, 7217, 5, 3, 0, 0, 7217, 7282, 1, 0, 0, 0, 7218, 7219, 5, 427, 0, 0, 7219, 7220, 5, 2, 0, 0, 7220, 7221, 3, 682, 341, 0, 7221, 7222, 3, 698, 349, 0, 7222, 7223, 5, 3, 0, 0, 7223, 7282, 1, 0, 0, 0, 7224, 7225, 5, 428, 0, 0, 7225, 7226, 5, 2, 0, 0, 7226, 7227, 3, 692, 346, 0, 7227, 7228, 5, 3, 0, 0, 7228, 7282, 1, 0, 0, 0, 7229, 7230, 5, 429, 0, 0, 7230, 7231, 5, 2, 0, 0, 7231, 7232, 3, 696, 348, 0, 7232, 7235, 3, 674, 337, 0, 7233, 7234, 7, 99, 0, 0, 7234, 7236, 5, 378, 0, 0, 7235, 7233, 1, 0, 0, 0, 7235, 7236, 1, 0, 0, 0, 7236, 7237, 1, 0, 0, 0, 7237, 7238, 5, 3, 0, 0, 7238, 7282, 1, 0, 0, 0, 7239, 7240, 5, 430, 0, 0, 7240, 7241, 5, 2, 0, 0, 7241, 7242, 5, 266, 0, 0, 7242, 7245, 3, 824, 412, 0, 7243, 7244, 5, 6, 0, 0, 7244, 7246, 3, 674, 337, 0, 7245, 7243, 1, 0, 0, 0, 7245, 7246, 1, 0, 0, 0, 7246, 7247, 1, 0, 0, 0, 7247, 7248, 5, 3, 0, 0, 7248, 7282, 1, 0, 0, 0, 7249, 7250, 5, 431, 0, 0, 7250, 7251, 5, 2, 0, 0, 7251, 7252, 5, 383, 0, 0, 7252, 7253, 3, 674, 337, 0, 7253, 7254, 5, 6, 0, 0, 7254, 7258, 5, 375, 0, 0, 7255, 7256, 5, 269, 0, 0, 7256, 7259, 5, 450, 0, 0, 7257, 7259, 3, 674, 337, 0, 7258, 7255, 1, 0, 0, 0, 7258, 7257, 1, 0, 0, 0, 7259, 7269, 1, 0, 0, 0, 7260, 7261, 5, 6, 0, 0, 7261, 7267, 5, 339, 0, 0, 7262, 7264, 5, 269, 0, 0, 7263, 7262, 1, 0, 0, 0, 7263, 7264, 1, 0, 0, 0, 7264, 7265, 1, 0, 0, 0, 7265, 7268, 5, 450, 0, 0, 7266, 7268, 5, 385, 0, 0, 7267, 7263, 1, 0, 0, 0, 7267, 7266, 1, 0, 0, 0, 7268, 7270, 1, 0, 0, 0, 7269, 7260, 1, 0, 0, 0, 7269, 7270, 1, 0, 0, 0, 7270, 7271, 1, 0, 0, 0, 7271, 7272, 5, 3, 0, 0, 7272, 7282, 1, 0, 0, 0, 7273, 7274, 5, 432, 0, 0, 7274, 7275, 5, 2, 0, 0, 7275, 7276, 3, 696, 348, 0, 7276, 7277, 3, 674, 337, 0, 7277, 7278, 5, 36, 0, 0, 7278, 7279, 3, 654, 327, 0, 7279, 7280, 5, 3, 0, 0, 7280, 7282, 1, 0, 0, 0, 7281, 7107, 1, 0, 0, 0, 7281, 7113, 1, 0, 0, 0, 7281, 7114, 1, 0, 0, 0, 7281, 7118, 1, 0, 0, 0, 7281, 7119, 1, 0, 0, 0, 7281, 7120, 1, 0, 0, 0, 7281, 7121, 1, 0, 0, 0, 7281, 7122, 1, 0, 0, 0, 7281, 7123, 1, 0, 0, 0, 7281, 7124, 1, 0, 0, 0, 7281, 7131, 1, 0, 0, 0, 7281, 7140, 1, 0, 0, 0, 7281, 7149, 1, 0, 0, 0, 7281, 7162, 1, 0, 0, 0, 7281, 7171, 1, 0, 0, 0, 7281, 7177, 1, 0, 0, 0, 7281, 7192, 1, 0, 0, 0, 7281, 7199, 1, 0, 0, 0, 7281, 7201, 1, 0, 0, 0, 7281, 7218, 1, 0, 0, 0, 7281, 7224, 1, 0, 0, 0, 7281, 7229, 1, 0, 0, 0, 7281, 7239, 1, 0, 0, 0, 7281, 7249, 1, 0, 0, 0, 7281, 7273, 1, 0, 0, 0, 7282, 691, 1, 0, 0, 0, 7283, 7288, 3, 694, 347, 0, 7284, 7285, 5, 6, 0, 0, 7285, 7287, 3, 694, 347, 0, 7286, 7284, 1, 0, 0, 0, 7287, 7290, 1, 0, 0, 0, 7288, 7286, 1, 0, 0, 0, 7288, 7289, 1, 0, 0, 0, 7289, 693, 1, 0, 0, 0, 7290, 7288, 1, 0, 0, 0, 7291, 7294, 3, 674, 337, 0, 7292, 7293, 5, 36, 0, 0, 7293, 7295, 3, 824, 412, 0, 7294, 7292, 1, 0, 0, 0, 7294, 7295, 1, 0, 0, 0, 7295, 695, 1, 0, 0, 0, 7296, 7297, 7, 100, 0, 0, 7297, 697, 1, 0, 0, 0, 7298, 7300, 5, 286, 0, 0, 7299, 7301, 3, 700, 350, 0, 7300, 7299, 1, 0, 0, 0, 7300, 7301, 1, 0, 0, 0, 7301, 7302, 1, 0, 0, 0, 7302, 7304, 3, 682, 341, 0, 7303, 7305, 3, 700, 350, 0, 7304, 7303, 1, 0, 0, 0, 7304, 7305, 1, 0, 0, 0, 7305, 699, 1, 0, 0, 0, 7306, 7307, 5, 147, 0, 0, 7307, 7308, 7, 101, 0, 0, 7308, 701, 1, 0, 0, 0, 7309, 7310, 5, 104, 0, 0, 7310, 7315, 3, 704, 352, 0, 7311, 7312, 5, 6, 0, 0, 7312, 7314, 3, 704, 352, 0, 7313, 7311, 1, 0, 0, 0, 7314, 7317, 1, 0, 0, 0, 7315, 7313, 1, 0, 0, 0, 7315, 7316, 1, 0, 0, 0, 7316, 703, 1, 0, 0, 0, 7317, 7315, 1, 0, 0, 0, 7318, 7319, 3, 818, 409, 0, 7319, 7320, 5, 36, 0, 0, 7320, 7321, 3, 708, 354, 0, 7321, 705, 1, 0, 0, 0, 7322, 7325, 5, 124, 0, 0, 7323, 7326, 3, 708, 354, 0, 7324, 7326, 3, 818, 409, 0, 7325, 7323, 1, 0, 0, 0, 7325, 7324, 1, 0, 0, 0, 7326, 707, 1, 0, 0, 0, 7327, 7329, 5, 2, 0, 0, 7328, 7330, 3, 818, 409, 0, 7329, 7328, 1, 0, 0, 0, 7329, 7330, 1, 0, 0, 0, 7330, 7334, 1, 0, 0, 0, 7331, 7332, 5, 285, 0, 0, 7332, 7333, 5, 147, 0, 0, 7333, 7335, 3, 730, 365, 0, 7334, 7331, 1, 0, 0, 0, 7334, 7335, 1, 0, 0, 0, 7335, 7337, 1, 0, 0, 0, 7336, 7338, 3, 586, 293, 0, 7337, 7336, 1, 0, 0, 0, 7337, 7338, 1, 0, 0, 0, 7338, 7340, 1, 0, 0, 0, 7339, 7341, 3, 710, 355, 0, 7340, 7339, 1, 0, 0, 0, 7340, 7341, 1, 0, 0, 0, 7341, 7342, 1, 0, 0, 0, 7342, 7343, 5, 3, 0, 0, 7343, 709, 1, 0, 0, 0, 7344, 7349, 7, 102, 0, 0, 7345, 7346, 5, 387, 0, 0, 7346, 7347, 3, 712, 356, 0, 7347, 7348, 5, 33, 0, 0, 7348, 7350, 1, 0, 0, 0, 7349, 7345, 1, 0, 0, 0, 7349, 7350, 1, 0, 0, 0, 7350, 7351, 1, 0, 0, 0, 7351, 7352, 3, 712, 356, 0, 7352, 7362, 1, 0, 0, 0, 7353, 7360, 5, 199, 0, 0, 7354, 7355, 5, 434, 0, 0, 7355, 7361, 5, 414, 0, 0, 7356, 7361, 5, 66, 0, 0, 7357, 7361, 5, 467, 0, 0, 7358, 7359, 5, 269, 0, 0, 7359, 7361, 5, 482, 0, 0, 7360, 7354, 1, 0, 0, 0, 7360, 7356, 1, 0, 0, 0, 7360, 7357, 1, 0, 0, 0, 7360, 7358, 1, 0, 0, 0, 7361, 7363, 1, 0, 0, 0, 7362, 7353, 1, 0, 0, 0, 7362, 7363, 1, 0, 0, 0, 7363, 711, 1, 0, 0, 0, 7364, 7367, 5, 362, 0, 0, 7365, 7367, 3, 674, 337, 0, 7366, 7364, 1, 0, 0, 0, 7366, 7365, 1, 0, 0, 0, 7367, 7368, 1, 0, 0, 0, 7368, 7372, 7, 103, 0, 0, 7369, 7370, 5, 434, 0, 0, 7370, 7372, 5, 414, 0, 0, 7371, 7366, 1, 0, 0, 0, 7371, 7369, 1, 0, 0, 0, 7372, 713, 1, 0, 0, 0, 7373, 7381, 3, 716, 358, 0, 7374, 7375, 5, 2, 0, 0, 7375, 7376, 3, 730, 365, 0, 7376, 7377, 5, 6, 0, 0, 7377, 7378, 3, 674, 337, 0, 7378, 7379, 5, 3, 0, 0, 7379, 7381, 1, 0, 0, 0, 7380, 7373, 1, 0, 0, 0, 7380, 7374, 1, 0, 0, 0, 7381, 715, 1, 0, 0, 0, 7382, 7383, 5, 414, 0, 0, 7383, 7385, 5, 2, 0, 0, 7384, 7386, 3, 730, 365, 0, 7385, 7384, 1, 0, 0, 0, 7385, 7386, 1, 0, 0, 0, 7386, 7387, 1, 0, 0, 0, 7387, 7388, 5, 3, 0, 0, 7388, 717, 1, 0, 0, 0, 7389, 7390, 7, 104, 0, 0, 7390, 719, 1, 0, 0, 0, 7391, 7394, 5, 29, 0, 0, 7392, 7394, 3, 722, 361, 0, 7393, 7391, 1, 0, 0, 0, 7393, 7392, 1, 0, 0, 0, 7394, 721, 1, 0, 0, 0, 7395, 7396, 7, 105, 0, 0, 7396, 723, 1, 0, 0, 0, 7397, 7404, 5, 29, 0, 0, 7398, 7399, 5, 278, 0, 0, 7399, 7400, 5, 2, 0, 0, 7400, 7401, 3, 414, 207, 0, 7401, 7402, 5, 3, 0, 0, 7402, 7404, 1, 0, 0, 0, 7403, 7397, 1, 0, 0, 0, 7403, 7398, 1, 0, 0, 0, 7404, 725, 1, 0, 0, 0, 7405, 7412, 3, 720, 360, 0, 7406, 7407, 5, 278, 0, 0, 7407, 7408, 5, 2, 0, 0, 7408, 7409, 3, 414, 207, 0, 7409, 7410, 5, 3, 0, 0, 7410, 7412, 1, 0, 0, 0, 7411, 7405, 1, 0, 0, 0, 7411, 7406, 1, 0, 0, 0, 7412, 727, 1, 0, 0, 0, 7413, 7419, 3, 726, 363, 0, 7414, 7416, 5, 77, 0, 0, 7415, 7414, 1, 0, 0, 0, 7415, 7416, 1, 0, 0, 0, 7416, 7417, 1, 0, 0, 0, 7417, 7419, 7, 106, 0, 0, 7418, 7413, 1, 0, 0, 0, 7418, 7415, 1, 0, 0, 0, 7419, 729, 1, 0, 0, 0, 7420, 7425, 3, 674, 337, 0, 7421, 7422, 5, 6, 0, 0, 7422, 7424, 3, 674, 337, 0, 7423, 7421, 1, 0, 0, 0, 7424, 7427, 1, 0, 0, 0, 7425, 7423, 1, 0, 0, 0, 7425, 7426, 1, 0, 0, 0, 7426, 731, 1, 0, 0, 0, 7427, 7425, 1, 0, 0, 0, 7428, 7429, 5, 2, 0, 0, 7429, 7430, 3, 674, 337, 0, 7430, 7431, 5, 3, 0, 0, 7431, 7434, 1, 0, 0, 0, 7432, 7434, 3, 800, 400, 0, 7433, 7428, 1, 0, 0, 0, 7433, 7432, 1, 0, 0, 0, 7434, 733, 1, 0, 0, 0, 7435, 7438, 3, 674, 337, 0, 7436, 7438, 3, 800, 400, 0, 7437, 7435, 1, 0, 0, 0, 7437, 7436, 1, 0, 0, 0, 7438, 735, 1, 0, 0, 0, 7439, 7444, 3, 738, 369, 0, 7440, 7441, 5, 6, 0, 0, 7441, 7443, 3, 738, 369, 0, 7442, 7440, 1, 0, 0, 0, 7443, 7446, 1, 0, 0, 0, 7444, 7442, 1, 0, 0, 0, 7444, 7445, 1, 0, 0, 0, 7445, 737, 1, 0, 0, 0, 7446, 7444, 1, 0, 0, 0, 7447, 7454, 3, 800, 400, 0, 7448, 7454, 3, 674, 337, 0, 7449, 7450, 3, 820, 410, 0, 7450, 7451, 7, 107, 0, 0, 7451, 7452, 3, 674, 337, 0, 7452, 7454, 1, 0, 0, 0, 7453, 7447, 1, 0, 0, 0, 7453, 7448, 1, 0, 0, 0, 7453, 7449, 1, 0, 0, 0, 7454, 739, 1, 0, 0, 0, 7455, 7465, 5, 4, 0, 0, 7456, 7466, 3, 730, 365, 0, 7457, 7462, 3, 740, 370, 0, 7458, 7459, 5, 6, 0, 0, 7459, 7461, 3, 740, 370, 0, 7460, 7458, 1, 0, 0, 0, 7461, 7464, 1, 0, 0, 0, 7462, 7460, 1, 0, 0, 0, 7462, 7463, 1, 0, 0, 0, 7463, 7466, 1, 0, 0, 0, 7464, 7462, 1, 0, 0, 0, 7465, 7456, 1, 0, 0, 0, 7465, 7457, 1, 0, 0, 0, 7465, 7466, 1, 0, 0, 0, 7466, 7467, 1, 0, 0, 0, 7467, 7468, 5, 5, 0, 0, 7468, 741, 1, 0, 0, 0, 7469, 7478, 3, 826, 413, 0, 7470, 7478, 5, 384, 0, 0, 7471, 7478, 5, 264, 0, 0, 7472, 7478, 5, 176, 0, 0, 7473, 7478, 5, 218, 0, 0, 7474, 7478, 5, 261, 0, 0, 7475, 7478, 5, 326, 0, 0, 7476, 7478, 3, 808, 404, 0, 7477, 7469, 1, 0, 0, 0, 7477, 7470, 1, 0, 0, 0, 7477, 7471, 1, 0, 0, 0, 7477, 7472, 1, 0, 0, 0, 7477, 7473, 1, 0, 0, 0, 7477, 7474, 1, 0, 0, 0, 7477, 7475, 1, 0, 0, 0, 7477, 7476, 1, 0, 0, 0, 7478, 743, 1, 0, 0, 0, 7479, 7480, 7, 108, 0, 0, 7480, 745, 1, 0, 0, 0, 7481, 7482, 3, 674, 337, 0, 7482, 7483, 5, 64, 0, 0, 7483, 7486, 3, 674, 337, 0, 7484, 7485, 5, 62, 0, 0, 7485, 7487, 3, 674, 337, 0, 7486, 7484, 1, 0, 0, 0, 7486, 7487, 1, 0, 0, 0, 7487, 7503, 1, 0, 0, 0, 7488, 7489, 3, 674, 337, 0, 7489, 7490, 5, 62, 0, 0, 7490, 7493, 3, 674, 337, 0, 7491, 7492, 5, 64, 0, 0, 7492, 7494, 3, 674, 337, 0, 7493, 7491, 1, 0, 0, 0, 7493, 7494, 1, 0, 0, 0, 7494, 7503, 1, 0, 0, 0, 7495, 7496, 3, 674, 337, 0, 7496, 7497, 5, 127, 0, 0, 7497, 7498, 3, 674, 337, 0, 7498, 7499, 5, 197, 0, 0, 7499, 7500, 3, 674, 337, 0, 7500, 7503, 1, 0, 0, 0, 7501, 7503, 3, 730, 365, 0, 7502, 7481, 1, 0, 0, 0, 7502, 7488, 1, 0, 0, 0, 7502, 7495, 1, 0, 0, 0, 7502, 7501, 1, 0, 0, 0, 7503, 747, 1, 0, 0, 0, 7504, 7505, 5, 102, 0, 0, 7505, 7506, 3, 674, 337, 0, 7506, 7507, 5, 93, 0, 0, 7507, 7508, 3, 674, 337, 0, 7508, 749, 1, 0, 0, 0, 7509, 7512, 5, 11, 0, 0, 7510, 7513, 3, 824, 412, 0, 7511, 7513, 5, 9, 0, 0, 7512, 7510, 1, 0, 0, 0, 7512, 7511, 1, 0, 0, 0, 7513, 7527, 1, 0, 0, 0, 7514, 7523, 5, 4, 0, 0, 7515, 7524, 3, 674, 337, 0, 7516, 7518, 3, 674, 337, 0, 7517, 7516, 1, 0, 0, 0, 7517, 7518, 1, 0, 0, 0, 7518, 7519, 1, 0, 0, 0, 7519, 7521, 5, 8, 0, 0, 7520, 7522, 3, 674, 337, 0, 7521, 7520, 1, 0, 0, 0, 7521, 7522, 1, 0, 0, 0, 7522, 7524, 1, 0, 0, 0, 7523, 7515, 1, 0, 0, 0, 7523, 7517, 1, 0, 0, 0, 7524, 7525, 1, 0, 0, 0, 7525, 7527, 5, 5, 0, 0, 7526, 7509, 1, 0, 0, 0, 7526, 7514, 1, 0, 0, 0, 7527, 751, 1, 0, 0, 0, 7528, 7530, 3, 750, 375, 0, 7529, 7528, 1, 0, 0, 0, 7530, 7531, 1, 0, 0, 0, 7531, 7529, 1, 0, 0, 0, 7531, 7532, 1, 0, 0, 0, 7532, 753, 1, 0, 0, 0, 7533, 7535, 3, 750, 375, 0, 7534, 7533, 1, 0, 0, 0, 7535, 7538, 1, 0, 0, 0, 7536, 7534, 1, 0, 0, 0, 7536, 7537, 1, 0, 0, 0, 7537, 755, 1, 0, 0, 0, 7538, 7536, 1, 0, 0, 0, 7539, 7544, 3, 758, 379, 0, 7540, 7541, 5, 6, 0, 0, 7541, 7543, 3, 758, 379, 0, 7542, 7540, 1, 0, 0, 0, 7543, 7546, 1, 0, 0, 0, 7544, 7542, 1, 0, 0, 0, 7544, 7545, 1, 0, 0, 0, 7545, 757, 1, 0, 0, 0, 7546, 7544, 1, 0, 0, 0, 7547, 7552, 3, 734, 367, 0, 7548, 7549, 5, 36, 0, 0, 7549, 7553, 3, 824, 412, 0, 7550, 7553, 3, 826, 413, 0, 7551, 7553, 1, 0, 0, 0, 7552, 7548, 1, 0, 0, 0, 7552, 7550, 1, 0, 0, 0, 7552, 7551, 1, 0, 0, 0, 7553, 7556, 1, 0, 0, 0, 7554, 7556, 5, 9, 0, 0, 7555, 7547, 1, 0, 0, 0, 7555, 7554, 1, 0, 0, 0, 7556, 759, 1, 0, 0, 0, 7557, 7562, 3, 780, 390, 0, 7558, 7559, 5, 6, 0, 0, 7559, 7561, 3, 780, 390, 0, 7560, 7558, 1, 0, 0, 0, 7561, 7564, 1, 0, 0, 0, 7562, 7560, 1, 0, 0, 0, 7562, 7563, 1, 0, 0, 0, 7563, 761, 1, 0, 0, 0, 7564, 7562, 1, 0, 0, 0, 7565, 7570, 3, 774, 387, 0, 7566, 7567, 5, 6, 0, 0, 7567, 7569, 3, 774, 387, 0, 7568, 7566, 1, 0, 0, 0, 7569, 7572, 1, 0, 0, 0, 7570, 7568, 1, 0, 0, 0, 7570, 7571, 1, 0, 0, 0, 7571, 763, 1, 0, 0, 0, 7572, 7570, 1, 0, 0, 0, 7573, 7578, 3, 790, 395, 0, 7574, 7575, 5, 6, 0, 0, 7575, 7577, 3, 790, 395, 0, 7576, 7574, 1, 0, 0, 0, 7577, 7580, 1, 0, 0, 0, 7578, 7576, 1, 0, 0, 0, 7578, 7579, 1, 0, 0, 0, 7579, 765, 1, 0, 0, 0, 7580, 7578, 1, 0, 0, 0, 7581, 7586, 3, 788, 394, 0, 7582, 7583, 5, 6, 0, 0, 7583, 7585, 3, 788, 394, 0, 7584, 7582, 1, 0, 0, 0, 7585, 7588, 1, 0, 0, 0, 7586, 7584, 1, 0, 0, 0, 7586, 7587, 1, 0, 0, 0, 7587, 767, 1, 0, 0, 0, 7588, 7586, 1, 0, 0, 0, 7589, 7590, 3, 780, 390, 0, 7590, 769, 1, 0, 0, 0, 7591, 7592, 3, 780, 390, 0, 7592, 771, 1, 0, 0, 0, 7593, 7594, 3, 780, 390, 0, 7594, 773, 1, 0, 0, 0, 7595, 7596, 3, 780, 390, 0, 7596, 775, 1, 0, 0, 0, 7597, 7598, 3, 780, 390, 0, 7598, 777, 1, 0, 0, 0, 7599, 7600, 3, 316, 158, 0, 7600, 779, 1, 0, 0, 0, 7601, 7603, 3, 818, 409, 0, 7602, 7604, 3, 752, 376, 0, 7603, 7602, 1, 0, 0, 0, 7603, 7604, 1, 0, 0, 0, 7604, 781, 1, 0, 0, 0, 7605, 7610, 3, 770, 385, 0, 7606, 7607, 5, 6, 0, 0, 7607, 7609, 3, 770, 385, 0, 7608, 7606, 1, 0, 0, 0, 7609, 7612, 1, 0, 0, 0, 7610, 7608, 1, 0, 0, 0, 7610, 7611, 1, 0, 0, 0, 7611, 783, 1, 0, 0, 0, 7612, 7610, 1, 0, 0, 0, 7613, 7618, 3, 818, 409, 0, 7614, 7615, 5, 6, 0, 0, 7615, 7617, 3, 818, 409, 0, 7616, 7614, 1, 0, 0, 0, 7617, 7620, 1, 0, 0, 0, 7618, 7616, 1, 0, 0, 0, 7618, 7619, 1, 0, 0, 0, 7619, 785, 1, 0, 0, 0, 7620, 7618, 1, 0, 0, 0, 7621, 7622, 3, 316, 158, 0, 7622, 787, 1, 0, 0, 0, 7623, 7624, 3, 316, 158, 0, 7624, 789, 1, 0, 0, 0, 7625, 7626, 3, 316, 158, 0, 7626, 791, 1, 0, 0, 0, 7627, 7628, 3, 818, 409, 0, 7628, 793, 1, 0, 0, 0, 7629, 7630, 3, 818, 409, 0, 7630, 795, 1, 0, 0, 0, 7631, 7636, 3, 820, 410, 0, 7632, 7633, 3, 818, 409, 0, 7633, 7634, 3, 752, 376, 0, 7634, 7636, 1, 0, 0, 0, 7635, 7631, 1, 0, 0, 0, 7635, 7632, 1, 0, 0, 0, 7636, 797, 1, 0, 0, 0, 7637, 7642, 3, 820, 410, 0, 7638, 7639, 3, 818, 409, 0, 7639, 7640, 3, 752, 376, 0, 7640, 7642, 1, 0, 0, 0, 7641, 7637, 1, 0, 0, 0, 7641, 7638, 1, 0, 0, 0, 7642, 799, 1, 0, 0, 0, 7643, 7644, 3, 818, 409, 0, 7644, 7645, 3, 754, 377, 0, 7645, 7648, 1, 0, 0, 0, 7646, 7648, 4, 400, 10, 0, 7647, 7643, 1, 0, 0, 0, 7647, 7646, 1, 0, 0, 0, 7648, 801, 1, 0, 0, 0, 7649, 7650, 3, 818, 409, 0, 7650, 803, 1, 0, 0, 0, 7651, 7656, 3, 820, 410, 0, 7652, 7653, 3, 818, 409, 0, 7653, 7654, 3, 752, 376, 0, 7654, 7656, 1, 0, 0, 0, 7655, 7651, 1, 0, 0, 0, 7655, 7652, 1, 0, 0, 0, 7656, 805, 1, 0, 0, 0, 7657, 7662, 3, 820, 410, 0, 7658, 7659, 3, 818, 409, 0, 7659, 7660, 3, 752, 376, 0, 7660, 7662, 1, 0, 0, 0, 7661, 7657, 1, 0, 0, 0, 7661, 7658, 1, 0, 0, 0, 7662, 807, 1, 0, 0, 0, 7663, 7666, 3, 810, 405, 0, 7664, 7665, 5, 487, 0, 0, 7665, 7667, 3, 810, 405, 0, 7666, 7664, 1, 0, 0, 0, 7666, 7667, 1, 0, 0, 0, 7667, 809, 1, 0, 0, 0, 7668, 7680, 5, 558, 0, 0, 7669, 7680, 5, 560, 0, 0, 7670, 7674, 5, 562, 0, 0, 7671, 7673, 5, 588, 0, 0, 7672, 7671, 1, 0, 0, 0, 7673, 7676, 1, 0, 0, 0, 7674, 7672, 1, 0, 0, 0, 7674, 7675, 1, 0, 0, 0, 7675, 7677, 1, 0, 0, 0, 7676, 7674, 1, 0, 0, 0, 7677, 7680, 5, 589, 0, 0, 7678, 7680, 5, 584, 0, 0, 7679, 7668, 1, 0, 0, 0, 7679, 7669, 1, 0, 0, 0, 7679, 7670, 1, 0, 0, 0, 7679, 7678, 1, 0, 0, 0, 7680, 811, 1, 0, 0, 0, 7681, 7683, 7, 29, 0, 0, 7682, 7681, 1, 0, 0, 0, 7682, 7683, 1, 0, 0, 0, 7683, 7684, 1, 0, 0, 0, 7684, 7685, 5, 571, 0, 0, 7685, 813, 1, 0, 0, 0, 7686, 7692, 3, 822, 411, 0, 7687, 7692, 5, 52, 0, 0, 7688, 7692, 5, 49, 0, 0, 7689, 7692, 5, 89, 0, 0, 7690, 7692, 5, 524, 0, 0, 7691, 7686, 1, 0, 0, 0, 7691, 7687, 1, 0, 0, 0, 7691, 7688, 1, 0, 0, 0, 7691, 7689, 1, 0, 0, 0, 7691, 7690, 1, 0, 0, 0, 7692, 815, 1, 0, 0, 0, 7693, 7698, 3, 814, 407, 0, 7694, 7695, 5, 6, 0, 0, 7695, 7697, 3, 814, 407, 0, 7696, 7694, 1, 0, 0, 0, 7697, 7700, 1, 0, 0, 0, 7698, 7696, 1, 0, 0, 0, 7698, 7699, 1, 0, 0, 0, 7699, 817, 1, 0, 0, 0, 7700, 7698, 1, 0, 0, 0, 7701, 7704, 3, 826, 413, 0, 7702, 7704, 3, 830, 415, 0, 7703, 7701, 1, 0, 0, 0, 7703, 7702, 1, 0, 0, 0, 7704, 819, 1, 0, 0, 0, 7705, 7708, 3, 826, 413, 0, 7706, 7708, 3, 832, 416, 0, 7707, 7705, 1, 0, 0, 0, 7707, 7706, 1, 0, 0, 0, 7708, 821, 1, 0, 0, 0, 7709, 7713, 3, 826, 413, 0, 7710, 7713, 3, 830, 415, 0, 7711, 7713, 3, 832, 416, 0, 7712, 7709, 1, 0, 0, 0, 7712, 7710, 1, 0, 0, 0, 7712, 7711, 1, 0, 0, 0, 7713, 823, 1, 0, 0, 0, 7714, 7719, 3, 826, 413, 0, 7715, 7719, 3, 830, 415, 0, 7716, 7719, 3, 832, 416, 0, 7717, 7719, 3, 834, 417, 0, 7718, 7714, 1, 0, 0, 0, 7718, 7715, 1, 0, 0, 0, 7718, 7716, 1, 0, 0, 0, 7718, 7717, 1, 0, 0, 0, 7719, 825, 1, 0, 0, 0, 7720, 7723, 5, 549, 0, 0, 7721, 7722, 5, 487, 0, 0, 7722, 7724, 3, 810, 405, 0, 7723, 7721, 1, 0, 0, 0, 7723, 7724, 1, 0, 0, 0, 7724, 7732, 1, 0, 0, 0, 7725, 7732, 3, 808, 404, 0, 7726, 7732, 5, 550, 0, 0, 7727, 7732, 5, 554, 0, 0, 7728, 7732, 5, 574, 0, 0, 7729, 7732, 5, 575, 0, 0, 7730, 7732, 3, 828, 414, 0, 7731, 7720, 1, 0, 0, 0, 7731, 7725, 1, 0, 0, 0, 7731, 7726, 1, 0, 0, 0, 7731, 7727, 1, 0, 0, 0, 7731, 7728, 1, 0, 0, 0, 7731, 7729, 1, 0, 0, 0, 7731, 7730, 1, 0, 0, 0, 7732, 827, 1, 0, 0, 0, 7733, 7734, 7, 109, 0, 0, 7734, 829, 1, 0, 0, 0, 7735, 7787, 5, 387, 0, 0, 7736, 7787, 5, 388, 0, 0, 7737, 7787, 3, 662, 331, 0, 7738, 7787, 5, 390, 0, 0, 7739, 7787, 5, 391, 0, 0, 7740, 7787, 3, 664, 332, 0, 7741, 7787, 5, 393, 0, 0, 7742, 7787, 5, 394, 0, 0, 7743, 7787, 5, 395, 0, 0, 7744, 7787, 5, 396, 0, 0, 7745, 7787, 5, 397, 0, 0, 7746, 7787, 5, 398, 0, 0, 7747, 7787, 5, 399, 0, 0, 7748, 7787, 5, 470, 0, 0, 7749, 7787, 5, 400, 0, 0, 7750, 7787, 5, 401, 0, 0, 7751, 7787, 5, 402, 0, 0, 7752, 7787, 5, 403, 0, 0, 7753, 7787, 5, 404, 0, 0, 7754, 7787, 5, 405, 0, 0, 7755, 7787, 5, 406, 0, 0, 7756, 7787, 5, 407, 0, 0, 7757, 7787, 5, 489, 0, 0, 7758, 7787, 5, 408, 0, 0, 7759, 7787, 3, 658, 329, 0, 7760, 7787, 5, 453, 0, 0, 7761, 7787, 5, 410, 0, 0, 7762, 7787, 5, 411, 0, 0, 7763, 7787, 5, 412, 0, 0, 7764, 7787, 5, 413, 0, 0, 7765, 7787, 5, 414, 0, 0, 7766, 7787, 5, 415, 0, 0, 7767, 7787, 5, 416, 0, 0, 7768, 7787, 5, 417, 0, 0, 7769, 7787, 5, 418, 0, 0, 7770, 7787, 5, 419, 0, 0, 7771, 7787, 5, 420, 0, 0, 7772, 7787, 5, 421, 0, 0, 7773, 7787, 5, 422, 0, 0, 7774, 7787, 5, 423, 0, 0, 7775, 7787, 5, 424, 0, 0, 7776, 7787, 5, 425, 0, 0, 7777, 7787, 5, 426, 0, 0, 7778, 7787, 5, 427, 0, 0, 7779, 7787, 5, 428, 0, 0, 7780, 7787, 5, 476, 0, 0, 7781, 7787, 5, 429, 0, 0, 7782, 7787, 5, 430, 0, 0, 7783, 7787, 5, 431, 0, 0, 7784, 7787, 5, 432, 0, 0, 7785, 7787, 5, 474, 0, 0, 7786, 7735, 1, 0, 0, 0, 7786, 7736, 1, 0, 0, 0, 7786, 7737, 1, 0, 0, 0, 7786, 7738, 1, 0, 0, 0, 7786, 7739, 1, 0, 0, 0, 7786, 7740, 1, 0, 0, 0, 7786, 7741, 1, 0, 0, 0, 7786, 7742, 1, 0, 0, 0, 7786, 7743, 1, 0, 0, 0, 7786, 7744, 1, 0, 0, 0, 7786, 7745, 1, 0, 0, 0, 7786, 7746, 1, 0, 0, 0, 7786, 7747, 1, 0, 0, 0, 7786, 7748, 1, 0, 0, 0, 7786, 7749, 1, 0, 0, 0, 7786, 7750, 1, 0, 0, 0, 7786, 7751, 1, 0, 0, 0, 7786, 7752, 1, 0, 0, 0, 7786, 7753, 1, 0, 0, 0, 7786, 7754, 1, 0, 0, 0, 7786, 7755, 1, 0, 0, 0, 7786, 7756, 1, 0, 0, 0, 7786, 7757, 1, 0, 0, 0, 7786, 7758, 1, 0, 0, 0, 7786, 7759, 1, 0, 0, 0, 7786, 7760, 1, 0, 0, 0, 7786, 7761, 1, 0, 0, 0, 7786, 7762, 1, 0, 0, 0, 7786, 7763, 1, 0, 0, 0, 7786, 7764, 1, 0, 0, 0, 7786, 7765, 1, 0, 0, 0, 7786, 7766, 1, 0, 0, 0, 7786, 7767, 1, 0, 0, 0, 7786, 7768, 1, 0, 0, 0, 7786, 7769, 1, 0, 0, 0, 7786, 7770, 1, 0, 0, 0, 7786, 7771, 1, 0, 0, 0, 7786, 7772, 1, 0, 0, 0, 7786, 7773, 1, 0, 0, 0, 7786, 7774, 1, 0, 0, 0, 7786, 7775, 1, 0, 0, 0, 7786, 7776, 1, 0, 0, 0, 7786, 7777, 1, 0, 0, 0, 7786, 7778, 1, 0, 0, 0, 7786, 7779, 1, 0, 0, 0, 7786, 7780, 1, 0, 0, 0, 7786, 7781, 1, 0, 0, 0, 7786, 7782, 1, 0, 0, 0, 7786, 7783, 1, 0, 0, 0, 7786, 7784, 1, 0, 0, 0, 7786, 7785, 1, 0, 0, 0, 7787, 831, 1, 0, 0, 0, 7788, 7789, 7, 110, 0, 0, 7789, 833, 1, 0, 0, 0, 7790, 7791, 7, 111, 0, 0, 7791, 835, 1, 0, 0, 0, 7792, 7794, 3, 838, 419, 0, 7793, 7792, 1, 0, 0, 0, 7793, 7794, 1, 0, 0, 0, 7794, 7805, 1, 0, 0, 0, 7795, 7803, 5, 178, 0, 0, 7796, 7800, 3, 840, 420, 0, 7797, 7800, 5, 178, 0, 0, 7798, 7800, 3, 838, 419, 0, 7799, 7796, 1, 0, 0, 0, 7799, 7797, 1, 0, 0, 0, 7799, 7798, 1, 0, 0, 0, 7800, 7801, 1, 0, 0, 0, 7801, 7799, 1, 0, 0, 0, 7801, 7802, 1, 0, 0, 0, 7802, 7804, 1, 0, 0, 0, 7803, 7799, 1, 0, 0, 0, 7803, 7804, 1, 0, 0, 0, 7804, 7806, 1, 0, 0, 0, 7805, 7795, 1, 0, 0, 0, 7805, 7806, 1, 0, 0, 0, 7806, 7807, 1, 0, 0, 0, 7807, 7811, 5, 146, 0, 0, 7808, 7810, 3, 846, 423, 0, 7809, 7808, 1, 0, 0, 0, 7810, 7813, 1, 0, 0, 0, 7811, 7809, 1, 0, 0, 0, 7811, 7812, 1, 0, 0, 0, 7812, 7815, 1, 0, 0, 0, 7813, 7811, 1, 0, 0, 0, 7814, 7816, 3, 924, 462, 0, 7815, 7814, 1, 0, 0, 0, 7815, 7816, 1, 0, 0, 0, 7816, 7817, 1, 0, 0, 0, 7817, 7819, 5, 454, 0, 0, 7818, 7820, 3, 928, 464, 0, 7819, 7818, 1, 0, 0, 0, 7819, 7820, 1, 0, 0, 0, 7820, 837, 1, 0, 0, 0, 7821, 7822, 5, 18, 0, 0, 7822, 7823, 3, 928, 464, 0, 7823, 7824, 5, 19, 0, 0, 7824, 839, 1, 0, 0, 0, 7825, 7872, 3, 928, 464, 0, 7826, 7827, 5, 496, 0, 0, 7827, 7830, 5, 62, 0, 0, 7828, 7831, 5, 28, 0, 0, 7829, 7831, 3, 818, 409, 0, 7830, 7828, 1, 0, 0, 0, 7830, 7829, 1, 0, 0, 0, 7831, 7873, 1, 0, 0, 0, 7832, 7834, 5, 497, 0, 0, 7833, 7832, 1, 0, 0, 0, 7833, 7834, 1, 0, 0, 0, 7834, 7835, 1, 0, 0, 0, 7835, 7837, 3, 652, 326, 0, 7836, 7838, 3, 98, 49, 0, 7837, 7836, 1, 0, 0, 0, 7837, 7838, 1, 0, 0, 0, 7838, 7841, 1, 0, 0, 0, 7839, 7840, 5, 77, 0, 0, 7840, 7842, 5, 78, 0, 0, 7841, 7839, 1, 0, 0, 0, 7841, 7842, 1, 0, 0, 0, 7842, 7848, 1, 0, 0, 0, 7843, 7846, 3, 844, 422, 0, 7844, 7846, 5, 53, 0, 0, 7845, 7843, 1, 0, 0, 0, 7845, 7844, 1, 0, 0, 0, 7846, 7847, 1, 0, 0, 0, 7847, 7849, 3, 930, 465, 0, 7848, 7845, 1, 0, 0, 0, 7848, 7849, 1, 0, 0, 0, 7849, 7873, 1, 0, 0, 0, 7850, 7852, 5, 269, 0, 0, 7851, 7850, 1, 0, 0, 0, 7851, 7852, 1, 0, 0, 0, 7852, 7853, 1, 0, 0, 0, 7853, 7855, 5, 324, 0, 0, 7854, 7851, 1, 0, 0, 0, 7854, 7855, 1, 0, 0, 0, 7855, 7856, 1, 0, 0, 0, 7856, 7868, 5, 172, 0, 0, 7857, 7858, 5, 2, 0, 0, 7858, 7863, 3, 842, 421, 0, 7859, 7860, 5, 6, 0, 0, 7860, 7862, 3, 842, 421, 0, 7861, 7859, 1, 0, 0, 0, 7862, 7865, 1, 0, 0, 0, 7863, 7861, 1, 0, 0, 0, 7863, 7864, 1, 0, 0, 0, 7864, 7866, 1, 0, 0, 0, 7865, 7863, 1, 0, 0, 0, 7866, 7867, 5, 3, 0, 0, 7867, 7869, 1, 0, 0, 0, 7868, 7857, 1, 0, 0, 0, 7868, 7869, 1, 0, 0, 0, 7869, 7870, 1, 0, 0, 0, 7870, 7871, 7, 112, 0, 0, 7871, 7873, 3, 560, 280, 0, 7872, 7826, 1, 0, 0, 0, 7872, 7833, 1, 0, 0, 0, 7872, 7854, 1, 0, 0, 0, 7873, 7874, 1, 0, 0, 0, 7874, 7875, 5, 7, 0, 0, 7875, 841, 1, 0, 0, 0, 7876, 7877, 3, 928, 464, 0, 7877, 7878, 3, 652, 326, 0, 7878, 843, 1, 0, 0, 0, 7879, 7880, 7, 113, 0, 0, 7880, 845, 1, 0, 0, 0, 7881, 7882, 3, 836, 418, 0, 7882, 7883, 5, 7, 0, 0, 7883, 7906, 1, 0, 0, 0, 7884, 7906, 3, 874, 437, 0, 7885, 7906, 3, 876, 438, 0, 7886, 7906, 3, 852, 426, 0, 7887, 7906, 3, 860, 430, 0, 7888, 7906, 3, 864, 432, 0, 7889, 7906, 3, 866, 433, 0, 7890, 7906, 3, 870, 435, 0, 7891, 7906, 3, 872, 436, 0, 7892, 7906, 3, 880, 440, 0, 7893, 7906, 3, 884, 442, 0, 7894, 7906, 3, 886, 443, 0, 7895, 7906, 3, 848, 424, 0, 7896, 7906, 3, 850, 425, 0, 7897, 7906, 3, 854, 427, 0, 7898, 7906, 3, 890, 445, 0, 7899, 7906, 3, 894, 447, 0, 7900, 7906, 3, 898, 449, 0, 7901, 7906, 3, 914, 457, 0, 7902, 7906, 3, 916, 458, 0, 7903, 7906, 3, 918, 459, 0, 7904, 7906, 3, 920, 460, 0, 7905, 7881, 1, 0, 0, 0, 7905, 7884, 1, 0, 0, 0, 7905, 7885, 1, 0, 0, 0, 7905, 7886, 1, 0, 0, 0, 7905, 7887, 1, 0, 0, 0, 7905, 7888, 1, 0, 0, 0, 7905, 7889, 1, 0, 0, 0, 7905, 7890, 1, 0, 0, 0, 7905, 7891, 1, 0, 0, 0, 7905, 7892, 1, 0, 0, 0, 7905, 7893, 1, 0, 0, 0, 7905, 7894, 1, 0, 0, 0, 7905, 7895, 1, 0, 0, 0, 7905, 7896, 1, 0, 0, 0, 7905, 7897, 1, 0, 0, 0, 7905, 7898, 1, 0, 0, 0, 7905, 7899, 1, 0, 0, 0, 7905, 7900, 1, 0, 0, 0, 7905, 7901, 1, 0, 0, 0, 7905, 7902, 1, 0, 0, 0, 7905, 7903, 1, 0, 0, 0, 7905, 7904, 1, 0, 0, 0, 7906, 847, 1, 0, 0, 0, 7907, 7908, 5, 498, 0, 0, 7908, 7909, 3, 930, 465, 0, 7909, 7910, 5, 7, 0, 0, 7910, 849, 1, 0, 0, 0, 7911, 7912, 5, 433, 0, 0, 7912, 7919, 3, 928, 464, 0, 7913, 7915, 5, 2, 0, 0, 7914, 7916, 3, 730, 365, 0, 7915, 7914, 1, 0, 0, 0, 7915, 7916, 1, 0, 0, 0, 7916, 7917, 1, 0, 0, 0, 7917, 7918, 5, 3, 0, 0, 7918, 7920, 5, 7, 0, 0, 7919, 7913, 1, 0, 0, 0, 7919, 7920, 1, 0, 0, 0, 7920, 7931, 1, 0, 0, 0, 7921, 7922, 5, 57, 0, 0, 7922, 7923, 3, 928, 464, 0, 7923, 7925, 5, 2, 0, 0, 7924, 7926, 3, 730, 365, 0, 7925, 7924, 1, 0, 0, 0, 7925, 7926, 1, 0, 0, 0, 7926, 7927, 1, 0, 0, 0, 7927, 7928, 5, 3, 0, 0, 7928, 7929, 5, 7, 0, 0, 7929, 7931, 1, 0, 0, 0, 7930, 7911, 1, 0, 0, 0, 7930, 7921, 1, 0, 0, 0, 7931, 851, 1, 0, 0, 0, 7932, 7933, 3, 858, 429, 0, 7933, 7934, 3, 844, 422, 0, 7934, 7935, 3, 930, 465, 0, 7935, 7936, 5, 7, 0, 0, 7936, 853, 1, 0, 0, 0, 7937, 7939, 5, 499, 0, 0, 7938, 7940, 7, 114, 0, 0, 7939, 7938, 1, 0, 0, 0, 7939, 7940, 1, 0, 0, 0, 7940, 7941, 1, 0, 0, 0, 7941, 7942, 5, 500, 0, 0, 7942, 7947, 3, 856, 428, 0, 7943, 7944, 5, 6, 0, 0, 7944, 7946, 3, 856, 428, 0, 7945, 7943, 1, 0, 0, 0, 7946, 7949, 1, 0, 0, 0, 7947, 7945, 1, 0, 0, 0, 7947, 7948, 1, 0, 0, 0, 7948, 7950, 1, 0, 0, 0, 7949, 7947, 1, 0, 0, 0, 7950, 7951, 5, 7, 0, 0, 7951, 855, 1, 0, 0, 0, 7952, 7953, 3, 858, 429, 0, 7953, 7954, 3, 844, 422, 0, 7954, 7955, 3, 818, 409, 0, 7955, 857, 1, 0, 0, 0, 7956, 7959, 3, 316, 158, 0, 7957, 7959, 5, 28, 0, 0, 7958, 7956, 1, 0, 0, 0, 7958, 7957, 1, 0, 0, 0, 7959, 7966, 1, 0, 0, 0, 7960, 7961, 5, 4, 0, 0, 7961, 7962, 3, 674, 337, 0, 7962, 7963, 5, 5, 0, 0, 7963, 7965, 1, 0, 0, 0, 7964, 7960, 1, 0, 0, 0, 7965, 7968, 1, 0, 0, 0, 7966, 7964, 1, 0, 0, 0, 7966, 7967, 1, 0, 0, 0, 7967, 859, 1, 0, 0, 0, 7968, 7966, 1, 0, 0, 0, 7969, 7970, 5, 220, 0, 0, 7970, 7971, 3, 930, 465, 0, 7971, 7975, 5, 93, 0, 0, 7972, 7974, 3, 846, 423, 0, 7973, 7972, 1, 0, 0, 0, 7974, 7977, 1, 0, 0, 0, 7975, 7973, 1, 0, 0, 0, 7975, 7976, 1, 0, 0, 0, 7976, 7989, 1, 0, 0, 0, 7977, 7975, 1, 0, 0, 0, 7978, 7979, 5, 502, 0, 0, 7979, 7980, 3, 674, 337, 0, 7980, 7984, 5, 93, 0, 0, 7981, 7983, 3, 846, 423, 0, 7982, 7981, 1, 0, 0, 0, 7983, 7986, 1, 0, 0, 0, 7984, 7982, 1, 0, 0, 0, 7984, 7985, 1, 0, 0, 0, 7985, 7988, 1, 0, 0, 0, 7986, 7984, 1, 0, 0, 0, 7987, 7978, 1, 0, 0, 0, 7988, 7991, 1, 0, 0, 0, 7989, 7987, 1, 0, 0, 0, 7989, 7990, 1, 0, 0, 0, 7990, 7993, 1, 0, 0, 0, 7991, 7989, 1, 0, 0, 0, 7992, 7994, 3, 862, 431, 0, 7993, 7992, 1, 0, 0, 0, 7993, 7994, 1, 0, 0, 0, 7994, 7995, 1, 0, 0, 0, 7995, 7996, 5, 454, 0, 0, 7996, 7997, 5, 220, 0, 0, 7997, 7998, 5, 7, 0, 0, 7998, 861, 1, 0, 0, 0, 7999, 8003, 5, 58, 0, 0, 8000, 8002, 3, 846, 423, 0, 8001, 8000, 1, 0, 0, 0, 8002, 8005, 1, 0, 0, 0, 8003, 8001, 1, 0, 0, 0, 8003, 8004, 1, 0, 0, 0, 8004, 863, 1, 0, 0, 0, 8005, 8003, 1, 0, 0, 0, 8006, 8008, 5, 40, 0, 0, 8007, 8009, 3, 930, 465, 0, 8008, 8007, 1, 0, 0, 0, 8008, 8009, 1, 0, 0, 0, 8009, 8019, 1, 0, 0, 0, 8010, 8011, 5, 102, 0, 0, 8011, 8012, 3, 730, 365, 0, 8012, 8016, 5, 93, 0, 0, 8013, 8015, 3, 846, 423, 0, 8014, 8013, 1, 0, 0, 0, 8015, 8018, 1, 0, 0, 0, 8016, 8014, 1, 0, 0, 0, 8016, 8017, 1, 0, 0, 0, 8017, 8020, 1, 0, 0, 0, 8018, 8016, 1, 0, 0, 0, 8019, 8010, 1, 0, 0, 0, 8020, 8021, 1, 0, 0, 0, 8021, 8019, 1, 0, 0, 0, 8021, 8022, 1, 0, 0, 0, 8022, 8024, 1, 0, 0, 0, 8023, 8025, 3, 862, 431, 0, 8024, 8023, 1, 0, 0, 0, 8024, 8025, 1, 0, 0, 0, 8025, 8026, 1, 0, 0, 0, 8026, 8027, 5, 454, 0, 0, 8027, 8028, 5, 40, 0, 0, 8028, 8029, 5, 7, 0, 0, 8029, 865, 1, 0, 0, 0, 8030, 8032, 3, 838, 419, 0, 8031, 8030, 1, 0, 0, 0, 8031, 8032, 1, 0, 0, 0, 8032, 8037, 1, 0, 0, 0, 8033, 8034, 5, 503, 0, 0, 8034, 8038, 3, 674, 337, 0, 8035, 8036, 5, 62, 0, 0, 8036, 8038, 3, 868, 434, 0, 8037, 8033, 1, 0, 0, 0, 8037, 8035, 1, 0, 0, 0, 8037, 8038, 1, 0, 0, 0, 8038, 8039, 1, 0, 0, 0, 8039, 8040, 3, 882, 441, 0, 8040, 867, 1, 0, 0, 0, 8041, 8042, 3, 314, 157, 0, 8042, 8065, 5, 68, 0, 0, 8043, 8045, 3, 818, 409, 0, 8044, 8046, 3, 534, 267, 0, 8045, 8044, 1, 0, 0, 0, 8045, 8046, 1, 0, 0, 0, 8046, 8066, 1, 0, 0, 0, 8047, 8066, 3, 560, 280, 0, 8048, 8066, 3, 520, 260, 0, 8049, 8050, 5, 202, 0, 0, 8050, 8053, 3, 674, 337, 0, 8051, 8052, 5, 100, 0, 0, 8052, 8054, 3, 730, 365, 0, 8053, 8051, 1, 0, 0, 0, 8053, 8054, 1, 0, 0, 0, 8054, 8066, 1, 0, 0, 0, 8055, 8057, 5, 504, 0, 0, 8056, 8055, 1, 0, 0, 0, 8056, 8057, 1, 0, 0, 0, 8057, 8058, 1, 0, 0, 0, 8058, 8059, 3, 674, 337, 0, 8059, 8060, 5, 24, 0, 0, 8060, 8063, 3, 674, 337, 0, 8061, 8062, 5, 147, 0, 0, 8062, 8064, 3, 674, 337, 0, 8063, 8061, 1, 0, 0, 0, 8063, 8064, 1, 0, 0, 0, 8064, 8066, 1, 0, 0, 0, 8065, 8043, 1, 0, 0, 0, 8065, 8047, 1, 0, 0, 0, 8065, 8048, 1, 0, 0, 0, 8065, 8049, 1, 0, 0, 0, 8065, 8056, 1, 0, 0, 0, 8066, 869, 1, 0, 0, 0, 8067, 8069, 3, 838, 419, 0, 8068, 8067, 1, 0, 0, 0, 8068, 8069, 1, 0, 0, 0, 8069, 8070, 1, 0, 0, 0, 8070, 8071, 5, 505, 0, 0, 8071, 8074, 3, 314, 157, 0, 8072, 8073, 5, 506, 0, 0, 8073, 8075, 5, 571, 0, 0, 8074, 8072, 1, 0, 0, 0, 8074, 8075, 1, 0, 0, 0, 8075, 8076, 1, 0, 0, 0, 8076, 8077, 5, 68, 0, 0, 8077, 8078, 5, 35, 0, 0, 8078, 8079, 3, 674, 337, 0, 8079, 8080, 3, 882, 441, 0, 8080, 871, 1, 0, 0, 0, 8081, 8083, 7, 115, 0, 0, 8082, 8084, 3, 928, 464, 0, 8083, 8082, 1, 0, 0, 0, 8083, 8084, 1, 0, 0, 0, 8084, 8087, 1, 0, 0, 0, 8085, 8086, 5, 102, 0, 0, 8086, 8088, 3, 930, 465, 0, 8087, 8085, 1, 0, 0, 0, 8087, 8088, 1, 0, 0, 0, 8088, 8089, 1, 0, 0, 0, 8089, 8090, 5, 7, 0, 0, 8090, 873, 1, 0, 0, 0, 8091, 8106, 5, 508, 0, 0, 8092, 8093, 5, 268, 0, 0, 8093, 8107, 3, 930, 465, 0, 8094, 8101, 5, 509, 0, 0, 8095, 8096, 5, 202, 0, 0, 8096, 8097, 3, 674, 337, 0, 8097, 8098, 5, 100, 0, 0, 8098, 8099, 3, 730, 365, 0, 8099, 8102, 1, 0, 0, 0, 8100, 8102, 3, 560, 280, 0, 8101, 8095, 1, 0, 0, 0, 8101, 8100, 1, 0, 0, 0, 8102, 8107, 1, 0, 0, 0, 8103, 8105, 3, 930, 465, 0, 8104, 8103, 1, 0, 0, 0, 8104, 8105, 1, 0, 0, 0, 8105, 8107, 1, 0, 0, 0, 8106, 8092, 1, 0, 0, 0, 8106, 8094, 1, 0, 0, 0, 8106, 8104, 1, 0, 0, 0, 8107, 8108, 1, 0, 0, 0, 8108, 8109, 5, 7, 0, 0, 8109, 875, 1, 0, 0, 0, 8110, 8140, 5, 510, 0, 0, 8111, 8113, 7, 116, 0, 0, 8112, 8111, 1, 0, 0, 0, 8112, 8113, 1, 0, 0, 0, 8113, 8126, 1, 0, 0, 0, 8114, 8127, 3, 826, 413, 0, 8115, 8116, 5, 511, 0, 0, 8116, 8127, 3, 808, 404, 0, 8117, 8124, 3, 808, 404, 0, 8118, 8119, 5, 6, 0, 0, 8119, 8121, 3, 674, 337, 0, 8120, 8118, 1, 0, 0, 0, 8121, 8122, 1, 0, 0, 0, 8122, 8120, 1, 0, 0, 0, 8122, 8123, 1, 0, 0, 0, 8123, 8125, 1, 0, 0, 0, 8124, 8120, 1, 0, 0, 0, 8124, 8125, 1, 0, 0, 0, 8125, 8127, 1, 0, 0, 0, 8126, 8114, 1, 0, 0, 0, 8126, 8115, 1, 0, 0, 0, 8126, 8117, 1, 0, 0, 0, 8126, 8127, 1, 0, 0, 0, 8127, 8137, 1, 0, 0, 0, 8128, 8129, 5, 100, 0, 0, 8129, 8134, 3, 878, 439, 0, 8130, 8131, 5, 6, 0, 0, 8131, 8133, 3, 878, 439, 0, 8132, 8130, 1, 0, 0, 0, 8133, 8136, 1, 0, 0, 0, 8134, 8132, 1, 0, 0, 0, 8134, 8135, 1, 0, 0, 0, 8135, 8138, 1, 0, 0, 0, 8136, 8134, 1, 0, 0, 0, 8137, 8128, 1, 0, 0, 0, 8137, 8138, 1, 0, 0, 0, 8138, 8139, 1, 0, 0, 0, 8139, 8141, 5, 7, 0, 0, 8140, 8112, 1, 0, 0, 0, 8140, 8141, 1, 0, 0, 0, 8141, 877, 1, 0, 0, 0, 8142, 8143, 3, 826, 413, 0, 8143, 8144, 5, 10, 0, 0, 8144, 8145, 3, 674, 337, 0, 8145, 879, 1, 0, 0, 0, 8146, 8147, 5, 518, 0, 0, 8147, 8150, 3, 930, 465, 0, 8148, 8149, 5, 6, 0, 0, 8149, 8151, 3, 930, 465, 0, 8150, 8148, 1, 0, 0, 0, 8150, 8151, 1, 0, 0, 0, 8151, 8152, 1, 0, 0, 0, 8152, 8153, 5, 7, 0, 0, 8153, 881, 1, 0, 0, 0, 8154, 8158, 5, 519, 0, 0, 8155, 8157, 3, 846, 423, 0, 8156, 8155, 1, 0, 0, 0, 8157, 8160, 1, 0, 0, 0, 8158, 8156, 1, 0, 0, 0, 8158, 8159, 1, 0, 0, 0, 8159, 8161, 1, 0, 0, 0, 8160, 8158, 1, 0, 0, 0, 8161, 8162, 5, 454, 0, 0, 8162, 8164, 5, 519, 0, 0, 8163, 8165, 3, 928, 464, 0, 8164, 8163, 1, 0, 0, 0, 8164, 8165, 1, 0, 0, 0, 8165, 8166, 1, 0, 0, 0, 8166, 8167, 5, 7, 0, 0, 8167, 883, 1, 0, 0, 0, 8168, 8170, 3, 4, 2, 0, 8169, 8171, 3, 888, 444, 0, 8170, 8169, 1, 0, 0, 0, 8170, 8171, 1, 0, 0, 0, 8171, 8172, 1, 0, 0, 0, 8172, 8173, 5, 7, 0, 0, 8173, 885, 1, 0, 0, 0, 8174, 8175, 5, 202, 0, 0, 8175, 8191, 3, 674, 337, 0, 8176, 8178, 3, 888, 444, 0, 8177, 8176, 1, 0, 0, 0, 8177, 8178, 1, 0, 0, 0, 8178, 8181, 1, 0, 0, 0, 8179, 8180, 5, 100, 0, 0, 8180, 8182, 3, 730, 365, 0, 8181, 8179, 1, 0, 0, 0, 8181, 8182, 1, 0, 0, 0, 8182, 8192, 1, 0, 0, 0, 8183, 8184, 5, 100, 0, 0, 8184, 8186, 3, 730, 365, 0, 8185, 8183, 1, 0, 0, 0, 8185, 8186, 1, 0, 0, 0, 8186, 8188, 1, 0, 0, 0, 8187, 8189, 3, 888, 444, 0, 8188, 8187, 1, 0, 0, 0, 8188, 8189, 1, 0, 0, 0, 8189, 8192, 1, 0, 0, 0, 8190, 8192, 1, 0, 0, 0, 8191, 8177, 1, 0, 0, 0, 8191, 8185, 1, 0, 0, 0, 8191, 8190, 1, 0, 0, 0, 8192, 8193, 1, 0, 0, 0, 8193, 8194, 5, 7, 0, 0, 8194, 887, 1, 0, 0, 0, 8195, 8197, 5, 71, 0, 0, 8196, 8198, 5, 346, 0, 0, 8197, 8196, 1, 0, 0, 0, 8197, 8198, 1, 0, 0, 0, 8198, 8199, 1, 0, 0, 0, 8199, 8200, 3, 730, 365, 0, 8200, 889, 1, 0, 0, 0, 8201, 8233, 5, 520, 0, 0, 8202, 8207, 3, 922, 461, 0, 8203, 8205, 5, 269, 0, 0, 8204, 8203, 1, 0, 0, 0, 8204, 8205, 1, 0, 0, 0, 8205, 8206, 1, 0, 0, 0, 8206, 8208, 5, 324, 0, 0, 8207, 8204, 1, 0, 0, 0, 8207, 8208, 1, 0, 0, 0, 8208, 8209, 1, 0, 0, 0, 8209, 8217, 5, 62, 0, 0, 8210, 8218, 3, 560, 280, 0, 8211, 8212, 5, 202, 0, 0, 8212, 8215, 3, 930, 465, 0, 8213, 8214, 5, 100, 0, 0, 8214, 8216, 3, 730, 365, 0, 8215, 8213, 1, 0, 0, 0, 8215, 8216, 1, 0, 0, 0, 8216, 8218, 1, 0, 0, 0, 8217, 8210, 1, 0, 0, 0, 8217, 8211, 1, 0, 0, 0, 8218, 8234, 1, 0, 0, 0, 8219, 8231, 3, 818, 409, 0, 8220, 8221, 5, 2, 0, 0, 8221, 8226, 3, 892, 446, 0, 8222, 8223, 5, 6, 0, 0, 8223, 8225, 3, 892, 446, 0, 8224, 8222, 1, 0, 0, 0, 8225, 8228, 1, 0, 0, 0, 8226, 8224, 1, 0, 0, 0, 8226, 8227, 1, 0, 0, 0, 8227, 8229, 1, 0, 0, 0, 8228, 8226, 1, 0, 0, 0, 8229, 8230, 5, 3, 0, 0, 8230, 8232, 1, 0, 0, 0, 8231, 8220, 1, 0, 0, 0, 8231, 8232, 1, 0, 0, 0, 8232, 8234, 1, 0, 0, 0, 8233, 8202, 1, 0, 0, 0, 8233, 8219, 1, 0, 0, 0, 8234, 8235, 1, 0, 0, 0, 8235, 8236, 5, 7, 0, 0, 8236, 891, 1, 0, 0, 0, 8237, 8238, 3, 818, 409, 0, 8238, 8239, 5, 20, 0, 0, 8239, 8241, 1, 0, 0, 0, 8240, 8237, 1, 0, 0, 0, 8240, 8241, 1, 0, 0, 0, 8241, 8242, 1, 0, 0, 0, 8242, 8243, 3, 674, 337, 0, 8243, 893, 1, 0, 0, 0, 8244, 8246, 5, 61, 0, 0, 8245, 8247, 3, 896, 448, 0, 8246, 8245, 1, 0, 0, 0, 8246, 8247, 1, 0, 0, 0, 8247, 8249, 1, 0, 0, 0, 8248, 8250, 3, 332, 166, 0, 8249, 8248, 1, 0, 0, 0, 8249, 8250, 1, 0, 0, 0, 8250, 8251, 1, 0, 0, 0, 8251, 8252, 3, 922, 461, 0, 8252, 8253, 5, 71, 0, 0, 8253, 8254, 3, 730, 365, 0, 8254, 8255, 5, 7, 0, 0, 8255, 895, 1, 0, 0, 0, 8256, 8271, 5, 268, 0, 0, 8257, 8271, 5, 293, 0, 0, 8258, 8271, 5, 207, 0, 0, 8259, 8271, 5, 249, 0, 0, 8260, 8262, 7, 50, 0, 0, 8261, 8260, 1, 0, 0, 0, 8261, 8262, 1, 0, 0, 0, 8262, 8263, 1, 0, 0, 0, 8263, 8271, 3, 674, 337, 0, 8264, 8271, 5, 30, 0, 0, 8265, 8268, 7, 117, 0, 0, 8266, 8269, 3, 674, 337, 0, 8267, 8269, 5, 30, 0, 0, 8268, 8266, 1, 0, 0, 0, 8268, 8267, 1, 0, 0, 0, 8268, 8269, 1, 0, 0, 0, 8269, 8271, 1, 0, 0, 0, 8270, 8256, 1, 0, 0, 0, 8270, 8257, 1, 0, 0, 0, 8270, 8258, 1, 0, 0, 0, 8270, 8259, 1, 0, 0, 0, 8270, 8261, 1, 0, 0, 0, 8270, 8264, 1, 0, 0, 0, 8270, 8265, 1, 0, 0, 0, 8271, 897, 1, 0, 0, 0, 8272, 8274, 5, 265, 0, 0, 8273, 8275, 3, 896, 448, 0, 8274, 8273, 1, 0, 0, 0, 8274, 8275, 1, 0, 0, 0, 8275, 8276, 1, 0, 0, 0, 8276, 8277, 3, 922, 461, 0, 8277, 8278, 5, 7, 0, 0, 8278, 899, 1, 0, 0, 0, 8279, 8281, 3, 572, 286, 0, 8280, 8279, 1, 0, 0, 0, 8280, 8281, 1, 0, 0, 0, 8281, 8282, 1, 0, 0, 0, 8282, 8283, 5, 525, 0, 0, 8283, 8285, 5, 71, 0, 0, 8284, 8286, 5, 81, 0, 0, 8285, 8284, 1, 0, 0, 0, 8285, 8286, 1, 0, 0, 0, 8286, 8287, 1, 0, 0, 0, 8287, 8289, 3, 774, 387, 0, 8288, 8290, 5, 9, 0, 0, 8289, 8288, 1, 0, 0, 0, 8289, 8290, 1, 0, 0, 0, 8290, 8295, 1, 0, 0, 0, 8291, 8293, 5, 36, 0, 0, 8292, 8291, 1, 0, 0, 0, 8292, 8293, 1, 0, 0, 0, 8293, 8294, 1, 0, 0, 0, 8294, 8296, 3, 818, 409, 0, 8295, 8292, 1, 0, 0, 0, 8295, 8296, 1, 0, 0, 0, 8296, 8297, 1, 0, 0, 0, 8297, 8298, 5, 100, 0, 0, 8298, 8299, 3, 902, 451, 0, 8299, 8300, 5, 80, 0, 0, 8300, 8302, 3, 674, 337, 0, 8301, 8303, 3, 904, 452, 0, 8302, 8301, 1, 0, 0, 0, 8303, 8304, 1, 0, 0, 0, 8304, 8302, 1, 0, 0, 0, 8304, 8305, 1, 0, 0, 0, 8305, 901, 1, 0, 0, 0, 8306, 8308, 5, 81, 0, 0, 8307, 8306, 1, 0, 0, 0, 8307, 8308, 1, 0, 0, 0, 8308, 8309, 1, 0, 0, 0, 8309, 8311, 3, 774, 387, 0, 8310, 8312, 5, 9, 0, 0, 8311, 8310, 1, 0, 0, 0, 8311, 8312, 1, 0, 0, 0, 8312, 8318, 1, 0, 0, 0, 8313, 8316, 3, 564, 282, 0, 8314, 8316, 3, 608, 304, 0, 8315, 8313, 1, 0, 0, 0, 8315, 8314, 1, 0, 0, 0, 8316, 8318, 1, 0, 0, 0, 8317, 8307, 1, 0, 0, 0, 8317, 8315, 1, 0, 0, 0, 8318, 8323, 1, 0, 0, 0, 8319, 8321, 5, 36, 0, 0, 8320, 8319, 1, 0, 0, 0, 8320, 8321, 1, 0, 0, 0, 8321, 8322, 1, 0, 0, 0, 8322, 8324, 3, 818, 409, 0, 8323, 8320, 1, 0, 0, 0, 8323, 8324, 1, 0, 0, 0, 8324, 903, 1, 0, 0, 0, 8325, 8326, 5, 102, 0, 0, 8326, 8329, 5, 526, 0, 0, 8327, 8328, 5, 33, 0, 0, 8328, 8330, 3, 674, 337, 0, 8329, 8327, 1, 0, 0, 0, 8329, 8330, 1, 0, 0, 0, 8330, 8331, 1, 0, 0, 0, 8331, 8336, 5, 93, 0, 0, 8332, 8337, 3, 908, 454, 0, 8333, 8337, 5, 182, 0, 0, 8334, 8335, 5, 57, 0, 0, 8335, 8337, 5, 270, 0, 0, 8336, 8332, 1, 0, 0, 0, 8336, 8333, 1, 0, 0, 0, 8336, 8334, 1, 0, 0, 0, 8337, 8352, 1, 0, 0, 0, 8338, 8339, 5, 102, 0, 0, 8339, 8340, 5, 77, 0, 0, 8340, 8343, 5, 526, 0, 0, 8341, 8342, 5, 33, 0, 0, 8342, 8344, 3, 674, 337, 0, 8343, 8341, 1, 0, 0, 0, 8343, 8344, 1, 0, 0, 0, 8344, 8345, 1, 0, 0, 0, 8345, 8349, 5, 93, 0, 0, 8346, 8350, 3, 906, 453, 0, 8347, 8348, 5, 57, 0, 0, 8348, 8350, 5, 270, 0, 0, 8349, 8346, 1, 0, 0, 0, 8349, 8347, 1, 0, 0, 0, 8350, 8352, 1, 0, 0, 0, 8351, 8325, 1, 0, 0, 0, 8351, 8338, 1, 0, 0, 0, 8352, 905, 1, 0, 0, 0, 8353, 8355, 5, 241, 0, 0, 8354, 8356, 3, 144, 72, 0, 8355, 8354, 1, 0, 0, 0, 8355, 8356, 1, 0, 0, 0, 8356, 8360, 1, 0, 0, 0, 8357, 8358, 5, 463, 0, 0, 8358, 8359, 7, 76, 0, 0, 8359, 8361, 5, 450, 0, 0, 8360, 8357, 1, 0, 0, 0, 8360, 8361, 1, 0, 0, 0, 8361, 8362, 1, 0, 0, 0, 8362, 8363, 3, 910, 455, 0, 8363, 907, 1, 0, 0, 0, 8364, 8365, 5, 369, 0, 0, 8365, 8383, 5, 333, 0, 0, 8366, 8367, 3, 800, 400, 0, 8367, 8368, 5, 10, 0, 0, 8368, 8369, 3, 912, 456, 0, 8369, 8384, 1, 0, 0, 0, 8370, 8371, 3, 144, 72, 0, 8371, 8372, 5, 10, 0, 0, 8372, 8373, 5, 2, 0, 0, 8373, 8378, 3, 912, 456, 0, 8374, 8375, 5, 6, 0, 0, 8375, 8377, 3, 912, 456, 0, 8376, 8374, 1, 0, 0, 0, 8377, 8380, 1, 0, 0, 0, 8378, 8376, 1, 0, 0, 0, 8378, 8379, 1, 0, 0, 0, 8379, 8381, 1, 0, 0, 0, 8380, 8378, 1, 0, 0, 0, 8381, 8382, 5, 3, 0, 0, 8382, 8384, 1, 0, 0, 0, 8383, 8366, 1, 0, 0, 0, 8383, 8370, 1, 0, 0, 0, 8384, 8385, 1, 0, 0, 0, 8385, 8383, 1, 0, 0, 0, 8385, 8386, 1, 0, 0, 0, 8386, 909, 1, 0, 0, 0, 8387, 8388, 5, 422, 0, 0, 8388, 8389, 5, 2, 0, 0, 8389, 8394, 3, 912, 456, 0, 8390, 8391, 5, 6, 0, 0, 8391, 8393, 3, 912, 456, 0, 8392, 8390, 1, 0, 0, 0, 8393, 8396, 1, 0, 0, 0, 8394, 8392, 1, 0, 0, 0, 8394, 8395, 1, 0, 0, 0, 8395, 8397, 1, 0, 0, 0, 8396, 8394, 1, 0, 0, 0, 8397, 8398, 5, 3, 0, 0, 8398, 8402, 1, 0, 0, 0, 8399, 8400, 5, 53, 0, 0, 8400, 8402, 5, 422, 0, 0, 8401, 8387, 1, 0, 0, 0, 8401, 8399, 1, 0, 0, 0, 8402, 911, 1, 0, 0, 0, 8403, 8406, 3, 588, 294, 0, 8404, 8406, 5, 53, 0, 0, 8405, 8403, 1, 0, 0, 0, 8405, 8404, 1, 0, 0, 0, 8406, 913, 1, 0, 0, 0, 8407, 8408, 5, 157, 0, 0, 8408, 8409, 3, 922, 461, 0, 8409, 8410, 5, 7, 0, 0, 8410, 915, 1, 0, 0, 0, 8411, 8412, 5, 78, 0, 0, 8412, 8413, 5, 7, 0, 0, 8413, 917, 1, 0, 0, 0, 8414, 8420, 7, 67, 0, 0, 8415, 8417, 5, 33, 0, 0, 8416, 8418, 5, 269, 0, 0, 8417, 8416, 1, 0, 0, 0, 8417, 8418, 1, 0, 0, 0, 8418, 8419, 1, 0, 0, 0, 8419, 8421, 5, 153, 0, 0, 8420, 8415, 1, 0, 0, 0, 8420, 8421, 1, 0, 0, 0, 8421, 8422, 1, 0, 0, 0, 8422, 8423, 5, 7, 0, 0, 8423, 919, 1, 0, 0, 0, 8424, 8425, 5, 333, 0, 0, 8425, 8426, 3, 316, 158, 0, 8426, 8427, 5, 94, 0, 0, 8427, 8428, 5, 53, 0, 0, 8428, 8429, 5, 7, 0, 0, 8429, 8437, 1, 0, 0, 0, 8430, 8433, 5, 313, 0, 0, 8431, 8434, 3, 316, 158, 0, 8432, 8434, 5, 30, 0, 0, 8433, 8431, 1, 0, 0, 0, 8433, 8432, 1, 0, 0, 0, 8434, 8435, 1, 0, 0, 0, 8435, 8437, 5, 7, 0, 0, 8436, 8424, 1, 0, 0, 0, 8436, 8430, 1, 0, 0, 0, 8437, 921, 1, 0, 0, 0, 8438, 8441, 3, 818, 409, 0, 8439, 8441, 5, 28, 0, 0, 8440, 8438, 1, 0, 0, 0, 8440, 8439, 1, 0, 0, 0, 8441, 923, 1, 0, 0, 0, 8442, 8459, 5, 517, 0, 0, 8443, 8444, 5, 102, 0, 0, 8444, 8449, 3, 926, 463, 0, 8445, 8446, 5, 82, 0, 0, 8446, 8448, 3, 926, 463, 0, 8447, 8445, 1, 0, 0, 0, 8448, 8451, 1, 0, 0, 0, 8449, 8447, 1, 0, 0, 0, 8449, 8450, 1, 0, 0, 0, 8450, 8452, 1, 0, 0, 0, 8451, 8449, 1, 0, 0, 0, 8452, 8456, 5, 93, 0, 0, 8453, 8455, 3, 846, 423, 0, 8454, 8453, 1, 0, 0, 0, 8455, 8458, 1, 0, 0, 0, 8456, 8454, 1, 0, 0, 0, 8456, 8457, 1, 0, 0, 0, 8457, 8460, 1, 0, 0, 0, 8458, 8456, 1, 0, 0, 0, 8459, 8443, 1, 0, 0, 0, 8460, 8461, 1, 0, 0, 0, 8461, 8459, 1, 0, 0, 0, 8461, 8462, 1, 0, 0, 0, 8462, 925, 1, 0, 0, 0, 8463, 8467, 3, 928, 464, 0, 8464, 8465, 5, 511, 0, 0, 8465, 8467, 3, 808, 404, 0, 8466, 8463, 1, 0, 0, 0, 8466, 8464, 1, 0, 0, 0, 8467, 927, 1, 0, 0, 0, 8468, 8471, 3, 818, 409, 0, 8469, 8471, 3, 828, 414, 0, 8470, 8468, 1, 0, 0, 0, 8470, 8469, 1, 0, 0, 0, 8471, 929, 1, 0, 0, 0, 8472, 8474, 3, 756, 378, 0, 8473, 8472, 1, 0, 0, 0, 8473, 8474, 1, 0, 0, 0, 8474, 8476, 1, 0, 0, 0, 8475, 8477, 3, 580, 290, 0, 8476, 8475, 1, 0, 0, 0, 8476, 8477, 1, 0, 0, 0, 8477, 8479, 1, 0, 0, 0, 8478, 8480, 3, 610, 305, 0, 8479, 8478, 1, 0, 0, 0, 8479, 8480, 1, 0, 0, 0, 8480, 8482, 1, 0, 0, 0, 8481, 8483, 3, 638, 319, 0, 8482, 8481, 1, 0, 0, 0, 8482, 8483, 1, 0, 0, 0, 8483, 8485, 1, 0, 0, 0, 8484, 8486, 3, 600, 300, 0, 8485, 8484, 1, 0, 0, 0, 8485, 8486, 1, 0, 0, 0, 8486, 8489, 1, 0, 0, 0, 8487, 8488, 5, 67, 0, 0, 8488, 8490, 3, 674, 337, 0, 8489, 8487, 1, 0, 0, 0, 8489, 8490, 1, 0, 0, 0, 8490, 8492, 1, 0, 0, 0, 8491, 8493, 3, 702, 351, 0, 8492, 8491, 1, 0, 0, 0, 8492, 8493, 1, 0, 0, 0, 8493, 931, 1, 0, 0, 0, 1187, 935, 942, 1062, 1064, 1073, 1078, 1084, 1119, 1129, 1135, 1140, 1147, 1152, 1159, 1170, 1178, 1182, 1194, 1200, 1206, 1210, 1215, 1219, 1232, 1242, 1244, 1250, 1255, 1268, 1271, 1276, 1281, 1292, 1296, 1308, 1312, 1315, 1319, 1331, 1349, 1356, 1364, 1369, 1376, 1384, 1390, 1398, 1406, 1410, 1424, 1429, 1434, 1446, 1452, 1464, 1469, 1479, 1485, 1490, 1498, 1503, 1510, 1515, 1520, 1530, 1535, 1540, 1547, 1551, 1565, 1571, 1577, 1582, 1589, 1601, 1609, 1617, 1633, 1642, 1651, 1660, 1664, 1676, 1684, 1694, 1714, 1719, 1722, 1729, 1732, 1736, 1740, 1743, 1748, 1753, 1757, 1766, 1772, 1776, 1785, 1788, 1794, 1803, 1815, 1819, 1823, 1828, 1831, 1837, 1839, 1841, 1845, 1851, 1855, 1860, 1865, 1869, 1872, 1879, 1892, 1905, 1919, 1936, 1946, 1953, 1958, 1962, 1969, 1974, 1977, 1979, 1984, 1988, 1992, 1996, 2001, 2004, 2008, 2011, 2015, 2023, 2028, 2031, 2035, 2041, 2050, 2054, 2060, 2062, 2071, 2076, 2088, 2093, 2097, 2101, 2106, 2110, 2113, 2116, 2119, 2122, 2125, 2130, 2133, 2136, 2139, 2142, 2145, 2151, 2155, 2158, 2161, 2164, 2167, 2169, 2176, 2184, 2194, 2199, 2209, 2212, 2217, 2222, 2227, 2230, 2235, 2244, 2246, 2250, 2253, 2257, 2262, 2267, 2271, 2274, 2278, 2281, 2286, 2289, 2294, 2297, 2301, 2304, 2307, 2312, 2315, 2323, 2335, 2339, 2346, 2351, 2354, 2357, 2360, 2365, 2376, 2382, 2386, 2389, 2392, 2397, 2404, 2407, 2411, 2419, 2424, 2427, 2430, 2437, 2442, 2451, 2454, 2457, 2462, 2465, 2477, 2487, 2504, 2508, 2512, 2514, 2531, 2533, 2549, 2560, 2563, 2566, 2575, 2584, 2600, 2603, 2606, 2614, 2618, 2625, 2634, 2638, 2644, 2648, 2651, 2654, 2657, 2660, 2666, 2670, 2675, 2679, 2682, 2685, 2688, 2693, 2699, 2703, 2707, 2711, 2717, 2719, 2724, 2730, 2736, 2740, 2755, 2760, 2763, 2765, 2768, 2772, 2776, 2779, 2782, 2790, 2796, 2798, 2804, 2809, 2814, 2818, 2825, 2827, 2838, 2877, 2887, 2889, 2892, 2896, 2900, 2910, 2912, 2918, 2920, 2929, 2941, 2955, 2960, 2963, 2970, 2975, 2983, 2985, 2991, 2996, 3000, 3005, 3011, 3018, 3024, 3026, 3035, 3041, 3049, 3055, 3060, 3065, 3073, 3088, 3090, 3094, 3098, 3101, 3104, 3113, 3116, 3119, 3125, 3131, 3135, 3147, 3153, 3156, 3161, 3165, 3172, 3182, 3184, 3208, 3220, 3225, 3227, 3231, 3234, 3237, 3247, 3250, 3260, 3265, 3270, 3273, 3276, 3284, 3290, 3297, 3305, 3308, 3319, 3323, 3329, 3336, 3339, 3348, 3362, 3365, 3379, 3390, 3393, 3405, 3410, 3423, 3428, 3441, 3450, 3453, 3456, 3463, 3466, 3478, 3484, 3486, 3494, 3502, 3510, 3522, 3527, 3538, 3549, 3557, 3565, 3572, 3579, 3581, 3584, 3589, 3594, 3613, 3622, 3625, 3652, 3661, 3664, 3668, 3672, 3676, 3683, 3687, 3691, 3695, 3699, 3704, 3708, 3713, 3719, 3724, 3731, 3735, 3741, 3745, 3750, 3758, 3764, 3769, 3776, 3781, 3785, 3790, 3796, 3803, 3808, 3815, 3820, 3827, 3831, 3839, 3843, 3845, 3848, 3853, 3863, 3878, 3881, 3889, 3896, 3901, 3907, 3911, 3918, 3923, 3926, 3929, 3933, 3942, 3960, 3963, 3995, 4000, 4006, 4026, 4031, 4037, 4040, 4044, 4048, 4054, 4057, 4061, 4065, 4070, 4073, 4076, 4079, 4092, 4098, 4106, 4113, 4118, 4121, 4128, 4131, 4139, 4142, 4147, 4154, 4157, 4177, 4189, 4192, 4198, 4203, 4212, 4220, 4225, 4231, 4238, 4246, 4249, 4260, 4262, 4276, 4282, 4290, 4292, 4298, 4302, 4305, 4308, 4313, 4318, 4322, 4325, 4328, 4331, 4334, 4342, 4353, 4356, 4359, 4364, 4367, 4371, 4375, 4381, 4389, 4392, 4405, 4410, 4412, 4417, 4424, 4431, 4440, 4448, 4456, 4463, 4471, 4478, 4486, 4490, 4494, 4496, 4502, 4507, 4511, 4518, 4523, 4528, 4533, 4535, 4545, 4555, 4571, 4589, 4601, 4608, 4623, 4628, 4631, 4636, 4641, 4646, 4649, 4652, 4657, 4664, 4668, 4673, 4680, 4684, 4690, 4699, 4708, 4720, 4722, 4735, 4741, 4745, 4747, 4754, 4767, 4774, 4776, 4792, 4796, 4800, 4805, 4810, 4815, 4820, 4823, 4835, 4888, 4897, 4901, 4910, 4914, 4923, 4927, 4932, 4935, 4939, 4944, 4946, 4955, 4960, 4971, 4975, 4989, 4997, 5035, 5037, 5056, 5059, 5086, 5090, 5094, 5098, 5102, 5105, 5120, 5127, 5141, 5154, 5179, 5198, 5213, 5229, 5236, 5247, 5250, 5269, 5272, 5285, 5289, 5309, 5321, 5325, 5347, 5351, 5361, 5365, 5371, 5375, 5379, 5383, 5390, 5395, 5406, 5410, 5413, 5418, 5424, 5435, 5439, 5442, 5446, 5450, 5453, 5463, 5466, 5470, 5475, 5481, 5484, 5489, 5492, 5499, 5501, 5507, 5511, 5520, 5525, 5527, 5537, 5540, 5545, 5553, 5556, 5561, 5563, 5565, 5571, 5588, 5594, 5607, 5613, 5617, 5622, 5652, 5667, 5672, 5676, 5689, 5693, 5695, 5704, 5710, 5712, 5716, 5719, 5722, 5725, 5728, 5730, 5733, 5737, 5745, 5750, 5753, 5759, 5763, 5767, 5772, 5774, 5778, 5782, 5789, 5795, 5799, 5801, 5803, 5816, 5824, 5832, 5843, 5852, 5857, 5861, 5865, 5872, 5875, 5877, 5885, 5889, 5892, 5899, 5906, 5911, 5918, 5921, 5923, 5926, 5932, 5937, 5941, 5948, 5958, 5965, 5968, 5971, 5975, 5986, 5989, 5992, 5995, 5998, 6005, 6008, 6011, 6018, 6030, 6037, 6039, 6044, 6049, 6051, 6057, 6064, 6069, 6074, 6078, 6082, 6086, 6088, 6092, 6096, 6099, 6102, 6104, 6114, 6116, 6121, 6125, 6130, 6134, 6141, 6146, 6150, 6153, 6159, 6162, 6181, 6188, 6192, 6195, 6199, 6203, 6206, 6209, 6214, 6223, 6230, 6234, 6238, 6242, 6245, 6247, 6252, 6256, 6261, 6267, 6274, 6279, 6284, 6293, 6300, 6308, 6319, 6324, 6328, 6331, 6335, 6340, 6344, 6349, 6357, 6368, 6373, 6377, 6380, 6383, 6385, 6388, 6391, 6394, 6398, 6402, 6406, 6408, 6417, 6422, 6428, 6432, 6434, 6441, 6446, 6452, 6454, 6458, 6465, 6470, 6473, 6479, 6483, 6489, 6498, 6504, 6506, 6511, 6514, 6523, 6530, 6532, 6539, 6544, 6547, 6557, 6568, 6573, 6577, 6585, 6595, 6602, 6608, 6619, 6625, 6635, 6644, 6648, 6651, 6653, 6655, 6659, 6667, 6670, 6675, 6680, 6687, 6689, 6695, 6699, 6702, 6707, 6710, 6712, 6718, 6727, 6733, 6736, 6744, 6747, 6751, 6757, 6759, 6762, 6766, 6771, 6778, 6785, 6787, 6793, 6795, 6800, 6802, 6806, 6815, 6819, 6827, 6829, 6843, 6846, 6854, 6863, 6869, 6874, 6882, 6884, 6889, 6893, 6898, 6903, 6909, 6925, 6927, 6936, 6951, 6956, 6959, 6965, 6970, 6983, 6988, 6992, 6999, 7018, 7030, 7035, 7043, 7045, 7047, 7056, 7059, 7064, 7069, 7072, 7083, 7091, 7096, 7098, 7101, 7105, 7116, 7137, 7145, 7158, 7168, 7174, 7180, 7183, 7186, 7212, 7214, 7235, 7245, 7258, 7263, 7267, 7269, 7281, 7288, 7294, 7300, 7304, 7315, 7325, 7329, 7334, 7337, 7340, 7349, 7360, 7362, 7366, 7371, 7380, 7385, 7393, 7403, 7411, 7415, 7418, 7425, 7433, 7437, 7444, 7453, 7462, 7465, 7477, 7486, 7493, 7502, 7512, 7517, 7521, 7523, 7526, 7531, 7536, 7544, 7552, 7555, 7562, 7570, 7578, 7586, 7603, 7610, 7618, 7635, 7641, 7647, 7655, 7661, 7666, 7674, 7679, 7682, 7691, 7698, 7703, 7707, 7712, 7718, 7723, 7731, 7786, 7793, 7799, 7801, 7803, 7805, 7811, 7815, 7819, 7830, 7833, 7837, 7841, 7845, 7848, 7851, 7854, 7863, 7868, 7872, 7905, 7915, 7919, 7925, 7930, 7939, 7947, 7958, 7966, 7975, 7984, 7989, 7993, 8003, 8008, 8016, 8021, 8024, 8031, 8037, 8045, 8053, 8056, 8063, 8065, 8068, 8074, 8083, 8087, 8101, 8104, 8106, 8112, 8122, 8124, 8126, 8134, 8137, 8140, 8150, 8158, 8164, 8170, 8177, 8181, 8185, 8188, 8191, 8197, 8204, 8207, 8215, 8217, 8226, 8231, 8233, 8240, 8246, 8249, 8261, 8268, 8270, 8274, 8280, 8285, 8289, 8292, 8295, 8304, 8307, 8311, 8315, 8317, 8320, 8323, 8329, 8336, 8343, 8349, 8351, 8355, 8360, 8378, 8383, 8385, 8394, 8401, 8405, 8417, 8420, 8433, 8436, 8440, 8449, 8456, 8461, 8466, 8470, 8473, 8476, 8479, 8482, 8485, 8489, 8492] \ No newline at end of file +[4, 1, 590, 8496, 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, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, 464, 7, 464, 2, 465, 7, 465, 1, 0, 5, 0, 934, 8, 0, 10, 0, 12, 0, 937, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 943, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1063, 8, 2, 3, 2, 1065, 8, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1074, 8, 4, 1, 4, 5, 4, 1077, 8, 4, 10, 4, 12, 4, 1080, 9, 4, 1, 5, 1, 5, 1, 5, 3, 5, 1085, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1120, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 1130, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 1136, 8, 7, 1, 7, 5, 7, 1139, 8, 7, 10, 7, 12, 7, 1142, 9, 7, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1148, 8, 8, 1, 8, 5, 8, 1151, 8, 8, 10, 8, 12, 8, 1154, 9, 8, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 1160, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 1171, 8, 10, 1, 10, 1, 10, 1, 11, 1, 11, 5, 11, 1177, 8, 11, 10, 11, 12, 11, 1180, 9, 11, 1, 11, 3, 11, 1183, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1195, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1201, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1207, 8, 12, 1, 12, 1, 12, 3, 12, 1211, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1216, 8, 12, 1, 12, 1, 12, 3, 12, 1220, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1233, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1243, 8, 12, 3, 12, 1245, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1251, 8, 13, 1, 13, 5, 13, 1254, 8, 13, 10, 13, 12, 13, 1257, 9, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 3, 15, 1269, 8, 15, 1, 15, 3, 15, 1272, 8, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1277, 8, 15, 1, 15, 5, 15, 1280, 8, 15, 10, 15, 12, 15, 1283, 9, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1293, 8, 17, 1, 18, 1, 18, 3, 18, 1297, 8, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 1309, 8, 19, 1, 20, 1, 20, 3, 20, 1313, 8, 20, 1, 20, 3, 20, 1316, 8, 20, 1, 20, 1, 20, 3, 20, 1320, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 1332, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 1350, 8, 21, 1, 22, 1, 22, 1, 22, 5, 22, 1355, 8, 22, 10, 22, 12, 22, 1358, 9, 22, 1, 23, 1, 23, 1, 23, 5, 23, 1363, 8, 23, 10, 23, 12, 23, 1366, 9, 23, 1, 24, 1, 24, 3, 24, 1370, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1377, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 1385, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 1391, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1399, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1407, 8, 28, 1, 29, 1, 29, 3, 29, 1411, 8, 29, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 1425, 8, 31, 1, 32, 1, 32, 1, 32, 3, 32, 1430, 8, 32, 1, 33, 1, 33, 1, 33, 3, 33, 1435, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1447, 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 1453, 8, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 3, 38, 1465, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1470, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1480, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1486, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1491, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1499, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1504, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1511, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1516, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1521, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1531, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1536, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1541, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1548, 8, 38, 1, 38, 1, 38, 3, 38, 1552, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1566, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1572, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1578, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1583, 8, 38, 1, 39, 1, 39, 1, 39, 5, 39, 1588, 8, 39, 10, 39, 12, 39, 1591, 9, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1602, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 5, 41, 1608, 8, 41, 10, 41, 12, 41, 1611, 9, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 3, 42, 1618, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1634, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 3, 46, 1643, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 5, 46, 1650, 8, 46, 10, 46, 12, 46, 1653, 9, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1661, 8, 46, 1, 46, 1, 46, 3, 46, 1665, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1677, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1685, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1695, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1715, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1720, 8, 46, 1, 46, 3, 46, 1723, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1730, 8, 46, 1, 46, 3, 46, 1733, 8, 46, 1, 46, 1, 46, 3, 46, 1737, 8, 46, 1, 46, 1, 46, 3, 46, 1741, 8, 46, 1, 46, 3, 46, 1744, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1749, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1754, 8, 46, 1, 46, 1, 46, 3, 46, 1758, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1767, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1773, 8, 46, 1, 46, 1, 46, 3, 46, 1777, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1786, 8, 46, 1, 46, 3, 46, 1789, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1795, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1804, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 4, 46, 1814, 8, 46, 11, 46, 12, 46, 1815, 1, 46, 1, 46, 3, 46, 1820, 8, 46, 1, 46, 1, 46, 3, 46, 1824, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1829, 8, 46, 1, 46, 3, 46, 1832, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1838, 8, 46, 4, 46, 1840, 8, 46, 11, 46, 12, 46, 1841, 1, 46, 1, 46, 3, 46, 1846, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1852, 8, 46, 1, 46, 1, 46, 3, 46, 1856, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1861, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1866, 8, 46, 1, 46, 1, 46, 3, 46, 1870, 8, 46, 1, 46, 3, 46, 1873, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1880, 8, 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 5, 50, 1891, 8, 50, 10, 50, 12, 50, 1894, 9, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1906, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 5, 53, 1918, 8, 53, 10, 53, 12, 53, 1921, 9, 53, 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, 53, 1, 53, 3, 53, 1937, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1945, 8, 54, 10, 54, 12, 54, 1948, 9, 54, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1954, 8, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1959, 8, 55, 1, 55, 1, 55, 3, 55, 1963, 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1970, 8, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1975, 8, 55, 1, 55, 3, 55, 1978, 8, 55, 3, 55, 1980, 8, 55, 1, 56, 1, 56, 1, 56, 3, 56, 1985, 8, 56, 1, 57, 1, 57, 3, 57, 1989, 8, 57, 1, 57, 1, 57, 3, 57, 1993, 8, 57, 1, 57, 1, 57, 3, 57, 1997, 8, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2002, 8, 57, 1, 57, 3, 57, 2005, 8, 57, 1, 57, 1, 57, 3, 57, 2009, 8, 57, 1, 57, 3, 57, 2012, 8, 57, 1, 57, 1, 57, 3, 57, 2016, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2024, 8, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2029, 8, 57, 1, 57, 3, 57, 2032, 8, 57, 1, 57, 1, 57, 3, 57, 2036, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 2042, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 2051, 8, 58, 1, 58, 1, 58, 3, 58, 2055, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 5, 58, 2061, 8, 58, 10, 58, 12, 58, 2064, 9, 58, 1, 58, 1, 58, 1, 58, 1, 58, 5, 58, 2070, 8, 58, 10, 58, 12, 58, 2073, 9, 58, 1, 58, 1, 58, 3, 58, 2077, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2087, 8, 59, 10, 59, 12, 59, 2090, 9, 59, 1, 59, 1, 59, 3, 59, 2094, 8, 59, 1, 60, 1, 60, 3, 60, 2098, 8, 60, 1, 60, 1, 60, 3, 60, 2102, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2107, 8, 60, 1, 60, 1, 60, 3, 60, 2111, 8, 60, 1, 60, 3, 60, 2114, 8, 60, 1, 60, 3, 60, 2117, 8, 60, 1, 60, 3, 60, 2120, 8, 60, 1, 60, 3, 60, 2123, 8, 60, 1, 60, 3, 60, 2126, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2131, 8, 60, 1, 60, 3, 60, 2134, 8, 60, 1, 60, 3, 60, 2137, 8, 60, 1, 60, 3, 60, 2140, 8, 60, 1, 60, 3, 60, 2143, 8, 60, 1, 60, 3, 60, 2146, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2152, 8, 60, 1, 60, 1, 60, 3, 60, 2156, 8, 60, 1, 60, 3, 60, 2159, 8, 60, 1, 60, 3, 60, 2162, 8, 60, 1, 60, 3, 60, 2165, 8, 60, 1, 60, 3, 60, 2168, 8, 60, 3, 60, 2170, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 2177, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 5, 62, 2183, 8, 62, 10, 62, 12, 62, 2186, 9, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 5, 63, 2193, 8, 63, 10, 63, 12, 63, 2196, 9, 63, 1, 64, 1, 64, 3, 64, 2200, 8, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 5, 64, 2208, 8, 64, 10, 64, 12, 64, 2211, 9, 64, 3, 64, 2213, 8, 64, 1, 65, 1, 65, 1, 65, 3, 65, 2218, 8, 65, 1, 65, 5, 65, 2221, 8, 65, 10, 65, 12, 65, 2224, 9, 65, 1, 65, 1, 65, 3, 65, 2228, 8, 65, 1, 65, 3, 65, 2231, 8, 65, 1, 66, 1, 66, 1, 66, 3, 66, 2236, 8, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 2245, 8, 66, 3, 66, 2247, 8, 66, 1, 66, 1, 66, 3, 66, 2251, 8, 66, 1, 66, 3, 66, 2254, 8, 66, 1, 66, 1, 66, 3, 66, 2258, 8, 66, 1, 66, 5, 66, 2261, 8, 66, 10, 66, 12, 66, 2264, 9, 66, 1, 67, 1, 67, 3, 67, 2268, 8, 67, 1, 67, 1, 67, 3, 67, 2272, 8, 67, 1, 67, 3, 67, 2275, 8, 67, 1, 67, 1, 67, 3, 67, 2279, 8, 67, 1, 68, 3, 68, 2282, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2287, 8, 68, 1, 68, 3, 68, 2290, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2295, 8, 68, 1, 68, 3, 68, 2298, 8, 68, 1, 68, 1, 68, 3, 68, 2302, 8, 68, 1, 68, 3, 68, 2305, 8, 68, 1, 68, 3, 68, 2308, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2313, 8, 68, 1, 68, 3, 68, 2316, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2324, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 4, 68, 2334, 8, 68, 11, 68, 12, 68, 2335, 1, 68, 1, 68, 3, 68, 2340, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2347, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2352, 8, 68, 1, 68, 3, 68, 2355, 8, 68, 1, 68, 3, 68, 2358, 8, 68, 1, 68, 3, 68, 2361, 8, 68, 1, 69, 1, 69, 1, 69, 3, 69, 2366, 8, 69, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2375, 8, 71, 10, 71, 12, 71, 2378, 9, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2383, 8, 71, 1, 71, 1, 71, 3, 71, 2387, 8, 71, 1, 71, 3, 71, 2390, 8, 71, 1, 71, 3, 71, 2393, 8, 71, 1, 71, 5, 71, 2396, 8, 71, 10, 71, 12, 71, 2399, 9, 71, 1, 71, 1, 71, 5, 71, 2403, 8, 71, 10, 71, 12, 71, 2406, 9, 71, 3, 71, 2408, 8, 71, 1, 71, 1, 71, 3, 71, 2412, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2418, 8, 71, 10, 71, 12, 71, 2421, 9, 71, 1, 71, 1, 71, 3, 71, 2425, 8, 71, 1, 71, 3, 71, 2428, 8, 71, 1, 71, 3, 71, 2431, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2438, 8, 71, 1, 71, 5, 71, 2441, 8, 71, 10, 71, 12, 71, 2444, 9, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2452, 8, 71, 1, 71, 3, 71, 2455, 8, 71, 1, 71, 3, 71, 2458, 8, 71, 1, 71, 5, 71, 2461, 8, 71, 10, 71, 12, 71, 2464, 9, 71, 3, 71, 2466, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 5, 73, 2476, 8, 73, 10, 73, 12, 73, 2479, 9, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 5, 74, 2486, 8, 74, 10, 74, 12, 74, 2489, 9, 74, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2505, 8, 77, 1, 78, 1, 78, 3, 78, 2509, 8, 78, 1, 78, 1, 78, 3, 78, 2513, 8, 78, 3, 78, 2515, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2532, 8, 81, 3, 81, 2534, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 5, 83, 2548, 8, 83, 10, 83, 12, 83, 2551, 9, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 2561, 8, 84, 1, 84, 3, 84, 2564, 8, 84, 1, 84, 3, 84, 2567, 8, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 2576, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2585, 8, 87, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 3, 91, 2601, 8, 91, 1, 91, 3, 91, 2604, 8, 91, 1, 91, 3, 91, 2607, 8, 91, 1, 91, 1, 91, 1, 91, 1, 91, 5, 91, 2613, 8, 91, 10, 91, 12, 91, 2616, 9, 91, 1, 91, 3, 91, 2619, 8, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 3, 92, 2626, 8, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 3, 93, 2635, 8, 93, 1, 93, 1, 93, 3, 93, 2639, 8, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 2645, 8, 93, 1, 94, 1, 94, 3, 94, 2649, 8, 94, 1, 94, 3, 94, 2652, 8, 94, 1, 94, 3, 94, 2655, 8, 94, 1, 94, 3, 94, 2658, 8, 94, 1, 94, 3, 94, 2661, 8, 94, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 2667, 8, 95, 1, 96, 1, 96, 3, 96, 2671, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2676, 8, 96, 1, 96, 1, 96, 3, 96, 2680, 8, 96, 1, 96, 3, 96, 2683, 8, 96, 1, 96, 3, 96, 2686, 8, 96, 1, 96, 3, 96, 2689, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2694, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 2700, 8, 97, 1, 97, 1, 97, 3, 97, 2704, 8, 97, 1, 98, 1, 98, 3, 98, 2708, 8, 98, 1, 98, 1, 98, 3, 98, 2712, 8, 98, 1, 98, 1, 98, 4, 98, 2716, 8, 98, 11, 98, 12, 98, 2717, 3, 98, 2720, 8, 98, 1, 99, 1, 99, 1, 99, 3, 99, 2725, 8, 99, 1, 99, 1, 99, 4, 99, 2729, 8, 99, 11, 99, 12, 99, 2730, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2737, 8, 100, 1, 100, 1, 100, 3, 100, 2741, 8, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2756, 8, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2761, 8, 100, 1, 100, 3, 100, 2764, 8, 100, 3, 100, 2766, 8, 100, 1, 101, 3, 101, 2769, 8, 101, 1, 101, 1, 101, 3, 101, 2773, 8, 101, 1, 102, 1, 102, 3, 102, 2777, 8, 102, 1, 102, 3, 102, 2780, 8, 102, 1, 102, 3, 102, 2783, 8, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2791, 8, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2797, 8, 102, 3, 102, 2799, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2805, 8, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2810, 8, 103, 1, 104, 1, 104, 1, 104, 3, 104, 2815, 8, 104, 1, 104, 1, 104, 3, 104, 2819, 8, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 5, 104, 2826, 8, 104, 10, 104, 12, 104, 2829, 9, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2837, 8, 105, 10, 105, 12, 105, 2840, 9, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2878, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 4, 107, 2886, 8, 107, 11, 107, 12, 107, 2887, 3, 107, 2890, 8, 107, 1, 107, 3, 107, 2893, 8, 107, 1, 108, 1, 108, 3, 108, 2897, 8, 108, 1, 108, 1, 108, 3, 108, 2901, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 4, 109, 2909, 8, 109, 11, 109, 12, 109, 2910, 3, 109, 2913, 8, 109, 1, 109, 1, 109, 4, 109, 2917, 8, 109, 11, 109, 12, 109, 2918, 3, 109, 2921, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 2928, 8, 110, 10, 110, 12, 110, 2931, 9, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 2940, 8, 111, 10, 111, 12, 111, 2943, 9, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 3, 114, 2956, 8, 114, 1, 114, 1, 114, 1, 114, 3, 114, 2961, 8, 114, 1, 114, 3, 114, 2964, 8, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 2971, 8, 114, 1, 115, 1, 115, 1, 115, 3, 115, 2976, 8, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2984, 8, 116, 3, 116, 2986, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2992, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2997, 8, 117, 1, 117, 1, 117, 3, 117, 3001, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3006, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3012, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3019, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3025, 8, 117, 3, 117, 3027, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3036, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3042, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3050, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3056, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3061, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3066, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 3074, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 3089, 8, 121, 3, 121, 3091, 8, 121, 1, 121, 1, 121, 3, 121, 3095, 8, 121, 1, 121, 1, 121, 3, 121, 3099, 8, 121, 1, 121, 3, 121, 3102, 8, 121, 1, 121, 3, 121, 3105, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3114, 8, 122, 1, 122, 3, 122, 3117, 8, 122, 1, 122, 3, 122, 3120, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3126, 8, 123, 1, 123, 1, 123, 5, 123, 3130, 8, 123, 10, 123, 12, 123, 3133, 9, 123, 1, 123, 3, 123, 3136, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3148, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3154, 8, 123, 1, 124, 3, 124, 3157, 8, 124, 1, 124, 1, 124, 1, 124, 3, 124, 3162, 8, 124, 1, 124, 1, 124, 3, 124, 3166, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 3173, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 3183, 8, 124, 3, 124, 3185, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 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, 127, 1, 128, 1, 128, 3, 128, 3209, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3221, 8, 128, 1, 128, 4, 128, 3224, 8, 128, 11, 128, 12, 128, 3225, 3, 128, 3228, 8, 128, 1, 128, 1, 128, 3, 128, 3232, 8, 128, 1, 128, 3, 128, 3235, 8, 128, 1, 128, 3, 128, 3238, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3248, 8, 128, 1, 128, 3, 128, 3251, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3261, 8, 128, 1, 128, 5, 128, 3264, 8, 128, 10, 128, 12, 128, 3267, 9, 128, 1, 128, 1, 128, 3, 128, 3271, 8, 128, 1, 128, 3, 128, 3274, 8, 128, 1, 128, 3, 128, 3277, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3285, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 3291, 8, 129, 1, 130, 1, 130, 1, 130, 5, 130, 3296, 8, 130, 10, 130, 12, 130, 3299, 9, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 3306, 8, 131, 1, 131, 3, 131, 3309, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 3320, 8, 133, 1, 134, 1, 134, 3, 134, 3324, 8, 134, 1, 134, 1, 134, 5, 134, 3328, 8, 134, 10, 134, 12, 134, 3331, 9, 134, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 3337, 8, 135, 1, 136, 3, 136, 3340, 8, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 3349, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 5, 137, 3361, 8, 137, 10, 137, 12, 137, 3364, 9, 137, 3, 137, 3366, 8, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 5, 138, 3378, 8, 138, 10, 138, 12, 138, 3381, 9, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 3391, 8, 139, 1, 139, 3, 139, 3394, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 5, 140, 3404, 8, 140, 10, 140, 12, 140, 3407, 9, 140, 1, 141, 1, 141, 3, 141, 3411, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 5, 141, 3422, 8, 141, 10, 141, 12, 141, 3425, 9, 141, 1, 141, 1, 141, 3, 141, 3429, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3442, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 5, 141, 3449, 8, 141, 10, 141, 12, 141, 3452, 9, 141, 3, 141, 3454, 8, 141, 1, 141, 3, 141, 3457, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3464, 8, 141, 1, 141, 3, 141, 3467, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3479, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3485, 8, 141, 3, 141, 3487, 8, 141, 1, 142, 1, 142, 1, 142, 1, 142, 5, 142, 3493, 8, 142, 10, 142, 12, 142, 3496, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 3, 143, 3503, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 3511, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3523, 8, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3528, 8, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3539, 8, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3550, 8, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3558, 8, 148, 1, 148, 1, 148, 1, 148, 1, 148, 5, 148, 3564, 8, 148, 10, 148, 12, 148, 3567, 9, 148, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3573, 8, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3580, 8, 149, 3, 149, 3582, 8, 149, 1, 149, 3, 149, 3585, 8, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3590, 8, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3595, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 3612, 8, 151, 10, 151, 12, 151, 3615, 9, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 3621, 8, 151, 10, 151, 12, 151, 3624, 9, 151, 3, 151, 3626, 8, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3653, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3662, 8, 154, 1, 154, 3, 154, 3665, 8, 154, 1, 154, 1, 154, 3, 154, 3669, 8, 154, 1, 154, 1, 154, 3, 154, 3673, 8, 154, 1, 154, 1, 154, 3, 154, 3677, 8, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3682, 8, 154, 10, 154, 12, 154, 3685, 9, 154, 1, 154, 3, 154, 3688, 8, 154, 1, 154, 1, 154, 3, 154, 3692, 8, 154, 1, 154, 1, 154, 3, 154, 3696, 8, 154, 1, 154, 1, 154, 3, 154, 3700, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3705, 8, 154, 1, 154, 1, 154, 3, 154, 3709, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3714, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3720, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3725, 8, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3730, 8, 154, 10, 154, 12, 154, 3733, 9, 154, 1, 154, 3, 154, 3736, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3742, 8, 154, 1, 154, 1, 154, 3, 154, 3746, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3751, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3759, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3765, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3770, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3777, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3782, 8, 154, 1, 154, 1, 154, 3, 154, 3786, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3791, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3797, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3804, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3809, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3816, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3821, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3828, 8, 154, 1, 154, 1, 154, 3, 154, 3832, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3838, 8, 154, 10, 154, 12, 154, 3841, 9, 154, 1, 154, 3, 154, 3844, 8, 154, 3, 154, 3846, 8, 154, 1, 155, 3, 155, 3849, 8, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3854, 8, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3864, 8, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 3879, 8, 156, 1, 156, 3, 156, 3882, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 3890, 8, 156, 1, 157, 1, 157, 1, 157, 5, 157, 3895, 8, 157, 10, 157, 12, 157, 3898, 9, 157, 1, 158, 1, 158, 3, 158, 3902, 8, 158, 1, 159, 1, 159, 4, 159, 3906, 8, 159, 11, 159, 12, 159, 3907, 1, 160, 1, 160, 3, 160, 3912, 8, 160, 1, 160, 1, 160, 1, 160, 5, 160, 3917, 8, 160, 10, 160, 12, 160, 3920, 9, 160, 1, 160, 1, 160, 3, 160, 3924, 8, 160, 1, 160, 3, 160, 3927, 8, 160, 1, 161, 3, 161, 3930, 8, 161, 1, 161, 1, 161, 3, 161, 3934, 8, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 3943, 8, 162, 1, 162, 1, 162, 1, 162, 1, 162, 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, 3961, 8, 162, 1, 162, 3, 162, 3964, 8, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 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, 3996, 8, 162, 1, 162, 1, 162, 1, 162, 3, 162, 4001, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4007, 8, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4027, 8, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4032, 8, 163, 1, 164, 1, 164, 1, 164, 1, 165, 3, 165, 4038, 8, 165, 1, 165, 3, 165, 4041, 8, 165, 1, 165, 1, 165, 3, 165, 4045, 8, 165, 1, 165, 1, 165, 3, 165, 4049, 8, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4055, 8, 165, 1, 165, 3, 165, 4058, 8, 165, 1, 165, 1, 165, 3, 165, 4062, 8, 165, 1, 165, 1, 165, 3, 165, 4066, 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4071, 8, 165, 1, 165, 3, 165, 4074, 8, 165, 1, 165, 3, 165, 4077, 8, 165, 1, 165, 3, 165, 4080, 8, 165, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 4093, 8, 167, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 4099, 8, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 4107, 8, 168, 1, 169, 1, 169, 1, 169, 5, 169, 4112, 8, 169, 10, 169, 12, 169, 4115, 9, 169, 1, 169, 1, 169, 3, 169, 4119, 8, 169, 1, 169, 3, 169, 4122, 8, 169, 1, 169, 1, 169, 1, 169, 5, 169, 4127, 8, 169, 10, 169, 12, 169, 4130, 9, 169, 3, 169, 4132, 8, 169, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 4140, 8, 171, 1, 171, 3, 171, 4143, 8, 171, 1, 172, 1, 172, 1, 172, 3, 172, 4148, 8, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 4155, 8, 172, 1, 172, 3, 172, 4158, 8, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 5, 172, 4176, 8, 172, 10, 172, 12, 172, 4179, 9, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 4190, 8, 172, 1, 173, 3, 173, 4193, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 4199, 8, 173, 1, 173, 5, 173, 4202, 8, 173, 10, 173, 12, 173, 4205, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 5, 174, 4211, 8, 174, 10, 174, 12, 174, 4214, 9, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 4221, 8, 174, 1, 174, 1, 174, 1, 174, 3, 174, 4226, 8, 174, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 4232, 8, 175, 1, 175, 1, 175, 1, 175, 5, 175, 4237, 8, 175, 10, 175, 12, 175, 4240, 9, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 4247, 8, 175, 1, 175, 3, 175, 4250, 8, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 5, 176, 4261, 8, 176, 10, 176, 12, 176, 4264, 9, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4277, 8, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4283, 8, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4291, 8, 177, 3, 177, 4293, 8, 177, 1, 178, 1, 178, 1, 179, 1, 179, 3, 179, 4299, 8, 179, 1, 179, 1, 179, 3, 179, 4303, 8, 179, 1, 179, 3, 179, 4306, 8, 179, 1, 179, 3, 179, 4309, 8, 179, 1, 179, 1, 179, 1, 179, 3, 179, 4314, 8, 179, 1, 179, 1, 179, 1, 179, 3, 179, 4319, 8, 179, 1, 179, 1, 179, 3, 179, 4323, 8, 179, 1, 179, 3, 179, 4326, 8, 179, 1, 179, 3, 179, 4329, 8, 179, 1, 179, 3, 179, 4332, 8, 179, 1, 179, 3, 179, 4335, 8, 179, 1, 180, 1, 180, 1, 180, 1, 180, 5, 180, 4341, 8, 180, 10, 180, 12, 180, 4344, 9, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 4354, 8, 181, 1, 181, 3, 181, 4357, 8, 181, 1, 181, 3, 181, 4360, 8, 181, 1, 181, 1, 181, 1, 181, 3, 181, 4365, 8, 181, 1, 181, 3, 181, 4368, 8, 181, 1, 181, 1, 181, 3, 181, 4372, 8, 181, 1, 182, 1, 182, 3, 182, 4376, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 4382, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 4388, 8, 182, 10, 182, 12, 182, 4391, 9, 182, 3, 182, 4393, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 4404, 8, 182, 10, 182, 12, 182, 4407, 9, 182, 1, 182, 1, 182, 3, 182, 4411, 8, 182, 3, 182, 4413, 8, 182, 1, 182, 4, 182, 4416, 8, 182, 11, 182, 12, 182, 4417, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 4425, 8, 182, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 3, 184, 4432, 8, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 5, 185, 4439, 8, 185, 10, 185, 12, 185, 4442, 9, 185, 1, 186, 1, 186, 1, 186, 5, 186, 4447, 8, 186, 10, 186, 12, 186, 4450, 9, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 4457, 8, 187, 1, 188, 1, 188, 1, 188, 5, 188, 4462, 8, 188, 10, 188, 12, 188, 4465, 9, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 4472, 8, 189, 1, 190, 1, 190, 1, 190, 5, 190, 4477, 8, 190, 10, 190, 12, 190, 4480, 9, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, 4487, 8, 191, 1, 192, 1, 192, 3, 192, 4491, 8, 192, 1, 192, 1, 192, 3, 192, 4495, 8, 192, 3, 192, 4497, 8, 192, 1, 192, 1, 192, 1, 193, 1, 193, 3, 193, 4503, 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 4508, 8, 193, 1, 194, 1, 194, 3, 194, 4512, 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, 4519, 8, 194, 1, 195, 1, 195, 1, 195, 3, 195, 4524, 8, 195, 1, 196, 1, 196, 1, 196, 3, 196, 4529, 8, 196, 1, 196, 1, 196, 1, 196, 3, 196, 4534, 8, 196, 3, 196, 4536, 8, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 3, 198, 4546, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 4556, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 4572, 8, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 5, 199, 4588, 8, 199, 10, 199, 12, 199, 4591, 9, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4602, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4609, 8, 199, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 4624, 8, 202, 1, 202, 4, 202, 4627, 8, 202, 11, 202, 12, 202, 4628, 1, 202, 3, 202, 4632, 8, 202, 1, 203, 1, 203, 1, 203, 3, 203, 4637, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 4642, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 4647, 8, 203, 1, 203, 3, 203, 4650, 8, 203, 1, 203, 3, 203, 4653, 8, 203, 1, 204, 1, 204, 1, 204, 3, 204, 4658, 8, 204, 1, 204, 1, 204, 1, 204, 5, 204, 4663, 8, 204, 10, 204, 12, 204, 4666, 9, 204, 1, 204, 3, 204, 4669, 8, 204, 1, 205, 1, 205, 1, 205, 3, 205, 4674, 8, 205, 1, 205, 1, 205, 1, 205, 5, 205, 4679, 8, 205, 10, 205, 12, 205, 4682, 9, 205, 1, 205, 3, 205, 4685, 8, 205, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 4691, 8, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 4700, 8, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 5, 207, 4707, 8, 207, 10, 207, 12, 207, 4710, 9, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 4, 209, 4721, 8, 209, 11, 209, 12, 209, 4722, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, 210, 4736, 8, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, 210, 4742, 8, 210, 1, 210, 1, 210, 3, 210, 4746, 8, 210, 3, 210, 4748, 8, 210, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 3, 212, 4755, 8, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 4768, 8, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 4775, 8, 212, 3, 212, 4777, 8, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 5, 214, 4791, 8, 214, 10, 214, 12, 214, 4794, 9, 214, 1, 214, 3, 214, 4797, 8, 214, 1, 214, 1, 214, 3, 214, 4801, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4806, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4811, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4816, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4821, 8, 214, 1, 214, 3, 214, 4824, 8, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4836, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4889, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4898, 8, 216, 1, 216, 1, 216, 3, 216, 4902, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4911, 8, 216, 1, 216, 1, 216, 3, 216, 4915, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4924, 8, 216, 1, 216, 1, 216, 3, 216, 4928, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4933, 8, 216, 1, 216, 3, 216, 4936, 8, 216, 1, 216, 1, 216, 3, 216, 4940, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4945, 8, 216, 3, 216, 4947, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4956, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4961, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4972, 8, 216, 1, 216, 1, 216, 3, 216, 4976, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4990, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4998, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5036, 8, 216, 3, 216, 5038, 8, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 3, 217, 5057, 8, 217, 1, 217, 3, 217, 5060, 8, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 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, 3, 218, 5087, 8, 218, 1, 218, 1, 218, 3, 218, 5091, 8, 218, 1, 218, 1, 218, 3, 218, 5095, 8, 218, 1, 218, 1, 218, 3, 218, 5099, 8, 218, 1, 218, 1, 218, 3, 218, 5103, 8, 218, 1, 218, 3, 218, 5106, 8, 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, 5121, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 5128, 8, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5140, 8, 220, 10, 220, 12, 220, 5143, 9, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 5155, 8, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5180, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5199, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5214, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5230, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5237, 8, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 5248, 8, 224, 1, 224, 3, 224, 5251, 8, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 5, 225, 5268, 8, 225, 10, 225, 12, 225, 5271, 9, 225, 3, 225, 5273, 8, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 5, 226, 5284, 8, 226, 10, 226, 12, 226, 5287, 9, 226, 1, 226, 3, 226, 5290, 8, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 5310, 8, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 5, 227, 5320, 8, 227, 10, 227, 12, 227, 5323, 9, 227, 1, 227, 3, 227, 5326, 8, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 5348, 8, 227, 1, 228, 1, 228, 3, 228, 5352, 8, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, 5362, 8, 228, 1, 228, 1, 228, 3, 228, 5366, 8, 228, 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, 5372, 8, 228, 1, 228, 1, 228, 3, 228, 5376, 8, 228, 5, 228, 5378, 8, 228, 10, 228, 12, 228, 5381, 9, 228, 1, 228, 3, 228, 5384, 8, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5391, 8, 229, 1, 230, 1, 230, 1, 230, 3, 230, 5396, 8, 230, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 3, 233, 5407, 8, 233, 1, 234, 1, 234, 3, 234, 5411, 8, 234, 1, 234, 3, 234, 5414, 8, 234, 1, 234, 1, 234, 1, 234, 3, 234, 5419, 8, 234, 1, 234, 1, 234, 1, 234, 1, 234, 3, 234, 5425, 8, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 3, 234, 5436, 8, 234, 1, 234, 1, 234, 3, 234, 5440, 8, 234, 1, 234, 3, 234, 5443, 8, 234, 1, 234, 1, 234, 3, 234, 5447, 8, 234, 1, 234, 1, 234, 3, 234, 5451, 8, 234, 1, 234, 3, 234, 5454, 8, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 3, 236, 5464, 8, 236, 1, 236, 3, 236, 5467, 8, 236, 1, 237, 1, 237, 3, 237, 5471, 8, 237, 1, 237, 5, 237, 5474, 8, 237, 10, 237, 12, 237, 5477, 9, 237, 1, 238, 1, 238, 1, 238, 3, 238, 5482, 8, 238, 1, 238, 3, 238, 5485, 8, 238, 1, 238, 1, 238, 1, 238, 3, 238, 5490, 8, 238, 1, 238, 3, 238, 5493, 8, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, 5500, 8, 238, 3, 238, 5502, 8, 238, 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, 5508, 8, 238, 1, 238, 1, 238, 3, 238, 5512, 8, 238, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 3, 240, 5521, 8, 240, 1, 240, 4, 240, 5524, 8, 240, 11, 240, 12, 240, 5525, 3, 240, 5528, 8, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 3, 241, 5538, 8, 241, 1, 241, 3, 241, 5541, 8, 241, 1, 241, 1, 241, 1, 241, 3, 241, 5546, 8, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 3, 242, 5554, 8, 242, 1, 242, 3, 242, 5557, 8, 242, 1, 242, 4, 242, 5560, 8, 242, 11, 242, 12, 242, 5561, 3, 242, 5564, 8, 242, 3, 242, 5566, 8, 242, 1, 243, 1, 243, 1, 243, 1, 243, 3, 243, 5572, 8, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 3, 246, 5589, 8, 246, 1, 246, 1, 246, 5, 246, 5593, 8, 246, 10, 246, 12, 246, 5596, 9, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5608, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5614, 8, 247, 1, 247, 1, 247, 3, 247, 5618, 8, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5623, 8, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5653, 8, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5668, 8, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5673, 8, 249, 1, 250, 1, 250, 3, 250, 5677, 8, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 3, 251, 5690, 8, 251, 1, 251, 1, 251, 3, 251, 5694, 8, 251, 3, 251, 5696, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 5, 251, 5703, 8, 251, 10, 251, 12, 251, 5706, 9, 251, 1, 251, 1, 251, 1, 251, 3, 251, 5711, 8, 251, 3, 251, 5713, 8, 251, 1, 252, 1, 252, 3, 252, 5717, 8, 252, 1, 252, 3, 252, 5720, 8, 252, 1, 252, 3, 252, 5723, 8, 252, 1, 252, 3, 252, 5726, 8, 252, 1, 252, 3, 252, 5729, 8, 252, 3, 252, 5731, 8, 252, 1, 252, 3, 252, 5734, 8, 252, 1, 253, 1, 253, 3, 253, 5738, 8, 253, 1, 253, 1, 253, 1, 253, 1, 253, 5, 253, 5744, 8, 253, 10, 253, 12, 253, 5747, 9, 253, 1, 253, 1, 253, 3, 253, 5751, 8, 253, 1, 253, 3, 253, 5754, 8, 253, 1, 254, 1, 254, 1, 255, 1, 255, 3, 255, 5760, 8, 255, 1, 255, 1, 255, 3, 255, 5764, 8, 255, 1, 256, 1, 256, 3, 256, 5768, 8, 256, 1, 256, 1, 256, 1, 256, 3, 256, 5773, 8, 256, 3, 256, 5775, 8, 256, 1, 257, 1, 257, 3, 257, 5779, 8, 257, 1, 258, 1, 258, 3, 258, 5783, 8, 258, 1, 259, 1, 259, 1, 259, 5, 259, 5788, 8, 259, 10, 259, 12, 259, 5791, 9, 259, 1, 260, 1, 260, 1, 260, 3, 260, 5796, 8, 260, 1, 260, 1, 260, 3, 260, 5800, 8, 260, 3, 260, 5802, 8, 260, 3, 260, 5804, 8, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 5817, 8, 261, 1, 262, 1, 262, 1, 262, 1, 262, 5, 262, 5823, 8, 262, 10, 262, 12, 262, 5826, 9, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 3, 263, 5833, 8, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 5, 264, 5842, 8, 264, 10, 264, 12, 264, 5845, 9, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 3, 265, 5853, 8, 265, 1, 266, 1, 266, 1, 266, 3, 266, 5858, 8, 266, 1, 266, 1, 266, 3, 266, 5862, 8, 266, 1, 266, 1, 266, 3, 266, 5866, 8, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 3, 266, 5873, 8, 266, 1, 266, 3, 266, 5876, 8, 266, 3, 266, 5878, 8, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 3, 268, 5886, 8, 268, 1, 268, 1, 268, 3, 268, 5890, 8, 268, 1, 269, 3, 269, 5893, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5900, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5907, 8, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5912, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5919, 8, 269, 1, 269, 3, 269, 5922, 8, 269, 3, 269, 5924, 8, 269, 1, 269, 3, 269, 5927, 8, 269, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 5933, 8, 270, 1, 270, 1, 270, 1, 270, 3, 270, 5938, 8, 270, 1, 270, 1, 270, 3, 270, 5942, 8, 270, 1, 271, 1, 271, 1, 271, 5, 271, 5947, 8, 271, 10, 271, 12, 271, 5950, 9, 271, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 274, 3, 274, 5959, 8, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 5966, 8, 274, 1, 274, 3, 274, 5969, 8, 274, 1, 274, 3, 274, 5972, 8, 274, 1, 275, 1, 275, 3, 275, 5976, 8, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275, 5987, 8, 275, 1, 275, 3, 275, 5990, 8, 275, 1, 275, 3, 275, 5993, 8, 275, 1, 275, 3, 275, 5996, 8, 275, 1, 276, 3, 276, 5999, 8, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, 6006, 8, 276, 1, 276, 3, 276, 6009, 8, 276, 1, 276, 3, 276, 6012, 8, 276, 1, 277, 1, 277, 1, 277, 5, 277, 6017, 8, 277, 10, 277, 12, 277, 6020, 9, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 6031, 8, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 6038, 8, 278, 3, 278, 6040, 8, 278, 1, 279, 1, 279, 1, 279, 3, 279, 6045, 8, 279, 1, 279, 1, 279, 1, 279, 5, 279, 6050, 8, 279, 10, 279, 12, 279, 6053, 9, 279, 1, 279, 1, 279, 1, 279, 3, 279, 6058, 8, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 3, 280, 6065, 8, 280, 1, 281, 1, 281, 1, 281, 3, 281, 6070, 8, 281, 1, 281, 1, 281, 1, 282, 3, 282, 6075, 8, 282, 1, 282, 1, 282, 3, 282, 6079, 8, 282, 1, 282, 1, 282, 3, 282, 6083, 8, 282, 1, 282, 1, 282, 3, 282, 6087, 8, 282, 3, 282, 6089, 8, 282, 1, 283, 1, 283, 3, 283, 6093, 8, 283, 1, 284, 1, 284, 3, 284, 6097, 8, 284, 1, 284, 3, 284, 6100, 8, 284, 1, 284, 3, 284, 6103, 8, 284, 3, 284, 6105, 8, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 6115, 8, 284, 3, 284, 6117, 8, 284, 1, 284, 1, 284, 1, 284, 3, 284, 6122, 8, 284, 5, 284, 6124, 8, 284, 10, 284, 12, 284, 6127, 9, 284, 1, 285, 1, 285, 3, 285, 6131, 8, 285, 1, 286, 1, 286, 3, 286, 6135, 8, 286, 1, 286, 1, 286, 1, 286, 5, 286, 6140, 8, 286, 10, 286, 12, 286, 6143, 9, 286, 1, 287, 1, 287, 3, 287, 6147, 8, 287, 1, 287, 1, 287, 3, 287, 6151, 8, 287, 1, 287, 3, 287, 6154, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 6160, 8, 287, 1, 287, 3, 287, 6163, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 3, 289, 6182, 8, 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 3, 290, 6189, 8, 290, 1, 290, 1, 290, 3, 290, 6193, 8, 290, 1, 291, 3, 291, 6196, 8, 291, 1, 291, 1, 291, 3, 291, 6200, 8, 291, 1, 291, 1, 291, 3, 291, 6204, 8, 291, 1, 291, 3, 291, 6207, 8, 291, 1, 291, 3, 291, 6210, 8, 291, 1, 292, 1, 292, 1, 292, 3, 292, 6215, 8, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 5, 293, 6222, 8, 293, 10, 293, 12, 293, 6225, 9, 293, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 6231, 8, 294, 1, 294, 1, 294, 3, 294, 6235, 8, 294, 1, 295, 1, 295, 3, 295, 6239, 8, 295, 1, 295, 1, 295, 3, 295, 6243, 8, 295, 1, 295, 3, 295, 6246, 8, 295, 3, 295, 6248, 8, 295, 1, 296, 1, 296, 1, 296, 3, 296, 6253, 8, 296, 1, 296, 1, 296, 3, 296, 6257, 8, 296, 1, 297, 1, 297, 1, 297, 3, 297, 6262, 8, 297, 1, 297, 1, 297, 1, 297, 1, 297, 3, 297, 6268, 8, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 6275, 8, 298, 1, 299, 1, 299, 1, 299, 3, 299, 6280, 8, 299, 1, 300, 1, 300, 1, 300, 3, 300, 6285, 8, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 5, 301, 6292, 8, 301, 10, 301, 12, 301, 6295, 9, 301, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6301, 8, 302, 1, 302, 1, 302, 1, 302, 1, 302, 5, 302, 6307, 8, 302, 10, 302, 12, 302, 6310, 9, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6320, 8, 302, 1, 303, 1, 303, 1, 303, 3, 303, 6325, 8, 303, 1, 303, 1, 303, 3, 303, 6329, 8, 303, 1, 303, 3, 303, 6332, 8, 303, 1, 303, 1, 303, 3, 303, 6336, 8, 303, 1, 303, 1, 303, 1, 303, 3, 303, 6341, 8, 303, 4, 303, 6343, 8, 303, 11, 303, 12, 303, 6344, 1, 303, 1, 303, 1, 303, 3, 303, 6350, 8, 303, 1, 304, 1, 304, 1, 304, 1, 304, 5, 304, 6356, 8, 304, 10, 304, 12, 304, 6359, 9, 304, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 5, 306, 6367, 8, 306, 10, 306, 12, 306, 6370, 9, 306, 1, 307, 1, 307, 3, 307, 6374, 8, 307, 1, 307, 1, 307, 3, 307, 6378, 8, 307, 1, 307, 3, 307, 6381, 8, 307, 1, 307, 3, 307, 6384, 8, 307, 3, 307, 6386, 8, 307, 1, 307, 3, 307, 6389, 8, 307, 1, 307, 3, 307, 6392, 8, 307, 1, 307, 3, 307, 6395, 8, 307, 1, 307, 1, 307, 3, 307, 6399, 8, 307, 1, 307, 1, 307, 3, 307, 6403, 8, 307, 1, 307, 1, 307, 3, 307, 6407, 8, 307, 3, 307, 6409, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6418, 8, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6423, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6429, 8, 307, 1, 307, 1, 307, 3, 307, 6433, 8, 307, 3, 307, 6435, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6442, 8, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6447, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 5, 307, 6453, 8, 307, 10, 307, 12, 307, 6456, 9, 307, 1, 308, 3, 308, 6459, 8, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 6466, 8, 308, 1, 309, 1, 309, 1, 309, 3, 309, 6471, 8, 309, 1, 309, 3, 309, 6474, 8, 309, 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, 6480, 8, 309, 1, 310, 1, 310, 3, 310, 6484, 8, 310, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 6490, 8, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 6499, 8, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 6505, 8, 312, 3, 312, 6507, 8, 312, 1, 313, 1, 313, 1, 313, 3, 313, 6512, 8, 313, 1, 313, 3, 313, 6515, 8, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 6524, 8, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 6531, 8, 313, 3, 313, 6533, 8, 313, 1, 314, 1, 314, 1, 314, 5, 314, 6538, 8, 314, 10, 314, 12, 314, 6541, 9, 314, 1, 315, 1, 315, 3, 315, 6545, 8, 315, 1, 315, 3, 315, 6548, 8, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 3, 316, 6558, 8, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 5, 317, 6567, 8, 317, 10, 317, 12, 317, 6570, 9, 317, 1, 317, 1, 317, 3, 317, 6574, 8, 317, 1, 317, 1, 317, 3, 317, 6578, 8, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 3, 318, 6586, 8, 318, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 6596, 8, 320, 1, 321, 1, 321, 1, 321, 5, 321, 6601, 8, 321, 10, 321, 12, 321, 6604, 9, 321, 1, 322, 1, 322, 1, 322, 3, 322, 6609, 8, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 5, 323, 6618, 8, 323, 10, 323, 12, 323, 6621, 9, 323, 1, 323, 1, 323, 1, 323, 3, 323, 6626, 8, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 5, 323, 6634, 8, 323, 10, 323, 12, 323, 6637, 9, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 3, 324, 6645, 8, 324, 1, 324, 1, 324, 3, 324, 6649, 8, 324, 1, 324, 4, 324, 6652, 8, 324, 11, 324, 12, 324, 6653, 3, 324, 6656, 8, 324, 1, 324, 1, 324, 3, 324, 6660, 8, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6668, 8, 325, 1, 326, 3, 326, 6671, 8, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6676, 8, 326, 1, 326, 5, 326, 6679, 8, 326, 10, 326, 12, 326, 6682, 9, 326, 1, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6688, 8, 326, 3, 326, 6690, 8, 326, 1, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6696, 8, 326, 1, 327, 1, 327, 3, 327, 6700, 8, 327, 1, 327, 3, 327, 6703, 8, 327, 1, 327, 1, 327, 1, 327, 3, 327, 6708, 8, 327, 1, 327, 3, 327, 6711, 8, 327, 3, 327, 6713, 8, 327, 1, 328, 1, 328, 1, 328, 1, 328, 3, 328, 6719, 8, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 6728, 8, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 6734, 8, 329, 1, 329, 3, 329, 6737, 8, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 3, 331, 6745, 8, 331, 1, 331, 3, 331, 6748, 8, 331, 1, 332, 1, 332, 3, 332, 6752, 8, 332, 1, 332, 1, 332, 1, 332, 1, 332, 3, 332, 6758, 8, 332, 3, 332, 6760, 8, 332, 1, 332, 3, 332, 6763, 8, 332, 1, 333, 1, 333, 3, 333, 6767, 8, 333, 1, 333, 1, 333, 1, 333, 3, 333, 6772, 8, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6779, 8, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6786, 8, 334, 3, 334, 6788, 8, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6794, 8, 334, 3, 334, 6796, 8, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6801, 8, 334, 3, 334, 6803, 8, 334, 1, 335, 1, 335, 3, 335, 6807, 8, 335, 1, 336, 1, 336, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 3, 338, 6816, 8, 338, 1, 338, 1, 338, 3, 338, 6820, 8, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 5, 338, 6828, 8, 338, 10, 338, 12, 338, 6831, 9, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6844, 8, 339, 1, 339, 3, 339, 6847, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6855, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 5, 339, 6862, 8, 339, 10, 339, 12, 339, 6865, 9, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6870, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6875, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6883, 8, 339, 3, 339, 6885, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6890, 8, 339, 1, 339, 1, 339, 3, 339, 6894, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6899, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6904, 8, 339, 1, 340, 1, 340, 1, 340, 1, 340, 3, 340, 6910, 8, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 5, 340, 6926, 8, 340, 10, 340, 12, 340, 6929, 9, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6937, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6952, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6957, 8, 341, 1, 341, 3, 341, 6960, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6966, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6971, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6984, 8, 341, 1, 341, 4, 341, 6987, 8, 341, 11, 341, 12, 341, 6988, 1, 341, 1, 341, 3, 341, 6993, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7000, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7019, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7031, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7036, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7044, 8, 341, 5, 341, 7046, 8, 341, 10, 341, 12, 341, 7049, 9, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7057, 8, 342, 1, 342, 3, 342, 7060, 8, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7065, 8, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7070, 8, 342, 1, 342, 3, 342, 7073, 8, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7084, 8, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7092, 8, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7097, 8, 343, 3, 343, 7099, 8, 343, 1, 343, 3, 343, 7102, 8, 343, 1, 344, 1, 344, 3, 344, 7106, 8, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7117, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7138, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7146, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7159, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7169, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7175, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7181, 8, 345, 1, 345, 3, 345, 7184, 8, 345, 1, 345, 3, 345, 7187, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7213, 8, 345, 3, 345, 7215, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7236, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7246, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7259, 8, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7264, 8, 345, 1, 345, 1, 345, 3, 345, 7268, 8, 345, 3, 345, 7270, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7282, 8, 345, 1, 346, 1, 346, 1, 346, 5, 346, 7287, 8, 346, 10, 346, 12, 346, 7290, 9, 346, 1, 347, 1, 347, 1, 347, 3, 347, 7295, 8, 347, 1, 348, 1, 348, 1, 349, 1, 349, 3, 349, 7301, 8, 349, 1, 349, 1, 349, 3, 349, 7305, 8, 349, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 5, 351, 7314, 8, 351, 10, 351, 12, 351, 7317, 9, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 3, 353, 7326, 8, 353, 1, 354, 1, 354, 3, 354, 7330, 8, 354, 1, 354, 1, 354, 1, 354, 3, 354, 7335, 8, 354, 1, 354, 3, 354, 7338, 8, 354, 1, 354, 3, 354, 7341, 8, 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 3, 355, 7350, 8, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 3, 355, 7361, 8, 355, 3, 355, 7363, 8, 355, 1, 356, 1, 356, 3, 356, 7367, 8, 356, 1, 356, 1, 356, 1, 356, 3, 356, 7372, 8, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 3, 357, 7381, 8, 357, 1, 358, 1, 358, 1, 358, 3, 358, 7386, 8, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 360, 1, 360, 3, 360, 7394, 8, 360, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 3, 362, 7404, 8, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 3, 363, 7412, 8, 363, 1, 364, 1, 364, 3, 364, 7416, 8, 364, 1, 364, 3, 364, 7419, 8, 364, 1, 365, 1, 365, 1, 365, 5, 365, 7424, 8, 365, 10, 365, 12, 365, 7427, 9, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 3, 366, 7434, 8, 366, 1, 367, 1, 367, 3, 367, 7438, 8, 367, 1, 368, 1, 368, 1, 368, 5, 368, 7443, 8, 368, 10, 368, 12, 368, 7446, 9, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 3, 369, 7453, 8, 369, 3, 369, 7455, 8, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 5, 370, 7462, 8, 370, 10, 370, 12, 370, 7465, 9, 370, 3, 370, 7467, 8, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 7479, 8, 371, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7488, 8, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7495, 8, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7504, 8, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 3, 375, 7514, 8, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7519, 8, 375, 1, 375, 1, 375, 3, 375, 7523, 8, 375, 3, 375, 7525, 8, 375, 1, 375, 3, 375, 7528, 8, 375, 1, 376, 4, 376, 7531, 8, 376, 11, 376, 12, 376, 7532, 1, 377, 5, 377, 7536, 8, 377, 10, 377, 12, 377, 7539, 9, 377, 1, 378, 1, 378, 1, 378, 5, 378, 7544, 8, 378, 10, 378, 12, 378, 7547, 9, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 3, 379, 7554, 8, 379, 1, 379, 3, 379, 7557, 8, 379, 1, 380, 1, 380, 1, 380, 5, 380, 7562, 8, 380, 10, 380, 12, 380, 7565, 9, 380, 1, 381, 1, 381, 1, 381, 5, 381, 7570, 8, 381, 10, 381, 12, 381, 7573, 9, 381, 1, 382, 1, 382, 1, 382, 5, 382, 7578, 8, 382, 10, 382, 12, 382, 7581, 9, 382, 1, 383, 1, 383, 1, 383, 5, 383, 7586, 8, 383, 10, 383, 12, 383, 7589, 9, 383, 1, 384, 1, 384, 1, 385, 1, 385, 1, 386, 1, 386, 1, 387, 1, 387, 1, 388, 1, 388, 1, 389, 1, 389, 1, 390, 1, 390, 3, 390, 7605, 8, 390, 1, 391, 1, 391, 1, 391, 5, 391, 7610, 8, 391, 10, 391, 12, 391, 7613, 9, 391, 1, 392, 1, 392, 1, 392, 5, 392, 7618, 8, 392, 10, 392, 12, 392, 7621, 9, 392, 1, 393, 1, 393, 1, 394, 1, 394, 1, 395, 1, 395, 1, 396, 1, 396, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 7637, 8, 398, 1, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7643, 8, 399, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 7649, 8, 400, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 3, 402, 7657, 8, 402, 1, 403, 1, 403, 1, 403, 1, 403, 3, 403, 7663, 8, 403, 1, 404, 1, 404, 1, 404, 3, 404, 7668, 8, 404, 1, 405, 1, 405, 1, 405, 1, 405, 5, 405, 7674, 8, 405, 10, 405, 12, 405, 7677, 9, 405, 1, 405, 1, 405, 3, 405, 7681, 8, 405, 1, 406, 3, 406, 7684, 8, 406, 1, 406, 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 3, 407, 7693, 8, 407, 1, 408, 1, 408, 1, 408, 5, 408, 7698, 8, 408, 10, 408, 12, 408, 7701, 9, 408, 1, 409, 1, 409, 3, 409, 7705, 8, 409, 1, 410, 1, 410, 3, 410, 7709, 8, 410, 1, 411, 1, 411, 1, 411, 3, 411, 7714, 8, 411, 1, 412, 1, 412, 1, 412, 1, 412, 3, 412, 7720, 8, 412, 1, 413, 1, 413, 1, 413, 3, 413, 7725, 8, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 3, 413, 7733, 8, 413, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 3, 415, 7788, 8, 415, 1, 416, 1, 416, 1, 417, 1, 417, 1, 418, 3, 418, 7795, 8, 418, 1, 418, 1, 418, 1, 418, 1, 418, 4, 418, 7801, 8, 418, 11, 418, 12, 418, 7802, 3, 418, 7805, 8, 418, 3, 418, 7807, 8, 418, 1, 418, 1, 418, 5, 418, 7811, 8, 418, 10, 418, 12, 418, 7814, 9, 418, 1, 418, 3, 418, 7817, 8, 418, 1, 418, 1, 418, 3, 418, 7821, 8, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 3, 420, 7832, 8, 420, 1, 420, 3, 420, 7835, 8, 420, 1, 420, 1, 420, 3, 420, 7839, 8, 420, 1, 420, 1, 420, 3, 420, 7843, 8, 420, 1, 420, 1, 420, 3, 420, 7847, 8, 420, 1, 420, 3, 420, 7850, 8, 420, 1, 420, 3, 420, 7853, 8, 420, 1, 420, 3, 420, 7856, 8, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 5, 420, 7863, 8, 420, 10, 420, 12, 420, 7866, 9, 420, 1, 420, 1, 420, 3, 420, 7870, 8, 420, 1, 420, 1, 420, 3, 420, 7874, 8, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 3, 423, 7907, 8, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7917, 8, 425, 1, 425, 1, 425, 3, 425, 7921, 8, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7927, 8, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7932, 8, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 3, 427, 7941, 8, 427, 1, 427, 1, 427, 1, 427, 1, 427, 5, 427, 7947, 8, 427, 10, 427, 12, 427, 7950, 9, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 3, 429, 7960, 8, 429, 1, 429, 1, 429, 1, 429, 1, 429, 5, 429, 7966, 8, 429, 10, 429, 12, 429, 7969, 9, 429, 1, 430, 1, 430, 1, 430, 1, 430, 5, 430, 7975, 8, 430, 10, 430, 12, 430, 7978, 9, 430, 1, 430, 1, 430, 1, 430, 1, 430, 5, 430, 7984, 8, 430, 10, 430, 12, 430, 7987, 9, 430, 5, 430, 7989, 8, 430, 10, 430, 12, 430, 7992, 9, 430, 1, 430, 3, 430, 7995, 8, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 5, 431, 8003, 8, 431, 10, 431, 12, 431, 8006, 9, 431, 1, 432, 1, 432, 3, 432, 8010, 8, 432, 1, 432, 1, 432, 1, 432, 1, 432, 5, 432, 8016, 8, 432, 10, 432, 12, 432, 8019, 9, 432, 4, 432, 8021, 8, 432, 11, 432, 12, 432, 8022, 1, 432, 3, 432, 8026, 8, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 3, 433, 8033, 8, 433, 1, 433, 1, 433, 1, 433, 1, 433, 3, 433, 8039, 8, 433, 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8047, 8, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8055, 8, 434, 1, 434, 3, 434, 8058, 8, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8065, 8, 434, 3, 434, 8067, 8, 434, 1, 435, 3, 435, 8070, 8, 435, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 8076, 8, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 3, 436, 8085, 8, 436, 1, 436, 1, 436, 3, 436, 8089, 8, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 3, 437, 8103, 8, 437, 1, 437, 3, 437, 8106, 8, 437, 3, 437, 8108, 8, 437, 1, 437, 1, 437, 1, 438, 1, 438, 3, 438, 8114, 8, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 4, 438, 8122, 8, 438, 11, 438, 12, 438, 8123, 3, 438, 8126, 8, 438, 3, 438, 8128, 8, 438, 1, 438, 1, 438, 1, 438, 1, 438, 5, 438, 8134, 8, 438, 10, 438, 12, 438, 8137, 9, 438, 3, 438, 8139, 8, 438, 1, 438, 3, 438, 8142, 8, 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, 1, 440, 3, 440, 8152, 8, 440, 1, 440, 1, 440, 1, 441, 1, 441, 5, 441, 8158, 8, 441, 10, 441, 12, 441, 8161, 9, 441, 1, 441, 1, 441, 1, 441, 3, 441, 8166, 8, 441, 1, 441, 1, 441, 1, 442, 1, 442, 3, 442, 8172, 8, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 3, 443, 8179, 8, 443, 1, 443, 1, 443, 3, 443, 8183, 8, 443, 1, 443, 1, 443, 3, 443, 8187, 8, 443, 1, 443, 3, 443, 8190, 8, 443, 1, 443, 3, 443, 8193, 8, 443, 1, 443, 1, 443, 1, 444, 1, 444, 3, 444, 8199, 8, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 3, 445, 8206, 8, 445, 1, 445, 3, 445, 8209, 8, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 3, 445, 8217, 8, 445, 3, 445, 8219, 8, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 5, 445, 8226, 8, 445, 10, 445, 12, 445, 8229, 9, 445, 1, 445, 1, 445, 3, 445, 8233, 8, 445, 3, 445, 8235, 8, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 3, 446, 8242, 8, 446, 1, 446, 1, 446, 1, 447, 1, 447, 3, 447, 8248, 8, 447, 1, 447, 3, 447, 8251, 8, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8263, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8270, 8, 448, 3, 448, 8272, 8, 448, 1, 449, 1, 449, 3, 449, 8276, 8, 449, 1, 449, 1, 449, 1, 449, 1, 450, 3, 450, 8282, 8, 450, 1, 450, 1, 450, 1, 450, 3, 450, 8287, 8, 450, 1, 450, 1, 450, 3, 450, 8291, 8, 450, 1, 450, 3, 450, 8294, 8, 450, 1, 450, 3, 450, 8297, 8, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 4, 450, 8304, 8, 450, 11, 450, 12, 450, 8305, 1, 451, 3, 451, 8309, 8, 451, 1, 451, 1, 451, 3, 451, 8313, 8, 451, 1, 451, 1, 451, 3, 451, 8317, 8, 451, 3, 451, 8319, 8, 451, 1, 451, 3, 451, 8322, 8, 451, 1, 451, 3, 451, 8325, 8, 451, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8331, 8, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8338, 8, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8345, 8, 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8351, 8, 452, 3, 452, 8353, 8, 452, 1, 453, 1, 453, 3, 453, 8357, 8, 453, 1, 453, 1, 453, 1, 453, 3, 453, 8362, 8, 453, 1, 453, 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 5, 454, 8378, 8, 454, 10, 454, 12, 454, 8381, 9, 454, 1, 454, 1, 454, 4, 454, 8385, 8, 454, 11, 454, 12, 454, 8386, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 5, 455, 8394, 8, 455, 10, 455, 12, 455, 8397, 9, 455, 1, 455, 1, 455, 1, 455, 1, 455, 3, 455, 8403, 8, 455, 1, 456, 1, 456, 3, 456, 8407, 8, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 3, 459, 8419, 8, 459, 1, 459, 3, 459, 8422, 8, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 3, 460, 8435, 8, 460, 1, 460, 3, 460, 8438, 8, 460, 1, 461, 1, 461, 3, 461, 8442, 8, 461, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 5, 462, 8449, 8, 462, 10, 462, 12, 462, 8452, 9, 462, 1, 462, 1, 462, 5, 462, 8456, 8, 462, 10, 462, 12, 462, 8459, 9, 462, 4, 462, 8461, 8, 462, 11, 462, 12, 462, 8462, 1, 463, 1, 463, 1, 463, 3, 463, 8468, 8, 463, 1, 464, 1, 464, 3, 464, 8472, 8, 464, 1, 465, 3, 465, 8475, 8, 465, 1, 465, 3, 465, 8478, 8, 465, 1, 465, 3, 465, 8481, 8, 465, 1, 465, 3, 465, 8484, 8, 465, 1, 465, 3, 465, 8487, 8, 465, 1, 465, 1, 465, 3, 465, 8491, 8, 465, 1, 465, 3, 465, 8494, 8, 465, 1, 465, 0, 3, 676, 680, 682, 466, 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, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 928, 930, 0, 118, 2, 0, 195, 195, 364, 364, 2, 0, 66, 66, 318, 318, 2, 0, 99, 99, 318, 318, 2, 0, 134, 134, 318, 318, 1, 0, 529, 531, 2, 0, 10, 10, 94, 94, 2, 0, 133, 133, 191, 191, 2, 0, 254, 254, 332, 332, 2, 0, 162, 162, 363, 363, 2, 0, 180, 180, 221, 221, 5, 0, 30, 30, 288, 288, 329, 329, 352, 352, 354, 354, 2, 0, 109, 109, 532, 532, 2, 0, 158, 158, 277, 277, 2, 0, 367, 367, 439, 439, 2, 0, 139, 139, 312, 312, 2, 0, 191, 191, 333, 333, 2, 0, 313, 313, 333, 333, 2, 0, 150, 150, 315, 315, 2, 0, 64, 64, 94, 94, 4, 0, 78, 78, 183, 183, 197, 197, 298, 298, 2, 0, 213, 213, 254, 254, 2, 0, 352, 352, 354, 354, 2, 0, 200, 200, 224, 224, 9, 0, 30, 30, 160, 160, 165, 165, 179, 179, 219, 219, 227, 227, 342, 342, 345, 345, 438, 438, 3, 0, 113, 113, 284, 284, 336, 336, 2, 0, 53, 53, 78, 78, 2, 0, 105, 105, 379, 379, 2, 0, 260, 260, 262, 262, 3, 0, 173, 173, 260, 260, 262, 262, 1, 0, 12, 13, 2, 0, 64, 64, 375, 375, 2, 0, 156, 156, 206, 206, 2, 0, 189, 189, 360, 360, 2, 0, 215, 215, 373, 373, 3, 0, 133, 133, 191, 191, 333, 333, 5, 0, 30, 30, 88, 88, 182, 182, 241, 241, 369, 369, 2, 0, 9, 9, 94, 94, 2, 0, 92, 92, 226, 226, 1, 0, 448, 449, 2, 0, 92, 92, 414, 414, 2, 0, 341, 341, 414, 414, 4, 0, 163, 163, 185, 185, 283, 283, 353, 353, 2, 0, 135, 135, 145, 145, 2, 0, 211, 211, 278, 278, 3, 0, 321, 321, 357, 357, 445, 445, 3, 0, 66, 66, 99, 99, 318, 318, 5, 0, 108, 108, 168, 168, 226, 226, 328, 328, 342, 342, 2, 0, 167, 167, 314, 314, 2, 0, 61, 61, 265, 265, 4, 0, 207, 207, 249, 249, 268, 268, 293, 293, 2, 0, 130, 130, 307, 307, 2, 0, 64, 64, 68, 68, 10, 0, 46, 46, 88, 88, 182, 182, 202, 202, 241, 241, 352, 352, 354, 354, 357, 358, 369, 369, 521, 523, 5, 0, 212, 212, 329, 329, 350, 350, 455, 455, 457, 457, 5, 0, 212, 212, 329, 329, 350, 350, 361, 361, 455, 456, 2, 0, 37, 37, 55, 55, 2, 0, 207, 207, 249, 249, 2, 0, 10, 10, 53, 53, 2, 0, 181, 181, 243, 243, 2, 0, 170, 170, 320, 320, 2, 0, 141, 141, 223, 223, 5, 0, 108, 108, 168, 168, 189, 189, 342, 342, 360, 360, 2, 0, 226, 226, 328, 328, 2, 0, 163, 163, 185, 185, 2, 0, 186, 186, 193, 193, 4, 0, 88, 88, 182, 182, 241, 241, 369, 369, 2, 0, 137, 137, 242, 242, 2, 0, 161, 161, 319, 319, 4, 0, 129, 129, 161, 161, 319, 319, 454, 454, 2, 0, 356, 356, 380, 380, 2, 0, 81, 81, 382, 382, 2, 0, 151, 151, 254, 254, 2, 0, 133, 133, 138, 138, 1, 0, 31, 32, 2, 0, 128, 128, 547, 547, 2, 0, 60, 60, 96, 96, 2, 0, 99, 99, 349, 349, 2, 0, 131, 131, 414, 414, 2, 0, 201, 201, 334, 334, 3, 0, 59, 59, 70, 70, 97, 97, 2, 0, 30, 30, 56, 56, 1, 0, 527, 528, 2, 0, 207, 207, 268, 268, 2, 0, 320, 320, 414, 414, 2, 0, 571, 571, 573, 573, 1, 0, 468, 469, 4, 0, 113, 113, 115, 115, 119, 119, 126, 126, 2, 0, 360, 360, 477, 477, 2, 0, 394, 395, 409, 409, 2, 0, 391, 392, 406, 406, 1, 0, 391, 392, 1, 0, 418, 419, 5, 0, 10, 10, 16, 17, 21, 21, 23, 23, 25, 25, 3, 0, 9, 9, 14, 14, 27, 27, 2, 0, 98, 98, 396, 396, 2, 0, 50, 51, 75, 76, 2, 0, 41, 41, 420, 420, 3, 0, 39, 39, 73, 73, 95, 95, 4, 0, 393, 393, 399, 399, 404, 404, 425, 425, 2, 0, 292, 292, 347, 347, 2, 0, 166, 166, 188, 188, 2, 0, 304, 304, 450, 450, 3, 0, 299, 299, 320, 320, 481, 481, 2, 0, 208, 208, 289, 289, 3, 0, 30, 30, 34, 34, 90, 90, 6, 0, 9, 10, 12, 17, 21, 21, 23, 23, 25, 25, 27, 27, 2, 0, 114, 114, 120, 120, 2, 0, 20, 20, 22, 22, 1, 0, 483, 486, 17, 0, 53, 53, 116, 116, 123, 124, 129, 228, 238, 386, 433, 452, 455, 469, 471, 471, 473, 473, 475, 475, 477, 488, 490, 502, 504, 504, 506, 518, 520, 520, 524, 524, 547, 548, 3, 0, 106, 123, 125, 128, 472, 472, 4, 0, 30, 52, 54, 70, 72, 105, 454, 454, 2, 0, 62, 62, 116, 116, 2, 0, 10, 10, 20, 20, 2, 0, 434, 434, 501, 501, 2, 0, 167, 167, 507, 507, 1, 0, 512, 517, 2, 0, 144, 144, 210, 210, 9931, 0, 935, 1, 0, 0, 0, 2, 940, 1, 0, 0, 0, 4, 1064, 1, 0, 0, 0, 6, 1066, 1, 0, 0, 0, 8, 1069, 1, 0, 0, 0, 10, 1119, 1, 0, 0, 0, 12, 1129, 1, 0, 0, 0, 14, 1131, 1, 0, 0, 0, 16, 1143, 1, 0, 0, 0, 18, 1155, 1, 0, 0, 0, 20, 1166, 1, 0, 0, 0, 22, 1200, 1, 0, 0, 0, 24, 1244, 1, 0, 0, 0, 26, 1246, 1, 0, 0, 0, 28, 1258, 1, 0, 0, 0, 30, 1265, 1, 0, 0, 0, 32, 1284, 1, 0, 0, 0, 34, 1292, 1, 0, 0, 0, 36, 1294, 1, 0, 0, 0, 38, 1308, 1, 0, 0, 0, 40, 1312, 1, 0, 0, 0, 42, 1349, 1, 0, 0, 0, 44, 1351, 1, 0, 0, 0, 46, 1359, 1, 0, 0, 0, 48, 1369, 1, 0, 0, 0, 50, 1376, 1, 0, 0, 0, 52, 1384, 1, 0, 0, 0, 54, 1390, 1, 0, 0, 0, 56, 1406, 1, 0, 0, 0, 58, 1410, 1, 0, 0, 0, 60, 1412, 1, 0, 0, 0, 62, 1424, 1, 0, 0, 0, 64, 1429, 1, 0, 0, 0, 66, 1434, 1, 0, 0, 0, 68, 1436, 1, 0, 0, 0, 70, 1448, 1, 0, 0, 0, 72, 1456, 1, 0, 0, 0, 74, 1458, 1, 0, 0, 0, 76, 1582, 1, 0, 0, 0, 78, 1584, 1, 0, 0, 0, 80, 1601, 1, 0, 0, 0, 82, 1603, 1, 0, 0, 0, 84, 1617, 1, 0, 0, 0, 86, 1619, 1, 0, 0, 0, 88, 1633, 1, 0, 0, 0, 90, 1635, 1, 0, 0, 0, 92, 1872, 1, 0, 0, 0, 94, 1879, 1, 0, 0, 0, 96, 1881, 1, 0, 0, 0, 98, 1883, 1, 0, 0, 0, 100, 1886, 1, 0, 0, 0, 102, 1897, 1, 0, 0, 0, 104, 1900, 1, 0, 0, 0, 106, 1936, 1, 0, 0, 0, 108, 1938, 1, 0, 0, 0, 110, 1979, 1, 0, 0, 0, 112, 1981, 1, 0, 0, 0, 114, 2035, 1, 0, 0, 0, 116, 2076, 1, 0, 0, 0, 118, 2078, 1, 0, 0, 0, 120, 2095, 1, 0, 0, 0, 122, 2176, 1, 0, 0, 0, 124, 2178, 1, 0, 0, 0, 126, 2189, 1, 0, 0, 0, 128, 2212, 1, 0, 0, 0, 130, 2230, 1, 0, 0, 0, 132, 2232, 1, 0, 0, 0, 134, 2267, 1, 0, 0, 0, 136, 2360, 1, 0, 0, 0, 138, 2365, 1, 0, 0, 0, 140, 2367, 1, 0, 0, 0, 142, 2465, 1, 0, 0, 0, 144, 2467, 1, 0, 0, 0, 146, 2471, 1, 0, 0, 0, 148, 2482, 1, 0, 0, 0, 150, 2490, 1, 0, 0, 0, 152, 2493, 1, 0, 0, 0, 154, 2496, 1, 0, 0, 0, 156, 2514, 1, 0, 0, 0, 158, 2516, 1, 0, 0, 0, 160, 2520, 1, 0, 0, 0, 162, 2533, 1, 0, 0, 0, 164, 2535, 1, 0, 0, 0, 166, 2540, 1, 0, 0, 0, 168, 2560, 1, 0, 0, 0, 170, 2568, 1, 0, 0, 0, 172, 2575, 1, 0, 0, 0, 174, 2577, 1, 0, 0, 0, 176, 2586, 1, 0, 0, 0, 178, 2589, 1, 0, 0, 0, 180, 2593, 1, 0, 0, 0, 182, 2597, 1, 0, 0, 0, 184, 2622, 1, 0, 0, 0, 186, 2632, 1, 0, 0, 0, 188, 2646, 1, 0, 0, 0, 190, 2662, 1, 0, 0, 0, 192, 2668, 1, 0, 0, 0, 194, 2695, 1, 0, 0, 0, 196, 2705, 1, 0, 0, 0, 198, 2721, 1, 0, 0, 0, 200, 2765, 1, 0, 0, 0, 202, 2772, 1, 0, 0, 0, 204, 2774, 1, 0, 0, 0, 206, 2800, 1, 0, 0, 0, 208, 2811, 1, 0, 0, 0, 210, 2830, 1, 0, 0, 0, 212, 2841, 1, 0, 0, 0, 214, 2879, 1, 0, 0, 0, 216, 2900, 1, 0, 0, 0, 218, 2902, 1, 0, 0, 0, 220, 2922, 1, 0, 0, 0, 222, 2934, 1, 0, 0, 0, 224, 2946, 1, 0, 0, 0, 226, 2949, 1, 0, 0, 0, 228, 2952, 1, 0, 0, 0, 230, 2972, 1, 0, 0, 0, 232, 2977, 1, 0, 0, 0, 234, 3026, 1, 0, 0, 0, 236, 3028, 1, 0, 0, 0, 238, 3051, 1, 0, 0, 0, 240, 3067, 1, 0, 0, 0, 242, 3079, 1, 0, 0, 0, 244, 3106, 1, 0, 0, 0, 246, 3121, 1, 0, 0, 0, 248, 3184, 1, 0, 0, 0, 250, 3186, 1, 0, 0, 0, 252, 3191, 1, 0, 0, 0, 254, 3197, 1, 0, 0, 0, 256, 3284, 1, 0, 0, 0, 258, 3290, 1, 0, 0, 0, 260, 3292, 1, 0, 0, 0, 262, 3308, 1, 0, 0, 0, 264, 3310, 1, 0, 0, 0, 266, 3319, 1, 0, 0, 0, 268, 3323, 1, 0, 0, 0, 270, 3336, 1, 0, 0, 0, 272, 3348, 1, 0, 0, 0, 274, 3350, 1, 0, 0, 0, 276, 3372, 1, 0, 0, 0, 278, 3384, 1, 0, 0, 0, 280, 3395, 1, 0, 0, 0, 282, 3486, 1, 0, 0, 0, 284, 3488, 1, 0, 0, 0, 286, 3499, 1, 0, 0, 0, 288, 3510, 1, 0, 0, 0, 290, 3512, 1, 0, 0, 0, 292, 3538, 1, 0, 0, 0, 294, 3540, 1, 0, 0, 0, 296, 3544, 1, 0, 0, 0, 298, 3594, 1, 0, 0, 0, 300, 3596, 1, 0, 0, 0, 302, 3602, 1, 0, 0, 0, 304, 3627, 1, 0, 0, 0, 306, 3631, 1, 0, 0, 0, 308, 3845, 1, 0, 0, 0, 310, 3863, 1, 0, 0, 0, 312, 3889, 1, 0, 0, 0, 314, 3891, 1, 0, 0, 0, 316, 3899, 1, 0, 0, 0, 318, 3905, 1, 0, 0, 0, 320, 3909, 1, 0, 0, 0, 322, 3929, 1, 0, 0, 0, 324, 3935, 1, 0, 0, 0, 326, 4002, 1, 0, 0, 0, 328, 4033, 1, 0, 0, 0, 330, 4079, 1, 0, 0, 0, 332, 4081, 1, 0, 0, 0, 334, 4083, 1, 0, 0, 0, 336, 4094, 1, 0, 0, 0, 338, 4131, 1, 0, 0, 0, 340, 4133, 1, 0, 0, 0, 342, 4139, 1, 0, 0, 0, 344, 4189, 1, 0, 0, 0, 346, 4192, 1, 0, 0, 0, 348, 4206, 1, 0, 0, 0, 350, 4227, 1, 0, 0, 0, 352, 4251, 1, 0, 0, 0, 354, 4292, 1, 0, 0, 0, 356, 4294, 1, 0, 0, 0, 358, 4296, 1, 0, 0, 0, 360, 4336, 1, 0, 0, 0, 362, 4353, 1, 0, 0, 0, 364, 4373, 1, 0, 0, 0, 366, 4426, 1, 0, 0, 0, 368, 4429, 1, 0, 0, 0, 370, 4435, 1, 0, 0, 0, 372, 4443, 1, 0, 0, 0, 374, 4456, 1, 0, 0, 0, 376, 4458, 1, 0, 0, 0, 378, 4471, 1, 0, 0, 0, 380, 4473, 1, 0, 0, 0, 382, 4486, 1, 0, 0, 0, 384, 4496, 1, 0, 0, 0, 386, 4507, 1, 0, 0, 0, 388, 4518, 1, 0, 0, 0, 390, 4520, 1, 0, 0, 0, 392, 4525, 1, 0, 0, 0, 394, 4539, 1, 0, 0, 0, 396, 4571, 1, 0, 0, 0, 398, 4608, 1, 0, 0, 0, 400, 4610, 1, 0, 0, 0, 402, 4613, 1, 0, 0, 0, 404, 4616, 1, 0, 0, 0, 406, 4633, 1, 0, 0, 0, 408, 4654, 1, 0, 0, 0, 410, 4670, 1, 0, 0, 0, 412, 4686, 1, 0, 0, 0, 414, 4708, 1, 0, 0, 0, 416, 4713, 1, 0, 0, 0, 418, 4716, 1, 0, 0, 0, 420, 4724, 1, 0, 0, 0, 422, 4749, 1, 0, 0, 0, 424, 4752, 1, 0, 0, 0, 426, 4780, 1, 0, 0, 0, 428, 4785, 1, 0, 0, 0, 430, 4825, 1, 0, 0, 0, 432, 5037, 1, 0, 0, 0, 434, 5039, 1, 0, 0, 0, 436, 5127, 1, 0, 0, 0, 438, 5129, 1, 0, 0, 0, 440, 5135, 1, 0, 0, 0, 442, 5146, 1, 0, 0, 0, 444, 5156, 1, 0, 0, 0, 446, 5236, 1, 0, 0, 0, 448, 5238, 1, 0, 0, 0, 450, 5252, 1, 0, 0, 0, 452, 5274, 1, 0, 0, 0, 454, 5347, 1, 0, 0, 0, 456, 5349, 1, 0, 0, 0, 458, 5390, 1, 0, 0, 0, 460, 5392, 1, 0, 0, 0, 462, 5397, 1, 0, 0, 0, 464, 5400, 1, 0, 0, 0, 466, 5403, 1, 0, 0, 0, 468, 5453, 1, 0, 0, 0, 470, 5455, 1, 0, 0, 0, 472, 5466, 1, 0, 0, 0, 474, 5468, 1, 0, 0, 0, 476, 5478, 1, 0, 0, 0, 478, 5513, 1, 0, 0, 0, 480, 5516, 1, 0, 0, 0, 482, 5537, 1, 0, 0, 0, 484, 5547, 1, 0, 0, 0, 486, 5567, 1, 0, 0, 0, 488, 5573, 1, 0, 0, 0, 490, 5579, 1, 0, 0, 0, 492, 5584, 1, 0, 0, 0, 494, 5597, 1, 0, 0, 0, 496, 5624, 1, 0, 0, 0, 498, 5672, 1, 0, 0, 0, 500, 5674, 1, 0, 0, 0, 502, 5712, 1, 0, 0, 0, 504, 5714, 1, 0, 0, 0, 506, 5735, 1, 0, 0, 0, 508, 5755, 1, 0, 0, 0, 510, 5759, 1, 0, 0, 0, 512, 5774, 1, 0, 0, 0, 514, 5776, 1, 0, 0, 0, 516, 5780, 1, 0, 0, 0, 518, 5784, 1, 0, 0, 0, 520, 5792, 1, 0, 0, 0, 522, 5816, 1, 0, 0, 0, 524, 5818, 1, 0, 0, 0, 526, 5829, 1, 0, 0, 0, 528, 5837, 1, 0, 0, 0, 530, 5852, 1, 0, 0, 0, 532, 5877, 1, 0, 0, 0, 534, 5879, 1, 0, 0, 0, 536, 5883, 1, 0, 0, 0, 538, 5892, 1, 0, 0, 0, 540, 5932, 1, 0, 0, 0, 542, 5943, 1, 0, 0, 0, 544, 5951, 1, 0, 0, 0, 546, 5954, 1, 0, 0, 0, 548, 5958, 1, 0, 0, 0, 550, 5973, 1, 0, 0, 0, 552, 5998, 1, 0, 0, 0, 554, 6013, 1, 0, 0, 0, 556, 6039, 1, 0, 0, 0, 558, 6041, 1, 0, 0, 0, 560, 6064, 1, 0, 0, 0, 562, 6066, 1, 0, 0, 0, 564, 6074, 1, 0, 0, 0, 566, 6092, 1, 0, 0, 0, 568, 6116, 1, 0, 0, 0, 570, 6128, 1, 0, 0, 0, 572, 6132, 1, 0, 0, 0, 574, 6144, 1, 0, 0, 0, 576, 6164, 1, 0, 0, 0, 578, 6172, 1, 0, 0, 0, 580, 6186, 1, 0, 0, 0, 582, 6209, 1, 0, 0, 0, 584, 6211, 1, 0, 0, 0, 586, 6216, 1, 0, 0, 0, 588, 6226, 1, 0, 0, 0, 590, 6247, 1, 0, 0, 0, 592, 6249, 1, 0, 0, 0, 594, 6258, 1, 0, 0, 0, 596, 6269, 1, 0, 0, 0, 598, 6279, 1, 0, 0, 0, 600, 6281, 1, 0, 0, 0, 602, 6288, 1, 0, 0, 0, 604, 6319, 1, 0, 0, 0, 606, 6349, 1, 0, 0, 0, 608, 6351, 1, 0, 0, 0, 610, 6360, 1, 0, 0, 0, 612, 6363, 1, 0, 0, 0, 614, 6434, 1, 0, 0, 0, 616, 6458, 1, 0, 0, 0, 618, 6479, 1, 0, 0, 0, 620, 6481, 1, 0, 0, 0, 622, 6489, 1, 0, 0, 0, 624, 6506, 1, 0, 0, 0, 626, 6532, 1, 0, 0, 0, 628, 6534, 1, 0, 0, 0, 630, 6542, 1, 0, 0, 0, 632, 6549, 1, 0, 0, 0, 634, 6573, 1, 0, 0, 0, 636, 6579, 1, 0, 0, 0, 638, 6587, 1, 0, 0, 0, 640, 6590, 1, 0, 0, 0, 642, 6597, 1, 0, 0, 0, 644, 6605, 1, 0, 0, 0, 646, 6610, 1, 0, 0, 0, 648, 6640, 1, 0, 0, 0, 650, 6667, 1, 0, 0, 0, 652, 6695, 1, 0, 0, 0, 654, 6712, 1, 0, 0, 0, 656, 6718, 1, 0, 0, 0, 658, 6736, 1, 0, 0, 0, 660, 6738, 1, 0, 0, 0, 662, 6742, 1, 0, 0, 0, 664, 6759, 1, 0, 0, 0, 666, 6764, 1, 0, 0, 0, 668, 6802, 1, 0, 0, 0, 670, 6804, 1, 0, 0, 0, 672, 6808, 1, 0, 0, 0, 674, 6810, 1, 0, 0, 0, 676, 6819, 1, 0, 0, 0, 678, 6903, 1, 0, 0, 0, 680, 6909, 1, 0, 0, 0, 682, 7018, 1, 0, 0, 0, 684, 7050, 1, 0, 0, 0, 686, 7101, 1, 0, 0, 0, 688, 7105, 1, 0, 0, 0, 690, 7281, 1, 0, 0, 0, 692, 7283, 1, 0, 0, 0, 694, 7291, 1, 0, 0, 0, 696, 7296, 1, 0, 0, 0, 698, 7298, 1, 0, 0, 0, 700, 7306, 1, 0, 0, 0, 702, 7309, 1, 0, 0, 0, 704, 7318, 1, 0, 0, 0, 706, 7322, 1, 0, 0, 0, 708, 7327, 1, 0, 0, 0, 710, 7344, 1, 0, 0, 0, 712, 7371, 1, 0, 0, 0, 714, 7380, 1, 0, 0, 0, 716, 7382, 1, 0, 0, 0, 718, 7389, 1, 0, 0, 0, 720, 7393, 1, 0, 0, 0, 722, 7395, 1, 0, 0, 0, 724, 7403, 1, 0, 0, 0, 726, 7411, 1, 0, 0, 0, 728, 7418, 1, 0, 0, 0, 730, 7420, 1, 0, 0, 0, 732, 7433, 1, 0, 0, 0, 734, 7437, 1, 0, 0, 0, 736, 7439, 1, 0, 0, 0, 738, 7454, 1, 0, 0, 0, 740, 7456, 1, 0, 0, 0, 742, 7478, 1, 0, 0, 0, 744, 7480, 1, 0, 0, 0, 746, 7503, 1, 0, 0, 0, 748, 7505, 1, 0, 0, 0, 750, 7527, 1, 0, 0, 0, 752, 7530, 1, 0, 0, 0, 754, 7537, 1, 0, 0, 0, 756, 7540, 1, 0, 0, 0, 758, 7556, 1, 0, 0, 0, 760, 7558, 1, 0, 0, 0, 762, 7566, 1, 0, 0, 0, 764, 7574, 1, 0, 0, 0, 766, 7582, 1, 0, 0, 0, 768, 7590, 1, 0, 0, 0, 770, 7592, 1, 0, 0, 0, 772, 7594, 1, 0, 0, 0, 774, 7596, 1, 0, 0, 0, 776, 7598, 1, 0, 0, 0, 778, 7600, 1, 0, 0, 0, 780, 7602, 1, 0, 0, 0, 782, 7606, 1, 0, 0, 0, 784, 7614, 1, 0, 0, 0, 786, 7622, 1, 0, 0, 0, 788, 7624, 1, 0, 0, 0, 790, 7626, 1, 0, 0, 0, 792, 7628, 1, 0, 0, 0, 794, 7630, 1, 0, 0, 0, 796, 7636, 1, 0, 0, 0, 798, 7642, 1, 0, 0, 0, 800, 7648, 1, 0, 0, 0, 802, 7650, 1, 0, 0, 0, 804, 7656, 1, 0, 0, 0, 806, 7662, 1, 0, 0, 0, 808, 7664, 1, 0, 0, 0, 810, 7680, 1, 0, 0, 0, 812, 7683, 1, 0, 0, 0, 814, 7692, 1, 0, 0, 0, 816, 7694, 1, 0, 0, 0, 818, 7704, 1, 0, 0, 0, 820, 7708, 1, 0, 0, 0, 822, 7713, 1, 0, 0, 0, 824, 7719, 1, 0, 0, 0, 826, 7732, 1, 0, 0, 0, 828, 7734, 1, 0, 0, 0, 830, 7787, 1, 0, 0, 0, 832, 7789, 1, 0, 0, 0, 834, 7791, 1, 0, 0, 0, 836, 7794, 1, 0, 0, 0, 838, 7822, 1, 0, 0, 0, 840, 7826, 1, 0, 0, 0, 842, 7877, 1, 0, 0, 0, 844, 7880, 1, 0, 0, 0, 846, 7906, 1, 0, 0, 0, 848, 7908, 1, 0, 0, 0, 850, 7931, 1, 0, 0, 0, 852, 7933, 1, 0, 0, 0, 854, 7938, 1, 0, 0, 0, 856, 7953, 1, 0, 0, 0, 858, 7959, 1, 0, 0, 0, 860, 7970, 1, 0, 0, 0, 862, 8000, 1, 0, 0, 0, 864, 8007, 1, 0, 0, 0, 866, 8032, 1, 0, 0, 0, 868, 8042, 1, 0, 0, 0, 870, 8069, 1, 0, 0, 0, 872, 8082, 1, 0, 0, 0, 874, 8092, 1, 0, 0, 0, 876, 8111, 1, 0, 0, 0, 878, 8143, 1, 0, 0, 0, 880, 8147, 1, 0, 0, 0, 882, 8155, 1, 0, 0, 0, 884, 8169, 1, 0, 0, 0, 886, 8175, 1, 0, 0, 0, 888, 8196, 1, 0, 0, 0, 890, 8202, 1, 0, 0, 0, 892, 8241, 1, 0, 0, 0, 894, 8245, 1, 0, 0, 0, 896, 8271, 1, 0, 0, 0, 898, 8273, 1, 0, 0, 0, 900, 8281, 1, 0, 0, 0, 902, 8318, 1, 0, 0, 0, 904, 8352, 1, 0, 0, 0, 906, 8354, 1, 0, 0, 0, 908, 8365, 1, 0, 0, 0, 910, 8402, 1, 0, 0, 0, 912, 8406, 1, 0, 0, 0, 914, 8408, 1, 0, 0, 0, 916, 8412, 1, 0, 0, 0, 918, 8415, 1, 0, 0, 0, 920, 8437, 1, 0, 0, 0, 922, 8441, 1, 0, 0, 0, 924, 8443, 1, 0, 0, 0, 926, 8467, 1, 0, 0, 0, 928, 8471, 1, 0, 0, 0, 930, 8474, 1, 0, 0, 0, 932, 934, 3, 2, 1, 0, 933, 932, 1, 0, 0, 0, 934, 937, 1, 0, 0, 0, 935, 933, 1, 0, 0, 0, 935, 936, 1, 0, 0, 0, 936, 938, 1, 0, 0, 0, 937, 935, 1, 0, 0, 0, 938, 939, 5, 0, 0, 1, 939, 1, 1, 0, 0, 0, 940, 942, 3, 4, 2, 0, 941, 943, 5, 7, 0, 0, 942, 941, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 3, 1, 0, 0, 0, 944, 1065, 3, 278, 139, 0, 945, 1065, 3, 488, 244, 0, 946, 1065, 3, 484, 242, 0, 947, 1065, 3, 486, 243, 0, 948, 1065, 3, 352, 176, 0, 949, 1065, 3, 494, 247, 0, 950, 1065, 3, 292, 146, 0, 951, 1065, 3, 210, 105, 0, 952, 1065, 3, 212, 106, 0, 953, 1065, 3, 218, 109, 0, 954, 1065, 3, 232, 116, 0, 955, 1065, 3, 404, 202, 0, 956, 1065, 3, 28, 14, 0, 957, 1065, 3, 434, 217, 0, 958, 1065, 3, 436, 218, 0, 959, 1065, 3, 446, 223, 0, 960, 1065, 3, 438, 219, 0, 961, 1065, 3, 444, 222, 0, 962, 1065, 3, 244, 122, 0, 963, 1065, 3, 246, 123, 0, 964, 1065, 3, 198, 99, 0, 965, 1065, 3, 490, 245, 0, 966, 1065, 3, 76, 38, 0, 967, 1065, 3, 430, 215, 0, 968, 1065, 3, 108, 54, 0, 969, 1065, 3, 450, 225, 0, 970, 1065, 3, 18, 9, 0, 971, 1065, 3, 20, 10, 0, 972, 1065, 3, 16, 8, 0, 973, 1065, 3, 454, 227, 0, 974, 1065, 3, 184, 92, 0, 975, 1065, 3, 498, 249, 0, 976, 1065, 3, 496, 248, 0, 977, 1065, 3, 240, 120, 0, 978, 1065, 3, 506, 253, 0, 979, 1065, 3, 6, 3, 0, 980, 1065, 3, 72, 36, 0, 981, 1065, 3, 112, 56, 0, 982, 1065, 3, 502, 251, 0, 983, 1065, 3, 324, 162, 0, 984, 1065, 3, 70, 35, 0, 985, 1065, 3, 114, 57, 0, 986, 1065, 3, 254, 127, 0, 987, 1065, 3, 186, 93, 0, 988, 1065, 3, 280, 140, 0, 989, 1065, 3, 420, 210, 0, 990, 1065, 3, 500, 250, 0, 991, 1065, 3, 492, 246, 0, 992, 1065, 3, 208, 104, 0, 993, 1065, 3, 214, 107, 0, 994, 1065, 3, 228, 114, 0, 995, 1065, 3, 234, 117, 0, 996, 1065, 3, 364, 182, 0, 997, 1065, 3, 26, 13, 0, 998, 1065, 3, 192, 96, 0, 999, 1065, 3, 296, 148, 0, 1000, 1065, 3, 300, 150, 0, 1001, 1065, 3, 448, 224, 0, 1002, 1065, 3, 302, 151, 0, 1003, 1065, 3, 242, 121, 0, 1004, 1065, 3, 204, 102, 0, 1005, 1065, 3, 30, 15, 0, 1006, 1065, 3, 196, 98, 0, 1007, 1065, 3, 120, 60, 0, 1008, 1065, 3, 452, 226, 0, 1009, 1065, 3, 182, 91, 0, 1010, 1065, 3, 206, 103, 0, 1011, 1065, 3, 424, 212, 0, 1012, 1065, 3, 256, 128, 0, 1013, 1065, 3, 274, 137, 0, 1014, 1065, 3, 8, 4, 0, 1015, 1065, 3, 14, 7, 0, 1016, 1065, 3, 238, 119, 0, 1017, 1065, 3, 480, 240, 0, 1018, 1065, 3, 536, 268, 0, 1019, 1065, 3, 558, 279, 0, 1020, 1065, 3, 282, 141, 0, 1021, 1065, 3, 548, 274, 0, 1022, 1065, 3, 74, 37, 0, 1023, 1065, 3, 418, 209, 0, 1024, 1065, 3, 308, 154, 0, 1025, 1065, 3, 532, 266, 0, 1026, 1065, 3, 520, 260, 0, 1027, 1065, 3, 328, 164, 0, 1028, 1065, 3, 334, 167, 0, 1029, 1065, 3, 348, 174, 0, 1030, 1065, 3, 900, 450, 0, 1031, 1065, 3, 236, 118, 0, 1032, 1065, 3, 358, 179, 0, 1033, 1065, 3, 538, 269, 0, 1034, 1065, 3, 464, 232, 0, 1035, 1065, 3, 194, 97, 0, 1036, 1065, 3, 478, 239, 0, 1037, 1065, 3, 550, 275, 0, 1038, 1065, 3, 460, 230, 0, 1039, 1065, 3, 526, 263, 0, 1040, 1065, 3, 306, 153, 0, 1041, 1065, 3, 428, 214, 0, 1042, 1065, 3, 408, 204, 0, 1043, 1065, 3, 406, 203, 0, 1044, 1065, 3, 410, 205, 0, 1045, 1065, 3, 432, 216, 0, 1046, 1065, 3, 336, 168, 0, 1047, 1065, 3, 350, 175, 0, 1048, 1065, 3, 456, 228, 0, 1049, 1065, 3, 326, 163, 0, 1050, 1065, 3, 560, 280, 0, 1051, 1065, 3, 468, 234, 0, 1052, 1065, 3, 320, 160, 0, 1053, 1065, 3, 466, 233, 0, 1054, 1065, 3, 552, 276, 0, 1055, 1065, 3, 504, 252, 0, 1056, 1065, 3, 60, 30, 0, 1057, 1065, 3, 36, 18, 0, 1058, 1065, 3, 68, 34, 0, 1059, 1065, 3, 476, 238, 0, 1060, 1062, 5, 581, 0, 0, 1061, 1063, 5, 582, 0, 0, 1062, 1061, 1, 0, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1065, 1, 0, 0, 0, 1064, 944, 1, 0, 0, 0, 1064, 945, 1, 0, 0, 0, 1064, 946, 1, 0, 0, 0, 1064, 947, 1, 0, 0, 0, 1064, 948, 1, 0, 0, 0, 1064, 949, 1, 0, 0, 0, 1064, 950, 1, 0, 0, 0, 1064, 951, 1, 0, 0, 0, 1064, 952, 1, 0, 0, 0, 1064, 953, 1, 0, 0, 0, 1064, 954, 1, 0, 0, 0, 1064, 955, 1, 0, 0, 0, 1064, 956, 1, 0, 0, 0, 1064, 957, 1, 0, 0, 0, 1064, 958, 1, 0, 0, 0, 1064, 959, 1, 0, 0, 0, 1064, 960, 1, 0, 0, 0, 1064, 961, 1, 0, 0, 0, 1064, 962, 1, 0, 0, 0, 1064, 963, 1, 0, 0, 0, 1064, 964, 1, 0, 0, 0, 1064, 965, 1, 0, 0, 0, 1064, 966, 1, 0, 0, 0, 1064, 967, 1, 0, 0, 0, 1064, 968, 1, 0, 0, 0, 1064, 969, 1, 0, 0, 0, 1064, 970, 1, 0, 0, 0, 1064, 971, 1, 0, 0, 0, 1064, 972, 1, 0, 0, 0, 1064, 973, 1, 0, 0, 0, 1064, 974, 1, 0, 0, 0, 1064, 975, 1, 0, 0, 0, 1064, 976, 1, 0, 0, 0, 1064, 977, 1, 0, 0, 0, 1064, 978, 1, 0, 0, 0, 1064, 979, 1, 0, 0, 0, 1064, 980, 1, 0, 0, 0, 1064, 981, 1, 0, 0, 0, 1064, 982, 1, 0, 0, 0, 1064, 983, 1, 0, 0, 0, 1064, 984, 1, 0, 0, 0, 1064, 985, 1, 0, 0, 0, 1064, 986, 1, 0, 0, 0, 1064, 987, 1, 0, 0, 0, 1064, 988, 1, 0, 0, 0, 1064, 989, 1, 0, 0, 0, 1064, 990, 1, 0, 0, 0, 1064, 991, 1, 0, 0, 0, 1064, 992, 1, 0, 0, 0, 1064, 993, 1, 0, 0, 0, 1064, 994, 1, 0, 0, 0, 1064, 995, 1, 0, 0, 0, 1064, 996, 1, 0, 0, 0, 1064, 997, 1, 0, 0, 0, 1064, 998, 1, 0, 0, 0, 1064, 999, 1, 0, 0, 0, 1064, 1000, 1, 0, 0, 0, 1064, 1001, 1, 0, 0, 0, 1064, 1002, 1, 0, 0, 0, 1064, 1003, 1, 0, 0, 0, 1064, 1004, 1, 0, 0, 0, 1064, 1005, 1, 0, 0, 0, 1064, 1006, 1, 0, 0, 0, 1064, 1007, 1, 0, 0, 0, 1064, 1008, 1, 0, 0, 0, 1064, 1009, 1, 0, 0, 0, 1064, 1010, 1, 0, 0, 0, 1064, 1011, 1, 0, 0, 0, 1064, 1012, 1, 0, 0, 0, 1064, 1013, 1, 0, 0, 0, 1064, 1014, 1, 0, 0, 0, 1064, 1015, 1, 0, 0, 0, 1064, 1016, 1, 0, 0, 0, 1064, 1017, 1, 0, 0, 0, 1064, 1018, 1, 0, 0, 0, 1064, 1019, 1, 0, 0, 0, 1064, 1020, 1, 0, 0, 0, 1064, 1021, 1, 0, 0, 0, 1064, 1022, 1, 0, 0, 0, 1064, 1023, 1, 0, 0, 0, 1064, 1024, 1, 0, 0, 0, 1064, 1025, 1, 0, 0, 0, 1064, 1026, 1, 0, 0, 0, 1064, 1027, 1, 0, 0, 0, 1064, 1028, 1, 0, 0, 0, 1064, 1029, 1, 0, 0, 0, 1064, 1030, 1, 0, 0, 0, 1064, 1031, 1, 0, 0, 0, 1064, 1032, 1, 0, 0, 0, 1064, 1033, 1, 0, 0, 0, 1064, 1034, 1, 0, 0, 0, 1064, 1035, 1, 0, 0, 0, 1064, 1036, 1, 0, 0, 0, 1064, 1037, 1, 0, 0, 0, 1064, 1038, 1, 0, 0, 0, 1064, 1039, 1, 0, 0, 0, 1064, 1040, 1, 0, 0, 0, 1064, 1041, 1, 0, 0, 0, 1064, 1042, 1, 0, 0, 0, 1064, 1043, 1, 0, 0, 0, 1064, 1044, 1, 0, 0, 0, 1064, 1045, 1, 0, 0, 0, 1064, 1046, 1, 0, 0, 0, 1064, 1047, 1, 0, 0, 0, 1064, 1048, 1, 0, 0, 0, 1064, 1049, 1, 0, 0, 0, 1064, 1050, 1, 0, 0, 0, 1064, 1051, 1, 0, 0, 0, 1064, 1052, 1, 0, 0, 0, 1064, 1053, 1, 0, 0, 0, 1064, 1054, 1, 0, 0, 0, 1064, 1055, 1, 0, 0, 0, 1064, 1056, 1, 0, 0, 0, 1064, 1057, 1, 0, 0, 0, 1064, 1058, 1, 0, 0, 0, 1064, 1059, 1, 0, 0, 0, 1064, 1060, 1, 0, 0, 0, 1065, 5, 1, 0, 0, 0, 1066, 1067, 5, 433, 0, 0, 1067, 1068, 3, 684, 342, 0, 1068, 7, 1, 0, 0, 0, 1069, 1070, 5, 46, 0, 0, 1070, 1071, 5, 318, 0, 0, 1071, 1073, 3, 814, 407, 0, 1072, 1074, 5, 105, 0, 0, 1073, 1072, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1078, 1, 0, 0, 0, 1075, 1077, 3, 12, 6, 0, 1076, 1075, 1, 0, 0, 0, 1077, 1080, 1, 0, 0, 0, 1078, 1076, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 9, 1, 0, 0, 0, 1080, 1078, 1, 0, 0, 0, 1081, 1084, 5, 287, 0, 0, 1082, 1085, 3, 808, 404, 0, 1083, 1085, 5, 78, 0, 0, 1084, 1082, 1, 0, 0, 0, 1084, 1083, 1, 0, 0, 0, 1085, 1120, 1, 0, 0, 0, 1086, 1087, 7, 0, 0, 0, 1087, 1088, 5, 287, 0, 0, 1088, 1120, 3, 808, 404, 0, 1089, 1120, 5, 228, 0, 0, 1090, 1120, 5, 229, 0, 0, 1091, 1120, 5, 236, 0, 0, 1092, 1120, 5, 237, 0, 0, 1093, 1120, 5, 234, 0, 0, 1094, 1120, 5, 235, 0, 0, 1095, 1120, 5, 232, 0, 0, 1096, 1120, 5, 233, 0, 0, 1097, 1120, 5, 230, 0, 0, 1098, 1120, 5, 231, 0, 0, 1099, 1120, 5, 535, 0, 0, 1100, 1120, 5, 536, 0, 0, 1101, 1120, 5, 537, 0, 0, 1102, 1120, 5, 538, 0, 0, 1103, 1120, 5, 539, 0, 0, 1104, 1120, 5, 540, 0, 0, 1105, 1106, 5, 164, 0, 0, 1106, 1107, 5, 74, 0, 0, 1107, 1120, 3, 812, 406, 0, 1108, 1109, 5, 371, 0, 0, 1109, 1110, 5, 368, 0, 0, 1110, 1120, 3, 808, 404, 0, 1111, 1112, 5, 68, 0, 0, 1112, 1113, 7, 1, 0, 0, 1113, 1120, 3, 784, 392, 0, 1114, 1115, 7, 2, 0, 0, 1115, 1120, 3, 816, 408, 0, 1116, 1117, 5, 134, 0, 0, 1117, 1120, 3, 784, 392, 0, 1118, 1120, 3, 826, 413, 0, 1119, 1081, 1, 0, 0, 0, 1119, 1086, 1, 0, 0, 0, 1119, 1089, 1, 0, 0, 0, 1119, 1090, 1, 0, 0, 0, 1119, 1091, 1, 0, 0, 0, 1119, 1092, 1, 0, 0, 0, 1119, 1093, 1, 0, 0, 0, 1119, 1094, 1, 0, 0, 0, 1119, 1095, 1, 0, 0, 0, 1119, 1096, 1, 0, 0, 0, 1119, 1097, 1, 0, 0, 0, 1119, 1098, 1, 0, 0, 0, 1119, 1099, 1, 0, 0, 0, 1119, 1100, 1, 0, 0, 0, 1119, 1101, 1, 0, 0, 0, 1119, 1102, 1, 0, 0, 0, 1119, 1103, 1, 0, 0, 0, 1119, 1104, 1, 0, 0, 0, 1119, 1105, 1, 0, 0, 0, 1119, 1108, 1, 0, 0, 0, 1119, 1111, 1, 0, 0, 0, 1119, 1114, 1, 0, 0, 0, 1119, 1116, 1, 0, 0, 0, 1119, 1118, 1, 0, 0, 0, 1120, 11, 1, 0, 0, 0, 1121, 1130, 3, 10, 5, 0, 1122, 1123, 5, 348, 0, 0, 1123, 1130, 5, 571, 0, 0, 1124, 1125, 7, 3, 0, 0, 1125, 1130, 3, 816, 408, 0, 1126, 1127, 5, 68, 0, 0, 1127, 1128, 7, 1, 0, 0, 1128, 1130, 3, 816, 408, 0, 1129, 1121, 1, 0, 0, 0, 1129, 1122, 1, 0, 0, 0, 1129, 1124, 1, 0, 0, 0, 1129, 1126, 1, 0, 0, 0, 1130, 13, 1, 0, 0, 0, 1131, 1132, 5, 46, 0, 0, 1132, 1133, 5, 99, 0, 0, 1133, 1135, 3, 814, 407, 0, 1134, 1136, 5, 105, 0, 0, 1135, 1134, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1140, 1, 0, 0, 0, 1137, 1139, 3, 12, 6, 0, 1138, 1137, 1, 0, 0, 0, 1139, 1142, 1, 0, 0, 0, 1140, 1138, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 15, 1, 0, 0, 0, 1142, 1140, 1, 0, 0, 0, 1143, 1144, 5, 138, 0, 0, 1144, 1145, 7, 2, 0, 0, 1145, 1147, 3, 814, 407, 0, 1146, 1148, 5, 105, 0, 0, 1147, 1146, 1, 0, 0, 0, 1147, 1148, 1, 0, 0, 0, 1148, 1152, 1, 0, 0, 0, 1149, 1151, 3, 10, 5, 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, 17, 1, 0, 0, 0, 1154, 1152, 1, 0, 0, 0, 1155, 1156, 5, 138, 0, 0, 1156, 1159, 7, 2, 0, 0, 1157, 1160, 5, 30, 0, 0, 1158, 1160, 3, 814, 407, 0, 1159, 1157, 1, 0, 0, 0, 1159, 1158, 1, 0, 0, 0, 1160, 1161, 1, 0, 0, 0, 1161, 1162, 5, 68, 0, 0, 1162, 1163, 5, 175, 0, 0, 1163, 1164, 3, 788, 394, 0, 1164, 1165, 3, 64, 32, 0, 1165, 19, 1, 0, 0, 0, 1166, 1167, 5, 138, 0, 0, 1167, 1168, 5, 442, 0, 0, 1168, 1170, 3, 794, 397, 0, 1169, 1171, 3, 368, 184, 0, 1170, 1169, 1, 0, 0, 0, 1170, 1171, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 1173, 3, 22, 11, 0, 1173, 21, 1, 0, 0, 0, 1174, 1178, 3, 24, 12, 0, 1175, 1177, 3, 24, 12, 0, 1176, 1175, 1, 0, 0, 0, 1177, 1180, 1, 0, 0, 0, 1178, 1176, 1, 0, 0, 0, 1178, 1179, 1, 0, 0, 0, 1179, 1182, 1, 0, 0, 0, 1180, 1178, 1, 0, 0, 0, 1181, 1183, 5, 315, 0, 0, 1182, 1181, 1, 0, 0, 0, 1182, 1183, 1, 0, 0, 0, 1183, 1201, 1, 0, 0, 0, 1184, 1185, 5, 309, 0, 0, 1185, 1186, 5, 94, 0, 0, 1186, 1201, 3, 792, 396, 0, 1187, 1188, 5, 282, 0, 0, 1188, 1189, 5, 94, 0, 0, 1189, 1201, 3, 814, 407, 0, 1190, 1191, 5, 333, 0, 0, 1191, 1192, 5, 323, 0, 0, 1192, 1201, 3, 32, 16, 0, 1193, 1195, 5, 269, 0, 0, 1194, 1193, 1, 0, 0, 0, 1194, 1195, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1197, 5, 462, 0, 0, 1197, 1198, 5, 80, 0, 0, 1198, 1199, 5, 204, 0, 0, 1199, 1201, 3, 818, 409, 0, 1200, 1174, 1, 0, 0, 0, 1200, 1184, 1, 0, 0, 0, 1200, 1187, 1, 0, 0, 0, 1200, 1190, 1, 0, 0, 0, 1200, 1194, 1, 0, 0, 0, 1201, 23, 1, 0, 0, 0, 1202, 1245, 5, 222, 0, 0, 1203, 1245, 5, 338, 0, 0, 1204, 1245, 5, 377, 0, 0, 1205, 1207, 5, 77, 0, 0, 1206, 1205, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1245, 5, 250, 0, 0, 1209, 1211, 5, 205, 0, 0, 1210, 1209, 1, 0, 0, 0, 1210, 1211, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1213, 5, 327, 0, 0, 1213, 1220, 5, 243, 0, 0, 1214, 1216, 5, 205, 0, 0, 1215, 1214, 1, 0, 0, 0, 1215, 1216, 1, 0, 0, 0, 1216, 1217, 1, 0, 0, 0, 1217, 1218, 5, 327, 0, 0, 1218, 1220, 5, 181, 0, 0, 1219, 1210, 1, 0, 0, 0, 1219, 1215, 1, 0, 0, 0, 1220, 1245, 1, 0, 0, 0, 1221, 1222, 5, 460, 0, 0, 1222, 1245, 7, 4, 0, 0, 1223, 1224, 5, 170, 0, 0, 1224, 1245, 3, 824, 412, 0, 1225, 1226, 5, 320, 0, 0, 1226, 1245, 3, 818, 409, 0, 1227, 1228, 5, 333, 0, 0, 1228, 1229, 3, 818, 409, 0, 1229, 1232, 7, 5, 0, 0, 1230, 1233, 3, 818, 409, 0, 1231, 1233, 5, 53, 0, 0, 1232, 1230, 1, 0, 0, 0, 1232, 1231, 1, 0, 0, 0, 1233, 1245, 1, 0, 0, 0, 1234, 1235, 5, 333, 0, 0, 1235, 1236, 3, 818, 409, 0, 1236, 1237, 5, 64, 0, 0, 1237, 1238, 5, 434, 0, 0, 1238, 1245, 1, 0, 0, 0, 1239, 1242, 5, 313, 0, 0, 1240, 1243, 3, 818, 409, 0, 1241, 1243, 5, 30, 0, 0, 1242, 1240, 1, 0, 0, 0, 1242, 1241, 1, 0, 0, 0, 1243, 1245, 1, 0, 0, 0, 1244, 1202, 1, 0, 0, 0, 1244, 1203, 1, 0, 0, 0, 1244, 1204, 1, 0, 0, 0, 1244, 1206, 1, 0, 0, 0, 1244, 1219, 1, 0, 0, 0, 1244, 1221, 1, 0, 0, 0, 1244, 1223, 1, 0, 0, 0, 1244, 1225, 1, 0, 0, 0, 1244, 1227, 1, 0, 0, 0, 1244, 1234, 1, 0, 0, 0, 1244, 1239, 1, 0, 0, 0, 1245, 25, 1, 0, 0, 0, 1246, 1247, 5, 46, 0, 0, 1247, 1248, 5, 66, 0, 0, 1248, 1250, 3, 814, 407, 0, 1249, 1251, 5, 105, 0, 0, 1250, 1249, 1, 0, 0, 0, 1250, 1251, 1, 0, 0, 0, 1251, 1255, 1, 0, 0, 0, 1252, 1254, 3, 12, 6, 0, 1253, 1252, 1, 0, 0, 0, 1254, 1257, 1, 0, 0, 0, 1255, 1253, 1, 0, 0, 0, 1255, 1256, 1, 0, 0, 0, 1256, 27, 1, 0, 0, 0, 1257, 1255, 1, 0, 0, 0, 1258, 1259, 5, 138, 0, 0, 1259, 1260, 5, 66, 0, 0, 1260, 1261, 3, 814, 407, 0, 1261, 1262, 7, 6, 0, 0, 1262, 1263, 5, 99, 0, 0, 1263, 1264, 3, 816, 408, 0, 1264, 29, 1, 0, 0, 0, 1265, 1266, 5, 46, 0, 0, 1266, 1268, 5, 323, 0, 0, 1267, 1269, 3, 294, 147, 0, 1268, 1267, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, 1276, 1, 0, 0, 0, 1270, 1272, 3, 32, 16, 0, 1271, 1270, 1, 0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 1273, 1, 0, 0, 0, 1273, 1274, 5, 106, 0, 0, 1274, 1277, 3, 814, 407, 0, 1275, 1277, 3, 32, 16, 0, 1276, 1271, 1, 0, 0, 0, 1276, 1275, 1, 0, 0, 0, 1277, 1281, 1, 0, 0, 0, 1278, 1280, 3, 34, 17, 0, 1279, 1278, 1, 0, 0, 0, 1280, 1283, 1, 0, 0, 0, 1281, 1279, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 31, 1, 0, 0, 0, 1283, 1281, 1, 0, 0, 0, 1284, 1285, 3, 316, 158, 0, 1285, 33, 1, 0, 0, 0, 1286, 1293, 3, 120, 60, 0, 1287, 1293, 3, 358, 179, 0, 1288, 1293, 3, 196, 98, 0, 1289, 1293, 3, 256, 128, 0, 1290, 1293, 3, 334, 167, 0, 1291, 1293, 3, 476, 238, 0, 1292, 1286, 1, 0, 0, 0, 1292, 1287, 1, 0, 0, 0, 1292, 1288, 1, 0, 0, 0, 1292, 1289, 1, 0, 0, 0, 1292, 1290, 1, 0, 0, 0, 1292, 1291, 1, 0, 0, 0, 1293, 35, 1, 0, 0, 0, 1294, 1296, 5, 333, 0, 0, 1295, 1297, 7, 7, 0, 0, 1296, 1295, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 1298, 1, 0, 0, 0, 1298, 1299, 3, 38, 19, 0, 1299, 37, 1, 0, 0, 0, 1300, 1301, 5, 356, 0, 0, 1301, 1309, 3, 474, 237, 0, 1302, 1303, 5, 332, 0, 0, 1303, 1304, 5, 154, 0, 0, 1304, 1305, 5, 36, 0, 0, 1305, 1306, 5, 356, 0, 0, 1306, 1309, 3, 474, 237, 0, 1307, 1309, 3, 42, 21, 0, 1308, 1300, 1, 0, 0, 0, 1308, 1302, 1, 0, 0, 0, 1308, 1307, 1, 0, 0, 0, 1309, 39, 1, 0, 0, 0, 1310, 1313, 5, 30, 0, 0, 1311, 1313, 3, 44, 22, 0, 1312, 1310, 1, 0, 0, 0, 1312, 1311, 1, 0, 0, 0, 1313, 1315, 1, 0, 0, 0, 1314, 1316, 7, 5, 0, 0, 1315, 1314, 1, 0, 0, 0, 1315, 1316, 1, 0, 0, 0, 1316, 1319, 1, 0, 0, 0, 1317, 1320, 5, 53, 0, 0, 1318, 1320, 3, 46, 23, 0, 1319, 1317, 1, 0, 0, 0, 1319, 1318, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 41, 1, 0, 0, 0, 1321, 1322, 5, 418, 0, 0, 1322, 1323, 5, 386, 0, 0, 1323, 1350, 3, 56, 28, 0, 1324, 1325, 5, 152, 0, 0, 1325, 1350, 3, 808, 404, 0, 1326, 1327, 5, 323, 0, 0, 1327, 1350, 3, 790, 395, 0, 1328, 1331, 5, 267, 0, 0, 1329, 1332, 3, 808, 404, 0, 1330, 1332, 5, 53, 0, 0, 1331, 1329, 1, 0, 0, 0, 1331, 1330, 1, 0, 0, 0, 1331, 1332, 1, 0, 0, 0, 1332, 1350, 1, 0, 0, 0, 1333, 1334, 5, 318, 0, 0, 1334, 1350, 3, 58, 29, 0, 1335, 1336, 5, 332, 0, 0, 1336, 1337, 5, 106, 0, 0, 1337, 1350, 3, 58, 29, 0, 1338, 1339, 5, 383, 0, 0, 1339, 1340, 5, 279, 0, 0, 1340, 1350, 3, 696, 348, 0, 1341, 1342, 5, 356, 0, 0, 1342, 1343, 5, 337, 0, 0, 1343, 1350, 3, 808, 404, 0, 1344, 1345, 3, 44, 22, 0, 1345, 1346, 5, 64, 0, 0, 1346, 1347, 5, 434, 0, 0, 1347, 1350, 1, 0, 0, 0, 1348, 1350, 3, 40, 20, 0, 1349, 1321, 1, 0, 0, 0, 1349, 1324, 1, 0, 0, 0, 1349, 1326, 1, 0, 0, 0, 1349, 1328, 1, 0, 0, 0, 1349, 1333, 1, 0, 0, 0, 1349, 1335, 1, 0, 0, 0, 1349, 1338, 1, 0, 0, 0, 1349, 1341, 1, 0, 0, 0, 1349, 1344, 1, 0, 0, 0, 1349, 1348, 1, 0, 0, 0, 1350, 43, 1, 0, 0, 0, 1351, 1356, 3, 818, 409, 0, 1352, 1353, 5, 11, 0, 0, 1353, 1355, 3, 818, 409, 0, 1354, 1352, 1, 0, 0, 0, 1355, 1358, 1, 0, 0, 0, 1356, 1354, 1, 0, 0, 0, 1356, 1357, 1, 0, 0, 0, 1357, 45, 1, 0, 0, 0, 1358, 1356, 1, 0, 0, 0, 1359, 1364, 3, 48, 24, 0, 1360, 1361, 5, 6, 0, 0, 1361, 1363, 3, 48, 24, 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, 47, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1367, 1370, 3, 54, 27, 0, 1368, 1370, 3, 202, 101, 0, 1369, 1367, 1, 0, 0, 0, 1369, 1368, 1, 0, 0, 0, 1370, 49, 1, 0, 0, 0, 1371, 1372, 5, 300, 0, 0, 1372, 1377, 7, 8, 0, 0, 1373, 1374, 5, 310, 0, 0, 1374, 1377, 5, 300, 0, 0, 1375, 1377, 5, 330, 0, 0, 1376, 1371, 1, 0, 0, 0, 1376, 1373, 1, 0, 0, 0, 1376, 1375, 1, 0, 0, 0, 1377, 51, 1, 0, 0, 0, 1378, 1385, 5, 96, 0, 0, 1379, 1385, 5, 60, 0, 0, 1380, 1385, 5, 80, 0, 0, 1381, 1385, 3, 800, 400, 0, 1382, 1385, 3, 832, 416, 0, 1383, 1385, 3, 808, 404, 0, 1384, 1378, 1, 0, 0, 0, 1384, 1379, 1, 0, 0, 0, 1384, 1380, 1, 0, 0, 0, 1384, 1381, 1, 0, 0, 0, 1384, 1382, 1, 0, 0, 0, 1384, 1383, 1, 0, 0, 0, 1385, 53, 1, 0, 0, 0, 1386, 1391, 5, 96, 0, 0, 1387, 1391, 5, 60, 0, 0, 1388, 1391, 5, 80, 0, 0, 1389, 1391, 3, 58, 29, 0, 1390, 1386, 1, 0, 0, 0, 1390, 1387, 1, 0, 0, 0, 1390, 1388, 1, 0, 0, 0, 1390, 1389, 1, 0, 0, 0, 1391, 55, 1, 0, 0, 0, 1392, 1407, 3, 808, 404, 0, 1393, 1407, 5, 53, 0, 0, 1394, 1407, 3, 826, 413, 0, 1395, 1396, 5, 403, 0, 0, 1396, 1398, 3, 808, 404, 0, 1397, 1399, 3, 668, 334, 0, 1398, 1397, 1, 0, 0, 0, 1398, 1399, 1, 0, 0, 0, 1399, 1407, 1, 0, 0, 0, 1400, 1401, 5, 403, 0, 0, 1401, 1402, 3, 660, 330, 0, 1402, 1403, 3, 808, 404, 0, 1403, 1407, 1, 0, 0, 0, 1404, 1407, 3, 202, 101, 0, 1405, 1407, 5, 254, 0, 0, 1406, 1392, 1, 0, 0, 0, 1406, 1393, 1, 0, 0, 0, 1406, 1394, 1, 0, 0, 0, 1406, 1395, 1, 0, 0, 0, 1406, 1400, 1, 0, 0, 0, 1406, 1404, 1, 0, 0, 0, 1406, 1405, 1, 0, 0, 0, 1407, 57, 1, 0, 0, 0, 1408, 1411, 3, 822, 411, 0, 1409, 1411, 3, 808, 404, 0, 1410, 1408, 1, 0, 0, 0, 1410, 1409, 1, 0, 0, 0, 1411, 59, 1, 0, 0, 0, 1412, 1413, 5, 313, 0, 0, 1413, 1414, 3, 62, 31, 0, 1414, 61, 1, 0, 0, 0, 1415, 1416, 5, 418, 0, 0, 1416, 1425, 5, 386, 0, 0, 1417, 1418, 5, 356, 0, 0, 1418, 1419, 5, 244, 0, 0, 1419, 1425, 5, 251, 0, 0, 1420, 1421, 5, 332, 0, 0, 1421, 1425, 5, 106, 0, 0, 1422, 1425, 5, 30, 0, 0, 1423, 1425, 3, 44, 22, 0, 1424, 1415, 1, 0, 0, 0, 1424, 1417, 1, 0, 0, 0, 1424, 1420, 1, 0, 0, 0, 1424, 1422, 1, 0, 0, 0, 1424, 1423, 1, 0, 0, 0, 1425, 63, 1, 0, 0, 0, 1426, 1427, 5, 333, 0, 0, 1427, 1430, 3, 38, 19, 0, 1428, 1430, 3, 60, 30, 0, 1429, 1426, 1, 0, 0, 0, 1429, 1428, 1, 0, 0, 0, 1430, 65, 1, 0, 0, 0, 1431, 1432, 5, 333, 0, 0, 1432, 1435, 3, 42, 21, 0, 1433, 1435, 3, 60, 30, 0, 1434, 1431, 1, 0, 0, 0, 1434, 1433, 1, 0, 0, 0, 1435, 67, 1, 0, 0, 0, 1436, 1446, 5, 335, 0, 0, 1437, 1447, 3, 44, 22, 0, 1438, 1439, 5, 418, 0, 0, 1439, 1447, 5, 386, 0, 0, 1440, 1441, 5, 356, 0, 0, 1441, 1442, 5, 244, 0, 0, 1442, 1447, 5, 251, 0, 0, 1443, 1444, 5, 332, 0, 0, 1444, 1447, 5, 106, 0, 0, 1445, 1447, 5, 30, 0, 0, 1446, 1437, 1, 0, 0, 0, 1446, 1438, 1, 0, 0, 0, 1446, 1440, 1, 0, 0, 0, 1446, 1443, 1, 0, 0, 0, 1446, 1445, 1, 0, 0, 0, 1447, 69, 1, 0, 0, 0, 1448, 1449, 5, 333, 0, 0, 1449, 1452, 5, 165, 0, 0, 1450, 1453, 5, 30, 0, 0, 1451, 1453, 3, 760, 380, 0, 1452, 1450, 1, 0, 0, 0, 1452, 1451, 1, 0, 0, 0, 1453, 1454, 1, 0, 0, 0, 1454, 1455, 7, 9, 0, 0, 1455, 71, 1, 0, 0, 0, 1456, 1457, 5, 155, 0, 0, 1457, 73, 1, 0, 0, 0, 1458, 1459, 5, 187, 0, 0, 1459, 1460, 7, 10, 0, 0, 1460, 75, 1, 0, 0, 0, 1461, 1462, 5, 138, 0, 0, 1462, 1464, 5, 92, 0, 0, 1463, 1465, 3, 422, 211, 0, 1464, 1463, 1, 0, 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1469, 3, 624, 312, 0, 1467, 1470, 3, 78, 39, 0, 1468, 1470, 3, 88, 44, 0, 1469, 1467, 1, 0, 0, 0, 1469, 1468, 1, 0, 0, 0, 1470, 1583, 1, 0, 0, 0, 1471, 1472, 5, 138, 0, 0, 1472, 1473, 5, 92, 0, 0, 1473, 1474, 5, 30, 0, 0, 1474, 1475, 5, 68, 0, 0, 1475, 1479, 3, 176, 88, 0, 1476, 1477, 5, 281, 0, 0, 1477, 1478, 5, 147, 0, 0, 1478, 1480, 3, 816, 408, 0, 1479, 1476, 1, 0, 0, 0, 1479, 1480, 1, 0, 0, 0, 1480, 1481, 1, 0, 0, 0, 1481, 1482, 5, 333, 0, 0, 1482, 1483, 5, 351, 0, 0, 1483, 1485, 3, 768, 384, 0, 1484, 1486, 5, 272, 0, 0, 1485, 1484, 1, 0, 0, 0, 1485, 1486, 1, 0, 0, 0, 1486, 1583, 1, 0, 0, 0, 1487, 1488, 5, 138, 0, 0, 1488, 1490, 5, 92, 0, 0, 1489, 1491, 3, 422, 211, 0, 1490, 1489, 1, 0, 0, 0, 1490, 1491, 1, 0, 0, 0, 1491, 1492, 1, 0, 0, 0, 1492, 1493, 3, 774, 387, 0, 1493, 1498, 3, 90, 45, 0, 1494, 1495, 5, 62, 0, 0, 1495, 1496, 5, 422, 0, 0, 1496, 1499, 3, 80, 40, 0, 1497, 1499, 5, 53, 0, 0, 1498, 1494, 1, 0, 0, 0, 1498, 1497, 1, 0, 0, 0, 1499, 1583, 1, 0, 0, 0, 1500, 1501, 5, 138, 0, 0, 1501, 1503, 5, 92, 0, 0, 1502, 1504, 3, 422, 211, 0, 1503, 1502, 1, 0, 0, 0, 1503, 1504, 1, 0, 0, 0, 1504, 1505, 1, 0, 0, 0, 1505, 1506, 3, 774, 387, 0, 1506, 1507, 5, 436, 0, 0, 1507, 1508, 5, 285, 0, 0, 1508, 1510, 3, 780, 390, 0, 1509, 1511, 7, 11, 0, 0, 1510, 1509, 1, 0, 0, 0, 1510, 1511, 1, 0, 0, 0, 1511, 1583, 1, 0, 0, 0, 1512, 1513, 5, 138, 0, 0, 1513, 1515, 5, 226, 0, 0, 1514, 1516, 3, 422, 211, 0, 1515, 1514, 1, 0, 0, 0, 1515, 1516, 1, 0, 0, 0, 1516, 1517, 1, 0, 0, 0, 1517, 1520, 3, 780, 390, 0, 1518, 1521, 3, 78, 39, 0, 1519, 1521, 3, 90, 45, 0, 1520, 1518, 1, 0, 0, 0, 1520, 1519, 1, 0, 0, 0, 1521, 1583, 1, 0, 0, 0, 1522, 1523, 5, 138, 0, 0, 1523, 1524, 5, 226, 0, 0, 1524, 1525, 5, 30, 0, 0, 1525, 1526, 5, 68, 0, 0, 1526, 1530, 3, 176, 88, 0, 1527, 1528, 5, 281, 0, 0, 1528, 1529, 5, 147, 0, 0, 1529, 1531, 3, 816, 408, 0, 1530, 1527, 1, 0, 0, 0, 1530, 1531, 1, 0, 0, 0, 1531, 1532, 1, 0, 0, 0, 1532, 1533, 5, 333, 0, 0, 1533, 1535, 3, 176, 88, 0, 1534, 1536, 5, 272, 0, 0, 1535, 1534, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, 1583, 1, 0, 0, 0, 1537, 1538, 5, 138, 0, 0, 1538, 1540, 5, 328, 0, 0, 1539, 1541, 3, 422, 211, 0, 1540, 1539, 1, 0, 0, 0, 1540, 1541, 1, 0, 0, 0, 1541, 1542, 1, 0, 0, 0, 1542, 1543, 3, 780, 390, 0, 1543, 1544, 3, 78, 39, 0, 1544, 1583, 1, 0, 0, 0, 1545, 1547, 5, 138, 0, 0, 1546, 1548, 5, 259, 0, 0, 1547, 1546, 1, 0, 0, 0, 1547, 1548, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1551, 5, 376, 0, 0, 1550, 1552, 3, 422, 211, 0, 1551, 1550, 1, 0, 0, 0, 1551, 1552, 1, 0, 0, 0, 1552, 1553, 1, 0, 0, 0, 1553, 1554, 3, 778, 389, 0, 1554, 1555, 3, 78, 39, 0, 1555, 1583, 1, 0, 0, 0, 1556, 1557, 5, 138, 0, 0, 1557, 1558, 5, 259, 0, 0, 1558, 1559, 5, 376, 0, 0, 1559, 1560, 5, 30, 0, 0, 1560, 1561, 5, 68, 0, 0, 1561, 1565, 3, 176, 88, 0, 1562, 1563, 5, 281, 0, 0, 1563, 1564, 5, 147, 0, 0, 1564, 1566, 3, 816, 408, 0, 1565, 1562, 1, 0, 0, 0, 1565, 1566, 1, 0, 0, 0, 1566, 1567, 1, 0, 0, 0, 1567, 1568, 5, 333, 0, 0, 1568, 1569, 5, 351, 0, 0, 1569, 1571, 3, 768, 384, 0, 1570, 1572, 5, 272, 0, 0, 1571, 1570, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 1583, 1, 0, 0, 0, 1573, 1574, 5, 138, 0, 0, 1574, 1575, 5, 63, 0, 0, 1575, 1577, 5, 92, 0, 0, 1576, 1578, 3, 422, 211, 0, 1577, 1576, 1, 0, 0, 0, 1577, 1578, 1, 0, 0, 0, 1578, 1579, 1, 0, 0, 0, 1579, 1580, 3, 624, 312, 0, 1580, 1581, 3, 78, 39, 0, 1581, 1583, 1, 0, 0, 0, 1582, 1461, 1, 0, 0, 0, 1582, 1471, 1, 0, 0, 0, 1582, 1487, 1, 0, 0, 0, 1582, 1500, 1, 0, 0, 0, 1582, 1512, 1, 0, 0, 0, 1582, 1522, 1, 0, 0, 0, 1582, 1537, 1, 0, 0, 0, 1582, 1545, 1, 0, 0, 0, 1582, 1556, 1, 0, 0, 0, 1582, 1573, 1, 0, 0, 0, 1583, 77, 1, 0, 0, 0, 1584, 1589, 3, 92, 46, 0, 1585, 1586, 5, 6, 0, 0, 1586, 1588, 3, 92, 46, 0, 1587, 1585, 1, 0, 0, 0, 1588, 1591, 1, 0, 0, 0, 1589, 1587, 1, 0, 0, 0, 1589, 1590, 1, 0, 0, 0, 1590, 79, 1, 0, 0, 0, 1591, 1589, 1, 0, 0, 0, 1592, 1593, 5, 68, 0, 0, 1593, 1602, 3, 534, 267, 0, 1594, 1595, 5, 64, 0, 0, 1595, 1596, 3, 82, 41, 0, 1596, 1597, 5, 94, 0, 0, 1597, 1598, 3, 82, 41, 0, 1598, 1602, 1, 0, 0, 0, 1599, 1600, 5, 105, 0, 0, 1600, 1602, 3, 86, 43, 0, 1601, 1592, 1, 0, 0, 0, 1601, 1594, 1, 0, 0, 0, 1601, 1599, 1, 0, 0, 0, 1602, 81, 1, 0, 0, 0, 1603, 1604, 5, 2, 0, 0, 1604, 1609, 3, 84, 42, 0, 1605, 1606, 5, 6, 0, 0, 1606, 1608, 3, 84, 42, 0, 1607, 1605, 1, 0, 0, 0, 1608, 1611, 1, 0, 0, 0, 1609, 1607, 1, 0, 0, 0, 1609, 1610, 1, 0, 0, 0, 1610, 1612, 1, 0, 0, 0, 1611, 1609, 1, 0, 0, 0, 1612, 1613, 5, 3, 0, 0, 1613, 83, 1, 0, 0, 0, 1614, 1618, 3, 534, 267, 0, 1615, 1618, 5, 262, 0, 0, 1616, 1618, 5, 260, 0, 0, 1617, 1614, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1616, 1, 0, 0, 0, 1618, 85, 1, 0, 0, 0, 1619, 1620, 5, 2, 0, 0, 1620, 1621, 5, 533, 0, 0, 1621, 1622, 3, 202, 101, 0, 1622, 1623, 5, 6, 0, 0, 1623, 1624, 5, 534, 0, 0, 1624, 1625, 3, 202, 101, 0, 1625, 1626, 5, 3, 0, 0, 1626, 87, 1, 0, 0, 0, 1627, 1628, 3, 90, 45, 0, 1628, 1629, 3, 106, 53, 0, 1629, 1634, 1, 0, 0, 0, 1630, 1631, 5, 436, 0, 0, 1631, 1632, 5, 285, 0, 0, 1632, 1634, 3, 780, 390, 0, 1633, 1627, 1, 0, 0, 0, 1633, 1630, 1, 0, 0, 0, 1634, 89, 1, 0, 0, 0, 1635, 1636, 5, 435, 0, 0, 1636, 1637, 5, 285, 0, 0, 1637, 1638, 3, 780, 390, 0, 1638, 91, 1, 0, 0, 0, 1639, 1642, 5, 133, 0, 0, 1640, 1641, 5, 45, 0, 0, 1641, 1643, 3, 818, 409, 0, 1642, 1640, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1873, 3, 142, 71, 0, 1645, 1646, 5, 138, 0, 0, 1646, 1647, 5, 45, 0, 0, 1647, 1651, 3, 818, 409, 0, 1648, 1650, 3, 272, 136, 0, 1649, 1648, 1, 0, 0, 0, 1650, 1653, 1, 0, 0, 0, 1651, 1649, 1, 0, 0, 0, 1651, 1652, 1, 0, 0, 0, 1652, 1873, 1, 0, 0, 0, 1653, 1651, 1, 0, 0, 0, 1654, 1655, 5, 372, 0, 0, 1655, 1656, 5, 45, 0, 0, 1656, 1873, 3, 818, 409, 0, 1657, 1658, 5, 191, 0, 0, 1658, 1660, 5, 45, 0, 0, 1659, 1661, 3, 422, 211, 0, 1660, 1659, 1, 0, 0, 0, 1660, 1661, 1, 0, 0, 0, 1661, 1662, 1, 0, 0, 0, 1662, 1664, 3, 818, 409, 0, 1663, 1665, 3, 96, 48, 0, 1664, 1663, 1, 0, 0, 0, 1664, 1665, 1, 0, 0, 0, 1665, 1873, 1, 0, 0, 0, 1666, 1667, 5, 333, 0, 0, 1667, 1668, 5, 379, 0, 0, 1668, 1873, 7, 12, 0, 0, 1669, 1670, 5, 158, 0, 0, 1670, 1671, 5, 80, 0, 0, 1671, 1873, 3, 818, 409, 0, 1672, 1673, 5, 333, 0, 0, 1673, 1873, 7, 13, 0, 0, 1674, 1676, 5, 193, 0, 0, 1675, 1677, 7, 14, 0, 0, 1676, 1675, 1, 0, 0, 0, 1676, 1677, 1, 0, 0, 0, 1677, 1678, 1, 0, 0, 0, 1678, 1873, 5, 357, 0, 0, 1679, 1680, 5, 186, 0, 0, 1680, 1684, 5, 357, 0, 0, 1681, 1685, 5, 30, 0, 0, 1682, 1685, 5, 99, 0, 0, 1683, 1685, 3, 818, 409, 0, 1684, 1681, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 1873, 1, 0, 0, 0, 1686, 1687, 5, 193, 0, 0, 1687, 1688, 7, 14, 0, 0, 1688, 1689, 5, 321, 0, 0, 1689, 1873, 3, 818, 409, 0, 1690, 1691, 5, 186, 0, 0, 1691, 1692, 5, 321, 0, 0, 1692, 1873, 3, 818, 409, 0, 1693, 1695, 5, 269, 0, 0, 1694, 1693, 1, 0, 0, 0, 1694, 1695, 1, 0, 0, 0, 1695, 1696, 1, 0, 0, 0, 1696, 1697, 5, 228, 0, 0, 1697, 1873, 3, 780, 390, 0, 1698, 1699, 5, 275, 0, 0, 1699, 1873, 3, 316, 158, 0, 1700, 1701, 5, 77, 0, 0, 1701, 1873, 5, 275, 0, 0, 1702, 1703, 5, 282, 0, 0, 1703, 1704, 5, 94, 0, 0, 1704, 1873, 3, 814, 407, 0, 1705, 1706, 5, 333, 0, 0, 1706, 1707, 5, 351, 0, 0, 1707, 1873, 3, 768, 384, 0, 1708, 1709, 5, 312, 0, 0, 1709, 1714, 5, 219, 0, 0, 1710, 1715, 5, 270, 0, 0, 1711, 1715, 5, 113, 0, 0, 1712, 1715, 5, 53, 0, 0, 1713, 1715, 3, 180, 90, 0, 1714, 1710, 1, 0, 0, 0, 1714, 1711, 1, 0, 0, 0, 1714, 1712, 1, 0, 0, 0, 1714, 1713, 1, 0, 0, 0, 1715, 1873, 1, 0, 0, 0, 1716, 1723, 5, 193, 0, 0, 1717, 1723, 5, 186, 0, 0, 1718, 1720, 5, 269, 0, 0, 1719, 1718, 1, 0, 0, 0, 1719, 1720, 1, 0, 0, 0, 1720, 1721, 1, 0, 0, 0, 1721, 1723, 5, 209, 0, 0, 1722, 1716, 1, 0, 0, 0, 1722, 1717, 1, 0, 0, 0, 1722, 1719, 1, 0, 0, 0, 1723, 1724, 1, 0, 0, 0, 1724, 1725, 5, 414, 0, 0, 1725, 1726, 5, 251, 0, 0, 1726, 1873, 5, 327, 0, 0, 1727, 1729, 5, 191, 0, 0, 1728, 1730, 5, 44, 0, 0, 1729, 1728, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, 1732, 1, 0, 0, 0, 1731, 1733, 3, 422, 211, 0, 1732, 1731, 1, 0, 0, 0, 1732, 1733, 1, 0, 0, 0, 1733, 1734, 1, 0, 0, 0, 1734, 1736, 3, 800, 400, 0, 1735, 1737, 3, 96, 48, 0, 1736, 1735, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, 1873, 1, 0, 0, 0, 1738, 1740, 5, 133, 0, 0, 1739, 1741, 5, 44, 0, 0, 1740, 1739, 1, 0, 0, 0, 1740, 1741, 1, 0, 0, 0, 1741, 1743, 1, 0, 0, 0, 1742, 1744, 3, 294, 147, 0, 1743, 1742, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1745, 1, 0, 0, 0, 1745, 1873, 3, 132, 66, 0, 1746, 1748, 5, 138, 0, 0, 1747, 1749, 5, 44, 0, 0, 1748, 1747, 1, 0, 0, 0, 1748, 1749, 1, 0, 0, 0, 1749, 1750, 1, 0, 0, 0, 1750, 1753, 3, 800, 400, 0, 1751, 1754, 3, 94, 47, 0, 1752, 1754, 3, 222, 111, 0, 1753, 1751, 1, 0, 0, 0, 1753, 1752, 1, 0, 0, 0, 1754, 1873, 1, 0, 0, 0, 1755, 1757, 5, 138, 0, 0, 1756, 1758, 5, 44, 0, 0, 1757, 1756, 1, 0, 0, 0, 1757, 1758, 1, 0, 0, 0, 1758, 1759, 1, 0, 0, 0, 1759, 1760, 3, 800, 400, 0, 1760, 1761, 7, 15, 0, 0, 1761, 1762, 5, 77, 0, 0, 1762, 1763, 5, 78, 0, 0, 1763, 1873, 1, 0, 0, 0, 1764, 1766, 5, 138, 0, 0, 1765, 1767, 5, 44, 0, 0, 1766, 1765, 1, 0, 0, 0, 1766, 1767, 1, 0, 0, 0, 1767, 1768, 1, 0, 0, 0, 1768, 1769, 3, 800, 400, 0, 1769, 1770, 5, 191, 0, 0, 1770, 1772, 5, 437, 0, 0, 1771, 1773, 3, 422, 211, 0, 1772, 1771, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1873, 1, 0, 0, 0, 1774, 1776, 5, 138, 0, 0, 1775, 1777, 5, 44, 0, 0, 1776, 1775, 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1778, 1, 0, 0, 0, 1778, 1779, 3, 800, 400, 0, 1779, 1780, 5, 333, 0, 0, 1780, 1781, 5, 342, 0, 0, 1781, 1782, 3, 812, 406, 0, 1782, 1873, 1, 0, 0, 0, 1783, 1785, 5, 138, 0, 0, 1784, 1786, 5, 44, 0, 0, 1785, 1784, 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 1789, 3, 800, 400, 0, 1788, 1783, 1, 0, 0, 0, 1788, 1789, 1, 0, 0, 0, 1789, 1790, 1, 0, 0, 0, 1790, 1791, 7, 16, 0, 0, 1791, 1873, 3, 100, 50, 0, 1792, 1794, 5, 138, 0, 0, 1793, 1795, 5, 44, 0, 0, 1794, 1793, 1, 0, 0, 0, 1794, 1795, 1, 0, 0, 0, 1795, 1796, 1, 0, 0, 0, 1796, 1797, 3, 800, 400, 0, 1797, 1798, 5, 333, 0, 0, 1798, 1799, 5, 345, 0, 0, 1799, 1800, 3, 818, 409, 0, 1800, 1873, 1, 0, 0, 0, 1801, 1803, 5, 138, 0, 0, 1802, 1804, 5, 44, 0, 0, 1803, 1802, 1, 0, 0, 0, 1803, 1804, 1, 0, 0, 0, 1804, 1805, 1, 0, 0, 0, 1805, 1806, 3, 800, 400, 0, 1806, 1807, 5, 133, 0, 0, 1807, 1808, 5, 438, 0, 0, 1808, 1809, 3, 138, 69, 0, 1809, 1810, 5, 36, 0, 0, 1810, 1819, 5, 219, 0, 0, 1811, 1813, 5, 2, 0, 0, 1812, 1814, 3, 200, 100, 0, 1813, 1812, 1, 0, 0, 0, 1814, 1815, 1, 0, 0, 0, 1815, 1813, 1, 0, 0, 0, 1815, 1816, 1, 0, 0, 0, 1816, 1817, 1, 0, 0, 0, 1817, 1818, 5, 3, 0, 0, 1818, 1820, 1, 0, 0, 0, 1819, 1811, 1, 0, 0, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1873, 1, 0, 0, 0, 1821, 1823, 5, 138, 0, 0, 1822, 1824, 5, 44, 0, 0, 1823, 1822, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1825, 1, 0, 0, 0, 1825, 1839, 3, 800, 400, 0, 1826, 1831, 5, 314, 0, 0, 1827, 1829, 5, 105, 0, 0, 1828, 1827, 1, 0, 0, 0, 1828, 1829, 1, 0, 0, 0, 1829, 1830, 1, 0, 0, 0, 1830, 1832, 3, 202, 101, 0, 1831, 1828, 1, 0, 0, 0, 1831, 1832, 1, 0, 0, 0, 1832, 1840, 1, 0, 0, 0, 1833, 1837, 5, 333, 0, 0, 1834, 1838, 3, 200, 100, 0, 1835, 1836, 5, 438, 0, 0, 1836, 1838, 3, 138, 69, 0, 1837, 1834, 1, 0, 0, 0, 1837, 1835, 1, 0, 0, 0, 1838, 1840, 1, 0, 0, 0, 1839, 1826, 1, 0, 0, 0, 1839, 1833, 1, 0, 0, 0, 1840, 1841, 1, 0, 0, 0, 1841, 1839, 1, 0, 0, 0, 1841, 1842, 1, 0, 0, 0, 1842, 1873, 1, 0, 0, 0, 1843, 1845, 5, 138, 0, 0, 1844, 1846, 5, 44, 0, 0, 1845, 1844, 1, 0, 0, 0, 1845, 1846, 1, 0, 0, 0, 1846, 1847, 1, 0, 0, 0, 1847, 1848, 3, 800, 400, 0, 1848, 1849, 5, 191, 0, 0, 1849, 1851, 5, 219, 0, 0, 1850, 1852, 3, 422, 211, 0, 1851, 1850, 1, 0, 0, 0, 1851, 1852, 1, 0, 0, 0, 1852, 1873, 1, 0, 0, 0, 1853, 1855, 5, 138, 0, 0, 1854, 1856, 5, 44, 0, 0, 1855, 1854, 1, 0, 0, 0, 1855, 1856, 1, 0, 0, 0, 1856, 1857, 1, 0, 0, 0, 1857, 1860, 3, 800, 400, 0, 1858, 1859, 5, 333, 0, 0, 1859, 1861, 5, 174, 0, 0, 1860, 1858, 1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1862, 1, 0, 0, 0, 1862, 1863, 5, 360, 0, 0, 1863, 1865, 3, 652, 326, 0, 1864, 1866, 3, 98, 49, 0, 1865, 1864, 1, 0, 0, 0, 1865, 1866, 1, 0, 0, 0, 1866, 1869, 1, 0, 0, 0, 1867, 1868, 5, 100, 0, 0, 1868, 1870, 3, 674, 337, 0, 1869, 1867, 1, 0, 0, 0, 1869, 1870, 1, 0, 0, 0, 1870, 1873, 1, 0, 0, 0, 1871, 1873, 3, 222, 111, 0, 1872, 1639, 1, 0, 0, 0, 1872, 1645, 1, 0, 0, 0, 1872, 1654, 1, 0, 0, 0, 1872, 1657, 1, 0, 0, 0, 1872, 1666, 1, 0, 0, 0, 1872, 1669, 1, 0, 0, 0, 1872, 1672, 1, 0, 0, 0, 1872, 1674, 1, 0, 0, 0, 1872, 1679, 1, 0, 0, 0, 1872, 1686, 1, 0, 0, 0, 1872, 1690, 1, 0, 0, 0, 1872, 1694, 1, 0, 0, 0, 1872, 1698, 1, 0, 0, 0, 1872, 1700, 1, 0, 0, 0, 1872, 1702, 1, 0, 0, 0, 1872, 1705, 1, 0, 0, 0, 1872, 1708, 1, 0, 0, 0, 1872, 1722, 1, 0, 0, 0, 1872, 1727, 1, 0, 0, 0, 1872, 1738, 1, 0, 0, 0, 1872, 1746, 1, 0, 0, 0, 1872, 1755, 1, 0, 0, 0, 1872, 1764, 1, 0, 0, 0, 1872, 1774, 1, 0, 0, 0, 1872, 1788, 1, 0, 0, 0, 1872, 1792, 1, 0, 0, 0, 1872, 1801, 1, 0, 0, 0, 1872, 1821, 1, 0, 0, 0, 1872, 1843, 1, 0, 0, 0, 1872, 1853, 1, 0, 0, 0, 1872, 1871, 1, 0, 0, 0, 1873, 93, 1, 0, 0, 0, 1874, 1875, 5, 333, 0, 0, 1875, 1876, 5, 53, 0, 0, 1876, 1880, 3, 674, 337, 0, 1877, 1878, 5, 191, 0, 0, 1878, 1880, 5, 53, 0, 0, 1879, 1874, 1, 0, 0, 0, 1879, 1877, 1, 0, 0, 0, 1880, 95, 1, 0, 0, 0, 1881, 1882, 7, 17, 0, 0, 1882, 97, 1, 0, 0, 0, 1883, 1884, 5, 43, 0, 0, 1884, 1885, 3, 316, 158, 0, 1885, 99, 1, 0, 0, 0, 1886, 1887, 5, 2, 0, 0, 1887, 1892, 3, 104, 52, 0, 1888, 1889, 5, 6, 0, 0, 1889, 1891, 3, 104, 52, 0, 1890, 1888, 1, 0, 0, 0, 1891, 1894, 1, 0, 0, 0, 1892, 1890, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1895, 1, 0, 0, 0, 1894, 1892, 1, 0, 0, 0, 1895, 1896, 5, 3, 0, 0, 1896, 101, 1, 0, 0, 0, 1897, 1898, 5, 105, 0, 0, 1898, 1899, 3, 100, 50, 0, 1899, 103, 1, 0, 0, 0, 1900, 1905, 3, 824, 412, 0, 1901, 1902, 5, 10, 0, 0, 1902, 1906, 3, 288, 144, 0, 1903, 1904, 5, 11, 0, 0, 1904, 1906, 3, 286, 143, 0, 1905, 1901, 1, 0, 0, 0, 1905, 1903, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 105, 1, 0, 0, 0, 1907, 1908, 5, 62, 0, 0, 1908, 1909, 5, 422, 0, 0, 1909, 1910, 5, 105, 0, 0, 1910, 1911, 5, 2, 0, 0, 1911, 1912, 3, 822, 411, 0, 1912, 1919, 5, 571, 0, 0, 1913, 1914, 5, 6, 0, 0, 1914, 1915, 3, 822, 411, 0, 1915, 1916, 5, 571, 0, 0, 1916, 1918, 1, 0, 0, 0, 1917, 1913, 1, 0, 0, 0, 1918, 1921, 1, 0, 0, 0, 1919, 1917, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1922, 1, 0, 0, 0, 1921, 1919, 1, 0, 0, 0, 1922, 1923, 5, 3, 0, 0, 1923, 1937, 1, 0, 0, 0, 1924, 1925, 5, 62, 0, 0, 1925, 1926, 5, 422, 0, 0, 1926, 1927, 5, 68, 0, 0, 1927, 1937, 3, 534, 267, 0, 1928, 1929, 5, 62, 0, 0, 1929, 1930, 5, 422, 0, 0, 1930, 1931, 5, 64, 0, 0, 1931, 1932, 3, 534, 267, 0, 1932, 1933, 5, 94, 0, 0, 1933, 1934, 3, 534, 267, 0, 1934, 1937, 1, 0, 0, 0, 1935, 1937, 5, 53, 0, 0, 1936, 1907, 1, 0, 0, 0, 1936, 1924, 1, 0, 0, 0, 1936, 1928, 1, 0, 0, 0, 1936, 1935, 1, 0, 0, 0, 1937, 107, 1, 0, 0, 0, 1938, 1939, 5, 138, 0, 0, 1939, 1940, 5, 360, 0, 0, 1940, 1941, 3, 316, 158, 0, 1941, 1946, 3, 110, 55, 0, 1942, 1943, 5, 6, 0, 0, 1943, 1945, 3, 110, 55, 0, 1944, 1942, 1, 0, 0, 0, 1945, 1948, 1, 0, 0, 0, 1946, 1944, 1, 0, 0, 0, 1946, 1947, 1, 0, 0, 0, 1947, 109, 1, 0, 0, 0, 1948, 1946, 1, 0, 0, 0, 1949, 1950, 5, 133, 0, 0, 1950, 1951, 5, 143, 0, 0, 1951, 1953, 3, 644, 322, 0, 1952, 1954, 3, 96, 48, 0, 1953, 1952, 1, 0, 0, 0, 1953, 1954, 1, 0, 0, 0, 1954, 1980, 1, 0, 0, 0, 1955, 1956, 5, 191, 0, 0, 1956, 1958, 5, 143, 0, 0, 1957, 1959, 3, 422, 211, 0, 1958, 1957, 1, 0, 0, 0, 1958, 1959, 1, 0, 0, 0, 1959, 1960, 1, 0, 0, 0, 1960, 1962, 3, 818, 409, 0, 1961, 1963, 3, 96, 48, 0, 1962, 1961, 1, 0, 0, 0, 1962, 1963, 1, 0, 0, 0, 1963, 1980, 1, 0, 0, 0, 1964, 1965, 5, 138, 0, 0, 1965, 1966, 5, 143, 0, 0, 1966, 1969, 3, 818, 409, 0, 1967, 1968, 5, 333, 0, 0, 1968, 1970, 5, 174, 0, 0, 1969, 1967, 1, 0, 0, 0, 1969, 1970, 1, 0, 0, 0, 1970, 1971, 1, 0, 0, 0, 1971, 1972, 5, 360, 0, 0, 1972, 1974, 3, 652, 326, 0, 1973, 1975, 3, 98, 49, 0, 1974, 1973, 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 1977, 1, 0, 0, 0, 1976, 1978, 3, 96, 48, 0, 1977, 1976, 1, 0, 0, 0, 1977, 1978, 1, 0, 0, 0, 1978, 1980, 1, 0, 0, 0, 1979, 1949, 1, 0, 0, 0, 1979, 1955, 1, 0, 0, 0, 1979, 1964, 1, 0, 0, 0, 1980, 111, 1, 0, 0, 0, 1981, 1984, 5, 157, 0, 0, 1982, 1985, 3, 818, 409, 0, 1983, 1985, 5, 30, 0, 0, 1984, 1982, 1, 0, 0, 0, 1984, 1983, 1, 0, 0, 0, 1985, 113, 1, 0, 0, 0, 1986, 1988, 5, 169, 0, 0, 1987, 1989, 5, 107, 0, 0, 1988, 1987, 1, 0, 0, 0, 1988, 1989, 1, 0, 0, 0, 1989, 1990, 1, 0, 0, 0, 1990, 1992, 3, 774, 387, 0, 1991, 1993, 3, 144, 72, 0, 1992, 1991, 1, 0, 0, 0, 1992, 1993, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 1996, 7, 18, 0, 0, 1995, 1997, 5, 297, 0, 0, 1996, 1995, 1, 0, 0, 0, 1996, 1997, 1, 0, 0, 0, 1997, 2001, 1, 0, 0, 0, 1998, 2002, 3, 808, 404, 0, 1999, 2002, 5, 343, 0, 0, 2000, 2002, 5, 344, 0, 0, 2001, 1998, 1, 0, 0, 0, 2001, 1999, 1, 0, 0, 0, 2001, 2000, 1, 0, 0, 0, 2002, 2008, 1, 0, 0, 0, 2003, 2005, 5, 100, 0, 0, 2004, 2003, 1, 0, 0, 0, 2004, 2005, 1, 0, 0, 0, 2005, 2006, 1, 0, 0, 0, 2006, 2007, 5, 184, 0, 0, 2007, 2009, 3, 808, 404, 0, 2008, 2004, 1, 0, 0, 0, 2008, 2009, 1, 0, 0, 0, 2009, 2011, 1, 0, 0, 0, 2010, 2012, 5, 105, 0, 0, 2011, 2010, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2013, 1, 0, 0, 0, 2013, 2015, 3, 116, 58, 0, 2014, 2016, 3, 638, 319, 0, 2015, 2014, 1, 0, 0, 0, 2015, 2016, 1, 0, 0, 0, 2016, 2036, 1, 0, 0, 0, 2017, 2018, 5, 169, 0, 0, 2018, 2019, 5, 2, 0, 0, 2019, 2020, 3, 530, 265, 0, 2020, 2021, 5, 3, 0, 0, 2021, 2023, 5, 94, 0, 0, 2022, 2024, 5, 297, 0, 0, 2023, 2022, 1, 0, 0, 0, 2023, 2024, 1, 0, 0, 0, 2024, 2028, 1, 0, 0, 0, 2025, 2029, 3, 808, 404, 0, 2026, 2029, 5, 343, 0, 0, 2027, 2029, 5, 344, 0, 0, 2028, 2025, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2028, 2027, 1, 0, 0, 0, 2029, 2031, 1, 0, 0, 0, 2030, 2032, 5, 105, 0, 0, 2031, 2030, 1, 0, 0, 0, 2031, 2032, 1, 0, 0, 0, 2032, 2033, 1, 0, 0, 0, 2033, 2034, 3, 116, 58, 0, 2034, 2036, 1, 0, 0, 0, 2035, 1986, 1, 0, 0, 0, 2035, 2017, 1, 0, 0, 0, 2036, 115, 1, 0, 0, 0, 2037, 2061, 5, 107, 0, 0, 2038, 2061, 5, 112, 0, 0, 2039, 2041, 7, 19, 0, 0, 2040, 2042, 5, 36, 0, 0, 2041, 2040, 1, 0, 0, 0, 2041, 2042, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, 0, 2043, 2061, 3, 808, 404, 0, 2044, 2061, 5, 171, 0, 0, 2045, 2061, 5, 216, 0, 0, 2046, 2047, 5, 209, 0, 0, 2047, 2050, 5, 298, 0, 0, 2048, 2051, 3, 148, 74, 0, 2049, 2051, 5, 9, 0, 0, 2050, 2048, 1, 0, 0, 0, 2050, 2049, 1, 0, 0, 0, 2051, 2061, 1, 0, 0, 0, 2052, 2054, 5, 209, 0, 0, 2053, 2055, 5, 77, 0, 0, 2054, 2053, 1, 0, 0, 0, 2054, 2055, 1, 0, 0, 0, 2055, 2056, 1, 0, 0, 0, 2056, 2057, 5, 78, 0, 0, 2057, 2061, 3, 148, 74, 0, 2058, 2059, 5, 194, 0, 0, 2059, 2061, 3, 808, 404, 0, 2060, 2037, 1, 0, 0, 0, 2060, 2038, 1, 0, 0, 0, 2060, 2039, 1, 0, 0, 0, 2060, 2044, 1, 0, 0, 0, 2060, 2045, 1, 0, 0, 0, 2060, 2046, 1, 0, 0, 0, 2060, 2052, 1, 0, 0, 0, 2060, 2058, 1, 0, 0, 0, 2061, 2064, 1, 0, 0, 0, 2062, 2060, 1, 0, 0, 0, 2062, 2063, 1, 0, 0, 0, 2063, 2077, 1, 0, 0, 0, 2064, 2062, 1, 0, 0, 0, 2065, 2066, 5, 2, 0, 0, 2066, 2071, 3, 118, 59, 0, 2067, 2068, 5, 6, 0, 0, 2068, 2070, 3, 118, 59, 0, 2069, 2067, 1, 0, 0, 0, 2070, 2073, 1, 0, 0, 0, 2071, 2069, 1, 0, 0, 0, 2071, 2072, 1, 0, 0, 0, 2072, 2074, 1, 0, 0, 0, 2073, 2071, 1, 0, 0, 0, 2074, 2075, 5, 3, 0, 0, 2075, 2077, 1, 0, 0, 0, 2076, 2062, 1, 0, 0, 0, 2076, 2065, 1, 0, 0, 0, 2077, 117, 1, 0, 0, 0, 2078, 2093, 3, 824, 412, 0, 2079, 2094, 3, 54, 27, 0, 2080, 2094, 3, 202, 101, 0, 2081, 2094, 5, 9, 0, 0, 2082, 2083, 5, 2, 0, 0, 2083, 2088, 3, 52, 26, 0, 2084, 2085, 5, 6, 0, 0, 2085, 2087, 3, 52, 26, 0, 2086, 2084, 1, 0, 0, 0, 2087, 2090, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2088, 2089, 1, 0, 0, 0, 2089, 2091, 1, 0, 0, 0, 2090, 2088, 1, 0, 0, 0, 2091, 2092, 5, 3, 0, 0, 2092, 2094, 1, 0, 0, 0, 2093, 2079, 1, 0, 0, 0, 2093, 2080, 1, 0, 0, 0, 2093, 2081, 1, 0, 0, 0, 2093, 2082, 1, 0, 0, 0, 2093, 2094, 1, 0, 0, 0, 2094, 119, 1, 0, 0, 0, 2095, 2097, 5, 46, 0, 0, 2096, 2098, 3, 122, 61, 0, 2097, 2096, 1, 0, 0, 0, 2097, 2098, 1, 0, 0, 0, 2098, 2099, 1, 0, 0, 0, 2099, 2101, 5, 92, 0, 0, 2100, 2102, 3, 294, 147, 0, 2101, 2100, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2103, 1, 0, 0, 0, 2103, 2169, 3, 772, 386, 0, 2104, 2106, 5, 2, 0, 0, 2105, 2107, 3, 126, 63, 0, 2106, 2105, 1, 0, 0, 0, 2106, 2107, 1, 0, 0, 0, 2107, 2108, 1, 0, 0, 0, 2108, 2110, 5, 3, 0, 0, 2109, 2111, 3, 164, 82, 0, 2110, 2109, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2113, 1, 0, 0, 0, 2112, 2114, 3, 166, 83, 0, 2113, 2112, 1, 0, 0, 0, 2113, 2114, 1, 0, 0, 0, 2114, 2116, 1, 0, 0, 0, 2115, 2117, 3, 170, 85, 0, 2116, 2115, 1, 0, 0, 0, 2116, 2117, 1, 0, 0, 0, 2117, 2119, 1, 0, 0, 0, 2118, 2120, 3, 172, 86, 0, 2119, 2118, 1, 0, 0, 0, 2119, 2120, 1, 0, 0, 0, 2120, 2122, 1, 0, 0, 0, 2121, 2123, 3, 174, 87, 0, 2122, 2121, 1, 0, 0, 0, 2122, 2123, 1, 0, 0, 0, 2123, 2125, 1, 0, 0, 0, 2124, 2126, 3, 176, 88, 0, 2125, 2124, 1, 0, 0, 0, 2125, 2126, 1, 0, 0, 0, 2126, 2170, 1, 0, 0, 0, 2127, 2128, 5, 275, 0, 0, 2128, 2130, 3, 316, 158, 0, 2129, 2131, 3, 124, 62, 0, 2130, 2129, 1, 0, 0, 0, 2130, 2131, 1, 0, 0, 0, 2131, 2133, 1, 0, 0, 0, 2132, 2134, 3, 166, 83, 0, 2133, 2132, 1, 0, 0, 0, 2133, 2134, 1, 0, 0, 0, 2134, 2136, 1, 0, 0, 0, 2135, 2137, 3, 170, 85, 0, 2136, 2135, 1, 0, 0, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2139, 1, 0, 0, 0, 2138, 2140, 3, 172, 86, 0, 2139, 2138, 1, 0, 0, 0, 2139, 2140, 1, 0, 0, 0, 2140, 2142, 1, 0, 0, 0, 2141, 2143, 3, 174, 87, 0, 2142, 2141, 1, 0, 0, 0, 2142, 2143, 1, 0, 0, 0, 2143, 2145, 1, 0, 0, 0, 2144, 2146, 3, 176, 88, 0, 2145, 2144, 1, 0, 0, 0, 2145, 2146, 1, 0, 0, 0, 2146, 2170, 1, 0, 0, 0, 2147, 2148, 5, 285, 0, 0, 2148, 2149, 5, 275, 0, 0, 2149, 2151, 3, 780, 390, 0, 2150, 2152, 3, 124, 62, 0, 2151, 2150, 1, 0, 0, 0, 2151, 2152, 1, 0, 0, 0, 2152, 2153, 1, 0, 0, 0, 2153, 2155, 3, 106, 53, 0, 2154, 2156, 3, 166, 83, 0, 2155, 2154, 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2158, 1, 0, 0, 0, 2157, 2159, 3, 170, 85, 0, 2158, 2157, 1, 0, 0, 0, 2158, 2159, 1, 0, 0, 0, 2159, 2161, 1, 0, 0, 0, 2160, 2162, 3, 172, 86, 0, 2161, 2160, 1, 0, 0, 0, 2161, 2162, 1, 0, 0, 0, 2162, 2164, 1, 0, 0, 0, 2163, 2165, 3, 174, 87, 0, 2164, 2163, 1, 0, 0, 0, 2164, 2165, 1, 0, 0, 0, 2165, 2167, 1, 0, 0, 0, 2166, 2168, 3, 176, 88, 0, 2167, 2166, 1, 0, 0, 0, 2167, 2168, 1, 0, 0, 0, 2168, 2170, 1, 0, 0, 0, 2169, 2104, 1, 0, 0, 0, 2169, 2127, 1, 0, 0, 0, 2169, 2147, 1, 0, 0, 0, 2170, 121, 1, 0, 0, 0, 2171, 2177, 5, 354, 0, 0, 2172, 2177, 5, 352, 0, 0, 2173, 2174, 7, 20, 0, 0, 2174, 2177, 7, 21, 0, 0, 2175, 2177, 5, 367, 0, 0, 2176, 2171, 1, 0, 0, 0, 2176, 2172, 1, 0, 0, 0, 2176, 2173, 1, 0, 0, 0, 2176, 2175, 1, 0, 0, 0, 2177, 123, 1, 0, 0, 0, 2178, 2179, 5, 2, 0, 0, 2179, 2184, 3, 130, 65, 0, 2180, 2181, 5, 6, 0, 0, 2181, 2183, 3, 130, 65, 0, 2182, 2180, 1, 0, 0, 0, 2183, 2186, 1, 0, 0, 0, 2184, 2182, 1, 0, 0, 0, 2184, 2185, 1, 0, 0, 0, 2185, 2187, 1, 0, 0, 0, 2186, 2184, 1, 0, 0, 0, 2187, 2188, 5, 3, 0, 0, 2188, 125, 1, 0, 0, 0, 2189, 2194, 3, 128, 64, 0, 2190, 2191, 5, 6, 0, 0, 2191, 2193, 3, 128, 64, 0, 2192, 2190, 1, 0, 0, 0, 2193, 2196, 1, 0, 0, 0, 2194, 2192, 1, 0, 0, 0, 2194, 2195, 1, 0, 0, 0, 2195, 127, 1, 0, 0, 0, 2196, 2194, 1, 0, 0, 0, 2197, 2198, 5, 45, 0, 0, 2198, 2200, 3, 818, 409, 0, 2199, 2197, 1, 0, 0, 0, 2199, 2200, 1, 0, 0, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2213, 3, 142, 71, 0, 2202, 2213, 3, 132, 66, 0, 2203, 2204, 5, 120, 0, 0, 2204, 2209, 3, 780, 390, 0, 2205, 2206, 7, 22, 0, 0, 2206, 2208, 3, 140, 70, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2211, 1, 0, 0, 0, 2209, 2207, 1, 0, 0, 0, 2209, 2210, 1, 0, 0, 0, 2210, 2213, 1, 0, 0, 0, 2211, 2209, 1, 0, 0, 0, 2212, 2199, 1, 0, 0, 0, 2212, 2202, 1, 0, 0, 0, 2212, 2203, 1, 0, 0, 0, 2213, 129, 1, 0, 0, 0, 2214, 2217, 3, 802, 401, 0, 2215, 2216, 5, 105, 0, 0, 2216, 2218, 5, 280, 0, 0, 2217, 2215, 1, 0, 0, 0, 2217, 2218, 1, 0, 0, 0, 2218, 2222, 1, 0, 0, 0, 2219, 2221, 3, 134, 67, 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, 2231, 1, 0, 0, 0, 2224, 2222, 1, 0, 0, 0, 2225, 2226, 5, 45, 0, 0, 2226, 2228, 3, 818, 409, 0, 2227, 2225, 1, 0, 0, 0, 2227, 2228, 1, 0, 0, 0, 2228, 2229, 1, 0, 0, 0, 2229, 2231, 3, 142, 71, 0, 2230, 2214, 1, 0, 0, 0, 2230, 2227, 1, 0, 0, 0, 2231, 131, 1, 0, 0, 0, 2232, 2233, 3, 802, 401, 0, 2233, 2235, 3, 652, 326, 0, 2234, 2236, 3, 220, 110, 0, 2235, 2234, 1, 0, 0, 0, 2235, 2236, 1, 0, 0, 0, 2236, 2246, 1, 0, 0, 0, 2237, 2244, 5, 345, 0, 0, 2238, 2245, 5, 544, 0, 0, 2239, 2245, 5, 205, 0, 0, 2240, 2245, 5, 545, 0, 0, 2241, 2245, 5, 546, 0, 0, 2242, 2245, 5, 53, 0, 0, 2243, 2245, 3, 818, 409, 0, 2244, 2238, 1, 0, 0, 0, 2244, 2239, 1, 0, 0, 0, 2244, 2240, 1, 0, 0, 0, 2244, 2241, 1, 0, 0, 0, 2244, 2242, 1, 0, 0, 0, 2244, 2243, 1, 0, 0, 0, 2245, 2247, 1, 0, 0, 0, 2246, 2237, 1, 0, 0, 0, 2246, 2247, 1, 0, 0, 0, 2247, 2250, 1, 0, 0, 0, 2248, 2249, 5, 543, 0, 0, 2249, 2251, 3, 818, 409, 0, 2250, 2248, 1, 0, 0, 0, 2250, 2251, 1, 0, 0, 0, 2251, 2253, 1, 0, 0, 0, 2252, 2254, 3, 98, 49, 0, 2253, 2252, 1, 0, 0, 0, 2253, 2254, 1, 0, 0, 0, 2254, 2257, 1, 0, 0, 0, 2255, 2256, 5, 105, 0, 0, 2256, 2258, 5, 280, 0, 0, 2257, 2255, 1, 0, 0, 0, 2257, 2258, 1, 0, 0, 0, 2258, 2262, 1, 0, 0, 0, 2259, 2261, 3, 134, 67, 0, 2260, 2259, 1, 0, 0, 0, 2261, 2264, 1, 0, 0, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 133, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2265, 2266, 5, 45, 0, 0, 2266, 2268, 3, 818, 409, 0, 2267, 2265, 1, 0, 0, 0, 2267, 2268, 1, 0, 0, 0, 2268, 2269, 1, 0, 0, 0, 2269, 2274, 3, 136, 68, 0, 2270, 2272, 5, 77, 0, 0, 2271, 2270, 1, 0, 0, 0, 2271, 2272, 1, 0, 0, 0, 2272, 2273, 1, 0, 0, 0, 2273, 2275, 5, 54, 0, 0, 2274, 2271, 1, 0, 0, 0, 2274, 2275, 1, 0, 0, 0, 2275, 2278, 1, 0, 0, 0, 2276, 2277, 5, 69, 0, 0, 2277, 2279, 7, 9, 0, 0, 2278, 2276, 1, 0, 0, 0, 2278, 2279, 1, 0, 0, 0, 2279, 135, 1, 0, 0, 0, 2280, 2282, 5, 77, 0, 0, 2281, 2280, 1, 0, 0, 0, 2281, 2282, 1, 0, 0, 0, 2282, 2283, 1, 0, 0, 0, 2283, 2361, 5, 78, 0, 0, 2284, 2286, 5, 98, 0, 0, 2285, 2287, 3, 400, 200, 0, 2286, 2285, 1, 0, 0, 0, 2286, 2287, 1, 0, 0, 0, 2287, 2289, 1, 0, 0, 0, 2288, 2290, 3, 178, 89, 0, 2289, 2288, 1, 0, 0, 0, 2289, 2290, 1, 0, 0, 0, 2290, 2361, 1, 0, 0, 0, 2291, 2297, 5, 98, 0, 0, 2292, 2294, 5, 273, 0, 0, 2293, 2295, 5, 77, 0, 0, 2294, 2293, 1, 0, 0, 0, 2294, 2295, 1, 0, 0, 0, 2295, 2296, 1, 0, 0, 0, 2296, 2298, 5, 56, 0, 0, 2297, 2292, 1, 0, 0, 0, 2297, 2298, 1, 0, 0, 0, 2298, 2301, 1, 0, 0, 0, 2299, 2300, 5, 441, 0, 0, 2300, 2302, 3, 360, 180, 0, 2301, 2299, 1, 0, 0, 0, 2301, 2302, 1, 0, 0, 0, 2302, 2304, 1, 0, 0, 0, 2303, 2305, 3, 572, 286, 0, 2304, 2303, 1, 0, 0, 0, 2304, 2305, 1, 0, 0, 0, 2305, 2307, 1, 0, 0, 0, 2306, 2308, 3, 178, 89, 0, 2307, 2306, 1, 0, 0, 0, 2307, 2308, 1, 0, 0, 0, 2308, 2361, 1, 0, 0, 0, 2309, 2310, 5, 85, 0, 0, 2310, 2312, 5, 245, 0, 0, 2311, 2313, 3, 400, 200, 0, 2312, 2311, 1, 0, 0, 0, 2312, 2313, 1, 0, 0, 0, 2313, 2315, 1, 0, 0, 0, 2314, 2316, 3, 178, 89, 0, 2315, 2314, 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, 2316, 2361, 1, 0, 0, 0, 2317, 2318, 5, 42, 0, 0, 2318, 2319, 5, 2, 0, 0, 2319, 2320, 3, 674, 337, 0, 2320, 2323, 5, 3, 0, 0, 2321, 2322, 5, 269, 0, 0, 2322, 2324, 5, 228, 0, 0, 2323, 2321, 1, 0, 0, 0, 2323, 2324, 1, 0, 0, 0, 2324, 2361, 1, 0, 0, 0, 2325, 2326, 5, 53, 0, 0, 2326, 2361, 3, 682, 341, 0, 2327, 2328, 5, 438, 0, 0, 2328, 2329, 3, 138, 69, 0, 2329, 2346, 5, 36, 0, 0, 2330, 2339, 5, 219, 0, 0, 2331, 2333, 5, 2, 0, 0, 2332, 2334, 3, 200, 100, 0, 2333, 2332, 1, 0, 0, 0, 2334, 2335, 1, 0, 0, 0, 2335, 2333, 1, 0, 0, 0, 2335, 2336, 1, 0, 0, 0, 2336, 2337, 1, 0, 0, 0, 2337, 2338, 5, 3, 0, 0, 2338, 2340, 1, 0, 0, 0, 2339, 2331, 1, 0, 0, 0, 2339, 2340, 1, 0, 0, 0, 2340, 2347, 1, 0, 0, 0, 2341, 2342, 5, 2, 0, 0, 2342, 2343, 3, 674, 337, 0, 2343, 2344, 5, 3, 0, 0, 2344, 2345, 5, 440, 0, 0, 2345, 2347, 1, 0, 0, 0, 2346, 2330, 1, 0, 0, 0, 2346, 2341, 1, 0, 0, 0, 2347, 2361, 1, 0, 0, 0, 2348, 2349, 5, 86, 0, 0, 2349, 2351, 3, 780, 390, 0, 2350, 2352, 3, 144, 72, 0, 2351, 2350, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2354, 1, 0, 0, 0, 2353, 2355, 3, 152, 76, 0, 2354, 2353, 1, 0, 0, 0, 2354, 2355, 1, 0, 0, 0, 2355, 2357, 1, 0, 0, 0, 2356, 2358, 3, 156, 78, 0, 2357, 2356, 1, 0, 0, 0, 2357, 2358, 1, 0, 0, 0, 2358, 2361, 1, 0, 0, 0, 2359, 2361, 3, 98, 49, 0, 2360, 2281, 1, 0, 0, 0, 2360, 2284, 1, 0, 0, 0, 2360, 2291, 1, 0, 0, 0, 2360, 2309, 1, 0, 0, 0, 2360, 2317, 1, 0, 0, 0, 2360, 2325, 1, 0, 0, 0, 2360, 2327, 1, 0, 0, 0, 2360, 2348, 1, 0, 0, 0, 2360, 2359, 1, 0, 0, 0, 2361, 137, 1, 0, 0, 0, 2362, 2366, 5, 139, 0, 0, 2363, 2364, 5, 147, 0, 0, 2364, 2366, 5, 53, 0, 0, 2365, 2362, 1, 0, 0, 0, 2365, 2363, 1, 0, 0, 0, 2366, 139, 1, 0, 0, 0, 2367, 2368, 7, 23, 0, 0, 2368, 141, 1, 0, 0, 0, 2369, 2370, 5, 42, 0, 0, 2370, 2371, 5, 2, 0, 0, 2371, 2372, 3, 674, 337, 0, 2372, 2376, 5, 3, 0, 0, 2373, 2375, 3, 272, 136, 0, 2374, 2373, 1, 0, 0, 0, 2375, 2378, 1, 0, 0, 0, 2376, 2374, 1, 0, 0, 0, 2376, 2377, 1, 0, 0, 0, 2377, 2466, 1, 0, 0, 0, 2378, 2376, 1, 0, 0, 0, 2379, 2383, 5, 98, 0, 0, 2380, 2381, 5, 85, 0, 0, 2381, 2383, 5, 245, 0, 0, 2382, 2379, 1, 0, 0, 0, 2382, 2380, 1, 0, 0, 0, 2383, 2407, 1, 0, 0, 0, 2384, 2386, 3, 144, 72, 0, 2385, 2387, 3, 150, 75, 0, 2386, 2385, 1, 0, 0, 0, 2386, 2387, 1, 0, 0, 0, 2387, 2389, 1, 0, 0, 0, 2388, 2390, 3, 400, 200, 0, 2389, 2388, 1, 0, 0, 0, 2389, 2390, 1, 0, 0, 0, 2390, 2392, 1, 0, 0, 0, 2391, 2393, 3, 178, 89, 0, 2392, 2391, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2397, 1, 0, 0, 0, 2394, 2396, 3, 272, 136, 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, 2408, 1, 0, 0, 0, 2399, 2397, 1, 0, 0, 0, 2400, 2404, 3, 180, 90, 0, 2401, 2403, 3, 272, 136, 0, 2402, 2401, 1, 0, 0, 0, 2403, 2406, 1, 0, 0, 0, 2404, 2402, 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 2408, 1, 0, 0, 0, 2406, 2404, 1, 0, 0, 0, 2407, 2384, 1, 0, 0, 0, 2407, 2400, 1, 0, 0, 0, 2408, 2466, 1, 0, 0, 0, 2409, 2411, 5, 199, 0, 0, 2410, 2412, 3, 170, 85, 0, 2411, 2410, 1, 0, 0, 0, 2411, 2412, 1, 0, 0, 0, 2412, 2413, 1, 0, 0, 0, 2413, 2414, 5, 2, 0, 0, 2414, 2419, 3, 154, 77, 0, 2415, 2416, 5, 6, 0, 0, 2416, 2418, 3, 154, 77, 0, 2417, 2415, 1, 0, 0, 0, 2418, 2421, 1, 0, 0, 0, 2419, 2417, 1, 0, 0, 0, 2419, 2420, 1, 0, 0, 0, 2420, 2422, 1, 0, 0, 0, 2421, 2419, 1, 0, 0, 0, 2422, 2424, 5, 3, 0, 0, 2423, 2425, 3, 150, 75, 0, 2424, 2423, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2427, 1, 0, 0, 0, 2426, 2428, 3, 400, 200, 0, 2427, 2426, 1, 0, 0, 0, 2427, 2428, 1, 0, 0, 0, 2428, 2430, 1, 0, 0, 0, 2429, 2431, 3, 178, 89, 0, 2430, 2429, 1, 0, 0, 0, 2430, 2431, 1, 0, 0, 0, 2431, 2437, 1, 0, 0, 0, 2432, 2433, 5, 103, 0, 0, 2433, 2434, 5, 2, 0, 0, 2434, 2435, 3, 674, 337, 0, 2435, 2436, 5, 3, 0, 0, 2436, 2438, 1, 0, 0, 0, 2437, 2432, 1, 0, 0, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2442, 1, 0, 0, 0, 2439, 2441, 3, 272, 136, 0, 2440, 2439, 1, 0, 0, 0, 2441, 2444, 1, 0, 0, 0, 2442, 2440, 1, 0, 0, 0, 2442, 2443, 1, 0, 0, 0, 2443, 2466, 1, 0, 0, 0, 2444, 2442, 1, 0, 0, 0, 2445, 2446, 5, 63, 0, 0, 2446, 2447, 5, 245, 0, 0, 2447, 2448, 3, 144, 72, 0, 2448, 2449, 5, 86, 0, 0, 2449, 2451, 3, 780, 390, 0, 2450, 2452, 3, 144, 72, 0, 2451, 2450, 1, 0, 0, 0, 2451, 2452, 1, 0, 0, 0, 2452, 2454, 1, 0, 0, 0, 2453, 2455, 3, 152, 76, 0, 2454, 2453, 1, 0, 0, 0, 2454, 2455, 1, 0, 0, 0, 2455, 2457, 1, 0, 0, 0, 2456, 2458, 3, 156, 78, 0, 2457, 2456, 1, 0, 0, 0, 2457, 2458, 1, 0, 0, 0, 2458, 2462, 1, 0, 0, 0, 2459, 2461, 3, 272, 136, 0, 2460, 2459, 1, 0, 0, 0, 2461, 2464, 1, 0, 0, 0, 2462, 2460, 1, 0, 0, 0, 2462, 2463, 1, 0, 0, 0, 2463, 2466, 1, 0, 0, 0, 2464, 2462, 1, 0, 0, 0, 2465, 2369, 1, 0, 0, 0, 2465, 2382, 1, 0, 0, 0, 2465, 2409, 1, 0, 0, 0, 2465, 2445, 1, 0, 0, 0, 2466, 143, 1, 0, 0, 0, 2467, 2468, 5, 2, 0, 0, 2468, 2469, 3, 148, 74, 0, 2469, 2470, 5, 3, 0, 0, 2470, 145, 1, 0, 0, 0, 2471, 2472, 5, 2, 0, 0, 2472, 2477, 3, 802, 401, 0, 2473, 2474, 5, 6, 0, 0, 2474, 2476, 3, 802, 401, 0, 2475, 2473, 1, 0, 0, 0, 2476, 2479, 1, 0, 0, 0, 2477, 2475, 1, 0, 0, 0, 2477, 2478, 1, 0, 0, 0, 2478, 2480, 1, 0, 0, 0, 2479, 2477, 1, 0, 0, 0, 2480, 2481, 5, 3, 0, 0, 2481, 147, 1, 0, 0, 0, 2482, 2487, 3, 800, 400, 0, 2483, 2484, 5, 6, 0, 0, 2484, 2486, 3, 800, 400, 0, 2485, 2483, 1, 0, 0, 0, 2486, 2489, 1, 0, 0, 0, 2487, 2485, 1, 0, 0, 0, 2487, 2488, 1, 0, 0, 0, 2488, 149, 1, 0, 0, 0, 2489, 2487, 1, 0, 0, 0, 2490, 2491, 5, 441, 0, 0, 2491, 2492, 3, 144, 72, 0, 2492, 151, 1, 0, 0, 0, 2493, 2494, 5, 258, 0, 0, 2494, 2495, 7, 24, 0, 0, 2495, 153, 1, 0, 0, 0, 2496, 2497, 3, 362, 181, 0, 2497, 2504, 5, 105, 0, 0, 2498, 2505, 3, 414, 207, 0, 2499, 2500, 5, 278, 0, 0, 2500, 2501, 5, 2, 0, 0, 2501, 2502, 3, 414, 207, 0, 2502, 2503, 5, 3, 0, 0, 2503, 2505, 1, 0, 0, 0, 2504, 2498, 1, 0, 0, 0, 2504, 2499, 1, 0, 0, 0, 2505, 155, 1, 0, 0, 0, 2506, 2508, 3, 158, 79, 0, 2507, 2509, 3, 160, 80, 0, 2508, 2507, 1, 0, 0, 0, 2508, 2509, 1, 0, 0, 0, 2509, 2515, 1, 0, 0, 0, 2510, 2512, 3, 160, 80, 0, 2511, 2513, 3, 158, 79, 0, 2512, 2511, 1, 0, 0, 0, 2512, 2513, 1, 0, 0, 0, 2513, 2515, 1, 0, 0, 0, 2514, 2506, 1, 0, 0, 0, 2514, 2510, 1, 0, 0, 0, 2515, 157, 1, 0, 0, 0, 2516, 2517, 5, 80, 0, 0, 2517, 2518, 5, 369, 0, 0, 2518, 2519, 3, 162, 81, 0, 2519, 159, 1, 0, 0, 0, 2520, 2521, 5, 80, 0, 0, 2521, 2522, 5, 182, 0, 0, 2522, 2523, 3, 162, 81, 0, 2523, 161, 1, 0, 0, 0, 2524, 2525, 5, 269, 0, 0, 2525, 2534, 5, 132, 0, 0, 2526, 2534, 5, 315, 0, 0, 2527, 2534, 5, 150, 0, 0, 2528, 2529, 5, 333, 0, 0, 2529, 2531, 7, 25, 0, 0, 2530, 2532, 3, 148, 74, 0, 2531, 2530, 1, 0, 0, 0, 2531, 2532, 1, 0, 0, 0, 2532, 2534, 1, 0, 0, 0, 2533, 2524, 1, 0, 0, 0, 2533, 2526, 1, 0, 0, 0, 2533, 2527, 1, 0, 0, 0, 2533, 2528, 1, 0, 0, 0, 2534, 163, 1, 0, 0, 0, 2535, 2536, 5, 238, 0, 0, 2536, 2537, 5, 2, 0, 0, 2537, 2538, 3, 760, 380, 0, 2538, 2539, 5, 3, 0, 0, 2539, 165, 1, 0, 0, 0, 2540, 2541, 5, 285, 0, 0, 2541, 2542, 5, 147, 0, 0, 2542, 2543, 3, 818, 409, 0, 2543, 2544, 5, 2, 0, 0, 2544, 2549, 3, 168, 84, 0, 2545, 2546, 5, 6, 0, 0, 2546, 2548, 3, 168, 84, 0, 2547, 2545, 1, 0, 0, 0, 2548, 2551, 1, 0, 0, 0, 2549, 2547, 1, 0, 0, 0, 2549, 2550, 1, 0, 0, 0, 2550, 2552, 1, 0, 0, 0, 2551, 2549, 1, 0, 0, 0, 2552, 2553, 5, 3, 0, 0, 2553, 167, 1, 0, 0, 0, 2554, 2561, 3, 800, 400, 0, 2555, 2561, 3, 688, 344, 0, 2556, 2557, 5, 2, 0, 0, 2557, 2558, 3, 674, 337, 0, 2558, 2559, 5, 3, 0, 0, 2559, 2561, 1, 0, 0, 0, 2560, 2554, 1, 0, 0, 0, 2560, 2555, 1, 0, 0, 0, 2560, 2556, 1, 0, 0, 0, 2561, 2563, 1, 0, 0, 0, 2562, 2564, 3, 98, 49, 0, 2563, 2562, 1, 0, 0, 0, 2563, 2564, 1, 0, 0, 0, 2564, 2566, 1, 0, 0, 0, 2565, 2567, 3, 316, 158, 0, 2566, 2565, 1, 0, 0, 0, 2566, 2567, 1, 0, 0, 0, 2567, 169, 1, 0, 0, 0, 2568, 2569, 5, 100, 0, 0, 2569, 2570, 3, 818, 409, 0, 2570, 171, 1, 0, 0, 0, 2571, 2572, 5, 105, 0, 0, 2572, 2576, 3, 100, 50, 0, 2573, 2574, 7, 26, 0, 0, 2574, 2576, 5, 277, 0, 0, 2575, 2571, 1, 0, 0, 0, 2575, 2573, 1, 0, 0, 0, 2576, 173, 1, 0, 0, 0, 2577, 2578, 5, 80, 0, 0, 2578, 2584, 5, 161, 0, 0, 2579, 2585, 5, 191, 0, 0, 2580, 2581, 5, 182, 0, 0, 2581, 2585, 5, 320, 0, 0, 2582, 2583, 5, 292, 0, 0, 2583, 2585, 5, 320, 0, 0, 2584, 2579, 1, 0, 0, 0, 2584, 2580, 1, 0, 0, 0, 2584, 2582, 1, 0, 0, 0, 2585, 175, 1, 0, 0, 0, 2586, 2587, 5, 351, 0, 0, 2587, 2588, 3, 770, 385, 0, 2588, 177, 1, 0, 0, 0, 2589, 2590, 5, 100, 0, 0, 2590, 2591, 5, 226, 0, 0, 2591, 2592, 3, 176, 88, 0, 2592, 179, 1, 0, 0, 0, 2593, 2594, 5, 100, 0, 0, 2594, 2595, 5, 226, 0, 0, 2595, 2596, 3, 818, 409, 0, 2596, 181, 1, 0, 0, 0, 2597, 2598, 5, 46, 0, 0, 2598, 2603, 5, 342, 0, 0, 2599, 2601, 3, 294, 147, 0, 2600, 2599, 1, 0, 0, 0, 2600, 2601, 1, 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 2604, 3, 316, 158, 0, 2603, 2600, 1, 0, 0, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2606, 1, 0, 0, 0, 2605, 2607, 3, 144, 72, 0, 2606, 2605, 1, 0, 0, 0, 2606, 2607, 1, 0, 0, 0, 2607, 2608, 1, 0, 0, 0, 2608, 2618, 5, 80, 0, 0, 2609, 2614, 3, 732, 366, 0, 2610, 2611, 5, 6, 0, 0, 2611, 2613, 3, 732, 366, 0, 2612, 2610, 1, 0, 0, 0, 2613, 2616, 1, 0, 0, 0, 2614, 2612, 1, 0, 0, 0, 2614, 2615, 1, 0, 0, 0, 2615, 2619, 1, 0, 0, 0, 2616, 2614, 1, 0, 0, 0, 2617, 2619, 3, 730, 365, 0, 2618, 2609, 1, 0, 0, 0, 2618, 2617, 1, 0, 0, 0, 2619, 2620, 1, 0, 0, 0, 2620, 2621, 3, 610, 305, 0, 2621, 183, 1, 0, 0, 0, 2622, 2623, 5, 138, 0, 0, 2623, 2625, 5, 342, 0, 0, 2624, 2626, 3, 422, 211, 0, 2625, 2624, 1, 0, 0, 0, 2625, 2626, 1, 0, 0, 0, 2626, 2627, 1, 0, 0, 0, 2627, 2628, 3, 316, 158, 0, 2628, 2629, 5, 333, 0, 0, 2629, 2630, 5, 342, 0, 0, 2630, 2631, 3, 812, 406, 0, 2631, 185, 1, 0, 0, 0, 2632, 2634, 5, 46, 0, 0, 2633, 2635, 3, 122, 61, 0, 2634, 2633, 1, 0, 0, 0, 2634, 2635, 1, 0, 0, 0, 2635, 2636, 1, 0, 0, 0, 2636, 2638, 5, 92, 0, 0, 2637, 2639, 3, 294, 147, 0, 2638, 2637, 1, 0, 0, 0, 2638, 2639, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, 2641, 3, 188, 94, 0, 2641, 2642, 5, 36, 0, 0, 2642, 2644, 3, 560, 280, 0, 2643, 2645, 3, 190, 95, 0, 2644, 2643, 1, 0, 0, 0, 2644, 2645, 1, 0, 0, 0, 2645, 187, 1, 0, 0, 0, 2646, 2648, 3, 772, 386, 0, 2647, 2649, 3, 146, 73, 0, 2648, 2647, 1, 0, 0, 0, 2648, 2649, 1, 0, 0, 0, 2649, 2651, 1, 0, 0, 0, 2650, 2652, 3, 170, 85, 0, 2651, 2650, 1, 0, 0, 0, 2651, 2652, 1, 0, 0, 0, 2652, 2654, 1, 0, 0, 0, 2653, 2655, 3, 172, 86, 0, 2654, 2653, 1, 0, 0, 0, 2654, 2655, 1, 0, 0, 0, 2655, 2657, 1, 0, 0, 0, 2656, 2658, 3, 174, 87, 0, 2657, 2656, 1, 0, 0, 0, 2657, 2658, 1, 0, 0, 0, 2658, 2660, 1, 0, 0, 0, 2659, 2661, 3, 176, 88, 0, 2660, 2659, 1, 0, 0, 0, 2660, 2661, 1, 0, 0, 0, 2661, 189, 1, 0, 0, 0, 2662, 2666, 5, 105, 0, 0, 2663, 2667, 5, 174, 0, 0, 2664, 2665, 5, 269, 0, 0, 2665, 2667, 5, 174, 0, 0, 2666, 2663, 1, 0, 0, 0, 2666, 2664, 1, 0, 0, 0, 2667, 191, 1, 0, 0, 0, 2668, 2670, 5, 46, 0, 0, 2669, 2671, 5, 367, 0, 0, 2670, 2669, 1, 0, 0, 0, 2670, 2671, 1, 0, 0, 0, 2671, 2672, 1, 0, 0, 0, 2672, 2673, 5, 259, 0, 0, 2673, 2675, 5, 376, 0, 0, 2674, 2676, 3, 294, 147, 0, 2675, 2674, 1, 0, 0, 0, 2675, 2676, 1, 0, 0, 0, 2676, 2677, 1, 0, 0, 0, 2677, 2679, 3, 776, 388, 0, 2678, 2680, 3, 146, 73, 0, 2679, 2678, 1, 0, 0, 0, 2679, 2680, 1, 0, 0, 0, 2680, 2682, 1, 0, 0, 0, 2681, 2683, 3, 170, 85, 0, 2682, 2681, 1, 0, 0, 0, 2682, 2683, 1, 0, 0, 0, 2683, 2685, 1, 0, 0, 0, 2684, 2686, 3, 102, 51, 0, 2685, 2684, 1, 0, 0, 0, 2685, 2686, 1, 0, 0, 0, 2686, 2688, 1, 0, 0, 0, 2687, 2689, 3, 176, 88, 0, 2688, 2687, 1, 0, 0, 0, 2688, 2689, 1, 0, 0, 0, 2689, 2690, 1, 0, 0, 0, 2690, 2691, 5, 36, 0, 0, 2691, 2693, 3, 560, 280, 0, 2692, 2694, 3, 190, 95, 0, 2693, 2692, 1, 0, 0, 0, 2693, 2694, 1, 0, 0, 0, 2694, 193, 1, 0, 0, 0, 2695, 2696, 5, 305, 0, 0, 2696, 2697, 5, 259, 0, 0, 2697, 2699, 5, 376, 0, 0, 2698, 2700, 5, 109, 0, 0, 2699, 2698, 1, 0, 0, 0, 2699, 2700, 1, 0, 0, 0, 2700, 2701, 1, 0, 0, 0, 2701, 2703, 3, 778, 389, 0, 2702, 2704, 3, 190, 95, 0, 2703, 2702, 1, 0, 0, 0, 2703, 2704, 1, 0, 0, 0, 2704, 195, 1, 0, 0, 0, 2705, 2707, 5, 46, 0, 0, 2706, 2708, 3, 122, 61, 0, 2707, 2706, 1, 0, 0, 0, 2707, 2708, 1, 0, 0, 0, 2708, 2709, 1, 0, 0, 0, 2709, 2711, 5, 328, 0, 0, 2710, 2712, 3, 294, 147, 0, 2711, 2710, 1, 0, 0, 0, 2711, 2712, 1, 0, 0, 0, 2712, 2713, 1, 0, 0, 0, 2713, 2719, 3, 780, 390, 0, 2714, 2716, 3, 200, 100, 0, 2715, 2714, 1, 0, 0, 0, 2716, 2717, 1, 0, 0, 0, 2717, 2715, 1, 0, 0, 0, 2717, 2718, 1, 0, 0, 0, 2718, 2720, 1, 0, 0, 0, 2719, 2715, 1, 0, 0, 0, 2719, 2720, 1, 0, 0, 0, 2720, 197, 1, 0, 0, 0, 2721, 2722, 5, 138, 0, 0, 2722, 2724, 5, 328, 0, 0, 2723, 2725, 3, 422, 211, 0, 2724, 2723, 1, 0, 0, 0, 2724, 2725, 1, 0, 0, 0, 2725, 2726, 1, 0, 0, 0, 2726, 2728, 3, 780, 390, 0, 2727, 2729, 3, 200, 100, 0, 2728, 2727, 1, 0, 0, 0, 2729, 2730, 1, 0, 0, 0, 2730, 2728, 1, 0, 0, 0, 2730, 2731, 1, 0, 0, 0, 2731, 199, 1, 0, 0, 0, 2732, 2733, 5, 36, 0, 0, 2733, 2766, 3, 654, 327, 0, 2734, 2736, 5, 148, 0, 0, 2735, 2737, 3, 202, 101, 0, 2736, 2735, 1, 0, 0, 0, 2736, 2737, 1, 0, 0, 0, 2737, 2766, 1, 0, 0, 0, 2738, 2740, 5, 225, 0, 0, 2739, 2741, 5, 147, 0, 0, 2740, 2739, 1, 0, 0, 0, 2740, 2741, 1, 0, 0, 0, 2741, 2742, 1, 0, 0, 0, 2742, 2766, 3, 202, 101, 0, 2743, 2744, 7, 27, 0, 0, 2744, 2766, 3, 202, 101, 0, 2745, 2746, 5, 269, 0, 0, 2746, 2766, 7, 28, 0, 0, 2747, 2748, 5, 281, 0, 0, 2748, 2749, 5, 147, 0, 0, 2749, 2766, 3, 800, 400, 0, 2750, 2751, 5, 328, 0, 0, 2751, 2752, 5, 266, 0, 0, 2752, 2766, 3, 316, 158, 0, 2753, 2755, 5, 340, 0, 0, 2754, 2756, 5, 105, 0, 0, 2755, 2754, 1, 0, 0, 0, 2755, 2756, 1, 0, 0, 0, 2756, 2757, 1, 0, 0, 0, 2757, 2766, 3, 202, 101, 0, 2758, 2760, 5, 314, 0, 0, 2759, 2761, 5, 105, 0, 0, 2760, 2759, 1, 0, 0, 0, 2760, 2761, 1, 0, 0, 0, 2761, 2763, 1, 0, 0, 0, 2762, 2764, 3, 202, 101, 0, 2763, 2762, 1, 0, 0, 0, 2763, 2764, 1, 0, 0, 0, 2764, 2766, 1, 0, 0, 0, 2765, 2732, 1, 0, 0, 0, 2765, 2734, 1, 0, 0, 0, 2765, 2738, 1, 0, 0, 0, 2765, 2743, 1, 0, 0, 0, 2765, 2745, 1, 0, 0, 0, 2765, 2747, 1, 0, 0, 0, 2765, 2750, 1, 0, 0, 0, 2765, 2753, 1, 0, 0, 0, 2765, 2758, 1, 0, 0, 0, 2766, 201, 1, 0, 0, 0, 2767, 2769, 7, 29, 0, 0, 2768, 2767, 1, 0, 0, 0, 2768, 2769, 1, 0, 0, 0, 2769, 2770, 1, 0, 0, 0, 2770, 2773, 5, 573, 0, 0, 2771, 2773, 3, 812, 406, 0, 2772, 2768, 1, 0, 0, 0, 2772, 2771, 1, 0, 0, 0, 2773, 203, 1, 0, 0, 0, 2774, 2776, 5, 46, 0, 0, 2775, 2777, 3, 366, 183, 0, 2776, 2775, 1, 0, 0, 0, 2776, 2777, 1, 0, 0, 0, 2777, 2779, 1, 0, 0, 0, 2778, 2780, 5, 359, 0, 0, 2779, 2778, 1, 0, 0, 0, 2779, 2780, 1, 0, 0, 0, 2780, 2782, 1, 0, 0, 0, 2781, 2783, 5, 295, 0, 0, 2782, 2781, 1, 0, 0, 0, 2782, 2783, 1, 0, 0, 0, 2783, 2784, 1, 0, 0, 0, 2784, 2785, 5, 247, 0, 0, 2785, 2798, 3, 818, 409, 0, 2786, 2787, 5, 215, 0, 0, 2787, 2790, 3, 316, 158, 0, 2788, 2789, 5, 239, 0, 0, 2789, 2791, 3, 316, 158, 0, 2790, 2788, 1, 0, 0, 0, 2790, 2791, 1, 0, 0, 0, 2791, 2796, 1, 0, 0, 0, 2792, 2793, 5, 373, 0, 0, 2793, 2797, 3, 316, 158, 0, 2794, 2795, 5, 269, 0, 0, 2795, 2797, 5, 373, 0, 0, 2796, 2792, 1, 0, 0, 0, 2796, 2794, 1, 0, 0, 0, 2796, 2797, 1, 0, 0, 0, 2797, 2799, 1, 0, 0, 0, 2798, 2786, 1, 0, 0, 0, 2798, 2799, 1, 0, 0, 0, 2799, 205, 1, 0, 0, 0, 2800, 2801, 5, 46, 0, 0, 2801, 2804, 3, 176, 88, 0, 2802, 2803, 5, 282, 0, 0, 2803, 2805, 3, 814, 407, 0, 2804, 2802, 1, 0, 0, 0, 2804, 2805, 1, 0, 0, 0, 2805, 2806, 1, 0, 0, 0, 2806, 2807, 5, 255, 0, 0, 2807, 2809, 3, 808, 404, 0, 2808, 2810, 3, 102, 51, 0, 2809, 2808, 1, 0, 0, 0, 2809, 2810, 1, 0, 0, 0, 2810, 207, 1, 0, 0, 0, 2811, 2812, 5, 46, 0, 0, 2812, 2814, 5, 204, 0, 0, 2813, 2815, 3, 294, 147, 0, 2814, 2813, 1, 0, 0, 0, 2814, 2815, 1, 0, 0, 0, 2815, 2816, 1, 0, 0, 0, 2816, 2818, 3, 818, 409, 0, 2817, 2819, 5, 105, 0, 0, 2818, 2817, 1, 0, 0, 0, 2818, 2819, 1, 0, 0, 0, 2819, 2827, 1, 0, 0, 0, 2820, 2821, 5, 323, 0, 0, 2821, 2826, 3, 790, 395, 0, 2822, 2823, 7, 30, 0, 0, 2823, 2826, 3, 58, 29, 0, 2824, 2826, 5, 150, 0, 0, 2825, 2820, 1, 0, 0, 0, 2825, 2822, 1, 0, 0, 0, 2825, 2824, 1, 0, 0, 0, 2826, 2829, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2827, 2828, 1, 0, 0, 0, 2828, 209, 1, 0, 0, 0, 2829, 2827, 1, 0, 0, 0, 2830, 2831, 5, 138, 0, 0, 2831, 2832, 5, 204, 0, 0, 2832, 2833, 3, 818, 409, 0, 2833, 2838, 5, 369, 0, 0, 2834, 2835, 5, 94, 0, 0, 2835, 2837, 3, 58, 29, 0, 2836, 2834, 1, 0, 0, 0, 2837, 2840, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2838, 2839, 1, 0, 0, 0, 2839, 211, 1, 0, 0, 0, 2840, 2838, 1, 0, 0, 0, 2841, 2842, 5, 138, 0, 0, 2842, 2843, 5, 204, 0, 0, 2843, 2844, 3, 818, 409, 0, 2844, 2877, 7, 6, 0, 0, 2845, 2846, 5, 443, 0, 0, 2846, 2847, 5, 62, 0, 0, 2847, 2848, 3, 652, 326, 0, 2848, 2849, 5, 247, 0, 0, 2849, 2850, 3, 818, 409, 0, 2850, 2878, 1, 0, 0, 0, 2851, 2852, 5, 442, 0, 0, 2852, 2878, 3, 374, 187, 0, 2853, 2854, 5, 296, 0, 0, 2854, 2878, 3, 378, 189, 0, 2855, 2856, 5, 278, 0, 0, 2856, 2857, 7, 31, 0, 0, 2857, 2858, 3, 316, 158, 0, 2858, 2859, 3, 170, 85, 0, 2859, 2878, 1, 0, 0, 0, 2860, 2861, 5, 278, 0, 0, 2861, 2878, 3, 416, 208, 0, 2862, 2863, 5, 211, 0, 0, 2863, 2878, 3, 382, 191, 0, 2864, 2865, 7, 32, 0, 0, 2865, 2878, 3, 652, 326, 0, 2866, 2867, 5, 41, 0, 0, 2867, 2868, 5, 2, 0, 0, 2868, 2869, 3, 652, 326, 0, 2869, 2870, 5, 36, 0, 0, 2870, 2871, 3, 652, 326, 0, 2871, 2872, 5, 3, 0, 0, 2872, 2878, 1, 0, 0, 0, 2873, 2874, 5, 136, 0, 0, 2874, 2878, 3, 394, 197, 0, 2875, 2878, 3, 312, 156, 0, 2876, 2878, 3, 310, 155, 0, 2877, 2845, 1, 0, 0, 0, 2877, 2851, 1, 0, 0, 0, 2877, 2853, 1, 0, 0, 0, 2877, 2855, 1, 0, 0, 0, 2877, 2860, 1, 0, 0, 0, 2877, 2862, 1, 0, 0, 0, 2877, 2864, 1, 0, 0, 0, 2877, 2866, 1, 0, 0, 0, 2877, 2873, 1, 0, 0, 0, 2877, 2875, 1, 0, 0, 0, 2877, 2876, 1, 0, 0, 0, 2878, 213, 1, 0, 0, 0, 2879, 2880, 5, 46, 0, 0, 2880, 2881, 5, 63, 0, 0, 2881, 2882, 5, 174, 0, 0, 2882, 2883, 5, 381, 0, 0, 2883, 2889, 3, 818, 409, 0, 2884, 2886, 3, 216, 108, 0, 2885, 2884, 1, 0, 0, 0, 2886, 2887, 1, 0, 0, 0, 2887, 2885, 1, 0, 0, 0, 2887, 2888, 1, 0, 0, 0, 2888, 2890, 1, 0, 0, 0, 2889, 2885, 1, 0, 0, 0, 2889, 2890, 1, 0, 0, 0, 2890, 2892, 1, 0, 0, 0, 2891, 2893, 3, 220, 110, 0, 2892, 2891, 1, 0, 0, 0, 2892, 2893, 1, 0, 0, 0, 2893, 215, 1, 0, 0, 0, 2894, 2896, 7, 33, 0, 0, 2895, 2897, 3, 316, 158, 0, 2896, 2895, 1, 0, 0, 0, 2896, 2897, 1, 0, 0, 0, 2897, 2901, 1, 0, 0, 0, 2898, 2899, 5, 269, 0, 0, 2899, 2901, 7, 33, 0, 0, 2900, 2894, 1, 0, 0, 0, 2900, 2898, 1, 0, 0, 0, 2901, 217, 1, 0, 0, 0, 2902, 2903, 5, 138, 0, 0, 2903, 2904, 5, 63, 0, 0, 2904, 2905, 5, 174, 0, 0, 2905, 2906, 5, 381, 0, 0, 2906, 2920, 3, 818, 409, 0, 2907, 2909, 3, 216, 108, 0, 2908, 2907, 1, 0, 0, 0, 2909, 2910, 1, 0, 0, 0, 2910, 2908, 1, 0, 0, 0, 2910, 2911, 1, 0, 0, 0, 2911, 2913, 1, 0, 0, 0, 2912, 2908, 1, 0, 0, 0, 2912, 2913, 1, 0, 0, 0, 2913, 2914, 1, 0, 0, 0, 2914, 2921, 3, 222, 111, 0, 2915, 2917, 3, 216, 108, 0, 2916, 2915, 1, 0, 0, 0, 2917, 2918, 1, 0, 0, 0, 2918, 2916, 1, 0, 0, 0, 2918, 2919, 1, 0, 0, 0, 2919, 2921, 1, 0, 0, 0, 2920, 2912, 1, 0, 0, 0, 2920, 2916, 1, 0, 0, 0, 2921, 219, 1, 0, 0, 0, 2922, 2923, 5, 280, 0, 0, 2923, 2924, 5, 2, 0, 0, 2924, 2929, 3, 226, 113, 0, 2925, 2926, 5, 6, 0, 0, 2926, 2928, 3, 226, 113, 0, 2927, 2925, 1, 0, 0, 0, 2928, 2931, 1, 0, 0, 0, 2929, 2927, 1, 0, 0, 0, 2929, 2930, 1, 0, 0, 0, 2930, 2932, 1, 0, 0, 0, 2931, 2929, 1, 0, 0, 0, 2932, 2933, 5, 3, 0, 0, 2933, 221, 1, 0, 0, 0, 2934, 2935, 5, 280, 0, 0, 2935, 2936, 5, 2, 0, 0, 2936, 2941, 3, 224, 112, 0, 2937, 2938, 5, 6, 0, 0, 2938, 2940, 3, 224, 112, 0, 2939, 2937, 1, 0, 0, 0, 2940, 2943, 1, 0, 0, 0, 2941, 2939, 1, 0, 0, 0, 2941, 2942, 1, 0, 0, 0, 2942, 2944, 1, 0, 0, 0, 2943, 2941, 1, 0, 0, 0, 2944, 2945, 5, 3, 0, 0, 2945, 223, 1, 0, 0, 0, 2946, 2947, 7, 34, 0, 0, 2947, 2948, 3, 226, 113, 0, 2948, 225, 1, 0, 0, 0, 2949, 2950, 3, 824, 412, 0, 2950, 2951, 3, 808, 404, 0, 2951, 227, 1, 0, 0, 0, 2952, 2953, 5, 46, 0, 0, 2953, 2955, 5, 331, 0, 0, 2954, 2956, 3, 294, 147, 0, 2955, 2954, 1, 0, 0, 0, 2955, 2956, 1, 0, 0, 0, 2956, 2957, 1, 0, 0, 0, 2957, 2960, 3, 818, 409, 0, 2958, 2959, 5, 360, 0, 0, 2959, 2961, 3, 808, 404, 0, 2960, 2958, 1, 0, 0, 0, 2960, 2961, 1, 0, 0, 0, 2961, 2963, 1, 0, 0, 0, 2962, 2964, 3, 230, 115, 0, 2963, 2962, 1, 0, 0, 0, 2963, 2964, 1, 0, 0, 0, 2964, 2965, 1, 0, 0, 0, 2965, 2966, 5, 63, 0, 0, 2966, 2967, 5, 174, 0, 0, 2967, 2968, 5, 381, 0, 0, 2968, 2970, 3, 818, 409, 0, 2969, 2971, 3, 220, 110, 0, 2970, 2969, 1, 0, 0, 0, 2970, 2971, 1, 0, 0, 0, 2971, 229, 1, 0, 0, 0, 2972, 2975, 5, 375, 0, 0, 2973, 2976, 3, 808, 404, 0, 2974, 2976, 5, 78, 0, 0, 2975, 2973, 1, 0, 0, 0, 2975, 2974, 1, 0, 0, 0, 2976, 231, 1, 0, 0, 0, 2977, 2978, 5, 138, 0, 0, 2978, 2979, 5, 331, 0, 0, 2979, 2985, 3, 818, 409, 0, 2980, 2986, 3, 222, 111, 0, 2981, 2983, 3, 230, 115, 0, 2982, 2984, 3, 222, 111, 0, 2983, 2982, 1, 0, 0, 0, 2983, 2984, 1, 0, 0, 0, 2984, 2986, 1, 0, 0, 0, 2985, 2980, 1, 0, 0, 0, 2985, 2981, 1, 0, 0, 0, 2986, 233, 1, 0, 0, 0, 2987, 2988, 5, 46, 0, 0, 2988, 2989, 5, 63, 0, 0, 2989, 2991, 5, 92, 0, 0, 2990, 2992, 3, 294, 147, 0, 2991, 2990, 1, 0, 0, 0, 2991, 2992, 1, 0, 0, 0, 2992, 2993, 1, 0, 0, 0, 2993, 2994, 3, 772, 386, 0, 2994, 2996, 5, 2, 0, 0, 2995, 2997, 3, 126, 63, 0, 2996, 2995, 1, 0, 0, 0, 2996, 2997, 1, 0, 0, 0, 2997, 2998, 1, 0, 0, 0, 2998, 3000, 5, 3, 0, 0, 2999, 3001, 3, 164, 82, 0, 3000, 2999, 1, 0, 0, 0, 3000, 3001, 1, 0, 0, 0, 3001, 3002, 1, 0, 0, 0, 3002, 3003, 5, 331, 0, 0, 3003, 3005, 3, 818, 409, 0, 3004, 3006, 3, 220, 110, 0, 3005, 3004, 1, 0, 0, 0, 3005, 3006, 1, 0, 0, 0, 3006, 3027, 1, 0, 0, 0, 3007, 3008, 5, 46, 0, 0, 3008, 3009, 5, 63, 0, 0, 3009, 3011, 5, 92, 0, 0, 3010, 3012, 3, 294, 147, 0, 3011, 3010, 1, 0, 0, 0, 3011, 3012, 1, 0, 0, 0, 3012, 3013, 1, 0, 0, 0, 3013, 3014, 3, 772, 386, 0, 3014, 3015, 5, 285, 0, 0, 3015, 3016, 5, 275, 0, 0, 3016, 3018, 3, 774, 387, 0, 3017, 3019, 3, 124, 62, 0, 3018, 3017, 1, 0, 0, 0, 3018, 3019, 1, 0, 0, 0, 3019, 3020, 1, 0, 0, 0, 3020, 3021, 3, 106, 53, 0, 3021, 3022, 5, 331, 0, 0, 3022, 3024, 3, 818, 409, 0, 3023, 3025, 3, 220, 110, 0, 3024, 3023, 1, 0, 0, 0, 3024, 3025, 1, 0, 0, 0, 3025, 3027, 1, 0, 0, 0, 3026, 2987, 1, 0, 0, 0, 3026, 3007, 1, 0, 0, 0, 3027, 235, 1, 0, 0, 0, 3028, 3029, 5, 444, 0, 0, 3029, 3030, 5, 63, 0, 0, 3030, 3031, 5, 323, 0, 0, 3031, 3041, 3, 790, 395, 0, 3032, 3033, 5, 74, 0, 0, 3033, 3036, 5, 94, 0, 0, 3034, 3036, 5, 59, 0, 0, 3035, 3032, 1, 0, 0, 0, 3035, 3034, 1, 0, 0, 0, 3036, 3037, 1, 0, 0, 0, 3037, 3038, 5, 2, 0, 0, 3038, 3039, 3, 628, 314, 0, 3039, 3040, 5, 3, 0, 0, 3040, 3042, 1, 0, 0, 0, 3041, 3035, 1, 0, 0, 0, 3041, 3042, 1, 0, 0, 0, 3042, 3043, 1, 0, 0, 0, 3043, 3044, 5, 64, 0, 0, 3044, 3045, 5, 331, 0, 0, 3045, 3046, 3, 818, 409, 0, 3046, 3047, 5, 71, 0, 0, 3047, 3049, 3, 818, 409, 0, 3048, 3050, 3, 220, 110, 0, 3049, 3048, 1, 0, 0, 0, 3049, 3050, 1, 0, 0, 0, 3050, 237, 1, 0, 0, 0, 3051, 3052, 5, 46, 0, 0, 3052, 3053, 5, 99, 0, 0, 3053, 3055, 5, 257, 0, 0, 3054, 3056, 3, 294, 147, 0, 3055, 3054, 1, 0, 0, 0, 3055, 3056, 1, 0, 0, 0, 3056, 3057, 1, 0, 0, 0, 3057, 3060, 5, 62, 0, 0, 3058, 3061, 3, 814, 407, 0, 3059, 3061, 5, 99, 0, 0, 3060, 3058, 1, 0, 0, 0, 3060, 3059, 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 3063, 5, 331, 0, 0, 3063, 3065, 3, 818, 409, 0, 3064, 3066, 3, 220, 110, 0, 3065, 3064, 1, 0, 0, 0, 3065, 3066, 1, 0, 0, 0, 3066, 239, 1, 0, 0, 0, 3067, 3068, 5, 138, 0, 0, 3068, 3069, 5, 99, 0, 0, 3069, 3070, 5, 257, 0, 0, 3070, 3073, 5, 62, 0, 0, 3071, 3074, 3, 814, 407, 0, 3072, 3074, 5, 99, 0, 0, 3073, 3071, 1, 0, 0, 0, 3073, 3072, 1, 0, 0, 0, 3074, 3075, 1, 0, 0, 0, 3075, 3076, 5, 331, 0, 0, 3076, 3077, 3, 818, 409, 0, 3077, 3078, 3, 222, 111, 0, 3078, 241, 1, 0, 0, 0, 3079, 3080, 5, 46, 0, 0, 3080, 3081, 5, 445, 0, 0, 3081, 3082, 3, 818, 409, 0, 3082, 3083, 5, 80, 0, 0, 3083, 3090, 3, 780, 390, 0, 3084, 3088, 5, 36, 0, 0, 3085, 3089, 5, 541, 0, 0, 3086, 3089, 5, 542, 0, 0, 3087, 3089, 3, 826, 413, 0, 3088, 3085, 1, 0, 0, 0, 3088, 3086, 1, 0, 0, 0, 3088, 3087, 1, 0, 0, 0, 3089, 3091, 1, 0, 0, 0, 3090, 3084, 1, 0, 0, 0, 3090, 3091, 1, 0, 0, 0, 3091, 3094, 1, 0, 0, 0, 3092, 3093, 5, 62, 0, 0, 3093, 3095, 7, 35, 0, 0, 3094, 3092, 1, 0, 0, 0, 3094, 3095, 1, 0, 0, 0, 3095, 3098, 1, 0, 0, 0, 3096, 3097, 5, 94, 0, 0, 3097, 3099, 3, 816, 408, 0, 3098, 3096, 1, 0, 0, 0, 3098, 3099, 1, 0, 0, 0, 3099, 3101, 1, 0, 0, 0, 3100, 3102, 3, 250, 125, 0, 3101, 3100, 1, 0, 0, 0, 3101, 3102, 1, 0, 0, 0, 3102, 3104, 1, 0, 0, 0, 3103, 3105, 3, 252, 126, 0, 3104, 3103, 1, 0, 0, 0, 3104, 3105, 1, 0, 0, 0, 3105, 243, 1, 0, 0, 0, 3106, 3107, 5, 138, 0, 0, 3107, 3108, 5, 445, 0, 0, 3108, 3109, 3, 818, 409, 0, 3109, 3110, 5, 80, 0, 0, 3110, 3113, 3, 780, 390, 0, 3111, 3112, 5, 94, 0, 0, 3112, 3114, 3, 816, 408, 0, 3113, 3111, 1, 0, 0, 0, 3113, 3114, 1, 0, 0, 0, 3114, 3116, 1, 0, 0, 0, 3115, 3117, 3, 250, 125, 0, 3116, 3115, 1, 0, 0, 0, 3116, 3117, 1, 0, 0, 0, 3117, 3119, 1, 0, 0, 0, 3118, 3120, 3, 252, 126, 0, 3119, 3118, 1, 0, 0, 0, 3119, 3120, 1, 0, 0, 0, 3120, 245, 1, 0, 0, 0, 3121, 3122, 5, 138, 0, 0, 3122, 3123, 5, 296, 0, 0, 3123, 3125, 3, 796, 398, 0, 3124, 3126, 3, 368, 184, 0, 3125, 3124, 1, 0, 0, 0, 3125, 3126, 1, 0, 0, 0, 3126, 3153, 1, 0, 0, 0, 3127, 3131, 3, 248, 124, 0, 3128, 3130, 3, 248, 124, 0, 3129, 3128, 1, 0, 0, 0, 3130, 3133, 1, 0, 0, 0, 3131, 3129, 1, 0, 0, 0, 3131, 3132, 1, 0, 0, 0, 3132, 3135, 1, 0, 0, 0, 3133, 3131, 1, 0, 0, 0, 3134, 3136, 5, 315, 0, 0, 3135, 3134, 1, 0, 0, 0, 3135, 3136, 1, 0, 0, 0, 3136, 3154, 1, 0, 0, 0, 3137, 3138, 5, 309, 0, 0, 3138, 3139, 5, 94, 0, 0, 3139, 3154, 3, 798, 399, 0, 3140, 3141, 5, 282, 0, 0, 3141, 3142, 5, 94, 0, 0, 3142, 3154, 3, 814, 407, 0, 3143, 3144, 5, 333, 0, 0, 3144, 3145, 5, 323, 0, 0, 3145, 3154, 3, 32, 16, 0, 3146, 3148, 5, 269, 0, 0, 3147, 3146, 1, 0, 0, 0, 3147, 3148, 1, 0, 0, 0, 3148, 3149, 1, 0, 0, 0, 3149, 3150, 5, 462, 0, 0, 3150, 3151, 5, 80, 0, 0, 3151, 3152, 5, 204, 0, 0, 3152, 3154, 3, 818, 409, 0, 3153, 3127, 1, 0, 0, 0, 3153, 3137, 1, 0, 0, 0, 3153, 3140, 1, 0, 0, 0, 3153, 3143, 1, 0, 0, 0, 3153, 3147, 1, 0, 0, 0, 3154, 247, 1, 0, 0, 0, 3155, 3157, 5, 205, 0, 0, 3156, 3155, 1, 0, 0, 0, 3156, 3157, 1, 0, 0, 0, 3157, 3158, 1, 0, 0, 0, 3158, 3159, 5, 327, 0, 0, 3159, 3166, 5, 243, 0, 0, 3160, 3162, 5, 205, 0, 0, 3161, 3160, 1, 0, 0, 0, 3161, 3162, 1, 0, 0, 0, 3162, 3163, 1, 0, 0, 0, 3163, 3164, 5, 327, 0, 0, 3164, 3166, 5, 181, 0, 0, 3165, 3156, 1, 0, 0, 0, 3165, 3161, 1, 0, 0, 0, 3166, 3185, 1, 0, 0, 0, 3167, 3168, 5, 333, 0, 0, 3168, 3169, 3, 818, 409, 0, 3169, 3172, 7, 36, 0, 0, 3170, 3173, 3, 818, 409, 0, 3171, 3173, 5, 53, 0, 0, 3172, 3170, 1, 0, 0, 0, 3172, 3171, 1, 0, 0, 0, 3173, 3185, 1, 0, 0, 0, 3174, 3175, 5, 333, 0, 0, 3175, 3176, 3, 818, 409, 0, 3176, 3177, 5, 64, 0, 0, 3177, 3178, 5, 434, 0, 0, 3178, 3185, 1, 0, 0, 0, 3179, 3182, 5, 313, 0, 0, 3180, 3183, 3, 818, 409, 0, 3181, 3183, 5, 30, 0, 0, 3182, 3180, 1, 0, 0, 0, 3182, 3181, 1, 0, 0, 0, 3183, 3185, 1, 0, 0, 0, 3184, 3165, 1, 0, 0, 0, 3184, 3167, 1, 0, 0, 0, 3184, 3174, 1, 0, 0, 0, 3184, 3179, 1, 0, 0, 0, 3185, 249, 1, 0, 0, 0, 3186, 3187, 5, 100, 0, 0, 3187, 3188, 5, 2, 0, 0, 3188, 3189, 3, 674, 337, 0, 3189, 3190, 5, 3, 0, 0, 3190, 251, 1, 0, 0, 0, 3191, 3192, 5, 105, 0, 0, 3192, 3193, 5, 42, 0, 0, 3193, 3194, 5, 2, 0, 0, 3194, 3195, 3, 674, 337, 0, 3195, 3196, 5, 3, 0, 0, 3196, 253, 1, 0, 0, 0, 3197, 3198, 5, 46, 0, 0, 3198, 3199, 5, 131, 0, 0, 3199, 3200, 5, 446, 0, 0, 3200, 3201, 3, 818, 409, 0, 3201, 3202, 5, 360, 0, 0, 3202, 3203, 7, 37, 0, 0, 3203, 3204, 5, 215, 0, 0, 3204, 3205, 3, 316, 158, 0, 3205, 255, 1, 0, 0, 0, 3206, 3208, 5, 46, 0, 0, 3207, 3209, 3, 366, 183, 0, 3208, 3207, 1, 0, 0, 0, 3208, 3209, 1, 0, 0, 0, 3209, 3210, 1, 0, 0, 0, 3210, 3211, 5, 357, 0, 0, 3211, 3212, 3, 818, 409, 0, 3212, 3213, 3, 258, 129, 0, 3213, 3214, 3, 260, 130, 0, 3214, 3215, 5, 80, 0, 0, 3215, 3227, 3, 774, 387, 0, 3216, 3223, 5, 447, 0, 0, 3217, 3218, 7, 38, 0, 0, 3218, 3220, 7, 39, 0, 0, 3219, 3221, 5, 36, 0, 0, 3220, 3219, 1, 0, 0, 0, 3220, 3221, 1, 0, 0, 0, 3221, 3222, 1, 0, 0, 0, 3222, 3224, 3, 818, 409, 0, 3223, 3217, 1, 0, 0, 0, 3224, 3225, 1, 0, 0, 0, 3225, 3223, 1, 0, 0, 0, 3225, 3226, 1, 0, 0, 0, 3226, 3228, 1, 0, 0, 0, 3227, 3216, 1, 0, 0, 0, 3227, 3228, 1, 0, 0, 0, 3228, 3234, 1, 0, 0, 0, 3229, 3231, 5, 62, 0, 0, 3230, 3232, 5, 192, 0, 0, 3231, 3230, 1, 0, 0, 0, 3231, 3232, 1, 0, 0, 0, 3232, 3233, 1, 0, 0, 0, 3233, 3235, 7, 40, 0, 0, 3234, 3229, 1, 0, 0, 0, 3234, 3235, 1, 0, 0, 0, 3235, 3237, 1, 0, 0, 0, 3236, 3238, 3, 264, 132, 0, 3237, 3236, 1, 0, 0, 0, 3237, 3238, 1, 0, 0, 0, 3238, 3239, 1, 0, 0, 0, 3239, 3240, 5, 202, 0, 0, 3240, 3241, 3, 266, 133, 0, 3241, 3242, 5, 2, 0, 0, 3242, 3243, 3, 268, 134, 0, 3243, 3244, 5, 3, 0, 0, 3244, 3285, 1, 0, 0, 0, 3245, 3247, 5, 46, 0, 0, 3246, 3248, 3, 366, 183, 0, 3247, 3246, 1, 0, 0, 0, 3247, 3248, 1, 0, 0, 0, 3248, 3250, 1, 0, 0, 0, 3249, 3251, 5, 45, 0, 0, 3250, 3249, 1, 0, 0, 0, 3250, 3251, 1, 0, 0, 0, 3251, 3252, 1, 0, 0, 0, 3252, 3253, 5, 357, 0, 0, 3253, 3254, 3, 818, 409, 0, 3254, 3255, 3, 258, 129, 0, 3255, 3256, 3, 260, 130, 0, 3256, 3257, 5, 80, 0, 0, 3257, 3260, 3, 774, 387, 0, 3258, 3259, 5, 64, 0, 0, 3259, 3261, 3, 780, 390, 0, 3260, 3258, 1, 0, 0, 0, 3260, 3261, 1, 0, 0, 0, 3261, 3265, 1, 0, 0, 0, 3262, 3264, 3, 272, 136, 0, 3263, 3262, 1, 0, 0, 0, 3264, 3267, 1, 0, 0, 0, 3265, 3263, 1, 0, 0, 0, 3265, 3266, 1, 0, 0, 0, 3266, 3273, 1, 0, 0, 0, 3267, 3265, 1, 0, 0, 0, 3268, 3270, 5, 62, 0, 0, 3269, 3271, 5, 192, 0, 0, 3270, 3269, 1, 0, 0, 0, 3270, 3271, 1, 0, 0, 0, 3271, 3272, 1, 0, 0, 0, 3272, 3274, 7, 40, 0, 0, 3273, 3268, 1, 0, 0, 0, 3273, 3274, 1, 0, 0, 0, 3274, 3276, 1, 0, 0, 0, 3275, 3277, 3, 264, 132, 0, 3276, 3275, 1, 0, 0, 0, 3276, 3277, 1, 0, 0, 0, 3277, 3278, 1, 0, 0, 0, 3278, 3279, 5, 202, 0, 0, 3279, 3280, 3, 266, 133, 0, 3280, 3281, 5, 2, 0, 0, 3281, 3282, 3, 268, 134, 0, 3282, 3283, 5, 3, 0, 0, 3283, 3285, 1, 0, 0, 0, 3284, 3206, 1, 0, 0, 0, 3284, 3245, 1, 0, 0, 0, 3285, 257, 1, 0, 0, 0, 3286, 3291, 5, 145, 0, 0, 3287, 3291, 5, 135, 0, 0, 3288, 3289, 5, 242, 0, 0, 3289, 3291, 5, 275, 0, 0, 3290, 3286, 1, 0, 0, 0, 3290, 3287, 1, 0, 0, 0, 3290, 3288, 1, 0, 0, 0, 3291, 259, 1, 0, 0, 0, 3292, 3297, 3, 262, 131, 0, 3293, 3294, 5, 82, 0, 0, 3294, 3296, 3, 262, 131, 0, 3295, 3293, 1, 0, 0, 0, 3296, 3299, 1, 0, 0, 0, 3297, 3295, 1, 0, 0, 0, 3297, 3298, 1, 0, 0, 0, 3298, 261, 1, 0, 0, 0, 3299, 3297, 1, 0, 0, 0, 3300, 3309, 5, 241, 0, 0, 3301, 3309, 5, 182, 0, 0, 3302, 3305, 5, 369, 0, 0, 3303, 3304, 5, 275, 0, 0, 3304, 3306, 3, 148, 74, 0, 3305, 3303, 1, 0, 0, 0, 3305, 3306, 1, 0, 0, 0, 3306, 3309, 1, 0, 0, 0, 3307, 3309, 5, 358, 0, 0, 3308, 3300, 1, 0, 0, 0, 3308, 3301, 1, 0, 0, 0, 3308, 3302, 1, 0, 0, 0, 3308, 3307, 1, 0, 0, 0, 3309, 263, 1, 0, 0, 0, 3310, 3311, 5, 102, 0, 0, 3311, 3312, 5, 2, 0, 0, 3312, 3313, 3, 674, 337, 0, 3313, 3314, 5, 3, 0, 0, 3314, 265, 1, 0, 0, 0, 3315, 3316, 5, 211, 0, 0, 3316, 3320, 3, 806, 403, 0, 3317, 3318, 5, 296, 0, 0, 3318, 3320, 3, 796, 398, 0, 3319, 3315, 1, 0, 0, 0, 3319, 3317, 1, 0, 0, 0, 3320, 267, 1, 0, 0, 0, 3321, 3324, 3, 270, 135, 0, 3322, 3324, 1, 0, 0, 0, 3323, 3321, 1, 0, 0, 0, 3323, 3322, 1, 0, 0, 0, 3324, 3329, 1, 0, 0, 0, 3325, 3326, 5, 6, 0, 0, 3326, 3328, 3, 270, 135, 0, 3327, 3325, 1, 0, 0, 0, 3328, 3331, 1, 0, 0, 0, 3329, 3327, 1, 0, 0, 0, 3329, 3330, 1, 0, 0, 0, 3330, 269, 1, 0, 0, 0, 3331, 3329, 1, 0, 0, 0, 3332, 3337, 5, 571, 0, 0, 3333, 3337, 5, 573, 0, 0, 3334, 3337, 3, 808, 404, 0, 3335, 3337, 3, 824, 412, 0, 3336, 3332, 1, 0, 0, 0, 3336, 3333, 1, 0, 0, 0, 3336, 3334, 1, 0, 0, 0, 3336, 3335, 1, 0, 0, 0, 3337, 271, 1, 0, 0, 0, 3338, 3340, 5, 77, 0, 0, 3339, 3338, 1, 0, 0, 0, 3339, 3340, 1, 0, 0, 0, 3340, 3341, 1, 0, 0, 0, 3341, 3349, 5, 54, 0, 0, 3342, 3343, 5, 69, 0, 0, 3343, 3349, 7, 9, 0, 0, 3344, 3345, 5, 77, 0, 0, 3345, 3349, 5, 371, 0, 0, 3346, 3347, 5, 269, 0, 0, 3347, 3349, 5, 228, 0, 0, 3348, 3339, 1, 0, 0, 0, 3348, 3342, 1, 0, 0, 0, 3348, 3344, 1, 0, 0, 0, 3348, 3346, 1, 0, 0, 0, 3349, 273, 1, 0, 0, 0, 3350, 3351, 5, 46, 0, 0, 3351, 3352, 5, 198, 0, 0, 3352, 3353, 5, 357, 0, 0, 3353, 3354, 3, 818, 409, 0, 3354, 3355, 5, 80, 0, 0, 3355, 3365, 3, 824, 412, 0, 3356, 3357, 5, 102, 0, 0, 3357, 3362, 3, 276, 138, 0, 3358, 3359, 5, 33, 0, 0, 3359, 3361, 3, 276, 138, 0, 3360, 3358, 1, 0, 0, 0, 3361, 3364, 1, 0, 0, 0, 3362, 3360, 1, 0, 0, 0, 3362, 3363, 1, 0, 0, 0, 3363, 3366, 1, 0, 0, 0, 3364, 3362, 1, 0, 0, 0, 3365, 3356, 1, 0, 0, 0, 3365, 3366, 1, 0, 0, 0, 3366, 3367, 1, 0, 0, 0, 3367, 3368, 5, 202, 0, 0, 3368, 3369, 3, 266, 133, 0, 3369, 3370, 5, 2, 0, 0, 3370, 3371, 5, 3, 0, 0, 3371, 275, 1, 0, 0, 0, 3372, 3373, 3, 818, 409, 0, 3373, 3374, 5, 68, 0, 0, 3374, 3375, 5, 2, 0, 0, 3375, 3379, 3, 808, 404, 0, 3376, 3378, 3, 462, 231, 0, 3377, 3376, 1, 0, 0, 0, 3378, 3381, 1, 0, 0, 0, 3379, 3377, 1, 0, 0, 0, 3379, 3380, 1, 0, 0, 0, 3380, 3382, 1, 0, 0, 0, 3381, 3379, 1, 0, 0, 0, 3382, 3383, 5, 3, 0, 0, 3383, 277, 1, 0, 0, 0, 3384, 3385, 5, 138, 0, 0, 3385, 3386, 5, 198, 0, 0, 3386, 3387, 5, 357, 0, 0, 3387, 3393, 3, 818, 409, 0, 3388, 3390, 5, 193, 0, 0, 3389, 3391, 7, 14, 0, 0, 3390, 3389, 1, 0, 0, 0, 3390, 3391, 1, 0, 0, 0, 3391, 3394, 1, 0, 0, 0, 3392, 3394, 5, 186, 0, 0, 3393, 3388, 1, 0, 0, 0, 3393, 3392, 1, 0, 0, 0, 3394, 279, 1, 0, 0, 0, 3395, 3396, 5, 46, 0, 0, 3396, 3397, 5, 140, 0, 0, 3397, 3398, 3, 316, 158, 0, 3398, 3399, 5, 42, 0, 0, 3399, 3400, 5, 2, 0, 0, 3400, 3401, 3, 674, 337, 0, 3401, 3405, 5, 3, 0, 0, 3402, 3404, 3, 272, 136, 0, 3403, 3402, 1, 0, 0, 0, 3404, 3407, 1, 0, 0, 0, 3405, 3403, 1, 0, 0, 0, 3405, 3406, 1, 0, 0, 0, 3406, 281, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3408, 3410, 5, 46, 0, 0, 3409, 3411, 3, 366, 183, 0, 3410, 3409, 1, 0, 0, 0, 3410, 3411, 1, 0, 0, 0, 3411, 3412, 1, 0, 0, 0, 3412, 3413, 5, 136, 0, 0, 3413, 3428, 3, 806, 403, 0, 3414, 3415, 3, 392, 196, 0, 3415, 3416, 3, 284, 142, 0, 3416, 3429, 1, 0, 0, 0, 3417, 3418, 5, 2, 0, 0, 3418, 3423, 3, 290, 145, 0, 3419, 3420, 5, 6, 0, 0, 3420, 3422, 3, 290, 145, 0, 3421, 3419, 1, 0, 0, 0, 3422, 3425, 1, 0, 0, 0, 3423, 3421, 1, 0, 0, 0, 3423, 3424, 1, 0, 0, 0, 3424, 3426, 1, 0, 0, 0, 3425, 3423, 1, 0, 0, 0, 3426, 3427, 5, 3, 0, 0, 3427, 3429, 1, 0, 0, 0, 3428, 3414, 1, 0, 0, 0, 3428, 3417, 1, 0, 0, 0, 3429, 3487, 1, 0, 0, 0, 3430, 3431, 5, 46, 0, 0, 3431, 3432, 5, 278, 0, 0, 3432, 3433, 3, 414, 207, 0, 3433, 3434, 3, 284, 142, 0, 3434, 3487, 1, 0, 0, 0, 3435, 3436, 5, 46, 0, 0, 3436, 3437, 5, 360, 0, 0, 3437, 3438, 3, 316, 158, 0, 3438, 3456, 5, 36, 0, 0, 3439, 3441, 5, 2, 0, 0, 3440, 3442, 3, 642, 321, 0, 3441, 3440, 1, 0, 0, 0, 3441, 3442, 1, 0, 0, 0, 3442, 3443, 1, 0, 0, 0, 3443, 3457, 5, 3, 0, 0, 3444, 3445, 5, 196, 0, 0, 3445, 3453, 5, 2, 0, 0, 3446, 3450, 3, 808, 404, 0, 3447, 3449, 3, 462, 231, 0, 3448, 3447, 1, 0, 0, 0, 3449, 3452, 1, 0, 0, 0, 3450, 3448, 1, 0, 0, 0, 3450, 3451, 1, 0, 0, 0, 3451, 3454, 1, 0, 0, 0, 3452, 3450, 1, 0, 0, 0, 3453, 3446, 1, 0, 0, 0, 3453, 3454, 1, 0, 0, 0, 3454, 3455, 1, 0, 0, 0, 3455, 3457, 5, 3, 0, 0, 3456, 3439, 1, 0, 0, 0, 3456, 3444, 1, 0, 0, 0, 3457, 3487, 1, 0, 0, 0, 3458, 3459, 5, 46, 0, 0, 3459, 3460, 5, 360, 0, 0, 3460, 3466, 3, 316, 158, 0, 3461, 3462, 5, 36, 0, 0, 3462, 3464, 5, 299, 0, 0, 3463, 3461, 1, 0, 0, 0, 3463, 3464, 1, 0, 0, 0, 3464, 3465, 1, 0, 0, 0, 3465, 3467, 3, 284, 142, 0, 3466, 3463, 1, 0, 0, 0, 3466, 3467, 1, 0, 0, 0, 3467, 3487, 1, 0, 0, 0, 3468, 3469, 5, 46, 0, 0, 3469, 3470, 5, 355, 0, 0, 3470, 3471, 5, 325, 0, 0, 3471, 3472, 7, 41, 0, 0, 3472, 3473, 3, 316, 158, 0, 3473, 3474, 3, 284, 142, 0, 3474, 3487, 1, 0, 0, 0, 3475, 3476, 5, 46, 0, 0, 3476, 3478, 5, 108, 0, 0, 3477, 3479, 3, 294, 147, 0, 3478, 3477, 1, 0, 0, 0, 3478, 3479, 1, 0, 0, 0, 3479, 3480, 1, 0, 0, 0, 3480, 3484, 3, 316, 158, 0, 3481, 3485, 3, 284, 142, 0, 3482, 3483, 5, 64, 0, 0, 3483, 3485, 3, 316, 158, 0, 3484, 3481, 1, 0, 0, 0, 3484, 3482, 1, 0, 0, 0, 3485, 3487, 1, 0, 0, 0, 3486, 3408, 1, 0, 0, 0, 3486, 3430, 1, 0, 0, 0, 3486, 3435, 1, 0, 0, 0, 3486, 3458, 1, 0, 0, 0, 3486, 3468, 1, 0, 0, 0, 3486, 3475, 1, 0, 0, 0, 3487, 283, 1, 0, 0, 0, 3488, 3489, 5, 2, 0, 0, 3489, 3494, 3, 286, 143, 0, 3490, 3491, 5, 6, 0, 0, 3491, 3493, 3, 286, 143, 0, 3492, 3490, 1, 0, 0, 0, 3493, 3496, 1, 0, 0, 0, 3494, 3492, 1, 0, 0, 0, 3494, 3495, 1, 0, 0, 0, 3495, 3497, 1, 0, 0, 0, 3496, 3494, 1, 0, 0, 0, 3497, 3498, 5, 3, 0, 0, 3498, 285, 1, 0, 0, 0, 3499, 3502, 3, 824, 412, 0, 3500, 3501, 5, 10, 0, 0, 3501, 3503, 3, 288, 144, 0, 3502, 3500, 1, 0, 0, 0, 3502, 3503, 1, 0, 0, 0, 3503, 287, 1, 0, 0, 0, 3504, 3511, 3, 388, 194, 0, 3505, 3511, 3, 834, 417, 0, 3506, 3511, 3, 726, 363, 0, 3507, 3511, 3, 202, 101, 0, 3508, 3511, 3, 808, 404, 0, 3509, 3511, 5, 407, 0, 0, 3510, 3504, 1, 0, 0, 0, 3510, 3505, 1, 0, 0, 0, 3510, 3506, 1, 0, 0, 0, 3510, 3507, 1, 0, 0, 0, 3510, 3508, 1, 0, 0, 0, 3510, 3509, 1, 0, 0, 0, 3511, 289, 1, 0, 0, 0, 3512, 3513, 3, 826, 413, 0, 3513, 3514, 5, 10, 0, 0, 3514, 3515, 3, 288, 144, 0, 3515, 291, 1, 0, 0, 0, 3516, 3517, 5, 138, 0, 0, 3517, 3518, 5, 360, 0, 0, 3518, 3519, 3, 316, 158, 0, 3519, 3520, 5, 133, 0, 0, 3520, 3522, 5, 450, 0, 0, 3521, 3523, 3, 294, 147, 0, 3522, 3521, 1, 0, 0, 0, 3522, 3523, 1, 0, 0, 0, 3523, 3524, 1, 0, 0, 0, 3524, 3527, 3, 808, 404, 0, 3525, 3526, 7, 42, 0, 0, 3526, 3528, 3, 808, 404, 0, 3527, 3525, 1, 0, 0, 0, 3527, 3528, 1, 0, 0, 0, 3528, 3539, 1, 0, 0, 0, 3529, 3530, 5, 138, 0, 0, 3530, 3531, 5, 360, 0, 0, 3531, 3532, 3, 316, 158, 0, 3532, 3533, 5, 309, 0, 0, 3533, 3534, 5, 450, 0, 0, 3534, 3535, 3, 808, 404, 0, 3535, 3536, 5, 94, 0, 0, 3536, 3537, 3, 808, 404, 0, 3537, 3539, 1, 0, 0, 0, 3538, 3516, 1, 0, 0, 0, 3538, 3529, 1, 0, 0, 0, 3539, 293, 1, 0, 0, 0, 3540, 3541, 5, 220, 0, 0, 3541, 3542, 5, 77, 0, 0, 3542, 3543, 5, 396, 0, 0, 3543, 295, 1, 0, 0, 0, 3544, 3545, 5, 46, 0, 0, 3545, 3546, 5, 278, 0, 0, 3546, 3547, 5, 156, 0, 0, 3547, 3549, 3, 316, 158, 0, 3548, 3550, 5, 53, 0, 0, 3549, 3548, 1, 0, 0, 0, 3549, 3550, 1, 0, 0, 0, 3550, 3551, 1, 0, 0, 0, 3551, 3552, 5, 62, 0, 0, 3552, 3553, 5, 360, 0, 0, 3553, 3554, 3, 652, 326, 0, 3554, 3557, 3, 170, 85, 0, 3555, 3556, 5, 206, 0, 0, 3556, 3558, 3, 316, 158, 0, 3557, 3555, 1, 0, 0, 0, 3557, 3558, 1, 0, 0, 0, 3558, 3559, 1, 0, 0, 0, 3559, 3560, 5, 36, 0, 0, 3560, 3565, 3, 298, 149, 0, 3561, 3562, 5, 6, 0, 0, 3562, 3564, 3, 298, 149, 0, 3563, 3561, 1, 0, 0, 0, 3564, 3567, 1, 0, 0, 0, 3565, 3563, 1, 0, 0, 0, 3565, 3566, 1, 0, 0, 0, 3566, 297, 1, 0, 0, 0, 3567, 3565, 1, 0, 0, 0, 3568, 3569, 5, 278, 0, 0, 3569, 3570, 5, 571, 0, 0, 3570, 3572, 3, 414, 207, 0, 3571, 3573, 3, 412, 206, 0, 3572, 3571, 1, 0, 0, 0, 3572, 3573, 1, 0, 0, 0, 3573, 3581, 1, 0, 0, 0, 3574, 3579, 5, 62, 0, 0, 3575, 3580, 5, 325, 0, 0, 3576, 3577, 5, 83, 0, 0, 3577, 3578, 5, 147, 0, 0, 3578, 3580, 3, 316, 158, 0, 3579, 3575, 1, 0, 0, 0, 3579, 3576, 1, 0, 0, 0, 3580, 3582, 1, 0, 0, 0, 3581, 3574, 1, 0, 0, 0, 3581, 3582, 1, 0, 0, 0, 3582, 3584, 1, 0, 0, 0, 3583, 3585, 5, 302, 0, 0, 3584, 3583, 1, 0, 0, 0, 3584, 3585, 1, 0, 0, 0, 3585, 3595, 1, 0, 0, 0, 3586, 3587, 5, 211, 0, 0, 3587, 3589, 5, 571, 0, 0, 3588, 3590, 3, 528, 264, 0, 3589, 3588, 1, 0, 0, 0, 3589, 3590, 1, 0, 0, 0, 3590, 3591, 1, 0, 0, 0, 3591, 3595, 3, 382, 191, 0, 3592, 3593, 5, 345, 0, 0, 3593, 3595, 3, 652, 326, 0, 3594, 3568, 1, 0, 0, 0, 3594, 3586, 1, 0, 0, 0, 3594, 3592, 1, 0, 0, 0, 3595, 299, 1, 0, 0, 0, 3596, 3597, 5, 46, 0, 0, 3597, 3598, 5, 278, 0, 0, 3598, 3599, 5, 206, 0, 0, 3599, 3600, 3, 316, 158, 0, 3600, 3601, 3, 170, 85, 0, 3601, 301, 1, 0, 0, 0, 3602, 3603, 5, 138, 0, 0, 3603, 3604, 5, 278, 0, 0, 3604, 3605, 5, 206, 0, 0, 3605, 3606, 3, 316, 158, 0, 3606, 3625, 3, 170, 85, 0, 3607, 3608, 5, 133, 0, 0, 3608, 3613, 3, 298, 149, 0, 3609, 3610, 5, 6, 0, 0, 3610, 3612, 3, 298, 149, 0, 3611, 3609, 1, 0, 0, 0, 3612, 3615, 1, 0, 0, 0, 3613, 3611, 1, 0, 0, 0, 3613, 3614, 1, 0, 0, 0, 3614, 3626, 1, 0, 0, 0, 3615, 3613, 1, 0, 0, 0, 3616, 3617, 5, 191, 0, 0, 3617, 3622, 3, 304, 152, 0, 3618, 3619, 5, 6, 0, 0, 3619, 3621, 3, 304, 152, 0, 3620, 3618, 1, 0, 0, 0, 3621, 3624, 1, 0, 0, 0, 3622, 3620, 1, 0, 0, 0, 3622, 3623, 1, 0, 0, 0, 3623, 3626, 1, 0, 0, 0, 3624, 3622, 1, 0, 0, 0, 3625, 3607, 1, 0, 0, 0, 3625, 3616, 1, 0, 0, 0, 3626, 303, 1, 0, 0, 0, 3627, 3628, 7, 43, 0, 0, 3628, 3629, 5, 571, 0, 0, 3629, 3630, 3, 528, 264, 0, 3630, 305, 1, 0, 0, 0, 3631, 3632, 5, 301, 0, 0, 3632, 3633, 5, 281, 0, 0, 3633, 3634, 5, 147, 0, 0, 3634, 3635, 3, 816, 408, 0, 3635, 3636, 5, 94, 0, 0, 3636, 3637, 3, 814, 407, 0, 3637, 307, 1, 0, 0, 0, 3638, 3661, 5, 191, 0, 0, 3639, 3662, 5, 328, 0, 0, 3640, 3662, 5, 226, 0, 0, 3641, 3662, 5, 108, 0, 0, 3642, 3662, 5, 168, 0, 0, 3643, 3662, 5, 342, 0, 0, 3644, 3662, 5, 452, 0, 0, 3645, 3662, 5, 331, 0, 0, 3646, 3647, 5, 131, 0, 0, 3647, 3662, 5, 446, 0, 0, 3648, 3649, 5, 198, 0, 0, 3649, 3662, 5, 357, 0, 0, 3650, 3662, 5, 204, 0, 0, 3651, 3653, 5, 295, 0, 0, 3652, 3651, 1, 0, 0, 0, 3652, 3653, 1, 0, 0, 0, 3653, 3654, 1, 0, 0, 0, 3654, 3662, 5, 247, 0, 0, 3655, 3656, 5, 63, 0, 0, 3656, 3657, 5, 174, 0, 0, 3657, 3662, 5, 381, 0, 0, 3658, 3659, 5, 355, 0, 0, 3659, 3660, 5, 325, 0, 0, 3660, 3662, 7, 41, 0, 0, 3661, 3639, 1, 0, 0, 0, 3661, 3640, 1, 0, 0, 0, 3661, 3641, 1, 0, 0, 0, 3661, 3642, 1, 0, 0, 0, 3661, 3643, 1, 0, 0, 0, 3661, 3644, 1, 0, 0, 0, 3661, 3645, 1, 0, 0, 0, 3661, 3646, 1, 0, 0, 0, 3661, 3648, 1, 0, 0, 0, 3661, 3650, 1, 0, 0, 0, 3661, 3652, 1, 0, 0, 0, 3661, 3655, 1, 0, 0, 0, 3661, 3658, 1, 0, 0, 0, 3662, 3664, 1, 0, 0, 0, 3663, 3665, 3, 422, 211, 0, 3664, 3663, 1, 0, 0, 0, 3664, 3665, 1, 0, 0, 0, 3665, 3666, 1, 0, 0, 0, 3666, 3668, 3, 784, 392, 0, 3667, 3669, 3, 96, 48, 0, 3668, 3667, 1, 0, 0, 0, 3668, 3669, 1, 0, 0, 0, 3669, 3846, 1, 0, 0, 0, 3670, 3672, 5, 191, 0, 0, 3671, 3673, 5, 259, 0, 0, 3672, 3671, 1, 0, 0, 0, 3672, 3673, 1, 0, 0, 0, 3673, 3674, 1, 0, 0, 0, 3674, 3676, 5, 376, 0, 0, 3675, 3677, 3, 422, 211, 0, 3676, 3675, 1, 0, 0, 0, 3676, 3677, 1, 0, 0, 0, 3677, 3678, 1, 0, 0, 0, 3678, 3683, 3, 778, 389, 0, 3679, 3680, 5, 6, 0, 0, 3680, 3682, 3, 778, 389, 0, 3681, 3679, 1, 0, 0, 0, 3682, 3685, 1, 0, 0, 0, 3683, 3681, 1, 0, 0, 0, 3683, 3684, 1, 0, 0, 0, 3684, 3687, 1, 0, 0, 0, 3685, 3683, 1, 0, 0, 0, 3686, 3688, 3, 96, 48, 0, 3687, 3686, 1, 0, 0, 0, 3687, 3688, 1, 0, 0, 0, 3688, 3846, 1, 0, 0, 0, 3689, 3691, 5, 191, 0, 0, 3690, 3692, 5, 63, 0, 0, 3691, 3690, 1, 0, 0, 0, 3691, 3692, 1, 0, 0, 0, 3692, 3693, 1, 0, 0, 0, 3693, 3695, 5, 92, 0, 0, 3694, 3696, 3, 422, 211, 0, 3695, 3694, 1, 0, 0, 0, 3695, 3696, 1, 0, 0, 0, 3696, 3697, 1, 0, 0, 0, 3697, 3699, 3, 762, 381, 0, 3698, 3700, 3, 96, 48, 0, 3699, 3698, 1, 0, 0, 0, 3699, 3700, 1, 0, 0, 0, 3700, 3846, 1, 0, 0, 0, 3701, 3702, 5, 191, 0, 0, 3702, 3704, 5, 323, 0, 0, 3703, 3705, 3, 422, 211, 0, 3704, 3703, 1, 0, 0, 0, 3704, 3705, 1, 0, 0, 0, 3705, 3706, 1, 0, 0, 0, 3706, 3708, 3, 764, 382, 0, 3707, 3709, 3, 96, 48, 0, 3708, 3707, 1, 0, 0, 0, 3708, 3709, 1, 0, 0, 0, 3709, 3846, 1, 0, 0, 0, 3710, 3711, 5, 191, 0, 0, 3711, 3713, 7, 44, 0, 0, 3712, 3714, 3, 422, 211, 0, 3713, 3712, 1, 0, 0, 0, 3713, 3714, 1, 0, 0, 0, 3714, 3715, 1, 0, 0, 0, 3715, 3716, 3, 818, 409, 0, 3716, 3717, 5, 80, 0, 0, 3717, 3719, 3, 316, 158, 0, 3718, 3720, 3, 96, 48, 0, 3719, 3718, 1, 0, 0, 0, 3719, 3720, 1, 0, 0, 0, 3720, 3846, 1, 0, 0, 0, 3721, 3722, 5, 191, 0, 0, 3722, 3724, 7, 32, 0, 0, 3723, 3725, 3, 422, 211, 0, 3724, 3723, 1, 0, 0, 0, 3724, 3725, 1, 0, 0, 0, 3725, 3726, 1, 0, 0, 0, 3726, 3731, 3, 652, 326, 0, 3727, 3728, 5, 6, 0, 0, 3728, 3730, 3, 652, 326, 0, 3729, 3727, 1, 0, 0, 0, 3730, 3733, 1, 0, 0, 0, 3731, 3729, 1, 0, 0, 0, 3731, 3732, 1, 0, 0, 0, 3732, 3735, 1, 0, 0, 0, 3733, 3731, 1, 0, 0, 0, 3734, 3736, 3, 96, 48, 0, 3735, 3734, 1, 0, 0, 0, 3735, 3736, 1, 0, 0, 0, 3736, 3846, 1, 0, 0, 0, 3737, 3738, 5, 191, 0, 0, 3738, 3739, 5, 226, 0, 0, 3739, 3741, 5, 109, 0, 0, 3740, 3742, 3, 422, 211, 0, 3741, 3740, 1, 0, 0, 0, 3741, 3742, 1, 0, 0, 0, 3742, 3743, 1, 0, 0, 0, 3743, 3745, 3, 314, 157, 0, 3744, 3746, 3, 96, 48, 0, 3745, 3744, 1, 0, 0, 0, 3745, 3746, 1, 0, 0, 0, 3746, 3846, 1, 0, 0, 0, 3747, 3748, 5, 191, 0, 0, 3748, 3750, 5, 41, 0, 0, 3749, 3751, 3, 422, 211, 0, 3750, 3749, 1, 0, 0, 0, 3750, 3751, 1, 0, 0, 0, 3751, 3752, 1, 0, 0, 0, 3752, 3753, 5, 2, 0, 0, 3753, 3754, 3, 652, 326, 0, 3754, 3755, 5, 36, 0, 0, 3755, 3756, 3, 652, 326, 0, 3756, 3758, 5, 3, 0, 0, 3757, 3759, 3, 96, 48, 0, 3758, 3757, 1, 0, 0, 0, 3758, 3759, 1, 0, 0, 0, 3759, 3846, 1, 0, 0, 0, 3760, 3761, 5, 191, 0, 0, 3761, 3762, 5, 278, 0, 0, 3762, 3764, 7, 31, 0, 0, 3763, 3765, 3, 422, 211, 0, 3764, 3763, 1, 0, 0, 0, 3764, 3765, 1, 0, 0, 0, 3765, 3766, 1, 0, 0, 0, 3766, 3767, 3, 316, 158, 0, 3767, 3769, 3, 170, 85, 0, 3768, 3770, 3, 96, 48, 0, 3769, 3768, 1, 0, 0, 0, 3769, 3770, 1, 0, 0, 0, 3770, 3846, 1, 0, 0, 0, 3771, 3772, 5, 191, 0, 0, 3772, 3773, 5, 281, 0, 0, 3773, 3774, 5, 147, 0, 0, 3774, 3776, 3, 816, 408, 0, 3775, 3777, 3, 96, 48, 0, 3776, 3775, 1, 0, 0, 0, 3776, 3777, 1, 0, 0, 0, 3777, 3846, 1, 0, 0, 0, 3778, 3779, 5, 191, 0, 0, 3779, 3781, 5, 451, 0, 0, 3780, 3782, 3, 422, 211, 0, 3781, 3780, 1, 0, 0, 0, 3781, 3782, 1, 0, 0, 0, 3782, 3783, 1, 0, 0, 0, 3783, 3785, 3, 818, 409, 0, 3784, 3786, 3, 96, 48, 0, 3785, 3784, 1, 0, 0, 0, 3785, 3786, 1, 0, 0, 0, 3786, 3846, 1, 0, 0, 0, 3787, 3788, 5, 191, 0, 0, 3788, 3790, 5, 351, 0, 0, 3789, 3791, 3, 422, 211, 0, 3790, 3789, 1, 0, 0, 0, 3790, 3791, 1, 0, 0, 0, 3791, 3792, 1, 0, 0, 0, 3792, 3846, 3, 770, 385, 0, 3793, 3794, 5, 191, 0, 0, 3794, 3796, 5, 443, 0, 0, 3795, 3797, 3, 422, 211, 0, 3796, 3795, 1, 0, 0, 0, 3796, 3797, 1, 0, 0, 0, 3797, 3798, 1, 0, 0, 0, 3798, 3799, 5, 62, 0, 0, 3799, 3800, 3, 652, 326, 0, 3800, 3801, 5, 247, 0, 0, 3801, 3803, 3, 818, 409, 0, 3802, 3804, 3, 96, 48, 0, 3803, 3802, 1, 0, 0, 0, 3803, 3804, 1, 0, 0, 0, 3804, 3846, 1, 0, 0, 0, 3805, 3806, 5, 191, 0, 0, 3806, 3808, 7, 45, 0, 0, 3807, 3809, 3, 422, 211, 0, 3808, 3807, 1, 0, 0, 0, 3808, 3809, 1, 0, 0, 0, 3809, 3810, 1, 0, 0, 0, 3810, 3846, 3, 816, 408, 0, 3811, 3812, 5, 191, 0, 0, 3812, 3813, 5, 99, 0, 0, 3813, 3815, 5, 257, 0, 0, 3814, 3816, 3, 422, 211, 0, 3815, 3814, 1, 0, 0, 0, 3815, 3816, 1, 0, 0, 0, 3816, 3817, 1, 0, 0, 0, 3817, 3820, 5, 62, 0, 0, 3818, 3821, 3, 814, 407, 0, 3819, 3821, 5, 99, 0, 0, 3820, 3818, 1, 0, 0, 0, 3820, 3819, 1, 0, 0, 0, 3821, 3822, 1, 0, 0, 0, 3822, 3823, 5, 331, 0, 0, 3823, 3846, 3, 818, 409, 0, 3824, 3825, 5, 191, 0, 0, 3825, 3827, 5, 175, 0, 0, 3826, 3828, 3, 422, 211, 0, 3827, 3826, 1, 0, 0, 0, 3827, 3828, 1, 0, 0, 0, 3828, 3829, 1, 0, 0, 0, 3829, 3843, 3, 788, 394, 0, 3830, 3832, 5, 105, 0, 0, 3831, 3830, 1, 0, 0, 0, 3831, 3832, 1, 0, 0, 0, 3832, 3833, 1, 0, 0, 0, 3833, 3834, 5, 2, 0, 0, 3834, 3839, 5, 209, 0, 0, 3835, 3836, 5, 6, 0, 0, 3836, 3838, 5, 209, 0, 0, 3837, 3835, 1, 0, 0, 0, 3838, 3841, 1, 0, 0, 0, 3839, 3837, 1, 0, 0, 0, 3839, 3840, 1, 0, 0, 0, 3840, 3842, 1, 0, 0, 0, 3841, 3839, 1, 0, 0, 0, 3842, 3844, 5, 3, 0, 0, 3843, 3831, 1, 0, 0, 0, 3843, 3844, 1, 0, 0, 0, 3844, 3846, 1, 0, 0, 0, 3845, 3638, 1, 0, 0, 0, 3845, 3670, 1, 0, 0, 0, 3845, 3689, 1, 0, 0, 0, 3845, 3701, 1, 0, 0, 0, 3845, 3710, 1, 0, 0, 0, 3845, 3721, 1, 0, 0, 0, 3845, 3737, 1, 0, 0, 0, 3845, 3747, 1, 0, 0, 0, 3845, 3760, 1, 0, 0, 0, 3845, 3771, 1, 0, 0, 0, 3845, 3778, 1, 0, 0, 0, 3845, 3787, 1, 0, 0, 0, 3845, 3793, 1, 0, 0, 0, 3845, 3805, 1, 0, 0, 0, 3845, 3811, 1, 0, 0, 0, 3845, 3824, 1, 0, 0, 0, 3846, 309, 1, 0, 0, 0, 3847, 3849, 5, 63, 0, 0, 3848, 3847, 1, 0, 0, 0, 3848, 3849, 1, 0, 0, 0, 3849, 3850, 1, 0, 0, 0, 3850, 3851, 5, 92, 0, 0, 3851, 3864, 3, 774, 387, 0, 3852, 3854, 5, 259, 0, 0, 3853, 3852, 1, 0, 0, 0, 3853, 3854, 1, 0, 0, 0, 3854, 3855, 1, 0, 0, 0, 3855, 3856, 5, 376, 0, 0, 3856, 3864, 3, 778, 389, 0, 3857, 3858, 7, 46, 0, 0, 3858, 3864, 3, 316, 158, 0, 3859, 3860, 5, 355, 0, 0, 3860, 3861, 5, 325, 0, 0, 3861, 3862, 7, 41, 0, 0, 3862, 3864, 3, 316, 158, 0, 3863, 3848, 1, 0, 0, 0, 3863, 3853, 1, 0, 0, 0, 3863, 3857, 1, 0, 0, 0, 3863, 3859, 1, 0, 0, 0, 3864, 311, 1, 0, 0, 0, 3865, 3866, 5, 198, 0, 0, 3866, 3882, 5, 357, 0, 0, 3867, 3868, 5, 131, 0, 0, 3868, 3882, 5, 446, 0, 0, 3869, 3882, 5, 204, 0, 0, 3870, 3882, 5, 452, 0, 0, 3871, 3882, 5, 331, 0, 0, 3872, 3882, 5, 318, 0, 0, 3873, 3882, 5, 451, 0, 0, 3874, 3875, 5, 63, 0, 0, 3875, 3876, 5, 174, 0, 0, 3876, 3882, 5, 381, 0, 0, 3877, 3879, 5, 295, 0, 0, 3878, 3877, 1, 0, 0, 0, 3878, 3879, 1, 0, 0, 0, 3879, 3880, 1, 0, 0, 0, 3880, 3882, 5, 247, 0, 0, 3881, 3865, 1, 0, 0, 0, 3881, 3867, 1, 0, 0, 0, 3881, 3869, 1, 0, 0, 0, 3881, 3870, 1, 0, 0, 0, 3881, 3871, 1, 0, 0, 0, 3881, 3872, 1, 0, 0, 0, 3881, 3873, 1, 0, 0, 0, 3881, 3874, 1, 0, 0, 0, 3881, 3878, 1, 0, 0, 0, 3882, 3883, 1, 0, 0, 0, 3883, 3890, 3, 818, 409, 0, 3884, 3885, 5, 323, 0, 0, 3885, 3890, 3, 790, 395, 0, 3886, 3887, 5, 175, 0, 0, 3887, 3890, 3, 788, 394, 0, 3888, 3890, 3, 176, 88, 0, 3889, 3881, 1, 0, 0, 0, 3889, 3884, 1, 0, 0, 0, 3889, 3886, 1, 0, 0, 0, 3889, 3888, 1, 0, 0, 0, 3890, 313, 1, 0, 0, 0, 3891, 3896, 3, 316, 158, 0, 3892, 3893, 5, 6, 0, 0, 3893, 3895, 3, 316, 158, 0, 3894, 3892, 1, 0, 0, 0, 3895, 3898, 1, 0, 0, 0, 3896, 3894, 1, 0, 0, 0, 3896, 3897, 1, 0, 0, 0, 3897, 315, 1, 0, 0, 0, 3898, 3896, 1, 0, 0, 0, 3899, 3901, 3, 818, 409, 0, 3900, 3902, 3, 318, 159, 0, 3901, 3900, 1, 0, 0, 0, 3901, 3902, 1, 0, 0, 0, 3902, 317, 1, 0, 0, 0, 3903, 3904, 5, 11, 0, 0, 3904, 3906, 3, 824, 412, 0, 3905, 3903, 1, 0, 0, 0, 3906, 3907, 1, 0, 0, 0, 3907, 3905, 1, 0, 0, 0, 3907, 3908, 1, 0, 0, 0, 3908, 319, 1, 0, 0, 0, 3909, 3911, 5, 358, 0, 0, 3910, 3912, 5, 92, 0, 0, 3911, 3910, 1, 0, 0, 0, 3911, 3912, 1, 0, 0, 0, 3912, 3913, 1, 0, 0, 0, 3913, 3918, 3, 322, 161, 0, 3914, 3915, 5, 6, 0, 0, 3915, 3917, 3, 322, 161, 0, 3916, 3914, 1, 0, 0, 0, 3917, 3920, 1, 0, 0, 0, 3918, 3916, 1, 0, 0, 0, 3918, 3919, 1, 0, 0, 0, 3919, 3923, 1, 0, 0, 0, 3920, 3918, 1, 0, 0, 0, 3921, 3922, 7, 47, 0, 0, 3922, 3924, 5, 219, 0, 0, 3923, 3921, 1, 0, 0, 0, 3923, 3924, 1, 0, 0, 0, 3924, 3926, 1, 0, 0, 0, 3925, 3927, 3, 96, 48, 0, 3926, 3925, 1, 0, 0, 0, 3926, 3927, 1, 0, 0, 0, 3927, 321, 1, 0, 0, 0, 3928, 3930, 5, 81, 0, 0, 3929, 3928, 1, 0, 0, 0, 3929, 3930, 1, 0, 0, 0, 3930, 3931, 1, 0, 0, 0, 3931, 3933, 3, 774, 387, 0, 3932, 3934, 5, 9, 0, 0, 3933, 3932, 1, 0, 0, 0, 3933, 3934, 1, 0, 0, 0, 3934, 323, 1, 0, 0, 0, 3935, 3936, 5, 159, 0, 0, 3936, 3995, 5, 80, 0, 0, 3937, 3996, 3, 310, 155, 0, 3938, 3996, 3, 312, 156, 0, 3939, 3940, 5, 44, 0, 0, 3940, 3942, 3, 818, 409, 0, 3941, 3943, 3, 318, 159, 0, 3942, 3941, 1, 0, 0, 0, 3942, 3943, 1, 0, 0, 0, 3943, 3944, 1, 0, 0, 0, 3944, 3945, 5, 11, 0, 0, 3945, 3946, 3, 800, 400, 0, 3946, 3996, 1, 0, 0, 0, 3947, 3948, 7, 32, 0, 0, 3948, 3996, 3, 652, 326, 0, 3949, 3950, 5, 136, 0, 0, 3950, 3996, 3, 394, 197, 0, 3951, 3952, 5, 211, 0, 0, 3952, 3996, 3, 382, 191, 0, 3953, 3954, 5, 278, 0, 0, 3954, 3996, 3, 416, 208, 0, 3955, 3956, 5, 45, 0, 0, 3956, 3957, 3, 818, 409, 0, 3957, 3963, 5, 80, 0, 0, 3958, 3964, 3, 774, 387, 0, 3959, 3961, 5, 189, 0, 0, 3960, 3959, 1, 0, 0, 0, 3960, 3961, 1, 0, 0, 0, 3961, 3962, 1, 0, 0, 0, 3962, 3964, 3, 316, 158, 0, 3963, 3958, 1, 0, 0, 0, 3963, 3960, 1, 0, 0, 0, 3964, 3996, 1, 0, 0, 0, 3965, 3966, 7, 44, 0, 0, 3966, 3967, 3, 818, 409, 0, 3967, 3968, 5, 80, 0, 0, 3968, 3969, 3, 316, 158, 0, 3969, 3996, 1, 0, 0, 0, 3970, 3971, 5, 296, 0, 0, 3971, 3996, 3, 378, 189, 0, 3972, 3973, 5, 442, 0, 0, 3973, 3996, 3, 374, 187, 0, 3974, 3975, 5, 443, 0, 0, 3975, 3976, 5, 62, 0, 0, 3976, 3977, 3, 652, 326, 0, 3977, 3978, 5, 247, 0, 0, 3978, 3979, 3, 818, 409, 0, 3979, 3996, 1, 0, 0, 0, 3980, 3981, 5, 278, 0, 0, 3981, 3982, 7, 31, 0, 0, 3982, 3983, 3, 316, 158, 0, 3983, 3984, 3, 170, 85, 0, 3984, 3996, 1, 0, 0, 0, 3985, 3986, 5, 248, 0, 0, 3986, 3987, 5, 274, 0, 0, 3987, 3996, 3, 202, 101, 0, 3988, 3989, 5, 41, 0, 0, 3989, 3990, 5, 2, 0, 0, 3990, 3991, 3, 652, 326, 0, 3991, 3992, 5, 36, 0, 0, 3992, 3993, 3, 652, 326, 0, 3993, 3994, 5, 3, 0, 0, 3994, 3996, 1, 0, 0, 0, 3995, 3937, 1, 0, 0, 0, 3995, 3938, 1, 0, 0, 0, 3995, 3939, 1, 0, 0, 0, 3995, 3947, 1, 0, 0, 0, 3995, 3949, 1, 0, 0, 0, 3995, 3951, 1, 0, 0, 0, 3995, 3953, 1, 0, 0, 0, 3995, 3955, 1, 0, 0, 0, 3995, 3965, 1, 0, 0, 0, 3995, 3970, 1, 0, 0, 0, 3995, 3972, 1, 0, 0, 0, 3995, 3974, 1, 0, 0, 0, 3995, 3980, 1, 0, 0, 0, 3995, 3985, 1, 0, 0, 0, 3995, 3988, 1, 0, 0, 0, 3996, 3997, 1, 0, 0, 0, 3997, 4000, 5, 116, 0, 0, 3998, 4001, 3, 808, 404, 0, 3999, 4001, 5, 78, 0, 0, 4000, 3998, 1, 0, 0, 0, 4000, 3999, 1, 0, 0, 0, 4001, 325, 1, 0, 0, 0, 4002, 4003, 5, 327, 0, 0, 4003, 4006, 5, 246, 0, 0, 4004, 4005, 5, 62, 0, 0, 4005, 4007, 3, 58, 29, 0, 4006, 4004, 1, 0, 0, 0, 4006, 4007, 1, 0, 0, 0, 4007, 4008, 1, 0, 0, 0, 4008, 4026, 5, 80, 0, 0, 4009, 4010, 7, 32, 0, 0, 4010, 4027, 3, 652, 326, 0, 4011, 4012, 5, 136, 0, 0, 4012, 4027, 3, 394, 197, 0, 4013, 4014, 5, 44, 0, 0, 4014, 4027, 3, 800, 400, 0, 4015, 4016, 5, 211, 0, 0, 4016, 4027, 3, 382, 191, 0, 4017, 4018, 5, 248, 0, 0, 4018, 4019, 5, 274, 0, 0, 4019, 4027, 3, 202, 101, 0, 4020, 4021, 5, 296, 0, 0, 4021, 4027, 3, 378, 189, 0, 4022, 4023, 5, 442, 0, 0, 4023, 4027, 3, 374, 187, 0, 4024, 4027, 3, 310, 155, 0, 4025, 4027, 3, 312, 156, 0, 4026, 4009, 1, 0, 0, 0, 4026, 4011, 1, 0, 0, 0, 4026, 4013, 1, 0, 0, 0, 4026, 4015, 1, 0, 0, 0, 4026, 4017, 1, 0, 0, 0, 4026, 4020, 1, 0, 0, 0, 4026, 4022, 1, 0, 0, 0, 4026, 4024, 1, 0, 0, 0, 4026, 4025, 1, 0, 0, 0, 4027, 4028, 1, 0, 0, 0, 4028, 4031, 5, 116, 0, 0, 4029, 4032, 3, 808, 404, 0, 4030, 4032, 5, 78, 0, 0, 4031, 4029, 1, 0, 0, 0, 4031, 4030, 1, 0, 0, 0, 4032, 327, 1, 0, 0, 0, 4033, 4034, 7, 48, 0, 0, 4034, 4035, 3, 330, 165, 0, 4035, 329, 1, 0, 0, 0, 4036, 4038, 7, 49, 0, 0, 4037, 4036, 1, 0, 0, 0, 4037, 4038, 1, 0, 0, 0, 4038, 4040, 1, 0, 0, 0, 4039, 4041, 3, 332, 166, 0, 4040, 4039, 1, 0, 0, 0, 4040, 4041, 1, 0, 0, 0, 4041, 4042, 1, 0, 0, 0, 4042, 4080, 3, 818, 409, 0, 4043, 4045, 7, 50, 0, 0, 4044, 4043, 1, 0, 0, 0, 4044, 4045, 1, 0, 0, 0, 4045, 4046, 1, 0, 0, 0, 4046, 4048, 3, 812, 406, 0, 4047, 4049, 3, 332, 166, 0, 4048, 4047, 1, 0, 0, 0, 4048, 4049, 1, 0, 0, 0, 4049, 4050, 1, 0, 0, 0, 4050, 4051, 3, 818, 409, 0, 4051, 4080, 1, 0, 0, 0, 4052, 4054, 5, 210, 0, 0, 4053, 4055, 3, 812, 406, 0, 4054, 4053, 1, 0, 0, 0, 4054, 4055, 1, 0, 0, 0, 4055, 4057, 1, 0, 0, 0, 4056, 4058, 3, 332, 166, 0, 4057, 4056, 1, 0, 0, 0, 4057, 4058, 1, 0, 0, 0, 4058, 4059, 1, 0, 0, 0, 4059, 4080, 3, 818, 409, 0, 4060, 4062, 5, 210, 0, 0, 4061, 4060, 1, 0, 0, 0, 4061, 4062, 1, 0, 0, 0, 4062, 4063, 1, 0, 0, 0, 4063, 4065, 5, 30, 0, 0, 4064, 4066, 3, 332, 166, 0, 4065, 4064, 1, 0, 0, 0, 4065, 4066, 1, 0, 0, 0, 4066, 4067, 1, 0, 0, 0, 4067, 4080, 3, 818, 409, 0, 4068, 4073, 5, 144, 0, 0, 4069, 4071, 5, 30, 0, 0, 4070, 4069, 1, 0, 0, 0, 4070, 4071, 1, 0, 0, 0, 4071, 4074, 1, 0, 0, 0, 4072, 4074, 3, 812, 406, 0, 4073, 4070, 1, 0, 0, 0, 4073, 4072, 1, 0, 0, 0, 4074, 4076, 1, 0, 0, 0, 4075, 4077, 3, 332, 166, 0, 4076, 4075, 1, 0, 0, 0, 4076, 4077, 1, 0, 0, 0, 4077, 4078, 1, 0, 0, 0, 4078, 4080, 3, 818, 409, 0, 4079, 4037, 1, 0, 0, 0, 4079, 4044, 1, 0, 0, 0, 4079, 4052, 1, 0, 0, 0, 4079, 4061, 1, 0, 0, 0, 4079, 4068, 1, 0, 0, 0, 4080, 331, 1, 0, 0, 0, 4081, 4082, 7, 51, 0, 0, 4082, 333, 1, 0, 0, 0, 4083, 4084, 5, 65, 0, 0, 4084, 4085, 3, 338, 169, 0, 4085, 4086, 5, 80, 0, 0, 4086, 4087, 3, 344, 172, 0, 4087, 4088, 5, 94, 0, 0, 4088, 4092, 3, 346, 173, 0, 4089, 4090, 5, 105, 0, 0, 4090, 4091, 5, 65, 0, 0, 4091, 4093, 5, 279, 0, 0, 4092, 4089, 1, 0, 0, 0, 4092, 4093, 1, 0, 0, 0, 4093, 335, 1, 0, 0, 0, 4094, 4098, 5, 317, 0, 0, 4095, 4096, 5, 65, 0, 0, 4096, 4097, 5, 279, 0, 0, 4097, 4099, 5, 62, 0, 0, 4098, 4095, 1, 0, 0, 0, 4098, 4099, 1, 0, 0, 0, 4099, 4100, 1, 0, 0, 0, 4100, 4101, 3, 338, 169, 0, 4101, 4102, 5, 80, 0, 0, 4102, 4103, 3, 344, 172, 0, 4103, 4104, 5, 64, 0, 0, 4104, 4106, 3, 346, 173, 0, 4105, 4107, 3, 96, 48, 0, 4106, 4105, 1, 0, 0, 0, 4106, 4107, 1, 0, 0, 0, 4107, 337, 1, 0, 0, 0, 4108, 4113, 3, 342, 171, 0, 4109, 4110, 5, 6, 0, 0, 4110, 4112, 3, 342, 171, 0, 4111, 4109, 1, 0, 0, 0, 4112, 4115, 1, 0, 0, 0, 4113, 4111, 1, 0, 0, 0, 4113, 4114, 1, 0, 0, 0, 4114, 4132, 1, 0, 0, 0, 4115, 4113, 1, 0, 0, 0, 4116, 4118, 5, 30, 0, 0, 4117, 4119, 5, 294, 0, 0, 4118, 4117, 1, 0, 0, 0, 4118, 4119, 1, 0, 0, 0, 4119, 4121, 1, 0, 0, 0, 4120, 4122, 3, 144, 72, 0, 4121, 4120, 1, 0, 0, 0, 4121, 4122, 1, 0, 0, 0, 4122, 4132, 1, 0, 0, 0, 4123, 4128, 3, 340, 170, 0, 4124, 4125, 5, 6, 0, 0, 4125, 4127, 3, 340, 170, 0, 4126, 4124, 1, 0, 0, 0, 4127, 4130, 1, 0, 0, 0, 4128, 4126, 1, 0, 0, 0, 4128, 4129, 1, 0, 0, 0, 4129, 4132, 1, 0, 0, 0, 4130, 4128, 1, 0, 0, 0, 4131, 4108, 1, 0, 0, 0, 4131, 4116, 1, 0, 0, 0, 4131, 4123, 1, 0, 0, 0, 4132, 339, 1, 0, 0, 0, 4133, 4134, 7, 52, 0, 0, 4134, 341, 1, 0, 0, 0, 4135, 4140, 5, 88, 0, 0, 4136, 4140, 5, 86, 0, 0, 4137, 4140, 5, 46, 0, 0, 4138, 4140, 3, 818, 409, 0, 4139, 4135, 1, 0, 0, 0, 4139, 4136, 1, 0, 0, 0, 4139, 4137, 1, 0, 0, 0, 4139, 4138, 1, 0, 0, 0, 4140, 4142, 1, 0, 0, 0, 4141, 4143, 3, 144, 72, 0, 4142, 4141, 1, 0, 0, 0, 4142, 4143, 1, 0, 0, 0, 4143, 343, 1, 0, 0, 0, 4144, 4145, 5, 92, 0, 0, 4145, 4190, 3, 762, 381, 0, 4146, 4148, 5, 328, 0, 0, 4147, 4146, 1, 0, 0, 0, 4147, 4148, 1, 0, 0, 0, 4148, 4149, 1, 0, 0, 0, 4149, 4190, 3, 760, 380, 0, 4150, 4154, 5, 63, 0, 0, 4151, 4152, 5, 174, 0, 0, 4152, 4155, 5, 381, 0, 0, 4153, 4155, 5, 331, 0, 0, 4154, 4151, 1, 0, 0, 0, 4154, 4153, 1, 0, 0, 0, 4155, 4158, 1, 0, 0, 0, 4156, 4158, 5, 247, 0, 0, 4157, 4150, 1, 0, 0, 0, 4157, 4156, 1, 0, 0, 0, 4158, 4159, 1, 0, 0, 0, 4159, 4190, 3, 784, 392, 0, 4160, 4161, 5, 211, 0, 0, 4161, 4190, 3, 380, 190, 0, 4162, 4163, 5, 296, 0, 0, 4163, 4190, 3, 376, 188, 0, 4164, 4165, 5, 442, 0, 0, 4165, 4190, 3, 372, 186, 0, 4166, 4167, 5, 175, 0, 0, 4167, 4190, 3, 766, 383, 0, 4168, 4169, 7, 32, 0, 0, 4169, 4190, 3, 314, 157, 0, 4170, 4171, 5, 248, 0, 0, 4171, 4172, 5, 274, 0, 0, 4172, 4177, 3, 202, 101, 0, 4173, 4174, 5, 6, 0, 0, 4174, 4176, 3, 202, 101, 0, 4175, 4173, 1, 0, 0, 0, 4176, 4179, 1, 0, 0, 0, 4177, 4175, 1, 0, 0, 0, 4177, 4178, 1, 0, 0, 0, 4178, 4190, 1, 0, 0, 0, 4179, 4177, 1, 0, 0, 0, 4180, 4181, 5, 323, 0, 0, 4181, 4190, 3, 764, 382, 0, 4182, 4183, 5, 351, 0, 0, 4183, 4190, 3, 782, 391, 0, 4184, 4185, 5, 30, 0, 0, 4185, 4186, 7, 53, 0, 0, 4186, 4187, 5, 68, 0, 0, 4187, 4188, 5, 323, 0, 0, 4188, 4190, 3, 764, 382, 0, 4189, 4144, 1, 0, 0, 0, 4189, 4147, 1, 0, 0, 0, 4189, 4157, 1, 0, 0, 0, 4189, 4160, 1, 0, 0, 0, 4189, 4162, 1, 0, 0, 0, 4189, 4164, 1, 0, 0, 0, 4189, 4166, 1, 0, 0, 0, 4189, 4168, 1, 0, 0, 0, 4189, 4170, 1, 0, 0, 0, 4189, 4180, 1, 0, 0, 0, 4189, 4182, 1, 0, 0, 0, 4189, 4184, 1, 0, 0, 0, 4190, 345, 1, 0, 0, 0, 4191, 4193, 5, 66, 0, 0, 4192, 4191, 1, 0, 0, 0, 4192, 4193, 1, 0, 0, 0, 4193, 4194, 1, 0, 0, 0, 4194, 4195, 3, 814, 407, 0, 4195, 4203, 1, 0, 0, 0, 4196, 4198, 5, 6, 0, 0, 4197, 4199, 5, 66, 0, 0, 4198, 4197, 1, 0, 0, 0, 4198, 4199, 1, 0, 0, 0, 4199, 4200, 1, 0, 0, 0, 4200, 4202, 3, 814, 407, 0, 4201, 4196, 1, 0, 0, 0, 4202, 4205, 1, 0, 0, 0, 4203, 4201, 1, 0, 0, 0, 4203, 4204, 1, 0, 0, 0, 4204, 347, 1, 0, 0, 0, 4205, 4203, 1, 0, 0, 0, 4206, 4207, 5, 65, 0, 0, 4207, 4212, 3, 342, 171, 0, 4208, 4209, 5, 6, 0, 0, 4209, 4211, 3, 342, 171, 0, 4210, 4208, 1, 0, 0, 0, 4211, 4214, 1, 0, 0, 0, 4212, 4210, 1, 0, 0, 0, 4212, 4213, 1, 0, 0, 0, 4213, 4215, 1, 0, 0, 0, 4214, 4212, 1, 0, 0, 0, 4215, 4216, 5, 94, 0, 0, 4216, 4220, 3, 816, 408, 0, 4217, 4218, 5, 105, 0, 0, 4218, 4219, 5, 134, 0, 0, 4219, 4221, 5, 279, 0, 0, 4220, 4217, 1, 0, 0, 0, 4220, 4221, 1, 0, 0, 0, 4221, 4225, 1, 0, 0, 0, 4222, 4223, 5, 214, 0, 0, 4223, 4224, 5, 147, 0, 0, 4224, 4226, 3, 814, 407, 0, 4225, 4222, 1, 0, 0, 0, 4225, 4226, 1, 0, 0, 0, 4226, 349, 1, 0, 0, 0, 4227, 4231, 5, 317, 0, 0, 4228, 4229, 5, 134, 0, 0, 4229, 4230, 5, 279, 0, 0, 4230, 4232, 5, 62, 0, 0, 4231, 4228, 1, 0, 0, 0, 4231, 4232, 1, 0, 0, 0, 4232, 4233, 1, 0, 0, 0, 4233, 4238, 3, 342, 171, 0, 4234, 4235, 5, 6, 0, 0, 4235, 4237, 3, 342, 171, 0, 4236, 4234, 1, 0, 0, 0, 4237, 4240, 1, 0, 0, 0, 4238, 4236, 1, 0, 0, 0, 4238, 4239, 1, 0, 0, 0, 4239, 4241, 1, 0, 0, 0, 4240, 4238, 1, 0, 0, 0, 4241, 4242, 5, 64, 0, 0, 4242, 4246, 3, 816, 408, 0, 4243, 4244, 5, 214, 0, 0, 4244, 4245, 5, 147, 0, 0, 4245, 4247, 3, 814, 407, 0, 4246, 4243, 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, 4249, 1, 0, 0, 0, 4248, 4250, 3, 96, 48, 0, 4249, 4248, 1, 0, 0, 0, 4249, 4250, 1, 0, 0, 0, 4250, 351, 1, 0, 0, 0, 4251, 4252, 5, 138, 0, 0, 4252, 4253, 5, 53, 0, 0, 4253, 4262, 5, 294, 0, 0, 4254, 4255, 5, 68, 0, 0, 4255, 4256, 5, 323, 0, 0, 4256, 4261, 3, 764, 382, 0, 4257, 4258, 5, 62, 0, 0, 4258, 4259, 7, 2, 0, 0, 4259, 4261, 3, 816, 408, 0, 4260, 4254, 1, 0, 0, 0, 4260, 4257, 1, 0, 0, 0, 4261, 4264, 1, 0, 0, 0, 4262, 4260, 1, 0, 0, 0, 4262, 4263, 1, 0, 0, 0, 4263, 4265, 1, 0, 0, 0, 4264, 4262, 1, 0, 0, 0, 4265, 4266, 3, 354, 177, 0, 4266, 353, 1, 0, 0, 0, 4267, 4268, 5, 65, 0, 0, 4268, 4269, 3, 338, 169, 0, 4269, 4270, 5, 80, 0, 0, 4270, 4271, 3, 356, 178, 0, 4271, 4272, 5, 94, 0, 0, 4272, 4276, 3, 346, 173, 0, 4273, 4274, 5, 105, 0, 0, 4274, 4275, 5, 65, 0, 0, 4275, 4277, 5, 279, 0, 0, 4276, 4273, 1, 0, 0, 0, 4276, 4277, 1, 0, 0, 0, 4277, 4293, 1, 0, 0, 0, 4278, 4282, 5, 317, 0, 0, 4279, 4280, 5, 65, 0, 0, 4280, 4281, 5, 279, 0, 0, 4281, 4283, 5, 62, 0, 0, 4282, 4279, 1, 0, 0, 0, 4282, 4283, 1, 0, 0, 0, 4283, 4284, 1, 0, 0, 0, 4284, 4285, 3, 338, 169, 0, 4285, 4286, 5, 80, 0, 0, 4286, 4287, 3, 356, 178, 0, 4287, 4288, 5, 64, 0, 0, 4288, 4290, 3, 346, 173, 0, 4289, 4291, 3, 96, 48, 0, 4290, 4289, 1, 0, 0, 0, 4290, 4291, 1, 0, 0, 0, 4291, 4293, 1, 0, 0, 0, 4292, 4267, 1, 0, 0, 0, 4292, 4278, 1, 0, 0, 0, 4293, 355, 1, 0, 0, 0, 4294, 4295, 7, 54, 0, 0, 4295, 357, 1, 0, 0, 0, 4296, 4298, 5, 46, 0, 0, 4297, 4299, 5, 98, 0, 0, 4298, 4297, 1, 0, 0, 0, 4298, 4299, 1, 0, 0, 0, 4299, 4300, 1, 0, 0, 0, 4300, 4302, 5, 226, 0, 0, 4301, 4303, 5, 109, 0, 0, 4302, 4301, 1, 0, 0, 0, 4302, 4303, 1, 0, 0, 0, 4303, 4305, 1, 0, 0, 0, 4304, 4306, 3, 294, 147, 0, 4305, 4304, 1, 0, 0, 0, 4305, 4306, 1, 0, 0, 0, 4306, 4308, 1, 0, 0, 0, 4307, 4309, 3, 818, 409, 0, 4308, 4307, 1, 0, 0, 0, 4308, 4309, 1, 0, 0, 0, 4309, 4310, 1, 0, 0, 0, 4310, 4311, 5, 80, 0, 0, 4311, 4313, 3, 624, 312, 0, 4312, 4314, 3, 170, 85, 0, 4313, 4312, 1, 0, 0, 0, 4313, 4314, 1, 0, 0, 0, 4314, 4315, 1, 0, 0, 0, 4315, 4318, 3, 360, 180, 0, 4316, 4317, 5, 441, 0, 0, 4317, 4319, 3, 360, 180, 0, 4318, 4316, 1, 0, 0, 0, 4318, 4319, 1, 0, 0, 0, 4319, 4325, 1, 0, 0, 0, 4320, 4322, 5, 273, 0, 0, 4321, 4323, 5, 77, 0, 0, 4322, 4321, 1, 0, 0, 0, 4322, 4323, 1, 0, 0, 0, 4323, 4324, 1, 0, 0, 0, 4324, 4326, 5, 56, 0, 0, 4325, 4320, 1, 0, 0, 0, 4325, 4326, 1, 0, 0, 0, 4326, 4328, 1, 0, 0, 0, 4327, 4329, 3, 102, 51, 0, 4328, 4327, 1, 0, 0, 0, 4328, 4329, 1, 0, 0, 0, 4329, 4331, 1, 0, 0, 0, 4330, 4332, 3, 176, 88, 0, 4331, 4330, 1, 0, 0, 0, 4331, 4332, 1, 0, 0, 0, 4332, 4334, 1, 0, 0, 0, 4333, 4335, 3, 638, 319, 0, 4334, 4333, 1, 0, 0, 0, 4334, 4335, 1, 0, 0, 0, 4335, 359, 1, 0, 0, 0, 4336, 4337, 5, 2, 0, 0, 4337, 4342, 3, 362, 181, 0, 4338, 4339, 5, 6, 0, 0, 4339, 4341, 3, 362, 181, 0, 4340, 4338, 1, 0, 0, 0, 4341, 4344, 1, 0, 0, 0, 4342, 4340, 1, 0, 0, 0, 4342, 4343, 1, 0, 0, 0, 4343, 4345, 1, 0, 0, 0, 4344, 4342, 1, 0, 0, 0, 4345, 4346, 5, 3, 0, 0, 4346, 361, 1, 0, 0, 0, 4347, 4354, 3, 800, 400, 0, 4348, 4354, 3, 688, 344, 0, 4349, 4350, 5, 2, 0, 0, 4350, 4351, 3, 674, 337, 0, 4351, 4352, 5, 3, 0, 0, 4352, 4354, 1, 0, 0, 0, 4353, 4347, 1, 0, 0, 0, 4353, 4348, 1, 0, 0, 0, 4353, 4349, 1, 0, 0, 0, 4354, 4356, 1, 0, 0, 0, 4355, 4357, 3, 98, 49, 0, 4356, 4355, 1, 0, 0, 0, 4356, 4357, 1, 0, 0, 0, 4357, 4364, 1, 0, 0, 0, 4358, 4360, 3, 316, 158, 0, 4359, 4358, 1, 0, 0, 0, 4359, 4360, 1, 0, 0, 0, 4360, 4365, 1, 0, 0, 0, 4361, 4362, 3, 316, 158, 0, 4362, 4363, 3, 100, 50, 0, 4363, 4365, 1, 0, 0, 0, 4364, 4359, 1, 0, 0, 0, 4364, 4361, 1, 0, 0, 0, 4365, 4367, 1, 0, 0, 0, 4366, 4368, 7, 55, 0, 0, 4367, 4366, 1, 0, 0, 0, 4367, 4368, 1, 0, 0, 0, 4368, 4371, 1, 0, 0, 0, 4369, 4370, 5, 273, 0, 0, 4370, 4372, 7, 56, 0, 0, 4371, 4369, 1, 0, 0, 0, 4371, 4372, 1, 0, 0, 0, 4372, 363, 1, 0, 0, 0, 4373, 4375, 5, 46, 0, 0, 4374, 4376, 3, 366, 183, 0, 4375, 4374, 1, 0, 0, 0, 4375, 4376, 1, 0, 0, 0, 4376, 4381, 1, 0, 0, 0, 4377, 4378, 5, 211, 0, 0, 4378, 4382, 3, 804, 402, 0, 4379, 4380, 5, 296, 0, 0, 4380, 4382, 3, 798, 399, 0, 4381, 4377, 1, 0, 0, 0, 4381, 4379, 1, 0, 0, 0, 4382, 4383, 1, 0, 0, 0, 4383, 4392, 5, 2, 0, 0, 4384, 4389, 3, 390, 195, 0, 4385, 4386, 5, 6, 0, 0, 4386, 4388, 3, 390, 195, 0, 4387, 4385, 1, 0, 0, 0, 4388, 4391, 1, 0, 0, 0, 4389, 4387, 1, 0, 0, 0, 4389, 4390, 1, 0, 0, 0, 4390, 4393, 1, 0, 0, 0, 4391, 4389, 1, 0, 0, 0, 4392, 4384, 1, 0, 0, 0, 4392, 4393, 1, 0, 0, 0, 4393, 4394, 1, 0, 0, 0, 4394, 4395, 5, 3, 0, 0, 4395, 4412, 1, 0, 0, 0, 4396, 4410, 5, 316, 0, 0, 4397, 4411, 3, 388, 194, 0, 4398, 4399, 5, 92, 0, 0, 4399, 4400, 5, 2, 0, 0, 4400, 4405, 3, 402, 201, 0, 4401, 4402, 5, 6, 0, 0, 4402, 4404, 3, 402, 201, 0, 4403, 4401, 1, 0, 0, 0, 4404, 4407, 1, 0, 0, 0, 4405, 4403, 1, 0, 0, 0, 4405, 4406, 1, 0, 0, 0, 4406, 4408, 1, 0, 0, 0, 4407, 4405, 1, 0, 0, 0, 4408, 4409, 5, 3, 0, 0, 4409, 4411, 1, 0, 0, 0, 4410, 4397, 1, 0, 0, 0, 4410, 4398, 1, 0, 0, 0, 4411, 4413, 1, 0, 0, 0, 4412, 4396, 1, 0, 0, 0, 4412, 4413, 1, 0, 0, 0, 4413, 4415, 1, 0, 0, 0, 4414, 4416, 3, 398, 199, 0, 4415, 4414, 1, 0, 0, 0, 4416, 4417, 1, 0, 0, 0, 4417, 4415, 1, 0, 0, 0, 4417, 4418, 1, 0, 0, 0, 4418, 4424, 1, 0, 0, 0, 4419, 4420, 5, 105, 0, 0, 4420, 4421, 5, 2, 0, 0, 4421, 4422, 3, 784, 392, 0, 4422, 4423, 5, 3, 0, 0, 4423, 4425, 1, 0, 0, 0, 4424, 4419, 1, 0, 0, 0, 4424, 4425, 1, 0, 0, 0, 4425, 365, 1, 0, 0, 0, 4426, 4427, 5, 82, 0, 0, 4427, 4428, 5, 311, 0, 0, 4428, 367, 1, 0, 0, 0, 4429, 4431, 5, 2, 0, 0, 4430, 4432, 3, 370, 185, 0, 4431, 4430, 1, 0, 0, 0, 4431, 4432, 1, 0, 0, 0, 4432, 4433, 1, 0, 0, 0, 4433, 4434, 5, 3, 0, 0, 4434, 369, 1, 0, 0, 0, 4435, 4440, 3, 384, 192, 0, 4436, 4437, 5, 6, 0, 0, 4437, 4439, 3, 384, 192, 0, 4438, 4436, 1, 0, 0, 0, 4439, 4442, 1, 0, 0, 0, 4440, 4438, 1, 0, 0, 0, 4440, 4441, 1, 0, 0, 0, 4441, 371, 1, 0, 0, 0, 4442, 4440, 1, 0, 0, 0, 4443, 4448, 3, 374, 187, 0, 4444, 4445, 5, 6, 0, 0, 4445, 4447, 3, 374, 187, 0, 4446, 4444, 1, 0, 0, 0, 4447, 4450, 1, 0, 0, 0, 4448, 4446, 1, 0, 0, 0, 4448, 4449, 1, 0, 0, 0, 4449, 373, 1, 0, 0, 0, 4450, 4448, 1, 0, 0, 0, 4451, 4452, 3, 794, 397, 0, 4452, 4453, 3, 368, 184, 0, 4453, 4457, 1, 0, 0, 0, 4454, 4457, 3, 832, 416, 0, 4455, 4457, 3, 780, 390, 0, 4456, 4451, 1, 0, 0, 0, 4456, 4454, 1, 0, 0, 0, 4456, 4455, 1, 0, 0, 0, 4457, 375, 1, 0, 0, 0, 4458, 4463, 3, 378, 189, 0, 4459, 4460, 5, 6, 0, 0, 4460, 4462, 3, 378, 189, 0, 4461, 4459, 1, 0, 0, 0, 4462, 4465, 1, 0, 0, 0, 4463, 4461, 1, 0, 0, 0, 4463, 4464, 1, 0, 0, 0, 4464, 377, 1, 0, 0, 0, 4465, 4463, 1, 0, 0, 0, 4466, 4467, 3, 796, 398, 0, 4467, 4468, 3, 368, 184, 0, 4468, 4472, 1, 0, 0, 0, 4469, 4472, 3, 832, 416, 0, 4470, 4472, 3, 780, 390, 0, 4471, 4466, 1, 0, 0, 0, 4471, 4469, 1, 0, 0, 0, 4471, 4470, 1, 0, 0, 0, 4472, 379, 1, 0, 0, 0, 4473, 4478, 3, 382, 191, 0, 4474, 4475, 5, 6, 0, 0, 4475, 4477, 3, 382, 191, 0, 4476, 4474, 1, 0, 0, 0, 4477, 4480, 1, 0, 0, 0, 4478, 4476, 1, 0, 0, 0, 4478, 4479, 1, 0, 0, 0, 4479, 381, 1, 0, 0, 0, 4480, 4478, 1, 0, 0, 0, 4481, 4482, 3, 806, 403, 0, 4482, 4483, 3, 368, 184, 0, 4483, 4487, 1, 0, 0, 0, 4484, 4487, 3, 832, 416, 0, 4485, 4487, 3, 780, 390, 0, 4486, 4481, 1, 0, 0, 0, 4486, 4484, 1, 0, 0, 0, 4486, 4485, 1, 0, 0, 0, 4487, 383, 1, 0, 0, 0, 4488, 4490, 3, 386, 193, 0, 4489, 4491, 3, 820, 410, 0, 4490, 4489, 1, 0, 0, 0, 4490, 4491, 1, 0, 0, 0, 4491, 4497, 1, 0, 0, 0, 4492, 4494, 3, 820, 410, 0, 4493, 4495, 3, 386, 193, 0, 4494, 4493, 1, 0, 0, 0, 4494, 4495, 1, 0, 0, 0, 4495, 4497, 1, 0, 0, 0, 4496, 4488, 1, 0, 0, 0, 4496, 4492, 1, 0, 0, 0, 4496, 4497, 1, 0, 0, 0, 4497, 4498, 1, 0, 0, 0, 4498, 4499, 3, 388, 194, 0, 4499, 385, 1, 0, 0, 0, 4500, 4502, 5, 68, 0, 0, 4501, 4503, 5, 453, 0, 0, 4502, 4501, 1, 0, 0, 0, 4502, 4503, 1, 0, 0, 0, 4503, 4508, 1, 0, 0, 0, 4504, 4508, 5, 453, 0, 0, 4505, 4508, 5, 400, 0, 0, 4506, 4508, 5, 101, 0, 0, 4507, 4500, 1, 0, 0, 0, 4507, 4504, 1, 0, 0, 0, 4507, 4505, 1, 0, 0, 0, 4507, 4506, 1, 0, 0, 0, 4508, 387, 1, 0, 0, 0, 4509, 4519, 3, 652, 326, 0, 4510, 4512, 5, 415, 0, 0, 4511, 4510, 1, 0, 0, 0, 4511, 4512, 1, 0, 0, 0, 4512, 4513, 1, 0, 0, 0, 4513, 4514, 3, 820, 410, 0, 4514, 4515, 3, 318, 159, 0, 4515, 4516, 5, 27, 0, 0, 4516, 4517, 5, 360, 0, 0, 4517, 4519, 1, 0, 0, 0, 4518, 4509, 1, 0, 0, 0, 4518, 4511, 1, 0, 0, 0, 4519, 389, 1, 0, 0, 0, 4520, 4523, 3, 384, 192, 0, 4521, 4522, 7, 57, 0, 0, 4522, 4524, 3, 674, 337, 0, 4523, 4521, 1, 0, 0, 0, 4523, 4524, 1, 0, 0, 0, 4524, 391, 1, 0, 0, 0, 4525, 4535, 5, 2, 0, 0, 4526, 4536, 5, 9, 0, 0, 4527, 4529, 3, 370, 185, 0, 4528, 4527, 1, 0, 0, 0, 4528, 4529, 1, 0, 0, 0, 4529, 4533, 1, 0, 0, 0, 4530, 4531, 5, 83, 0, 0, 4531, 4532, 5, 147, 0, 0, 4532, 4534, 3, 370, 185, 0, 4533, 4530, 1, 0, 0, 0, 4533, 4534, 1, 0, 0, 0, 4534, 4536, 1, 0, 0, 0, 4535, 4526, 1, 0, 0, 0, 4535, 4528, 1, 0, 0, 0, 4536, 4537, 1, 0, 0, 0, 4537, 4538, 5, 3, 0, 0, 4538, 393, 1, 0, 0, 0, 4539, 4540, 3, 806, 403, 0, 4540, 4541, 3, 392, 196, 0, 4541, 395, 1, 0, 0, 0, 4542, 4543, 5, 316, 0, 0, 4543, 4546, 5, 78, 0, 0, 4544, 4546, 5, 149, 0, 0, 4545, 4542, 1, 0, 0, 0, 4545, 4544, 1, 0, 0, 0, 4546, 4547, 1, 0, 0, 0, 4547, 4548, 5, 80, 0, 0, 4548, 4549, 5, 78, 0, 0, 4549, 4572, 5, 458, 0, 0, 4550, 4572, 5, 346, 0, 0, 4551, 4572, 5, 222, 0, 0, 4552, 4572, 5, 338, 0, 0, 4553, 4572, 5, 377, 0, 0, 4554, 4556, 5, 205, 0, 0, 4555, 4554, 1, 0, 0, 0, 4555, 4556, 1, 0, 0, 0, 4556, 4557, 1, 0, 0, 0, 4557, 4558, 5, 327, 0, 0, 4558, 4572, 7, 58, 0, 0, 4559, 4572, 5, 250, 0, 0, 4560, 4561, 5, 77, 0, 0, 4561, 4572, 5, 250, 0, 0, 4562, 4563, 7, 59, 0, 0, 4563, 4572, 3, 202, 101, 0, 4564, 4565, 5, 459, 0, 0, 4565, 4572, 3, 316, 158, 0, 4566, 4567, 5, 333, 0, 0, 4567, 4572, 3, 42, 21, 0, 4568, 4572, 3, 60, 30, 0, 4569, 4570, 5, 460, 0, 0, 4570, 4572, 3, 818, 409, 0, 4571, 4545, 1, 0, 0, 0, 4571, 4550, 1, 0, 0, 0, 4571, 4551, 1, 0, 0, 0, 4571, 4552, 1, 0, 0, 0, 4571, 4553, 1, 0, 0, 0, 4571, 4555, 1, 0, 0, 0, 4571, 4559, 1, 0, 0, 0, 4571, 4560, 1, 0, 0, 0, 4571, 4562, 1, 0, 0, 0, 4571, 4564, 1, 0, 0, 0, 4571, 4566, 1, 0, 0, 0, 4571, 4568, 1, 0, 0, 0, 4571, 4569, 1, 0, 0, 0, 4572, 397, 1, 0, 0, 0, 4573, 4574, 5, 36, 0, 0, 4574, 4575, 3, 808, 404, 0, 4575, 4576, 3, 462, 231, 0, 4576, 4609, 1, 0, 0, 0, 4577, 4578, 5, 247, 0, 0, 4578, 4609, 3, 58, 29, 0, 4579, 4580, 5, 443, 0, 0, 4580, 4581, 5, 62, 0, 0, 4581, 4582, 5, 360, 0, 0, 4582, 4589, 3, 652, 326, 0, 4583, 4584, 5, 6, 0, 0, 4584, 4585, 5, 62, 0, 0, 4585, 4586, 5, 360, 0, 0, 4586, 4588, 3, 652, 326, 0, 4587, 4583, 1, 0, 0, 0, 4588, 4591, 1, 0, 0, 0, 4589, 4587, 1, 0, 0, 0, 4589, 4590, 1, 0, 0, 0, 4590, 4609, 1, 0, 0, 0, 4591, 4589, 1, 0, 0, 0, 4592, 4609, 5, 104, 0, 0, 4593, 4594, 5, 333, 0, 0, 4594, 4601, 3, 818, 409, 0, 4595, 4596, 5, 94, 0, 0, 4596, 4602, 3, 818, 409, 0, 4597, 4598, 5, 10, 0, 0, 4598, 4602, 3, 818, 409, 0, 4599, 4600, 5, 64, 0, 0, 4600, 4602, 5, 434, 0, 0, 4601, 4595, 1, 0, 0, 0, 4601, 4597, 1, 0, 0, 0, 4601, 4599, 1, 0, 0, 0, 4602, 4609, 1, 0, 0, 0, 4603, 4604, 5, 36, 0, 0, 4604, 4609, 3, 818, 409, 0, 4605, 4609, 3, 4, 2, 0, 4606, 4609, 3, 396, 198, 0, 4607, 4609, 3, 818, 409, 0, 4608, 4573, 1, 0, 0, 0, 4608, 4577, 1, 0, 0, 0, 4608, 4579, 1, 0, 0, 0, 4608, 4592, 1, 0, 0, 0, 4608, 4593, 1, 0, 0, 0, 4608, 4603, 1, 0, 0, 0, 4608, 4605, 1, 0, 0, 0, 4608, 4606, 1, 0, 0, 0, 4608, 4607, 1, 0, 0, 0, 4609, 399, 1, 0, 0, 0, 4610, 4611, 5, 105, 0, 0, 4611, 4612, 3, 284, 142, 0, 4612, 401, 1, 0, 0, 0, 4613, 4614, 3, 800, 400, 0, 4614, 4615, 3, 388, 194, 0, 4615, 403, 1, 0, 0, 0, 4616, 4623, 5, 138, 0, 0, 4617, 4618, 5, 211, 0, 0, 4618, 4624, 3, 382, 191, 0, 4619, 4620, 5, 296, 0, 0, 4620, 4624, 3, 378, 189, 0, 4621, 4622, 5, 442, 0, 0, 4622, 4624, 3, 374, 187, 0, 4623, 4617, 1, 0, 0, 0, 4623, 4619, 1, 0, 0, 0, 4623, 4621, 1, 0, 0, 0, 4624, 4626, 1, 0, 0, 0, 4625, 4627, 3, 396, 198, 0, 4626, 4625, 1, 0, 0, 0, 4627, 4628, 1, 0, 0, 0, 4628, 4626, 1, 0, 0, 0, 4628, 4629, 1, 0, 0, 0, 4629, 4631, 1, 0, 0, 0, 4630, 4632, 5, 315, 0, 0, 4631, 4630, 1, 0, 0, 0, 4631, 4632, 1, 0, 0, 0, 4632, 405, 1, 0, 0, 0, 4633, 4649, 5, 191, 0, 0, 4634, 4636, 5, 211, 0, 0, 4635, 4637, 3, 422, 211, 0, 4636, 4635, 1, 0, 0, 0, 4636, 4637, 1, 0, 0, 0, 4637, 4638, 1, 0, 0, 0, 4638, 4650, 3, 380, 190, 0, 4639, 4641, 5, 296, 0, 0, 4640, 4642, 3, 422, 211, 0, 4641, 4640, 1, 0, 0, 0, 4641, 4642, 1, 0, 0, 0, 4642, 4643, 1, 0, 0, 0, 4643, 4650, 3, 376, 188, 0, 4644, 4646, 5, 442, 0, 0, 4645, 4647, 3, 422, 211, 0, 4646, 4645, 1, 0, 0, 0, 4646, 4647, 1, 0, 0, 0, 4647, 4648, 1, 0, 0, 0, 4648, 4650, 3, 372, 186, 0, 4649, 4634, 1, 0, 0, 0, 4649, 4639, 1, 0, 0, 0, 4649, 4644, 1, 0, 0, 0, 4650, 4652, 1, 0, 0, 0, 4651, 4653, 3, 96, 48, 0, 4652, 4651, 1, 0, 0, 0, 4652, 4653, 1, 0, 0, 0, 4653, 407, 1, 0, 0, 0, 4654, 4655, 5, 191, 0, 0, 4655, 4657, 5, 136, 0, 0, 4656, 4658, 3, 422, 211, 0, 4657, 4656, 1, 0, 0, 0, 4657, 4658, 1, 0, 0, 0, 4658, 4659, 1, 0, 0, 0, 4659, 4664, 3, 394, 197, 0, 4660, 4661, 5, 6, 0, 0, 4661, 4663, 3, 394, 197, 0, 4662, 4660, 1, 0, 0, 0, 4663, 4666, 1, 0, 0, 0, 4664, 4662, 1, 0, 0, 0, 4664, 4665, 1, 0, 0, 0, 4665, 4668, 1, 0, 0, 0, 4666, 4664, 1, 0, 0, 0, 4667, 4669, 3, 96, 48, 0, 4668, 4667, 1, 0, 0, 0, 4668, 4669, 1, 0, 0, 0, 4669, 409, 1, 0, 0, 0, 4670, 4671, 5, 191, 0, 0, 4671, 4673, 5, 278, 0, 0, 4672, 4674, 3, 422, 211, 0, 4673, 4672, 1, 0, 0, 0, 4673, 4674, 1, 0, 0, 0, 4674, 4675, 1, 0, 0, 0, 4675, 4680, 3, 416, 208, 0, 4676, 4677, 5, 6, 0, 0, 4677, 4679, 3, 416, 208, 0, 4678, 4676, 1, 0, 0, 0, 4679, 4682, 1, 0, 0, 0, 4680, 4678, 1, 0, 0, 0, 4680, 4681, 1, 0, 0, 0, 4681, 4684, 1, 0, 0, 0, 4682, 4680, 1, 0, 0, 0, 4683, 4685, 3, 96, 48, 0, 4684, 4683, 1, 0, 0, 0, 4684, 4685, 1, 0, 0, 0, 4685, 411, 1, 0, 0, 0, 4686, 4699, 5, 2, 0, 0, 4687, 4690, 3, 652, 326, 0, 4688, 4689, 5, 6, 0, 0, 4689, 4691, 3, 652, 326, 0, 4690, 4688, 1, 0, 0, 0, 4690, 4691, 1, 0, 0, 0, 4691, 4700, 1, 0, 0, 0, 4692, 4693, 5, 407, 0, 0, 4693, 4694, 5, 6, 0, 0, 4694, 4700, 3, 652, 326, 0, 4695, 4696, 3, 652, 326, 0, 4696, 4697, 5, 6, 0, 0, 4697, 4698, 5, 407, 0, 0, 4698, 4700, 1, 0, 0, 0, 4699, 4687, 1, 0, 0, 0, 4699, 4692, 1, 0, 0, 0, 4699, 4695, 1, 0, 0, 0, 4700, 4701, 1, 0, 0, 0, 4701, 4702, 5, 3, 0, 0, 4702, 413, 1, 0, 0, 0, 4703, 4704, 3, 818, 409, 0, 4704, 4705, 5, 11, 0, 0, 4705, 4707, 1, 0, 0, 0, 4706, 4703, 1, 0, 0, 0, 4707, 4710, 1, 0, 0, 0, 4708, 4706, 1, 0, 0, 0, 4708, 4709, 1, 0, 0, 0, 4709, 4711, 1, 0, 0, 0, 4710, 4708, 1, 0, 0, 0, 4711, 4712, 3, 720, 360, 0, 4712, 415, 1, 0, 0, 0, 4713, 4714, 3, 414, 207, 0, 4714, 4715, 3, 412, 206, 0, 4715, 417, 1, 0, 0, 0, 4716, 4720, 5, 57, 0, 0, 4717, 4721, 3, 808, 404, 0, 4718, 4719, 5, 247, 0, 0, 4719, 4721, 3, 58, 29, 0, 4720, 4717, 1, 0, 0, 0, 4720, 4718, 1, 0, 0, 0, 4721, 4722, 1, 0, 0, 0, 4722, 4720, 1, 0, 0, 0, 4722, 4723, 1, 0, 0, 0, 4723, 419, 1, 0, 0, 0, 4724, 4725, 5, 46, 0, 0, 4725, 4726, 5, 41, 0, 0, 4726, 4727, 5, 2, 0, 0, 4727, 4728, 3, 652, 326, 0, 4728, 4729, 5, 36, 0, 0, 4729, 4730, 3, 652, 326, 0, 4730, 4747, 5, 3, 0, 0, 4731, 4732, 5, 379, 0, 0, 4732, 4735, 5, 211, 0, 0, 4733, 4734, 5, 36, 0, 0, 4734, 4736, 7, 60, 0, 0, 4735, 4733, 1, 0, 0, 0, 4735, 4736, 1, 0, 0, 0, 4736, 4748, 1, 0, 0, 0, 4737, 4741, 5, 105, 0, 0, 4738, 4739, 5, 211, 0, 0, 4739, 4742, 3, 382, 191, 0, 4740, 4742, 5, 400, 0, 0, 4741, 4738, 1, 0, 0, 0, 4741, 4740, 1, 0, 0, 0, 4742, 4745, 1, 0, 0, 0, 4743, 4744, 5, 36, 0, 0, 4744, 4746, 7, 60, 0, 0, 4745, 4743, 1, 0, 0, 0, 4745, 4746, 1, 0, 0, 0, 4746, 4748, 1, 0, 0, 0, 4747, 4731, 1, 0, 0, 0, 4747, 4737, 1, 0, 0, 0, 4748, 421, 1, 0, 0, 0, 4749, 4750, 5, 220, 0, 0, 4750, 4751, 5, 396, 0, 0, 4751, 423, 1, 0, 0, 0, 4752, 4754, 5, 46, 0, 0, 4753, 4755, 3, 366, 183, 0, 4754, 4753, 1, 0, 0, 0, 4754, 4755, 1, 0, 0, 0, 4755, 4756, 1, 0, 0, 0, 4756, 4757, 5, 443, 0, 0, 4757, 4758, 5, 62, 0, 0, 4758, 4759, 3, 652, 326, 0, 4759, 4760, 5, 247, 0, 0, 4760, 4761, 3, 818, 409, 0, 4761, 4776, 5, 2, 0, 0, 4762, 4763, 5, 64, 0, 0, 4763, 4767, 3, 426, 213, 0, 4764, 4765, 5, 6, 0, 0, 4765, 4766, 5, 94, 0, 0, 4766, 4768, 3, 426, 213, 0, 4767, 4764, 1, 0, 0, 0, 4767, 4768, 1, 0, 0, 0, 4768, 4777, 1, 0, 0, 0, 4769, 4770, 5, 94, 0, 0, 4770, 4774, 3, 426, 213, 0, 4771, 4772, 5, 6, 0, 0, 4772, 4773, 5, 64, 0, 0, 4773, 4775, 3, 426, 213, 0, 4774, 4771, 1, 0, 0, 0, 4774, 4775, 1, 0, 0, 0, 4775, 4777, 1, 0, 0, 0, 4776, 4762, 1, 0, 0, 0, 4776, 4769, 1, 0, 0, 0, 4777, 4778, 1, 0, 0, 0, 4778, 4779, 5, 3, 0, 0, 4779, 425, 1, 0, 0, 0, 4780, 4781, 5, 461, 0, 0, 4781, 4782, 5, 105, 0, 0, 4782, 4783, 5, 211, 0, 0, 4783, 4784, 3, 382, 191, 0, 4784, 427, 1, 0, 0, 0, 4785, 4796, 5, 306, 0, 0, 4786, 4787, 5, 2, 0, 0, 4787, 4792, 5, 128, 0, 0, 4788, 4789, 5, 6, 0, 0, 4789, 4791, 5, 128, 0, 0, 4790, 4788, 1, 0, 0, 0, 4791, 4794, 1, 0, 0, 0, 4792, 4790, 1, 0, 0, 0, 4792, 4793, 1, 0, 0, 0, 4793, 4795, 1, 0, 0, 0, 4794, 4792, 1, 0, 0, 0, 4795, 4797, 5, 3, 0, 0, 4796, 4786, 1, 0, 0, 0, 4796, 4797, 1, 0, 0, 0, 4797, 4823, 1, 0, 0, 0, 4798, 4800, 5, 226, 0, 0, 4799, 4801, 5, 109, 0, 0, 4800, 4799, 1, 0, 0, 0, 4800, 4801, 1, 0, 0, 0, 4801, 4802, 1, 0, 0, 0, 4802, 4824, 3, 780, 390, 0, 4803, 4805, 5, 92, 0, 0, 4804, 4806, 5, 109, 0, 0, 4805, 4804, 1, 0, 0, 0, 4805, 4806, 1, 0, 0, 0, 4806, 4807, 1, 0, 0, 0, 4807, 4824, 3, 774, 387, 0, 4808, 4810, 5, 323, 0, 0, 4809, 4811, 5, 109, 0, 0, 4810, 4809, 1, 0, 0, 0, 4810, 4811, 1, 0, 0, 0, 4811, 4812, 1, 0, 0, 0, 4812, 4824, 3, 790, 395, 0, 4813, 4815, 5, 349, 0, 0, 4814, 4816, 5, 109, 0, 0, 4815, 4814, 1, 0, 0, 0, 4815, 4816, 1, 0, 0, 0, 4816, 4817, 1, 0, 0, 0, 4817, 4824, 3, 818, 409, 0, 4818, 4820, 5, 175, 0, 0, 4819, 4821, 5, 109, 0, 0, 4820, 4819, 1, 0, 0, 0, 4820, 4821, 1, 0, 0, 0, 4821, 4822, 1, 0, 0, 0, 4822, 4824, 3, 788, 394, 0, 4823, 4798, 1, 0, 0, 0, 4823, 4803, 1, 0, 0, 0, 4823, 4808, 1, 0, 0, 0, 4823, 4813, 1, 0, 0, 0, 4823, 4818, 1, 0, 0, 0, 4824, 429, 1, 0, 0, 0, 4825, 4826, 5, 138, 0, 0, 4826, 4827, 3, 176, 88, 0, 4827, 4828, 7, 16, 0, 0, 4828, 4829, 3, 100, 50, 0, 4829, 431, 1, 0, 0, 0, 4830, 4835, 5, 138, 0, 0, 4831, 4832, 5, 136, 0, 0, 4832, 4836, 3, 394, 197, 0, 4833, 4834, 5, 442, 0, 0, 4834, 4836, 3, 374, 187, 0, 4835, 4831, 1, 0, 0, 0, 4835, 4833, 1, 0, 0, 0, 4836, 4837, 1, 0, 0, 0, 4837, 4838, 5, 309, 0, 0, 4838, 4839, 5, 94, 0, 0, 4839, 4840, 3, 818, 409, 0, 4840, 5038, 1, 0, 0, 0, 4841, 4842, 5, 138, 0, 0, 4842, 4843, 5, 175, 0, 0, 4843, 4844, 3, 788, 394, 0, 4844, 4845, 5, 309, 0, 0, 4845, 4846, 5, 94, 0, 0, 4846, 4847, 3, 786, 393, 0, 4847, 5038, 1, 0, 0, 0, 4848, 4849, 5, 138, 0, 0, 4849, 4850, 7, 61, 0, 0, 4850, 4851, 3, 316, 158, 0, 4851, 4852, 5, 309, 0, 0, 4852, 4853, 5, 94, 0, 0, 4853, 4854, 3, 818, 409, 0, 4854, 5038, 1, 0, 0, 0, 4855, 4856, 5, 138, 0, 0, 4856, 4857, 5, 211, 0, 0, 4857, 4858, 3, 382, 191, 0, 4858, 4859, 5, 309, 0, 0, 4859, 4860, 5, 94, 0, 0, 4860, 4861, 3, 804, 402, 0, 4861, 5038, 1, 0, 0, 0, 4862, 4863, 5, 138, 0, 0, 4863, 4864, 5, 278, 0, 0, 4864, 4865, 7, 31, 0, 0, 4865, 4866, 3, 316, 158, 0, 4866, 4867, 3, 170, 85, 0, 4867, 4868, 5, 309, 0, 0, 4868, 4869, 5, 94, 0, 0, 4869, 4870, 3, 818, 409, 0, 4870, 5038, 1, 0, 0, 0, 4871, 4872, 5, 138, 0, 0, 4872, 4873, 5, 296, 0, 0, 4873, 4874, 3, 378, 189, 0, 4874, 4875, 5, 309, 0, 0, 4875, 4876, 5, 94, 0, 0, 4876, 4877, 3, 798, 399, 0, 4877, 5038, 1, 0, 0, 0, 4878, 4879, 5, 138, 0, 0, 4879, 4880, 5, 323, 0, 0, 4880, 4881, 3, 790, 395, 0, 4881, 4882, 5, 309, 0, 0, 4882, 4883, 5, 94, 0, 0, 4883, 4884, 3, 32, 16, 0, 4884, 5038, 1, 0, 0, 0, 4885, 4886, 5, 138, 0, 0, 4886, 4888, 7, 62, 0, 0, 4887, 4889, 3, 422, 211, 0, 4888, 4887, 1, 0, 0, 0, 4888, 4889, 1, 0, 0, 0, 4889, 4890, 1, 0, 0, 0, 4890, 4891, 3, 780, 390, 0, 4891, 4892, 5, 309, 0, 0, 4892, 4893, 5, 94, 0, 0, 4893, 4894, 3, 818, 409, 0, 4894, 5038, 1, 0, 0, 0, 4895, 4897, 5, 138, 0, 0, 4896, 4898, 5, 259, 0, 0, 4897, 4896, 1, 0, 0, 0, 4897, 4898, 1, 0, 0, 0, 4898, 4899, 1, 0, 0, 0, 4899, 4901, 5, 376, 0, 0, 4900, 4902, 3, 422, 211, 0, 4901, 4900, 1, 0, 0, 0, 4901, 4902, 1, 0, 0, 0, 4902, 4903, 1, 0, 0, 0, 4903, 4904, 3, 778, 389, 0, 4904, 4905, 5, 309, 0, 0, 4905, 4906, 5, 94, 0, 0, 4906, 4907, 3, 776, 388, 0, 4907, 5038, 1, 0, 0, 0, 4908, 4910, 5, 138, 0, 0, 4909, 4911, 5, 63, 0, 0, 4910, 4909, 1, 0, 0, 0, 4910, 4911, 1, 0, 0, 0, 4911, 4912, 1, 0, 0, 0, 4912, 4914, 5, 92, 0, 0, 4913, 4915, 3, 422, 211, 0, 4914, 4913, 1, 0, 0, 0, 4914, 4915, 1, 0, 0, 0, 4915, 4916, 1, 0, 0, 0, 4916, 4917, 3, 624, 312, 0, 4917, 4918, 5, 309, 0, 0, 4918, 4919, 5, 94, 0, 0, 4919, 4920, 3, 772, 386, 0, 4920, 5038, 1, 0, 0, 0, 4921, 4946, 5, 138, 0, 0, 4922, 4924, 5, 63, 0, 0, 4923, 4922, 1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 4925, 1, 0, 0, 0, 4925, 4927, 5, 92, 0, 0, 4926, 4928, 3, 422, 211, 0, 4927, 4926, 1, 0, 0, 0, 4927, 4928, 1, 0, 0, 0, 4928, 4929, 1, 0, 0, 0, 4929, 4930, 3, 624, 312, 0, 4930, 4932, 5, 309, 0, 0, 4931, 4933, 5, 44, 0, 0, 4932, 4931, 1, 0, 0, 0, 4932, 4933, 1, 0, 0, 0, 4933, 4947, 1, 0, 0, 0, 4934, 4936, 5, 259, 0, 0, 4935, 4934, 1, 0, 0, 0, 4935, 4936, 1, 0, 0, 0, 4936, 4937, 1, 0, 0, 0, 4937, 4939, 5, 376, 0, 0, 4938, 4940, 3, 422, 211, 0, 4939, 4938, 1, 0, 0, 0, 4939, 4940, 1, 0, 0, 0, 4940, 4941, 1, 0, 0, 0, 4941, 4942, 3, 778, 389, 0, 4942, 4944, 5, 309, 0, 0, 4943, 4945, 5, 44, 0, 0, 4944, 4943, 1, 0, 0, 0, 4944, 4945, 1, 0, 0, 0, 4945, 4947, 1, 0, 0, 0, 4946, 4923, 1, 0, 0, 0, 4946, 4935, 1, 0, 0, 0, 4947, 4948, 1, 0, 0, 0, 4948, 4949, 3, 800, 400, 0, 4949, 4950, 5, 94, 0, 0, 4950, 4951, 3, 802, 401, 0, 4951, 5038, 1, 0, 0, 0, 4952, 4960, 5, 138, 0, 0, 4953, 4955, 5, 92, 0, 0, 4954, 4956, 3, 422, 211, 0, 4955, 4954, 1, 0, 0, 0, 4955, 4956, 1, 0, 0, 0, 4956, 4957, 1, 0, 0, 0, 4957, 4961, 3, 624, 312, 0, 4958, 4959, 5, 189, 0, 0, 4959, 4961, 3, 316, 158, 0, 4960, 4953, 1, 0, 0, 0, 4960, 4958, 1, 0, 0, 0, 4961, 4962, 1, 0, 0, 0, 4962, 4963, 5, 309, 0, 0, 4963, 4964, 5, 45, 0, 0, 4964, 4965, 3, 818, 409, 0, 4965, 4966, 5, 94, 0, 0, 4966, 4967, 3, 818, 409, 0, 4967, 5038, 1, 0, 0, 0, 4968, 4975, 5, 138, 0, 0, 4969, 4971, 5, 445, 0, 0, 4970, 4972, 3, 422, 211, 0, 4971, 4970, 1, 0, 0, 0, 4971, 4972, 1, 0, 0, 0, 4972, 4976, 1, 0, 0, 0, 4973, 4976, 5, 321, 0, 0, 4974, 4976, 5, 357, 0, 0, 4975, 4969, 1, 0, 0, 0, 4975, 4973, 1, 0, 0, 0, 4975, 4974, 1, 0, 0, 0, 4976, 4977, 1, 0, 0, 0, 4977, 4978, 3, 818, 409, 0, 4978, 4979, 5, 80, 0, 0, 4979, 4980, 3, 780, 390, 0, 4980, 4981, 5, 309, 0, 0, 4981, 4982, 5, 94, 0, 0, 4982, 4983, 3, 818, 409, 0, 4983, 5038, 1, 0, 0, 0, 4984, 4997, 5, 138, 0, 0, 4985, 4986, 5, 63, 0, 0, 4986, 4987, 5, 174, 0, 0, 4987, 4998, 5, 381, 0, 0, 4988, 4990, 5, 295, 0, 0, 4989, 4988, 1, 0, 0, 0, 4989, 4990, 1, 0, 0, 0, 4990, 4991, 1, 0, 0, 0, 4991, 4998, 5, 247, 0, 0, 4992, 4998, 5, 452, 0, 0, 4993, 4998, 5, 331, 0, 0, 4994, 4998, 5, 451, 0, 0, 4995, 4996, 5, 198, 0, 0, 4996, 4998, 5, 357, 0, 0, 4997, 4985, 1, 0, 0, 0, 4997, 4989, 1, 0, 0, 0, 4997, 4992, 1, 0, 0, 0, 4997, 4993, 1, 0, 0, 0, 4997, 4994, 1, 0, 0, 0, 4997, 4995, 1, 0, 0, 0, 4998, 4999, 1, 0, 0, 0, 4999, 5000, 3, 818, 409, 0, 5000, 5001, 5, 309, 0, 0, 5001, 5002, 5, 94, 0, 0, 5002, 5003, 3, 818, 409, 0, 5003, 5038, 1, 0, 0, 0, 5004, 5005, 5, 138, 0, 0, 5005, 5006, 7, 45, 0, 0, 5006, 5007, 3, 814, 407, 0, 5007, 5008, 5, 309, 0, 0, 5008, 5009, 5, 94, 0, 0, 5009, 5010, 3, 814, 407, 0, 5010, 5038, 1, 0, 0, 0, 5011, 5012, 5, 138, 0, 0, 5012, 5013, 3, 176, 88, 0, 5013, 5014, 5, 309, 0, 0, 5014, 5015, 5, 94, 0, 0, 5015, 5016, 3, 768, 384, 0, 5016, 5038, 1, 0, 0, 0, 5017, 5018, 5, 138, 0, 0, 5018, 5019, 5, 355, 0, 0, 5019, 5020, 5, 325, 0, 0, 5020, 5021, 7, 41, 0, 0, 5021, 5022, 3, 316, 158, 0, 5022, 5023, 5, 309, 0, 0, 5023, 5024, 5, 94, 0, 0, 5024, 5025, 3, 818, 409, 0, 5025, 5038, 1, 0, 0, 0, 5026, 5027, 5, 138, 0, 0, 5027, 5028, 5, 360, 0, 0, 5028, 5029, 3, 316, 158, 0, 5029, 5030, 5, 309, 0, 0, 5030, 5031, 5, 143, 0, 0, 5031, 5032, 3, 818, 409, 0, 5032, 5033, 5, 94, 0, 0, 5033, 5035, 3, 818, 409, 0, 5034, 5036, 3, 96, 48, 0, 5035, 5034, 1, 0, 0, 0, 5035, 5036, 1, 0, 0, 0, 5036, 5038, 1, 0, 0, 0, 5037, 4830, 1, 0, 0, 0, 5037, 4841, 1, 0, 0, 0, 5037, 4848, 1, 0, 0, 0, 5037, 4855, 1, 0, 0, 0, 5037, 4862, 1, 0, 0, 0, 5037, 4871, 1, 0, 0, 0, 5037, 4878, 1, 0, 0, 0, 5037, 4885, 1, 0, 0, 0, 5037, 4895, 1, 0, 0, 0, 5037, 4908, 1, 0, 0, 0, 5037, 4921, 1, 0, 0, 0, 5037, 4952, 1, 0, 0, 0, 5037, 4968, 1, 0, 0, 0, 5037, 4984, 1, 0, 0, 0, 5037, 5004, 1, 0, 0, 0, 5037, 5011, 1, 0, 0, 0, 5037, 5017, 1, 0, 0, 0, 5037, 5026, 1, 0, 0, 0, 5038, 433, 1, 0, 0, 0, 5039, 5056, 5, 138, 0, 0, 5040, 5041, 5, 211, 0, 0, 5041, 5057, 3, 382, 191, 0, 5042, 5043, 5, 296, 0, 0, 5043, 5057, 3, 378, 189, 0, 5044, 5045, 5, 442, 0, 0, 5045, 5057, 3, 374, 187, 0, 5046, 5047, 5, 357, 0, 0, 5047, 5048, 3, 818, 409, 0, 5048, 5049, 5, 80, 0, 0, 5049, 5050, 3, 780, 390, 0, 5050, 5057, 1, 0, 0, 0, 5051, 5052, 5, 259, 0, 0, 5052, 5053, 5, 376, 0, 0, 5053, 5057, 3, 778, 389, 0, 5054, 5055, 5, 226, 0, 0, 5055, 5057, 3, 780, 390, 0, 5056, 5040, 1, 0, 0, 0, 5056, 5042, 1, 0, 0, 0, 5056, 5044, 1, 0, 0, 0, 5056, 5046, 1, 0, 0, 0, 5056, 5051, 1, 0, 0, 0, 5056, 5054, 1, 0, 0, 0, 5057, 5059, 1, 0, 0, 0, 5058, 5060, 5, 269, 0, 0, 5059, 5058, 1, 0, 0, 0, 5059, 5060, 1, 0, 0, 0, 5060, 5061, 1, 0, 0, 0, 5061, 5062, 5, 462, 0, 0, 5062, 5063, 5, 80, 0, 0, 5063, 5064, 5, 204, 0, 0, 5064, 5065, 3, 818, 409, 0, 5065, 435, 1, 0, 0, 0, 5066, 5105, 5, 138, 0, 0, 5067, 5068, 5, 136, 0, 0, 5068, 5106, 3, 394, 197, 0, 5069, 5070, 5, 204, 0, 0, 5070, 5106, 3, 818, 409, 0, 5071, 5072, 5, 211, 0, 0, 5072, 5106, 3, 382, 191, 0, 5073, 5074, 5, 278, 0, 0, 5074, 5106, 3, 416, 208, 0, 5075, 5076, 5, 278, 0, 0, 5076, 5077, 7, 31, 0, 0, 5077, 5078, 3, 316, 158, 0, 5078, 5079, 3, 170, 85, 0, 5079, 5106, 1, 0, 0, 0, 5080, 5081, 5, 296, 0, 0, 5081, 5106, 3, 378, 189, 0, 5082, 5083, 5, 442, 0, 0, 5083, 5106, 3, 374, 187, 0, 5084, 5086, 5, 328, 0, 0, 5085, 5087, 3, 422, 211, 0, 5086, 5085, 1, 0, 0, 0, 5086, 5087, 1, 0, 0, 0, 5087, 5088, 1, 0, 0, 0, 5088, 5106, 3, 780, 390, 0, 5089, 5091, 5, 259, 0, 0, 5090, 5089, 1, 0, 0, 0, 5090, 5091, 1, 0, 0, 0, 5091, 5092, 1, 0, 0, 0, 5092, 5094, 5, 376, 0, 0, 5093, 5095, 3, 422, 211, 0, 5094, 5093, 1, 0, 0, 0, 5094, 5095, 1, 0, 0, 0, 5095, 5096, 1, 0, 0, 0, 5096, 5106, 3, 778, 389, 0, 5097, 5099, 5, 63, 0, 0, 5098, 5097, 1, 0, 0, 0, 5098, 5099, 1, 0, 0, 0, 5099, 5100, 1, 0, 0, 0, 5100, 5102, 5, 92, 0, 0, 5101, 5103, 3, 422, 211, 0, 5102, 5101, 1, 0, 0, 0, 5102, 5103, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5106, 3, 624, 312, 0, 5105, 5067, 1, 0, 0, 0, 5105, 5069, 1, 0, 0, 0, 5105, 5071, 1, 0, 0, 0, 5105, 5073, 1, 0, 0, 0, 5105, 5075, 1, 0, 0, 0, 5105, 5080, 1, 0, 0, 0, 5105, 5082, 1, 0, 0, 0, 5105, 5084, 1, 0, 0, 0, 5105, 5090, 1, 0, 0, 0, 5105, 5098, 1, 0, 0, 0, 5106, 5107, 1, 0, 0, 0, 5107, 5108, 5, 333, 0, 0, 5108, 5109, 5, 323, 0, 0, 5109, 5110, 3, 790, 395, 0, 5110, 5128, 1, 0, 0, 0, 5111, 5120, 5, 138, 0, 0, 5112, 5113, 5, 355, 0, 0, 5113, 5114, 5, 325, 0, 0, 5114, 5121, 7, 41, 0, 0, 5115, 5121, 5, 108, 0, 0, 5116, 5121, 5, 168, 0, 0, 5117, 5121, 5, 189, 0, 0, 5118, 5121, 5, 342, 0, 0, 5119, 5121, 5, 360, 0, 0, 5120, 5112, 1, 0, 0, 0, 5120, 5115, 1, 0, 0, 0, 5120, 5116, 1, 0, 0, 0, 5120, 5117, 1, 0, 0, 0, 5120, 5118, 1, 0, 0, 0, 5120, 5119, 1, 0, 0, 0, 5121, 5122, 1, 0, 0, 0, 5122, 5123, 3, 316, 158, 0, 5123, 5124, 5, 333, 0, 0, 5124, 5125, 5, 323, 0, 0, 5125, 5126, 3, 790, 395, 0, 5126, 5128, 1, 0, 0, 0, 5127, 5066, 1, 0, 0, 0, 5127, 5111, 1, 0, 0, 0, 5128, 437, 1, 0, 0, 0, 5129, 5130, 5, 138, 0, 0, 5130, 5131, 5, 278, 0, 0, 5131, 5132, 3, 416, 208, 0, 5132, 5133, 5, 333, 0, 0, 5133, 5134, 3, 440, 220, 0, 5134, 439, 1, 0, 0, 0, 5135, 5136, 5, 2, 0, 0, 5136, 5141, 3, 442, 221, 0, 5137, 5138, 5, 6, 0, 0, 5138, 5140, 3, 442, 221, 0, 5139, 5137, 1, 0, 0, 0, 5140, 5143, 1, 0, 0, 0, 5141, 5139, 1, 0, 0, 0, 5141, 5142, 1, 0, 0, 0, 5142, 5144, 1, 0, 0, 0, 5143, 5141, 1, 0, 0, 0, 5144, 5145, 5, 3, 0, 0, 5145, 441, 1, 0, 0, 0, 5146, 5147, 3, 824, 412, 0, 5147, 5154, 5, 10, 0, 0, 5148, 5155, 5, 407, 0, 0, 5149, 5155, 3, 388, 194, 0, 5150, 5155, 3, 834, 417, 0, 5151, 5155, 3, 726, 363, 0, 5152, 5155, 3, 202, 101, 0, 5153, 5155, 3, 808, 404, 0, 5154, 5148, 1, 0, 0, 0, 5154, 5149, 1, 0, 0, 0, 5154, 5150, 1, 0, 0, 0, 5154, 5151, 1, 0, 0, 0, 5154, 5152, 1, 0, 0, 0, 5154, 5153, 1, 0, 0, 0, 5155, 443, 1, 0, 0, 0, 5156, 5157, 5, 138, 0, 0, 5157, 5158, 5, 360, 0, 0, 5158, 5159, 3, 316, 158, 0, 5159, 5160, 5, 333, 0, 0, 5160, 5161, 3, 440, 220, 0, 5161, 445, 1, 0, 0, 0, 5162, 5163, 5, 138, 0, 0, 5163, 5164, 5, 278, 0, 0, 5164, 5165, 7, 31, 0, 0, 5165, 5166, 3, 316, 158, 0, 5166, 5167, 3, 170, 85, 0, 5167, 5168, 5, 282, 0, 0, 5168, 5169, 5, 94, 0, 0, 5169, 5170, 3, 814, 407, 0, 5170, 5237, 1, 0, 0, 0, 5171, 5198, 5, 138, 0, 0, 5172, 5173, 5, 136, 0, 0, 5173, 5199, 3, 394, 197, 0, 5174, 5175, 5, 175, 0, 0, 5175, 5199, 3, 788, 394, 0, 5176, 5177, 5, 211, 0, 0, 5177, 5199, 3, 382, 191, 0, 5178, 5180, 5, 295, 0, 0, 5179, 5178, 1, 0, 0, 0, 5179, 5180, 1, 0, 0, 0, 5180, 5181, 1, 0, 0, 0, 5181, 5182, 5, 247, 0, 0, 5182, 5199, 3, 818, 409, 0, 5183, 5184, 5, 248, 0, 0, 5184, 5185, 5, 274, 0, 0, 5185, 5199, 3, 202, 101, 0, 5186, 5187, 5, 248, 0, 0, 5187, 5188, 5, 274, 0, 0, 5188, 5199, 3, 202, 101, 0, 5189, 5190, 5, 278, 0, 0, 5190, 5199, 3, 416, 208, 0, 5191, 5192, 5, 296, 0, 0, 5192, 5199, 3, 378, 189, 0, 5193, 5194, 5, 442, 0, 0, 5194, 5199, 3, 374, 187, 0, 5195, 5196, 5, 323, 0, 0, 5196, 5199, 3, 790, 395, 0, 5197, 5199, 3, 176, 88, 0, 5198, 5172, 1, 0, 0, 0, 5198, 5174, 1, 0, 0, 0, 5198, 5176, 1, 0, 0, 0, 5198, 5179, 1, 0, 0, 0, 5198, 5183, 1, 0, 0, 0, 5198, 5186, 1, 0, 0, 0, 5198, 5189, 1, 0, 0, 0, 5198, 5191, 1, 0, 0, 0, 5198, 5193, 1, 0, 0, 0, 5198, 5195, 1, 0, 0, 0, 5198, 5197, 1, 0, 0, 0, 5199, 5200, 1, 0, 0, 0, 5200, 5201, 5, 282, 0, 0, 5201, 5202, 5, 94, 0, 0, 5202, 5203, 3, 814, 407, 0, 5203, 5237, 1, 0, 0, 0, 5204, 5213, 5, 138, 0, 0, 5205, 5206, 5, 355, 0, 0, 5206, 5207, 5, 325, 0, 0, 5207, 5214, 7, 63, 0, 0, 5208, 5214, 5, 108, 0, 0, 5209, 5214, 5, 168, 0, 0, 5210, 5214, 5, 189, 0, 0, 5211, 5214, 5, 360, 0, 0, 5212, 5214, 5, 342, 0, 0, 5213, 5205, 1, 0, 0, 0, 5213, 5208, 1, 0, 0, 0, 5213, 5209, 1, 0, 0, 0, 5213, 5210, 1, 0, 0, 0, 5213, 5211, 1, 0, 0, 0, 5213, 5212, 1, 0, 0, 0, 5214, 5215, 1, 0, 0, 0, 5215, 5216, 3, 316, 158, 0, 5216, 5217, 5, 282, 0, 0, 5217, 5218, 5, 94, 0, 0, 5218, 5219, 3, 814, 407, 0, 5219, 5237, 1, 0, 0, 0, 5220, 5229, 5, 138, 0, 0, 5221, 5230, 5, 331, 0, 0, 5222, 5223, 5, 63, 0, 0, 5223, 5224, 5, 174, 0, 0, 5224, 5230, 5, 381, 0, 0, 5225, 5226, 5, 198, 0, 0, 5226, 5230, 5, 357, 0, 0, 5227, 5230, 5, 452, 0, 0, 5228, 5230, 5, 451, 0, 0, 5229, 5221, 1, 0, 0, 0, 5229, 5222, 1, 0, 0, 0, 5229, 5225, 1, 0, 0, 0, 5229, 5227, 1, 0, 0, 0, 5229, 5228, 1, 0, 0, 0, 5230, 5231, 1, 0, 0, 0, 5231, 5232, 3, 818, 409, 0, 5232, 5233, 5, 282, 0, 0, 5233, 5234, 5, 94, 0, 0, 5234, 5235, 3, 814, 407, 0, 5235, 5237, 1, 0, 0, 0, 5236, 5162, 1, 0, 0, 0, 5236, 5171, 1, 0, 0, 0, 5236, 5204, 1, 0, 0, 0, 5236, 5220, 1, 0, 0, 0, 5237, 447, 1, 0, 0, 0, 5238, 5239, 5, 46, 0, 0, 5239, 5240, 5, 452, 0, 0, 5240, 5247, 3, 818, 409, 0, 5241, 5242, 5, 62, 0, 0, 5242, 5243, 5, 92, 0, 0, 5243, 5248, 3, 628, 314, 0, 5244, 5245, 5, 62, 0, 0, 5245, 5246, 5, 30, 0, 0, 5246, 5248, 5, 350, 0, 0, 5247, 5241, 1, 0, 0, 0, 5247, 5244, 1, 0, 0, 0, 5247, 5248, 1, 0, 0, 0, 5248, 5250, 1, 0, 0, 0, 5249, 5251, 3, 400, 200, 0, 5250, 5249, 1, 0, 0, 0, 5250, 5251, 1, 0, 0, 0, 5251, 449, 1, 0, 0, 0, 5252, 5253, 5, 138, 0, 0, 5253, 5254, 5, 452, 0, 0, 5254, 5272, 3, 818, 409, 0, 5255, 5256, 5, 282, 0, 0, 5256, 5257, 5, 94, 0, 0, 5257, 5273, 3, 814, 407, 0, 5258, 5259, 5, 333, 0, 0, 5259, 5273, 3, 284, 142, 0, 5260, 5261, 5, 309, 0, 0, 5261, 5262, 5, 94, 0, 0, 5262, 5273, 3, 818, 409, 0, 5263, 5264, 7, 34, 0, 0, 5264, 5269, 3, 626, 313, 0, 5265, 5266, 5, 6, 0, 0, 5266, 5268, 3, 626, 313, 0, 5267, 5265, 1, 0, 0, 0, 5268, 5271, 1, 0, 0, 0, 5269, 5267, 1, 0, 0, 0, 5269, 5270, 1, 0, 0, 0, 5270, 5273, 1, 0, 0, 0, 5271, 5269, 1, 0, 0, 0, 5272, 5255, 1, 0, 0, 0, 5272, 5258, 1, 0, 0, 0, 5272, 5260, 1, 0, 0, 0, 5272, 5263, 1, 0, 0, 0, 5273, 451, 1, 0, 0, 0, 5274, 5275, 5, 46, 0, 0, 5275, 5276, 5, 451, 0, 0, 5276, 5277, 3, 818, 409, 0, 5277, 5278, 5, 164, 0, 0, 5278, 5279, 3, 808, 404, 0, 5279, 5280, 5, 452, 0, 0, 5280, 5285, 3, 824, 412, 0, 5281, 5282, 5, 6, 0, 0, 5282, 5284, 3, 824, 412, 0, 5283, 5281, 1, 0, 0, 0, 5284, 5287, 1, 0, 0, 0, 5285, 5283, 1, 0, 0, 0, 5285, 5286, 1, 0, 0, 0, 5286, 5289, 1, 0, 0, 0, 5287, 5285, 1, 0, 0, 0, 5288, 5290, 3, 400, 200, 0, 5289, 5288, 1, 0, 0, 0, 5289, 5290, 1, 0, 0, 0, 5290, 453, 1, 0, 0, 0, 5291, 5292, 5, 138, 0, 0, 5292, 5293, 5, 451, 0, 0, 5293, 5294, 3, 818, 409, 0, 5294, 5295, 5, 333, 0, 0, 5295, 5296, 3, 284, 142, 0, 5296, 5348, 1, 0, 0, 0, 5297, 5298, 5, 138, 0, 0, 5298, 5299, 5, 451, 0, 0, 5299, 5300, 3, 818, 409, 0, 5300, 5301, 5, 164, 0, 0, 5301, 5302, 3, 808, 404, 0, 5302, 5348, 1, 0, 0, 0, 5303, 5304, 5, 138, 0, 0, 5304, 5305, 5, 451, 0, 0, 5305, 5306, 3, 818, 409, 0, 5306, 5307, 5, 305, 0, 0, 5307, 5309, 5, 452, 0, 0, 5308, 5310, 3, 400, 200, 0, 5309, 5308, 1, 0, 0, 0, 5309, 5310, 1, 0, 0, 0, 5310, 5348, 1, 0, 0, 0, 5311, 5312, 5, 138, 0, 0, 5312, 5313, 5, 451, 0, 0, 5313, 5314, 3, 818, 409, 0, 5314, 5315, 7, 34, 0, 0, 5315, 5316, 5, 452, 0, 0, 5316, 5321, 3, 824, 412, 0, 5317, 5318, 5, 6, 0, 0, 5318, 5320, 3, 824, 412, 0, 5319, 5317, 1, 0, 0, 0, 5320, 5323, 1, 0, 0, 0, 5321, 5319, 1, 0, 0, 0, 5321, 5322, 1, 0, 0, 0, 5322, 5325, 1, 0, 0, 0, 5323, 5321, 1, 0, 0, 0, 5324, 5326, 3, 400, 200, 0, 5325, 5324, 1, 0, 0, 0, 5325, 5326, 1, 0, 0, 0, 5326, 5348, 1, 0, 0, 0, 5327, 5328, 5, 138, 0, 0, 5328, 5329, 5, 451, 0, 0, 5329, 5330, 3, 818, 409, 0, 5330, 5331, 7, 64, 0, 0, 5331, 5348, 1, 0, 0, 0, 5332, 5333, 5, 138, 0, 0, 5333, 5334, 5, 451, 0, 0, 5334, 5335, 3, 818, 409, 0, 5335, 5336, 5, 465, 0, 0, 5336, 5337, 5, 2, 0, 0, 5337, 5338, 3, 290, 145, 0, 5338, 5339, 5, 3, 0, 0, 5339, 5348, 1, 0, 0, 0, 5340, 5341, 5, 138, 0, 0, 5341, 5342, 5, 451, 0, 0, 5342, 5343, 3, 818, 409, 0, 5343, 5344, 5, 282, 0, 0, 5344, 5345, 5, 94, 0, 0, 5345, 5346, 3, 814, 407, 0, 5346, 5348, 1, 0, 0, 0, 5347, 5291, 1, 0, 0, 0, 5347, 5297, 1, 0, 0, 0, 5347, 5303, 1, 0, 0, 0, 5347, 5311, 1, 0, 0, 0, 5347, 5327, 1, 0, 0, 0, 5347, 5332, 1, 0, 0, 0, 5347, 5340, 1, 0, 0, 0, 5348, 455, 1, 0, 0, 0, 5349, 5351, 5, 46, 0, 0, 5350, 5352, 3, 366, 183, 0, 5351, 5350, 1, 0, 0, 0, 5351, 5352, 1, 0, 0, 0, 5352, 5353, 1, 0, 0, 0, 5353, 5354, 5, 321, 0, 0, 5354, 5355, 3, 818, 409, 0, 5355, 5356, 5, 36, 0, 0, 5356, 5357, 5, 80, 0, 0, 5357, 5358, 7, 65, 0, 0, 5358, 5359, 5, 94, 0, 0, 5359, 5361, 3, 780, 390, 0, 5360, 5362, 3, 638, 319, 0, 5361, 5360, 1, 0, 0, 0, 5361, 5362, 1, 0, 0, 0, 5362, 5363, 1, 0, 0, 0, 5363, 5365, 5, 57, 0, 0, 5364, 5366, 7, 66, 0, 0, 5365, 5364, 1, 0, 0, 0, 5365, 5366, 1, 0, 0, 0, 5366, 5383, 1, 0, 0, 0, 5367, 5384, 5, 270, 0, 0, 5368, 5384, 3, 458, 229, 0, 5369, 5371, 5, 2, 0, 0, 5370, 5372, 3, 458, 229, 0, 5371, 5370, 1, 0, 0, 0, 5371, 5372, 1, 0, 0, 0, 5372, 5379, 1, 0, 0, 0, 5373, 5375, 5, 7, 0, 0, 5374, 5376, 3, 458, 229, 0, 5375, 5374, 1, 0, 0, 0, 5375, 5376, 1, 0, 0, 0, 5376, 5378, 1, 0, 0, 0, 5377, 5373, 1, 0, 0, 0, 5378, 5381, 1, 0, 0, 0, 5379, 5377, 1, 0, 0, 0, 5379, 5380, 1, 0, 0, 0, 5380, 5382, 1, 0, 0, 0, 5381, 5379, 1, 0, 0, 0, 5382, 5384, 5, 3, 0, 0, 5383, 5367, 1, 0, 0, 0, 5383, 5368, 1, 0, 0, 0, 5383, 5369, 1, 0, 0, 0, 5384, 457, 1, 0, 0, 0, 5385, 5391, 3, 560, 280, 0, 5386, 5391, 3, 538, 269, 0, 5387, 5391, 3, 552, 276, 0, 5388, 5391, 3, 548, 274, 0, 5389, 5391, 3, 460, 230, 0, 5390, 5385, 1, 0, 0, 0, 5390, 5386, 1, 0, 0, 0, 5390, 5387, 1, 0, 0, 0, 5390, 5388, 1, 0, 0, 0, 5390, 5389, 1, 0, 0, 0, 5391, 459, 1, 0, 0, 0, 5392, 5393, 5, 271, 0, 0, 5393, 5395, 3, 818, 409, 0, 5394, 5396, 3, 462, 231, 0, 5395, 5394, 1, 0, 0, 0, 5395, 5396, 1, 0, 0, 0, 5396, 461, 1, 0, 0, 0, 5397, 5398, 5, 6, 0, 0, 5398, 5399, 3, 808, 404, 0, 5399, 463, 1, 0, 0, 0, 5400, 5401, 5, 252, 0, 0, 5401, 5402, 3, 818, 409, 0, 5402, 465, 1, 0, 0, 0, 5403, 5406, 5, 366, 0, 0, 5404, 5407, 3, 818, 409, 0, 5405, 5407, 5, 9, 0, 0, 5406, 5404, 1, 0, 0, 0, 5406, 5405, 1, 0, 0, 0, 5407, 467, 1, 0, 0, 0, 5408, 5410, 5, 146, 0, 0, 5409, 5411, 3, 470, 235, 0, 5410, 5409, 1, 0, 0, 0, 5410, 5411, 1, 0, 0, 0, 5411, 5413, 1, 0, 0, 0, 5412, 5414, 3, 474, 237, 0, 5413, 5412, 1, 0, 0, 0, 5413, 5414, 1, 0, 0, 0, 5414, 5454, 1, 0, 0, 0, 5415, 5416, 5, 340, 0, 0, 5416, 5418, 5, 356, 0, 0, 5417, 5419, 3, 474, 237, 0, 5418, 5417, 1, 0, 0, 0, 5418, 5419, 1, 0, 0, 0, 5419, 5454, 1, 0, 0, 0, 5420, 5421, 5, 322, 0, 0, 5421, 5454, 3, 818, 409, 0, 5422, 5424, 5, 308, 0, 0, 5423, 5425, 5, 322, 0, 0, 5424, 5423, 1, 0, 0, 0, 5424, 5425, 1, 0, 0, 0, 5425, 5426, 1, 0, 0, 0, 5426, 5454, 3, 818, 409, 0, 5427, 5428, 5, 290, 0, 0, 5428, 5429, 5, 356, 0, 0, 5429, 5454, 3, 808, 404, 0, 5430, 5431, 7, 67, 0, 0, 5431, 5432, 5, 291, 0, 0, 5432, 5454, 3, 808, 404, 0, 5433, 5435, 7, 68, 0, 0, 5434, 5436, 3, 470, 235, 0, 5435, 5434, 1, 0, 0, 0, 5435, 5436, 1, 0, 0, 0, 5436, 5442, 1, 0, 0, 0, 5437, 5439, 5, 33, 0, 0, 5438, 5440, 5, 269, 0, 0, 5439, 5438, 1, 0, 0, 0, 5439, 5440, 1, 0, 0, 0, 5440, 5441, 1, 0, 0, 0, 5441, 5443, 5, 153, 0, 0, 5442, 5437, 1, 0, 0, 0, 5442, 5443, 1, 0, 0, 0, 5443, 5454, 1, 0, 0, 0, 5444, 5446, 5, 319, 0, 0, 5445, 5447, 3, 470, 235, 0, 5446, 5445, 1, 0, 0, 0, 5446, 5447, 1, 0, 0, 0, 5447, 5448, 1, 0, 0, 0, 5448, 5450, 5, 94, 0, 0, 5449, 5451, 5, 322, 0, 0, 5450, 5449, 1, 0, 0, 0, 5450, 5451, 1, 0, 0, 0, 5451, 5452, 1, 0, 0, 0, 5452, 5454, 3, 818, 409, 0, 5453, 5408, 1, 0, 0, 0, 5453, 5415, 1, 0, 0, 0, 5453, 5420, 1, 0, 0, 0, 5453, 5422, 1, 0, 0, 0, 5453, 5427, 1, 0, 0, 0, 5453, 5430, 1, 0, 0, 0, 5453, 5433, 1, 0, 0, 0, 5453, 5444, 1, 0, 0, 0, 5454, 469, 1, 0, 0, 0, 5455, 5456, 7, 69, 0, 0, 5456, 471, 1, 0, 0, 0, 5457, 5458, 5, 244, 0, 0, 5458, 5459, 5, 251, 0, 0, 5459, 5467, 3, 50, 25, 0, 5460, 5461, 5, 300, 0, 0, 5461, 5467, 7, 70, 0, 0, 5462, 5464, 5, 77, 0, 0, 5463, 5462, 1, 0, 0, 0, 5463, 5464, 1, 0, 0, 0, 5464, 5465, 1, 0, 0, 0, 5465, 5467, 5, 54, 0, 0, 5466, 5457, 1, 0, 0, 0, 5466, 5460, 1, 0, 0, 0, 5466, 5463, 1, 0, 0, 0, 5467, 473, 1, 0, 0, 0, 5468, 5475, 3, 472, 236, 0, 5469, 5471, 5, 6, 0, 0, 5470, 5469, 1, 0, 0, 0, 5470, 5471, 1, 0, 0, 0, 5471, 5472, 1, 0, 0, 0, 5472, 5474, 3, 472, 236, 0, 5473, 5470, 1, 0, 0, 0, 5474, 5477, 1, 0, 0, 0, 5475, 5473, 1, 0, 0, 0, 5475, 5476, 1, 0, 0, 0, 5476, 475, 1, 0, 0, 0, 5477, 5475, 1, 0, 0, 0, 5478, 5481, 5, 46, 0, 0, 5479, 5480, 5, 82, 0, 0, 5480, 5482, 5, 311, 0, 0, 5481, 5479, 1, 0, 0, 0, 5481, 5482, 1, 0, 0, 0, 5482, 5484, 1, 0, 0, 0, 5483, 5485, 3, 122, 61, 0, 5484, 5483, 1, 0, 0, 0, 5484, 5485, 1, 0, 0, 0, 5485, 5501, 1, 0, 0, 0, 5486, 5487, 5, 376, 0, 0, 5487, 5489, 3, 776, 388, 0, 5488, 5490, 3, 146, 73, 0, 5489, 5488, 1, 0, 0, 0, 5489, 5490, 1, 0, 0, 0, 5490, 5492, 1, 0, 0, 0, 5491, 5493, 3, 102, 51, 0, 5492, 5491, 1, 0, 0, 0, 5492, 5493, 1, 0, 0, 0, 5493, 5502, 1, 0, 0, 0, 5494, 5495, 5, 303, 0, 0, 5495, 5496, 5, 376, 0, 0, 5496, 5497, 3, 776, 388, 0, 5497, 5499, 3, 144, 72, 0, 5498, 5500, 3, 102, 51, 0, 5499, 5498, 1, 0, 0, 0, 5499, 5500, 1, 0, 0, 0, 5500, 5502, 1, 0, 0, 0, 5501, 5486, 1, 0, 0, 0, 5501, 5494, 1, 0, 0, 0, 5502, 5503, 1, 0, 0, 0, 5503, 5504, 5, 36, 0, 0, 5504, 5511, 3, 560, 280, 0, 5505, 5507, 5, 105, 0, 0, 5506, 5508, 7, 71, 0, 0, 5507, 5506, 1, 0, 0, 0, 5507, 5508, 1, 0, 0, 0, 5508, 5509, 1, 0, 0, 0, 5509, 5510, 5, 42, 0, 0, 5510, 5512, 5, 279, 0, 0, 5511, 5505, 1, 0, 0, 0, 5511, 5512, 1, 0, 0, 0, 5512, 477, 1, 0, 0, 0, 5513, 5514, 5, 253, 0, 0, 5514, 5515, 3, 808, 404, 0, 5515, 479, 1, 0, 0, 0, 5516, 5517, 5, 46, 0, 0, 5517, 5518, 5, 175, 0, 0, 5518, 5520, 3, 786, 393, 0, 5519, 5521, 5, 105, 0, 0, 5520, 5519, 1, 0, 0, 0, 5520, 5521, 1, 0, 0, 0, 5521, 5527, 1, 0, 0, 0, 5522, 5524, 3, 482, 241, 0, 5523, 5522, 1, 0, 0, 0, 5524, 5525, 1, 0, 0, 0, 5525, 5523, 1, 0, 0, 0, 5525, 5526, 1, 0, 0, 0, 5526, 5528, 1, 0, 0, 0, 5527, 5523, 1, 0, 0, 0, 5527, 5528, 1, 0, 0, 0, 5528, 481, 1, 0, 0, 0, 5529, 5530, 5, 164, 0, 0, 5530, 5538, 5, 74, 0, 0, 5531, 5538, 5, 194, 0, 0, 5532, 5538, 5, 255, 0, 0, 5533, 5538, 5, 282, 0, 0, 5534, 5538, 5, 351, 0, 0, 5535, 5538, 5, 353, 0, 0, 5536, 5538, 3, 826, 413, 0, 5537, 5529, 1, 0, 0, 0, 5537, 5531, 1, 0, 0, 0, 5537, 5532, 1, 0, 0, 0, 5537, 5533, 1, 0, 0, 0, 5537, 5534, 1, 0, 0, 0, 5537, 5535, 1, 0, 0, 0, 5537, 5536, 1, 0, 0, 0, 5538, 5540, 1, 0, 0, 0, 5539, 5541, 5, 10, 0, 0, 5540, 5539, 1, 0, 0, 0, 5540, 5541, 1, 0, 0, 0, 5541, 5545, 1, 0, 0, 0, 5542, 5546, 3, 812, 406, 0, 5543, 5546, 3, 54, 27, 0, 5544, 5546, 5, 53, 0, 0, 5545, 5542, 1, 0, 0, 0, 5545, 5543, 1, 0, 0, 0, 5545, 5544, 1, 0, 0, 0, 5546, 483, 1, 0, 0, 0, 5547, 5548, 5, 138, 0, 0, 5548, 5549, 5, 175, 0, 0, 5549, 5565, 3, 788, 394, 0, 5550, 5551, 5, 333, 0, 0, 5551, 5552, 5, 351, 0, 0, 5552, 5554, 3, 768, 384, 0, 5553, 5550, 1, 0, 0, 0, 5553, 5554, 1, 0, 0, 0, 5554, 5566, 1, 0, 0, 0, 5555, 5557, 5, 105, 0, 0, 5556, 5555, 1, 0, 0, 0, 5556, 5557, 1, 0, 0, 0, 5557, 5559, 1, 0, 0, 0, 5558, 5560, 3, 482, 241, 0, 5559, 5558, 1, 0, 0, 0, 5560, 5561, 1, 0, 0, 0, 5561, 5559, 1, 0, 0, 0, 5561, 5562, 1, 0, 0, 0, 5562, 5564, 1, 0, 0, 0, 5563, 5556, 1, 0, 0, 0, 5563, 5564, 1, 0, 0, 0, 5564, 5566, 1, 0, 0, 0, 5565, 5553, 1, 0, 0, 0, 5565, 5563, 1, 0, 0, 0, 5566, 485, 1, 0, 0, 0, 5567, 5568, 5, 138, 0, 0, 5568, 5569, 5, 175, 0, 0, 5569, 5571, 3, 788, 394, 0, 5570, 5572, 3, 64, 32, 0, 5571, 5570, 1, 0, 0, 0, 5571, 5572, 1, 0, 0, 0, 5572, 487, 1, 0, 0, 0, 5573, 5574, 5, 138, 0, 0, 5574, 5575, 5, 108, 0, 0, 5575, 5576, 3, 316, 158, 0, 5576, 5577, 5, 305, 0, 0, 5577, 5578, 5, 375, 0, 0, 5578, 489, 1, 0, 0, 0, 5579, 5580, 5, 138, 0, 0, 5580, 5581, 5, 349, 0, 0, 5581, 5582, 7, 16, 0, 0, 5582, 5583, 3, 40, 20, 0, 5583, 491, 1, 0, 0, 0, 5584, 5585, 5, 46, 0, 0, 5585, 5586, 5, 189, 0, 0, 5586, 5588, 3, 316, 158, 0, 5587, 5589, 5, 36, 0, 0, 5588, 5587, 1, 0, 0, 0, 5588, 5589, 1, 0, 0, 0, 5589, 5590, 1, 0, 0, 0, 5590, 5594, 3, 652, 326, 0, 5591, 5593, 3, 134, 67, 0, 5592, 5591, 1, 0, 0, 0, 5593, 5596, 1, 0, 0, 0, 5594, 5592, 1, 0, 0, 0, 5594, 5595, 1, 0, 0, 0, 5595, 493, 1, 0, 0, 0, 5596, 5594, 1, 0, 0, 0, 5597, 5598, 5, 138, 0, 0, 5598, 5599, 5, 189, 0, 0, 5599, 5622, 3, 316, 158, 0, 5600, 5623, 3, 94, 47, 0, 5601, 5602, 7, 15, 0, 0, 5602, 5603, 5, 77, 0, 0, 5603, 5623, 5, 78, 0, 0, 5604, 5607, 5, 133, 0, 0, 5605, 5606, 5, 45, 0, 0, 5606, 5608, 3, 818, 409, 0, 5607, 5605, 1, 0, 0, 0, 5607, 5608, 1, 0, 0, 0, 5608, 5609, 1, 0, 0, 0, 5609, 5623, 3, 142, 71, 0, 5610, 5611, 5, 191, 0, 0, 5611, 5613, 5, 45, 0, 0, 5612, 5614, 3, 422, 211, 0, 5613, 5612, 1, 0, 0, 0, 5613, 5614, 1, 0, 0, 0, 5614, 5615, 1, 0, 0, 0, 5615, 5617, 3, 818, 409, 0, 5616, 5618, 3, 96, 48, 0, 5617, 5616, 1, 0, 0, 0, 5617, 5618, 1, 0, 0, 0, 5618, 5623, 1, 0, 0, 0, 5619, 5620, 5, 372, 0, 0, 5620, 5621, 5, 45, 0, 0, 5621, 5623, 3, 818, 409, 0, 5622, 5600, 1, 0, 0, 0, 5622, 5601, 1, 0, 0, 0, 5622, 5604, 1, 0, 0, 0, 5622, 5610, 1, 0, 0, 0, 5622, 5619, 1, 0, 0, 0, 5623, 495, 1, 0, 0, 0, 5624, 5625, 5, 138, 0, 0, 5625, 5626, 5, 355, 0, 0, 5626, 5627, 5, 325, 0, 0, 5627, 5628, 5, 185, 0, 0, 5628, 5629, 3, 316, 158, 0, 5629, 5630, 3, 284, 142, 0, 5630, 497, 1, 0, 0, 0, 5631, 5632, 5, 138, 0, 0, 5632, 5633, 5, 355, 0, 0, 5633, 5634, 5, 325, 0, 0, 5634, 5635, 5, 163, 0, 0, 5635, 5636, 3, 316, 158, 0, 5636, 5637, 7, 72, 0, 0, 5637, 5638, 5, 257, 0, 0, 5638, 5639, 5, 62, 0, 0, 5639, 5640, 3, 784, 392, 0, 5640, 5641, 5, 105, 0, 0, 5641, 5642, 3, 314, 157, 0, 5642, 5673, 1, 0, 0, 0, 5643, 5644, 5, 138, 0, 0, 5644, 5645, 5, 355, 0, 0, 5645, 5646, 5, 325, 0, 0, 5646, 5647, 5, 163, 0, 0, 5647, 5648, 3, 316, 158, 0, 5648, 5649, 5, 138, 0, 0, 5649, 5652, 5, 257, 0, 0, 5650, 5651, 5, 62, 0, 0, 5651, 5653, 3, 784, 392, 0, 5652, 5650, 1, 0, 0, 0, 5652, 5653, 1, 0, 0, 0, 5653, 5654, 1, 0, 0, 0, 5654, 5655, 5, 311, 0, 0, 5655, 5656, 3, 316, 158, 0, 5656, 5657, 5, 105, 0, 0, 5657, 5658, 3, 316, 158, 0, 5658, 5673, 1, 0, 0, 0, 5659, 5660, 5, 138, 0, 0, 5660, 5661, 5, 355, 0, 0, 5661, 5662, 5, 325, 0, 0, 5662, 5663, 5, 163, 0, 0, 5663, 5664, 3, 316, 158, 0, 5664, 5665, 5, 191, 0, 0, 5665, 5667, 5, 257, 0, 0, 5666, 5668, 3, 422, 211, 0, 5667, 5666, 1, 0, 0, 0, 5667, 5668, 1, 0, 0, 0, 5668, 5669, 1, 0, 0, 0, 5669, 5670, 5, 62, 0, 0, 5670, 5671, 3, 784, 392, 0, 5671, 5673, 1, 0, 0, 0, 5672, 5631, 1, 0, 0, 0, 5672, 5643, 1, 0, 0, 0, 5672, 5659, 1, 0, 0, 0, 5673, 499, 1, 0, 0, 0, 5674, 5676, 5, 46, 0, 0, 5675, 5677, 5, 53, 0, 0, 5676, 5675, 1, 0, 0, 0, 5676, 5677, 1, 0, 0, 0, 5677, 5678, 1, 0, 0, 0, 5678, 5679, 5, 168, 0, 0, 5679, 5680, 3, 316, 158, 0, 5680, 5681, 5, 62, 0, 0, 5681, 5682, 3, 808, 404, 0, 5682, 5683, 5, 94, 0, 0, 5683, 5684, 3, 808, 404, 0, 5684, 5685, 5, 64, 0, 0, 5685, 5686, 3, 316, 158, 0, 5686, 501, 1, 0, 0, 0, 5687, 5689, 5, 158, 0, 0, 5688, 5690, 3, 514, 257, 0, 5689, 5688, 1, 0, 0, 0, 5689, 5690, 1, 0, 0, 0, 5690, 5695, 1, 0, 0, 0, 5691, 5693, 3, 774, 387, 0, 5692, 5694, 3, 170, 85, 0, 5693, 5692, 1, 0, 0, 0, 5693, 5694, 1, 0, 0, 0, 5694, 5696, 1, 0, 0, 0, 5695, 5691, 1, 0, 0, 0, 5695, 5696, 1, 0, 0, 0, 5696, 5713, 1, 0, 0, 0, 5697, 5698, 5, 158, 0, 0, 5698, 5699, 5, 2, 0, 0, 5699, 5704, 3, 514, 257, 0, 5700, 5701, 5, 6, 0, 0, 5701, 5703, 3, 514, 257, 0, 5702, 5700, 1, 0, 0, 0, 5703, 5706, 1, 0, 0, 0, 5704, 5702, 1, 0, 0, 0, 5704, 5705, 1, 0, 0, 0, 5705, 5707, 1, 0, 0, 0, 5706, 5704, 1, 0, 0, 0, 5707, 5708, 5, 3, 0, 0, 5708, 5710, 3, 774, 387, 0, 5709, 5711, 3, 170, 85, 0, 5710, 5709, 1, 0, 0, 0, 5710, 5711, 1, 0, 0, 0, 5711, 5713, 1, 0, 0, 0, 5712, 5687, 1, 0, 0, 0, 5712, 5697, 1, 0, 0, 0, 5713, 503, 1, 0, 0, 0, 5714, 5730, 5, 370, 0, 0, 5715, 5717, 5, 113, 0, 0, 5716, 5715, 1, 0, 0, 0, 5716, 5717, 1, 0, 0, 0, 5717, 5719, 1, 0, 0, 0, 5718, 5720, 5, 112, 0, 0, 5719, 5718, 1, 0, 0, 0, 5719, 5720, 1, 0, 0, 0, 5720, 5722, 1, 0, 0, 0, 5721, 5723, 3, 514, 257, 0, 5722, 5721, 1, 0, 0, 0, 5722, 5723, 1, 0, 0, 0, 5723, 5725, 1, 0, 0, 0, 5724, 5726, 3, 508, 254, 0, 5725, 5724, 1, 0, 0, 0, 5725, 5726, 1, 0, 0, 0, 5726, 5731, 1, 0, 0, 0, 5727, 5729, 3, 524, 262, 0, 5728, 5727, 1, 0, 0, 0, 5728, 5729, 1, 0, 0, 0, 5729, 5731, 1, 0, 0, 0, 5730, 5716, 1, 0, 0, 0, 5730, 5728, 1, 0, 0, 0, 5731, 5733, 1, 0, 0, 0, 5732, 5734, 3, 518, 259, 0, 5733, 5732, 1, 0, 0, 0, 5733, 5734, 1, 0, 0, 0, 5734, 505, 1, 0, 0, 0, 5735, 5750, 3, 508, 254, 0, 5736, 5738, 3, 514, 257, 0, 5737, 5736, 1, 0, 0, 0, 5737, 5738, 1, 0, 0, 0, 5738, 5751, 1, 0, 0, 0, 5739, 5740, 5, 2, 0, 0, 5740, 5745, 3, 512, 256, 0, 5741, 5742, 5, 6, 0, 0, 5742, 5744, 3, 512, 256, 0, 5743, 5741, 1, 0, 0, 0, 5744, 5747, 1, 0, 0, 0, 5745, 5743, 1, 0, 0, 0, 5745, 5746, 1, 0, 0, 0, 5746, 5748, 1, 0, 0, 0, 5747, 5745, 1, 0, 0, 0, 5748, 5749, 5, 3, 0, 0, 5749, 5751, 1, 0, 0, 0, 5750, 5737, 1, 0, 0, 0, 5750, 5739, 1, 0, 0, 0, 5751, 5753, 1, 0, 0, 0, 5752, 5754, 3, 518, 259, 0, 5753, 5752, 1, 0, 0, 0, 5753, 5754, 1, 0, 0, 0, 5754, 507, 1, 0, 0, 0, 5755, 5756, 7, 73, 0, 0, 5756, 509, 1, 0, 0, 0, 5757, 5760, 3, 822, 411, 0, 5758, 5760, 3, 508, 254, 0, 5759, 5757, 1, 0, 0, 0, 5759, 5758, 1, 0, 0, 0, 5760, 5763, 1, 0, 0, 0, 5761, 5764, 3, 54, 27, 0, 5762, 5764, 3, 202, 101, 0, 5763, 5761, 1, 0, 0, 0, 5763, 5762, 1, 0, 0, 0, 5763, 5764, 1, 0, 0, 0, 5764, 511, 1, 0, 0, 0, 5765, 5767, 7, 74, 0, 0, 5766, 5768, 7, 75, 0, 0, 5767, 5766, 1, 0, 0, 0, 5767, 5768, 1, 0, 0, 0, 5768, 5775, 1, 0, 0, 0, 5769, 5772, 5, 548, 0, 0, 5770, 5773, 3, 202, 101, 0, 5771, 5773, 3, 808, 404, 0, 5772, 5770, 1, 0, 0, 0, 5772, 5771, 1, 0, 0, 0, 5773, 5775, 1, 0, 0, 0, 5774, 5765, 1, 0, 0, 0, 5774, 5769, 1, 0, 0, 0, 5775, 513, 1, 0, 0, 0, 5776, 5778, 5, 128, 0, 0, 5777, 5779, 7, 75, 0, 0, 5778, 5777, 1, 0, 0, 0, 5778, 5779, 1, 0, 0, 0, 5779, 515, 1, 0, 0, 0, 5780, 5782, 3, 774, 387, 0, 5781, 5783, 3, 144, 72, 0, 5782, 5781, 1, 0, 0, 0, 5782, 5783, 1, 0, 0, 0, 5783, 517, 1, 0, 0, 0, 5784, 5789, 3, 516, 258, 0, 5785, 5786, 5, 6, 0, 0, 5786, 5788, 3, 516, 258, 0, 5787, 5785, 1, 0, 0, 0, 5788, 5791, 1, 0, 0, 0, 5789, 5787, 1, 0, 0, 0, 5789, 5790, 1, 0, 0, 0, 5790, 519, 1, 0, 0, 0, 5791, 5789, 1, 0, 0, 0, 5792, 5803, 5, 203, 0, 0, 5793, 5804, 3, 524, 262, 0, 5794, 5796, 5, 128, 0, 0, 5795, 5794, 1, 0, 0, 0, 5795, 5796, 1, 0, 0, 0, 5796, 5804, 1, 0, 0, 0, 5797, 5799, 3, 508, 254, 0, 5798, 5800, 3, 514, 257, 0, 5799, 5798, 1, 0, 0, 0, 5799, 5800, 1, 0, 0, 0, 5800, 5802, 1, 0, 0, 0, 5801, 5797, 1, 0, 0, 0, 5801, 5802, 1, 0, 0, 0, 5802, 5804, 1, 0, 0, 0, 5803, 5793, 1, 0, 0, 0, 5803, 5795, 1, 0, 0, 0, 5803, 5801, 1, 0, 0, 0, 5804, 5805, 1, 0, 0, 0, 5805, 5806, 3, 522, 261, 0, 5806, 521, 1, 0, 0, 0, 5807, 5817, 3, 560, 280, 0, 5808, 5817, 3, 538, 269, 0, 5809, 5817, 3, 552, 276, 0, 5810, 5817, 3, 548, 274, 0, 5811, 5817, 3, 558, 279, 0, 5812, 5817, 3, 186, 93, 0, 5813, 5817, 3, 192, 96, 0, 5814, 5817, 3, 194, 97, 0, 5815, 5817, 3, 532, 266, 0, 5816, 5807, 1, 0, 0, 0, 5816, 5808, 1, 0, 0, 0, 5816, 5809, 1, 0, 0, 0, 5816, 5810, 1, 0, 0, 0, 5816, 5811, 1, 0, 0, 0, 5816, 5812, 1, 0, 0, 0, 5816, 5813, 1, 0, 0, 0, 5816, 5814, 1, 0, 0, 0, 5816, 5815, 1, 0, 0, 0, 5817, 523, 1, 0, 0, 0, 5818, 5819, 5, 2, 0, 0, 5819, 5824, 3, 510, 255, 0, 5820, 5821, 5, 6, 0, 0, 5821, 5823, 3, 510, 255, 0, 5822, 5820, 1, 0, 0, 0, 5823, 5826, 1, 0, 0, 0, 5824, 5822, 1, 0, 0, 0, 5824, 5825, 1, 0, 0, 0, 5825, 5827, 1, 0, 0, 0, 5826, 5824, 1, 0, 0, 0, 5827, 5828, 5, 3, 0, 0, 5828, 525, 1, 0, 0, 0, 5829, 5830, 5, 290, 0, 0, 5830, 5832, 3, 818, 409, 0, 5831, 5833, 3, 528, 264, 0, 5832, 5831, 1, 0, 0, 0, 5832, 5833, 1, 0, 0, 0, 5833, 5834, 1, 0, 0, 0, 5834, 5835, 5, 36, 0, 0, 5835, 5836, 3, 530, 265, 0, 5836, 527, 1, 0, 0, 0, 5837, 5838, 5, 2, 0, 0, 5838, 5843, 3, 652, 326, 0, 5839, 5840, 5, 6, 0, 0, 5840, 5842, 3, 652, 326, 0, 5841, 5839, 1, 0, 0, 0, 5842, 5845, 1, 0, 0, 0, 5843, 5841, 1, 0, 0, 0, 5843, 5844, 1, 0, 0, 0, 5844, 5846, 1, 0, 0, 0, 5845, 5843, 1, 0, 0, 0, 5846, 5847, 5, 3, 0, 0, 5847, 529, 1, 0, 0, 0, 5848, 5853, 3, 560, 280, 0, 5849, 5853, 3, 538, 269, 0, 5850, 5853, 3, 552, 276, 0, 5851, 5853, 3, 548, 274, 0, 5852, 5848, 1, 0, 0, 0, 5852, 5849, 1, 0, 0, 0, 5852, 5850, 1, 0, 0, 0, 5852, 5851, 1, 0, 0, 0, 5853, 531, 1, 0, 0, 0, 5854, 5855, 5, 202, 0, 0, 5855, 5857, 3, 818, 409, 0, 5856, 5858, 3, 534, 267, 0, 5857, 5856, 1, 0, 0, 0, 5857, 5858, 1, 0, 0, 0, 5858, 5878, 1, 0, 0, 0, 5859, 5861, 5, 46, 0, 0, 5860, 5862, 3, 122, 61, 0, 5861, 5860, 1, 0, 0, 0, 5861, 5862, 1, 0, 0, 0, 5862, 5863, 1, 0, 0, 0, 5863, 5865, 5, 92, 0, 0, 5864, 5866, 3, 294, 147, 0, 5865, 5864, 1, 0, 0, 0, 5865, 5866, 1, 0, 0, 0, 5866, 5867, 1, 0, 0, 0, 5867, 5868, 3, 188, 94, 0, 5868, 5869, 5, 36, 0, 0, 5869, 5870, 5, 202, 0, 0, 5870, 5872, 3, 818, 409, 0, 5871, 5873, 3, 534, 267, 0, 5872, 5871, 1, 0, 0, 0, 5872, 5873, 1, 0, 0, 0, 5873, 5875, 1, 0, 0, 0, 5874, 5876, 3, 190, 95, 0, 5875, 5874, 1, 0, 0, 0, 5875, 5876, 1, 0, 0, 0, 5876, 5878, 1, 0, 0, 0, 5877, 5854, 1, 0, 0, 0, 5877, 5859, 1, 0, 0, 0, 5878, 533, 1, 0, 0, 0, 5879, 5880, 5, 2, 0, 0, 5880, 5881, 3, 730, 365, 0, 5881, 5882, 5, 3, 0, 0, 5882, 535, 1, 0, 0, 0, 5883, 5885, 5, 177, 0, 0, 5884, 5886, 5, 290, 0, 0, 5885, 5884, 1, 0, 0, 0, 5885, 5886, 1, 0, 0, 0, 5886, 5889, 1, 0, 0, 0, 5887, 5890, 3, 818, 409, 0, 5888, 5890, 5, 30, 0, 0, 5889, 5887, 1, 0, 0, 0, 5889, 5888, 1, 0, 0, 0, 5890, 537, 1, 0, 0, 0, 5891, 5893, 3, 572, 286, 0, 5892, 5891, 1, 0, 0, 0, 5892, 5893, 1, 0, 0, 0, 5893, 5894, 1, 0, 0, 0, 5894, 5895, 5, 241, 0, 0, 5895, 5896, 5, 71, 0, 0, 5896, 5899, 3, 774, 387, 0, 5897, 5898, 5, 36, 0, 0, 5898, 5900, 3, 818, 409, 0, 5899, 5897, 1, 0, 0, 0, 5899, 5900, 1, 0, 0, 0, 5900, 5901, 1, 0, 0, 0, 5901, 5923, 3, 540, 270, 0, 5902, 5903, 5, 80, 0, 0, 5903, 5911, 5, 464, 0, 0, 5904, 5906, 3, 360, 180, 0, 5905, 5907, 3, 638, 319, 0, 5906, 5905, 1, 0, 0, 0, 5906, 5907, 1, 0, 0, 0, 5907, 5912, 1, 0, 0, 0, 5908, 5909, 5, 80, 0, 0, 5909, 5910, 5, 45, 0, 0, 5910, 5912, 3, 818, 409, 0, 5911, 5904, 1, 0, 0, 0, 5911, 5908, 1, 0, 0, 0, 5911, 5912, 1, 0, 0, 0, 5912, 5913, 1, 0, 0, 0, 5913, 5921, 5, 57, 0, 0, 5914, 5915, 5, 369, 0, 0, 5915, 5916, 5, 333, 0, 0, 5916, 5918, 3, 554, 277, 0, 5917, 5919, 3, 638, 319, 0, 5918, 5917, 1, 0, 0, 0, 5918, 5919, 1, 0, 0, 0, 5919, 5922, 1, 0, 0, 0, 5920, 5922, 5, 270, 0, 0, 5921, 5914, 1, 0, 0, 0, 5921, 5920, 1, 0, 0, 0, 5922, 5924, 1, 0, 0, 0, 5923, 5902, 1, 0, 0, 0, 5923, 5924, 1, 0, 0, 0, 5924, 5926, 1, 0, 0, 0, 5925, 5927, 3, 546, 273, 0, 5926, 5925, 1, 0, 0, 0, 5926, 5927, 1, 0, 0, 0, 5927, 539, 1, 0, 0, 0, 5928, 5929, 5, 2, 0, 0, 5929, 5930, 3, 542, 271, 0, 5930, 5931, 5, 3, 0, 0, 5931, 5933, 1, 0, 0, 0, 5932, 5928, 1, 0, 0, 0, 5932, 5933, 1, 0, 0, 0, 5933, 5937, 1, 0, 0, 0, 5934, 5935, 5, 463, 0, 0, 5935, 5936, 7, 76, 0, 0, 5936, 5938, 5, 450, 0, 0, 5937, 5934, 1, 0, 0, 0, 5937, 5938, 1, 0, 0, 0, 5938, 5941, 1, 0, 0, 0, 5939, 5942, 3, 910, 455, 0, 5940, 5942, 3, 560, 280, 0, 5941, 5939, 1, 0, 0, 0, 5941, 5940, 1, 0, 0, 0, 5942, 541, 1, 0, 0, 0, 5943, 5948, 3, 544, 272, 0, 5944, 5945, 5, 6, 0, 0, 5945, 5947, 3, 544, 272, 0, 5946, 5944, 1, 0, 0, 0, 5947, 5950, 1, 0, 0, 0, 5948, 5946, 1, 0, 0, 0, 5948, 5949, 1, 0, 0, 0, 5949, 543, 1, 0, 0, 0, 5950, 5948, 1, 0, 0, 0, 5951, 5952, 3, 800, 400, 0, 5952, 5953, 3, 754, 377, 0, 5953, 545, 1, 0, 0, 0, 5954, 5955, 5, 87, 0, 0, 5955, 5956, 3, 756, 378, 0, 5956, 547, 1, 0, 0, 0, 5957, 5959, 3, 572, 286, 0, 5958, 5957, 1, 0, 0, 0, 5958, 5959, 1, 0, 0, 0, 5959, 5960, 1, 0, 0, 0, 5960, 5961, 5, 182, 0, 0, 5961, 5962, 5, 64, 0, 0, 5962, 5965, 3, 630, 315, 0, 5963, 5964, 5, 100, 0, 0, 5964, 5966, 3, 612, 306, 0, 5965, 5963, 1, 0, 0, 0, 5965, 5966, 1, 0, 0, 0, 5966, 5968, 1, 0, 0, 0, 5967, 5969, 3, 640, 320, 0, 5968, 5967, 1, 0, 0, 0, 5968, 5969, 1, 0, 0, 0, 5969, 5971, 1, 0, 0, 0, 5970, 5972, 3, 546, 273, 0, 5971, 5970, 1, 0, 0, 0, 5971, 5972, 1, 0, 0, 0, 5972, 549, 1, 0, 0, 0, 5973, 5975, 5, 256, 0, 0, 5974, 5976, 5, 92, 0, 0, 5975, 5974, 1, 0, 0, 0, 5975, 5976, 1, 0, 0, 0, 5976, 5977, 1, 0, 0, 0, 5977, 5992, 3, 628, 314, 0, 5978, 5989, 5, 68, 0, 0, 5979, 5980, 7, 77, 0, 0, 5980, 5990, 7, 78, 0, 0, 5981, 5986, 5, 334, 0, 0, 5982, 5983, 5, 369, 0, 0, 5983, 5987, 5, 201, 0, 0, 5984, 5985, 5, 414, 0, 0, 5985, 5987, 5, 201, 0, 0, 5986, 5982, 1, 0, 0, 0, 5986, 5984, 1, 0, 0, 0, 5986, 5987, 1, 0, 0, 0, 5987, 5990, 1, 0, 0, 0, 5988, 5990, 5, 201, 0, 0, 5989, 5979, 1, 0, 0, 0, 5989, 5981, 1, 0, 0, 0, 5989, 5988, 1, 0, 0, 0, 5990, 5991, 1, 0, 0, 0, 5991, 5993, 5, 263, 0, 0, 5992, 5978, 1, 0, 0, 0, 5992, 5993, 1, 0, 0, 0, 5993, 5995, 1, 0, 0, 0, 5994, 5996, 5, 272, 0, 0, 5995, 5994, 1, 0, 0, 0, 5995, 5996, 1, 0, 0, 0, 5996, 551, 1, 0, 0, 0, 5997, 5999, 3, 572, 286, 0, 5998, 5997, 1, 0, 0, 0, 5998, 5999, 1, 0, 0, 0, 5999, 6000, 1, 0, 0, 0, 6000, 6001, 5, 369, 0, 0, 6001, 6002, 3, 630, 315, 0, 6002, 6003, 5, 333, 0, 0, 6003, 6005, 3, 554, 277, 0, 6004, 6006, 3, 610, 305, 0, 6005, 6004, 1, 0, 0, 0, 6005, 6006, 1, 0, 0, 0, 6006, 6008, 1, 0, 0, 0, 6007, 6009, 3, 640, 320, 0, 6008, 6007, 1, 0, 0, 0, 6008, 6009, 1, 0, 0, 0, 6009, 6011, 1, 0, 0, 0, 6010, 6012, 3, 546, 273, 0, 6011, 6010, 1, 0, 0, 0, 6011, 6012, 1, 0, 0, 0, 6012, 553, 1, 0, 0, 0, 6013, 6018, 3, 556, 278, 0, 6014, 6015, 5, 6, 0, 0, 6015, 6017, 3, 556, 278, 0, 6016, 6014, 1, 0, 0, 0, 6017, 6020, 1, 0, 0, 0, 6018, 6016, 1, 0, 0, 0, 6018, 6019, 1, 0, 0, 0, 6019, 555, 1, 0, 0, 0, 6020, 6018, 1, 0, 0, 0, 6021, 6022, 3, 544, 272, 0, 6022, 6023, 5, 10, 0, 0, 6023, 6024, 3, 674, 337, 0, 6024, 6040, 1, 0, 0, 0, 6025, 6026, 5, 2, 0, 0, 6026, 6027, 3, 542, 271, 0, 6027, 6028, 5, 3, 0, 0, 6028, 6037, 5, 10, 0, 0, 6029, 6031, 5, 414, 0, 0, 6030, 6029, 1, 0, 0, 0, 6030, 6031, 1, 0, 0, 0, 6031, 6032, 1, 0, 0, 0, 6032, 6038, 3, 674, 337, 0, 6033, 6034, 5, 2, 0, 0, 6034, 6035, 3, 566, 283, 0, 6035, 6036, 5, 3, 0, 0, 6036, 6038, 1, 0, 0, 0, 6037, 6030, 1, 0, 0, 0, 6037, 6033, 1, 0, 0, 0, 6038, 6040, 1, 0, 0, 0, 6039, 6021, 1, 0, 0, 0, 6039, 6025, 1, 0, 0, 0, 6040, 557, 1, 0, 0, 0, 6041, 6042, 5, 178, 0, 0, 6042, 6051, 3, 818, 409, 0, 6043, 6045, 5, 269, 0, 0, 6044, 6043, 1, 0, 0, 0, 6044, 6045, 1, 0, 0, 0, 6045, 6046, 1, 0, 0, 0, 6046, 6050, 5, 324, 0, 0, 6047, 6050, 5, 107, 0, 0, 6048, 6050, 5, 240, 0, 0, 6049, 6044, 1, 0, 0, 0, 6049, 6047, 1, 0, 0, 0, 6049, 6048, 1, 0, 0, 0, 6050, 6053, 1, 0, 0, 0, 6051, 6049, 1, 0, 0, 0, 6051, 6052, 1, 0, 0, 0, 6052, 6054, 1, 0, 0, 0, 6053, 6051, 1, 0, 0, 0, 6054, 6057, 5, 172, 0, 0, 6055, 6056, 7, 26, 0, 0, 6056, 6058, 5, 217, 0, 0, 6057, 6055, 1, 0, 0, 0, 6057, 6058, 1, 0, 0, 0, 6058, 6059, 1, 0, 0, 0, 6059, 6060, 5, 62, 0, 0, 6060, 6061, 3, 560, 280, 0, 6061, 559, 1, 0, 0, 0, 6062, 6065, 3, 564, 282, 0, 6063, 6065, 3, 562, 281, 0, 6064, 6062, 1, 0, 0, 0, 6064, 6063, 1, 0, 0, 0, 6065, 561, 1, 0, 0, 0, 6066, 6069, 5, 2, 0, 0, 6067, 6070, 3, 564, 282, 0, 6068, 6070, 3, 562, 281, 0, 6069, 6067, 1, 0, 0, 0, 6069, 6068, 1, 0, 0, 0, 6070, 6071, 1, 0, 0, 0, 6071, 6072, 5, 3, 0, 0, 6072, 563, 1, 0, 0, 0, 6073, 6075, 3, 572, 286, 0, 6074, 6073, 1, 0, 0, 0, 6074, 6075, 1, 0, 0, 0, 6075, 6076, 1, 0, 0, 0, 6076, 6078, 3, 566, 283, 0, 6077, 6079, 3, 586, 293, 0, 6078, 6077, 1, 0, 0, 0, 6078, 6079, 1, 0, 0, 0, 6079, 6088, 1, 0, 0, 0, 6080, 6082, 3, 606, 303, 0, 6081, 6083, 3, 590, 295, 0, 6082, 6081, 1, 0, 0, 0, 6082, 6083, 1, 0, 0, 0, 6083, 6089, 1, 0, 0, 0, 6084, 6086, 3, 590, 295, 0, 6085, 6087, 3, 606, 303, 0, 6086, 6085, 1, 0, 0, 0, 6086, 6087, 1, 0, 0, 0, 6087, 6089, 1, 0, 0, 0, 6088, 6080, 1, 0, 0, 0, 6088, 6084, 1, 0, 0, 0, 6088, 6089, 1, 0, 0, 0, 6089, 565, 1, 0, 0, 0, 6090, 6093, 3, 568, 284, 0, 6091, 6093, 3, 562, 281, 0, 6092, 6090, 1, 0, 0, 0, 6092, 6091, 1, 0, 0, 0, 6093, 567, 1, 0, 0, 0, 6094, 6104, 5, 88, 0, 0, 6095, 6097, 5, 30, 0, 0, 6096, 6095, 1, 0, 0, 0, 6096, 6097, 1, 0, 0, 0, 6097, 6099, 1, 0, 0, 0, 6098, 6100, 3, 580, 290, 0, 6099, 6098, 1, 0, 0, 0, 6099, 6100, 1, 0, 0, 0, 6100, 6105, 1, 0, 0, 0, 6101, 6103, 3, 584, 292, 0, 6102, 6101, 1, 0, 0, 0, 6102, 6103, 1, 0, 0, 0, 6103, 6105, 1, 0, 0, 0, 6104, 6096, 1, 0, 0, 0, 6104, 6102, 1, 0, 0, 0, 6105, 6106, 1, 0, 0, 0, 6106, 6117, 3, 930, 465, 0, 6107, 6117, 3, 608, 304, 0, 6108, 6109, 5, 92, 0, 0, 6109, 6117, 3, 624, 312, 0, 6110, 6111, 3, 562, 281, 0, 6111, 6114, 3, 570, 285, 0, 6112, 6115, 3, 568, 284, 0, 6113, 6115, 3, 562, 281, 0, 6114, 6112, 1, 0, 0, 0, 6114, 6113, 1, 0, 0, 0, 6115, 6117, 1, 0, 0, 0, 6116, 6094, 1, 0, 0, 0, 6116, 6107, 1, 0, 0, 0, 6116, 6108, 1, 0, 0, 0, 6116, 6110, 1, 0, 0, 0, 6117, 6125, 1, 0, 0, 0, 6118, 6121, 3, 570, 285, 0, 6119, 6122, 3, 568, 284, 0, 6120, 6122, 3, 562, 281, 0, 6121, 6119, 1, 0, 0, 0, 6121, 6120, 1, 0, 0, 0, 6122, 6124, 1, 0, 0, 0, 6123, 6118, 1, 0, 0, 0, 6124, 6127, 1, 0, 0, 0, 6125, 6123, 1, 0, 0, 0, 6125, 6126, 1, 0, 0, 0, 6126, 569, 1, 0, 0, 0, 6127, 6125, 1, 0, 0, 0, 6128, 6130, 7, 79, 0, 0, 6129, 6131, 7, 80, 0, 0, 6130, 6129, 1, 0, 0, 0, 6130, 6131, 1, 0, 0, 0, 6131, 571, 1, 0, 0, 0, 6132, 6134, 5, 105, 0, 0, 6133, 6135, 5, 303, 0, 0, 6134, 6133, 1, 0, 0, 0, 6134, 6135, 1, 0, 0, 0, 6135, 6136, 1, 0, 0, 0, 6136, 6141, 3, 574, 287, 0, 6137, 6138, 5, 6, 0, 0, 6138, 6140, 3, 574, 287, 0, 6139, 6137, 1, 0, 0, 0, 6140, 6143, 1, 0, 0, 0, 6141, 6139, 1, 0, 0, 0, 6141, 6142, 1, 0, 0, 0, 6142, 573, 1, 0, 0, 0, 6143, 6141, 1, 0, 0, 0, 6144, 6146, 3, 818, 409, 0, 6145, 6147, 3, 144, 72, 0, 6146, 6145, 1, 0, 0, 0, 6146, 6147, 1, 0, 0, 0, 6147, 6148, 1, 0, 0, 0, 6148, 6153, 5, 36, 0, 0, 6149, 6151, 5, 77, 0, 0, 6150, 6149, 1, 0, 0, 0, 6150, 6151, 1, 0, 0, 0, 6151, 6152, 1, 0, 0, 0, 6152, 6154, 5, 259, 0, 0, 6153, 6150, 1, 0, 0, 0, 6153, 6154, 1, 0, 0, 0, 6154, 6155, 1, 0, 0, 0, 6155, 6156, 5, 2, 0, 0, 6156, 6157, 3, 530, 265, 0, 6157, 6159, 5, 3, 0, 0, 6158, 6160, 3, 576, 288, 0, 6159, 6158, 1, 0, 0, 0, 6159, 6160, 1, 0, 0, 0, 6160, 6162, 1, 0, 0, 0, 6161, 6163, 3, 578, 289, 0, 6162, 6161, 1, 0, 0, 0, 6162, 6163, 1, 0, 0, 0, 6163, 575, 1, 0, 0, 0, 6164, 6165, 5, 325, 0, 0, 6165, 6166, 7, 81, 0, 0, 6166, 6167, 5, 207, 0, 0, 6167, 6168, 5, 147, 0, 0, 6168, 6169, 3, 148, 74, 0, 6169, 6170, 5, 333, 0, 0, 6170, 6171, 3, 800, 400, 0, 6171, 577, 1, 0, 0, 0, 6172, 6173, 5, 173, 0, 0, 6173, 6174, 3, 148, 74, 0, 6174, 6175, 5, 333, 0, 0, 6175, 6181, 3, 800, 400, 0, 6176, 6177, 5, 94, 0, 0, 6177, 6178, 3, 818, 409, 0, 6178, 6179, 5, 53, 0, 0, 6179, 6180, 3, 818, 409, 0, 6180, 6182, 1, 0, 0, 0, 6181, 6176, 1, 0, 0, 0, 6181, 6182, 1, 0, 0, 0, 6182, 6183, 1, 0, 0, 0, 6183, 6184, 5, 100, 0, 0, 6184, 6185, 3, 800, 400, 0, 6185, 579, 1, 0, 0, 0, 6186, 6192, 5, 71, 0, 0, 6187, 6189, 5, 346, 0, 0, 6188, 6187, 1, 0, 0, 0, 6188, 6189, 1, 0, 0, 0, 6189, 6190, 1, 0, 0, 0, 6190, 6193, 3, 582, 291, 0, 6191, 6193, 3, 730, 365, 0, 6192, 6188, 1, 0, 0, 0, 6192, 6191, 1, 0, 0, 0, 6193, 581, 1, 0, 0, 0, 6194, 6196, 7, 20, 0, 0, 6195, 6194, 1, 0, 0, 0, 6195, 6196, 1, 0, 0, 0, 6196, 6197, 1, 0, 0, 0, 6197, 6199, 7, 21, 0, 0, 6198, 6200, 5, 92, 0, 0, 6199, 6198, 1, 0, 0, 0, 6199, 6200, 1, 0, 0, 0, 6200, 6201, 1, 0, 0, 0, 6201, 6210, 3, 772, 386, 0, 6202, 6204, 5, 367, 0, 0, 6203, 6202, 1, 0, 0, 0, 6203, 6204, 1, 0, 0, 0, 6204, 6206, 1, 0, 0, 0, 6205, 6207, 5, 92, 0, 0, 6206, 6205, 1, 0, 0, 0, 6206, 6207, 1, 0, 0, 0, 6207, 6208, 1, 0, 0, 0, 6208, 6210, 3, 772, 386, 0, 6209, 6195, 1, 0, 0, 0, 6209, 6203, 1, 0, 0, 0, 6210, 583, 1, 0, 0, 0, 6211, 6214, 5, 56, 0, 0, 6212, 6213, 5, 80, 0, 0, 6213, 6215, 3, 534, 267, 0, 6214, 6212, 1, 0, 0, 0, 6214, 6215, 1, 0, 0, 0, 6215, 585, 1, 0, 0, 0, 6216, 6217, 5, 83, 0, 0, 6217, 6218, 5, 147, 0, 0, 6218, 6223, 3, 588, 294, 0, 6219, 6220, 5, 6, 0, 0, 6220, 6222, 3, 588, 294, 0, 6221, 6219, 1, 0, 0, 0, 6222, 6225, 1, 0, 0, 0, 6223, 6221, 1, 0, 0, 0, 6223, 6224, 1, 0, 0, 0, 6224, 587, 1, 0, 0, 0, 6225, 6223, 1, 0, 0, 0, 6226, 6230, 3, 734, 367, 0, 6227, 6228, 5, 100, 0, 0, 6228, 6231, 3, 726, 363, 0, 6229, 6231, 7, 55, 0, 0, 6230, 6227, 1, 0, 0, 0, 6230, 6229, 1, 0, 0, 0, 6230, 6231, 1, 0, 0, 0, 6231, 6234, 1, 0, 0, 0, 6232, 6233, 5, 273, 0, 0, 6233, 6235, 7, 56, 0, 0, 6234, 6232, 1, 0, 0, 0, 6234, 6235, 1, 0, 0, 0, 6235, 589, 1, 0, 0, 0, 6236, 6238, 3, 596, 298, 0, 6237, 6239, 3, 594, 297, 0, 6238, 6237, 1, 0, 0, 0, 6238, 6239, 1, 0, 0, 0, 6239, 6248, 1, 0, 0, 0, 6240, 6243, 3, 592, 296, 0, 6241, 6243, 3, 594, 297, 0, 6242, 6240, 1, 0, 0, 0, 6242, 6241, 1, 0, 0, 0, 6243, 6245, 1, 0, 0, 0, 6244, 6246, 3, 596, 298, 0, 6245, 6244, 1, 0, 0, 0, 6245, 6246, 1, 0, 0, 0, 6246, 6248, 1, 0, 0, 0, 6247, 6236, 1, 0, 0, 0, 6247, 6242, 1, 0, 0, 0, 6248, 591, 1, 0, 0, 0, 6249, 6252, 5, 74, 0, 0, 6250, 6253, 3, 674, 337, 0, 6251, 6253, 5, 30, 0, 0, 6252, 6250, 1, 0, 0, 0, 6252, 6251, 1, 0, 0, 0, 6253, 6256, 1, 0, 0, 0, 6254, 6255, 5, 6, 0, 0, 6255, 6257, 3, 674, 337, 0, 6256, 6254, 1, 0, 0, 0, 6256, 6257, 1, 0, 0, 0, 6257, 593, 1, 0, 0, 0, 6258, 6259, 5, 61, 0, 0, 6259, 6261, 7, 82, 0, 0, 6260, 6262, 3, 598, 299, 0, 6261, 6260, 1, 0, 0, 0, 6261, 6262, 1, 0, 0, 0, 6262, 6263, 1, 0, 0, 0, 6263, 6267, 7, 83, 0, 0, 6264, 6268, 5, 81, 0, 0, 6265, 6266, 5, 105, 0, 0, 6266, 6268, 5, 467, 0, 0, 6267, 6264, 1, 0, 0, 0, 6267, 6265, 1, 0, 0, 0, 6268, 595, 1, 0, 0, 0, 6269, 6274, 5, 79, 0, 0, 6270, 6271, 3, 598, 299, 0, 6271, 6272, 7, 83, 0, 0, 6272, 6275, 1, 0, 0, 0, 6273, 6275, 3, 674, 337, 0, 6274, 6270, 1, 0, 0, 0, 6274, 6273, 1, 0, 0, 0, 6275, 597, 1, 0, 0, 0, 6276, 6277, 7, 29, 0, 0, 6277, 6280, 7, 84, 0, 0, 6278, 6280, 3, 682, 341, 0, 6279, 6276, 1, 0, 0, 0, 6279, 6278, 1, 0, 0, 0, 6280, 599, 1, 0, 0, 0, 6281, 6282, 5, 66, 0, 0, 6282, 6284, 5, 147, 0, 0, 6283, 6285, 7, 80, 0, 0, 6284, 6283, 1, 0, 0, 0, 6284, 6285, 1, 0, 0, 0, 6285, 6286, 1, 0, 0, 0, 6286, 6287, 3, 602, 301, 0, 6287, 601, 1, 0, 0, 0, 6288, 6293, 3, 604, 302, 0, 6289, 6290, 5, 6, 0, 0, 6290, 6292, 3, 604, 302, 0, 6291, 6289, 1, 0, 0, 0, 6292, 6295, 1, 0, 0, 0, 6293, 6291, 1, 0, 0, 0, 6293, 6294, 1, 0, 0, 0, 6294, 603, 1, 0, 0, 0, 6295, 6293, 1, 0, 0, 0, 6296, 6320, 3, 734, 367, 0, 6297, 6298, 5, 2, 0, 0, 6298, 6320, 5, 3, 0, 0, 6299, 6301, 7, 85, 0, 0, 6300, 6299, 1, 0, 0, 0, 6300, 6301, 1, 0, 0, 0, 6301, 6302, 1, 0, 0, 0, 6302, 6303, 5, 2, 0, 0, 6303, 6308, 3, 734, 367, 0, 6304, 6305, 5, 6, 0, 0, 6305, 6307, 3, 734, 367, 0, 6306, 6304, 1, 0, 0, 0, 6307, 6310, 1, 0, 0, 0, 6308, 6306, 1, 0, 0, 0, 6308, 6309, 1, 0, 0, 0, 6309, 6311, 1, 0, 0, 0, 6310, 6308, 1, 0, 0, 0, 6311, 6312, 5, 3, 0, 0, 6312, 6320, 1, 0, 0, 0, 6313, 6314, 5, 470, 0, 0, 6314, 6315, 5, 471, 0, 0, 6315, 6316, 5, 2, 0, 0, 6316, 6317, 3, 602, 301, 0, 6317, 6318, 5, 3, 0, 0, 6318, 6320, 1, 0, 0, 0, 6319, 6296, 1, 0, 0, 0, 6319, 6297, 1, 0, 0, 0, 6319, 6300, 1, 0, 0, 0, 6319, 6313, 1, 0, 0, 0, 6320, 605, 1, 0, 0, 0, 6321, 6331, 5, 62, 0, 0, 6322, 6323, 5, 269, 0, 0, 6323, 6325, 5, 245, 0, 0, 6324, 6322, 1, 0, 0, 0, 6324, 6325, 1, 0, 0, 0, 6325, 6326, 1, 0, 0, 0, 6326, 6332, 5, 369, 0, 0, 6327, 6329, 5, 245, 0, 0, 6328, 6327, 1, 0, 0, 0, 6328, 6329, 1, 0, 0, 0, 6329, 6330, 1, 0, 0, 0, 6330, 6332, 5, 334, 0, 0, 6331, 6324, 1, 0, 0, 0, 6331, 6328, 1, 0, 0, 0, 6332, 6335, 1, 0, 0, 0, 6333, 6334, 5, 275, 0, 0, 6334, 6336, 3, 760, 380, 0, 6335, 6333, 1, 0, 0, 0, 6335, 6336, 1, 0, 0, 0, 6336, 6340, 1, 0, 0, 0, 6337, 6341, 5, 272, 0, 0, 6338, 6339, 5, 465, 0, 0, 6339, 6341, 5, 466, 0, 0, 6340, 6337, 1, 0, 0, 0, 6340, 6338, 1, 0, 0, 0, 6340, 6341, 1, 0, 0, 0, 6341, 6343, 1, 0, 0, 0, 6342, 6321, 1, 0, 0, 0, 6343, 6344, 1, 0, 0, 0, 6344, 6342, 1, 0, 0, 0, 6344, 6345, 1, 0, 0, 0, 6345, 6350, 1, 0, 0, 0, 6346, 6347, 5, 62, 0, 0, 6347, 6348, 5, 300, 0, 0, 6348, 6350, 5, 81, 0, 0, 6349, 6342, 1, 0, 0, 0, 6349, 6346, 1, 0, 0, 0, 6350, 607, 1, 0, 0, 0, 6351, 6352, 5, 422, 0, 0, 6352, 6357, 3, 534, 267, 0, 6353, 6354, 5, 6, 0, 0, 6354, 6356, 3, 534, 267, 0, 6355, 6353, 1, 0, 0, 0, 6356, 6359, 1, 0, 0, 0, 6357, 6355, 1, 0, 0, 0, 6357, 6358, 1, 0, 0, 0, 6358, 609, 1, 0, 0, 0, 6359, 6357, 1, 0, 0, 0, 6360, 6361, 5, 64, 0, 0, 6361, 6362, 3, 612, 306, 0, 6362, 611, 1, 0, 0, 0, 6363, 6368, 3, 614, 307, 0, 6364, 6365, 5, 6, 0, 0, 6365, 6367, 3, 614, 307, 0, 6366, 6364, 1, 0, 0, 0, 6367, 6370, 1, 0, 0, 0, 6368, 6366, 1, 0, 0, 0, 6368, 6369, 1, 0, 0, 0, 6369, 613, 1, 0, 0, 0, 6370, 6368, 1, 0, 0, 0, 6371, 6386, 3, 624, 312, 0, 6372, 6374, 5, 81, 0, 0, 6373, 6372, 1, 0, 0, 0, 6373, 6374, 1, 0, 0, 0, 6374, 6375, 1, 0, 0, 0, 6375, 6377, 3, 778, 389, 0, 6376, 6378, 5, 9, 0, 0, 6377, 6376, 1, 0, 0, 0, 6377, 6378, 1, 0, 0, 0, 6378, 6380, 1, 0, 0, 0, 6379, 6381, 3, 148, 74, 0, 6380, 6379, 1, 0, 0, 0, 6380, 6381, 1, 0, 0, 0, 6381, 6383, 1, 0, 0, 0, 6382, 6384, 3, 638, 319, 0, 6383, 6382, 1, 0, 0, 0, 6383, 6384, 1, 0, 0, 0, 6384, 6386, 1, 0, 0, 0, 6385, 6371, 1, 0, 0, 0, 6385, 6373, 1, 0, 0, 0, 6386, 6388, 1, 0, 0, 0, 6387, 6389, 3, 616, 308, 0, 6388, 6387, 1, 0, 0, 0, 6388, 6389, 1, 0, 0, 0, 6389, 6391, 1, 0, 0, 0, 6390, 6392, 3, 632, 316, 0, 6391, 6390, 1, 0, 0, 0, 6391, 6392, 1, 0, 0, 0, 6392, 6435, 1, 0, 0, 0, 6393, 6395, 5, 72, 0, 0, 6394, 6393, 1, 0, 0, 0, 6394, 6395, 1, 0, 0, 0, 6395, 6408, 1, 0, 0, 0, 6396, 6398, 3, 646, 323, 0, 6397, 6399, 3, 616, 308, 0, 6398, 6397, 1, 0, 0, 0, 6398, 6399, 1, 0, 0, 0, 6399, 6409, 1, 0, 0, 0, 6400, 6402, 3, 634, 317, 0, 6401, 6403, 3, 618, 309, 0, 6402, 6401, 1, 0, 0, 0, 6402, 6403, 1, 0, 0, 0, 6403, 6409, 1, 0, 0, 0, 6404, 6406, 3, 562, 281, 0, 6405, 6407, 3, 616, 308, 0, 6406, 6405, 1, 0, 0, 0, 6406, 6407, 1, 0, 0, 0, 6407, 6409, 1, 0, 0, 0, 6408, 6396, 1, 0, 0, 0, 6408, 6400, 1, 0, 0, 0, 6408, 6404, 1, 0, 0, 0, 6409, 6435, 1, 0, 0, 0, 6410, 6411, 5, 2, 0, 0, 6411, 6428, 3, 614, 307, 0, 6412, 6413, 5, 110, 0, 0, 6413, 6414, 5, 118, 0, 0, 6414, 6429, 3, 614, 307, 0, 6415, 6417, 5, 121, 0, 0, 6416, 6418, 3, 620, 310, 0, 6417, 6416, 1, 0, 0, 0, 6417, 6418, 1, 0, 0, 0, 6418, 6419, 1, 0, 0, 0, 6419, 6420, 5, 118, 0, 0, 6420, 6429, 3, 614, 307, 0, 6421, 6423, 3, 620, 310, 0, 6422, 6421, 1, 0, 0, 0, 6422, 6423, 1, 0, 0, 0, 6423, 6424, 1, 0, 0, 0, 6424, 6425, 5, 118, 0, 0, 6425, 6426, 3, 614, 307, 0, 6426, 6427, 3, 622, 311, 0, 6427, 6429, 1, 0, 0, 0, 6428, 6412, 1, 0, 0, 0, 6428, 6415, 1, 0, 0, 0, 6428, 6422, 1, 0, 0, 0, 6428, 6429, 1, 0, 0, 0, 6429, 6430, 1, 0, 0, 0, 6430, 6432, 5, 3, 0, 0, 6431, 6433, 3, 616, 308, 0, 6432, 6431, 1, 0, 0, 0, 6432, 6433, 1, 0, 0, 0, 6433, 6435, 1, 0, 0, 0, 6434, 6385, 1, 0, 0, 0, 6434, 6394, 1, 0, 0, 0, 6434, 6410, 1, 0, 0, 0, 6435, 6454, 1, 0, 0, 0, 6436, 6437, 5, 110, 0, 0, 6437, 6438, 5, 118, 0, 0, 6438, 6453, 3, 614, 307, 0, 6439, 6441, 5, 121, 0, 0, 6440, 6442, 3, 620, 310, 0, 6441, 6440, 1, 0, 0, 0, 6441, 6442, 1, 0, 0, 0, 6442, 6443, 1, 0, 0, 0, 6443, 6444, 5, 118, 0, 0, 6444, 6453, 3, 614, 307, 0, 6445, 6447, 3, 620, 310, 0, 6446, 6445, 1, 0, 0, 0, 6446, 6447, 1, 0, 0, 0, 6447, 6448, 1, 0, 0, 0, 6448, 6449, 5, 118, 0, 0, 6449, 6450, 3, 614, 307, 0, 6450, 6451, 3, 622, 311, 0, 6451, 6453, 1, 0, 0, 0, 6452, 6436, 1, 0, 0, 0, 6452, 6439, 1, 0, 0, 0, 6452, 6446, 1, 0, 0, 0, 6453, 6456, 1, 0, 0, 0, 6454, 6452, 1, 0, 0, 0, 6454, 6455, 1, 0, 0, 0, 6455, 615, 1, 0, 0, 0, 6456, 6454, 1, 0, 0, 0, 6457, 6459, 5, 36, 0, 0, 6458, 6457, 1, 0, 0, 0, 6458, 6459, 1, 0, 0, 0, 6459, 6460, 1, 0, 0, 0, 6460, 6465, 3, 818, 409, 0, 6461, 6462, 5, 2, 0, 0, 6462, 6463, 3, 784, 392, 0, 6463, 6464, 5, 3, 0, 0, 6464, 6466, 1, 0, 0, 0, 6465, 6461, 1, 0, 0, 0, 6465, 6466, 1, 0, 0, 0, 6466, 617, 1, 0, 0, 0, 6467, 6480, 3, 616, 308, 0, 6468, 6470, 5, 36, 0, 0, 6469, 6471, 3, 818, 409, 0, 6470, 6469, 1, 0, 0, 0, 6470, 6471, 1, 0, 0, 0, 6471, 6474, 1, 0, 0, 0, 6472, 6474, 3, 818, 409, 0, 6473, 6468, 1, 0, 0, 0, 6473, 6472, 1, 0, 0, 0, 6474, 6475, 1, 0, 0, 0, 6475, 6476, 5, 2, 0, 0, 6476, 6477, 3, 642, 321, 0, 6477, 6478, 5, 3, 0, 0, 6478, 6480, 1, 0, 0, 0, 6479, 6467, 1, 0, 0, 0, 6479, 6473, 1, 0, 0, 0, 6480, 619, 1, 0, 0, 0, 6481, 6483, 7, 86, 0, 0, 6482, 6484, 5, 123, 0, 0, 6483, 6482, 1, 0, 0, 0, 6483, 6484, 1, 0, 0, 0, 6484, 621, 1, 0, 0, 0, 6485, 6486, 5, 100, 0, 0, 6486, 6490, 3, 144, 72, 0, 6487, 6488, 5, 80, 0, 0, 6488, 6490, 3, 674, 337, 0, 6489, 6485, 1, 0, 0, 0, 6489, 6487, 1, 0, 0, 0, 6490, 623, 1, 0, 0, 0, 6491, 6507, 3, 322, 161, 0, 6492, 6498, 5, 81, 0, 0, 6493, 6499, 3, 774, 387, 0, 6494, 6495, 5, 2, 0, 0, 6495, 6496, 3, 774, 387, 0, 6496, 6497, 5, 3, 0, 0, 6497, 6499, 1, 0, 0, 0, 6498, 6493, 1, 0, 0, 0, 6498, 6494, 1, 0, 0, 0, 6499, 6507, 1, 0, 0, 0, 6500, 6501, 5, 68, 0, 0, 6501, 6504, 5, 323, 0, 0, 6502, 6505, 3, 790, 395, 0, 6503, 6505, 5, 111, 0, 0, 6504, 6502, 1, 0, 0, 0, 6504, 6503, 1, 0, 0, 0, 6505, 6507, 1, 0, 0, 0, 6506, 6491, 1, 0, 0, 0, 6506, 6492, 1, 0, 0, 0, 6506, 6500, 1, 0, 0, 0, 6507, 625, 1, 0, 0, 0, 6508, 6509, 5, 92, 0, 0, 6509, 6511, 3, 322, 161, 0, 6510, 6512, 3, 144, 72, 0, 6511, 6510, 1, 0, 0, 0, 6511, 6512, 1, 0, 0, 0, 6512, 6514, 1, 0, 0, 0, 6513, 6515, 3, 638, 319, 0, 6514, 6513, 1, 0, 0, 0, 6514, 6515, 1, 0, 0, 0, 6515, 6533, 1, 0, 0, 0, 6516, 6517, 5, 92, 0, 0, 6517, 6523, 5, 81, 0, 0, 6518, 6524, 3, 774, 387, 0, 6519, 6520, 5, 2, 0, 0, 6520, 6521, 3, 774, 387, 0, 6521, 6522, 5, 3, 0, 0, 6522, 6524, 1, 0, 0, 0, 6523, 6518, 1, 0, 0, 0, 6523, 6519, 1, 0, 0, 0, 6524, 6533, 1, 0, 0, 0, 6525, 6526, 5, 350, 0, 0, 6526, 6527, 5, 68, 0, 0, 6527, 6530, 5, 323, 0, 0, 6528, 6531, 3, 790, 395, 0, 6529, 6531, 5, 111, 0, 0, 6530, 6528, 1, 0, 0, 0, 6530, 6529, 1, 0, 0, 0, 6531, 6533, 1, 0, 0, 0, 6532, 6508, 1, 0, 0, 0, 6532, 6516, 1, 0, 0, 0, 6532, 6525, 1, 0, 0, 0, 6533, 627, 1, 0, 0, 0, 6534, 6539, 3, 624, 312, 0, 6535, 6536, 5, 6, 0, 0, 6536, 6538, 3, 624, 312, 0, 6537, 6535, 1, 0, 0, 0, 6538, 6541, 1, 0, 0, 0, 6539, 6537, 1, 0, 0, 0, 6539, 6540, 1, 0, 0, 0, 6540, 629, 1, 0, 0, 0, 6541, 6539, 1, 0, 0, 0, 6542, 6547, 3, 624, 312, 0, 6543, 6545, 5, 36, 0, 0, 6544, 6543, 1, 0, 0, 0, 6544, 6545, 1, 0, 0, 0, 6545, 6546, 1, 0, 0, 0, 6546, 6548, 3, 818, 409, 0, 6547, 6544, 1, 0, 0, 0, 6547, 6548, 1, 0, 0, 0, 6548, 631, 1, 0, 0, 0, 6549, 6550, 5, 472, 0, 0, 6550, 6551, 3, 806, 403, 0, 6551, 6557, 3, 534, 267, 0, 6552, 6553, 5, 310, 0, 0, 6553, 6554, 5, 2, 0, 0, 6554, 6555, 3, 674, 337, 0, 6555, 6556, 5, 3, 0, 0, 6556, 6558, 1, 0, 0, 0, 6557, 6552, 1, 0, 0, 0, 6557, 6558, 1, 0, 0, 0, 6558, 633, 1, 0, 0, 0, 6559, 6574, 3, 688, 344, 0, 6560, 6561, 5, 320, 0, 0, 6561, 6562, 5, 64, 0, 0, 6562, 6563, 5, 2, 0, 0, 6563, 6568, 3, 636, 318, 0, 6564, 6565, 5, 6, 0, 0, 6565, 6567, 3, 636, 318, 0, 6566, 6564, 1, 0, 0, 0, 6567, 6570, 1, 0, 0, 0, 6568, 6566, 1, 0, 0, 0, 6568, 6569, 1, 0, 0, 0, 6569, 6571, 1, 0, 0, 0, 6570, 6568, 1, 0, 0, 0, 6571, 6572, 5, 3, 0, 0, 6572, 6574, 1, 0, 0, 0, 6573, 6559, 1, 0, 0, 0, 6573, 6560, 1, 0, 0, 0, 6574, 6577, 1, 0, 0, 0, 6575, 6576, 5, 105, 0, 0, 6576, 6578, 5, 473, 0, 0, 6577, 6575, 1, 0, 0, 0, 6577, 6578, 1, 0, 0, 0, 6578, 635, 1, 0, 0, 0, 6579, 6585, 3, 688, 344, 0, 6580, 6581, 5, 36, 0, 0, 6581, 6582, 5, 2, 0, 0, 6582, 6583, 3, 642, 321, 0, 6583, 6584, 5, 3, 0, 0, 6584, 6586, 1, 0, 0, 0, 6585, 6580, 1, 0, 0, 0, 6585, 6586, 1, 0, 0, 0, 6586, 637, 1, 0, 0, 0, 6587, 6588, 5, 103, 0, 0, 6588, 6589, 3, 734, 367, 0, 6589, 639, 1, 0, 0, 0, 6590, 6595, 5, 103, 0, 0, 6591, 6592, 5, 434, 0, 0, 6592, 6593, 5, 275, 0, 0, 6593, 6596, 3, 818, 409, 0, 6594, 6596, 3, 674, 337, 0, 6595, 6591, 1, 0, 0, 0, 6595, 6594, 1, 0, 0, 0, 6596, 641, 1, 0, 0, 0, 6597, 6602, 3, 644, 322, 0, 6598, 6599, 5, 6, 0, 0, 6599, 6601, 3, 644, 322, 0, 6600, 6598, 1, 0, 0, 0, 6601, 6604, 1, 0, 0, 0, 6602, 6600, 1, 0, 0, 0, 6602, 6603, 1, 0, 0, 0, 6603, 643, 1, 0, 0, 0, 6604, 6602, 1, 0, 0, 0, 6605, 6606, 3, 818, 409, 0, 6606, 6608, 3, 652, 326, 0, 6607, 6609, 3, 98, 49, 0, 6608, 6607, 1, 0, 0, 0, 6608, 6609, 1, 0, 0, 0, 6609, 645, 1, 0, 0, 0, 6610, 6611, 5, 474, 0, 0, 6611, 6625, 5, 2, 0, 0, 6612, 6613, 5, 476, 0, 0, 6613, 6614, 5, 2, 0, 0, 6614, 6619, 3, 650, 325, 0, 6615, 6616, 5, 6, 0, 0, 6616, 6618, 3, 650, 325, 0, 6617, 6615, 1, 0, 0, 0, 6618, 6621, 1, 0, 0, 0, 6619, 6617, 1, 0, 0, 0, 6619, 6620, 1, 0, 0, 0, 6620, 6622, 1, 0, 0, 0, 6621, 6619, 1, 0, 0, 0, 6622, 6623, 5, 3, 0, 0, 6623, 6624, 5, 6, 0, 0, 6624, 6626, 1, 0, 0, 0, 6625, 6612, 1, 0, 0, 0, 6625, 6626, 1, 0, 0, 0, 6626, 6627, 1, 0, 0, 0, 6627, 6628, 3, 682, 341, 0, 6628, 6629, 3, 698, 349, 0, 6629, 6630, 5, 475, 0, 0, 6630, 6635, 3, 648, 324, 0, 6631, 6632, 5, 6, 0, 0, 6632, 6634, 3, 648, 324, 0, 6633, 6631, 1, 0, 0, 0, 6634, 6637, 1, 0, 0, 0, 6635, 6633, 1, 0, 0, 0, 6635, 6636, 1, 0, 0, 0, 6636, 6638, 1, 0, 0, 0, 6637, 6635, 1, 0, 0, 0, 6638, 6639, 5, 3, 0, 0, 6639, 647, 1, 0, 0, 0, 6640, 6659, 3, 818, 409, 0, 6641, 6655, 3, 652, 326, 0, 6642, 6645, 5, 53, 0, 0, 6643, 6645, 3, 826, 413, 0, 6644, 6642, 1, 0, 0, 0, 6644, 6643, 1, 0, 0, 0, 6645, 6646, 1, 0, 0, 0, 6646, 6652, 3, 674, 337, 0, 6647, 6649, 5, 77, 0, 0, 6648, 6647, 1, 0, 0, 0, 6648, 6649, 1, 0, 0, 0, 6649, 6650, 1, 0, 0, 0, 6650, 6652, 5, 78, 0, 0, 6651, 6644, 1, 0, 0, 0, 6651, 6648, 1, 0, 0, 0, 6652, 6653, 1, 0, 0, 0, 6653, 6651, 1, 0, 0, 0, 6653, 6654, 1, 0, 0, 0, 6654, 6656, 1, 0, 0, 0, 6655, 6651, 1, 0, 0, 0, 6655, 6656, 1, 0, 0, 0, 6656, 6660, 1, 0, 0, 0, 6657, 6658, 5, 62, 0, 0, 6658, 6660, 5, 473, 0, 0, 6659, 6641, 1, 0, 0, 0, 6659, 6657, 1, 0, 0, 0, 6660, 649, 1, 0, 0, 0, 6661, 6662, 3, 682, 341, 0, 6662, 6663, 5, 36, 0, 0, 6663, 6664, 3, 824, 412, 0, 6664, 6668, 1, 0, 0, 0, 6665, 6666, 5, 53, 0, 0, 6666, 6668, 3, 682, 341, 0, 6667, 6661, 1, 0, 0, 0, 6667, 6665, 1, 0, 0, 0, 6668, 651, 1, 0, 0, 0, 6669, 6671, 5, 415, 0, 0, 6670, 6669, 1, 0, 0, 0, 6670, 6671, 1, 0, 0, 0, 6671, 6672, 1, 0, 0, 0, 6672, 6689, 3, 654, 327, 0, 6673, 6675, 5, 4, 0, 0, 6674, 6676, 5, 571, 0, 0, 6675, 6674, 1, 0, 0, 0, 6675, 6676, 1, 0, 0, 0, 6676, 6677, 1, 0, 0, 0, 6677, 6679, 5, 5, 0, 0, 6678, 6673, 1, 0, 0, 0, 6679, 6682, 1, 0, 0, 0, 6680, 6678, 1, 0, 0, 0, 6680, 6681, 1, 0, 0, 0, 6681, 6690, 1, 0, 0, 0, 6682, 6680, 1, 0, 0, 0, 6683, 6687, 5, 35, 0, 0, 6684, 6685, 5, 4, 0, 0, 6685, 6686, 5, 571, 0, 0, 6686, 6688, 5, 5, 0, 0, 6687, 6684, 1, 0, 0, 0, 6687, 6688, 1, 0, 0, 0, 6688, 6690, 1, 0, 0, 0, 6689, 6680, 1, 0, 0, 0, 6689, 6683, 1, 0, 0, 0, 6690, 6696, 1, 0, 0, 0, 6691, 6692, 3, 780, 390, 0, 6692, 6693, 5, 27, 0, 0, 6693, 6694, 7, 87, 0, 0, 6694, 6696, 1, 0, 0, 0, 6695, 6670, 1, 0, 0, 0, 6695, 6691, 1, 0, 0, 0, 6696, 653, 1, 0, 0, 0, 6697, 6699, 3, 820, 410, 0, 6698, 6700, 3, 318, 159, 0, 6699, 6698, 1, 0, 0, 0, 6699, 6700, 1, 0, 0, 0, 6700, 6702, 1, 0, 0, 0, 6701, 6703, 3, 534, 267, 0, 6702, 6701, 1, 0, 0, 0, 6702, 6703, 1, 0, 0, 0, 6703, 6713, 1, 0, 0, 0, 6704, 6713, 3, 656, 328, 0, 6705, 6710, 5, 403, 0, 0, 6706, 6708, 3, 668, 334, 0, 6707, 6706, 1, 0, 0, 0, 6707, 6708, 1, 0, 0, 0, 6708, 6711, 1, 0, 0, 0, 6709, 6711, 3, 660, 330, 0, 6710, 6707, 1, 0, 0, 0, 6710, 6709, 1, 0, 0, 0, 6711, 6713, 1, 0, 0, 0, 6712, 6697, 1, 0, 0, 0, 6712, 6704, 1, 0, 0, 0, 6712, 6705, 1, 0, 0, 0, 6713, 655, 1, 0, 0, 0, 6714, 6719, 3, 658, 329, 0, 6715, 6719, 3, 662, 331, 0, 6716, 6719, 3, 664, 332, 0, 6717, 6719, 3, 666, 333, 0, 6718, 6714, 1, 0, 0, 0, 6718, 6715, 1, 0, 0, 0, 6718, 6716, 1, 0, 0, 0, 6718, 6717, 1, 0, 0, 0, 6719, 657, 1, 0, 0, 0, 6720, 6737, 5, 401, 0, 0, 6721, 6737, 5, 402, 0, 0, 6722, 6737, 5, 416, 0, 0, 6723, 6737, 5, 388, 0, 0, 6724, 6737, 5, 413, 0, 0, 6725, 6727, 5, 398, 0, 0, 6726, 6728, 3, 660, 330, 0, 6727, 6726, 1, 0, 0, 0, 6727, 6728, 1, 0, 0, 0, 6728, 6737, 1, 0, 0, 0, 6729, 6730, 5, 190, 0, 0, 6730, 6737, 5, 412, 0, 0, 6731, 6733, 7, 88, 0, 0, 6732, 6734, 3, 534, 267, 0, 6733, 6732, 1, 0, 0, 0, 6733, 6734, 1, 0, 0, 0, 6734, 6737, 1, 0, 0, 0, 6735, 6737, 5, 390, 0, 0, 6736, 6720, 1, 0, 0, 0, 6736, 6721, 1, 0, 0, 0, 6736, 6722, 1, 0, 0, 0, 6736, 6723, 1, 0, 0, 0, 6736, 6724, 1, 0, 0, 0, 6736, 6725, 1, 0, 0, 0, 6736, 6729, 1, 0, 0, 0, 6736, 6731, 1, 0, 0, 0, 6736, 6735, 1, 0, 0, 0, 6737, 659, 1, 0, 0, 0, 6738, 6739, 5, 2, 0, 0, 6739, 6740, 5, 571, 0, 0, 6740, 6741, 5, 3, 0, 0, 6741, 661, 1, 0, 0, 0, 6742, 6744, 5, 389, 0, 0, 6743, 6745, 5, 374, 0, 0, 6744, 6743, 1, 0, 0, 0, 6744, 6745, 1, 0, 0, 0, 6745, 6747, 1, 0, 0, 0, 6746, 6748, 3, 534, 267, 0, 6747, 6746, 1, 0, 0, 0, 6747, 6748, 1, 0, 0, 0, 6748, 663, 1, 0, 0, 0, 6749, 6751, 7, 89, 0, 0, 6750, 6752, 5, 374, 0, 0, 6751, 6750, 1, 0, 0, 0, 6751, 6752, 1, 0, 0, 0, 6752, 6760, 1, 0, 0, 0, 6753, 6760, 5, 423, 0, 0, 6754, 6755, 5, 405, 0, 0, 6755, 6757, 7, 90, 0, 0, 6756, 6758, 5, 374, 0, 0, 6757, 6756, 1, 0, 0, 0, 6757, 6758, 1, 0, 0, 0, 6758, 6760, 1, 0, 0, 0, 6759, 6749, 1, 0, 0, 0, 6759, 6753, 1, 0, 0, 0, 6759, 6754, 1, 0, 0, 0, 6760, 6762, 1, 0, 0, 0, 6761, 6763, 3, 660, 330, 0, 6762, 6761, 1, 0, 0, 0, 6762, 6763, 1, 0, 0, 0, 6763, 665, 1, 0, 0, 0, 6764, 6766, 7, 91, 0, 0, 6765, 6767, 3, 660, 330, 0, 6766, 6765, 1, 0, 0, 0, 6766, 6767, 1, 0, 0, 0, 6767, 6771, 1, 0, 0, 0, 6768, 6769, 7, 26, 0, 0, 6769, 6770, 5, 418, 0, 0, 6770, 6772, 5, 386, 0, 0, 6771, 6768, 1, 0, 0, 0, 6771, 6772, 1, 0, 0, 0, 6772, 667, 1, 0, 0, 0, 6773, 6803, 5, 264, 0, 0, 6774, 6803, 3, 670, 335, 0, 6775, 6778, 5, 384, 0, 0, 6776, 6777, 5, 94, 0, 0, 6777, 6779, 5, 264, 0, 0, 6778, 6776, 1, 0, 0, 0, 6778, 6779, 1, 0, 0, 0, 6779, 6803, 1, 0, 0, 0, 6780, 6787, 5, 176, 0, 0, 6781, 6785, 5, 94, 0, 0, 6782, 6786, 5, 218, 0, 0, 6783, 6786, 5, 261, 0, 0, 6784, 6786, 3, 670, 335, 0, 6785, 6782, 1, 0, 0, 0, 6785, 6783, 1, 0, 0, 0, 6785, 6784, 1, 0, 0, 0, 6786, 6788, 1, 0, 0, 0, 6787, 6781, 1, 0, 0, 0, 6787, 6788, 1, 0, 0, 0, 6788, 6803, 1, 0, 0, 0, 6789, 6795, 5, 218, 0, 0, 6790, 6793, 5, 94, 0, 0, 6791, 6794, 5, 261, 0, 0, 6792, 6794, 3, 670, 335, 0, 6793, 6791, 1, 0, 0, 0, 6793, 6792, 1, 0, 0, 0, 6794, 6796, 1, 0, 0, 0, 6795, 6790, 1, 0, 0, 0, 6795, 6796, 1, 0, 0, 0, 6796, 6803, 1, 0, 0, 0, 6797, 6800, 5, 261, 0, 0, 6798, 6799, 5, 94, 0, 0, 6799, 6801, 3, 670, 335, 0, 6800, 6798, 1, 0, 0, 0, 6800, 6801, 1, 0, 0, 0, 6801, 6803, 1, 0, 0, 0, 6802, 6773, 1, 0, 0, 0, 6802, 6774, 1, 0, 0, 0, 6802, 6775, 1, 0, 0, 0, 6802, 6780, 1, 0, 0, 0, 6802, 6789, 1, 0, 0, 0, 6802, 6797, 1, 0, 0, 0, 6803, 669, 1, 0, 0, 0, 6804, 6806, 5, 326, 0, 0, 6805, 6807, 3, 660, 330, 0, 6806, 6805, 1, 0, 0, 0, 6806, 6807, 1, 0, 0, 0, 6807, 671, 1, 0, 0, 0, 6808, 6809, 7, 92, 0, 0, 6809, 673, 1, 0, 0, 0, 6810, 6811, 3, 676, 338, 0, 6811, 675, 1, 0, 0, 0, 6812, 6813, 6, 338, -1, 0, 6813, 6815, 3, 680, 340, 0, 6814, 6816, 3, 678, 339, 0, 6815, 6814, 1, 0, 0, 0, 6815, 6816, 1, 0, 0, 0, 6816, 6820, 1, 0, 0, 0, 6817, 6818, 5, 77, 0, 0, 6818, 6820, 3, 676, 338, 3, 6819, 6812, 1, 0, 0, 0, 6819, 6817, 1, 0, 0, 0, 6820, 6829, 1, 0, 0, 0, 6821, 6822, 10, 2, 0, 0, 6822, 6823, 5, 33, 0, 0, 6823, 6828, 3, 676, 338, 3, 6824, 6825, 10, 1, 0, 0, 6825, 6826, 5, 82, 0, 0, 6826, 6828, 3, 676, 338, 2, 6827, 6821, 1, 0, 0, 0, 6827, 6824, 1, 0, 0, 0, 6828, 6831, 1, 0, 0, 0, 6829, 6827, 1, 0, 0, 0, 6829, 6830, 1, 0, 0, 0, 6830, 677, 1, 0, 0, 0, 6831, 6829, 1, 0, 0, 0, 6832, 6833, 3, 672, 336, 0, 6833, 6834, 3, 680, 340, 0, 6834, 6904, 1, 0, 0, 0, 6835, 6836, 3, 672, 336, 0, 6836, 6837, 3, 728, 364, 0, 6837, 6843, 3, 718, 359, 0, 6838, 6844, 3, 562, 281, 0, 6839, 6840, 5, 2, 0, 0, 6840, 6841, 3, 674, 337, 0, 6841, 6842, 5, 3, 0, 0, 6842, 6844, 1, 0, 0, 0, 6843, 6838, 1, 0, 0, 0, 6843, 6839, 1, 0, 0, 0, 6844, 6904, 1, 0, 0, 0, 6845, 6847, 5, 77, 0, 0, 6846, 6845, 1, 0, 0, 0, 6846, 6847, 1, 0, 0, 0, 6847, 6848, 1, 0, 0, 0, 6848, 6849, 5, 387, 0, 0, 6849, 6850, 3, 680, 340, 0, 6850, 6851, 5, 33, 0, 0, 6851, 6852, 3, 680, 340, 0, 6852, 6904, 1, 0, 0, 0, 6853, 6855, 5, 77, 0, 0, 6854, 6853, 1, 0, 0, 0, 6854, 6855, 1, 0, 0, 0, 6855, 6856, 1, 0, 0, 0, 6856, 6857, 5, 68, 0, 0, 6857, 6858, 5, 2, 0, 0, 6858, 6863, 3, 674, 337, 0, 6859, 6860, 5, 6, 0, 0, 6860, 6862, 3, 674, 337, 0, 6861, 6859, 1, 0, 0, 0, 6862, 6865, 1, 0, 0, 0, 6863, 6861, 1, 0, 0, 0, 6863, 6864, 1, 0, 0, 0, 6864, 6866, 1, 0, 0, 0, 6865, 6863, 1, 0, 0, 0, 6866, 6867, 5, 3, 0, 0, 6867, 6904, 1, 0, 0, 0, 6868, 6870, 5, 77, 0, 0, 6869, 6868, 1, 0, 0, 0, 6869, 6870, 1, 0, 0, 0, 6870, 6871, 1, 0, 0, 0, 6871, 6872, 5, 68, 0, 0, 6872, 6904, 3, 562, 281, 0, 6873, 6875, 5, 77, 0, 0, 6874, 6873, 1, 0, 0, 0, 6874, 6875, 1, 0, 0, 0, 6875, 6884, 1, 0, 0, 0, 6876, 6885, 5, 120, 0, 0, 6877, 6885, 5, 114, 0, 0, 6878, 6879, 5, 127, 0, 0, 6879, 6885, 5, 94, 0, 0, 6880, 6882, 5, 387, 0, 0, 6881, 6883, 5, 91, 0, 0, 6882, 6881, 1, 0, 0, 0, 6882, 6883, 1, 0, 0, 0, 6883, 6885, 1, 0, 0, 0, 6884, 6876, 1, 0, 0, 0, 6884, 6877, 1, 0, 0, 0, 6884, 6878, 1, 0, 0, 0, 6884, 6880, 1, 0, 0, 0, 6885, 6886, 1, 0, 0, 0, 6886, 6889, 3, 680, 340, 0, 6887, 6888, 5, 197, 0, 0, 6888, 6890, 3, 680, 340, 0, 6889, 6887, 1, 0, 0, 0, 6889, 6890, 1, 0, 0, 0, 6890, 6904, 1, 0, 0, 0, 6891, 6893, 5, 116, 0, 0, 6892, 6894, 5, 77, 0, 0, 6893, 6892, 1, 0, 0, 0, 6893, 6894, 1, 0, 0, 0, 6894, 6895, 1, 0, 0, 0, 6895, 6904, 5, 78, 0, 0, 6896, 6898, 5, 116, 0, 0, 6897, 6899, 5, 77, 0, 0, 6898, 6897, 1, 0, 0, 0, 6898, 6899, 1, 0, 0, 0, 6899, 6900, 1, 0, 0, 0, 6900, 6901, 5, 56, 0, 0, 6901, 6902, 5, 64, 0, 0, 6902, 6904, 3, 680, 340, 0, 6903, 6832, 1, 0, 0, 0, 6903, 6835, 1, 0, 0, 0, 6903, 6846, 1, 0, 0, 0, 6903, 6854, 1, 0, 0, 0, 6903, 6869, 1, 0, 0, 0, 6903, 6874, 1, 0, 0, 0, 6903, 6891, 1, 0, 0, 0, 6903, 6896, 1, 0, 0, 0, 6904, 679, 1, 0, 0, 0, 6905, 6906, 6, 340, -1, 0, 6906, 6910, 3, 682, 341, 0, 6907, 6908, 7, 29, 0, 0, 6908, 6910, 3, 680, 340, 4, 6909, 6905, 1, 0, 0, 0, 6909, 6907, 1, 0, 0, 0, 6910, 6927, 1, 0, 0, 0, 6911, 6912, 10, 3, 0, 0, 6912, 6913, 7, 93, 0, 0, 6913, 6926, 3, 680, 340, 4, 6914, 6915, 10, 2, 0, 0, 6915, 6916, 7, 29, 0, 0, 6916, 6926, 3, 680, 340, 3, 6917, 6918, 10, 1, 0, 0, 6918, 6919, 5, 15, 0, 0, 6919, 6926, 3, 680, 340, 2, 6920, 6921, 10, 5, 0, 0, 6921, 6922, 5, 142, 0, 0, 6922, 6923, 5, 418, 0, 0, 6923, 6924, 5, 386, 0, 0, 6924, 6926, 3, 674, 337, 0, 6925, 6911, 1, 0, 0, 0, 6925, 6914, 1, 0, 0, 0, 6925, 6917, 1, 0, 0, 0, 6925, 6920, 1, 0, 0, 0, 6926, 6929, 1, 0, 0, 0, 6927, 6925, 1, 0, 0, 0, 6927, 6928, 1, 0, 0, 0, 6928, 681, 1, 0, 0, 0, 6929, 6927, 1, 0, 0, 0, 6930, 6931, 6, 341, -1, 0, 6931, 6932, 7, 94, 0, 0, 6932, 7019, 3, 562, 281, 0, 6933, 6936, 5, 35, 0, 0, 6934, 6937, 3, 562, 281, 0, 6935, 6937, 3, 740, 370, 0, 6936, 6934, 1, 0, 0, 0, 6936, 6935, 1, 0, 0, 0, 6937, 7019, 1, 0, 0, 0, 6938, 6939, 5, 28, 0, 0, 6939, 7019, 3, 754, 377, 0, 6940, 6941, 5, 470, 0, 0, 6941, 7019, 3, 534, 267, 0, 6942, 7019, 5, 571, 0, 0, 6943, 7019, 5, 573, 0, 0, 6944, 7019, 5, 563, 0, 0, 6945, 7019, 5, 567, 0, 0, 6946, 6956, 3, 806, 403, 0, 6947, 6957, 3, 808, 404, 0, 6948, 6949, 5, 2, 0, 0, 6949, 6951, 3, 736, 368, 0, 6950, 6952, 3, 586, 293, 0, 6951, 6950, 1, 0, 0, 0, 6951, 6952, 1, 0, 0, 0, 6952, 6953, 1, 0, 0, 0, 6953, 6954, 5, 3, 0, 0, 6954, 6955, 3, 808, 404, 0, 6955, 6957, 1, 0, 0, 0, 6956, 6947, 1, 0, 0, 0, 6956, 6948, 1, 0, 0, 0, 6957, 7019, 1, 0, 0, 0, 6958, 6960, 3, 656, 328, 0, 6959, 6958, 1, 0, 0, 0, 6959, 6960, 1, 0, 0, 0, 6960, 6961, 1, 0, 0, 0, 6961, 7019, 3, 808, 404, 0, 6962, 6970, 5, 403, 0, 0, 6963, 6965, 3, 808, 404, 0, 6964, 6966, 3, 668, 334, 0, 6965, 6964, 1, 0, 0, 0, 6965, 6966, 1, 0, 0, 0, 6966, 6971, 1, 0, 0, 0, 6967, 6968, 3, 660, 330, 0, 6968, 6969, 3, 808, 404, 0, 6969, 6971, 1, 0, 0, 0, 6970, 6963, 1, 0, 0, 0, 6970, 6967, 1, 0, 0, 0, 6971, 7019, 1, 0, 0, 0, 6972, 7019, 5, 96, 0, 0, 6973, 7019, 5, 60, 0, 0, 6974, 7019, 5, 78, 0, 0, 6975, 7019, 5, 574, 0, 0, 6976, 6977, 5, 2, 0, 0, 6977, 6978, 3, 674, 337, 0, 6978, 6979, 5, 3, 0, 0, 6979, 6980, 3, 754, 377, 0, 6980, 7019, 1, 0, 0, 0, 6981, 6983, 5, 40, 0, 0, 6982, 6984, 3, 674, 337, 0, 6983, 6982, 1, 0, 0, 0, 6983, 6984, 1, 0, 0, 0, 6984, 6986, 1, 0, 0, 0, 6985, 6987, 3, 748, 374, 0, 6986, 6985, 1, 0, 0, 0, 6987, 6988, 1, 0, 0, 0, 6988, 6986, 1, 0, 0, 0, 6988, 6989, 1, 0, 0, 0, 6989, 6992, 1, 0, 0, 0, 6990, 6991, 5, 58, 0, 0, 6991, 6993, 3, 674, 337, 0, 6992, 6990, 1, 0, 0, 0, 6992, 6993, 1, 0, 0, 0, 6993, 6994, 1, 0, 0, 0, 6994, 6995, 5, 454, 0, 0, 6995, 7019, 1, 0, 0, 0, 6996, 7019, 3, 686, 343, 0, 6997, 6999, 3, 562, 281, 0, 6998, 7000, 3, 752, 376, 0, 6999, 6998, 1, 0, 0, 0, 6999, 7000, 1, 0, 0, 0, 7000, 7019, 1, 0, 0, 0, 7001, 7019, 3, 716, 358, 0, 7002, 7003, 5, 2, 0, 0, 7003, 7004, 3, 674, 337, 0, 7004, 7005, 5, 6, 0, 0, 7005, 7006, 3, 730, 365, 0, 7006, 7007, 5, 3, 0, 0, 7007, 7019, 1, 0, 0, 0, 7008, 7009, 3, 714, 357, 0, 7009, 7010, 5, 125, 0, 0, 7010, 7011, 3, 714, 357, 0, 7011, 7019, 1, 0, 0, 0, 7012, 7019, 3, 780, 390, 0, 7013, 7014, 7, 29, 0, 0, 7014, 7019, 3, 682, 341, 5, 7015, 7016, 3, 724, 362, 0, 7016, 7017, 3, 682, 341, 2, 7017, 7019, 1, 0, 0, 0, 7018, 6930, 1, 0, 0, 0, 7018, 6933, 1, 0, 0, 0, 7018, 6938, 1, 0, 0, 0, 7018, 6940, 1, 0, 0, 0, 7018, 6942, 1, 0, 0, 0, 7018, 6943, 1, 0, 0, 0, 7018, 6944, 1, 0, 0, 0, 7018, 6945, 1, 0, 0, 0, 7018, 6946, 1, 0, 0, 0, 7018, 6959, 1, 0, 0, 0, 7018, 6962, 1, 0, 0, 0, 7018, 6972, 1, 0, 0, 0, 7018, 6973, 1, 0, 0, 0, 7018, 6974, 1, 0, 0, 0, 7018, 6975, 1, 0, 0, 0, 7018, 6976, 1, 0, 0, 0, 7018, 6981, 1, 0, 0, 0, 7018, 6996, 1, 0, 0, 0, 7018, 6997, 1, 0, 0, 0, 7018, 7001, 1, 0, 0, 0, 7018, 7002, 1, 0, 0, 0, 7018, 7008, 1, 0, 0, 0, 7018, 7012, 1, 0, 0, 0, 7018, 7013, 1, 0, 0, 0, 7018, 7015, 1, 0, 0, 0, 7019, 7047, 1, 0, 0, 0, 7020, 7021, 10, 3, 0, 0, 7021, 7022, 3, 722, 361, 0, 7022, 7023, 3, 682, 341, 4, 7023, 7046, 1, 0, 0, 0, 7024, 7025, 10, 6, 0, 0, 7025, 7026, 5, 26, 0, 0, 7026, 7046, 3, 652, 326, 0, 7027, 7028, 10, 4, 0, 0, 7028, 7030, 3, 724, 362, 0, 7029, 7031, 3, 682, 341, 0, 7030, 7029, 1, 0, 0, 0, 7030, 7031, 1, 0, 0, 0, 7031, 7046, 1, 0, 0, 0, 7032, 7033, 10, 1, 0, 0, 7033, 7035, 5, 116, 0, 0, 7034, 7036, 5, 77, 0, 0, 7035, 7034, 1, 0, 0, 0, 7035, 7036, 1, 0, 0, 0, 7036, 7043, 1, 0, 0, 0, 7037, 7038, 5, 56, 0, 0, 7038, 7039, 5, 64, 0, 0, 7039, 7044, 3, 682, 341, 0, 7040, 7041, 5, 275, 0, 0, 7041, 7044, 3, 528, 264, 0, 7042, 7044, 5, 188, 0, 0, 7043, 7037, 1, 0, 0, 0, 7043, 7040, 1, 0, 0, 0, 7043, 7042, 1, 0, 0, 0, 7044, 7046, 1, 0, 0, 0, 7045, 7020, 1, 0, 0, 0, 7045, 7024, 1, 0, 0, 0, 7045, 7027, 1, 0, 0, 0, 7045, 7032, 1, 0, 0, 0, 7046, 7049, 1, 0, 0, 0, 7047, 7045, 1, 0, 0, 0, 7047, 7048, 1, 0, 0, 0, 7048, 683, 1, 0, 0, 0, 7049, 7047, 1, 0, 0, 0, 7050, 7051, 3, 806, 403, 0, 7051, 7072, 5, 2, 0, 0, 7052, 7056, 3, 736, 368, 0, 7053, 7054, 5, 6, 0, 0, 7054, 7055, 5, 101, 0, 0, 7055, 7057, 3, 738, 369, 0, 7056, 7053, 1, 0, 0, 0, 7056, 7057, 1, 0, 0, 0, 7057, 7059, 1, 0, 0, 0, 7058, 7060, 3, 586, 293, 0, 7059, 7058, 1, 0, 0, 0, 7059, 7060, 1, 0, 0, 0, 7060, 7073, 1, 0, 0, 0, 7061, 7062, 5, 101, 0, 0, 7062, 7064, 3, 738, 369, 0, 7063, 7065, 3, 586, 293, 0, 7064, 7063, 1, 0, 0, 0, 7064, 7065, 1, 0, 0, 0, 7065, 7073, 1, 0, 0, 0, 7066, 7067, 7, 80, 0, 0, 7067, 7069, 3, 736, 368, 0, 7068, 7070, 3, 586, 293, 0, 7069, 7068, 1, 0, 0, 0, 7069, 7070, 1, 0, 0, 0, 7070, 7073, 1, 0, 0, 0, 7071, 7073, 5, 9, 0, 0, 7072, 7052, 1, 0, 0, 0, 7072, 7061, 1, 0, 0, 0, 7072, 7066, 1, 0, 0, 0, 7072, 7071, 1, 0, 0, 0, 7072, 7073, 1, 0, 0, 0, 7073, 7074, 1, 0, 0, 0, 7074, 7075, 5, 3, 0, 0, 7075, 685, 1, 0, 0, 0, 7076, 7083, 3, 684, 342, 0, 7077, 7078, 5, 479, 0, 0, 7078, 7079, 5, 66, 0, 0, 7079, 7080, 5, 2, 0, 0, 7080, 7081, 3, 586, 293, 0, 7081, 7082, 5, 3, 0, 0, 7082, 7084, 1, 0, 0, 0, 7083, 7077, 1, 0, 0, 0, 7083, 7084, 1, 0, 0, 0, 7084, 7091, 1, 0, 0, 0, 7085, 7086, 5, 480, 0, 0, 7086, 7087, 5, 2, 0, 0, 7087, 7088, 5, 103, 0, 0, 7088, 7089, 3, 674, 337, 0, 7089, 7090, 5, 3, 0, 0, 7090, 7092, 1, 0, 0, 0, 7091, 7085, 1, 0, 0, 0, 7091, 7092, 1, 0, 0, 0, 7092, 7098, 1, 0, 0, 0, 7093, 7096, 5, 124, 0, 0, 7094, 7097, 3, 708, 354, 0, 7095, 7097, 3, 818, 409, 0, 7096, 7094, 1, 0, 0, 0, 7096, 7095, 1, 0, 0, 0, 7097, 7099, 1, 0, 0, 0, 7098, 7093, 1, 0, 0, 0, 7098, 7099, 1, 0, 0, 0, 7099, 7102, 1, 0, 0, 0, 7100, 7102, 3, 690, 345, 0, 7101, 7076, 1, 0, 0, 0, 7101, 7100, 1, 0, 0, 0, 7102, 687, 1, 0, 0, 0, 7103, 7106, 3, 684, 342, 0, 7104, 7106, 3, 690, 345, 0, 7105, 7103, 1, 0, 0, 0, 7105, 7104, 1, 0, 0, 0, 7106, 689, 1, 0, 0, 0, 7107, 7108, 5, 108, 0, 0, 7108, 7109, 5, 62, 0, 0, 7109, 7110, 5, 2, 0, 0, 7110, 7111, 3, 674, 337, 0, 7111, 7112, 5, 3, 0, 0, 7112, 7282, 1, 0, 0, 0, 7113, 7282, 5, 48, 0, 0, 7114, 7116, 7, 95, 0, 0, 7115, 7117, 3, 660, 330, 0, 7116, 7115, 1, 0, 0, 0, 7116, 7117, 1, 0, 0, 0, 7117, 7282, 1, 0, 0, 0, 7118, 7282, 5, 49, 0, 0, 7119, 7282, 5, 52, 0, 0, 7120, 7282, 5, 89, 0, 0, 7121, 7282, 5, 99, 0, 0, 7122, 7282, 5, 47, 0, 0, 7123, 7282, 5, 111, 0, 0, 7124, 7125, 7, 96, 0, 0, 7125, 7126, 5, 2, 0, 0, 7126, 7127, 3, 674, 337, 0, 7127, 7128, 5, 36, 0, 0, 7128, 7129, 3, 652, 326, 0, 7129, 7130, 5, 3, 0, 0, 7130, 7282, 1, 0, 0, 0, 7131, 7132, 5, 397, 0, 0, 7132, 7137, 5, 2, 0, 0, 7133, 7134, 3, 742, 371, 0, 7134, 7135, 5, 64, 0, 0, 7135, 7136, 3, 674, 337, 0, 7136, 7138, 1, 0, 0, 0, 7137, 7133, 1, 0, 0, 0, 7137, 7138, 1, 0, 0, 0, 7138, 7139, 1, 0, 0, 0, 7139, 7282, 5, 3, 0, 0, 7140, 7141, 5, 489, 0, 0, 7141, 7142, 5, 2, 0, 0, 7142, 7145, 3, 674, 337, 0, 7143, 7144, 5, 6, 0, 0, 7144, 7146, 3, 744, 372, 0, 7145, 7143, 1, 0, 0, 0, 7145, 7146, 1, 0, 0, 0, 7146, 7147, 1, 0, 0, 0, 7147, 7148, 5, 3, 0, 0, 7148, 7282, 1, 0, 0, 0, 7149, 7150, 5, 410, 0, 0, 7150, 7151, 5, 2, 0, 0, 7151, 7152, 3, 674, 337, 0, 7152, 7153, 5, 84, 0, 0, 7153, 7154, 3, 674, 337, 0, 7154, 7155, 5, 64, 0, 0, 7155, 7158, 3, 674, 337, 0, 7156, 7157, 5, 62, 0, 0, 7157, 7159, 3, 674, 337, 0, 7158, 7156, 1, 0, 0, 0, 7158, 7159, 1, 0, 0, 0, 7159, 7160, 1, 0, 0, 0, 7160, 7161, 5, 3, 0, 0, 7161, 7282, 1, 0, 0, 0, 7162, 7163, 5, 411, 0, 0, 7163, 7168, 5, 2, 0, 0, 7164, 7165, 3, 682, 341, 0, 7165, 7166, 5, 68, 0, 0, 7166, 7167, 3, 682, 341, 0, 7167, 7169, 1, 0, 0, 0, 7168, 7164, 1, 0, 0, 0, 7168, 7169, 1, 0, 0, 0, 7169, 7170, 1, 0, 0, 0, 7170, 7282, 5, 3, 0, 0, 7171, 7172, 5, 417, 0, 0, 7172, 7174, 5, 2, 0, 0, 7173, 7175, 3, 746, 373, 0, 7174, 7173, 1, 0, 0, 0, 7174, 7175, 1, 0, 0, 0, 7175, 7176, 1, 0, 0, 0, 7176, 7282, 5, 3, 0, 0, 7177, 7178, 5, 421, 0, 0, 7178, 7180, 5, 2, 0, 0, 7179, 7181, 7, 97, 0, 0, 7180, 7179, 1, 0, 0, 0, 7180, 7181, 1, 0, 0, 0, 7181, 7186, 1, 0, 0, 0, 7182, 7184, 3, 674, 337, 0, 7183, 7182, 1, 0, 0, 0, 7183, 7184, 1, 0, 0, 0, 7184, 7185, 1, 0, 0, 0, 7185, 7187, 5, 64, 0, 0, 7186, 7183, 1, 0, 0, 0, 7186, 7187, 1, 0, 0, 0, 7187, 7188, 1, 0, 0, 0, 7188, 7189, 3, 730, 365, 0, 7189, 7190, 1, 0, 0, 0, 7190, 7191, 5, 3, 0, 0, 7191, 7282, 1, 0, 0, 0, 7192, 7193, 5, 408, 0, 0, 7193, 7194, 5, 2, 0, 0, 7194, 7195, 3, 674, 337, 0, 7195, 7196, 5, 6, 0, 0, 7196, 7197, 3, 674, 337, 0, 7197, 7198, 5, 3, 0, 0, 7198, 7282, 1, 0, 0, 0, 7199, 7200, 7, 98, 0, 0, 7200, 7282, 3, 534, 267, 0, 7201, 7202, 5, 426, 0, 0, 7202, 7203, 5, 2, 0, 0, 7203, 7204, 5, 266, 0, 0, 7204, 7214, 3, 824, 412, 0, 7205, 7212, 5, 6, 0, 0, 7206, 7207, 5, 424, 0, 0, 7207, 7208, 5, 2, 0, 0, 7208, 7209, 3, 692, 346, 0, 7209, 7210, 5, 3, 0, 0, 7210, 7213, 1, 0, 0, 0, 7211, 7213, 3, 730, 365, 0, 7212, 7206, 1, 0, 0, 0, 7212, 7211, 1, 0, 0, 0, 7213, 7215, 1, 0, 0, 0, 7214, 7205, 1, 0, 0, 0, 7214, 7215, 1, 0, 0, 0, 7215, 7216, 1, 0, 0, 0, 7216, 7217, 5, 3, 0, 0, 7217, 7282, 1, 0, 0, 0, 7218, 7219, 5, 427, 0, 0, 7219, 7220, 5, 2, 0, 0, 7220, 7221, 3, 682, 341, 0, 7221, 7222, 3, 698, 349, 0, 7222, 7223, 5, 3, 0, 0, 7223, 7282, 1, 0, 0, 0, 7224, 7225, 5, 428, 0, 0, 7225, 7226, 5, 2, 0, 0, 7226, 7227, 3, 692, 346, 0, 7227, 7228, 5, 3, 0, 0, 7228, 7282, 1, 0, 0, 0, 7229, 7230, 5, 429, 0, 0, 7230, 7231, 5, 2, 0, 0, 7231, 7232, 3, 696, 348, 0, 7232, 7235, 3, 674, 337, 0, 7233, 7234, 7, 99, 0, 0, 7234, 7236, 5, 378, 0, 0, 7235, 7233, 1, 0, 0, 0, 7235, 7236, 1, 0, 0, 0, 7236, 7237, 1, 0, 0, 0, 7237, 7238, 5, 3, 0, 0, 7238, 7282, 1, 0, 0, 0, 7239, 7240, 5, 430, 0, 0, 7240, 7241, 5, 2, 0, 0, 7241, 7242, 5, 266, 0, 0, 7242, 7245, 3, 824, 412, 0, 7243, 7244, 5, 6, 0, 0, 7244, 7246, 3, 674, 337, 0, 7245, 7243, 1, 0, 0, 0, 7245, 7246, 1, 0, 0, 0, 7246, 7247, 1, 0, 0, 0, 7247, 7248, 5, 3, 0, 0, 7248, 7282, 1, 0, 0, 0, 7249, 7250, 5, 431, 0, 0, 7250, 7251, 5, 2, 0, 0, 7251, 7252, 5, 383, 0, 0, 7252, 7253, 3, 674, 337, 0, 7253, 7254, 5, 6, 0, 0, 7254, 7258, 5, 375, 0, 0, 7255, 7256, 5, 269, 0, 0, 7256, 7259, 5, 450, 0, 0, 7257, 7259, 3, 674, 337, 0, 7258, 7255, 1, 0, 0, 0, 7258, 7257, 1, 0, 0, 0, 7259, 7269, 1, 0, 0, 0, 7260, 7261, 5, 6, 0, 0, 7261, 7267, 5, 339, 0, 0, 7262, 7264, 5, 269, 0, 0, 7263, 7262, 1, 0, 0, 0, 7263, 7264, 1, 0, 0, 0, 7264, 7265, 1, 0, 0, 0, 7265, 7268, 5, 450, 0, 0, 7266, 7268, 5, 385, 0, 0, 7267, 7263, 1, 0, 0, 0, 7267, 7266, 1, 0, 0, 0, 7268, 7270, 1, 0, 0, 0, 7269, 7260, 1, 0, 0, 0, 7269, 7270, 1, 0, 0, 0, 7270, 7271, 1, 0, 0, 0, 7271, 7272, 5, 3, 0, 0, 7272, 7282, 1, 0, 0, 0, 7273, 7274, 5, 432, 0, 0, 7274, 7275, 5, 2, 0, 0, 7275, 7276, 3, 696, 348, 0, 7276, 7277, 3, 674, 337, 0, 7277, 7278, 5, 36, 0, 0, 7278, 7279, 3, 654, 327, 0, 7279, 7280, 5, 3, 0, 0, 7280, 7282, 1, 0, 0, 0, 7281, 7107, 1, 0, 0, 0, 7281, 7113, 1, 0, 0, 0, 7281, 7114, 1, 0, 0, 0, 7281, 7118, 1, 0, 0, 0, 7281, 7119, 1, 0, 0, 0, 7281, 7120, 1, 0, 0, 0, 7281, 7121, 1, 0, 0, 0, 7281, 7122, 1, 0, 0, 0, 7281, 7123, 1, 0, 0, 0, 7281, 7124, 1, 0, 0, 0, 7281, 7131, 1, 0, 0, 0, 7281, 7140, 1, 0, 0, 0, 7281, 7149, 1, 0, 0, 0, 7281, 7162, 1, 0, 0, 0, 7281, 7171, 1, 0, 0, 0, 7281, 7177, 1, 0, 0, 0, 7281, 7192, 1, 0, 0, 0, 7281, 7199, 1, 0, 0, 0, 7281, 7201, 1, 0, 0, 0, 7281, 7218, 1, 0, 0, 0, 7281, 7224, 1, 0, 0, 0, 7281, 7229, 1, 0, 0, 0, 7281, 7239, 1, 0, 0, 0, 7281, 7249, 1, 0, 0, 0, 7281, 7273, 1, 0, 0, 0, 7282, 691, 1, 0, 0, 0, 7283, 7288, 3, 694, 347, 0, 7284, 7285, 5, 6, 0, 0, 7285, 7287, 3, 694, 347, 0, 7286, 7284, 1, 0, 0, 0, 7287, 7290, 1, 0, 0, 0, 7288, 7286, 1, 0, 0, 0, 7288, 7289, 1, 0, 0, 0, 7289, 693, 1, 0, 0, 0, 7290, 7288, 1, 0, 0, 0, 7291, 7294, 3, 674, 337, 0, 7292, 7293, 5, 36, 0, 0, 7293, 7295, 3, 824, 412, 0, 7294, 7292, 1, 0, 0, 0, 7294, 7295, 1, 0, 0, 0, 7295, 695, 1, 0, 0, 0, 7296, 7297, 7, 100, 0, 0, 7297, 697, 1, 0, 0, 0, 7298, 7300, 5, 286, 0, 0, 7299, 7301, 3, 700, 350, 0, 7300, 7299, 1, 0, 0, 0, 7300, 7301, 1, 0, 0, 0, 7301, 7302, 1, 0, 0, 0, 7302, 7304, 3, 682, 341, 0, 7303, 7305, 3, 700, 350, 0, 7304, 7303, 1, 0, 0, 0, 7304, 7305, 1, 0, 0, 0, 7305, 699, 1, 0, 0, 0, 7306, 7307, 5, 147, 0, 0, 7307, 7308, 7, 101, 0, 0, 7308, 701, 1, 0, 0, 0, 7309, 7310, 5, 104, 0, 0, 7310, 7315, 3, 704, 352, 0, 7311, 7312, 5, 6, 0, 0, 7312, 7314, 3, 704, 352, 0, 7313, 7311, 1, 0, 0, 0, 7314, 7317, 1, 0, 0, 0, 7315, 7313, 1, 0, 0, 0, 7315, 7316, 1, 0, 0, 0, 7316, 703, 1, 0, 0, 0, 7317, 7315, 1, 0, 0, 0, 7318, 7319, 3, 818, 409, 0, 7319, 7320, 5, 36, 0, 0, 7320, 7321, 3, 708, 354, 0, 7321, 705, 1, 0, 0, 0, 7322, 7325, 5, 124, 0, 0, 7323, 7326, 3, 708, 354, 0, 7324, 7326, 3, 818, 409, 0, 7325, 7323, 1, 0, 0, 0, 7325, 7324, 1, 0, 0, 0, 7326, 707, 1, 0, 0, 0, 7327, 7329, 5, 2, 0, 0, 7328, 7330, 3, 818, 409, 0, 7329, 7328, 1, 0, 0, 0, 7329, 7330, 1, 0, 0, 0, 7330, 7334, 1, 0, 0, 0, 7331, 7332, 5, 285, 0, 0, 7332, 7333, 5, 147, 0, 0, 7333, 7335, 3, 730, 365, 0, 7334, 7331, 1, 0, 0, 0, 7334, 7335, 1, 0, 0, 0, 7335, 7337, 1, 0, 0, 0, 7336, 7338, 3, 586, 293, 0, 7337, 7336, 1, 0, 0, 0, 7337, 7338, 1, 0, 0, 0, 7338, 7340, 1, 0, 0, 0, 7339, 7341, 3, 710, 355, 0, 7340, 7339, 1, 0, 0, 0, 7340, 7341, 1, 0, 0, 0, 7341, 7342, 1, 0, 0, 0, 7342, 7343, 5, 3, 0, 0, 7343, 709, 1, 0, 0, 0, 7344, 7349, 7, 102, 0, 0, 7345, 7346, 5, 387, 0, 0, 7346, 7347, 3, 712, 356, 0, 7347, 7348, 5, 33, 0, 0, 7348, 7350, 1, 0, 0, 0, 7349, 7345, 1, 0, 0, 0, 7349, 7350, 1, 0, 0, 0, 7350, 7351, 1, 0, 0, 0, 7351, 7352, 3, 712, 356, 0, 7352, 7362, 1, 0, 0, 0, 7353, 7360, 5, 199, 0, 0, 7354, 7355, 5, 434, 0, 0, 7355, 7361, 5, 414, 0, 0, 7356, 7361, 5, 66, 0, 0, 7357, 7361, 5, 467, 0, 0, 7358, 7359, 5, 269, 0, 0, 7359, 7361, 5, 482, 0, 0, 7360, 7354, 1, 0, 0, 0, 7360, 7356, 1, 0, 0, 0, 7360, 7357, 1, 0, 0, 0, 7360, 7358, 1, 0, 0, 0, 7361, 7363, 1, 0, 0, 0, 7362, 7353, 1, 0, 0, 0, 7362, 7363, 1, 0, 0, 0, 7363, 711, 1, 0, 0, 0, 7364, 7367, 5, 362, 0, 0, 7365, 7367, 3, 674, 337, 0, 7366, 7364, 1, 0, 0, 0, 7366, 7365, 1, 0, 0, 0, 7367, 7368, 1, 0, 0, 0, 7368, 7372, 7, 103, 0, 0, 7369, 7370, 5, 434, 0, 0, 7370, 7372, 5, 414, 0, 0, 7371, 7366, 1, 0, 0, 0, 7371, 7369, 1, 0, 0, 0, 7372, 713, 1, 0, 0, 0, 7373, 7381, 3, 716, 358, 0, 7374, 7375, 5, 2, 0, 0, 7375, 7376, 3, 730, 365, 0, 7376, 7377, 5, 6, 0, 0, 7377, 7378, 3, 674, 337, 0, 7378, 7379, 5, 3, 0, 0, 7379, 7381, 1, 0, 0, 0, 7380, 7373, 1, 0, 0, 0, 7380, 7374, 1, 0, 0, 0, 7381, 715, 1, 0, 0, 0, 7382, 7383, 5, 414, 0, 0, 7383, 7385, 5, 2, 0, 0, 7384, 7386, 3, 730, 365, 0, 7385, 7384, 1, 0, 0, 0, 7385, 7386, 1, 0, 0, 0, 7386, 7387, 1, 0, 0, 0, 7387, 7388, 5, 3, 0, 0, 7388, 717, 1, 0, 0, 0, 7389, 7390, 7, 104, 0, 0, 7390, 719, 1, 0, 0, 0, 7391, 7394, 5, 29, 0, 0, 7392, 7394, 3, 722, 361, 0, 7393, 7391, 1, 0, 0, 0, 7393, 7392, 1, 0, 0, 0, 7394, 721, 1, 0, 0, 0, 7395, 7396, 7, 105, 0, 0, 7396, 723, 1, 0, 0, 0, 7397, 7404, 5, 29, 0, 0, 7398, 7399, 5, 278, 0, 0, 7399, 7400, 5, 2, 0, 0, 7400, 7401, 3, 414, 207, 0, 7401, 7402, 5, 3, 0, 0, 7402, 7404, 1, 0, 0, 0, 7403, 7397, 1, 0, 0, 0, 7403, 7398, 1, 0, 0, 0, 7404, 725, 1, 0, 0, 0, 7405, 7412, 3, 720, 360, 0, 7406, 7407, 5, 278, 0, 0, 7407, 7408, 5, 2, 0, 0, 7408, 7409, 3, 414, 207, 0, 7409, 7410, 5, 3, 0, 0, 7410, 7412, 1, 0, 0, 0, 7411, 7405, 1, 0, 0, 0, 7411, 7406, 1, 0, 0, 0, 7412, 727, 1, 0, 0, 0, 7413, 7419, 3, 726, 363, 0, 7414, 7416, 5, 77, 0, 0, 7415, 7414, 1, 0, 0, 0, 7415, 7416, 1, 0, 0, 0, 7416, 7417, 1, 0, 0, 0, 7417, 7419, 7, 106, 0, 0, 7418, 7413, 1, 0, 0, 0, 7418, 7415, 1, 0, 0, 0, 7419, 729, 1, 0, 0, 0, 7420, 7425, 3, 674, 337, 0, 7421, 7422, 5, 6, 0, 0, 7422, 7424, 3, 674, 337, 0, 7423, 7421, 1, 0, 0, 0, 7424, 7427, 1, 0, 0, 0, 7425, 7423, 1, 0, 0, 0, 7425, 7426, 1, 0, 0, 0, 7426, 731, 1, 0, 0, 0, 7427, 7425, 1, 0, 0, 0, 7428, 7429, 5, 2, 0, 0, 7429, 7430, 3, 674, 337, 0, 7430, 7431, 5, 3, 0, 0, 7431, 7434, 1, 0, 0, 0, 7432, 7434, 3, 800, 400, 0, 7433, 7428, 1, 0, 0, 0, 7433, 7432, 1, 0, 0, 0, 7434, 733, 1, 0, 0, 0, 7435, 7438, 3, 674, 337, 0, 7436, 7438, 3, 800, 400, 0, 7437, 7435, 1, 0, 0, 0, 7437, 7436, 1, 0, 0, 0, 7438, 735, 1, 0, 0, 0, 7439, 7444, 3, 738, 369, 0, 7440, 7441, 5, 6, 0, 0, 7441, 7443, 3, 738, 369, 0, 7442, 7440, 1, 0, 0, 0, 7443, 7446, 1, 0, 0, 0, 7444, 7442, 1, 0, 0, 0, 7444, 7445, 1, 0, 0, 0, 7445, 737, 1, 0, 0, 0, 7446, 7444, 1, 0, 0, 0, 7447, 7455, 3, 800, 400, 0, 7448, 7455, 3, 674, 337, 0, 7449, 7452, 3, 820, 410, 0, 7450, 7451, 7, 107, 0, 0, 7451, 7453, 3, 674, 337, 0, 7452, 7450, 1, 0, 0, 0, 7452, 7453, 1, 0, 0, 0, 7453, 7455, 1, 0, 0, 0, 7454, 7447, 1, 0, 0, 0, 7454, 7448, 1, 0, 0, 0, 7454, 7449, 1, 0, 0, 0, 7455, 739, 1, 0, 0, 0, 7456, 7466, 5, 4, 0, 0, 7457, 7467, 3, 730, 365, 0, 7458, 7463, 3, 740, 370, 0, 7459, 7460, 5, 6, 0, 0, 7460, 7462, 3, 740, 370, 0, 7461, 7459, 1, 0, 0, 0, 7462, 7465, 1, 0, 0, 0, 7463, 7461, 1, 0, 0, 0, 7463, 7464, 1, 0, 0, 0, 7464, 7467, 1, 0, 0, 0, 7465, 7463, 1, 0, 0, 0, 7466, 7457, 1, 0, 0, 0, 7466, 7458, 1, 0, 0, 0, 7466, 7467, 1, 0, 0, 0, 7467, 7468, 1, 0, 0, 0, 7468, 7469, 5, 5, 0, 0, 7469, 741, 1, 0, 0, 0, 7470, 7479, 3, 826, 413, 0, 7471, 7479, 5, 384, 0, 0, 7472, 7479, 5, 264, 0, 0, 7473, 7479, 5, 176, 0, 0, 7474, 7479, 5, 218, 0, 0, 7475, 7479, 5, 261, 0, 0, 7476, 7479, 5, 326, 0, 0, 7477, 7479, 3, 808, 404, 0, 7478, 7470, 1, 0, 0, 0, 7478, 7471, 1, 0, 0, 0, 7478, 7472, 1, 0, 0, 0, 7478, 7473, 1, 0, 0, 0, 7478, 7474, 1, 0, 0, 0, 7478, 7475, 1, 0, 0, 0, 7478, 7476, 1, 0, 0, 0, 7478, 7477, 1, 0, 0, 0, 7479, 743, 1, 0, 0, 0, 7480, 7481, 7, 108, 0, 0, 7481, 745, 1, 0, 0, 0, 7482, 7483, 3, 674, 337, 0, 7483, 7484, 5, 64, 0, 0, 7484, 7487, 3, 674, 337, 0, 7485, 7486, 5, 62, 0, 0, 7486, 7488, 3, 674, 337, 0, 7487, 7485, 1, 0, 0, 0, 7487, 7488, 1, 0, 0, 0, 7488, 7504, 1, 0, 0, 0, 7489, 7490, 3, 674, 337, 0, 7490, 7491, 5, 62, 0, 0, 7491, 7494, 3, 674, 337, 0, 7492, 7493, 5, 64, 0, 0, 7493, 7495, 3, 674, 337, 0, 7494, 7492, 1, 0, 0, 0, 7494, 7495, 1, 0, 0, 0, 7495, 7504, 1, 0, 0, 0, 7496, 7497, 3, 674, 337, 0, 7497, 7498, 5, 127, 0, 0, 7498, 7499, 3, 674, 337, 0, 7499, 7500, 5, 197, 0, 0, 7500, 7501, 3, 674, 337, 0, 7501, 7504, 1, 0, 0, 0, 7502, 7504, 3, 730, 365, 0, 7503, 7482, 1, 0, 0, 0, 7503, 7489, 1, 0, 0, 0, 7503, 7496, 1, 0, 0, 0, 7503, 7502, 1, 0, 0, 0, 7504, 747, 1, 0, 0, 0, 7505, 7506, 5, 102, 0, 0, 7506, 7507, 3, 674, 337, 0, 7507, 7508, 5, 93, 0, 0, 7508, 7509, 3, 674, 337, 0, 7509, 749, 1, 0, 0, 0, 7510, 7513, 5, 11, 0, 0, 7511, 7514, 3, 824, 412, 0, 7512, 7514, 5, 9, 0, 0, 7513, 7511, 1, 0, 0, 0, 7513, 7512, 1, 0, 0, 0, 7514, 7528, 1, 0, 0, 0, 7515, 7524, 5, 4, 0, 0, 7516, 7525, 3, 674, 337, 0, 7517, 7519, 3, 674, 337, 0, 7518, 7517, 1, 0, 0, 0, 7518, 7519, 1, 0, 0, 0, 7519, 7520, 1, 0, 0, 0, 7520, 7522, 5, 8, 0, 0, 7521, 7523, 3, 674, 337, 0, 7522, 7521, 1, 0, 0, 0, 7522, 7523, 1, 0, 0, 0, 7523, 7525, 1, 0, 0, 0, 7524, 7516, 1, 0, 0, 0, 7524, 7518, 1, 0, 0, 0, 7525, 7526, 1, 0, 0, 0, 7526, 7528, 5, 5, 0, 0, 7527, 7510, 1, 0, 0, 0, 7527, 7515, 1, 0, 0, 0, 7528, 751, 1, 0, 0, 0, 7529, 7531, 3, 750, 375, 0, 7530, 7529, 1, 0, 0, 0, 7531, 7532, 1, 0, 0, 0, 7532, 7530, 1, 0, 0, 0, 7532, 7533, 1, 0, 0, 0, 7533, 753, 1, 0, 0, 0, 7534, 7536, 3, 750, 375, 0, 7535, 7534, 1, 0, 0, 0, 7536, 7539, 1, 0, 0, 0, 7537, 7535, 1, 0, 0, 0, 7537, 7538, 1, 0, 0, 0, 7538, 755, 1, 0, 0, 0, 7539, 7537, 1, 0, 0, 0, 7540, 7545, 3, 758, 379, 0, 7541, 7542, 5, 6, 0, 0, 7542, 7544, 3, 758, 379, 0, 7543, 7541, 1, 0, 0, 0, 7544, 7547, 1, 0, 0, 0, 7545, 7543, 1, 0, 0, 0, 7545, 7546, 1, 0, 0, 0, 7546, 757, 1, 0, 0, 0, 7547, 7545, 1, 0, 0, 0, 7548, 7553, 3, 734, 367, 0, 7549, 7550, 5, 36, 0, 0, 7550, 7554, 3, 824, 412, 0, 7551, 7554, 3, 826, 413, 0, 7552, 7554, 1, 0, 0, 0, 7553, 7549, 1, 0, 0, 0, 7553, 7551, 1, 0, 0, 0, 7553, 7552, 1, 0, 0, 0, 7554, 7557, 1, 0, 0, 0, 7555, 7557, 5, 9, 0, 0, 7556, 7548, 1, 0, 0, 0, 7556, 7555, 1, 0, 0, 0, 7557, 759, 1, 0, 0, 0, 7558, 7563, 3, 780, 390, 0, 7559, 7560, 5, 6, 0, 0, 7560, 7562, 3, 780, 390, 0, 7561, 7559, 1, 0, 0, 0, 7562, 7565, 1, 0, 0, 0, 7563, 7561, 1, 0, 0, 0, 7563, 7564, 1, 0, 0, 0, 7564, 761, 1, 0, 0, 0, 7565, 7563, 1, 0, 0, 0, 7566, 7571, 3, 774, 387, 0, 7567, 7568, 5, 6, 0, 0, 7568, 7570, 3, 774, 387, 0, 7569, 7567, 1, 0, 0, 0, 7570, 7573, 1, 0, 0, 0, 7571, 7569, 1, 0, 0, 0, 7571, 7572, 1, 0, 0, 0, 7572, 763, 1, 0, 0, 0, 7573, 7571, 1, 0, 0, 0, 7574, 7579, 3, 790, 395, 0, 7575, 7576, 5, 6, 0, 0, 7576, 7578, 3, 790, 395, 0, 7577, 7575, 1, 0, 0, 0, 7578, 7581, 1, 0, 0, 0, 7579, 7577, 1, 0, 0, 0, 7579, 7580, 1, 0, 0, 0, 7580, 765, 1, 0, 0, 0, 7581, 7579, 1, 0, 0, 0, 7582, 7587, 3, 788, 394, 0, 7583, 7584, 5, 6, 0, 0, 7584, 7586, 3, 788, 394, 0, 7585, 7583, 1, 0, 0, 0, 7586, 7589, 1, 0, 0, 0, 7587, 7585, 1, 0, 0, 0, 7587, 7588, 1, 0, 0, 0, 7588, 767, 1, 0, 0, 0, 7589, 7587, 1, 0, 0, 0, 7590, 7591, 3, 780, 390, 0, 7591, 769, 1, 0, 0, 0, 7592, 7593, 3, 780, 390, 0, 7593, 771, 1, 0, 0, 0, 7594, 7595, 3, 780, 390, 0, 7595, 773, 1, 0, 0, 0, 7596, 7597, 3, 780, 390, 0, 7597, 775, 1, 0, 0, 0, 7598, 7599, 3, 780, 390, 0, 7599, 777, 1, 0, 0, 0, 7600, 7601, 3, 316, 158, 0, 7601, 779, 1, 0, 0, 0, 7602, 7604, 3, 818, 409, 0, 7603, 7605, 3, 752, 376, 0, 7604, 7603, 1, 0, 0, 0, 7604, 7605, 1, 0, 0, 0, 7605, 781, 1, 0, 0, 0, 7606, 7611, 3, 770, 385, 0, 7607, 7608, 5, 6, 0, 0, 7608, 7610, 3, 770, 385, 0, 7609, 7607, 1, 0, 0, 0, 7610, 7613, 1, 0, 0, 0, 7611, 7609, 1, 0, 0, 0, 7611, 7612, 1, 0, 0, 0, 7612, 783, 1, 0, 0, 0, 7613, 7611, 1, 0, 0, 0, 7614, 7619, 3, 818, 409, 0, 7615, 7616, 5, 6, 0, 0, 7616, 7618, 3, 818, 409, 0, 7617, 7615, 1, 0, 0, 0, 7618, 7621, 1, 0, 0, 0, 7619, 7617, 1, 0, 0, 0, 7619, 7620, 1, 0, 0, 0, 7620, 785, 1, 0, 0, 0, 7621, 7619, 1, 0, 0, 0, 7622, 7623, 3, 316, 158, 0, 7623, 787, 1, 0, 0, 0, 7624, 7625, 3, 316, 158, 0, 7625, 789, 1, 0, 0, 0, 7626, 7627, 3, 316, 158, 0, 7627, 791, 1, 0, 0, 0, 7628, 7629, 3, 818, 409, 0, 7629, 793, 1, 0, 0, 0, 7630, 7631, 3, 818, 409, 0, 7631, 795, 1, 0, 0, 0, 7632, 7637, 3, 820, 410, 0, 7633, 7634, 3, 818, 409, 0, 7634, 7635, 3, 752, 376, 0, 7635, 7637, 1, 0, 0, 0, 7636, 7632, 1, 0, 0, 0, 7636, 7633, 1, 0, 0, 0, 7637, 797, 1, 0, 0, 0, 7638, 7643, 3, 820, 410, 0, 7639, 7640, 3, 818, 409, 0, 7640, 7641, 3, 752, 376, 0, 7641, 7643, 1, 0, 0, 0, 7642, 7638, 1, 0, 0, 0, 7642, 7639, 1, 0, 0, 0, 7643, 799, 1, 0, 0, 0, 7644, 7645, 3, 818, 409, 0, 7645, 7646, 3, 754, 377, 0, 7646, 7649, 1, 0, 0, 0, 7647, 7649, 4, 400, 10, 0, 7648, 7644, 1, 0, 0, 0, 7648, 7647, 1, 0, 0, 0, 7649, 801, 1, 0, 0, 0, 7650, 7651, 3, 818, 409, 0, 7651, 803, 1, 0, 0, 0, 7652, 7657, 3, 820, 410, 0, 7653, 7654, 3, 818, 409, 0, 7654, 7655, 3, 752, 376, 0, 7655, 7657, 1, 0, 0, 0, 7656, 7652, 1, 0, 0, 0, 7656, 7653, 1, 0, 0, 0, 7657, 805, 1, 0, 0, 0, 7658, 7663, 3, 820, 410, 0, 7659, 7660, 3, 818, 409, 0, 7660, 7661, 3, 752, 376, 0, 7661, 7663, 1, 0, 0, 0, 7662, 7658, 1, 0, 0, 0, 7662, 7659, 1, 0, 0, 0, 7663, 807, 1, 0, 0, 0, 7664, 7667, 3, 810, 405, 0, 7665, 7666, 5, 487, 0, 0, 7666, 7668, 3, 810, 405, 0, 7667, 7665, 1, 0, 0, 0, 7667, 7668, 1, 0, 0, 0, 7668, 809, 1, 0, 0, 0, 7669, 7681, 5, 558, 0, 0, 7670, 7681, 5, 560, 0, 0, 7671, 7675, 5, 562, 0, 0, 7672, 7674, 5, 588, 0, 0, 7673, 7672, 1, 0, 0, 0, 7674, 7677, 1, 0, 0, 0, 7675, 7673, 1, 0, 0, 0, 7675, 7676, 1, 0, 0, 0, 7676, 7678, 1, 0, 0, 0, 7677, 7675, 1, 0, 0, 0, 7678, 7681, 5, 589, 0, 0, 7679, 7681, 5, 584, 0, 0, 7680, 7669, 1, 0, 0, 0, 7680, 7670, 1, 0, 0, 0, 7680, 7671, 1, 0, 0, 0, 7680, 7679, 1, 0, 0, 0, 7681, 811, 1, 0, 0, 0, 7682, 7684, 7, 29, 0, 0, 7683, 7682, 1, 0, 0, 0, 7683, 7684, 1, 0, 0, 0, 7684, 7685, 1, 0, 0, 0, 7685, 7686, 5, 571, 0, 0, 7686, 813, 1, 0, 0, 0, 7687, 7693, 3, 822, 411, 0, 7688, 7693, 5, 52, 0, 0, 7689, 7693, 5, 49, 0, 0, 7690, 7693, 5, 89, 0, 0, 7691, 7693, 5, 524, 0, 0, 7692, 7687, 1, 0, 0, 0, 7692, 7688, 1, 0, 0, 0, 7692, 7689, 1, 0, 0, 0, 7692, 7690, 1, 0, 0, 0, 7692, 7691, 1, 0, 0, 0, 7693, 815, 1, 0, 0, 0, 7694, 7699, 3, 814, 407, 0, 7695, 7696, 5, 6, 0, 0, 7696, 7698, 3, 814, 407, 0, 7697, 7695, 1, 0, 0, 0, 7698, 7701, 1, 0, 0, 0, 7699, 7697, 1, 0, 0, 0, 7699, 7700, 1, 0, 0, 0, 7700, 817, 1, 0, 0, 0, 7701, 7699, 1, 0, 0, 0, 7702, 7705, 3, 826, 413, 0, 7703, 7705, 3, 830, 415, 0, 7704, 7702, 1, 0, 0, 0, 7704, 7703, 1, 0, 0, 0, 7705, 819, 1, 0, 0, 0, 7706, 7709, 3, 826, 413, 0, 7707, 7709, 3, 832, 416, 0, 7708, 7706, 1, 0, 0, 0, 7708, 7707, 1, 0, 0, 0, 7709, 821, 1, 0, 0, 0, 7710, 7714, 3, 826, 413, 0, 7711, 7714, 3, 830, 415, 0, 7712, 7714, 3, 832, 416, 0, 7713, 7710, 1, 0, 0, 0, 7713, 7711, 1, 0, 0, 0, 7713, 7712, 1, 0, 0, 0, 7714, 823, 1, 0, 0, 0, 7715, 7720, 3, 826, 413, 0, 7716, 7720, 3, 830, 415, 0, 7717, 7720, 3, 832, 416, 0, 7718, 7720, 3, 834, 417, 0, 7719, 7715, 1, 0, 0, 0, 7719, 7716, 1, 0, 0, 0, 7719, 7717, 1, 0, 0, 0, 7719, 7718, 1, 0, 0, 0, 7720, 825, 1, 0, 0, 0, 7721, 7724, 5, 549, 0, 0, 7722, 7723, 5, 487, 0, 0, 7723, 7725, 3, 810, 405, 0, 7724, 7722, 1, 0, 0, 0, 7724, 7725, 1, 0, 0, 0, 7725, 7733, 1, 0, 0, 0, 7726, 7733, 3, 808, 404, 0, 7727, 7733, 5, 550, 0, 0, 7728, 7733, 5, 554, 0, 0, 7729, 7733, 5, 574, 0, 0, 7730, 7733, 5, 575, 0, 0, 7731, 7733, 3, 828, 414, 0, 7732, 7721, 1, 0, 0, 0, 7732, 7726, 1, 0, 0, 0, 7732, 7727, 1, 0, 0, 0, 7732, 7728, 1, 0, 0, 0, 7732, 7729, 1, 0, 0, 0, 7732, 7730, 1, 0, 0, 0, 7732, 7731, 1, 0, 0, 0, 7733, 827, 1, 0, 0, 0, 7734, 7735, 7, 109, 0, 0, 7735, 829, 1, 0, 0, 0, 7736, 7788, 5, 387, 0, 0, 7737, 7788, 5, 388, 0, 0, 7738, 7788, 3, 662, 331, 0, 7739, 7788, 5, 390, 0, 0, 7740, 7788, 5, 391, 0, 0, 7741, 7788, 3, 664, 332, 0, 7742, 7788, 5, 393, 0, 0, 7743, 7788, 5, 394, 0, 0, 7744, 7788, 5, 395, 0, 0, 7745, 7788, 5, 396, 0, 0, 7746, 7788, 5, 397, 0, 0, 7747, 7788, 5, 398, 0, 0, 7748, 7788, 5, 399, 0, 0, 7749, 7788, 5, 470, 0, 0, 7750, 7788, 5, 400, 0, 0, 7751, 7788, 5, 401, 0, 0, 7752, 7788, 5, 402, 0, 0, 7753, 7788, 5, 403, 0, 0, 7754, 7788, 5, 404, 0, 0, 7755, 7788, 5, 405, 0, 0, 7756, 7788, 5, 406, 0, 0, 7757, 7788, 5, 407, 0, 0, 7758, 7788, 5, 489, 0, 0, 7759, 7788, 5, 408, 0, 0, 7760, 7788, 3, 658, 329, 0, 7761, 7788, 5, 453, 0, 0, 7762, 7788, 5, 410, 0, 0, 7763, 7788, 5, 411, 0, 0, 7764, 7788, 5, 412, 0, 0, 7765, 7788, 5, 413, 0, 0, 7766, 7788, 5, 414, 0, 0, 7767, 7788, 5, 415, 0, 0, 7768, 7788, 5, 416, 0, 0, 7769, 7788, 5, 417, 0, 0, 7770, 7788, 5, 418, 0, 0, 7771, 7788, 5, 419, 0, 0, 7772, 7788, 5, 420, 0, 0, 7773, 7788, 5, 421, 0, 0, 7774, 7788, 5, 422, 0, 0, 7775, 7788, 5, 423, 0, 0, 7776, 7788, 5, 424, 0, 0, 7777, 7788, 5, 425, 0, 0, 7778, 7788, 5, 426, 0, 0, 7779, 7788, 5, 427, 0, 0, 7780, 7788, 5, 428, 0, 0, 7781, 7788, 5, 476, 0, 0, 7782, 7788, 5, 429, 0, 0, 7783, 7788, 5, 430, 0, 0, 7784, 7788, 5, 431, 0, 0, 7785, 7788, 5, 432, 0, 0, 7786, 7788, 5, 474, 0, 0, 7787, 7736, 1, 0, 0, 0, 7787, 7737, 1, 0, 0, 0, 7787, 7738, 1, 0, 0, 0, 7787, 7739, 1, 0, 0, 0, 7787, 7740, 1, 0, 0, 0, 7787, 7741, 1, 0, 0, 0, 7787, 7742, 1, 0, 0, 0, 7787, 7743, 1, 0, 0, 0, 7787, 7744, 1, 0, 0, 0, 7787, 7745, 1, 0, 0, 0, 7787, 7746, 1, 0, 0, 0, 7787, 7747, 1, 0, 0, 0, 7787, 7748, 1, 0, 0, 0, 7787, 7749, 1, 0, 0, 0, 7787, 7750, 1, 0, 0, 0, 7787, 7751, 1, 0, 0, 0, 7787, 7752, 1, 0, 0, 0, 7787, 7753, 1, 0, 0, 0, 7787, 7754, 1, 0, 0, 0, 7787, 7755, 1, 0, 0, 0, 7787, 7756, 1, 0, 0, 0, 7787, 7757, 1, 0, 0, 0, 7787, 7758, 1, 0, 0, 0, 7787, 7759, 1, 0, 0, 0, 7787, 7760, 1, 0, 0, 0, 7787, 7761, 1, 0, 0, 0, 7787, 7762, 1, 0, 0, 0, 7787, 7763, 1, 0, 0, 0, 7787, 7764, 1, 0, 0, 0, 7787, 7765, 1, 0, 0, 0, 7787, 7766, 1, 0, 0, 0, 7787, 7767, 1, 0, 0, 0, 7787, 7768, 1, 0, 0, 0, 7787, 7769, 1, 0, 0, 0, 7787, 7770, 1, 0, 0, 0, 7787, 7771, 1, 0, 0, 0, 7787, 7772, 1, 0, 0, 0, 7787, 7773, 1, 0, 0, 0, 7787, 7774, 1, 0, 0, 0, 7787, 7775, 1, 0, 0, 0, 7787, 7776, 1, 0, 0, 0, 7787, 7777, 1, 0, 0, 0, 7787, 7778, 1, 0, 0, 0, 7787, 7779, 1, 0, 0, 0, 7787, 7780, 1, 0, 0, 0, 7787, 7781, 1, 0, 0, 0, 7787, 7782, 1, 0, 0, 0, 7787, 7783, 1, 0, 0, 0, 7787, 7784, 1, 0, 0, 0, 7787, 7785, 1, 0, 0, 0, 7787, 7786, 1, 0, 0, 0, 7788, 831, 1, 0, 0, 0, 7789, 7790, 7, 110, 0, 0, 7790, 833, 1, 0, 0, 0, 7791, 7792, 7, 111, 0, 0, 7792, 835, 1, 0, 0, 0, 7793, 7795, 3, 838, 419, 0, 7794, 7793, 1, 0, 0, 0, 7794, 7795, 1, 0, 0, 0, 7795, 7806, 1, 0, 0, 0, 7796, 7804, 5, 178, 0, 0, 7797, 7801, 3, 840, 420, 0, 7798, 7801, 5, 178, 0, 0, 7799, 7801, 3, 838, 419, 0, 7800, 7797, 1, 0, 0, 0, 7800, 7798, 1, 0, 0, 0, 7800, 7799, 1, 0, 0, 0, 7801, 7802, 1, 0, 0, 0, 7802, 7800, 1, 0, 0, 0, 7802, 7803, 1, 0, 0, 0, 7803, 7805, 1, 0, 0, 0, 7804, 7800, 1, 0, 0, 0, 7804, 7805, 1, 0, 0, 0, 7805, 7807, 1, 0, 0, 0, 7806, 7796, 1, 0, 0, 0, 7806, 7807, 1, 0, 0, 0, 7807, 7808, 1, 0, 0, 0, 7808, 7812, 5, 146, 0, 0, 7809, 7811, 3, 846, 423, 0, 7810, 7809, 1, 0, 0, 0, 7811, 7814, 1, 0, 0, 0, 7812, 7810, 1, 0, 0, 0, 7812, 7813, 1, 0, 0, 0, 7813, 7816, 1, 0, 0, 0, 7814, 7812, 1, 0, 0, 0, 7815, 7817, 3, 924, 462, 0, 7816, 7815, 1, 0, 0, 0, 7816, 7817, 1, 0, 0, 0, 7817, 7818, 1, 0, 0, 0, 7818, 7820, 5, 454, 0, 0, 7819, 7821, 3, 928, 464, 0, 7820, 7819, 1, 0, 0, 0, 7820, 7821, 1, 0, 0, 0, 7821, 837, 1, 0, 0, 0, 7822, 7823, 5, 18, 0, 0, 7823, 7824, 3, 928, 464, 0, 7824, 7825, 5, 19, 0, 0, 7825, 839, 1, 0, 0, 0, 7826, 7873, 3, 928, 464, 0, 7827, 7828, 5, 496, 0, 0, 7828, 7831, 5, 62, 0, 0, 7829, 7832, 5, 28, 0, 0, 7830, 7832, 3, 818, 409, 0, 7831, 7829, 1, 0, 0, 0, 7831, 7830, 1, 0, 0, 0, 7832, 7874, 1, 0, 0, 0, 7833, 7835, 5, 497, 0, 0, 7834, 7833, 1, 0, 0, 0, 7834, 7835, 1, 0, 0, 0, 7835, 7836, 1, 0, 0, 0, 7836, 7838, 3, 652, 326, 0, 7837, 7839, 3, 98, 49, 0, 7838, 7837, 1, 0, 0, 0, 7838, 7839, 1, 0, 0, 0, 7839, 7842, 1, 0, 0, 0, 7840, 7841, 5, 77, 0, 0, 7841, 7843, 5, 78, 0, 0, 7842, 7840, 1, 0, 0, 0, 7842, 7843, 1, 0, 0, 0, 7843, 7849, 1, 0, 0, 0, 7844, 7847, 3, 844, 422, 0, 7845, 7847, 5, 53, 0, 0, 7846, 7844, 1, 0, 0, 0, 7846, 7845, 1, 0, 0, 0, 7847, 7848, 1, 0, 0, 0, 7848, 7850, 3, 930, 465, 0, 7849, 7846, 1, 0, 0, 0, 7849, 7850, 1, 0, 0, 0, 7850, 7874, 1, 0, 0, 0, 7851, 7853, 5, 269, 0, 0, 7852, 7851, 1, 0, 0, 0, 7852, 7853, 1, 0, 0, 0, 7853, 7854, 1, 0, 0, 0, 7854, 7856, 5, 324, 0, 0, 7855, 7852, 1, 0, 0, 0, 7855, 7856, 1, 0, 0, 0, 7856, 7857, 1, 0, 0, 0, 7857, 7869, 5, 172, 0, 0, 7858, 7859, 5, 2, 0, 0, 7859, 7864, 3, 842, 421, 0, 7860, 7861, 5, 6, 0, 0, 7861, 7863, 3, 842, 421, 0, 7862, 7860, 1, 0, 0, 0, 7863, 7866, 1, 0, 0, 0, 7864, 7862, 1, 0, 0, 0, 7864, 7865, 1, 0, 0, 0, 7865, 7867, 1, 0, 0, 0, 7866, 7864, 1, 0, 0, 0, 7867, 7868, 5, 3, 0, 0, 7868, 7870, 1, 0, 0, 0, 7869, 7858, 1, 0, 0, 0, 7869, 7870, 1, 0, 0, 0, 7870, 7871, 1, 0, 0, 0, 7871, 7872, 7, 112, 0, 0, 7872, 7874, 3, 560, 280, 0, 7873, 7827, 1, 0, 0, 0, 7873, 7834, 1, 0, 0, 0, 7873, 7855, 1, 0, 0, 0, 7874, 7875, 1, 0, 0, 0, 7875, 7876, 5, 7, 0, 0, 7876, 841, 1, 0, 0, 0, 7877, 7878, 3, 928, 464, 0, 7878, 7879, 3, 652, 326, 0, 7879, 843, 1, 0, 0, 0, 7880, 7881, 7, 113, 0, 0, 7881, 845, 1, 0, 0, 0, 7882, 7883, 3, 836, 418, 0, 7883, 7884, 5, 7, 0, 0, 7884, 7907, 1, 0, 0, 0, 7885, 7907, 3, 874, 437, 0, 7886, 7907, 3, 876, 438, 0, 7887, 7907, 3, 852, 426, 0, 7888, 7907, 3, 860, 430, 0, 7889, 7907, 3, 864, 432, 0, 7890, 7907, 3, 866, 433, 0, 7891, 7907, 3, 870, 435, 0, 7892, 7907, 3, 872, 436, 0, 7893, 7907, 3, 880, 440, 0, 7894, 7907, 3, 884, 442, 0, 7895, 7907, 3, 886, 443, 0, 7896, 7907, 3, 848, 424, 0, 7897, 7907, 3, 850, 425, 0, 7898, 7907, 3, 854, 427, 0, 7899, 7907, 3, 890, 445, 0, 7900, 7907, 3, 894, 447, 0, 7901, 7907, 3, 898, 449, 0, 7902, 7907, 3, 914, 457, 0, 7903, 7907, 3, 916, 458, 0, 7904, 7907, 3, 918, 459, 0, 7905, 7907, 3, 920, 460, 0, 7906, 7882, 1, 0, 0, 0, 7906, 7885, 1, 0, 0, 0, 7906, 7886, 1, 0, 0, 0, 7906, 7887, 1, 0, 0, 0, 7906, 7888, 1, 0, 0, 0, 7906, 7889, 1, 0, 0, 0, 7906, 7890, 1, 0, 0, 0, 7906, 7891, 1, 0, 0, 0, 7906, 7892, 1, 0, 0, 0, 7906, 7893, 1, 0, 0, 0, 7906, 7894, 1, 0, 0, 0, 7906, 7895, 1, 0, 0, 0, 7906, 7896, 1, 0, 0, 0, 7906, 7897, 1, 0, 0, 0, 7906, 7898, 1, 0, 0, 0, 7906, 7899, 1, 0, 0, 0, 7906, 7900, 1, 0, 0, 0, 7906, 7901, 1, 0, 0, 0, 7906, 7902, 1, 0, 0, 0, 7906, 7903, 1, 0, 0, 0, 7906, 7904, 1, 0, 0, 0, 7906, 7905, 1, 0, 0, 0, 7907, 847, 1, 0, 0, 0, 7908, 7909, 5, 498, 0, 0, 7909, 7910, 3, 930, 465, 0, 7910, 7911, 5, 7, 0, 0, 7911, 849, 1, 0, 0, 0, 7912, 7913, 5, 433, 0, 0, 7913, 7920, 3, 928, 464, 0, 7914, 7916, 5, 2, 0, 0, 7915, 7917, 3, 730, 365, 0, 7916, 7915, 1, 0, 0, 0, 7916, 7917, 1, 0, 0, 0, 7917, 7918, 1, 0, 0, 0, 7918, 7919, 5, 3, 0, 0, 7919, 7921, 5, 7, 0, 0, 7920, 7914, 1, 0, 0, 0, 7920, 7921, 1, 0, 0, 0, 7921, 7932, 1, 0, 0, 0, 7922, 7923, 5, 57, 0, 0, 7923, 7924, 3, 928, 464, 0, 7924, 7926, 5, 2, 0, 0, 7925, 7927, 3, 730, 365, 0, 7926, 7925, 1, 0, 0, 0, 7926, 7927, 1, 0, 0, 0, 7927, 7928, 1, 0, 0, 0, 7928, 7929, 5, 3, 0, 0, 7929, 7930, 5, 7, 0, 0, 7930, 7932, 1, 0, 0, 0, 7931, 7912, 1, 0, 0, 0, 7931, 7922, 1, 0, 0, 0, 7932, 851, 1, 0, 0, 0, 7933, 7934, 3, 858, 429, 0, 7934, 7935, 3, 844, 422, 0, 7935, 7936, 3, 930, 465, 0, 7936, 7937, 5, 7, 0, 0, 7937, 853, 1, 0, 0, 0, 7938, 7940, 5, 499, 0, 0, 7939, 7941, 7, 114, 0, 0, 7940, 7939, 1, 0, 0, 0, 7940, 7941, 1, 0, 0, 0, 7941, 7942, 1, 0, 0, 0, 7942, 7943, 5, 500, 0, 0, 7943, 7948, 3, 856, 428, 0, 7944, 7945, 5, 6, 0, 0, 7945, 7947, 3, 856, 428, 0, 7946, 7944, 1, 0, 0, 0, 7947, 7950, 1, 0, 0, 0, 7948, 7946, 1, 0, 0, 0, 7948, 7949, 1, 0, 0, 0, 7949, 7951, 1, 0, 0, 0, 7950, 7948, 1, 0, 0, 0, 7951, 7952, 5, 7, 0, 0, 7952, 855, 1, 0, 0, 0, 7953, 7954, 3, 858, 429, 0, 7954, 7955, 3, 844, 422, 0, 7955, 7956, 3, 818, 409, 0, 7956, 857, 1, 0, 0, 0, 7957, 7960, 3, 316, 158, 0, 7958, 7960, 5, 28, 0, 0, 7959, 7957, 1, 0, 0, 0, 7959, 7958, 1, 0, 0, 0, 7960, 7967, 1, 0, 0, 0, 7961, 7962, 5, 4, 0, 0, 7962, 7963, 3, 674, 337, 0, 7963, 7964, 5, 5, 0, 0, 7964, 7966, 1, 0, 0, 0, 7965, 7961, 1, 0, 0, 0, 7966, 7969, 1, 0, 0, 0, 7967, 7965, 1, 0, 0, 0, 7967, 7968, 1, 0, 0, 0, 7968, 859, 1, 0, 0, 0, 7969, 7967, 1, 0, 0, 0, 7970, 7971, 5, 220, 0, 0, 7971, 7972, 3, 930, 465, 0, 7972, 7976, 5, 93, 0, 0, 7973, 7975, 3, 846, 423, 0, 7974, 7973, 1, 0, 0, 0, 7975, 7978, 1, 0, 0, 0, 7976, 7974, 1, 0, 0, 0, 7976, 7977, 1, 0, 0, 0, 7977, 7990, 1, 0, 0, 0, 7978, 7976, 1, 0, 0, 0, 7979, 7980, 5, 502, 0, 0, 7980, 7981, 3, 674, 337, 0, 7981, 7985, 5, 93, 0, 0, 7982, 7984, 3, 846, 423, 0, 7983, 7982, 1, 0, 0, 0, 7984, 7987, 1, 0, 0, 0, 7985, 7983, 1, 0, 0, 0, 7985, 7986, 1, 0, 0, 0, 7986, 7989, 1, 0, 0, 0, 7987, 7985, 1, 0, 0, 0, 7988, 7979, 1, 0, 0, 0, 7989, 7992, 1, 0, 0, 0, 7990, 7988, 1, 0, 0, 0, 7990, 7991, 1, 0, 0, 0, 7991, 7994, 1, 0, 0, 0, 7992, 7990, 1, 0, 0, 0, 7993, 7995, 3, 862, 431, 0, 7994, 7993, 1, 0, 0, 0, 7994, 7995, 1, 0, 0, 0, 7995, 7996, 1, 0, 0, 0, 7996, 7997, 5, 454, 0, 0, 7997, 7998, 5, 220, 0, 0, 7998, 7999, 5, 7, 0, 0, 7999, 861, 1, 0, 0, 0, 8000, 8004, 5, 58, 0, 0, 8001, 8003, 3, 846, 423, 0, 8002, 8001, 1, 0, 0, 0, 8003, 8006, 1, 0, 0, 0, 8004, 8002, 1, 0, 0, 0, 8004, 8005, 1, 0, 0, 0, 8005, 863, 1, 0, 0, 0, 8006, 8004, 1, 0, 0, 0, 8007, 8009, 5, 40, 0, 0, 8008, 8010, 3, 930, 465, 0, 8009, 8008, 1, 0, 0, 0, 8009, 8010, 1, 0, 0, 0, 8010, 8020, 1, 0, 0, 0, 8011, 8012, 5, 102, 0, 0, 8012, 8013, 3, 730, 365, 0, 8013, 8017, 5, 93, 0, 0, 8014, 8016, 3, 846, 423, 0, 8015, 8014, 1, 0, 0, 0, 8016, 8019, 1, 0, 0, 0, 8017, 8015, 1, 0, 0, 0, 8017, 8018, 1, 0, 0, 0, 8018, 8021, 1, 0, 0, 0, 8019, 8017, 1, 0, 0, 0, 8020, 8011, 1, 0, 0, 0, 8021, 8022, 1, 0, 0, 0, 8022, 8020, 1, 0, 0, 0, 8022, 8023, 1, 0, 0, 0, 8023, 8025, 1, 0, 0, 0, 8024, 8026, 3, 862, 431, 0, 8025, 8024, 1, 0, 0, 0, 8025, 8026, 1, 0, 0, 0, 8026, 8027, 1, 0, 0, 0, 8027, 8028, 5, 454, 0, 0, 8028, 8029, 5, 40, 0, 0, 8029, 8030, 5, 7, 0, 0, 8030, 865, 1, 0, 0, 0, 8031, 8033, 3, 838, 419, 0, 8032, 8031, 1, 0, 0, 0, 8032, 8033, 1, 0, 0, 0, 8033, 8038, 1, 0, 0, 0, 8034, 8035, 5, 503, 0, 0, 8035, 8039, 3, 674, 337, 0, 8036, 8037, 5, 62, 0, 0, 8037, 8039, 3, 868, 434, 0, 8038, 8034, 1, 0, 0, 0, 8038, 8036, 1, 0, 0, 0, 8038, 8039, 1, 0, 0, 0, 8039, 8040, 1, 0, 0, 0, 8040, 8041, 3, 882, 441, 0, 8041, 867, 1, 0, 0, 0, 8042, 8043, 3, 314, 157, 0, 8043, 8066, 5, 68, 0, 0, 8044, 8046, 3, 818, 409, 0, 8045, 8047, 3, 534, 267, 0, 8046, 8045, 1, 0, 0, 0, 8046, 8047, 1, 0, 0, 0, 8047, 8067, 1, 0, 0, 0, 8048, 8067, 3, 560, 280, 0, 8049, 8067, 3, 520, 260, 0, 8050, 8051, 5, 202, 0, 0, 8051, 8054, 3, 674, 337, 0, 8052, 8053, 5, 100, 0, 0, 8053, 8055, 3, 730, 365, 0, 8054, 8052, 1, 0, 0, 0, 8054, 8055, 1, 0, 0, 0, 8055, 8067, 1, 0, 0, 0, 8056, 8058, 5, 504, 0, 0, 8057, 8056, 1, 0, 0, 0, 8057, 8058, 1, 0, 0, 0, 8058, 8059, 1, 0, 0, 0, 8059, 8060, 3, 674, 337, 0, 8060, 8061, 5, 24, 0, 0, 8061, 8064, 3, 674, 337, 0, 8062, 8063, 5, 147, 0, 0, 8063, 8065, 3, 674, 337, 0, 8064, 8062, 1, 0, 0, 0, 8064, 8065, 1, 0, 0, 0, 8065, 8067, 1, 0, 0, 0, 8066, 8044, 1, 0, 0, 0, 8066, 8048, 1, 0, 0, 0, 8066, 8049, 1, 0, 0, 0, 8066, 8050, 1, 0, 0, 0, 8066, 8057, 1, 0, 0, 0, 8067, 869, 1, 0, 0, 0, 8068, 8070, 3, 838, 419, 0, 8069, 8068, 1, 0, 0, 0, 8069, 8070, 1, 0, 0, 0, 8070, 8071, 1, 0, 0, 0, 8071, 8072, 5, 505, 0, 0, 8072, 8075, 3, 314, 157, 0, 8073, 8074, 5, 506, 0, 0, 8074, 8076, 5, 571, 0, 0, 8075, 8073, 1, 0, 0, 0, 8075, 8076, 1, 0, 0, 0, 8076, 8077, 1, 0, 0, 0, 8077, 8078, 5, 68, 0, 0, 8078, 8079, 5, 35, 0, 0, 8079, 8080, 3, 674, 337, 0, 8080, 8081, 3, 882, 441, 0, 8081, 871, 1, 0, 0, 0, 8082, 8084, 7, 115, 0, 0, 8083, 8085, 3, 928, 464, 0, 8084, 8083, 1, 0, 0, 0, 8084, 8085, 1, 0, 0, 0, 8085, 8088, 1, 0, 0, 0, 8086, 8087, 5, 102, 0, 0, 8087, 8089, 3, 930, 465, 0, 8088, 8086, 1, 0, 0, 0, 8088, 8089, 1, 0, 0, 0, 8089, 8090, 1, 0, 0, 0, 8090, 8091, 5, 7, 0, 0, 8091, 873, 1, 0, 0, 0, 8092, 8107, 5, 508, 0, 0, 8093, 8094, 5, 268, 0, 0, 8094, 8108, 3, 930, 465, 0, 8095, 8102, 5, 509, 0, 0, 8096, 8097, 5, 202, 0, 0, 8097, 8098, 3, 674, 337, 0, 8098, 8099, 5, 100, 0, 0, 8099, 8100, 3, 730, 365, 0, 8100, 8103, 1, 0, 0, 0, 8101, 8103, 3, 560, 280, 0, 8102, 8096, 1, 0, 0, 0, 8102, 8101, 1, 0, 0, 0, 8103, 8108, 1, 0, 0, 0, 8104, 8106, 3, 930, 465, 0, 8105, 8104, 1, 0, 0, 0, 8105, 8106, 1, 0, 0, 0, 8106, 8108, 1, 0, 0, 0, 8107, 8093, 1, 0, 0, 0, 8107, 8095, 1, 0, 0, 0, 8107, 8105, 1, 0, 0, 0, 8108, 8109, 1, 0, 0, 0, 8109, 8110, 5, 7, 0, 0, 8110, 875, 1, 0, 0, 0, 8111, 8141, 5, 510, 0, 0, 8112, 8114, 7, 116, 0, 0, 8113, 8112, 1, 0, 0, 0, 8113, 8114, 1, 0, 0, 0, 8114, 8127, 1, 0, 0, 0, 8115, 8128, 3, 826, 413, 0, 8116, 8117, 5, 511, 0, 0, 8117, 8128, 3, 808, 404, 0, 8118, 8125, 3, 808, 404, 0, 8119, 8120, 5, 6, 0, 0, 8120, 8122, 3, 674, 337, 0, 8121, 8119, 1, 0, 0, 0, 8122, 8123, 1, 0, 0, 0, 8123, 8121, 1, 0, 0, 0, 8123, 8124, 1, 0, 0, 0, 8124, 8126, 1, 0, 0, 0, 8125, 8121, 1, 0, 0, 0, 8125, 8126, 1, 0, 0, 0, 8126, 8128, 1, 0, 0, 0, 8127, 8115, 1, 0, 0, 0, 8127, 8116, 1, 0, 0, 0, 8127, 8118, 1, 0, 0, 0, 8127, 8128, 1, 0, 0, 0, 8128, 8138, 1, 0, 0, 0, 8129, 8130, 5, 100, 0, 0, 8130, 8135, 3, 878, 439, 0, 8131, 8132, 5, 6, 0, 0, 8132, 8134, 3, 878, 439, 0, 8133, 8131, 1, 0, 0, 0, 8134, 8137, 1, 0, 0, 0, 8135, 8133, 1, 0, 0, 0, 8135, 8136, 1, 0, 0, 0, 8136, 8139, 1, 0, 0, 0, 8137, 8135, 1, 0, 0, 0, 8138, 8129, 1, 0, 0, 0, 8138, 8139, 1, 0, 0, 0, 8139, 8140, 1, 0, 0, 0, 8140, 8142, 5, 7, 0, 0, 8141, 8113, 1, 0, 0, 0, 8141, 8142, 1, 0, 0, 0, 8142, 877, 1, 0, 0, 0, 8143, 8144, 3, 826, 413, 0, 8144, 8145, 5, 10, 0, 0, 8145, 8146, 3, 674, 337, 0, 8146, 879, 1, 0, 0, 0, 8147, 8148, 5, 518, 0, 0, 8148, 8151, 3, 930, 465, 0, 8149, 8150, 5, 6, 0, 0, 8150, 8152, 3, 930, 465, 0, 8151, 8149, 1, 0, 0, 0, 8151, 8152, 1, 0, 0, 0, 8152, 8153, 1, 0, 0, 0, 8153, 8154, 5, 7, 0, 0, 8154, 881, 1, 0, 0, 0, 8155, 8159, 5, 519, 0, 0, 8156, 8158, 3, 846, 423, 0, 8157, 8156, 1, 0, 0, 0, 8158, 8161, 1, 0, 0, 0, 8159, 8157, 1, 0, 0, 0, 8159, 8160, 1, 0, 0, 0, 8160, 8162, 1, 0, 0, 0, 8161, 8159, 1, 0, 0, 0, 8162, 8163, 5, 454, 0, 0, 8163, 8165, 5, 519, 0, 0, 8164, 8166, 3, 928, 464, 0, 8165, 8164, 1, 0, 0, 0, 8165, 8166, 1, 0, 0, 0, 8166, 8167, 1, 0, 0, 0, 8167, 8168, 5, 7, 0, 0, 8168, 883, 1, 0, 0, 0, 8169, 8171, 3, 4, 2, 0, 8170, 8172, 3, 888, 444, 0, 8171, 8170, 1, 0, 0, 0, 8171, 8172, 1, 0, 0, 0, 8172, 8173, 1, 0, 0, 0, 8173, 8174, 5, 7, 0, 0, 8174, 885, 1, 0, 0, 0, 8175, 8176, 5, 202, 0, 0, 8176, 8192, 3, 674, 337, 0, 8177, 8179, 3, 888, 444, 0, 8178, 8177, 1, 0, 0, 0, 8178, 8179, 1, 0, 0, 0, 8179, 8182, 1, 0, 0, 0, 8180, 8181, 5, 100, 0, 0, 8181, 8183, 3, 730, 365, 0, 8182, 8180, 1, 0, 0, 0, 8182, 8183, 1, 0, 0, 0, 8183, 8193, 1, 0, 0, 0, 8184, 8185, 5, 100, 0, 0, 8185, 8187, 3, 730, 365, 0, 8186, 8184, 1, 0, 0, 0, 8186, 8187, 1, 0, 0, 0, 8187, 8189, 1, 0, 0, 0, 8188, 8190, 3, 888, 444, 0, 8189, 8188, 1, 0, 0, 0, 8189, 8190, 1, 0, 0, 0, 8190, 8193, 1, 0, 0, 0, 8191, 8193, 1, 0, 0, 0, 8192, 8178, 1, 0, 0, 0, 8192, 8186, 1, 0, 0, 0, 8192, 8191, 1, 0, 0, 0, 8193, 8194, 1, 0, 0, 0, 8194, 8195, 5, 7, 0, 0, 8195, 887, 1, 0, 0, 0, 8196, 8198, 5, 71, 0, 0, 8197, 8199, 5, 346, 0, 0, 8198, 8197, 1, 0, 0, 0, 8198, 8199, 1, 0, 0, 0, 8199, 8200, 1, 0, 0, 0, 8200, 8201, 3, 730, 365, 0, 8201, 889, 1, 0, 0, 0, 8202, 8234, 5, 520, 0, 0, 8203, 8208, 3, 922, 461, 0, 8204, 8206, 5, 269, 0, 0, 8205, 8204, 1, 0, 0, 0, 8205, 8206, 1, 0, 0, 0, 8206, 8207, 1, 0, 0, 0, 8207, 8209, 5, 324, 0, 0, 8208, 8205, 1, 0, 0, 0, 8208, 8209, 1, 0, 0, 0, 8209, 8210, 1, 0, 0, 0, 8210, 8218, 5, 62, 0, 0, 8211, 8219, 3, 560, 280, 0, 8212, 8213, 5, 202, 0, 0, 8213, 8216, 3, 930, 465, 0, 8214, 8215, 5, 100, 0, 0, 8215, 8217, 3, 730, 365, 0, 8216, 8214, 1, 0, 0, 0, 8216, 8217, 1, 0, 0, 0, 8217, 8219, 1, 0, 0, 0, 8218, 8211, 1, 0, 0, 0, 8218, 8212, 1, 0, 0, 0, 8219, 8235, 1, 0, 0, 0, 8220, 8232, 3, 818, 409, 0, 8221, 8222, 5, 2, 0, 0, 8222, 8227, 3, 892, 446, 0, 8223, 8224, 5, 6, 0, 0, 8224, 8226, 3, 892, 446, 0, 8225, 8223, 1, 0, 0, 0, 8226, 8229, 1, 0, 0, 0, 8227, 8225, 1, 0, 0, 0, 8227, 8228, 1, 0, 0, 0, 8228, 8230, 1, 0, 0, 0, 8229, 8227, 1, 0, 0, 0, 8230, 8231, 5, 3, 0, 0, 8231, 8233, 1, 0, 0, 0, 8232, 8221, 1, 0, 0, 0, 8232, 8233, 1, 0, 0, 0, 8233, 8235, 1, 0, 0, 0, 8234, 8203, 1, 0, 0, 0, 8234, 8220, 1, 0, 0, 0, 8235, 8236, 1, 0, 0, 0, 8236, 8237, 5, 7, 0, 0, 8237, 891, 1, 0, 0, 0, 8238, 8239, 3, 818, 409, 0, 8239, 8240, 5, 20, 0, 0, 8240, 8242, 1, 0, 0, 0, 8241, 8238, 1, 0, 0, 0, 8241, 8242, 1, 0, 0, 0, 8242, 8243, 1, 0, 0, 0, 8243, 8244, 3, 674, 337, 0, 8244, 893, 1, 0, 0, 0, 8245, 8247, 5, 61, 0, 0, 8246, 8248, 3, 896, 448, 0, 8247, 8246, 1, 0, 0, 0, 8247, 8248, 1, 0, 0, 0, 8248, 8250, 1, 0, 0, 0, 8249, 8251, 3, 332, 166, 0, 8250, 8249, 1, 0, 0, 0, 8250, 8251, 1, 0, 0, 0, 8251, 8252, 1, 0, 0, 0, 8252, 8253, 3, 922, 461, 0, 8253, 8254, 5, 71, 0, 0, 8254, 8255, 3, 730, 365, 0, 8255, 8256, 5, 7, 0, 0, 8256, 895, 1, 0, 0, 0, 8257, 8272, 5, 268, 0, 0, 8258, 8272, 5, 293, 0, 0, 8259, 8272, 5, 207, 0, 0, 8260, 8272, 5, 249, 0, 0, 8261, 8263, 7, 50, 0, 0, 8262, 8261, 1, 0, 0, 0, 8262, 8263, 1, 0, 0, 0, 8263, 8264, 1, 0, 0, 0, 8264, 8272, 3, 674, 337, 0, 8265, 8272, 5, 30, 0, 0, 8266, 8269, 7, 117, 0, 0, 8267, 8270, 3, 674, 337, 0, 8268, 8270, 5, 30, 0, 0, 8269, 8267, 1, 0, 0, 0, 8269, 8268, 1, 0, 0, 0, 8269, 8270, 1, 0, 0, 0, 8270, 8272, 1, 0, 0, 0, 8271, 8257, 1, 0, 0, 0, 8271, 8258, 1, 0, 0, 0, 8271, 8259, 1, 0, 0, 0, 8271, 8260, 1, 0, 0, 0, 8271, 8262, 1, 0, 0, 0, 8271, 8265, 1, 0, 0, 0, 8271, 8266, 1, 0, 0, 0, 8272, 897, 1, 0, 0, 0, 8273, 8275, 5, 265, 0, 0, 8274, 8276, 3, 896, 448, 0, 8275, 8274, 1, 0, 0, 0, 8275, 8276, 1, 0, 0, 0, 8276, 8277, 1, 0, 0, 0, 8277, 8278, 3, 922, 461, 0, 8278, 8279, 5, 7, 0, 0, 8279, 899, 1, 0, 0, 0, 8280, 8282, 3, 572, 286, 0, 8281, 8280, 1, 0, 0, 0, 8281, 8282, 1, 0, 0, 0, 8282, 8283, 1, 0, 0, 0, 8283, 8284, 5, 525, 0, 0, 8284, 8286, 5, 71, 0, 0, 8285, 8287, 5, 81, 0, 0, 8286, 8285, 1, 0, 0, 0, 8286, 8287, 1, 0, 0, 0, 8287, 8288, 1, 0, 0, 0, 8288, 8290, 3, 774, 387, 0, 8289, 8291, 5, 9, 0, 0, 8290, 8289, 1, 0, 0, 0, 8290, 8291, 1, 0, 0, 0, 8291, 8296, 1, 0, 0, 0, 8292, 8294, 5, 36, 0, 0, 8293, 8292, 1, 0, 0, 0, 8293, 8294, 1, 0, 0, 0, 8294, 8295, 1, 0, 0, 0, 8295, 8297, 3, 818, 409, 0, 8296, 8293, 1, 0, 0, 0, 8296, 8297, 1, 0, 0, 0, 8297, 8298, 1, 0, 0, 0, 8298, 8299, 5, 100, 0, 0, 8299, 8300, 3, 902, 451, 0, 8300, 8301, 5, 80, 0, 0, 8301, 8303, 3, 674, 337, 0, 8302, 8304, 3, 904, 452, 0, 8303, 8302, 1, 0, 0, 0, 8304, 8305, 1, 0, 0, 0, 8305, 8303, 1, 0, 0, 0, 8305, 8306, 1, 0, 0, 0, 8306, 901, 1, 0, 0, 0, 8307, 8309, 5, 81, 0, 0, 8308, 8307, 1, 0, 0, 0, 8308, 8309, 1, 0, 0, 0, 8309, 8310, 1, 0, 0, 0, 8310, 8312, 3, 774, 387, 0, 8311, 8313, 5, 9, 0, 0, 8312, 8311, 1, 0, 0, 0, 8312, 8313, 1, 0, 0, 0, 8313, 8319, 1, 0, 0, 0, 8314, 8317, 3, 564, 282, 0, 8315, 8317, 3, 608, 304, 0, 8316, 8314, 1, 0, 0, 0, 8316, 8315, 1, 0, 0, 0, 8317, 8319, 1, 0, 0, 0, 8318, 8308, 1, 0, 0, 0, 8318, 8316, 1, 0, 0, 0, 8319, 8324, 1, 0, 0, 0, 8320, 8322, 5, 36, 0, 0, 8321, 8320, 1, 0, 0, 0, 8321, 8322, 1, 0, 0, 0, 8322, 8323, 1, 0, 0, 0, 8323, 8325, 3, 818, 409, 0, 8324, 8321, 1, 0, 0, 0, 8324, 8325, 1, 0, 0, 0, 8325, 903, 1, 0, 0, 0, 8326, 8327, 5, 102, 0, 0, 8327, 8330, 5, 526, 0, 0, 8328, 8329, 5, 33, 0, 0, 8329, 8331, 3, 674, 337, 0, 8330, 8328, 1, 0, 0, 0, 8330, 8331, 1, 0, 0, 0, 8331, 8332, 1, 0, 0, 0, 8332, 8337, 5, 93, 0, 0, 8333, 8338, 3, 908, 454, 0, 8334, 8338, 5, 182, 0, 0, 8335, 8336, 5, 57, 0, 0, 8336, 8338, 5, 270, 0, 0, 8337, 8333, 1, 0, 0, 0, 8337, 8334, 1, 0, 0, 0, 8337, 8335, 1, 0, 0, 0, 8338, 8353, 1, 0, 0, 0, 8339, 8340, 5, 102, 0, 0, 8340, 8341, 5, 77, 0, 0, 8341, 8344, 5, 526, 0, 0, 8342, 8343, 5, 33, 0, 0, 8343, 8345, 3, 674, 337, 0, 8344, 8342, 1, 0, 0, 0, 8344, 8345, 1, 0, 0, 0, 8345, 8346, 1, 0, 0, 0, 8346, 8350, 5, 93, 0, 0, 8347, 8351, 3, 906, 453, 0, 8348, 8349, 5, 57, 0, 0, 8349, 8351, 5, 270, 0, 0, 8350, 8347, 1, 0, 0, 0, 8350, 8348, 1, 0, 0, 0, 8351, 8353, 1, 0, 0, 0, 8352, 8326, 1, 0, 0, 0, 8352, 8339, 1, 0, 0, 0, 8353, 905, 1, 0, 0, 0, 8354, 8356, 5, 241, 0, 0, 8355, 8357, 3, 144, 72, 0, 8356, 8355, 1, 0, 0, 0, 8356, 8357, 1, 0, 0, 0, 8357, 8361, 1, 0, 0, 0, 8358, 8359, 5, 463, 0, 0, 8359, 8360, 7, 76, 0, 0, 8360, 8362, 5, 450, 0, 0, 8361, 8358, 1, 0, 0, 0, 8361, 8362, 1, 0, 0, 0, 8362, 8363, 1, 0, 0, 0, 8363, 8364, 3, 910, 455, 0, 8364, 907, 1, 0, 0, 0, 8365, 8366, 5, 369, 0, 0, 8366, 8384, 5, 333, 0, 0, 8367, 8368, 3, 800, 400, 0, 8368, 8369, 5, 10, 0, 0, 8369, 8370, 3, 912, 456, 0, 8370, 8385, 1, 0, 0, 0, 8371, 8372, 3, 144, 72, 0, 8372, 8373, 5, 10, 0, 0, 8373, 8374, 5, 2, 0, 0, 8374, 8379, 3, 912, 456, 0, 8375, 8376, 5, 6, 0, 0, 8376, 8378, 3, 912, 456, 0, 8377, 8375, 1, 0, 0, 0, 8378, 8381, 1, 0, 0, 0, 8379, 8377, 1, 0, 0, 0, 8379, 8380, 1, 0, 0, 0, 8380, 8382, 1, 0, 0, 0, 8381, 8379, 1, 0, 0, 0, 8382, 8383, 5, 3, 0, 0, 8383, 8385, 1, 0, 0, 0, 8384, 8367, 1, 0, 0, 0, 8384, 8371, 1, 0, 0, 0, 8385, 8386, 1, 0, 0, 0, 8386, 8384, 1, 0, 0, 0, 8386, 8387, 1, 0, 0, 0, 8387, 909, 1, 0, 0, 0, 8388, 8389, 5, 422, 0, 0, 8389, 8390, 5, 2, 0, 0, 8390, 8395, 3, 912, 456, 0, 8391, 8392, 5, 6, 0, 0, 8392, 8394, 3, 912, 456, 0, 8393, 8391, 1, 0, 0, 0, 8394, 8397, 1, 0, 0, 0, 8395, 8393, 1, 0, 0, 0, 8395, 8396, 1, 0, 0, 0, 8396, 8398, 1, 0, 0, 0, 8397, 8395, 1, 0, 0, 0, 8398, 8399, 5, 3, 0, 0, 8399, 8403, 1, 0, 0, 0, 8400, 8401, 5, 53, 0, 0, 8401, 8403, 5, 422, 0, 0, 8402, 8388, 1, 0, 0, 0, 8402, 8400, 1, 0, 0, 0, 8403, 911, 1, 0, 0, 0, 8404, 8407, 3, 588, 294, 0, 8405, 8407, 5, 53, 0, 0, 8406, 8404, 1, 0, 0, 0, 8406, 8405, 1, 0, 0, 0, 8407, 913, 1, 0, 0, 0, 8408, 8409, 5, 157, 0, 0, 8409, 8410, 3, 922, 461, 0, 8410, 8411, 5, 7, 0, 0, 8411, 915, 1, 0, 0, 0, 8412, 8413, 5, 78, 0, 0, 8413, 8414, 5, 7, 0, 0, 8414, 917, 1, 0, 0, 0, 8415, 8421, 7, 67, 0, 0, 8416, 8418, 5, 33, 0, 0, 8417, 8419, 5, 269, 0, 0, 8418, 8417, 1, 0, 0, 0, 8418, 8419, 1, 0, 0, 0, 8419, 8420, 1, 0, 0, 0, 8420, 8422, 5, 153, 0, 0, 8421, 8416, 1, 0, 0, 0, 8421, 8422, 1, 0, 0, 0, 8422, 8423, 1, 0, 0, 0, 8423, 8424, 5, 7, 0, 0, 8424, 919, 1, 0, 0, 0, 8425, 8426, 5, 333, 0, 0, 8426, 8427, 3, 316, 158, 0, 8427, 8428, 5, 94, 0, 0, 8428, 8429, 5, 53, 0, 0, 8429, 8430, 5, 7, 0, 0, 8430, 8438, 1, 0, 0, 0, 8431, 8434, 5, 313, 0, 0, 8432, 8435, 3, 316, 158, 0, 8433, 8435, 5, 30, 0, 0, 8434, 8432, 1, 0, 0, 0, 8434, 8433, 1, 0, 0, 0, 8435, 8436, 1, 0, 0, 0, 8436, 8438, 5, 7, 0, 0, 8437, 8425, 1, 0, 0, 0, 8437, 8431, 1, 0, 0, 0, 8438, 921, 1, 0, 0, 0, 8439, 8442, 3, 818, 409, 0, 8440, 8442, 5, 28, 0, 0, 8441, 8439, 1, 0, 0, 0, 8441, 8440, 1, 0, 0, 0, 8442, 923, 1, 0, 0, 0, 8443, 8460, 5, 517, 0, 0, 8444, 8445, 5, 102, 0, 0, 8445, 8450, 3, 926, 463, 0, 8446, 8447, 5, 82, 0, 0, 8447, 8449, 3, 926, 463, 0, 8448, 8446, 1, 0, 0, 0, 8449, 8452, 1, 0, 0, 0, 8450, 8448, 1, 0, 0, 0, 8450, 8451, 1, 0, 0, 0, 8451, 8453, 1, 0, 0, 0, 8452, 8450, 1, 0, 0, 0, 8453, 8457, 5, 93, 0, 0, 8454, 8456, 3, 846, 423, 0, 8455, 8454, 1, 0, 0, 0, 8456, 8459, 1, 0, 0, 0, 8457, 8455, 1, 0, 0, 0, 8457, 8458, 1, 0, 0, 0, 8458, 8461, 1, 0, 0, 0, 8459, 8457, 1, 0, 0, 0, 8460, 8444, 1, 0, 0, 0, 8461, 8462, 1, 0, 0, 0, 8462, 8460, 1, 0, 0, 0, 8462, 8463, 1, 0, 0, 0, 8463, 925, 1, 0, 0, 0, 8464, 8468, 3, 928, 464, 0, 8465, 8466, 5, 511, 0, 0, 8466, 8468, 3, 808, 404, 0, 8467, 8464, 1, 0, 0, 0, 8467, 8465, 1, 0, 0, 0, 8468, 927, 1, 0, 0, 0, 8469, 8472, 3, 818, 409, 0, 8470, 8472, 3, 828, 414, 0, 8471, 8469, 1, 0, 0, 0, 8471, 8470, 1, 0, 0, 0, 8472, 929, 1, 0, 0, 0, 8473, 8475, 3, 756, 378, 0, 8474, 8473, 1, 0, 0, 0, 8474, 8475, 1, 0, 0, 0, 8475, 8477, 1, 0, 0, 0, 8476, 8478, 3, 580, 290, 0, 8477, 8476, 1, 0, 0, 0, 8477, 8478, 1, 0, 0, 0, 8478, 8480, 1, 0, 0, 0, 8479, 8481, 3, 610, 305, 0, 8480, 8479, 1, 0, 0, 0, 8480, 8481, 1, 0, 0, 0, 8481, 8483, 1, 0, 0, 0, 8482, 8484, 3, 638, 319, 0, 8483, 8482, 1, 0, 0, 0, 8483, 8484, 1, 0, 0, 0, 8484, 8486, 1, 0, 0, 0, 8485, 8487, 3, 600, 300, 0, 8486, 8485, 1, 0, 0, 0, 8486, 8487, 1, 0, 0, 0, 8487, 8490, 1, 0, 0, 0, 8488, 8489, 5, 67, 0, 0, 8489, 8491, 3, 674, 337, 0, 8490, 8488, 1, 0, 0, 0, 8490, 8491, 1, 0, 0, 0, 8491, 8493, 1, 0, 0, 0, 8492, 8494, 3, 702, 351, 0, 8493, 8492, 1, 0, 0, 0, 8493, 8494, 1, 0, 0, 0, 8494, 931, 1, 0, 0, 0, 1188, 935, 942, 1062, 1064, 1073, 1078, 1084, 1119, 1129, 1135, 1140, 1147, 1152, 1159, 1170, 1178, 1182, 1194, 1200, 1206, 1210, 1215, 1219, 1232, 1242, 1244, 1250, 1255, 1268, 1271, 1276, 1281, 1292, 1296, 1308, 1312, 1315, 1319, 1331, 1349, 1356, 1364, 1369, 1376, 1384, 1390, 1398, 1406, 1410, 1424, 1429, 1434, 1446, 1452, 1464, 1469, 1479, 1485, 1490, 1498, 1503, 1510, 1515, 1520, 1530, 1535, 1540, 1547, 1551, 1565, 1571, 1577, 1582, 1589, 1601, 1609, 1617, 1633, 1642, 1651, 1660, 1664, 1676, 1684, 1694, 1714, 1719, 1722, 1729, 1732, 1736, 1740, 1743, 1748, 1753, 1757, 1766, 1772, 1776, 1785, 1788, 1794, 1803, 1815, 1819, 1823, 1828, 1831, 1837, 1839, 1841, 1845, 1851, 1855, 1860, 1865, 1869, 1872, 1879, 1892, 1905, 1919, 1936, 1946, 1953, 1958, 1962, 1969, 1974, 1977, 1979, 1984, 1988, 1992, 1996, 2001, 2004, 2008, 2011, 2015, 2023, 2028, 2031, 2035, 2041, 2050, 2054, 2060, 2062, 2071, 2076, 2088, 2093, 2097, 2101, 2106, 2110, 2113, 2116, 2119, 2122, 2125, 2130, 2133, 2136, 2139, 2142, 2145, 2151, 2155, 2158, 2161, 2164, 2167, 2169, 2176, 2184, 2194, 2199, 2209, 2212, 2217, 2222, 2227, 2230, 2235, 2244, 2246, 2250, 2253, 2257, 2262, 2267, 2271, 2274, 2278, 2281, 2286, 2289, 2294, 2297, 2301, 2304, 2307, 2312, 2315, 2323, 2335, 2339, 2346, 2351, 2354, 2357, 2360, 2365, 2376, 2382, 2386, 2389, 2392, 2397, 2404, 2407, 2411, 2419, 2424, 2427, 2430, 2437, 2442, 2451, 2454, 2457, 2462, 2465, 2477, 2487, 2504, 2508, 2512, 2514, 2531, 2533, 2549, 2560, 2563, 2566, 2575, 2584, 2600, 2603, 2606, 2614, 2618, 2625, 2634, 2638, 2644, 2648, 2651, 2654, 2657, 2660, 2666, 2670, 2675, 2679, 2682, 2685, 2688, 2693, 2699, 2703, 2707, 2711, 2717, 2719, 2724, 2730, 2736, 2740, 2755, 2760, 2763, 2765, 2768, 2772, 2776, 2779, 2782, 2790, 2796, 2798, 2804, 2809, 2814, 2818, 2825, 2827, 2838, 2877, 2887, 2889, 2892, 2896, 2900, 2910, 2912, 2918, 2920, 2929, 2941, 2955, 2960, 2963, 2970, 2975, 2983, 2985, 2991, 2996, 3000, 3005, 3011, 3018, 3024, 3026, 3035, 3041, 3049, 3055, 3060, 3065, 3073, 3088, 3090, 3094, 3098, 3101, 3104, 3113, 3116, 3119, 3125, 3131, 3135, 3147, 3153, 3156, 3161, 3165, 3172, 3182, 3184, 3208, 3220, 3225, 3227, 3231, 3234, 3237, 3247, 3250, 3260, 3265, 3270, 3273, 3276, 3284, 3290, 3297, 3305, 3308, 3319, 3323, 3329, 3336, 3339, 3348, 3362, 3365, 3379, 3390, 3393, 3405, 3410, 3423, 3428, 3441, 3450, 3453, 3456, 3463, 3466, 3478, 3484, 3486, 3494, 3502, 3510, 3522, 3527, 3538, 3549, 3557, 3565, 3572, 3579, 3581, 3584, 3589, 3594, 3613, 3622, 3625, 3652, 3661, 3664, 3668, 3672, 3676, 3683, 3687, 3691, 3695, 3699, 3704, 3708, 3713, 3719, 3724, 3731, 3735, 3741, 3745, 3750, 3758, 3764, 3769, 3776, 3781, 3785, 3790, 3796, 3803, 3808, 3815, 3820, 3827, 3831, 3839, 3843, 3845, 3848, 3853, 3863, 3878, 3881, 3889, 3896, 3901, 3907, 3911, 3918, 3923, 3926, 3929, 3933, 3942, 3960, 3963, 3995, 4000, 4006, 4026, 4031, 4037, 4040, 4044, 4048, 4054, 4057, 4061, 4065, 4070, 4073, 4076, 4079, 4092, 4098, 4106, 4113, 4118, 4121, 4128, 4131, 4139, 4142, 4147, 4154, 4157, 4177, 4189, 4192, 4198, 4203, 4212, 4220, 4225, 4231, 4238, 4246, 4249, 4260, 4262, 4276, 4282, 4290, 4292, 4298, 4302, 4305, 4308, 4313, 4318, 4322, 4325, 4328, 4331, 4334, 4342, 4353, 4356, 4359, 4364, 4367, 4371, 4375, 4381, 4389, 4392, 4405, 4410, 4412, 4417, 4424, 4431, 4440, 4448, 4456, 4463, 4471, 4478, 4486, 4490, 4494, 4496, 4502, 4507, 4511, 4518, 4523, 4528, 4533, 4535, 4545, 4555, 4571, 4589, 4601, 4608, 4623, 4628, 4631, 4636, 4641, 4646, 4649, 4652, 4657, 4664, 4668, 4673, 4680, 4684, 4690, 4699, 4708, 4720, 4722, 4735, 4741, 4745, 4747, 4754, 4767, 4774, 4776, 4792, 4796, 4800, 4805, 4810, 4815, 4820, 4823, 4835, 4888, 4897, 4901, 4910, 4914, 4923, 4927, 4932, 4935, 4939, 4944, 4946, 4955, 4960, 4971, 4975, 4989, 4997, 5035, 5037, 5056, 5059, 5086, 5090, 5094, 5098, 5102, 5105, 5120, 5127, 5141, 5154, 5179, 5198, 5213, 5229, 5236, 5247, 5250, 5269, 5272, 5285, 5289, 5309, 5321, 5325, 5347, 5351, 5361, 5365, 5371, 5375, 5379, 5383, 5390, 5395, 5406, 5410, 5413, 5418, 5424, 5435, 5439, 5442, 5446, 5450, 5453, 5463, 5466, 5470, 5475, 5481, 5484, 5489, 5492, 5499, 5501, 5507, 5511, 5520, 5525, 5527, 5537, 5540, 5545, 5553, 5556, 5561, 5563, 5565, 5571, 5588, 5594, 5607, 5613, 5617, 5622, 5652, 5667, 5672, 5676, 5689, 5693, 5695, 5704, 5710, 5712, 5716, 5719, 5722, 5725, 5728, 5730, 5733, 5737, 5745, 5750, 5753, 5759, 5763, 5767, 5772, 5774, 5778, 5782, 5789, 5795, 5799, 5801, 5803, 5816, 5824, 5832, 5843, 5852, 5857, 5861, 5865, 5872, 5875, 5877, 5885, 5889, 5892, 5899, 5906, 5911, 5918, 5921, 5923, 5926, 5932, 5937, 5941, 5948, 5958, 5965, 5968, 5971, 5975, 5986, 5989, 5992, 5995, 5998, 6005, 6008, 6011, 6018, 6030, 6037, 6039, 6044, 6049, 6051, 6057, 6064, 6069, 6074, 6078, 6082, 6086, 6088, 6092, 6096, 6099, 6102, 6104, 6114, 6116, 6121, 6125, 6130, 6134, 6141, 6146, 6150, 6153, 6159, 6162, 6181, 6188, 6192, 6195, 6199, 6203, 6206, 6209, 6214, 6223, 6230, 6234, 6238, 6242, 6245, 6247, 6252, 6256, 6261, 6267, 6274, 6279, 6284, 6293, 6300, 6308, 6319, 6324, 6328, 6331, 6335, 6340, 6344, 6349, 6357, 6368, 6373, 6377, 6380, 6383, 6385, 6388, 6391, 6394, 6398, 6402, 6406, 6408, 6417, 6422, 6428, 6432, 6434, 6441, 6446, 6452, 6454, 6458, 6465, 6470, 6473, 6479, 6483, 6489, 6498, 6504, 6506, 6511, 6514, 6523, 6530, 6532, 6539, 6544, 6547, 6557, 6568, 6573, 6577, 6585, 6595, 6602, 6608, 6619, 6625, 6635, 6644, 6648, 6651, 6653, 6655, 6659, 6667, 6670, 6675, 6680, 6687, 6689, 6695, 6699, 6702, 6707, 6710, 6712, 6718, 6727, 6733, 6736, 6744, 6747, 6751, 6757, 6759, 6762, 6766, 6771, 6778, 6785, 6787, 6793, 6795, 6800, 6802, 6806, 6815, 6819, 6827, 6829, 6843, 6846, 6854, 6863, 6869, 6874, 6882, 6884, 6889, 6893, 6898, 6903, 6909, 6925, 6927, 6936, 6951, 6956, 6959, 6965, 6970, 6983, 6988, 6992, 6999, 7018, 7030, 7035, 7043, 7045, 7047, 7056, 7059, 7064, 7069, 7072, 7083, 7091, 7096, 7098, 7101, 7105, 7116, 7137, 7145, 7158, 7168, 7174, 7180, 7183, 7186, 7212, 7214, 7235, 7245, 7258, 7263, 7267, 7269, 7281, 7288, 7294, 7300, 7304, 7315, 7325, 7329, 7334, 7337, 7340, 7349, 7360, 7362, 7366, 7371, 7380, 7385, 7393, 7403, 7411, 7415, 7418, 7425, 7433, 7437, 7444, 7452, 7454, 7463, 7466, 7478, 7487, 7494, 7503, 7513, 7518, 7522, 7524, 7527, 7532, 7537, 7545, 7553, 7556, 7563, 7571, 7579, 7587, 7604, 7611, 7619, 7636, 7642, 7648, 7656, 7662, 7667, 7675, 7680, 7683, 7692, 7699, 7704, 7708, 7713, 7719, 7724, 7732, 7787, 7794, 7800, 7802, 7804, 7806, 7812, 7816, 7820, 7831, 7834, 7838, 7842, 7846, 7849, 7852, 7855, 7864, 7869, 7873, 7906, 7916, 7920, 7926, 7931, 7940, 7948, 7959, 7967, 7976, 7985, 7990, 7994, 8004, 8009, 8017, 8022, 8025, 8032, 8038, 8046, 8054, 8057, 8064, 8066, 8069, 8075, 8084, 8088, 8102, 8105, 8107, 8113, 8123, 8125, 8127, 8135, 8138, 8141, 8151, 8159, 8165, 8171, 8178, 8182, 8186, 8189, 8192, 8198, 8205, 8208, 8216, 8218, 8227, 8232, 8234, 8241, 8247, 8250, 8262, 8269, 8271, 8275, 8281, 8286, 8290, 8293, 8296, 8305, 8308, 8312, 8316, 8318, 8321, 8324, 8330, 8337, 8344, 8350, 8352, 8356, 8361, 8379, 8384, 8386, 8395, 8402, 8406, 8418, 8421, 8434, 8437, 8441, 8450, 8457, 8462, 8467, 8471, 8474, 8477, 8480, 8483, 8486, 8490, 8493] \ No newline at end of file diff --git a/src/lib/postgresql/PostgreSqlParser.ts b/src/lib/postgresql/PostgreSqlParser.ts index a307728b..0ce6cc0a 100644 --- a/src/lib/postgresql/PostgreSqlParser.ts +++ b/src/lib/postgresql/PostgreSqlParser.ts @@ -11547,7 +11547,7 @@ export class PostgreSqlParser extends SQLParserBase { this.state = 2232; this.column_name_create(); this.state = 2233; - this.typename(); + localContext._colType = this.typename(); this.state = 2235; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 185, this.context) ) { @@ -36866,7 +36866,7 @@ export class PostgreSqlParser extends SQLParserBase { } this.state = 6460; - this.colid(); + localContext._alias = this.colid(); this.state = 6465; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 865, this.context) ) { @@ -36928,7 +36928,7 @@ export class PostgreSqlParser extends SQLParserBase { if (_la === 53 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 18350039) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { this.state = 6469; - this.colid(); + localContext._alias = this.colid(); } } @@ -37330,7 +37330,7 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.EscapeStringConstant: { this.state = 6472; - this.colid(); + localContext._alias = this.colid(); } break; default: @@ -45686,9 +45686,9 @@ export class PostgreSqlParser extends SQLParserBase { this.enterRule(localContext, 738, PostgreSqlParser.RULE_func_arg_expr); let _la: number; try { - this.state = 7453; + this.state = 7454; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1021, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1022, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { @@ -45708,17 +45708,25 @@ export class PostgreSqlParser extends SQLParserBase { { this.state = 7449; this.type_function_name(); - this.state = 7450; + this.state = 7452; + this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if(!(_la === 20 || _la === 22)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); + if (_la === 20 || _la === 22) { + { + this.state = 7450; + _la = this.tokenStream.LA(1); + if(!(_la === 20 || _la === 22)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 7451; + this.expression(); + } } - this.state = 7451; - this.expression(); + } break; } @@ -45744,9 +45752,9 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7455; + this.state = 7456; this.match(PostgreSqlParser.OPEN_BRACKET); - this.state = 7465; + this.state = 7466; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.OPEN_PAREN: @@ -46192,28 +46200,28 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 7456; + this.state = 7457; this.expr_list(); } break; case PostgreSqlParser.OPEN_BRACKET: { { - this.state = 7457; + this.state = 7458; this.array_expr(); - this.state = 7462; + this.state = 7463; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7458; - this.match(PostgreSqlParser.COMMA); this.state = 7459; + this.match(PostgreSqlParser.COMMA); + this.state = 7460; this.array_expr(); } } - this.state = 7464; + this.state = 7465; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -46225,7 +46233,7 @@ export class PostgreSqlParser extends SQLParserBase { default: break; } - this.state = 7467; + this.state = 7468; this.match(PostgreSqlParser.CLOSE_BRACKET); } } @@ -46247,62 +46255,62 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Extract_argContext(this.context, this.state); this.enterRule(localContext, 742, PostgreSqlParser.RULE_extract_arg); try { - this.state = 7477; + this.state = 7478; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1024, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1025, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7469; + this.state = 7470; this.identifier(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7470; + this.state = 7471; this.match(PostgreSqlParser.KW_YEAR); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7471; + this.state = 7472; this.match(PostgreSqlParser.KW_MONTH); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 7472; + this.state = 7473; this.match(PostgreSqlParser.KW_DAY); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 7473; + this.state = 7474; this.match(PostgreSqlParser.KW_HOUR); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 7474; + this.state = 7475; this.match(PostgreSqlParser.KW_MINUTE); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 7475; + this.state = 7476; this.match(PostgreSqlParser.KW_SECOND); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 7476; + this.state = 7477; this.sconst(); } break; @@ -46329,7 +46337,7 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7479; + this.state = 7480; _la = this.tokenStream.LA(1); if(!(((((_la - 483)) & ~0x1F) === 0 && ((1 << (_la - 483)) & 15) !== 0))) { this.errorHandler.recoverInline(this); @@ -46359,26 +46367,26 @@ export class PostgreSqlParser extends SQLParserBase { this.enterRule(localContext, 746, PostgreSqlParser.RULE_substr_list); let _la: number; try { - this.state = 7502; + this.state = 7503; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1027, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1028, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7481; - this.expression(); this.state = 7482; - this.match(PostgreSqlParser.KW_FROM); + this.expression(); this.state = 7483; + this.match(PostgreSqlParser.KW_FROM); + this.state = 7484; this.expression(); - this.state = 7486; + this.state = 7487; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 62) { { - this.state = 7484; - this.match(PostgreSqlParser.KW_FOR); this.state = 7485; + this.match(PostgreSqlParser.KW_FOR); + this.state = 7486; this.expression(); } } @@ -46388,20 +46396,20 @@ export class PostgreSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7488; - this.expression(); this.state = 7489; - this.match(PostgreSqlParser.KW_FOR); + this.expression(); this.state = 7490; + this.match(PostgreSqlParser.KW_FOR); + this.state = 7491; this.expression(); - this.state = 7493; + this.state = 7494; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64) { { - this.state = 7491; - this.match(PostgreSqlParser.KW_FROM); this.state = 7492; + this.match(PostgreSqlParser.KW_FROM); + this.state = 7493; this.expression(); } } @@ -46411,22 +46419,22 @@ export class PostgreSqlParser extends SQLParserBase { case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7495; - this.expression(); this.state = 7496; - this.match(PostgreSqlParser.KW_SIMILAR); - this.state = 7497; this.expression(); + this.state = 7497; + this.match(PostgreSqlParser.KW_SIMILAR); this.state = 7498; - this.match(PostgreSqlParser.KW_ESCAPE); + this.expression(); this.state = 7499; + this.match(PostgreSqlParser.KW_ESCAPE); + this.state = 7500; this.expression(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 7501; + this.state = 7502; this.expr_list(); } break; @@ -46452,13 +46460,13 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7504; - this.match(PostgreSqlParser.KW_WHEN); this.state = 7505; - this.expression(); + this.match(PostgreSqlParser.KW_WHEN); this.state = 7506; - this.match(PostgreSqlParser.KW_THEN); + this.expression(); this.state = 7507; + this.match(PostgreSqlParser.KW_THEN); + this.state = 7508; this.expression(); } } @@ -46481,15 +46489,15 @@ export class PostgreSqlParser extends SQLParserBase { this.enterRule(localContext, 750, PostgreSqlParser.RULE_indirection_el); let _la: number; try { - this.state = 7526; + this.state = 7527; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.DOT: this.enterOuterAlt(localContext, 1); { - this.state = 7509; + this.state = 7510; this.match(PostgreSqlParser.DOT); - this.state = 7512; + this.state = 7513; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_ALL: @@ -46983,13 +46991,13 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 7510; + this.state = 7511; this.collabel(); } break; case PostgreSqlParser.STAR: { - this.state = 7511; + this.state = 7512; this.match(PostgreSqlParser.STAR); } break; @@ -47001,37 +47009,37 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.OPEN_BRACKET: this.enterOuterAlt(localContext, 2); { - this.state = 7514; + this.state = 7515; this.match(PostgreSqlParser.OPEN_BRACKET); - this.state = 7523; + this.state = 7524; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1031, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1032, this.context) ) { case 1: { - this.state = 7515; + this.state = 7516; this.expression(); } break; case 2: { - this.state = 7517; + this.state = 7518; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 34074721) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 1174402559) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { { - this.state = 7516; + this.state = 7517; this.expression(); } } - this.state = 7519; + this.state = 7520; this.match(PostgreSqlParser.COLON); - this.state = 7521; + this.state = 7522; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 34074721) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 1174402559) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { { - this.state = 7520; + this.state = 7521; this.expression(); } } @@ -47039,7 +47047,7 @@ export class PostgreSqlParser extends SQLParserBase { } break; } - this.state = 7525; + this.state = 7526; this.match(PostgreSqlParser.CLOSE_BRACKET); } break; @@ -47068,7 +47076,7 @@ export class PostgreSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 7529; + this.state = 7530; this.errorHandler.sync(this); alternative = 1; do { @@ -47076,7 +47084,7 @@ export class PostgreSqlParser extends SQLParserBase { case 1: { { - this.state = 7528; + this.state = 7529; this.indirection_el(); } } @@ -47084,9 +47092,9 @@ export class PostgreSqlParser extends SQLParserBase { default: throw new antlr.NoViableAltException(this); } - this.state = 7531; + this.state = 7532; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1033, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1034, this.context); } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } } @@ -47111,21 +47119,21 @@ export class PostgreSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 7536; + this.state = 7537; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1034, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1035, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 7533; + this.state = 7534; this.indirection_el(); } } } - this.state = 7538; + this.state = 7539; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1034, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1035, this.context); } } } @@ -47150,25 +47158,25 @@ export class PostgreSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 7539; + this.state = 7540; this.target_el(); - this.state = 7544; + this.state = 7545; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1035, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1036, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 7540; - this.match(PostgreSqlParser.COMMA); this.state = 7541; + this.match(PostgreSqlParser.COMMA); + this.state = 7542; this.target_el(); } } } - this.state = 7546; + this.state = 7547; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1035, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1036, this.context); } } } @@ -47190,29 +47198,29 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Target_elContext(this.context, this.state); this.enterRule(localContext, 758, PostgreSqlParser.RULE_target_el); try { - this.state = 7555; + this.state = 7556; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1037, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1038, this.context) ) { case 1: localContext = new Target_labelContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7547; + this.state = 7548; this.column_expr_noparen(); - this.state = 7552; + this.state = 7553; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1036, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1037, this.context) ) { case 1: { - this.state = 7548; - this.match(PostgreSqlParser.KW_AS); this.state = 7549; + this.match(PostgreSqlParser.KW_AS); + this.state = 7550; this.collabel(); } break; case 2: { - this.state = 7550; + this.state = 7551; this.identifier(); } break; @@ -47228,7 +47236,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new Target_starContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 7554; + this.state = 7555; this.match(PostgreSqlParser.STAR); } break; @@ -47255,21 +47263,21 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7557; + this.state = 7558; this.qualified_name(); - this.state = 7562; + this.state = 7563; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7558; - this.match(PostgreSqlParser.COMMA); this.state = 7559; + this.match(PostgreSqlParser.COMMA); + this.state = 7560; this.qualified_name(); } } - this.state = 7564; + this.state = 7565; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -47296,21 +47304,21 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7565; + this.state = 7566; this.table_name(); - this.state = 7570; + this.state = 7571; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7566; - this.match(PostgreSqlParser.COMMA); this.state = 7567; + this.match(PostgreSqlParser.COMMA); + this.state = 7568; this.table_name(); } } - this.state = 7572; + this.state = 7573; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -47337,21 +47345,21 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7573; + this.state = 7574; this.schema_name(); - this.state = 7578; + this.state = 7579; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7574; - this.match(PostgreSqlParser.COMMA); this.state = 7575; + this.match(PostgreSqlParser.COMMA); + this.state = 7576; this.schema_name(); } } - this.state = 7580; + this.state = 7581; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -47378,21 +47386,21 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7581; + this.state = 7582; this.database_name(); - this.state = 7586; + this.state = 7587; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7582; - this.match(PostgreSqlParser.COMMA); this.state = 7583; + this.match(PostgreSqlParser.COMMA); + this.state = 7584; this.database_name(); } } - this.state = 7588; + this.state = 7589; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -47419,7 +47427,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new TablespaceNameCreateContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7589; + this.state = 7590; this.qualified_name(); } } @@ -47444,7 +47452,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new TablespaceNameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7591; + this.state = 7592; this.qualified_name(); } } @@ -47469,7 +47477,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new TableNameCreateContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7593; + this.state = 7594; this.qualified_name(); } } @@ -47494,7 +47502,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new TableNameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7595; + this.state = 7596; this.qualified_name(); } } @@ -47519,7 +47527,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new ViewNameCreateContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7597; + this.state = 7598; this.qualified_name(); } } @@ -47544,7 +47552,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new ViewNameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7599; + this.state = 7600; this.any_name(); } } @@ -47568,14 +47576,14 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7601; + this.state = 7602; this.colid(); - this.state = 7603; + this.state = 7604; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1042, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1043, this.context) ) { case 1: { - this.state = 7602; + this.state = 7603; this.indirection(); } break; @@ -47603,21 +47611,21 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7605; + this.state = 7606; this.tablespace_name(); - this.state = 7610; + this.state = 7611; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7606; - this.match(PostgreSqlParser.COMMA); this.state = 7607; + this.match(PostgreSqlParser.COMMA); + this.state = 7608; this.tablespace_name(); } } - this.state = 7612; + this.state = 7613; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -47644,21 +47652,21 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7613; + this.state = 7614; this.colid(); - this.state = 7618; + this.state = 7619; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7614; - this.match(PostgreSqlParser.COMMA); this.state = 7615; + this.match(PostgreSqlParser.COMMA); + this.state = 7616; this.colid(); } } - this.state = 7620; + this.state = 7621; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -47685,7 +47693,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new DatabaseNameCreateContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7621; + this.state = 7622; this.any_name(); } } @@ -47710,7 +47718,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new DatabaseNameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7623; + this.state = 7624; this.any_name(); } } @@ -47735,7 +47743,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new SchemaNameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7625; + this.state = 7626; this.any_name(); } } @@ -47760,7 +47768,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new RoutineNameCreateContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7627; + this.state = 7628; this.colid(); } } @@ -47785,7 +47793,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new RoutineNameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7629; + this.state = 7630; this.colid(); } } @@ -47807,14 +47815,14 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Procedure_nameContext(this.context, this.state); this.enterRule(localContext, 796, PostgreSqlParser.RULE_procedure_name); try { - this.state = 7635; + this.state = 7636; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1045, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1046, this.context) ) { case 1: localContext = new ProcedureNameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7631; + this.state = 7632; this.type_function_name(); } break; @@ -47822,9 +47830,9 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new ProcedureNameContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 7632; - this.colid(); this.state = 7633; + this.colid(); + this.state = 7634; this.indirection(); } break; @@ -47848,14 +47856,14 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Procedure_name_createContext(this.context, this.state); this.enterRule(localContext, 798, PostgreSqlParser.RULE_procedure_name_create); try { - this.state = 7641; + this.state = 7642; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1046, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1047, this.context) ) { case 1: localContext = new ProcedureNameCreateContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7637; + this.state = 7638; this.type_function_name(); } break; @@ -47863,9 +47871,9 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new ProcedureNameCreateContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 7638; - this.colid(); this.state = 7639; + this.colid(); + this.state = 7640; this.indirection(); } break; @@ -47889,16 +47897,16 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Column_nameContext(this.context, this.state); this.enterRule(localContext, 800, PostgreSqlParser.RULE_column_name); try { - this.state = 7647; + this.state = 7648; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1047, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1048, this.context) ) { case 1: localContext = new ColumnNameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7643; - this.colid(); this.state = 7644; + this.colid(); + this.state = 7645; this.opt_indirection(); } break; @@ -47906,7 +47914,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new ColumnNameMatchContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 7646; + this.state = 7647; if (!(this.shouldMatchEmpty())) { throw this.createFailedPredicateException("this.shouldMatchEmpty()"); } @@ -47935,7 +47943,7 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new ColumnNameCreateContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7649; + this.state = 7650; this.colid(); } } @@ -47957,14 +47965,14 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Function_name_createContext(this.context, this.state); this.enterRule(localContext, 804, PostgreSqlParser.RULE_function_name_create); try { - this.state = 7655; + this.state = 7656; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1048, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1049, this.context) ) { case 1: localContext = new FunctionNameCreateContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7651; + this.state = 7652; this.type_function_name(); } break; @@ -47972,9 +47980,9 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new FunctionNameCreateContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 7652; - this.colid(); this.state = 7653; + this.colid(); + this.state = 7654; this.indirection(); } break; @@ -47998,14 +48006,14 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Function_nameContext(this.context, this.state); this.enterRule(localContext, 806, PostgreSqlParser.RULE_function_name); try { - this.state = 7661; + this.state = 7662; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1049, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1050, this.context) ) { case 1: localContext = new FunctionNameContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7657; + this.state = 7658; this.type_function_name(); } break; @@ -48013,9 +48021,9 @@ export class PostgreSqlParser extends SQLParserBase { localContext = new FunctionNameContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 7658; - this.colid(); this.state = 7659; + this.colid(); + this.state = 7660; this.indirection(); } break; @@ -48041,16 +48049,16 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7663; + this.state = 7664; this.anysconst(); - this.state = 7666; + this.state = 7667; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1050, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1051, this.context) ) { case 1: { - this.state = 7664; - this.match(PostgreSqlParser.KW_UESCAPE); this.state = 7665; + this.match(PostgreSqlParser.KW_UESCAPE); + this.state = 7666; this.anysconst(); } break; @@ -48076,50 +48084,50 @@ export class PostgreSqlParser extends SQLParserBase { this.enterRule(localContext, 810, PostgreSqlParser.RULE_anysconst); let _la: number; try { - this.state = 7679; + this.state = 7680; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.StringConstant: this.enterOuterAlt(localContext, 1); { - this.state = 7668; + this.state = 7669; this.match(PostgreSqlParser.StringConstant); } break; case PostgreSqlParser.UnicodeEscapeStringConstant: this.enterOuterAlt(localContext, 2); { - this.state = 7669; + this.state = 7670; this.match(PostgreSqlParser.UnicodeEscapeStringConstant); } break; case PostgreSqlParser.BeginDollarStringConstant: this.enterOuterAlt(localContext, 3); { - this.state = 7670; + this.state = 7671; this.match(PostgreSqlParser.BeginDollarStringConstant); - this.state = 7674; + this.state = 7675; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 588) { { { - this.state = 7671; + this.state = 7672; this.match(PostgreSqlParser.DollarText); } } - this.state = 7676; + this.state = 7677; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 7677; + this.state = 7678; this.match(PostgreSqlParser.EndDollarStringConstant); } break; case PostgreSqlParser.EscapeStringConstant: this.enterOuterAlt(localContext, 4); { - this.state = 7678; + this.state = 7679; this.match(PostgreSqlParser.EscapeStringConstant); } break; @@ -48148,12 +48156,12 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7682; + this.state = 7683; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 12 || _la === 13) { { - this.state = 7681; + this.state = 7682; _la = this.tokenStream.LA(1); if(!(_la === 12 || _la === 13)) { this.errorHandler.recoverInline(this); @@ -48165,7 +48173,7 @@ export class PostgreSqlParser extends SQLParserBase { } } - this.state = 7684; + this.state = 7685; this.match(PostgreSqlParser.Integral); } } @@ -48187,41 +48195,41 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new RolespecContext(this.context, this.state); this.enterRule(localContext, 814, PostgreSqlParser.RULE_rolespec); try { - this.state = 7691; + this.state = 7692; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1054, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1055, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7686; + this.state = 7687; this.nonreservedword(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7687; + this.state = 7688; this.match(PostgreSqlParser.KW_CURRENT_USER); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7688; + this.state = 7689; this.match(PostgreSqlParser.KW_CURRENT_ROLE); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 7689; + this.state = 7690; this.match(PostgreSqlParser.KW_SESSION_USER); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 7690; + this.state = 7691; this.match(PostgreSqlParser.KW_PUBLIC); } break; @@ -48248,21 +48256,21 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7693; + this.state = 7694; this.rolespec(); - this.state = 7698; + this.state = 7699; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7694; - this.match(PostgreSqlParser.COMMA); this.state = 7695; + this.match(PostgreSqlParser.COMMA); + this.state = 7696; this.rolespec(); } } - this.state = 7700; + this.state = 7701; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -48286,20 +48294,20 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new ColidContext(this.context, this.state); this.enterRule(localContext, 818, PostgreSqlParser.RULE_colid); try { - this.state = 7703; + this.state = 7704; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1056, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1057, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7701; + this.state = 7702; this.identifier(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7702; + this.state = 7703; this.col_name_keyword(); } break; @@ -48323,20 +48331,20 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Type_function_nameContext(this.context, this.state); this.enterRule(localContext, 820, PostgreSqlParser.RULE_type_function_name); try { - this.state = 7707; + this.state = 7708; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1057, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1058, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7705; + this.state = 7706; this.identifier(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7706; + this.state = 7707; this.type_func_name_keyword(); } break; @@ -48360,27 +48368,27 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new NonreservedwordContext(this.context, this.state); this.enterRule(localContext, 822, PostgreSqlParser.RULE_nonreservedword); try { - this.state = 7712; + this.state = 7713; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1058, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1059, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7709; + this.state = 7710; this.identifier(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7710; + this.state = 7711; this.col_name_keyword(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7711; + this.state = 7712; this.type_func_name_keyword(); } break; @@ -48404,34 +48412,34 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new CollabelContext(this.context, this.state); this.enterRule(localContext, 824, PostgreSqlParser.RULE_collabel); try { - this.state = 7718; + this.state = 7719; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1059, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1060, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7714; + this.state = 7715; this.identifier(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7715; + this.state = 7716; this.col_name_keyword(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7716; + this.state = 7717; this.type_func_name_keyword(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 7717; + this.state = 7718; this.reserved_keyword(); } break; @@ -48455,22 +48463,22 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new IdentifierContext(this.context, this.state); this.enterRule(localContext, 826, PostgreSqlParser.RULE_identifier); try { - this.state = 7731; + this.state = 7732; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.Identifier: this.enterOuterAlt(localContext, 1); { - this.state = 7720; + this.state = 7721; this.match(PostgreSqlParser.Identifier); - this.state = 7723; + this.state = 7724; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1060, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1061, this.context) ) { case 1: { - this.state = 7721; - this.match(PostgreSqlParser.KW_UESCAPE); this.state = 7722; + this.match(PostgreSqlParser.KW_UESCAPE); + this.state = 7723; this.anysconst(); } break; @@ -48483,35 +48491,35 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.EscapeStringConstant: this.enterOuterAlt(localContext, 2); { - this.state = 7725; + this.state = 7726; this.sconst(); } break; case PostgreSqlParser.QuotedIdentifier: this.enterOuterAlt(localContext, 3); { - this.state = 7726; + this.state = 7727; this.match(PostgreSqlParser.QuotedIdentifier); } break; case PostgreSqlParser.UnicodeQuotedIdentifier: this.enterOuterAlt(localContext, 4); { - this.state = 7727; + this.state = 7728; this.match(PostgreSqlParser.UnicodeQuotedIdentifier); } break; case PostgreSqlParser.PLSQLVARIABLENAME: this.enterOuterAlt(localContext, 5); { - this.state = 7728; + this.state = 7729; this.match(PostgreSqlParser.PLSQLVARIABLENAME); } break; case PostgreSqlParser.PLSQLIDENTIFIER: this.enterOuterAlt(localContext, 6); { - this.state = 7729; + this.state = 7730; this.match(PostgreSqlParser.PLSQLIDENTIFIER); } break; @@ -48851,7 +48859,7 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: this.enterOuterAlt(localContext, 7); { - this.state = 7730; + this.state = 7731; this.unreserved_keyword(); } break; @@ -48880,7 +48888,7 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7733; + this.state = 7734; _la = this.tokenStream.LA(1); if(!(_la === 53 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 32767) !== 0) || ((((_la - 433)) & ~0x1F) === 0 && ((1 << (_la - 433)) & 4291821567) !== 0) || ((((_la - 465)) & ~0x1F) === 0 && ((1 << (_la - 465)) & 4278187359) !== 0) || ((((_la - 497)) & ~0x1F) === 0 && ((1 << (_la - 497)) & 146800319) !== 0) || _la === 547 || _la === 548)) { this.errorHandler.recoverInline(this); @@ -48909,363 +48917,363 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Col_name_keywordContext(this.context, this.state); this.enterRule(localContext, 830, PostgreSqlParser.RULE_col_name_keyword); try { - this.state = 7786; + this.state = 7787; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1062, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1063, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7735; + this.state = 7736; this.match(PostgreSqlParser.KW_BETWEEN); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7736; + this.state = 7737; this.match(PostgreSqlParser.KW_BIGINT); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7737; + this.state = 7738; this.bit(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 7738; + this.state = 7739; this.match(PostgreSqlParser.KW_BOOLEAN); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 7739; + this.state = 7740; this.match(PostgreSqlParser.KW_CHAR); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 7740; + this.state = 7741; this.character(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 7741; + this.state = 7742; this.match(PostgreSqlParser.KW_COALESCE); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 7742; + this.state = 7743; this.match(PostgreSqlParser.KW_DEC); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 7743; + this.state = 7744; this.match(PostgreSqlParser.KW_DECIMAL); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 7744; + this.state = 7745; this.match(PostgreSqlParser.KW_EXISTS); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 7745; + this.state = 7746; this.match(PostgreSqlParser.KW_EXTRACT); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 7746; + this.state = 7747; this.match(PostgreSqlParser.KW_FLOAT); } break; case 13: this.enterOuterAlt(localContext, 13); { - this.state = 7747; + this.state = 7748; this.match(PostgreSqlParser.KW_GREATEST); } break; case 14: this.enterOuterAlt(localContext, 14); { - this.state = 7748; + this.state = 7749; this.match(PostgreSqlParser.KW_GROUPING); } break; case 15: this.enterOuterAlt(localContext, 15); { - this.state = 7749; + this.state = 7750; this.match(PostgreSqlParser.KW_INOUT); } break; case 16: this.enterOuterAlt(localContext, 16); { - this.state = 7750; + this.state = 7751; this.match(PostgreSqlParser.KW_INT); } break; case 17: this.enterOuterAlt(localContext, 17); { - this.state = 7751; + this.state = 7752; this.match(PostgreSqlParser.KW_INTEGER); } break; case 18: this.enterOuterAlt(localContext, 18); { - this.state = 7752; + this.state = 7753; this.match(PostgreSqlParser.KW_INTERVAL); } break; case 19: this.enterOuterAlt(localContext, 19); { - this.state = 7753; + this.state = 7754; this.match(PostgreSqlParser.KW_LEAST); } break; case 20: this.enterOuterAlt(localContext, 20); { - this.state = 7754; + this.state = 7755; this.match(PostgreSqlParser.KW_NATIONAL); } break; case 21: this.enterOuterAlt(localContext, 21); { - this.state = 7755; + this.state = 7756; this.match(PostgreSqlParser.KW_NCHAR); } break; case 22: this.enterOuterAlt(localContext, 22); { - this.state = 7756; + this.state = 7757; this.match(PostgreSqlParser.KW_NONE); } break; case 23: this.enterOuterAlt(localContext, 23); { - this.state = 7757; + this.state = 7758; this.match(PostgreSqlParser.KW_NORMALIZE); } break; case 24: this.enterOuterAlt(localContext, 24); { - this.state = 7758; + this.state = 7759; this.match(PostgreSqlParser.KW_NULLIF); } break; case 25: this.enterOuterAlt(localContext, 25); { - this.state = 7759; + this.state = 7760; this.numeric(); } break; case 26: this.enterOuterAlt(localContext, 26); { - this.state = 7760; + this.state = 7761; this.match(PostgreSqlParser.KW_OUT); } break; case 27: this.enterOuterAlt(localContext, 27); { - this.state = 7761; + this.state = 7762; this.match(PostgreSqlParser.KW_OVERLAY); } break; case 28: this.enterOuterAlt(localContext, 28); { - this.state = 7762; + this.state = 7763; this.match(PostgreSqlParser.KW_POSITION); } break; case 29: this.enterOuterAlt(localContext, 29); { - this.state = 7763; + this.state = 7764; this.match(PostgreSqlParser.KW_PRECISION); } break; case 30: this.enterOuterAlt(localContext, 30); { - this.state = 7764; + this.state = 7765; this.match(PostgreSqlParser.KW_REAL); } break; case 31: this.enterOuterAlt(localContext, 31); { - this.state = 7765; + this.state = 7766; this.match(PostgreSqlParser.KW_ROW); } break; case 32: this.enterOuterAlt(localContext, 32); { - this.state = 7766; + this.state = 7767; this.match(PostgreSqlParser.KW_SETOF); } break; case 33: this.enterOuterAlt(localContext, 33); { - this.state = 7767; + this.state = 7768; this.match(PostgreSqlParser.KW_SMALLINT); } break; case 34: this.enterOuterAlt(localContext, 34); { - this.state = 7768; + this.state = 7769; this.match(PostgreSqlParser.KW_SUBSTRING); } break; case 35: this.enterOuterAlt(localContext, 35); { - this.state = 7769; + this.state = 7770; this.match(PostgreSqlParser.KW_TIME); } break; case 36: this.enterOuterAlt(localContext, 36); { - this.state = 7770; + this.state = 7771; this.match(PostgreSqlParser.KW_TIMESTAMP); } break; case 37: this.enterOuterAlt(localContext, 37); { - this.state = 7771; + this.state = 7772; this.match(PostgreSqlParser.KW_TREAT); } break; case 38: this.enterOuterAlt(localContext, 38); { - this.state = 7772; + this.state = 7773; this.match(PostgreSqlParser.KW_TRIM); } break; case 39: this.enterOuterAlt(localContext, 39); { - this.state = 7773; + this.state = 7774; this.match(PostgreSqlParser.KW_VALUES); } break; case 40: this.enterOuterAlt(localContext, 40); { - this.state = 7774; + this.state = 7775; this.match(PostgreSqlParser.KW_VARCHAR); } break; case 41: this.enterOuterAlt(localContext, 41); { - this.state = 7775; + this.state = 7776; this.match(PostgreSqlParser.KW_XMLATTRIBUTES); } break; case 42: this.enterOuterAlt(localContext, 42); { - this.state = 7776; + this.state = 7777; this.match(PostgreSqlParser.KW_XMLCONCAT); } break; case 43: this.enterOuterAlt(localContext, 43); { - this.state = 7777; + this.state = 7778; this.match(PostgreSqlParser.KW_XMLELEMENT); } break; case 44: this.enterOuterAlt(localContext, 44); { - this.state = 7778; + this.state = 7779; this.match(PostgreSqlParser.KW_XMLEXISTS); } break; case 45: this.enterOuterAlt(localContext, 45); { - this.state = 7779; + this.state = 7780; this.match(PostgreSqlParser.KW_XMLFOREST); } break; case 46: this.enterOuterAlt(localContext, 46); { - this.state = 7780; + this.state = 7781; this.match(PostgreSqlParser.KW_XMLNAMESPACES); } break; case 47: this.enterOuterAlt(localContext, 47); { - this.state = 7781; + this.state = 7782; this.match(PostgreSqlParser.KW_XMLPARSE); } break; case 48: this.enterOuterAlt(localContext, 48); { - this.state = 7782; + this.state = 7783; this.match(PostgreSqlParser.KW_XMLPI); } break; case 49: this.enterOuterAlt(localContext, 49); { - this.state = 7783; + this.state = 7784; this.match(PostgreSqlParser.KW_XMLROOT); } break; case 50: this.enterOuterAlt(localContext, 50); { - this.state = 7784; + this.state = 7785; this.match(PostgreSqlParser.KW_XMLSERIALIZE); } break; case 51: this.enterOuterAlt(localContext, 51); { - this.state = 7785; + this.state = 7786; this.match(PostgreSqlParser.KW_XMLTABLE); } break; @@ -49292,7 +49300,7 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7788; + this.state = 7789; _la = this.tokenStream.LA(1); if(!(((((_la - 106)) & ~0x1F) === 0 && ((1 << (_la - 106)) & 8126463) !== 0) || _la === 472)) { this.errorHandler.recoverInline(this); @@ -49324,7 +49332,7 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7790; + this.state = 7791; _la = this.tokenStream.LA(1); if(!(((((_la - 30)) & ~0x1F) === 0 && ((1 << (_la - 30)) & 4286578687) !== 0) || ((((_la - 62)) & ~0x1F) === 0 && ((1 << (_la - 62)) & 4294966783) !== 0) || ((((_la - 94)) & ~0x1F) === 0 && ((1 << (_la - 94)) & 4095) !== 0) || _la === 454)) { this.errorHandler.recoverInline(this); @@ -49358,53 +49366,53 @@ export class PostgreSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 1); { { - this.state = 7793; + this.state = 7794; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 18) { { - this.state = 7792; + this.state = 7793; this.label_decl(); } } - this.state = 7805; + this.state = 7806; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 178) { { - this.state = 7795; + this.state = 7796; this.match(PostgreSqlParser.KW_DECLARE); - this.state = 7803; + this.state = 7804; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1066, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1067, this.context) ) { case 1: { - this.state = 7799; + this.state = 7800; this.errorHandler.sync(this); alternative = 1; do { switch (alternative) { case 1: { - this.state = 7799; + this.state = 7800; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1064, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1065, this.context) ) { case 1: { - this.state = 7796; + this.state = 7797; this.decl_statement(); } break; case 2: { - this.state = 7797; + this.state = 7798; this.match(PostgreSqlParser.KW_DECLARE); } break; case 3: { - this.state = 7798; + this.state = 7799; this.label_decl(); } break; @@ -49414,9 +49422,9 @@ export class PostgreSqlParser extends SQLParserBase { default: throw new antlr.NoViableAltException(this); } - this.state = 7801; + this.state = 7802; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1065, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1066, this.context); } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } break; @@ -49425,42 +49433,42 @@ export class PostgreSqlParser extends SQLParserBase { } } - this.state = 7807; + this.state = 7808; this.match(PostgreSqlParser.KW_BEGIN); - this.state = 7811; + this.state = 7812; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1068, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1069, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 7808; + this.state = 7809; this.proc_stmt(); } } } - this.state = 7813; + this.state = 7814; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1068, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1069, this.context); } - this.state = 7815; + this.state = 7816; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 517) { { - this.state = 7814; + this.state = 7815; this.exception_sect(); } } - this.state = 7817; + this.state = 7818; this.match(PostgreSqlParser.KW_END); - this.state = 7819; + this.state = 7820; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 53 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 18350039) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 7818; + this.state = 7819; this.any_identifier(); } } @@ -49487,11 +49495,11 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7821; - this.match(PostgreSqlParser.LESS_LESS); this.state = 7822; - this.any_identifier(); + this.match(PostgreSqlParser.LESS_LESS); this.state = 7823; + this.any_identifier(); + this.state = 7824; this.match(PostgreSqlParser.GREATER_GREATER); } } @@ -49516,23 +49524,23 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7825; + this.state = 7826; this.any_identifier(); - this.state = 7872; + this.state = 7873; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1081, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1082, this.context) ) { case 1: { - this.state = 7826; - this.match(PostgreSqlParser.KW_ALIAS); this.state = 7827; + this.match(PostgreSqlParser.KW_ALIAS); + this.state = 7828; this.match(PostgreSqlParser.KW_FOR); - this.state = 7830; + this.state = 7831; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.PARAM: { - this.state = 7828; + this.state = 7829; this.match(PostgreSqlParser.PARAM); } break; @@ -49931,7 +49939,7 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 7829; + this.state = 7830; this.colid(); } break; @@ -49942,65 +49950,65 @@ export class PostgreSqlParser extends SQLParserBase { break; case 2: { - this.state = 7833; + this.state = 7834; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1072, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1073, this.context) ) { case 1: { - this.state = 7832; + this.state = 7833; this.match(PostgreSqlParser.KW_CONSTANT); } break; } - this.state = 7835; + this.state = 7836; this.typename(); - this.state = 7837; + this.state = 7838; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 43) { { - this.state = 7836; + this.state = 7837; this.opt_collate_clause(); } } - this.state = 7841; + this.state = 7842; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 77) { { - this.state = 7839; - this.match(PostgreSqlParser.KW_NOT); this.state = 7840; + this.match(PostgreSqlParser.KW_NOT); + this.state = 7841; this.match(PostgreSqlParser.KW_NULL); } } - this.state = 7848; + this.state = 7849; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 10 || _la === 20 || _la === 53) { { - this.state = 7845; + this.state = 7846; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.EQUAL: case PostgreSqlParser.COLON_EQUALS: { - this.state = 7843; + this.state = 7844; this.assign_operator(); } break; case PostgreSqlParser.KW_DEFAULT: { - this.state = 7844; + this.state = 7845; this.match(PostgreSqlParser.KW_DEFAULT); } break; default: throw new antlr.NoViableAltException(this); } - this.state = 7847; + this.state = 7848; this.sql_expression(); } } @@ -50009,59 +50017,59 @@ export class PostgreSqlParser extends SQLParserBase { break; case 3: { - this.state = 7854; + this.state = 7855; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 269 || _la === 324) { { - this.state = 7851; + this.state = 7852; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 269) { { - this.state = 7850; + this.state = 7851; this.match(PostgreSqlParser.KW_NO); } } - this.state = 7853; + this.state = 7854; this.match(PostgreSqlParser.KW_SCROLL); } } - this.state = 7856; + this.state = 7857; this.match(PostgreSqlParser.KW_CURSOR); - this.state = 7868; + this.state = 7869; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 7857; - this.match(PostgreSqlParser.OPEN_PAREN); this.state = 7858; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7859; this.decl_cursor_arg(); - this.state = 7863; + this.state = 7864; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7859; - this.match(PostgreSqlParser.COMMA); this.state = 7860; + this.match(PostgreSqlParser.COMMA); + this.state = 7861; this.decl_cursor_arg(); } } - this.state = 7865; + this.state = 7866; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 7866; + this.state = 7867; this.match(PostgreSqlParser.CLOSE_PAREN); } } - this.state = 7870; + this.state = 7871; _la = this.tokenStream.LA(1); if(!(_la === 62 || _la === 116)) { this.errorHandler.recoverInline(this); @@ -50070,12 +50078,12 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 7871; + this.state = 7872; this.selectstmt(); } break; } - this.state = 7874; + this.state = 7875; this.match(PostgreSqlParser.SEMI); } } @@ -50099,9 +50107,9 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7876; - this.any_identifier(); this.state = 7877; + this.any_identifier(); + this.state = 7878; this.typename(); } } @@ -50126,7 +50134,7 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7879; + this.state = 7880; _la = this.tokenStream.LA(1); if(!(_la === 10 || _la === 20)) { this.errorHandler.recoverInline(this); @@ -50155,162 +50163,162 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Proc_stmtContext(this.context, this.state); this.enterRule(localContext, 846, PostgreSqlParser.RULE_proc_stmt); try { - this.state = 7905; + this.state = 7906; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1082, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1083, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7881; - this.pl_block(); this.state = 7882; + this.pl_block(); + this.state = 7883; this.match(PostgreSqlParser.SEMI); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7884; + this.state = 7885; this.stmt_return(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7885; + this.state = 7886; this.stmt_raise(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 7886; + this.state = 7887; this.stmt_assign(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 7887; + this.state = 7888; this.stmt_if(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 7888; + this.state = 7889; this.stmt_case(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 7889; + this.state = 7890; this.stmt_loop_while_for(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 7890; + this.state = 7891; this.stmt_foreach_a(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 7891; + this.state = 7892; this.stmt_exit(); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 7892; + this.state = 7893; this.stmt_assert(); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 7893; + this.state = 7894; this.stmt_execsql(); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 7894; + this.state = 7895; this.stmt_dynexecute(); } break; case 13: this.enterOuterAlt(localContext, 13); { - this.state = 7895; + this.state = 7896; this.stmt_perform(); } break; case 14: this.enterOuterAlt(localContext, 14); { - this.state = 7896; + this.state = 7897; this.stmt_call(); } break; case 15: this.enterOuterAlt(localContext, 15); { - this.state = 7897; + this.state = 7898; this.stmt_getdiag(); } break; case 16: this.enterOuterAlt(localContext, 16); { - this.state = 7898; + this.state = 7899; this.stmt_open(); } break; case 17: this.enterOuterAlt(localContext, 17); { - this.state = 7899; + this.state = 7900; this.stmt_fetch(); } break; case 18: this.enterOuterAlt(localContext, 18); { - this.state = 7900; + this.state = 7901; this.stmt_move(); } break; case 19: this.enterOuterAlt(localContext, 19); { - this.state = 7901; + this.state = 7902; this.stmt_close(); } break; case 20: this.enterOuterAlt(localContext, 20); { - this.state = 7902; + this.state = 7903; this.stmt_null(); } break; case 21: this.enterOuterAlt(localContext, 21); { - this.state = 7903; + this.state = 7904; this.stmt_commit_or_rollback(); } break; case 22: this.enterOuterAlt(localContext, 22); { - this.state = 7904; + this.state = 7905; this.stmt_set(); } break; @@ -50336,11 +50344,11 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7907; - this.match(PostgreSqlParser.KW_PERFORM); this.state = 7908; - this.sql_expression(); + this.match(PostgreSqlParser.KW_PERFORM); this.state = 7909; + this.sql_expression(); + this.state = 7910; this.match(PostgreSqlParser.SEMI); } } @@ -50363,36 +50371,36 @@ export class PostgreSqlParser extends SQLParserBase { this.enterRule(localContext, 850, PostgreSqlParser.RULE_stmt_call); let _la: number; try { - this.state = 7930; + this.state = 7931; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_CALL: this.enterOuterAlt(localContext, 1); { - this.state = 7911; - this.match(PostgreSqlParser.KW_CALL); this.state = 7912; + this.match(PostgreSqlParser.KW_CALL); + this.state = 7913; this.any_identifier(); - this.state = 7919; + this.state = 7920; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1084, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1085, this.context) ) { case 1: { - this.state = 7913; + this.state = 7914; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 7915; + this.state = 7916; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 34074721) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 1174402559) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { { - this.state = 7914; + this.state = 7915; this.expr_list(); } } - this.state = 7917; - this.match(PostgreSqlParser.CLOSE_PAREN); this.state = 7918; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 7919; this.match(PostgreSqlParser.SEMI); } break; @@ -50402,25 +50410,25 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_DO: this.enterOuterAlt(localContext, 2); { - this.state = 7921; - this.match(PostgreSqlParser.KW_DO); this.state = 7922; - this.any_identifier(); + this.match(PostgreSqlParser.KW_DO); this.state = 7923; + this.any_identifier(); + this.state = 7924; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 7925; + this.state = 7926; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & 34074721) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 1174402559) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { { - this.state = 7924; + this.state = 7925; this.expr_list(); } } - this.state = 7927; - this.match(PostgreSqlParser.CLOSE_PAREN); this.state = 7928; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 7929; this.match(PostgreSqlParser.SEMI); } break; @@ -50448,13 +50456,13 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7932; - this.assign_var(); this.state = 7933; - this.assign_operator(); + this.assign_var(); this.state = 7934; - this.sql_expression(); + this.assign_operator(); this.state = 7935; + this.sql_expression(); + this.state = 7936; this.match(PostgreSqlParser.SEMI); } } @@ -50479,14 +50487,14 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7937; + this.state = 7938; this.match(PostgreSqlParser.KW_GET); - this.state = 7939; + this.state = 7940; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 434 || _la === 501) { { - this.state = 7938; + this.state = 7939; _la = this.tokenStream.LA(1); if(!(_la === 434 || _la === 501)) { this.errorHandler.recoverInline(this); @@ -50498,29 +50506,29 @@ export class PostgreSqlParser extends SQLParserBase { } } - this.state = 7941; + this.state = 7942; this.match(PostgreSqlParser.KW_DIAGNOSTICS); { - this.state = 7942; + this.state = 7943; this.getdiag_list_item(); - this.state = 7947; + this.state = 7948; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 7943; - this.match(PostgreSqlParser.COMMA); this.state = 7944; + this.match(PostgreSqlParser.COMMA); + this.state = 7945; this.getdiag_list_item(); } } - this.state = 7949; + this.state = 7950; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } - this.state = 7950; + this.state = 7951; this.match(PostgreSqlParser.SEMI); } } @@ -50544,11 +50552,11 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7952; - this.assign_var(); this.state = 7953; - this.assign_operator(); + this.assign_var(); this.state = 7954; + this.assign_operator(); + this.state = 7955; this.colid(); } } @@ -50573,7 +50581,7 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 7958; + this.state = 7959; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_DEFAULT: @@ -50971,34 +50979,34 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 7956; + this.state = 7957; this.any_name(); } break; case PostgreSqlParser.PARAM: { - this.state = 7957; + this.state = 7958; this.match(PostgreSqlParser.PARAM); } break; default: throw new antlr.NoViableAltException(this); } - this.state = 7966; + this.state = 7967; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 4) { { { - this.state = 7960; - this.match(PostgreSqlParser.OPEN_BRACKET); this.state = 7961; - this.expression(); + this.match(PostgreSqlParser.OPEN_BRACKET); this.state = 7962; + this.expression(); + this.state = 7963; this.match(PostgreSqlParser.CLOSE_BRACKET); } } - this.state = 7968; + this.state = 7969; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -51026,79 +51034,79 @@ export class PostgreSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 7969; - this.match(PostgreSqlParser.KW_IF); this.state = 7970; - this.sql_expression(); + this.match(PostgreSqlParser.KW_IF); this.state = 7971; + this.sql_expression(); + this.state = 7972; this.match(PostgreSqlParser.KW_THEN); - this.state = 7975; + this.state = 7976; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1091, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1092, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 7972; + this.state = 7973; this.proc_stmt(); } } } - this.state = 7977; + this.state = 7978; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1091, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1092, this.context); } { - this.state = 7989; + this.state = 7990; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 502) { { { - this.state = 7978; - this.match(PostgreSqlParser.KW_ELSIF); this.state = 7979; - this.expression(); + this.match(PostgreSqlParser.KW_ELSIF); this.state = 7980; + this.expression(); + this.state = 7981; this.match(PostgreSqlParser.KW_THEN); - this.state = 7984; + this.state = 7985; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1092, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1093, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 7981; + this.state = 7982; this.proc_stmt(); } } } - this.state = 7986; + this.state = 7987; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1092, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1093, this.context); } } } - this.state = 7991; + this.state = 7992; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } - this.state = 7993; + this.state = 7994; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 58) { { - this.state = 7992; + this.state = 7993; this.stmt_else(); } } - this.state = 7995; - this.match(PostgreSqlParser.KW_END); this.state = 7996; - this.match(PostgreSqlParser.KW_IF); + this.match(PostgreSqlParser.KW_END); this.state = 7997; + this.match(PostgreSqlParser.KW_IF); + this.state = 7998; this.match(PostgreSqlParser.SEMI); } } @@ -51123,23 +51131,23 @@ export class PostgreSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 7999; + this.state = 8000; this.match(PostgreSqlParser.KW_ELSE); - this.state = 8003; + this.state = 8004; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1095, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1096, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 8000; + this.state = 8001; this.proc_stmt(); } } } - this.state = 8005; + this.state = 8006; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1095, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1096, this.context); } } } @@ -51165,67 +51173,67 @@ export class PostgreSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 8006; + this.state = 8007; this.match(PostgreSqlParser.KW_CASE); - this.state = 8008; + this.state = 8009; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1096, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1097, this.context) ) { case 1: { - this.state = 8007; + this.state = 8008; this.sql_expression(); } break; } - this.state = 8019; + this.state = 8020; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 8010; - this.match(PostgreSqlParser.KW_WHEN); this.state = 8011; - this.expr_list(); + this.match(PostgreSqlParser.KW_WHEN); this.state = 8012; + this.expr_list(); + this.state = 8013; this.match(PostgreSqlParser.KW_THEN); - this.state = 8016; + this.state = 8017; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1097, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1098, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 8013; + this.state = 8014; this.proc_stmt(); } } } - this.state = 8018; + this.state = 8019; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1097, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1098, this.context); } } } - this.state = 8021; + this.state = 8022; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 102); - this.state = 8024; + this.state = 8025; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 58) { { - this.state = 8023; + this.state = 8024; this.stmt_else(); } } - this.state = 8026; - this.match(PostgreSqlParser.KW_END); this.state = 8027; - this.match(PostgreSqlParser.KW_CASE); + this.match(PostgreSqlParser.KW_END); this.state = 8028; + this.match(PostgreSqlParser.KW_CASE); + this.state = 8029; this.match(PostgreSqlParser.SEMI); } } @@ -51250,25 +51258,25 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8031; + this.state = 8032; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 18) { { - this.state = 8030; + this.state = 8031; this.label_decl(); } } - this.state = 8037; + this.state = 8038; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_WHILE: { { - this.state = 8033; - this.match(PostgreSqlParser.KW_WHILE); this.state = 8034; + this.match(PostgreSqlParser.KW_WHILE); + this.state = 8035; this.expression(); } } @@ -51276,9 +51284,9 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_FOR: { { - this.state = 8035; - this.match(PostgreSqlParser.KW_FOR); this.state = 8036; + this.match(PostgreSqlParser.KW_FOR); + this.state = 8037; this.for_control(); } } @@ -51288,7 +51296,7 @@ export class PostgreSqlParser extends SQLParserBase { default: break; } - this.state = 8039; + this.state = 8040; this.loop_body(); } } @@ -51313,23 +51321,23 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8041; - this.any_name_list(); this.state = 8042; + this.any_name_list(); + this.state = 8043; this.match(PostgreSqlParser.KW_IN); - this.state = 8065; + this.state = 8066; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1106, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1107, this.context) ) { case 1: { - this.state = 8043; + this.state = 8044; this.colid(); - this.state = 8045; + this.state = 8046; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 8044; + this.state = 8045; this.execute_param_clause(); } } @@ -51338,30 +51346,30 @@ export class PostgreSqlParser extends SQLParserBase { break; case 2: { - this.state = 8047; + this.state = 8048; this.selectstmt(); } break; case 3: { - this.state = 8048; + this.state = 8049; this.explainstmt(); } break; case 4: { - this.state = 8049; - this.match(PostgreSqlParser.KW_EXECUTE); this.state = 8050; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 8051; this.expression(); - this.state = 8053; + this.state = 8054; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 8051; - this.match(PostgreSqlParser.KW_USING); this.state = 8052; + this.match(PostgreSqlParser.KW_USING); + this.state = 8053; this.expr_list(); } } @@ -51370,30 +51378,30 @@ export class PostgreSqlParser extends SQLParserBase { break; case 5: { - this.state = 8056; + this.state = 8057; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1104, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1105, this.context) ) { case 1: { - this.state = 8055; + this.state = 8056; this.match(PostgreSqlParser.KW_REVERSE); } break; } - this.state = 8058; - this.expression(); this.state = 8059; - this.match(PostgreSqlParser.DOT_DOT); + this.expression(); this.state = 8060; + this.match(PostgreSqlParser.DOT_DOT); + this.state = 8061; this.expression(); - this.state = 8063; + this.state = 8064; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 147) { { - this.state = 8061; - this.match(PostgreSqlParser.KW_BY); this.state = 8062; + this.match(PostgreSqlParser.KW_BY); + this.state = 8063; this.expression(); } } @@ -51424,39 +51432,39 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8068; + this.state = 8069; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 18) { { - this.state = 8067; + this.state = 8068; this.label_decl(); } } - this.state = 8070; - this.match(PostgreSqlParser.KW_FOREACH); this.state = 8071; + this.match(PostgreSqlParser.KW_FOREACH); + this.state = 8072; this.any_name_list(); - this.state = 8074; + this.state = 8075; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 506) { { - this.state = 8072; - this.match(PostgreSqlParser.KW_SLICE); this.state = 8073; + this.match(PostgreSqlParser.KW_SLICE); + this.state = 8074; this.match(PostgreSqlParser.Integral); } } - this.state = 8076; - this.match(PostgreSqlParser.KW_IN); this.state = 8077; - this.match(PostgreSqlParser.KW_ARRAY); + this.match(PostgreSqlParser.KW_IN); this.state = 8078; - this.expression(); + this.match(PostgreSqlParser.KW_ARRAY); this.state = 8079; + this.expression(); + this.state = 8080; this.loop_body(); } } @@ -51481,7 +51489,7 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8081; + this.state = 8082; _la = this.tokenStream.LA(1); if(!(_la === 167 || _la === 507)) { this.errorHandler.recoverInline(this); @@ -51490,29 +51498,29 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 8083; + this.state = 8084; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 53 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 18350039) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 8082; + this.state = 8083; this.any_identifier(); } } - this.state = 8087; + this.state = 8088; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 102) { { - this.state = 8085; - this.match(PostgreSqlParser.KW_WHEN); this.state = 8086; + this.match(PostgreSqlParser.KW_WHEN); + this.state = 8087; this.sql_expression(); } } - this.state = 8089; + this.state = 8090; this.match(PostgreSqlParser.SEMI); } } @@ -51536,35 +51544,35 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8091; + this.state = 8092; this.match(PostgreSqlParser.KW_RETURN); - this.state = 8106; + this.state = 8107; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1113, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1114, this.context) ) { case 1: { - this.state = 8092; - this.match(PostgreSqlParser.KW_NEXT); this.state = 8093; + this.match(PostgreSqlParser.KW_NEXT); + this.state = 8094; this.sql_expression(); } break; case 2: { - this.state = 8094; + this.state = 8095; this.match(PostgreSqlParser.KW_QUERY); - this.state = 8101; + this.state = 8102; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_EXECUTE: { - this.state = 8095; - this.match(PostgreSqlParser.KW_EXECUTE); this.state = 8096; - this.expression(); + this.match(PostgreSqlParser.KW_EXECUTE); this.state = 8097; - this.match(PostgreSqlParser.KW_USING); + this.expression(); this.state = 8098; + this.match(PostgreSqlParser.KW_USING); + this.state = 8099; this.expr_list(); } break; @@ -51574,7 +51582,7 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_WITH: case PostgreSqlParser.KW_VALUES: { - this.state = 8100; + this.state = 8101; this.selectstmt(); } break; @@ -51585,12 +51593,12 @@ export class PostgreSqlParser extends SQLParserBase { break; case 3: { - this.state = 8104; + this.state = 8105; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1112, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1113, this.context) ) { case 1: { - this.state = 8103; + this.state = 8104; this.sql_expression(); } break; @@ -51598,7 +51606,7 @@ export class PostgreSqlParser extends SQLParserBase { } break; } - this.state = 8108; + this.state = 8109; this.match(PostgreSqlParser.SEMI); } } @@ -51623,19 +51631,19 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8110; + this.state = 8111; this.match(PostgreSqlParser.KW_RAISE); - this.state = 8140; + this.state = 8141; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1120, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1121, this.context) ) { case 1: { - this.state = 8112; + this.state = 8113; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1114, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1115, this.context) ) { case 1: { - this.state = 8111; + this.state = 8112; _la = this.tokenStream.LA(1); if(!(((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & 63) !== 0))) { this.errorHandler.recoverInline(this); @@ -51647,21 +51655,21 @@ export class PostgreSqlParser extends SQLParserBase { } break; } - this.state = 8126; + this.state = 8127; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1117, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1118, this.context) ) { case 1: { - this.state = 8114; + this.state = 8115; this.identifier(); } break; case 2: { { - this.state = 8115; - this.match(PostgreSqlParser.KW_SQLSTATE); this.state = 8116; + this.match(PostgreSqlParser.KW_SQLSTATE); + this.state = 8117; this.sconst(); } } @@ -51669,26 +51677,26 @@ export class PostgreSqlParser extends SQLParserBase { case 3: { { - this.state = 8117; + this.state = 8118; this.sconst(); - this.state = 8124; + this.state = 8125; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 6) { { - this.state = 8120; + this.state = 8121; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 8118; - this.match(PostgreSqlParser.COMMA); this.state = 8119; + this.match(PostgreSqlParser.COMMA); + this.state = 8120; this.expression(); } } - this.state = 8122; + this.state = 8123; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 6); @@ -51699,29 +51707,29 @@ export class PostgreSqlParser extends SQLParserBase { } break; } - this.state = 8137; + this.state = 8138; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 8128; + this.state = 8129; this.match(PostgreSqlParser.KW_USING); { - this.state = 8129; + this.state = 8130; this.opt_raise_using_elem(); - this.state = 8134; + this.state = 8135; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 8130; - this.match(PostgreSqlParser.COMMA); this.state = 8131; + this.match(PostgreSqlParser.COMMA); + this.state = 8132; this.opt_raise_using_elem(); } } - this.state = 8136; + this.state = 8137; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -51729,7 +51737,7 @@ export class PostgreSqlParser extends SQLParserBase { } } - this.state = 8139; + this.state = 8140; this.match(PostgreSqlParser.SEMI); } break; @@ -51756,11 +51764,11 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8142; - this.identifier(); this.state = 8143; - this.match(PostgreSqlParser.EQUAL); + this.identifier(); this.state = 8144; + this.match(PostgreSqlParser.EQUAL); + this.state = 8145; this.expression(); } } @@ -51785,23 +51793,23 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8146; - this.match(PostgreSqlParser.KW_ASSERT); this.state = 8147; + this.match(PostgreSqlParser.KW_ASSERT); + this.state = 8148; this.sql_expression(); - this.state = 8150; + this.state = 8151; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 6) { { - this.state = 8148; - this.match(PostgreSqlParser.COMMA); this.state = 8149; + this.match(PostgreSqlParser.COMMA); + this.state = 8150; this.sql_expression(); } } - this.state = 8152; + this.state = 8153; this.match(PostgreSqlParser.SEMI); } } @@ -51827,39 +51835,39 @@ export class PostgreSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 8154; + this.state = 8155; this.match(PostgreSqlParser.KW_LOOP); - this.state = 8158; + this.state = 8159; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1122, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1123, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 8155; + this.state = 8156; this.proc_stmt(); } } } - this.state = 8160; + this.state = 8161; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1122, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1123, this.context); } - this.state = 8161; - this.match(PostgreSqlParser.KW_END); this.state = 8162; + this.match(PostgreSqlParser.KW_END); + this.state = 8163; this.match(PostgreSqlParser.KW_LOOP); - this.state = 8164; + this.state = 8165; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 53 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 18350039) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 8163; + this.state = 8164; this.any_identifier(); } } - this.state = 8166; + this.state = 8167; this.match(PostgreSqlParser.SEMI); } } @@ -51884,19 +51892,19 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8168; + this.state = 8169; this.stmt(); - this.state = 8170; + this.state = 8171; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 71) { { - this.state = 8169; + this.state = 8170; this.opt_execute_into(); } } - this.state = 8172; + this.state = 8173; this.match(PostgreSqlParser.SEMI); } } @@ -51921,33 +51929,33 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8174; - this.match(PostgreSqlParser.KW_EXECUTE); this.state = 8175; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 8176; this.expression(); - this.state = 8191; + this.state = 8192; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1129, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1130, this.context) ) { case 1: { - this.state = 8177; + this.state = 8178; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 71) { { - this.state = 8176; + this.state = 8177; this.opt_execute_into(); } } - this.state = 8181; + this.state = 8182; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 8179; - this.match(PostgreSqlParser.KW_USING); this.state = 8180; + this.match(PostgreSqlParser.KW_USING); + this.state = 8181; this.expr_list(); } } @@ -51956,24 +51964,24 @@ export class PostgreSqlParser extends SQLParserBase { break; case 2: { - this.state = 8185; + this.state = 8186; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 8183; - this.match(PostgreSqlParser.KW_USING); this.state = 8184; + this.match(PostgreSqlParser.KW_USING); + this.state = 8185; this.expr_list(); } } - this.state = 8188; + this.state = 8189; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 71) { { - this.state = 8187; + this.state = 8188; this.opt_execute_into(); } } @@ -51986,7 +51994,7 @@ export class PostgreSqlParser extends SQLParserBase { } break; } - this.state = 8193; + this.state = 8194; this.match(PostgreSqlParser.SEMI); } } @@ -52010,19 +52018,19 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8195; + this.state = 8196; this.match(PostgreSqlParser.KW_INTO); - this.state = 8197; + this.state = 8198; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1130, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1131, this.context) ) { case 1: { - this.state = 8196; + this.state = 8197; this.match(PostgreSqlParser.KW_STRICT); } break; } - this.state = 8199; + this.state = 8200; this.expr_list(); } } @@ -52047,38 +52055,38 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8201; + this.state = 8202; this.match(PostgreSqlParser.KW_OPEN); - this.state = 8233; + this.state = 8234; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1137, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1138, this.context) ) { case 1: { - this.state = 8202; + this.state = 8203; this.cursor_variable(); - this.state = 8207; + this.state = 8208; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 269 || _la === 324) { { - this.state = 8204; + this.state = 8205; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 269) { { - this.state = 8203; + this.state = 8204; this.match(PostgreSqlParser.KW_NO); } } - this.state = 8206; + this.state = 8207; this.match(PostgreSqlParser.KW_SCROLL); } } - this.state = 8209; + this.state = 8210; this.match(PostgreSqlParser.KW_FOR); - this.state = 8217; + this.state = 8218; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.OPEN_PAREN: @@ -52087,24 +52095,24 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_WITH: case PostgreSqlParser.KW_VALUES: { - this.state = 8210; + this.state = 8211; this.selectstmt(); } break; case PostgreSqlParser.KW_EXECUTE: { - this.state = 8211; - this.match(PostgreSqlParser.KW_EXECUTE); this.state = 8212; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 8213; this.sql_expression(); - this.state = 8215; + this.state = 8216; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 8213; - this.match(PostgreSqlParser.KW_USING); this.state = 8214; + this.match(PostgreSqlParser.KW_USING); + this.state = 8215; this.expr_list(); } } @@ -52118,36 +52126,36 @@ export class PostgreSqlParser extends SQLParserBase { break; case 2: { - this.state = 8219; + this.state = 8220; this.colid(); - this.state = 8231; + this.state = 8232; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 8220; + this.state = 8221; this.match(PostgreSqlParser.OPEN_PAREN); { - this.state = 8221; + this.state = 8222; this.opt_open_bound_list_item(); - this.state = 8226; + this.state = 8227; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 8222; - this.match(PostgreSqlParser.COMMA); this.state = 8223; + this.match(PostgreSqlParser.COMMA); + this.state = 8224; this.opt_open_bound_list_item(); } } - this.state = 8228; + this.state = 8229; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } - this.state = 8229; + this.state = 8230; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -52155,7 +52163,7 @@ export class PostgreSqlParser extends SQLParserBase { } break; } - this.state = 8235; + this.state = 8236; this.match(PostgreSqlParser.SEMI); } } @@ -52179,19 +52187,19 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8240; + this.state = 8241; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1138, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1139, this.context) ) { case 1: { - this.state = 8237; - this.colid(); this.state = 8238; + this.colid(); + this.state = 8239; this.match(PostgreSqlParser.COLON_EQUALS); } break; } - this.state = 8242; + this.state = 8243; this.expression(); } } @@ -52216,35 +52224,35 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8244; + this.state = 8245; this.match(PostgreSqlParser.KW_FETCH); - this.state = 8246; + this.state = 8247; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1139, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1140, this.context) ) { case 1: { - this.state = 8245; + this.state = 8246; localContext._direction = this.opt_fetch_direction(); } break; } - this.state = 8249; + this.state = 8250; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64 || _la === 68) { { - this.state = 8248; + this.state = 8249; this.from_in(); } } - this.state = 8251; - this.cursor_variable(); this.state = 8252; - this.match(PostgreSqlParser.KW_INTO); + this.cursor_variable(); this.state = 8253; - this.expr_list(); + this.match(PostgreSqlParser.KW_INTO); this.state = 8254; + this.expr_list(); + this.state = 8255; this.match(PostgreSqlParser.SEMI); } } @@ -52267,46 +52275,46 @@ export class PostgreSqlParser extends SQLParserBase { this.enterRule(localContext, 896, PostgreSqlParser.RULE_opt_fetch_direction); let _la: number; try { - this.state = 8270; + this.state = 8271; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1143, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1144, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8256; + this.state = 8257; this.match(PostgreSqlParser.KW_NEXT); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8257; + this.state = 8258; this.match(PostgreSqlParser.KW_PRIOR); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 8258; + this.state = 8259; this.match(PostgreSqlParser.KW_FIRST); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 8259; + this.state = 8260; this.match(PostgreSqlParser.KW_LAST); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 8261; + this.state = 8262; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1141, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1142, this.context) ) { case 1: { - this.state = 8260; + this.state = 8261; _la = this.tokenStream.LA(1); if(!(_la === 130 || _la === 307)) { this.errorHandler.recoverInline(this); @@ -52318,21 +52326,21 @@ export class PostgreSqlParser extends SQLParserBase { } break; } - this.state = 8263; + this.state = 8264; this.expression(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 8264; + this.state = 8265; this.match(PostgreSqlParser.KW_ALL); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 8265; + this.state = 8266; _la = this.tokenStream.LA(1); if(!(_la === 144 || _la === 210)) { this.errorHandler.recoverInline(this); @@ -52341,18 +52349,18 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 8268; + this.state = 8269; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1142, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1143, this.context) ) { case 1: { - this.state = 8266; + this.state = 8267; this.expression(); } break; case 2: { - this.state = 8267; + this.state = 8268; this.match(PostgreSqlParser.KW_ALL); } break; @@ -52381,21 +52389,21 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8272; + this.state = 8273; this.match(PostgreSqlParser.KW_MOVE); - this.state = 8274; + this.state = 8275; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1144, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1145, this.context) ) { case 1: { - this.state = 8273; + this.state = 8274; this.opt_fetch_direction(); } break; } - this.state = 8276; - this.cursor_variable(); this.state = 8277; + this.cursor_variable(); + this.state = 8278; this.match(PostgreSqlParser.SEMI); } } @@ -52420,81 +52428,81 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8280; + this.state = 8281; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 105) { { - this.state = 8279; + this.state = 8280; this.with_clause(); } } - this.state = 8282; - this.match(PostgreSqlParser.KW_MERGE); this.state = 8283; + this.match(PostgreSqlParser.KW_MERGE); + this.state = 8284; this.match(PostgreSqlParser.KW_INTO); - this.state = 8285; + this.state = 8286; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 81) { { - this.state = 8284; + this.state = 8285; this.match(PostgreSqlParser.KW_ONLY); } } - this.state = 8287; + this.state = 8288; this.table_name(); - this.state = 8289; + this.state = 8290; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 8288; + this.state = 8289; this.match(PostgreSqlParser.STAR); } } - this.state = 8295; + this.state = 8296; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 36 || _la === 53 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 18350039) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 8292; + this.state = 8293; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 36) { { - this.state = 8291; + this.state = 8292; this.match(PostgreSqlParser.KW_AS); } } - this.state = 8294; + this.state = 8295; this.colid(); } } - this.state = 8297; - this.match(PostgreSqlParser.KW_USING); this.state = 8298; - this.data_source(); + this.match(PostgreSqlParser.KW_USING); this.state = 8299; - this.match(PostgreSqlParser.KW_ON); + this.data_source(); this.state = 8300; + this.match(PostgreSqlParser.KW_ON); + this.state = 8301; this.expression(); - this.state = 8302; + this.state = 8303; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 8301; + this.state = 8302; this.merge_when_clause(); } } - this.state = 8304; + this.state = 8305; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 102); @@ -52521,29 +52529,29 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8317; + this.state = 8318; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1154, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1155, this.context) ) { case 1: { - this.state = 8307; + this.state = 8308; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 81) { { - this.state = 8306; + this.state = 8307; this.match(PostgreSqlParser.KW_ONLY); } } - this.state = 8309; + this.state = 8310; this.table_name(); - this.state = 8311; + this.state = 8312; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 8310; + this.state = 8311; this.match(PostgreSqlParser.STAR); } } @@ -52552,18 +52560,18 @@ export class PostgreSqlParser extends SQLParserBase { break; case 2: { - this.state = 8315; + this.state = 8316; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1153, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1154, this.context) ) { case 1: { - this.state = 8313; + this.state = 8314; this.select_no_parens(); } break; case 2: { - this.state = 8314; + this.state = 8315; this.values_clause(); } break; @@ -52571,22 +52579,22 @@ export class PostgreSqlParser extends SQLParserBase { } break; } - this.state = 8323; + this.state = 8324; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 36 || _la === 53 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 18350039) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 8320; + this.state = 8321; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 36) { { - this.state = 8319; + this.state = 8320; this.match(PostgreSqlParser.KW_AS); } } - this.state = 8322; + this.state = 8323; this.colid(); } } @@ -52612,50 +52620,50 @@ export class PostgreSqlParser extends SQLParserBase { this.enterRule(localContext, 904, PostgreSqlParser.RULE_merge_when_clause); let _la: number; try { - this.state = 8351; + this.state = 8352; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1161, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1162, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8325; - this.match(PostgreSqlParser.KW_WHEN); this.state = 8326; + this.match(PostgreSqlParser.KW_WHEN); + this.state = 8327; this.match(PostgreSqlParser.KW_MATCHED); - this.state = 8329; + this.state = 8330; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 33) { { - this.state = 8327; - this.match(PostgreSqlParser.KW_AND); this.state = 8328; + this.match(PostgreSqlParser.KW_AND); + this.state = 8329; this.expression(); } } - this.state = 8331; + this.state = 8332; this.match(PostgreSqlParser.KW_THEN); - this.state = 8336; + this.state = 8337; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_UPDATE: { - this.state = 8332; + this.state = 8333; this.merge_update(); } break; case PostgreSqlParser.KW_DELETE: { - this.state = 8333; + this.state = 8334; this.match(PostgreSqlParser.KW_DELETE); } break; case PostgreSqlParser.KW_DO: { - this.state = 8334; - this.match(PostgreSqlParser.KW_DO); this.state = 8335; + this.match(PostgreSqlParser.KW_DO); + this.state = 8336; this.match(PostgreSqlParser.KW_NOTHING); } break; @@ -52667,40 +52675,40 @@ export class PostgreSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8338; - this.match(PostgreSqlParser.KW_WHEN); this.state = 8339; - this.match(PostgreSqlParser.KW_NOT); + this.match(PostgreSqlParser.KW_WHEN); this.state = 8340; + this.match(PostgreSqlParser.KW_NOT); + this.state = 8341; this.match(PostgreSqlParser.KW_MATCHED); - this.state = 8343; + this.state = 8344; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 33) { { - this.state = 8341; - this.match(PostgreSqlParser.KW_AND); this.state = 8342; + this.match(PostgreSqlParser.KW_AND); + this.state = 8343; this.expression(); } } - this.state = 8345; + this.state = 8346; this.match(PostgreSqlParser.KW_THEN); - this.state = 8349; + this.state = 8350; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_INSERT: { - this.state = 8346; + this.state = 8347; this.merge_insert(); } break; case PostgreSqlParser.KW_DO: { - this.state = 8347; - this.match(PostgreSqlParser.KW_DO); this.state = 8348; + this.match(PostgreSqlParser.KW_DO); + this.state = 8349; this.match(PostgreSqlParser.KW_NOTHING); } break; @@ -52732,26 +52740,26 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8353; + this.state = 8354; this.match(PostgreSqlParser.KW_INSERT); - this.state = 8355; + this.state = 8356; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 8354; + this.state = 8355; this.opt_column_list(); } } - this.state = 8360; + this.state = 8361; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 463) { { - this.state = 8357; - this.match(PostgreSqlParser.KW_OVERRIDING); this.state = 8358; + this.match(PostgreSqlParser.KW_OVERRIDING); + this.state = 8359; _la = this.tokenStream.LA(1); if(!(_la === 99 || _la === 349)) { this.errorHandler.recoverInline(this); @@ -52760,12 +52768,12 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 8359; + this.state = 8360; this.match(PostgreSqlParser.KW_VALUE); } } - this.state = 8362; + this.state = 8363; this.default_values_or_values(); } } @@ -52791,57 +52799,57 @@ export class PostgreSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 8364; - this.match(PostgreSqlParser.KW_UPDATE); this.state = 8365; + this.match(PostgreSqlParser.KW_UPDATE); + this.state = 8366; this.match(PostgreSqlParser.KW_SET); - this.state = 8383; + this.state = 8384; this.errorHandler.sync(this); alternative = 1; do { switch (alternative) { case 1: { - this.state = 8383; + this.state = 8384; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1165, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1166, this.context) ) { case 1: { - this.state = 8366; - this.column_name(); this.state = 8367; - this.match(PostgreSqlParser.EQUAL); + this.column_name(); this.state = 8368; + this.match(PostgreSqlParser.EQUAL); + this.state = 8369; this.exprofdefault(); } break; case 2: { - this.state = 8370; - this.opt_column_list(); this.state = 8371; - this.match(PostgreSqlParser.EQUAL); + this.opt_column_list(); this.state = 8372; - this.match(PostgreSqlParser.OPEN_PAREN); + this.match(PostgreSqlParser.EQUAL); this.state = 8373; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 8374; this.exprofdefault(); - this.state = 8378; + this.state = 8379; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 8374; - this.match(PostgreSqlParser.COMMA); this.state = 8375; + this.match(PostgreSqlParser.COMMA); + this.state = 8376; this.exprofdefault(); } } - this.state = 8380; + this.state = 8381; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 8381; + this.state = 8382; this.match(PostgreSqlParser.CLOSE_PAREN); } break; @@ -52851,9 +52859,9 @@ export class PostgreSqlParser extends SQLParserBase { default: throw new antlr.NoViableAltException(this); } - this.state = 8385; + this.state = 8386; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1166, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1167, this.context); } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } } @@ -52876,44 +52884,44 @@ export class PostgreSqlParser extends SQLParserBase { this.enterRule(localContext, 910, PostgreSqlParser.RULE_default_values_or_values); let _la: number; try { - this.state = 8401; + this.state = 8402; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_VALUES: this.enterOuterAlt(localContext, 1); { - this.state = 8387; - this.match(PostgreSqlParser.KW_VALUES); this.state = 8388; - this.match(PostgreSqlParser.OPEN_PAREN); + this.match(PostgreSqlParser.KW_VALUES); this.state = 8389; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 8390; this.exprofdefault(); - this.state = 8394; + this.state = 8395; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 8390; - this.match(PostgreSqlParser.COMMA); this.state = 8391; + this.match(PostgreSqlParser.COMMA); + this.state = 8392; this.exprofdefault(); } } - this.state = 8396; + this.state = 8397; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 8397; + this.state = 8398; this.match(PostgreSqlParser.CLOSE_PAREN); } break; case PostgreSqlParser.KW_DEFAULT: this.enterOuterAlt(localContext, 2); { - this.state = 8399; - this.match(PostgreSqlParser.KW_DEFAULT); this.state = 8400; + this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 8401; this.match(PostgreSqlParser.KW_VALUES); } break; @@ -52939,20 +52947,20 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new ExprofdefaultContext(this.context, this.state); this.enterRule(localContext, 912, PostgreSqlParser.RULE_exprofdefault); try { - this.state = 8405; + this.state = 8406; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1169, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1170, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8403; + this.state = 8404; this.sortby(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8404; + this.state = 8405; this.match(PostgreSqlParser.KW_DEFAULT); } break; @@ -52978,11 +52986,11 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8407; - this.match(PostgreSqlParser.KW_CLOSE); this.state = 8408; - this.cursor_variable(); + this.match(PostgreSqlParser.KW_CLOSE); this.state = 8409; + this.cursor_variable(); + this.state = 8410; this.match(PostgreSqlParser.SEMI); } } @@ -53006,9 +53014,9 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8411; - this.match(PostgreSqlParser.KW_NULL); this.state = 8412; + this.match(PostgreSqlParser.KW_NULL); + this.state = 8413; this.match(PostgreSqlParser.SEMI); } } @@ -53033,7 +53041,7 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8414; + this.state = 8415; _la = this.tokenStream.LA(1); if(!(_la === 161 || _la === 319)) { this.errorHandler.recoverInline(this); @@ -53042,29 +53050,29 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 8420; + this.state = 8421; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 33) { { - this.state = 8415; + this.state = 8416; this.match(PostgreSqlParser.KW_AND); - this.state = 8417; + this.state = 8418; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 269) { { - this.state = 8416; + this.state = 8417; this.match(PostgreSqlParser.KW_NO); } } - this.state = 8419; + this.state = 8420; this.match(PostgreSqlParser.KW_CHAIN); } } - this.state = 8422; + this.state = 8423; this.match(PostgreSqlParser.SEMI); } } @@ -53086,30 +53094,30 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Stmt_setContext(this.context, this.state); this.enterRule(localContext, 920, PostgreSqlParser.RULE_stmt_set); try { - this.state = 8436; + this.state = 8437; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_SET: this.enterOuterAlt(localContext, 1); { - this.state = 8424; - this.match(PostgreSqlParser.KW_SET); this.state = 8425; - this.any_name(); + this.match(PostgreSqlParser.KW_SET); this.state = 8426; - this.match(PostgreSqlParser.KW_TO); + this.any_name(); this.state = 8427; - this.match(PostgreSqlParser.KW_DEFAULT); + this.match(PostgreSqlParser.KW_TO); this.state = 8428; + this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 8429; this.match(PostgreSqlParser.SEMI); } break; case PostgreSqlParser.KW_RESET: this.enterOuterAlt(localContext, 2); { - this.state = 8430; + this.state = 8431; this.match(PostgreSqlParser.KW_RESET); - this.state = 8433; + this.state = 8434; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_DEFAULT: @@ -53507,20 +53515,20 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 8431; + this.state = 8432; this.any_name(); } break; case PostgreSqlParser.KW_ALL: { - this.state = 8432; + this.state = 8433; this.match(PostgreSqlParser.KW_ALL); } break; default: throw new antlr.NoViableAltException(this); } - this.state = 8435; + this.state = 8436; this.match(PostgreSqlParser.SEMI); } break; @@ -53546,7 +53554,7 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Cursor_variableContext(this.context, this.state); this.enterRule(localContext, 922, PostgreSqlParser.RULE_cursor_variable); try { - this.state = 8440; + this.state = 8441; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_DEFAULT: @@ -53945,14 +53953,14 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.EscapeStringConstant: this.enterOuterAlt(localContext, 1); { - this.state = 8438; + this.state = 8439; this.colid(); } break; case PostgreSqlParser.PARAM: this.enterOuterAlt(localContext, 2); { - this.state = 8439; + this.state = 8440; this.match(PostgreSqlParser.PARAM); } break; @@ -53982,57 +53990,57 @@ export class PostgreSqlParser extends SQLParserBase { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 8442; + this.state = 8443; this.match(PostgreSqlParser.KW_EXCEPTION); - this.state = 8459; + this.state = 8460; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); do { { { - this.state = 8443; + this.state = 8444; this.match(PostgreSqlParser.KW_WHEN); { - this.state = 8444; + this.state = 8445; this.proc_condition(); - this.state = 8449; + this.state = 8450; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 82) { { { - this.state = 8445; - this.match(PostgreSqlParser.KW_OR); this.state = 8446; + this.match(PostgreSqlParser.KW_OR); + this.state = 8447; this.proc_condition(); } } - this.state = 8451; + this.state = 8452; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } - this.state = 8452; + this.state = 8453; this.match(PostgreSqlParser.KW_THEN); - this.state = 8456; + this.state = 8457; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1176, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1177, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 8453; + this.state = 8454; this.proc_stmt(); } } } - this.state = 8458; + this.state = 8459; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1176, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1177, this.context); } } } - this.state = 8461; + this.state = 8462; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } while (_la === 102); @@ -54056,22 +54064,22 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Proc_conditionContext(this.context, this.state); this.enterRule(localContext, 926, PostgreSqlParser.RULE_proc_condition); try { - this.state = 8466; + this.state = 8467; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1178, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1179, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8463; + this.state = 8464; this.any_identifier(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8464; - this.match(PostgreSqlParser.KW_SQLSTATE); this.state = 8465; + this.match(PostgreSqlParser.KW_SQLSTATE); + this.state = 8466; this.sconst(); } break; @@ -54095,20 +54103,20 @@ export class PostgreSqlParser extends SQLParserBase { let localContext = new Any_identifierContext(this.context, this.state); this.enterRule(localContext, 928, PostgreSqlParser.RULE_any_identifier); try { - this.state = 8470; + this.state = 8471; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1179, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1180, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8468; + this.state = 8469; this.colid(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8469; + this.state = 8470; this.unreserved_keyword(); } break; @@ -54135,74 +54143,74 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 8473; + this.state = 8474; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1180, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1181, this.context) ) { case 1: { - this.state = 8472; + this.state = 8473; this.target_list(); } break; } - this.state = 8476; + this.state = 8477; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1181, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1182, this.context) ) { case 1: { - this.state = 8475; + this.state = 8476; this.into_clause(); } break; } - this.state = 8479; + this.state = 8480; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64) { { - this.state = 8478; + this.state = 8479; this.from_clause(); } } - this.state = 8482; + this.state = 8483; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 103) { { - this.state = 8481; + this.state = 8482; this.where_clause(); } } - this.state = 8485; + this.state = 8486; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 66) { { - this.state = 8484; + this.state = 8485; this.group_clause(); } } - this.state = 8489; + this.state = 8490; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 67) { { - this.state = 8487; - this.match(PostgreSqlParser.KW_HAVING); this.state = 8488; + this.match(PostgreSqlParser.KW_HAVING); + this.state = 8489; this.expression(); } } - this.state = 8492; + this.state = 8493; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1186, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1187, this.context) ) { case 1: { - this.state = 8491; + this.state = 8492; this.window_clause(); } break; @@ -54281,7 +54289,7 @@ export class PostgreSqlParser extends SQLParserBase { } public static readonly _serializedATN: number[] = [ - 4,1,590,8495,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, + 4,1,590,8496,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, @@ -55025,159 +55033,159 @@ export class PostgreSqlParser extends SQLParserBase { 1,365,1,365,5,365,7424,8,365,10,365,12,365,7427,9,365,1,366,1,366, 1,366,1,366,1,366,3,366,7434,8,366,1,367,1,367,3,367,7438,8,367, 1,368,1,368,1,368,5,368,7443,8,368,10,368,12,368,7446,9,368,1,369, - 1,369,1,369,1,369,1,369,1,369,3,369,7454,8,369,1,370,1,370,1,370, - 1,370,1,370,5,370,7461,8,370,10,370,12,370,7464,9,370,3,370,7466, - 8,370,1,370,1,370,1,371,1,371,1,371,1,371,1,371,1,371,1,371,1,371, - 3,371,7478,8,371,1,372,1,372,1,373,1,373,1,373,1,373,1,373,3,373, - 7487,8,373,1,373,1,373,1,373,1,373,1,373,3,373,7494,8,373,1,373, - 1,373,1,373,1,373,1,373,1,373,1,373,3,373,7503,8,373,1,374,1,374, - 1,374,1,374,1,374,1,375,1,375,1,375,3,375,7513,8,375,1,375,1,375, - 1,375,3,375,7518,8,375,1,375,1,375,3,375,7522,8,375,3,375,7524,8, - 375,1,375,3,375,7527,8,375,1,376,4,376,7530,8,376,11,376,12,376, - 7531,1,377,5,377,7535,8,377,10,377,12,377,7538,9,377,1,378,1,378, - 1,378,5,378,7543,8,378,10,378,12,378,7546,9,378,1,379,1,379,1,379, - 1,379,1,379,3,379,7553,8,379,1,379,3,379,7556,8,379,1,380,1,380, - 1,380,5,380,7561,8,380,10,380,12,380,7564,9,380,1,381,1,381,1,381, - 5,381,7569,8,381,10,381,12,381,7572,9,381,1,382,1,382,1,382,5,382, - 7577,8,382,10,382,12,382,7580,9,382,1,383,1,383,1,383,5,383,7585, - 8,383,10,383,12,383,7588,9,383,1,384,1,384,1,385,1,385,1,386,1,386, - 1,387,1,387,1,388,1,388,1,389,1,389,1,390,1,390,3,390,7604,8,390, - 1,391,1,391,1,391,5,391,7609,8,391,10,391,12,391,7612,9,391,1,392, - 1,392,1,392,5,392,7617,8,392,10,392,12,392,7620,9,392,1,393,1,393, - 1,394,1,394,1,395,1,395,1,396,1,396,1,397,1,397,1,398,1,398,1,398, - 1,398,3,398,7636,8,398,1,399,1,399,1,399,1,399,3,399,7642,8,399, - 1,400,1,400,1,400,1,400,3,400,7648,8,400,1,401,1,401,1,402,1,402, - 1,402,1,402,3,402,7656,8,402,1,403,1,403,1,403,1,403,3,403,7662, - 8,403,1,404,1,404,1,404,3,404,7667,8,404,1,405,1,405,1,405,1,405, - 5,405,7673,8,405,10,405,12,405,7676,9,405,1,405,1,405,3,405,7680, - 8,405,1,406,3,406,7683,8,406,1,406,1,406,1,407,1,407,1,407,1,407, - 1,407,3,407,7692,8,407,1,408,1,408,1,408,5,408,7697,8,408,10,408, - 12,408,7700,9,408,1,409,1,409,3,409,7704,8,409,1,410,1,410,3,410, - 7708,8,410,1,411,1,411,1,411,3,411,7713,8,411,1,412,1,412,1,412, - 1,412,3,412,7719,8,412,1,413,1,413,1,413,3,413,7724,8,413,1,413, - 1,413,1,413,1,413,1,413,1,413,3,413,7732,8,413,1,414,1,414,1,415, - 1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, + 1,369,1,369,1,369,1,369,3,369,7453,8,369,3,369,7455,8,369,1,370, + 1,370,1,370,1,370,1,370,5,370,7462,8,370,10,370,12,370,7465,9,370, + 3,370,7467,8,370,1,370,1,370,1,371,1,371,1,371,1,371,1,371,1,371, + 1,371,1,371,3,371,7479,8,371,1,372,1,372,1,373,1,373,1,373,1,373, + 1,373,3,373,7488,8,373,1,373,1,373,1,373,1,373,1,373,3,373,7495, + 8,373,1,373,1,373,1,373,1,373,1,373,1,373,1,373,3,373,7504,8,373, + 1,374,1,374,1,374,1,374,1,374,1,375,1,375,1,375,3,375,7514,8,375, + 1,375,1,375,1,375,3,375,7519,8,375,1,375,1,375,3,375,7523,8,375, + 3,375,7525,8,375,1,375,3,375,7528,8,375,1,376,4,376,7531,8,376,11, + 376,12,376,7532,1,377,5,377,7536,8,377,10,377,12,377,7539,9,377, + 1,378,1,378,1,378,5,378,7544,8,378,10,378,12,378,7547,9,378,1,379, + 1,379,1,379,1,379,1,379,3,379,7554,8,379,1,379,3,379,7557,8,379, + 1,380,1,380,1,380,5,380,7562,8,380,10,380,12,380,7565,9,380,1,381, + 1,381,1,381,5,381,7570,8,381,10,381,12,381,7573,9,381,1,382,1,382, + 1,382,5,382,7578,8,382,10,382,12,382,7581,9,382,1,383,1,383,1,383, + 5,383,7586,8,383,10,383,12,383,7589,9,383,1,384,1,384,1,385,1,385, + 1,386,1,386,1,387,1,387,1,388,1,388,1,389,1,389,1,390,1,390,3,390, + 7605,8,390,1,391,1,391,1,391,5,391,7610,8,391,10,391,12,391,7613, + 9,391,1,392,1,392,1,392,5,392,7618,8,392,10,392,12,392,7621,9,392, + 1,393,1,393,1,394,1,394,1,395,1,395,1,396,1,396,1,397,1,397,1,398, + 1,398,1,398,1,398,3,398,7637,8,398,1,399,1,399,1,399,1,399,3,399, + 7643,8,399,1,400,1,400,1,400,1,400,3,400,7649,8,400,1,401,1,401, + 1,402,1,402,1,402,1,402,3,402,7657,8,402,1,403,1,403,1,403,1,403, + 3,403,7663,8,403,1,404,1,404,1,404,3,404,7668,8,404,1,405,1,405, + 1,405,1,405,5,405,7674,8,405,10,405,12,405,7677,9,405,1,405,1,405, + 3,405,7681,8,405,1,406,3,406,7684,8,406,1,406,1,406,1,407,1,407, + 1,407,1,407,1,407,3,407,7693,8,407,1,408,1,408,1,408,5,408,7698, + 8,408,10,408,12,408,7701,9,408,1,409,1,409,3,409,7705,8,409,1,410, + 1,410,3,410,7709,8,410,1,411,1,411,1,411,3,411,7714,8,411,1,412, + 1,412,1,412,1,412,3,412,7720,8,412,1,413,1,413,1,413,3,413,7725, + 8,413,1,413,1,413,1,413,1,413,1,413,1,413,3,413,7733,8,413,1,414, + 1,414,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, 1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, 1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, 1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, - 1,415,1,415,1,415,1,415,1,415,1,415,3,415,7787,8,415,1,416,1,416, - 1,417,1,417,1,418,3,418,7794,8,418,1,418,1,418,1,418,1,418,4,418, - 7800,8,418,11,418,12,418,7801,3,418,7804,8,418,3,418,7806,8,418, - 1,418,1,418,5,418,7810,8,418,10,418,12,418,7813,9,418,1,418,3,418, - 7816,8,418,1,418,1,418,3,418,7820,8,418,1,419,1,419,1,419,1,419, - 1,420,1,420,1,420,1,420,1,420,3,420,7831,8,420,1,420,3,420,7834, - 8,420,1,420,1,420,3,420,7838,8,420,1,420,1,420,3,420,7842,8,420, - 1,420,1,420,3,420,7846,8,420,1,420,3,420,7849,8,420,1,420,3,420, - 7852,8,420,1,420,3,420,7855,8,420,1,420,1,420,1,420,1,420,1,420, - 5,420,7862,8,420,10,420,12,420,7865,9,420,1,420,1,420,3,420,7869, - 8,420,1,420,1,420,3,420,7873,8,420,1,420,1,420,1,421,1,421,1,421, - 1,422,1,422,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423, + 1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,3,415,7788,8,415, + 1,416,1,416,1,417,1,417,1,418,3,418,7795,8,418,1,418,1,418,1,418, + 1,418,4,418,7801,8,418,11,418,12,418,7802,3,418,7805,8,418,3,418, + 7807,8,418,1,418,1,418,5,418,7811,8,418,10,418,12,418,7814,9,418, + 1,418,3,418,7817,8,418,1,418,1,418,3,418,7821,8,418,1,419,1,419, + 1,419,1,419,1,420,1,420,1,420,1,420,1,420,3,420,7832,8,420,1,420, + 3,420,7835,8,420,1,420,1,420,3,420,7839,8,420,1,420,1,420,3,420, + 7843,8,420,1,420,1,420,3,420,7847,8,420,1,420,3,420,7850,8,420,1, + 420,3,420,7853,8,420,1,420,3,420,7856,8,420,1,420,1,420,1,420,1, + 420,1,420,5,420,7863,8,420,10,420,12,420,7866,9,420,1,420,1,420, + 3,420,7870,8,420,1,420,1,420,3,420,7874,8,420,1,420,1,420,1,421, + 1,421,1,421,1,422,1,422,1,423,1,423,1,423,1,423,1,423,1,423,1,423, 1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423, - 1,423,1,423,1,423,1,423,3,423,7906,8,423,1,424,1,424,1,424,1,424, - 1,425,1,425,1,425,1,425,3,425,7916,8,425,1,425,1,425,3,425,7920, - 8,425,1,425,1,425,1,425,1,425,3,425,7926,8,425,1,425,1,425,1,425, - 3,425,7931,8,425,1,426,1,426,1,426,1,426,1,426,1,427,1,427,3,427, - 7940,8,427,1,427,1,427,1,427,1,427,5,427,7946,8,427,10,427,12,427, - 7949,9,427,1,427,1,427,1,428,1,428,1,428,1,428,1,429,1,429,3,429, - 7959,8,429,1,429,1,429,1,429,1,429,5,429,7965,8,429,10,429,12,429, - 7968,9,429,1,430,1,430,1,430,1,430,5,430,7974,8,430,10,430,12,430, - 7977,9,430,1,430,1,430,1,430,1,430,5,430,7983,8,430,10,430,12,430, - 7986,9,430,5,430,7988,8,430,10,430,12,430,7991,9,430,1,430,3,430, - 7994,8,430,1,430,1,430,1,430,1,430,1,431,1,431,5,431,8002,8,431, - 10,431,12,431,8005,9,431,1,432,1,432,3,432,8009,8,432,1,432,1,432, - 1,432,1,432,5,432,8015,8,432,10,432,12,432,8018,9,432,4,432,8020, - 8,432,11,432,12,432,8021,1,432,3,432,8025,8,432,1,432,1,432,1,432, - 1,432,1,433,3,433,8032,8,433,1,433,1,433,1,433,1,433,3,433,8038, - 8,433,1,433,1,433,1,434,1,434,1,434,1,434,3,434,8046,8,434,1,434, - 1,434,1,434,1,434,1,434,1,434,3,434,8054,8,434,1,434,3,434,8057, - 8,434,1,434,1,434,1,434,1,434,1,434,3,434,8064,8,434,3,434,8066, - 8,434,1,435,3,435,8069,8,435,1,435,1,435,1,435,1,435,3,435,8075, - 8,435,1,435,1,435,1,435,1,435,1,435,1,436,1,436,3,436,8084,8,436, - 1,436,1,436,3,436,8088,8,436,1,436,1,436,1,437,1,437,1,437,1,437, - 1,437,1,437,1,437,1,437,1,437,1,437,3,437,8102,8,437,1,437,3,437, - 8105,8,437,3,437,8107,8,437,1,437,1,437,1,438,1,438,3,438,8113,8, - 438,1,438,1,438,1,438,1,438,1,438,1,438,4,438,8121,8,438,11,438, - 12,438,8122,3,438,8125,8,438,3,438,8127,8,438,1,438,1,438,1,438, - 1,438,5,438,8133,8,438,10,438,12,438,8136,9,438,3,438,8138,8,438, - 1,438,3,438,8141,8,438,1,439,1,439,1,439,1,439,1,440,1,440,1,440, - 1,440,3,440,8151,8,440,1,440,1,440,1,441,1,441,5,441,8157,8,441, - 10,441,12,441,8160,9,441,1,441,1,441,1,441,3,441,8165,8,441,1,441, - 1,441,1,442,1,442,3,442,8171,8,442,1,442,1,442,1,443,1,443,1,443, - 3,443,8178,8,443,1,443,1,443,3,443,8182,8,443,1,443,1,443,3,443, - 8186,8,443,1,443,3,443,8189,8,443,1,443,3,443,8192,8,443,1,443,1, - 443,1,444,1,444,3,444,8198,8,444,1,444,1,444,1,445,1,445,1,445,3, - 445,8205,8,445,1,445,3,445,8208,8,445,1,445,1,445,1,445,1,445,1, - 445,1,445,3,445,8216,8,445,3,445,8218,8,445,1,445,1,445,1,445,1, - 445,1,445,5,445,8225,8,445,10,445,12,445,8228,9,445,1,445,1,445, - 3,445,8232,8,445,3,445,8234,8,445,1,445,1,445,1,446,1,446,1,446, - 3,446,8241,8,446,1,446,1,446,1,447,1,447,3,447,8247,8,447,1,447, - 3,447,8250,8,447,1,447,1,447,1,447,1,447,1,447,1,448,1,448,1,448, - 1,448,1,448,3,448,8262,8,448,1,448,1,448,1,448,1,448,1,448,3,448, - 8269,8,448,3,448,8271,8,448,1,449,1,449,3,449,8275,8,449,1,449,1, - 449,1,449,1,450,3,450,8281,8,450,1,450,1,450,1,450,3,450,8286,8, - 450,1,450,1,450,3,450,8290,8,450,1,450,3,450,8293,8,450,1,450,3, - 450,8296,8,450,1,450,1,450,1,450,1,450,1,450,4,450,8303,8,450,11, - 450,12,450,8304,1,451,3,451,8308,8,451,1,451,1,451,3,451,8312,8, - 451,1,451,1,451,3,451,8316,8,451,3,451,8318,8,451,1,451,3,451,8321, - 8,451,1,451,3,451,8324,8,451,1,452,1,452,1,452,1,452,3,452,8330, - 8,452,1,452,1,452,1,452,1,452,1,452,3,452,8337,8,452,1,452,1,452, - 1,452,1,452,1,452,3,452,8344,8,452,1,452,1,452,1,452,1,452,3,452, - 8350,8,452,3,452,8352,8,452,1,453,1,453,3,453,8356,8,453,1,453,1, - 453,1,453,3,453,8361,8,453,1,453,1,453,1,454,1,454,1,454,1,454,1, - 454,1,454,1,454,1,454,1,454,1,454,1,454,1,454,5,454,8377,8,454,10, - 454,12,454,8380,9,454,1,454,1,454,4,454,8384,8,454,11,454,12,454, - 8385,1,455,1,455,1,455,1,455,1,455,5,455,8393,8,455,10,455,12,455, - 8396,9,455,1,455,1,455,1,455,1,455,3,455,8402,8,455,1,456,1,456, - 3,456,8406,8,456,1,457,1,457,1,457,1,457,1,458,1,458,1,458,1,459, - 1,459,1,459,3,459,8418,8,459,1,459,3,459,8421,8,459,1,459,1,459, - 1,460,1,460,1,460,1,460,1,460,1,460,1,460,1,460,1,460,3,460,8434, - 8,460,1,460,3,460,8437,8,460,1,461,1,461,3,461,8441,8,461,1,462, - 1,462,1,462,1,462,1,462,5,462,8448,8,462,10,462,12,462,8451,9,462, - 1,462,1,462,5,462,8455,8,462,10,462,12,462,8458,9,462,4,462,8460, - 8,462,11,462,12,462,8461,1,463,1,463,1,463,3,463,8467,8,463,1,464, - 1,464,3,464,8471,8,464,1,465,3,465,8474,8,465,1,465,3,465,8477,8, - 465,1,465,3,465,8480,8,465,1,465,3,465,8483,8,465,1,465,3,465,8486, - 8,465,1,465,1,465,3,465,8490,8,465,1,465,3,465,8493,8,465,1,465, - 0,3,676,680,682,466,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, - 436,438,440,442,444,446,448,450,452,454,456,458,460,462,464,466, - 468,470,472,474,476,478,480,482,484,486,488,490,492,494,496,498, - 500,502,504,506,508,510,512,514,516,518,520,522,524,526,528,530, - 532,534,536,538,540,542,544,546,548,550,552,554,556,558,560,562, - 564,566,568,570,572,574,576,578,580,582,584,586,588,590,592,594, - 596,598,600,602,604,606,608,610,612,614,616,618,620,622,624,626, - 628,630,632,634,636,638,640,642,644,646,648,650,652,654,656,658, - 660,662,664,666,668,670,672,674,676,678,680,682,684,686,688,690, - 692,694,696,698,700,702,704,706,708,710,712,714,716,718,720,722, - 724,726,728,730,732,734,736,738,740,742,744,746,748,750,752,754, - 756,758,760,762,764,766,768,770,772,774,776,778,780,782,784,786, - 788,790,792,794,796,798,800,802,804,806,808,810,812,814,816,818, - 820,822,824,826,828,830,832,834,836,838,840,842,844,846,848,850, - 852,854,856,858,860,862,864,866,868,870,872,874,876,878,880,882, - 884,886,888,890,892,894,896,898,900,902,904,906,908,910,912,914, - 916,918,920,922,924,926,928,930,0,118,2,0,195,195,364,364,2,0,66, - 66,318,318,2,0,99,99,318,318,2,0,134,134,318,318,1,0,529,531,2,0, - 10,10,94,94,2,0,133,133,191,191,2,0,254,254,332,332,2,0,162,162, - 363,363,2,0,180,180,221,221,5,0,30,30,288,288,329,329,352,352,354, - 354,2,0,109,109,532,532,2,0,158,158,277,277,2,0,367,367,439,439, - 2,0,139,139,312,312,2,0,191,191,333,333,2,0,313,313,333,333,2,0, - 150,150,315,315,2,0,64,64,94,94,4,0,78,78,183,183,197,197,298,298, - 2,0,213,213,254,254,2,0,352,352,354,354,2,0,200,200,224,224,9,0, - 30,30,160,160,165,165,179,179,219,219,227,227,342,342,345,345,438, - 438,3,0,113,113,284,284,336,336,2,0,53,53,78,78,2,0,105,105,379, - 379,2,0,260,260,262,262,3,0,173,173,260,260,262,262,1,0,12,13,2, - 0,64,64,375,375,2,0,156,156,206,206,2,0,189,189,360,360,2,0,215, + 1,423,1,423,1,423,1,423,1,423,1,423,3,423,7907,8,423,1,424,1,424, + 1,424,1,424,1,425,1,425,1,425,1,425,3,425,7917,8,425,1,425,1,425, + 3,425,7921,8,425,1,425,1,425,1,425,1,425,3,425,7927,8,425,1,425, + 1,425,1,425,3,425,7932,8,425,1,426,1,426,1,426,1,426,1,426,1,427, + 1,427,3,427,7941,8,427,1,427,1,427,1,427,1,427,5,427,7947,8,427, + 10,427,12,427,7950,9,427,1,427,1,427,1,428,1,428,1,428,1,428,1,429, + 1,429,3,429,7960,8,429,1,429,1,429,1,429,1,429,5,429,7966,8,429, + 10,429,12,429,7969,9,429,1,430,1,430,1,430,1,430,5,430,7975,8,430, + 10,430,12,430,7978,9,430,1,430,1,430,1,430,1,430,5,430,7984,8,430, + 10,430,12,430,7987,9,430,5,430,7989,8,430,10,430,12,430,7992,9,430, + 1,430,3,430,7995,8,430,1,430,1,430,1,430,1,430,1,431,1,431,5,431, + 8003,8,431,10,431,12,431,8006,9,431,1,432,1,432,3,432,8010,8,432, + 1,432,1,432,1,432,1,432,5,432,8016,8,432,10,432,12,432,8019,9,432, + 4,432,8021,8,432,11,432,12,432,8022,1,432,3,432,8026,8,432,1,432, + 1,432,1,432,1,432,1,433,3,433,8033,8,433,1,433,1,433,1,433,1,433, + 3,433,8039,8,433,1,433,1,433,1,434,1,434,1,434,1,434,3,434,8047, + 8,434,1,434,1,434,1,434,1,434,1,434,1,434,3,434,8055,8,434,1,434, + 3,434,8058,8,434,1,434,1,434,1,434,1,434,1,434,3,434,8065,8,434, + 3,434,8067,8,434,1,435,3,435,8070,8,435,1,435,1,435,1,435,1,435, + 3,435,8076,8,435,1,435,1,435,1,435,1,435,1,435,1,436,1,436,3,436, + 8085,8,436,1,436,1,436,3,436,8089,8,436,1,436,1,436,1,437,1,437, + 1,437,1,437,1,437,1,437,1,437,1,437,1,437,1,437,3,437,8103,8,437, + 1,437,3,437,8106,8,437,3,437,8108,8,437,1,437,1,437,1,438,1,438, + 3,438,8114,8,438,1,438,1,438,1,438,1,438,1,438,1,438,4,438,8122, + 8,438,11,438,12,438,8123,3,438,8126,8,438,3,438,8128,8,438,1,438, + 1,438,1,438,1,438,5,438,8134,8,438,10,438,12,438,8137,9,438,3,438, + 8139,8,438,1,438,3,438,8142,8,438,1,439,1,439,1,439,1,439,1,440, + 1,440,1,440,1,440,3,440,8152,8,440,1,440,1,440,1,441,1,441,5,441, + 8158,8,441,10,441,12,441,8161,9,441,1,441,1,441,1,441,3,441,8166, + 8,441,1,441,1,441,1,442,1,442,3,442,8172,8,442,1,442,1,442,1,443, + 1,443,1,443,3,443,8179,8,443,1,443,1,443,3,443,8183,8,443,1,443, + 1,443,3,443,8187,8,443,1,443,3,443,8190,8,443,1,443,3,443,8193,8, + 443,1,443,1,443,1,444,1,444,3,444,8199,8,444,1,444,1,444,1,445,1, + 445,1,445,3,445,8206,8,445,1,445,3,445,8209,8,445,1,445,1,445,1, + 445,1,445,1,445,1,445,3,445,8217,8,445,3,445,8219,8,445,1,445,1, + 445,1,445,1,445,1,445,5,445,8226,8,445,10,445,12,445,8229,9,445, + 1,445,1,445,3,445,8233,8,445,3,445,8235,8,445,1,445,1,445,1,446, + 1,446,1,446,3,446,8242,8,446,1,446,1,446,1,447,1,447,3,447,8248, + 8,447,1,447,3,447,8251,8,447,1,447,1,447,1,447,1,447,1,447,1,448, + 1,448,1,448,1,448,1,448,3,448,8263,8,448,1,448,1,448,1,448,1,448, + 1,448,3,448,8270,8,448,3,448,8272,8,448,1,449,1,449,3,449,8276,8, + 449,1,449,1,449,1,449,1,450,3,450,8282,8,450,1,450,1,450,1,450,3, + 450,8287,8,450,1,450,1,450,3,450,8291,8,450,1,450,3,450,8294,8,450, + 1,450,3,450,8297,8,450,1,450,1,450,1,450,1,450,1,450,4,450,8304, + 8,450,11,450,12,450,8305,1,451,3,451,8309,8,451,1,451,1,451,3,451, + 8313,8,451,1,451,1,451,3,451,8317,8,451,3,451,8319,8,451,1,451,3, + 451,8322,8,451,1,451,3,451,8325,8,451,1,452,1,452,1,452,1,452,3, + 452,8331,8,452,1,452,1,452,1,452,1,452,1,452,3,452,8338,8,452,1, + 452,1,452,1,452,1,452,1,452,3,452,8345,8,452,1,452,1,452,1,452,1, + 452,3,452,8351,8,452,3,452,8353,8,452,1,453,1,453,3,453,8357,8,453, + 1,453,1,453,1,453,3,453,8362,8,453,1,453,1,453,1,454,1,454,1,454, + 1,454,1,454,1,454,1,454,1,454,1,454,1,454,1,454,1,454,5,454,8378, + 8,454,10,454,12,454,8381,9,454,1,454,1,454,4,454,8385,8,454,11,454, + 12,454,8386,1,455,1,455,1,455,1,455,1,455,5,455,8394,8,455,10,455, + 12,455,8397,9,455,1,455,1,455,1,455,1,455,3,455,8403,8,455,1,456, + 1,456,3,456,8407,8,456,1,457,1,457,1,457,1,457,1,458,1,458,1,458, + 1,459,1,459,1,459,3,459,8419,8,459,1,459,3,459,8422,8,459,1,459, + 1,459,1,460,1,460,1,460,1,460,1,460,1,460,1,460,1,460,1,460,3,460, + 8435,8,460,1,460,3,460,8438,8,460,1,461,1,461,3,461,8442,8,461,1, + 462,1,462,1,462,1,462,1,462,5,462,8449,8,462,10,462,12,462,8452, + 9,462,1,462,1,462,5,462,8456,8,462,10,462,12,462,8459,9,462,4,462, + 8461,8,462,11,462,12,462,8462,1,463,1,463,1,463,3,463,8468,8,463, + 1,464,1,464,3,464,8472,8,464,1,465,3,465,8475,8,465,1,465,3,465, + 8478,8,465,1,465,3,465,8481,8,465,1,465,3,465,8484,8,465,1,465,3, + 465,8487,8,465,1,465,1,465,3,465,8491,8,465,1,465,3,465,8494,8,465, + 1,465,0,3,676,680,682,466,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,436,438,440,442,444,446,448,450,452,454,456,458,460,462,464, + 466,468,470,472,474,476,478,480,482,484,486,488,490,492,494,496, + 498,500,502,504,506,508,510,512,514,516,518,520,522,524,526,528, + 530,532,534,536,538,540,542,544,546,548,550,552,554,556,558,560, + 562,564,566,568,570,572,574,576,578,580,582,584,586,588,590,592, + 594,596,598,600,602,604,606,608,610,612,614,616,618,620,622,624, + 626,628,630,632,634,636,638,640,642,644,646,648,650,652,654,656, + 658,660,662,664,666,668,670,672,674,676,678,680,682,684,686,688, + 690,692,694,696,698,700,702,704,706,708,710,712,714,716,718,720, + 722,724,726,728,730,732,734,736,738,740,742,744,746,748,750,752, + 754,756,758,760,762,764,766,768,770,772,774,776,778,780,782,784, + 786,788,790,792,794,796,798,800,802,804,806,808,810,812,814,816, + 818,820,822,824,826,828,830,832,834,836,838,840,842,844,846,848, + 850,852,854,856,858,860,862,864,866,868,870,872,874,876,878,880, + 882,884,886,888,890,892,894,896,898,900,902,904,906,908,910,912, + 914,916,918,920,922,924,926,928,930,0,118,2,0,195,195,364,364,2, + 0,66,66,318,318,2,0,99,99,318,318,2,0,134,134,318,318,1,0,529,531, + 2,0,10,10,94,94,2,0,133,133,191,191,2,0,254,254,332,332,2,0,162, + 162,363,363,2,0,180,180,221,221,5,0,30,30,288,288,329,329,352,352, + 354,354,2,0,109,109,532,532,2,0,158,158,277,277,2,0,367,367,439, + 439,2,0,139,139,312,312,2,0,191,191,333,333,2,0,313,313,333,333, + 2,0,150,150,315,315,2,0,64,64,94,94,4,0,78,78,183,183,197,197,298, + 298,2,0,213,213,254,254,2,0,352,352,354,354,2,0,200,200,224,224, + 9,0,30,30,160,160,165,165,179,179,219,219,227,227,342,342,345,345, + 438,438,3,0,113,113,284,284,336,336,2,0,53,53,78,78,2,0,105,105, + 379,379,2,0,260,260,262,262,3,0,173,173,260,260,262,262,1,0,12,13, + 2,0,64,64,375,375,2,0,156,156,206,206,2,0,189,189,360,360,2,0,215, 215,373,373,3,0,133,133,191,191,333,333,5,0,30,30,88,88,182,182, 241,241,369,369,2,0,9,9,94,94,2,0,92,92,226,226,1,0,448,449,2,0, 92,92,414,414,2,0,341,341,414,414,4,0,163,163,185,185,283,283,353, @@ -55209,7 +55217,7 @@ export class PostgreSqlParser extends SQLParserBase { 473,475,475,477,488,490,502,504,504,506,518,520,520,524,524,547, 548,3,0,106,123,125,128,472,472,4,0,30,52,54,70,72,105,454,454,2, 0,62,62,116,116,2,0,10,10,20,20,2,0,434,434,501,501,2,0,167,167, - 507,507,1,0,512,517,2,0,144,144,210,210,9929,0,935,1,0,0,0,2,940, + 507,507,1,0,512,517,2,0,144,144,210,210,9931,0,935,1,0,0,0,2,940, 1,0,0,0,4,1064,1,0,0,0,6,1066,1,0,0,0,8,1069,1,0,0,0,10,1119,1,0, 0,0,12,1129,1,0,0,0,14,1131,1,0,0,0,16,1143,1,0,0,0,18,1155,1,0, 0,0,20,1166,1,0,0,0,22,1200,1,0,0,0,24,1244,1,0,0,0,26,1246,1,0, @@ -55301,31 +55309,31 @@ export class PostgreSqlParser extends SQLParserBase { 1,0,0,0,708,7327,1,0,0,0,710,7344,1,0,0,0,712,7371,1,0,0,0,714,7380, 1,0,0,0,716,7382,1,0,0,0,718,7389,1,0,0,0,720,7393,1,0,0,0,722,7395, 1,0,0,0,724,7403,1,0,0,0,726,7411,1,0,0,0,728,7418,1,0,0,0,730,7420, - 1,0,0,0,732,7433,1,0,0,0,734,7437,1,0,0,0,736,7439,1,0,0,0,738,7453, - 1,0,0,0,740,7455,1,0,0,0,742,7477,1,0,0,0,744,7479,1,0,0,0,746,7502, - 1,0,0,0,748,7504,1,0,0,0,750,7526,1,0,0,0,752,7529,1,0,0,0,754,7536, - 1,0,0,0,756,7539,1,0,0,0,758,7555,1,0,0,0,760,7557,1,0,0,0,762,7565, - 1,0,0,0,764,7573,1,0,0,0,766,7581,1,0,0,0,768,7589,1,0,0,0,770,7591, - 1,0,0,0,772,7593,1,0,0,0,774,7595,1,0,0,0,776,7597,1,0,0,0,778,7599, - 1,0,0,0,780,7601,1,0,0,0,782,7605,1,0,0,0,784,7613,1,0,0,0,786,7621, - 1,0,0,0,788,7623,1,0,0,0,790,7625,1,0,0,0,792,7627,1,0,0,0,794,7629, - 1,0,0,0,796,7635,1,0,0,0,798,7641,1,0,0,0,800,7647,1,0,0,0,802,7649, - 1,0,0,0,804,7655,1,0,0,0,806,7661,1,0,0,0,808,7663,1,0,0,0,810,7679, - 1,0,0,0,812,7682,1,0,0,0,814,7691,1,0,0,0,816,7693,1,0,0,0,818,7703, - 1,0,0,0,820,7707,1,0,0,0,822,7712,1,0,0,0,824,7718,1,0,0,0,826,7731, - 1,0,0,0,828,7733,1,0,0,0,830,7786,1,0,0,0,832,7788,1,0,0,0,834,7790, - 1,0,0,0,836,7793,1,0,0,0,838,7821,1,0,0,0,840,7825,1,0,0,0,842,7876, - 1,0,0,0,844,7879,1,0,0,0,846,7905,1,0,0,0,848,7907,1,0,0,0,850,7930, - 1,0,0,0,852,7932,1,0,0,0,854,7937,1,0,0,0,856,7952,1,0,0,0,858,7958, - 1,0,0,0,860,7969,1,0,0,0,862,7999,1,0,0,0,864,8006,1,0,0,0,866,8031, - 1,0,0,0,868,8041,1,0,0,0,870,8068,1,0,0,0,872,8081,1,0,0,0,874,8091, - 1,0,0,0,876,8110,1,0,0,0,878,8142,1,0,0,0,880,8146,1,0,0,0,882,8154, - 1,0,0,0,884,8168,1,0,0,0,886,8174,1,0,0,0,888,8195,1,0,0,0,890,8201, - 1,0,0,0,892,8240,1,0,0,0,894,8244,1,0,0,0,896,8270,1,0,0,0,898,8272, - 1,0,0,0,900,8280,1,0,0,0,902,8317,1,0,0,0,904,8351,1,0,0,0,906,8353, - 1,0,0,0,908,8364,1,0,0,0,910,8401,1,0,0,0,912,8405,1,0,0,0,914,8407, - 1,0,0,0,916,8411,1,0,0,0,918,8414,1,0,0,0,920,8436,1,0,0,0,922,8440, - 1,0,0,0,924,8442,1,0,0,0,926,8466,1,0,0,0,928,8470,1,0,0,0,930,8473, + 1,0,0,0,732,7433,1,0,0,0,734,7437,1,0,0,0,736,7439,1,0,0,0,738,7454, + 1,0,0,0,740,7456,1,0,0,0,742,7478,1,0,0,0,744,7480,1,0,0,0,746,7503, + 1,0,0,0,748,7505,1,0,0,0,750,7527,1,0,0,0,752,7530,1,0,0,0,754,7537, + 1,0,0,0,756,7540,1,0,0,0,758,7556,1,0,0,0,760,7558,1,0,0,0,762,7566, + 1,0,0,0,764,7574,1,0,0,0,766,7582,1,0,0,0,768,7590,1,0,0,0,770,7592, + 1,0,0,0,772,7594,1,0,0,0,774,7596,1,0,0,0,776,7598,1,0,0,0,778,7600, + 1,0,0,0,780,7602,1,0,0,0,782,7606,1,0,0,0,784,7614,1,0,0,0,786,7622, + 1,0,0,0,788,7624,1,0,0,0,790,7626,1,0,0,0,792,7628,1,0,0,0,794,7630, + 1,0,0,0,796,7636,1,0,0,0,798,7642,1,0,0,0,800,7648,1,0,0,0,802,7650, + 1,0,0,0,804,7656,1,0,0,0,806,7662,1,0,0,0,808,7664,1,0,0,0,810,7680, + 1,0,0,0,812,7683,1,0,0,0,814,7692,1,0,0,0,816,7694,1,0,0,0,818,7704, + 1,0,0,0,820,7708,1,0,0,0,822,7713,1,0,0,0,824,7719,1,0,0,0,826,7732, + 1,0,0,0,828,7734,1,0,0,0,830,7787,1,0,0,0,832,7789,1,0,0,0,834,7791, + 1,0,0,0,836,7794,1,0,0,0,838,7822,1,0,0,0,840,7826,1,0,0,0,842,7877, + 1,0,0,0,844,7880,1,0,0,0,846,7906,1,0,0,0,848,7908,1,0,0,0,850,7931, + 1,0,0,0,852,7933,1,0,0,0,854,7938,1,0,0,0,856,7953,1,0,0,0,858,7959, + 1,0,0,0,860,7970,1,0,0,0,862,8000,1,0,0,0,864,8007,1,0,0,0,866,8032, + 1,0,0,0,868,8042,1,0,0,0,870,8069,1,0,0,0,872,8082,1,0,0,0,874,8092, + 1,0,0,0,876,8111,1,0,0,0,878,8143,1,0,0,0,880,8147,1,0,0,0,882,8155, + 1,0,0,0,884,8169,1,0,0,0,886,8175,1,0,0,0,888,8196,1,0,0,0,890,8202, + 1,0,0,0,892,8241,1,0,0,0,894,8245,1,0,0,0,896,8271,1,0,0,0,898,8273, + 1,0,0,0,900,8281,1,0,0,0,902,8318,1,0,0,0,904,8352,1,0,0,0,906,8354, + 1,0,0,0,908,8365,1,0,0,0,910,8402,1,0,0,0,912,8406,1,0,0,0,914,8408, + 1,0,0,0,916,8412,1,0,0,0,918,8415,1,0,0,0,920,8437,1,0,0,0,922,8441, + 1,0,0,0,924,8443,1,0,0,0,926,8467,1,0,0,0,928,8471,1,0,0,0,930,8474, 1,0,0,0,932,934,3,2,1,0,933,932,1,0,0,0,934,937,1,0,0,0,935,933, 1,0,0,0,935,936,1,0,0,0,936,938,1,0,0,0,937,935,1,0,0,0,938,939, 5,0,0,1,939,1,1,0,0,0,940,942,3,4,2,0,941,943,5,7,0,0,942,941,1, @@ -57699,483 +57707,484 @@ export class PostgreSqlParser extends SQLParserBase { 0,0,0,7437,7436,1,0,0,0,7438,735,1,0,0,0,7439,7444,3,738,369,0,7440, 7441,5,6,0,0,7441,7443,3,738,369,0,7442,7440,1,0,0,0,7443,7446,1, 0,0,0,7444,7442,1,0,0,0,7444,7445,1,0,0,0,7445,737,1,0,0,0,7446, - 7444,1,0,0,0,7447,7454,3,800,400,0,7448,7454,3,674,337,0,7449,7450, - 3,820,410,0,7450,7451,7,107,0,0,7451,7452,3,674,337,0,7452,7454, - 1,0,0,0,7453,7447,1,0,0,0,7453,7448,1,0,0,0,7453,7449,1,0,0,0,7454, - 739,1,0,0,0,7455,7465,5,4,0,0,7456,7466,3,730,365,0,7457,7462,3, - 740,370,0,7458,7459,5,6,0,0,7459,7461,3,740,370,0,7460,7458,1,0, - 0,0,7461,7464,1,0,0,0,7462,7460,1,0,0,0,7462,7463,1,0,0,0,7463,7466, - 1,0,0,0,7464,7462,1,0,0,0,7465,7456,1,0,0,0,7465,7457,1,0,0,0,7465, - 7466,1,0,0,0,7466,7467,1,0,0,0,7467,7468,5,5,0,0,7468,741,1,0,0, - 0,7469,7478,3,826,413,0,7470,7478,5,384,0,0,7471,7478,5,264,0,0, - 7472,7478,5,176,0,0,7473,7478,5,218,0,0,7474,7478,5,261,0,0,7475, - 7478,5,326,0,0,7476,7478,3,808,404,0,7477,7469,1,0,0,0,7477,7470, - 1,0,0,0,7477,7471,1,0,0,0,7477,7472,1,0,0,0,7477,7473,1,0,0,0,7477, - 7474,1,0,0,0,7477,7475,1,0,0,0,7477,7476,1,0,0,0,7478,743,1,0,0, - 0,7479,7480,7,108,0,0,7480,745,1,0,0,0,7481,7482,3,674,337,0,7482, - 7483,5,64,0,0,7483,7486,3,674,337,0,7484,7485,5,62,0,0,7485,7487, - 3,674,337,0,7486,7484,1,0,0,0,7486,7487,1,0,0,0,7487,7503,1,0,0, - 0,7488,7489,3,674,337,0,7489,7490,5,62,0,0,7490,7493,3,674,337,0, - 7491,7492,5,64,0,0,7492,7494,3,674,337,0,7493,7491,1,0,0,0,7493, - 7494,1,0,0,0,7494,7503,1,0,0,0,7495,7496,3,674,337,0,7496,7497,5, - 127,0,0,7497,7498,3,674,337,0,7498,7499,5,197,0,0,7499,7500,3,674, - 337,0,7500,7503,1,0,0,0,7501,7503,3,730,365,0,7502,7481,1,0,0,0, - 7502,7488,1,0,0,0,7502,7495,1,0,0,0,7502,7501,1,0,0,0,7503,747,1, - 0,0,0,7504,7505,5,102,0,0,7505,7506,3,674,337,0,7506,7507,5,93,0, - 0,7507,7508,3,674,337,0,7508,749,1,0,0,0,7509,7512,5,11,0,0,7510, - 7513,3,824,412,0,7511,7513,5,9,0,0,7512,7510,1,0,0,0,7512,7511,1, - 0,0,0,7513,7527,1,0,0,0,7514,7523,5,4,0,0,7515,7524,3,674,337,0, - 7516,7518,3,674,337,0,7517,7516,1,0,0,0,7517,7518,1,0,0,0,7518,7519, - 1,0,0,0,7519,7521,5,8,0,0,7520,7522,3,674,337,0,7521,7520,1,0,0, - 0,7521,7522,1,0,0,0,7522,7524,1,0,0,0,7523,7515,1,0,0,0,7523,7517, - 1,0,0,0,7524,7525,1,0,0,0,7525,7527,5,5,0,0,7526,7509,1,0,0,0,7526, - 7514,1,0,0,0,7527,751,1,0,0,0,7528,7530,3,750,375,0,7529,7528,1, - 0,0,0,7530,7531,1,0,0,0,7531,7529,1,0,0,0,7531,7532,1,0,0,0,7532, - 753,1,0,0,0,7533,7535,3,750,375,0,7534,7533,1,0,0,0,7535,7538,1, - 0,0,0,7536,7534,1,0,0,0,7536,7537,1,0,0,0,7537,755,1,0,0,0,7538, - 7536,1,0,0,0,7539,7544,3,758,379,0,7540,7541,5,6,0,0,7541,7543,3, - 758,379,0,7542,7540,1,0,0,0,7543,7546,1,0,0,0,7544,7542,1,0,0,0, - 7544,7545,1,0,0,0,7545,757,1,0,0,0,7546,7544,1,0,0,0,7547,7552,3, - 734,367,0,7548,7549,5,36,0,0,7549,7553,3,824,412,0,7550,7553,3,826, - 413,0,7551,7553,1,0,0,0,7552,7548,1,0,0,0,7552,7550,1,0,0,0,7552, - 7551,1,0,0,0,7553,7556,1,0,0,0,7554,7556,5,9,0,0,7555,7547,1,0,0, - 0,7555,7554,1,0,0,0,7556,759,1,0,0,0,7557,7562,3,780,390,0,7558, - 7559,5,6,0,0,7559,7561,3,780,390,0,7560,7558,1,0,0,0,7561,7564,1, - 0,0,0,7562,7560,1,0,0,0,7562,7563,1,0,0,0,7563,761,1,0,0,0,7564, - 7562,1,0,0,0,7565,7570,3,774,387,0,7566,7567,5,6,0,0,7567,7569,3, - 774,387,0,7568,7566,1,0,0,0,7569,7572,1,0,0,0,7570,7568,1,0,0,0, - 7570,7571,1,0,0,0,7571,763,1,0,0,0,7572,7570,1,0,0,0,7573,7578,3, - 790,395,0,7574,7575,5,6,0,0,7575,7577,3,790,395,0,7576,7574,1,0, - 0,0,7577,7580,1,0,0,0,7578,7576,1,0,0,0,7578,7579,1,0,0,0,7579,765, - 1,0,0,0,7580,7578,1,0,0,0,7581,7586,3,788,394,0,7582,7583,5,6,0, - 0,7583,7585,3,788,394,0,7584,7582,1,0,0,0,7585,7588,1,0,0,0,7586, - 7584,1,0,0,0,7586,7587,1,0,0,0,7587,767,1,0,0,0,7588,7586,1,0,0, - 0,7589,7590,3,780,390,0,7590,769,1,0,0,0,7591,7592,3,780,390,0,7592, - 771,1,0,0,0,7593,7594,3,780,390,0,7594,773,1,0,0,0,7595,7596,3,780, - 390,0,7596,775,1,0,0,0,7597,7598,3,780,390,0,7598,777,1,0,0,0,7599, - 7600,3,316,158,0,7600,779,1,0,0,0,7601,7603,3,818,409,0,7602,7604, - 3,752,376,0,7603,7602,1,0,0,0,7603,7604,1,0,0,0,7604,781,1,0,0,0, - 7605,7610,3,770,385,0,7606,7607,5,6,0,0,7607,7609,3,770,385,0,7608, - 7606,1,0,0,0,7609,7612,1,0,0,0,7610,7608,1,0,0,0,7610,7611,1,0,0, - 0,7611,783,1,0,0,0,7612,7610,1,0,0,0,7613,7618,3,818,409,0,7614, - 7615,5,6,0,0,7615,7617,3,818,409,0,7616,7614,1,0,0,0,7617,7620,1, - 0,0,0,7618,7616,1,0,0,0,7618,7619,1,0,0,0,7619,785,1,0,0,0,7620, - 7618,1,0,0,0,7621,7622,3,316,158,0,7622,787,1,0,0,0,7623,7624,3, - 316,158,0,7624,789,1,0,0,0,7625,7626,3,316,158,0,7626,791,1,0,0, - 0,7627,7628,3,818,409,0,7628,793,1,0,0,0,7629,7630,3,818,409,0,7630, - 795,1,0,0,0,7631,7636,3,820,410,0,7632,7633,3,818,409,0,7633,7634, - 3,752,376,0,7634,7636,1,0,0,0,7635,7631,1,0,0,0,7635,7632,1,0,0, - 0,7636,797,1,0,0,0,7637,7642,3,820,410,0,7638,7639,3,818,409,0,7639, - 7640,3,752,376,0,7640,7642,1,0,0,0,7641,7637,1,0,0,0,7641,7638,1, - 0,0,0,7642,799,1,0,0,0,7643,7644,3,818,409,0,7644,7645,3,754,377, - 0,7645,7648,1,0,0,0,7646,7648,4,400,10,0,7647,7643,1,0,0,0,7647, - 7646,1,0,0,0,7648,801,1,0,0,0,7649,7650,3,818,409,0,7650,803,1,0, - 0,0,7651,7656,3,820,410,0,7652,7653,3,818,409,0,7653,7654,3,752, - 376,0,7654,7656,1,0,0,0,7655,7651,1,0,0,0,7655,7652,1,0,0,0,7656, - 805,1,0,0,0,7657,7662,3,820,410,0,7658,7659,3,818,409,0,7659,7660, - 3,752,376,0,7660,7662,1,0,0,0,7661,7657,1,0,0,0,7661,7658,1,0,0, - 0,7662,807,1,0,0,0,7663,7666,3,810,405,0,7664,7665,5,487,0,0,7665, - 7667,3,810,405,0,7666,7664,1,0,0,0,7666,7667,1,0,0,0,7667,809,1, - 0,0,0,7668,7680,5,558,0,0,7669,7680,5,560,0,0,7670,7674,5,562,0, - 0,7671,7673,5,588,0,0,7672,7671,1,0,0,0,7673,7676,1,0,0,0,7674,7672, - 1,0,0,0,7674,7675,1,0,0,0,7675,7677,1,0,0,0,7676,7674,1,0,0,0,7677, - 7680,5,589,0,0,7678,7680,5,584,0,0,7679,7668,1,0,0,0,7679,7669,1, - 0,0,0,7679,7670,1,0,0,0,7679,7678,1,0,0,0,7680,811,1,0,0,0,7681, - 7683,7,29,0,0,7682,7681,1,0,0,0,7682,7683,1,0,0,0,7683,7684,1,0, - 0,0,7684,7685,5,571,0,0,7685,813,1,0,0,0,7686,7692,3,822,411,0,7687, - 7692,5,52,0,0,7688,7692,5,49,0,0,7689,7692,5,89,0,0,7690,7692,5, - 524,0,0,7691,7686,1,0,0,0,7691,7687,1,0,0,0,7691,7688,1,0,0,0,7691, - 7689,1,0,0,0,7691,7690,1,0,0,0,7692,815,1,0,0,0,7693,7698,3,814, - 407,0,7694,7695,5,6,0,0,7695,7697,3,814,407,0,7696,7694,1,0,0,0, - 7697,7700,1,0,0,0,7698,7696,1,0,0,0,7698,7699,1,0,0,0,7699,817,1, - 0,0,0,7700,7698,1,0,0,0,7701,7704,3,826,413,0,7702,7704,3,830,415, - 0,7703,7701,1,0,0,0,7703,7702,1,0,0,0,7704,819,1,0,0,0,7705,7708, - 3,826,413,0,7706,7708,3,832,416,0,7707,7705,1,0,0,0,7707,7706,1, - 0,0,0,7708,821,1,0,0,0,7709,7713,3,826,413,0,7710,7713,3,830,415, - 0,7711,7713,3,832,416,0,7712,7709,1,0,0,0,7712,7710,1,0,0,0,7712, - 7711,1,0,0,0,7713,823,1,0,0,0,7714,7719,3,826,413,0,7715,7719,3, - 830,415,0,7716,7719,3,832,416,0,7717,7719,3,834,417,0,7718,7714, - 1,0,0,0,7718,7715,1,0,0,0,7718,7716,1,0,0,0,7718,7717,1,0,0,0,7719, - 825,1,0,0,0,7720,7723,5,549,0,0,7721,7722,5,487,0,0,7722,7724,3, - 810,405,0,7723,7721,1,0,0,0,7723,7724,1,0,0,0,7724,7732,1,0,0,0, - 7725,7732,3,808,404,0,7726,7732,5,550,0,0,7727,7732,5,554,0,0,7728, - 7732,5,574,0,0,7729,7732,5,575,0,0,7730,7732,3,828,414,0,7731,7720, - 1,0,0,0,7731,7725,1,0,0,0,7731,7726,1,0,0,0,7731,7727,1,0,0,0,7731, - 7728,1,0,0,0,7731,7729,1,0,0,0,7731,7730,1,0,0,0,7732,827,1,0,0, - 0,7733,7734,7,109,0,0,7734,829,1,0,0,0,7735,7787,5,387,0,0,7736, - 7787,5,388,0,0,7737,7787,3,662,331,0,7738,7787,5,390,0,0,7739,7787, - 5,391,0,0,7740,7787,3,664,332,0,7741,7787,5,393,0,0,7742,7787,5, - 394,0,0,7743,7787,5,395,0,0,7744,7787,5,396,0,0,7745,7787,5,397, - 0,0,7746,7787,5,398,0,0,7747,7787,5,399,0,0,7748,7787,5,470,0,0, - 7749,7787,5,400,0,0,7750,7787,5,401,0,0,7751,7787,5,402,0,0,7752, - 7787,5,403,0,0,7753,7787,5,404,0,0,7754,7787,5,405,0,0,7755,7787, - 5,406,0,0,7756,7787,5,407,0,0,7757,7787,5,489,0,0,7758,7787,5,408, - 0,0,7759,7787,3,658,329,0,7760,7787,5,453,0,0,7761,7787,5,410,0, - 0,7762,7787,5,411,0,0,7763,7787,5,412,0,0,7764,7787,5,413,0,0,7765, - 7787,5,414,0,0,7766,7787,5,415,0,0,7767,7787,5,416,0,0,7768,7787, - 5,417,0,0,7769,7787,5,418,0,0,7770,7787,5,419,0,0,7771,7787,5,420, - 0,0,7772,7787,5,421,0,0,7773,7787,5,422,0,0,7774,7787,5,423,0,0, - 7775,7787,5,424,0,0,7776,7787,5,425,0,0,7777,7787,5,426,0,0,7778, - 7787,5,427,0,0,7779,7787,5,428,0,0,7780,7787,5,476,0,0,7781,7787, - 5,429,0,0,7782,7787,5,430,0,0,7783,7787,5,431,0,0,7784,7787,5,432, - 0,0,7785,7787,5,474,0,0,7786,7735,1,0,0,0,7786,7736,1,0,0,0,7786, - 7737,1,0,0,0,7786,7738,1,0,0,0,7786,7739,1,0,0,0,7786,7740,1,0,0, - 0,7786,7741,1,0,0,0,7786,7742,1,0,0,0,7786,7743,1,0,0,0,7786,7744, - 1,0,0,0,7786,7745,1,0,0,0,7786,7746,1,0,0,0,7786,7747,1,0,0,0,7786, - 7748,1,0,0,0,7786,7749,1,0,0,0,7786,7750,1,0,0,0,7786,7751,1,0,0, - 0,7786,7752,1,0,0,0,7786,7753,1,0,0,0,7786,7754,1,0,0,0,7786,7755, - 1,0,0,0,7786,7756,1,0,0,0,7786,7757,1,0,0,0,7786,7758,1,0,0,0,7786, - 7759,1,0,0,0,7786,7760,1,0,0,0,7786,7761,1,0,0,0,7786,7762,1,0,0, - 0,7786,7763,1,0,0,0,7786,7764,1,0,0,0,7786,7765,1,0,0,0,7786,7766, - 1,0,0,0,7786,7767,1,0,0,0,7786,7768,1,0,0,0,7786,7769,1,0,0,0,7786, - 7770,1,0,0,0,7786,7771,1,0,0,0,7786,7772,1,0,0,0,7786,7773,1,0,0, - 0,7786,7774,1,0,0,0,7786,7775,1,0,0,0,7786,7776,1,0,0,0,7786,7777, - 1,0,0,0,7786,7778,1,0,0,0,7786,7779,1,0,0,0,7786,7780,1,0,0,0,7786, - 7781,1,0,0,0,7786,7782,1,0,0,0,7786,7783,1,0,0,0,7786,7784,1,0,0, - 0,7786,7785,1,0,0,0,7787,831,1,0,0,0,7788,7789,7,110,0,0,7789,833, - 1,0,0,0,7790,7791,7,111,0,0,7791,835,1,0,0,0,7792,7794,3,838,419, - 0,7793,7792,1,0,0,0,7793,7794,1,0,0,0,7794,7805,1,0,0,0,7795,7803, - 5,178,0,0,7796,7800,3,840,420,0,7797,7800,5,178,0,0,7798,7800,3, - 838,419,0,7799,7796,1,0,0,0,7799,7797,1,0,0,0,7799,7798,1,0,0,0, - 7800,7801,1,0,0,0,7801,7799,1,0,0,0,7801,7802,1,0,0,0,7802,7804, - 1,0,0,0,7803,7799,1,0,0,0,7803,7804,1,0,0,0,7804,7806,1,0,0,0,7805, - 7795,1,0,0,0,7805,7806,1,0,0,0,7806,7807,1,0,0,0,7807,7811,5,146, - 0,0,7808,7810,3,846,423,0,7809,7808,1,0,0,0,7810,7813,1,0,0,0,7811, - 7809,1,0,0,0,7811,7812,1,0,0,0,7812,7815,1,0,0,0,7813,7811,1,0,0, - 0,7814,7816,3,924,462,0,7815,7814,1,0,0,0,7815,7816,1,0,0,0,7816, - 7817,1,0,0,0,7817,7819,5,454,0,0,7818,7820,3,928,464,0,7819,7818, - 1,0,0,0,7819,7820,1,0,0,0,7820,837,1,0,0,0,7821,7822,5,18,0,0,7822, - 7823,3,928,464,0,7823,7824,5,19,0,0,7824,839,1,0,0,0,7825,7872,3, - 928,464,0,7826,7827,5,496,0,0,7827,7830,5,62,0,0,7828,7831,5,28, - 0,0,7829,7831,3,818,409,0,7830,7828,1,0,0,0,7830,7829,1,0,0,0,7831, - 7873,1,0,0,0,7832,7834,5,497,0,0,7833,7832,1,0,0,0,7833,7834,1,0, - 0,0,7834,7835,1,0,0,0,7835,7837,3,652,326,0,7836,7838,3,98,49,0, - 7837,7836,1,0,0,0,7837,7838,1,0,0,0,7838,7841,1,0,0,0,7839,7840, - 5,77,0,0,7840,7842,5,78,0,0,7841,7839,1,0,0,0,7841,7842,1,0,0,0, - 7842,7848,1,0,0,0,7843,7846,3,844,422,0,7844,7846,5,53,0,0,7845, - 7843,1,0,0,0,7845,7844,1,0,0,0,7846,7847,1,0,0,0,7847,7849,3,930, - 465,0,7848,7845,1,0,0,0,7848,7849,1,0,0,0,7849,7873,1,0,0,0,7850, - 7852,5,269,0,0,7851,7850,1,0,0,0,7851,7852,1,0,0,0,7852,7853,1,0, - 0,0,7853,7855,5,324,0,0,7854,7851,1,0,0,0,7854,7855,1,0,0,0,7855, - 7856,1,0,0,0,7856,7868,5,172,0,0,7857,7858,5,2,0,0,7858,7863,3,842, - 421,0,7859,7860,5,6,0,0,7860,7862,3,842,421,0,7861,7859,1,0,0,0, - 7862,7865,1,0,0,0,7863,7861,1,0,0,0,7863,7864,1,0,0,0,7864,7866, - 1,0,0,0,7865,7863,1,0,0,0,7866,7867,5,3,0,0,7867,7869,1,0,0,0,7868, - 7857,1,0,0,0,7868,7869,1,0,0,0,7869,7870,1,0,0,0,7870,7871,7,112, - 0,0,7871,7873,3,560,280,0,7872,7826,1,0,0,0,7872,7833,1,0,0,0,7872, - 7854,1,0,0,0,7873,7874,1,0,0,0,7874,7875,5,7,0,0,7875,841,1,0,0, - 0,7876,7877,3,928,464,0,7877,7878,3,652,326,0,7878,843,1,0,0,0,7879, - 7880,7,113,0,0,7880,845,1,0,0,0,7881,7882,3,836,418,0,7882,7883, - 5,7,0,0,7883,7906,1,0,0,0,7884,7906,3,874,437,0,7885,7906,3,876, - 438,0,7886,7906,3,852,426,0,7887,7906,3,860,430,0,7888,7906,3,864, - 432,0,7889,7906,3,866,433,0,7890,7906,3,870,435,0,7891,7906,3,872, - 436,0,7892,7906,3,880,440,0,7893,7906,3,884,442,0,7894,7906,3,886, - 443,0,7895,7906,3,848,424,0,7896,7906,3,850,425,0,7897,7906,3,854, - 427,0,7898,7906,3,890,445,0,7899,7906,3,894,447,0,7900,7906,3,898, - 449,0,7901,7906,3,914,457,0,7902,7906,3,916,458,0,7903,7906,3,918, - 459,0,7904,7906,3,920,460,0,7905,7881,1,0,0,0,7905,7884,1,0,0,0, - 7905,7885,1,0,0,0,7905,7886,1,0,0,0,7905,7887,1,0,0,0,7905,7888, - 1,0,0,0,7905,7889,1,0,0,0,7905,7890,1,0,0,0,7905,7891,1,0,0,0,7905, - 7892,1,0,0,0,7905,7893,1,0,0,0,7905,7894,1,0,0,0,7905,7895,1,0,0, - 0,7905,7896,1,0,0,0,7905,7897,1,0,0,0,7905,7898,1,0,0,0,7905,7899, - 1,0,0,0,7905,7900,1,0,0,0,7905,7901,1,0,0,0,7905,7902,1,0,0,0,7905, - 7903,1,0,0,0,7905,7904,1,0,0,0,7906,847,1,0,0,0,7907,7908,5,498, - 0,0,7908,7909,3,930,465,0,7909,7910,5,7,0,0,7910,849,1,0,0,0,7911, - 7912,5,433,0,0,7912,7919,3,928,464,0,7913,7915,5,2,0,0,7914,7916, - 3,730,365,0,7915,7914,1,0,0,0,7915,7916,1,0,0,0,7916,7917,1,0,0, - 0,7917,7918,5,3,0,0,7918,7920,5,7,0,0,7919,7913,1,0,0,0,7919,7920, - 1,0,0,0,7920,7931,1,0,0,0,7921,7922,5,57,0,0,7922,7923,3,928,464, - 0,7923,7925,5,2,0,0,7924,7926,3,730,365,0,7925,7924,1,0,0,0,7925, - 7926,1,0,0,0,7926,7927,1,0,0,0,7927,7928,5,3,0,0,7928,7929,5,7,0, - 0,7929,7931,1,0,0,0,7930,7911,1,0,0,0,7930,7921,1,0,0,0,7931,851, - 1,0,0,0,7932,7933,3,858,429,0,7933,7934,3,844,422,0,7934,7935,3, - 930,465,0,7935,7936,5,7,0,0,7936,853,1,0,0,0,7937,7939,5,499,0,0, - 7938,7940,7,114,0,0,7939,7938,1,0,0,0,7939,7940,1,0,0,0,7940,7941, - 1,0,0,0,7941,7942,5,500,0,0,7942,7947,3,856,428,0,7943,7944,5,6, - 0,0,7944,7946,3,856,428,0,7945,7943,1,0,0,0,7946,7949,1,0,0,0,7947, - 7945,1,0,0,0,7947,7948,1,0,0,0,7948,7950,1,0,0,0,7949,7947,1,0,0, - 0,7950,7951,5,7,0,0,7951,855,1,0,0,0,7952,7953,3,858,429,0,7953, - 7954,3,844,422,0,7954,7955,3,818,409,0,7955,857,1,0,0,0,7956,7959, - 3,316,158,0,7957,7959,5,28,0,0,7958,7956,1,0,0,0,7958,7957,1,0,0, - 0,7959,7966,1,0,0,0,7960,7961,5,4,0,0,7961,7962,3,674,337,0,7962, - 7963,5,5,0,0,7963,7965,1,0,0,0,7964,7960,1,0,0,0,7965,7968,1,0,0, - 0,7966,7964,1,0,0,0,7966,7967,1,0,0,0,7967,859,1,0,0,0,7968,7966, - 1,0,0,0,7969,7970,5,220,0,0,7970,7971,3,930,465,0,7971,7975,5,93, - 0,0,7972,7974,3,846,423,0,7973,7972,1,0,0,0,7974,7977,1,0,0,0,7975, - 7973,1,0,0,0,7975,7976,1,0,0,0,7976,7989,1,0,0,0,7977,7975,1,0,0, - 0,7978,7979,5,502,0,0,7979,7980,3,674,337,0,7980,7984,5,93,0,0,7981, - 7983,3,846,423,0,7982,7981,1,0,0,0,7983,7986,1,0,0,0,7984,7982,1, - 0,0,0,7984,7985,1,0,0,0,7985,7988,1,0,0,0,7986,7984,1,0,0,0,7987, - 7978,1,0,0,0,7988,7991,1,0,0,0,7989,7987,1,0,0,0,7989,7990,1,0,0, - 0,7990,7993,1,0,0,0,7991,7989,1,0,0,0,7992,7994,3,862,431,0,7993, - 7992,1,0,0,0,7993,7994,1,0,0,0,7994,7995,1,0,0,0,7995,7996,5,454, - 0,0,7996,7997,5,220,0,0,7997,7998,5,7,0,0,7998,861,1,0,0,0,7999, - 8003,5,58,0,0,8000,8002,3,846,423,0,8001,8000,1,0,0,0,8002,8005, - 1,0,0,0,8003,8001,1,0,0,0,8003,8004,1,0,0,0,8004,863,1,0,0,0,8005, - 8003,1,0,0,0,8006,8008,5,40,0,0,8007,8009,3,930,465,0,8008,8007, - 1,0,0,0,8008,8009,1,0,0,0,8009,8019,1,0,0,0,8010,8011,5,102,0,0, - 8011,8012,3,730,365,0,8012,8016,5,93,0,0,8013,8015,3,846,423,0,8014, - 8013,1,0,0,0,8015,8018,1,0,0,0,8016,8014,1,0,0,0,8016,8017,1,0,0, - 0,8017,8020,1,0,0,0,8018,8016,1,0,0,0,8019,8010,1,0,0,0,8020,8021, - 1,0,0,0,8021,8019,1,0,0,0,8021,8022,1,0,0,0,8022,8024,1,0,0,0,8023, - 8025,3,862,431,0,8024,8023,1,0,0,0,8024,8025,1,0,0,0,8025,8026,1, - 0,0,0,8026,8027,5,454,0,0,8027,8028,5,40,0,0,8028,8029,5,7,0,0,8029, - 865,1,0,0,0,8030,8032,3,838,419,0,8031,8030,1,0,0,0,8031,8032,1, - 0,0,0,8032,8037,1,0,0,0,8033,8034,5,503,0,0,8034,8038,3,674,337, - 0,8035,8036,5,62,0,0,8036,8038,3,868,434,0,8037,8033,1,0,0,0,8037, - 8035,1,0,0,0,8037,8038,1,0,0,0,8038,8039,1,0,0,0,8039,8040,3,882, - 441,0,8040,867,1,0,0,0,8041,8042,3,314,157,0,8042,8065,5,68,0,0, - 8043,8045,3,818,409,0,8044,8046,3,534,267,0,8045,8044,1,0,0,0,8045, - 8046,1,0,0,0,8046,8066,1,0,0,0,8047,8066,3,560,280,0,8048,8066,3, - 520,260,0,8049,8050,5,202,0,0,8050,8053,3,674,337,0,8051,8052,5, - 100,0,0,8052,8054,3,730,365,0,8053,8051,1,0,0,0,8053,8054,1,0,0, - 0,8054,8066,1,0,0,0,8055,8057,5,504,0,0,8056,8055,1,0,0,0,8056,8057, - 1,0,0,0,8057,8058,1,0,0,0,8058,8059,3,674,337,0,8059,8060,5,24,0, - 0,8060,8063,3,674,337,0,8061,8062,5,147,0,0,8062,8064,3,674,337, - 0,8063,8061,1,0,0,0,8063,8064,1,0,0,0,8064,8066,1,0,0,0,8065,8043, - 1,0,0,0,8065,8047,1,0,0,0,8065,8048,1,0,0,0,8065,8049,1,0,0,0,8065, - 8056,1,0,0,0,8066,869,1,0,0,0,8067,8069,3,838,419,0,8068,8067,1, - 0,0,0,8068,8069,1,0,0,0,8069,8070,1,0,0,0,8070,8071,5,505,0,0,8071, - 8074,3,314,157,0,8072,8073,5,506,0,0,8073,8075,5,571,0,0,8074,8072, - 1,0,0,0,8074,8075,1,0,0,0,8075,8076,1,0,0,0,8076,8077,5,68,0,0,8077, - 8078,5,35,0,0,8078,8079,3,674,337,0,8079,8080,3,882,441,0,8080,871, - 1,0,0,0,8081,8083,7,115,0,0,8082,8084,3,928,464,0,8083,8082,1,0, - 0,0,8083,8084,1,0,0,0,8084,8087,1,0,0,0,8085,8086,5,102,0,0,8086, - 8088,3,930,465,0,8087,8085,1,0,0,0,8087,8088,1,0,0,0,8088,8089,1, - 0,0,0,8089,8090,5,7,0,0,8090,873,1,0,0,0,8091,8106,5,508,0,0,8092, - 8093,5,268,0,0,8093,8107,3,930,465,0,8094,8101,5,509,0,0,8095,8096, - 5,202,0,0,8096,8097,3,674,337,0,8097,8098,5,100,0,0,8098,8099,3, - 730,365,0,8099,8102,1,0,0,0,8100,8102,3,560,280,0,8101,8095,1,0, - 0,0,8101,8100,1,0,0,0,8102,8107,1,0,0,0,8103,8105,3,930,465,0,8104, - 8103,1,0,0,0,8104,8105,1,0,0,0,8105,8107,1,0,0,0,8106,8092,1,0,0, - 0,8106,8094,1,0,0,0,8106,8104,1,0,0,0,8107,8108,1,0,0,0,8108,8109, - 5,7,0,0,8109,875,1,0,0,0,8110,8140,5,510,0,0,8111,8113,7,116,0,0, - 8112,8111,1,0,0,0,8112,8113,1,0,0,0,8113,8126,1,0,0,0,8114,8127, - 3,826,413,0,8115,8116,5,511,0,0,8116,8127,3,808,404,0,8117,8124, - 3,808,404,0,8118,8119,5,6,0,0,8119,8121,3,674,337,0,8120,8118,1, - 0,0,0,8121,8122,1,0,0,0,8122,8120,1,0,0,0,8122,8123,1,0,0,0,8123, - 8125,1,0,0,0,8124,8120,1,0,0,0,8124,8125,1,0,0,0,8125,8127,1,0,0, - 0,8126,8114,1,0,0,0,8126,8115,1,0,0,0,8126,8117,1,0,0,0,8126,8127, - 1,0,0,0,8127,8137,1,0,0,0,8128,8129,5,100,0,0,8129,8134,3,878,439, - 0,8130,8131,5,6,0,0,8131,8133,3,878,439,0,8132,8130,1,0,0,0,8133, - 8136,1,0,0,0,8134,8132,1,0,0,0,8134,8135,1,0,0,0,8135,8138,1,0,0, - 0,8136,8134,1,0,0,0,8137,8128,1,0,0,0,8137,8138,1,0,0,0,8138,8139, - 1,0,0,0,8139,8141,5,7,0,0,8140,8112,1,0,0,0,8140,8141,1,0,0,0,8141, - 877,1,0,0,0,8142,8143,3,826,413,0,8143,8144,5,10,0,0,8144,8145,3, - 674,337,0,8145,879,1,0,0,0,8146,8147,5,518,0,0,8147,8150,3,930,465, - 0,8148,8149,5,6,0,0,8149,8151,3,930,465,0,8150,8148,1,0,0,0,8150, - 8151,1,0,0,0,8151,8152,1,0,0,0,8152,8153,5,7,0,0,8153,881,1,0,0, - 0,8154,8158,5,519,0,0,8155,8157,3,846,423,0,8156,8155,1,0,0,0,8157, - 8160,1,0,0,0,8158,8156,1,0,0,0,8158,8159,1,0,0,0,8159,8161,1,0,0, - 0,8160,8158,1,0,0,0,8161,8162,5,454,0,0,8162,8164,5,519,0,0,8163, - 8165,3,928,464,0,8164,8163,1,0,0,0,8164,8165,1,0,0,0,8165,8166,1, - 0,0,0,8166,8167,5,7,0,0,8167,883,1,0,0,0,8168,8170,3,4,2,0,8169, - 8171,3,888,444,0,8170,8169,1,0,0,0,8170,8171,1,0,0,0,8171,8172,1, - 0,0,0,8172,8173,5,7,0,0,8173,885,1,0,0,0,8174,8175,5,202,0,0,8175, - 8191,3,674,337,0,8176,8178,3,888,444,0,8177,8176,1,0,0,0,8177,8178, - 1,0,0,0,8178,8181,1,0,0,0,8179,8180,5,100,0,0,8180,8182,3,730,365, - 0,8181,8179,1,0,0,0,8181,8182,1,0,0,0,8182,8192,1,0,0,0,8183,8184, - 5,100,0,0,8184,8186,3,730,365,0,8185,8183,1,0,0,0,8185,8186,1,0, - 0,0,8186,8188,1,0,0,0,8187,8189,3,888,444,0,8188,8187,1,0,0,0,8188, - 8189,1,0,0,0,8189,8192,1,0,0,0,8190,8192,1,0,0,0,8191,8177,1,0,0, - 0,8191,8185,1,0,0,0,8191,8190,1,0,0,0,8192,8193,1,0,0,0,8193,8194, - 5,7,0,0,8194,887,1,0,0,0,8195,8197,5,71,0,0,8196,8198,5,346,0,0, - 8197,8196,1,0,0,0,8197,8198,1,0,0,0,8198,8199,1,0,0,0,8199,8200, - 3,730,365,0,8200,889,1,0,0,0,8201,8233,5,520,0,0,8202,8207,3,922, - 461,0,8203,8205,5,269,0,0,8204,8203,1,0,0,0,8204,8205,1,0,0,0,8205, - 8206,1,0,0,0,8206,8208,5,324,0,0,8207,8204,1,0,0,0,8207,8208,1,0, - 0,0,8208,8209,1,0,0,0,8209,8217,5,62,0,0,8210,8218,3,560,280,0,8211, - 8212,5,202,0,0,8212,8215,3,930,465,0,8213,8214,5,100,0,0,8214,8216, - 3,730,365,0,8215,8213,1,0,0,0,8215,8216,1,0,0,0,8216,8218,1,0,0, - 0,8217,8210,1,0,0,0,8217,8211,1,0,0,0,8218,8234,1,0,0,0,8219,8231, - 3,818,409,0,8220,8221,5,2,0,0,8221,8226,3,892,446,0,8222,8223,5, - 6,0,0,8223,8225,3,892,446,0,8224,8222,1,0,0,0,8225,8228,1,0,0,0, - 8226,8224,1,0,0,0,8226,8227,1,0,0,0,8227,8229,1,0,0,0,8228,8226, - 1,0,0,0,8229,8230,5,3,0,0,8230,8232,1,0,0,0,8231,8220,1,0,0,0,8231, - 8232,1,0,0,0,8232,8234,1,0,0,0,8233,8202,1,0,0,0,8233,8219,1,0,0, - 0,8234,8235,1,0,0,0,8235,8236,5,7,0,0,8236,891,1,0,0,0,8237,8238, - 3,818,409,0,8238,8239,5,20,0,0,8239,8241,1,0,0,0,8240,8237,1,0,0, - 0,8240,8241,1,0,0,0,8241,8242,1,0,0,0,8242,8243,3,674,337,0,8243, - 893,1,0,0,0,8244,8246,5,61,0,0,8245,8247,3,896,448,0,8246,8245,1, - 0,0,0,8246,8247,1,0,0,0,8247,8249,1,0,0,0,8248,8250,3,332,166,0, - 8249,8248,1,0,0,0,8249,8250,1,0,0,0,8250,8251,1,0,0,0,8251,8252, - 3,922,461,0,8252,8253,5,71,0,0,8253,8254,3,730,365,0,8254,8255,5, - 7,0,0,8255,895,1,0,0,0,8256,8271,5,268,0,0,8257,8271,5,293,0,0,8258, - 8271,5,207,0,0,8259,8271,5,249,0,0,8260,8262,7,50,0,0,8261,8260, - 1,0,0,0,8261,8262,1,0,0,0,8262,8263,1,0,0,0,8263,8271,3,674,337, - 0,8264,8271,5,30,0,0,8265,8268,7,117,0,0,8266,8269,3,674,337,0,8267, - 8269,5,30,0,0,8268,8266,1,0,0,0,8268,8267,1,0,0,0,8268,8269,1,0, - 0,0,8269,8271,1,0,0,0,8270,8256,1,0,0,0,8270,8257,1,0,0,0,8270,8258, - 1,0,0,0,8270,8259,1,0,0,0,8270,8261,1,0,0,0,8270,8264,1,0,0,0,8270, - 8265,1,0,0,0,8271,897,1,0,0,0,8272,8274,5,265,0,0,8273,8275,3,896, - 448,0,8274,8273,1,0,0,0,8274,8275,1,0,0,0,8275,8276,1,0,0,0,8276, - 8277,3,922,461,0,8277,8278,5,7,0,0,8278,899,1,0,0,0,8279,8281,3, - 572,286,0,8280,8279,1,0,0,0,8280,8281,1,0,0,0,8281,8282,1,0,0,0, - 8282,8283,5,525,0,0,8283,8285,5,71,0,0,8284,8286,5,81,0,0,8285,8284, - 1,0,0,0,8285,8286,1,0,0,0,8286,8287,1,0,0,0,8287,8289,3,774,387, - 0,8288,8290,5,9,0,0,8289,8288,1,0,0,0,8289,8290,1,0,0,0,8290,8295, - 1,0,0,0,8291,8293,5,36,0,0,8292,8291,1,0,0,0,8292,8293,1,0,0,0,8293, - 8294,1,0,0,0,8294,8296,3,818,409,0,8295,8292,1,0,0,0,8295,8296,1, - 0,0,0,8296,8297,1,0,0,0,8297,8298,5,100,0,0,8298,8299,3,902,451, - 0,8299,8300,5,80,0,0,8300,8302,3,674,337,0,8301,8303,3,904,452,0, - 8302,8301,1,0,0,0,8303,8304,1,0,0,0,8304,8302,1,0,0,0,8304,8305, - 1,0,0,0,8305,901,1,0,0,0,8306,8308,5,81,0,0,8307,8306,1,0,0,0,8307, - 8308,1,0,0,0,8308,8309,1,0,0,0,8309,8311,3,774,387,0,8310,8312,5, - 9,0,0,8311,8310,1,0,0,0,8311,8312,1,0,0,0,8312,8318,1,0,0,0,8313, - 8316,3,564,282,0,8314,8316,3,608,304,0,8315,8313,1,0,0,0,8315,8314, - 1,0,0,0,8316,8318,1,0,0,0,8317,8307,1,0,0,0,8317,8315,1,0,0,0,8318, - 8323,1,0,0,0,8319,8321,5,36,0,0,8320,8319,1,0,0,0,8320,8321,1,0, - 0,0,8321,8322,1,0,0,0,8322,8324,3,818,409,0,8323,8320,1,0,0,0,8323, - 8324,1,0,0,0,8324,903,1,0,0,0,8325,8326,5,102,0,0,8326,8329,5,526, - 0,0,8327,8328,5,33,0,0,8328,8330,3,674,337,0,8329,8327,1,0,0,0,8329, - 8330,1,0,0,0,8330,8331,1,0,0,0,8331,8336,5,93,0,0,8332,8337,3,908, - 454,0,8333,8337,5,182,0,0,8334,8335,5,57,0,0,8335,8337,5,270,0,0, - 8336,8332,1,0,0,0,8336,8333,1,0,0,0,8336,8334,1,0,0,0,8337,8352, - 1,0,0,0,8338,8339,5,102,0,0,8339,8340,5,77,0,0,8340,8343,5,526,0, - 0,8341,8342,5,33,0,0,8342,8344,3,674,337,0,8343,8341,1,0,0,0,8343, - 8344,1,0,0,0,8344,8345,1,0,0,0,8345,8349,5,93,0,0,8346,8350,3,906, - 453,0,8347,8348,5,57,0,0,8348,8350,5,270,0,0,8349,8346,1,0,0,0,8349, - 8347,1,0,0,0,8350,8352,1,0,0,0,8351,8325,1,0,0,0,8351,8338,1,0,0, - 0,8352,905,1,0,0,0,8353,8355,5,241,0,0,8354,8356,3,144,72,0,8355, - 8354,1,0,0,0,8355,8356,1,0,0,0,8356,8360,1,0,0,0,8357,8358,5,463, - 0,0,8358,8359,7,76,0,0,8359,8361,5,450,0,0,8360,8357,1,0,0,0,8360, - 8361,1,0,0,0,8361,8362,1,0,0,0,8362,8363,3,910,455,0,8363,907,1, - 0,0,0,8364,8365,5,369,0,0,8365,8383,5,333,0,0,8366,8367,3,800,400, - 0,8367,8368,5,10,0,0,8368,8369,3,912,456,0,8369,8384,1,0,0,0,8370, - 8371,3,144,72,0,8371,8372,5,10,0,0,8372,8373,5,2,0,0,8373,8378,3, - 912,456,0,8374,8375,5,6,0,0,8375,8377,3,912,456,0,8376,8374,1,0, - 0,0,8377,8380,1,0,0,0,8378,8376,1,0,0,0,8378,8379,1,0,0,0,8379,8381, - 1,0,0,0,8380,8378,1,0,0,0,8381,8382,5,3,0,0,8382,8384,1,0,0,0,8383, - 8366,1,0,0,0,8383,8370,1,0,0,0,8384,8385,1,0,0,0,8385,8383,1,0,0, - 0,8385,8386,1,0,0,0,8386,909,1,0,0,0,8387,8388,5,422,0,0,8388,8389, - 5,2,0,0,8389,8394,3,912,456,0,8390,8391,5,6,0,0,8391,8393,3,912, - 456,0,8392,8390,1,0,0,0,8393,8396,1,0,0,0,8394,8392,1,0,0,0,8394, - 8395,1,0,0,0,8395,8397,1,0,0,0,8396,8394,1,0,0,0,8397,8398,5,3,0, - 0,8398,8402,1,0,0,0,8399,8400,5,53,0,0,8400,8402,5,422,0,0,8401, - 8387,1,0,0,0,8401,8399,1,0,0,0,8402,911,1,0,0,0,8403,8406,3,588, - 294,0,8404,8406,5,53,0,0,8405,8403,1,0,0,0,8405,8404,1,0,0,0,8406, - 913,1,0,0,0,8407,8408,5,157,0,0,8408,8409,3,922,461,0,8409,8410, - 5,7,0,0,8410,915,1,0,0,0,8411,8412,5,78,0,0,8412,8413,5,7,0,0,8413, - 917,1,0,0,0,8414,8420,7,67,0,0,8415,8417,5,33,0,0,8416,8418,5,269, - 0,0,8417,8416,1,0,0,0,8417,8418,1,0,0,0,8418,8419,1,0,0,0,8419,8421, - 5,153,0,0,8420,8415,1,0,0,0,8420,8421,1,0,0,0,8421,8422,1,0,0,0, - 8422,8423,5,7,0,0,8423,919,1,0,0,0,8424,8425,5,333,0,0,8425,8426, - 3,316,158,0,8426,8427,5,94,0,0,8427,8428,5,53,0,0,8428,8429,5,7, - 0,0,8429,8437,1,0,0,0,8430,8433,5,313,0,0,8431,8434,3,316,158,0, - 8432,8434,5,30,0,0,8433,8431,1,0,0,0,8433,8432,1,0,0,0,8434,8435, - 1,0,0,0,8435,8437,5,7,0,0,8436,8424,1,0,0,0,8436,8430,1,0,0,0,8437, - 921,1,0,0,0,8438,8441,3,818,409,0,8439,8441,5,28,0,0,8440,8438,1, - 0,0,0,8440,8439,1,0,0,0,8441,923,1,0,0,0,8442,8459,5,517,0,0,8443, - 8444,5,102,0,0,8444,8449,3,926,463,0,8445,8446,5,82,0,0,8446,8448, - 3,926,463,0,8447,8445,1,0,0,0,8448,8451,1,0,0,0,8449,8447,1,0,0, - 0,8449,8450,1,0,0,0,8450,8452,1,0,0,0,8451,8449,1,0,0,0,8452,8456, - 5,93,0,0,8453,8455,3,846,423,0,8454,8453,1,0,0,0,8455,8458,1,0,0, - 0,8456,8454,1,0,0,0,8456,8457,1,0,0,0,8457,8460,1,0,0,0,8458,8456, - 1,0,0,0,8459,8443,1,0,0,0,8460,8461,1,0,0,0,8461,8459,1,0,0,0,8461, - 8462,1,0,0,0,8462,925,1,0,0,0,8463,8467,3,928,464,0,8464,8465,5, - 511,0,0,8465,8467,3,808,404,0,8466,8463,1,0,0,0,8466,8464,1,0,0, - 0,8467,927,1,0,0,0,8468,8471,3,818,409,0,8469,8471,3,828,414,0,8470, - 8468,1,0,0,0,8470,8469,1,0,0,0,8471,929,1,0,0,0,8472,8474,3,756, - 378,0,8473,8472,1,0,0,0,8473,8474,1,0,0,0,8474,8476,1,0,0,0,8475, - 8477,3,580,290,0,8476,8475,1,0,0,0,8476,8477,1,0,0,0,8477,8479,1, - 0,0,0,8478,8480,3,610,305,0,8479,8478,1,0,0,0,8479,8480,1,0,0,0, - 8480,8482,1,0,0,0,8481,8483,3,638,319,0,8482,8481,1,0,0,0,8482,8483, - 1,0,0,0,8483,8485,1,0,0,0,8484,8486,3,600,300,0,8485,8484,1,0,0, - 0,8485,8486,1,0,0,0,8486,8489,1,0,0,0,8487,8488,5,67,0,0,8488,8490, - 3,674,337,0,8489,8487,1,0,0,0,8489,8490,1,0,0,0,8490,8492,1,0,0, - 0,8491,8493,3,702,351,0,8492,8491,1,0,0,0,8492,8493,1,0,0,0,8493, - 931,1,0,0,0,1187,935,942,1062,1064,1073,1078,1084,1119,1129,1135, - 1140,1147,1152,1159,1170,1178,1182,1194,1200,1206,1210,1215,1219, - 1232,1242,1244,1250,1255,1268,1271,1276,1281,1292,1296,1308,1312, - 1315,1319,1331,1349,1356,1364,1369,1376,1384,1390,1398,1406,1410, - 1424,1429,1434,1446,1452,1464,1469,1479,1485,1490,1498,1503,1510, - 1515,1520,1530,1535,1540,1547,1551,1565,1571,1577,1582,1589,1601, - 1609,1617,1633,1642,1651,1660,1664,1676,1684,1694,1714,1719,1722, - 1729,1732,1736,1740,1743,1748,1753,1757,1766,1772,1776,1785,1788, - 1794,1803,1815,1819,1823,1828,1831,1837,1839,1841,1845,1851,1855, - 1860,1865,1869,1872,1879,1892,1905,1919,1936,1946,1953,1958,1962, - 1969,1974,1977,1979,1984,1988,1992,1996,2001,2004,2008,2011,2015, - 2023,2028,2031,2035,2041,2050,2054,2060,2062,2071,2076,2088,2093, - 2097,2101,2106,2110,2113,2116,2119,2122,2125,2130,2133,2136,2139, - 2142,2145,2151,2155,2158,2161,2164,2167,2169,2176,2184,2194,2199, - 2209,2212,2217,2222,2227,2230,2235,2244,2246,2250,2253,2257,2262, - 2267,2271,2274,2278,2281,2286,2289,2294,2297,2301,2304,2307,2312, - 2315,2323,2335,2339,2346,2351,2354,2357,2360,2365,2376,2382,2386, - 2389,2392,2397,2404,2407,2411,2419,2424,2427,2430,2437,2442,2451, - 2454,2457,2462,2465,2477,2487,2504,2508,2512,2514,2531,2533,2549, - 2560,2563,2566,2575,2584,2600,2603,2606,2614,2618,2625,2634,2638, - 2644,2648,2651,2654,2657,2660,2666,2670,2675,2679,2682,2685,2688, - 2693,2699,2703,2707,2711,2717,2719,2724,2730,2736,2740,2755,2760, - 2763,2765,2768,2772,2776,2779,2782,2790,2796,2798,2804,2809,2814, - 2818,2825,2827,2838,2877,2887,2889,2892,2896,2900,2910,2912,2918, - 2920,2929,2941,2955,2960,2963,2970,2975,2983,2985,2991,2996,3000, - 3005,3011,3018,3024,3026,3035,3041,3049,3055,3060,3065,3073,3088, - 3090,3094,3098,3101,3104,3113,3116,3119,3125,3131,3135,3147,3153, - 3156,3161,3165,3172,3182,3184,3208,3220,3225,3227,3231,3234,3237, - 3247,3250,3260,3265,3270,3273,3276,3284,3290,3297,3305,3308,3319, - 3323,3329,3336,3339,3348,3362,3365,3379,3390,3393,3405,3410,3423, - 3428,3441,3450,3453,3456,3463,3466,3478,3484,3486,3494,3502,3510, - 3522,3527,3538,3549,3557,3565,3572,3579,3581,3584,3589,3594,3613, - 3622,3625,3652,3661,3664,3668,3672,3676,3683,3687,3691,3695,3699, - 3704,3708,3713,3719,3724,3731,3735,3741,3745,3750,3758,3764,3769, - 3776,3781,3785,3790,3796,3803,3808,3815,3820,3827,3831,3839,3843, - 3845,3848,3853,3863,3878,3881,3889,3896,3901,3907,3911,3918,3923, - 3926,3929,3933,3942,3960,3963,3995,4000,4006,4026,4031,4037,4040, - 4044,4048,4054,4057,4061,4065,4070,4073,4076,4079,4092,4098,4106, - 4113,4118,4121,4128,4131,4139,4142,4147,4154,4157,4177,4189,4192, - 4198,4203,4212,4220,4225,4231,4238,4246,4249,4260,4262,4276,4282, - 4290,4292,4298,4302,4305,4308,4313,4318,4322,4325,4328,4331,4334, - 4342,4353,4356,4359,4364,4367,4371,4375,4381,4389,4392,4405,4410, - 4412,4417,4424,4431,4440,4448,4456,4463,4471,4478,4486,4490,4494, - 4496,4502,4507,4511,4518,4523,4528,4533,4535,4545,4555,4571,4589, - 4601,4608,4623,4628,4631,4636,4641,4646,4649,4652,4657,4664,4668, - 4673,4680,4684,4690,4699,4708,4720,4722,4735,4741,4745,4747,4754, - 4767,4774,4776,4792,4796,4800,4805,4810,4815,4820,4823,4835,4888, - 4897,4901,4910,4914,4923,4927,4932,4935,4939,4944,4946,4955,4960, - 4971,4975,4989,4997,5035,5037,5056,5059,5086,5090,5094,5098,5102, - 5105,5120,5127,5141,5154,5179,5198,5213,5229,5236,5247,5250,5269, - 5272,5285,5289,5309,5321,5325,5347,5351,5361,5365,5371,5375,5379, - 5383,5390,5395,5406,5410,5413,5418,5424,5435,5439,5442,5446,5450, - 5453,5463,5466,5470,5475,5481,5484,5489,5492,5499,5501,5507,5511, - 5520,5525,5527,5537,5540,5545,5553,5556,5561,5563,5565,5571,5588, - 5594,5607,5613,5617,5622,5652,5667,5672,5676,5689,5693,5695,5704, - 5710,5712,5716,5719,5722,5725,5728,5730,5733,5737,5745,5750,5753, - 5759,5763,5767,5772,5774,5778,5782,5789,5795,5799,5801,5803,5816, - 5824,5832,5843,5852,5857,5861,5865,5872,5875,5877,5885,5889,5892, - 5899,5906,5911,5918,5921,5923,5926,5932,5937,5941,5948,5958,5965, - 5968,5971,5975,5986,5989,5992,5995,5998,6005,6008,6011,6018,6030, - 6037,6039,6044,6049,6051,6057,6064,6069,6074,6078,6082,6086,6088, - 6092,6096,6099,6102,6104,6114,6116,6121,6125,6130,6134,6141,6146, - 6150,6153,6159,6162,6181,6188,6192,6195,6199,6203,6206,6209,6214, - 6223,6230,6234,6238,6242,6245,6247,6252,6256,6261,6267,6274,6279, - 6284,6293,6300,6308,6319,6324,6328,6331,6335,6340,6344,6349,6357, - 6368,6373,6377,6380,6383,6385,6388,6391,6394,6398,6402,6406,6408, - 6417,6422,6428,6432,6434,6441,6446,6452,6454,6458,6465,6470,6473, - 6479,6483,6489,6498,6504,6506,6511,6514,6523,6530,6532,6539,6544, - 6547,6557,6568,6573,6577,6585,6595,6602,6608,6619,6625,6635,6644, - 6648,6651,6653,6655,6659,6667,6670,6675,6680,6687,6689,6695,6699, - 6702,6707,6710,6712,6718,6727,6733,6736,6744,6747,6751,6757,6759, - 6762,6766,6771,6778,6785,6787,6793,6795,6800,6802,6806,6815,6819, - 6827,6829,6843,6846,6854,6863,6869,6874,6882,6884,6889,6893,6898, - 6903,6909,6925,6927,6936,6951,6956,6959,6965,6970,6983,6988,6992, - 6999,7018,7030,7035,7043,7045,7047,7056,7059,7064,7069,7072,7083, - 7091,7096,7098,7101,7105,7116,7137,7145,7158,7168,7174,7180,7183, - 7186,7212,7214,7235,7245,7258,7263,7267,7269,7281,7288,7294,7300, - 7304,7315,7325,7329,7334,7337,7340,7349,7360,7362,7366,7371,7380, - 7385,7393,7403,7411,7415,7418,7425,7433,7437,7444,7453,7462,7465, - 7477,7486,7493,7502,7512,7517,7521,7523,7526,7531,7536,7544,7552, - 7555,7562,7570,7578,7586,7603,7610,7618,7635,7641,7647,7655,7661, - 7666,7674,7679,7682,7691,7698,7703,7707,7712,7718,7723,7731,7786, - 7793,7799,7801,7803,7805,7811,7815,7819,7830,7833,7837,7841,7845, - 7848,7851,7854,7863,7868,7872,7905,7915,7919,7925,7930,7939,7947, - 7958,7966,7975,7984,7989,7993,8003,8008,8016,8021,8024,8031,8037, - 8045,8053,8056,8063,8065,8068,8074,8083,8087,8101,8104,8106,8112, - 8122,8124,8126,8134,8137,8140,8150,8158,8164,8170,8177,8181,8185, - 8188,8191,8197,8204,8207,8215,8217,8226,8231,8233,8240,8246,8249, - 8261,8268,8270,8274,8280,8285,8289,8292,8295,8304,8307,8311,8315, - 8317,8320,8323,8329,8336,8343,8349,8351,8355,8360,8378,8383,8385, - 8394,8401,8405,8417,8420,8433,8436,8440,8449,8456,8461,8466,8470, - 8473,8476,8479,8482,8485,8489,8492 + 7444,1,0,0,0,7447,7455,3,800,400,0,7448,7455,3,674,337,0,7449,7452, + 3,820,410,0,7450,7451,7,107,0,0,7451,7453,3,674,337,0,7452,7450, + 1,0,0,0,7452,7453,1,0,0,0,7453,7455,1,0,0,0,7454,7447,1,0,0,0,7454, + 7448,1,0,0,0,7454,7449,1,0,0,0,7455,739,1,0,0,0,7456,7466,5,4,0, + 0,7457,7467,3,730,365,0,7458,7463,3,740,370,0,7459,7460,5,6,0,0, + 7460,7462,3,740,370,0,7461,7459,1,0,0,0,7462,7465,1,0,0,0,7463,7461, + 1,0,0,0,7463,7464,1,0,0,0,7464,7467,1,0,0,0,7465,7463,1,0,0,0,7466, + 7457,1,0,0,0,7466,7458,1,0,0,0,7466,7467,1,0,0,0,7467,7468,1,0,0, + 0,7468,7469,5,5,0,0,7469,741,1,0,0,0,7470,7479,3,826,413,0,7471, + 7479,5,384,0,0,7472,7479,5,264,0,0,7473,7479,5,176,0,0,7474,7479, + 5,218,0,0,7475,7479,5,261,0,0,7476,7479,5,326,0,0,7477,7479,3,808, + 404,0,7478,7470,1,0,0,0,7478,7471,1,0,0,0,7478,7472,1,0,0,0,7478, + 7473,1,0,0,0,7478,7474,1,0,0,0,7478,7475,1,0,0,0,7478,7476,1,0,0, + 0,7478,7477,1,0,0,0,7479,743,1,0,0,0,7480,7481,7,108,0,0,7481,745, + 1,0,0,0,7482,7483,3,674,337,0,7483,7484,5,64,0,0,7484,7487,3,674, + 337,0,7485,7486,5,62,0,0,7486,7488,3,674,337,0,7487,7485,1,0,0,0, + 7487,7488,1,0,0,0,7488,7504,1,0,0,0,7489,7490,3,674,337,0,7490,7491, + 5,62,0,0,7491,7494,3,674,337,0,7492,7493,5,64,0,0,7493,7495,3,674, + 337,0,7494,7492,1,0,0,0,7494,7495,1,0,0,0,7495,7504,1,0,0,0,7496, + 7497,3,674,337,0,7497,7498,5,127,0,0,7498,7499,3,674,337,0,7499, + 7500,5,197,0,0,7500,7501,3,674,337,0,7501,7504,1,0,0,0,7502,7504, + 3,730,365,0,7503,7482,1,0,0,0,7503,7489,1,0,0,0,7503,7496,1,0,0, + 0,7503,7502,1,0,0,0,7504,747,1,0,0,0,7505,7506,5,102,0,0,7506,7507, + 3,674,337,0,7507,7508,5,93,0,0,7508,7509,3,674,337,0,7509,749,1, + 0,0,0,7510,7513,5,11,0,0,7511,7514,3,824,412,0,7512,7514,5,9,0,0, + 7513,7511,1,0,0,0,7513,7512,1,0,0,0,7514,7528,1,0,0,0,7515,7524, + 5,4,0,0,7516,7525,3,674,337,0,7517,7519,3,674,337,0,7518,7517,1, + 0,0,0,7518,7519,1,0,0,0,7519,7520,1,0,0,0,7520,7522,5,8,0,0,7521, + 7523,3,674,337,0,7522,7521,1,0,0,0,7522,7523,1,0,0,0,7523,7525,1, + 0,0,0,7524,7516,1,0,0,0,7524,7518,1,0,0,0,7525,7526,1,0,0,0,7526, + 7528,5,5,0,0,7527,7510,1,0,0,0,7527,7515,1,0,0,0,7528,751,1,0,0, + 0,7529,7531,3,750,375,0,7530,7529,1,0,0,0,7531,7532,1,0,0,0,7532, + 7530,1,0,0,0,7532,7533,1,0,0,0,7533,753,1,0,0,0,7534,7536,3,750, + 375,0,7535,7534,1,0,0,0,7536,7539,1,0,0,0,7537,7535,1,0,0,0,7537, + 7538,1,0,0,0,7538,755,1,0,0,0,7539,7537,1,0,0,0,7540,7545,3,758, + 379,0,7541,7542,5,6,0,0,7542,7544,3,758,379,0,7543,7541,1,0,0,0, + 7544,7547,1,0,0,0,7545,7543,1,0,0,0,7545,7546,1,0,0,0,7546,757,1, + 0,0,0,7547,7545,1,0,0,0,7548,7553,3,734,367,0,7549,7550,5,36,0,0, + 7550,7554,3,824,412,0,7551,7554,3,826,413,0,7552,7554,1,0,0,0,7553, + 7549,1,0,0,0,7553,7551,1,0,0,0,7553,7552,1,0,0,0,7554,7557,1,0,0, + 0,7555,7557,5,9,0,0,7556,7548,1,0,0,0,7556,7555,1,0,0,0,7557,759, + 1,0,0,0,7558,7563,3,780,390,0,7559,7560,5,6,0,0,7560,7562,3,780, + 390,0,7561,7559,1,0,0,0,7562,7565,1,0,0,0,7563,7561,1,0,0,0,7563, + 7564,1,0,0,0,7564,761,1,0,0,0,7565,7563,1,0,0,0,7566,7571,3,774, + 387,0,7567,7568,5,6,0,0,7568,7570,3,774,387,0,7569,7567,1,0,0,0, + 7570,7573,1,0,0,0,7571,7569,1,0,0,0,7571,7572,1,0,0,0,7572,763,1, + 0,0,0,7573,7571,1,0,0,0,7574,7579,3,790,395,0,7575,7576,5,6,0,0, + 7576,7578,3,790,395,0,7577,7575,1,0,0,0,7578,7581,1,0,0,0,7579,7577, + 1,0,0,0,7579,7580,1,0,0,0,7580,765,1,0,0,0,7581,7579,1,0,0,0,7582, + 7587,3,788,394,0,7583,7584,5,6,0,0,7584,7586,3,788,394,0,7585,7583, + 1,0,0,0,7586,7589,1,0,0,0,7587,7585,1,0,0,0,7587,7588,1,0,0,0,7588, + 767,1,0,0,0,7589,7587,1,0,0,0,7590,7591,3,780,390,0,7591,769,1,0, + 0,0,7592,7593,3,780,390,0,7593,771,1,0,0,0,7594,7595,3,780,390,0, + 7595,773,1,0,0,0,7596,7597,3,780,390,0,7597,775,1,0,0,0,7598,7599, + 3,780,390,0,7599,777,1,0,0,0,7600,7601,3,316,158,0,7601,779,1,0, + 0,0,7602,7604,3,818,409,0,7603,7605,3,752,376,0,7604,7603,1,0,0, + 0,7604,7605,1,0,0,0,7605,781,1,0,0,0,7606,7611,3,770,385,0,7607, + 7608,5,6,0,0,7608,7610,3,770,385,0,7609,7607,1,0,0,0,7610,7613,1, + 0,0,0,7611,7609,1,0,0,0,7611,7612,1,0,0,0,7612,783,1,0,0,0,7613, + 7611,1,0,0,0,7614,7619,3,818,409,0,7615,7616,5,6,0,0,7616,7618,3, + 818,409,0,7617,7615,1,0,0,0,7618,7621,1,0,0,0,7619,7617,1,0,0,0, + 7619,7620,1,0,0,0,7620,785,1,0,0,0,7621,7619,1,0,0,0,7622,7623,3, + 316,158,0,7623,787,1,0,0,0,7624,7625,3,316,158,0,7625,789,1,0,0, + 0,7626,7627,3,316,158,0,7627,791,1,0,0,0,7628,7629,3,818,409,0,7629, + 793,1,0,0,0,7630,7631,3,818,409,0,7631,795,1,0,0,0,7632,7637,3,820, + 410,0,7633,7634,3,818,409,0,7634,7635,3,752,376,0,7635,7637,1,0, + 0,0,7636,7632,1,0,0,0,7636,7633,1,0,0,0,7637,797,1,0,0,0,7638,7643, + 3,820,410,0,7639,7640,3,818,409,0,7640,7641,3,752,376,0,7641,7643, + 1,0,0,0,7642,7638,1,0,0,0,7642,7639,1,0,0,0,7643,799,1,0,0,0,7644, + 7645,3,818,409,0,7645,7646,3,754,377,0,7646,7649,1,0,0,0,7647,7649, + 4,400,10,0,7648,7644,1,0,0,0,7648,7647,1,0,0,0,7649,801,1,0,0,0, + 7650,7651,3,818,409,0,7651,803,1,0,0,0,7652,7657,3,820,410,0,7653, + 7654,3,818,409,0,7654,7655,3,752,376,0,7655,7657,1,0,0,0,7656,7652, + 1,0,0,0,7656,7653,1,0,0,0,7657,805,1,0,0,0,7658,7663,3,820,410,0, + 7659,7660,3,818,409,0,7660,7661,3,752,376,0,7661,7663,1,0,0,0,7662, + 7658,1,0,0,0,7662,7659,1,0,0,0,7663,807,1,0,0,0,7664,7667,3,810, + 405,0,7665,7666,5,487,0,0,7666,7668,3,810,405,0,7667,7665,1,0,0, + 0,7667,7668,1,0,0,0,7668,809,1,0,0,0,7669,7681,5,558,0,0,7670,7681, + 5,560,0,0,7671,7675,5,562,0,0,7672,7674,5,588,0,0,7673,7672,1,0, + 0,0,7674,7677,1,0,0,0,7675,7673,1,0,0,0,7675,7676,1,0,0,0,7676,7678, + 1,0,0,0,7677,7675,1,0,0,0,7678,7681,5,589,0,0,7679,7681,5,584,0, + 0,7680,7669,1,0,0,0,7680,7670,1,0,0,0,7680,7671,1,0,0,0,7680,7679, + 1,0,0,0,7681,811,1,0,0,0,7682,7684,7,29,0,0,7683,7682,1,0,0,0,7683, + 7684,1,0,0,0,7684,7685,1,0,0,0,7685,7686,5,571,0,0,7686,813,1,0, + 0,0,7687,7693,3,822,411,0,7688,7693,5,52,0,0,7689,7693,5,49,0,0, + 7690,7693,5,89,0,0,7691,7693,5,524,0,0,7692,7687,1,0,0,0,7692,7688, + 1,0,0,0,7692,7689,1,0,0,0,7692,7690,1,0,0,0,7692,7691,1,0,0,0,7693, + 815,1,0,0,0,7694,7699,3,814,407,0,7695,7696,5,6,0,0,7696,7698,3, + 814,407,0,7697,7695,1,0,0,0,7698,7701,1,0,0,0,7699,7697,1,0,0,0, + 7699,7700,1,0,0,0,7700,817,1,0,0,0,7701,7699,1,0,0,0,7702,7705,3, + 826,413,0,7703,7705,3,830,415,0,7704,7702,1,0,0,0,7704,7703,1,0, + 0,0,7705,819,1,0,0,0,7706,7709,3,826,413,0,7707,7709,3,832,416,0, + 7708,7706,1,0,0,0,7708,7707,1,0,0,0,7709,821,1,0,0,0,7710,7714,3, + 826,413,0,7711,7714,3,830,415,0,7712,7714,3,832,416,0,7713,7710, + 1,0,0,0,7713,7711,1,0,0,0,7713,7712,1,0,0,0,7714,823,1,0,0,0,7715, + 7720,3,826,413,0,7716,7720,3,830,415,0,7717,7720,3,832,416,0,7718, + 7720,3,834,417,0,7719,7715,1,0,0,0,7719,7716,1,0,0,0,7719,7717,1, + 0,0,0,7719,7718,1,0,0,0,7720,825,1,0,0,0,7721,7724,5,549,0,0,7722, + 7723,5,487,0,0,7723,7725,3,810,405,0,7724,7722,1,0,0,0,7724,7725, + 1,0,0,0,7725,7733,1,0,0,0,7726,7733,3,808,404,0,7727,7733,5,550, + 0,0,7728,7733,5,554,0,0,7729,7733,5,574,0,0,7730,7733,5,575,0,0, + 7731,7733,3,828,414,0,7732,7721,1,0,0,0,7732,7726,1,0,0,0,7732,7727, + 1,0,0,0,7732,7728,1,0,0,0,7732,7729,1,0,0,0,7732,7730,1,0,0,0,7732, + 7731,1,0,0,0,7733,827,1,0,0,0,7734,7735,7,109,0,0,7735,829,1,0,0, + 0,7736,7788,5,387,0,0,7737,7788,5,388,0,0,7738,7788,3,662,331,0, + 7739,7788,5,390,0,0,7740,7788,5,391,0,0,7741,7788,3,664,332,0,7742, + 7788,5,393,0,0,7743,7788,5,394,0,0,7744,7788,5,395,0,0,7745,7788, + 5,396,0,0,7746,7788,5,397,0,0,7747,7788,5,398,0,0,7748,7788,5,399, + 0,0,7749,7788,5,470,0,0,7750,7788,5,400,0,0,7751,7788,5,401,0,0, + 7752,7788,5,402,0,0,7753,7788,5,403,0,0,7754,7788,5,404,0,0,7755, + 7788,5,405,0,0,7756,7788,5,406,0,0,7757,7788,5,407,0,0,7758,7788, + 5,489,0,0,7759,7788,5,408,0,0,7760,7788,3,658,329,0,7761,7788,5, + 453,0,0,7762,7788,5,410,0,0,7763,7788,5,411,0,0,7764,7788,5,412, + 0,0,7765,7788,5,413,0,0,7766,7788,5,414,0,0,7767,7788,5,415,0,0, + 7768,7788,5,416,0,0,7769,7788,5,417,0,0,7770,7788,5,418,0,0,7771, + 7788,5,419,0,0,7772,7788,5,420,0,0,7773,7788,5,421,0,0,7774,7788, + 5,422,0,0,7775,7788,5,423,0,0,7776,7788,5,424,0,0,7777,7788,5,425, + 0,0,7778,7788,5,426,0,0,7779,7788,5,427,0,0,7780,7788,5,428,0,0, + 7781,7788,5,476,0,0,7782,7788,5,429,0,0,7783,7788,5,430,0,0,7784, + 7788,5,431,0,0,7785,7788,5,432,0,0,7786,7788,5,474,0,0,7787,7736, + 1,0,0,0,7787,7737,1,0,0,0,7787,7738,1,0,0,0,7787,7739,1,0,0,0,7787, + 7740,1,0,0,0,7787,7741,1,0,0,0,7787,7742,1,0,0,0,7787,7743,1,0,0, + 0,7787,7744,1,0,0,0,7787,7745,1,0,0,0,7787,7746,1,0,0,0,7787,7747, + 1,0,0,0,7787,7748,1,0,0,0,7787,7749,1,0,0,0,7787,7750,1,0,0,0,7787, + 7751,1,0,0,0,7787,7752,1,0,0,0,7787,7753,1,0,0,0,7787,7754,1,0,0, + 0,7787,7755,1,0,0,0,7787,7756,1,0,0,0,7787,7757,1,0,0,0,7787,7758, + 1,0,0,0,7787,7759,1,0,0,0,7787,7760,1,0,0,0,7787,7761,1,0,0,0,7787, + 7762,1,0,0,0,7787,7763,1,0,0,0,7787,7764,1,0,0,0,7787,7765,1,0,0, + 0,7787,7766,1,0,0,0,7787,7767,1,0,0,0,7787,7768,1,0,0,0,7787,7769, + 1,0,0,0,7787,7770,1,0,0,0,7787,7771,1,0,0,0,7787,7772,1,0,0,0,7787, + 7773,1,0,0,0,7787,7774,1,0,0,0,7787,7775,1,0,0,0,7787,7776,1,0,0, + 0,7787,7777,1,0,0,0,7787,7778,1,0,0,0,7787,7779,1,0,0,0,7787,7780, + 1,0,0,0,7787,7781,1,0,0,0,7787,7782,1,0,0,0,7787,7783,1,0,0,0,7787, + 7784,1,0,0,0,7787,7785,1,0,0,0,7787,7786,1,0,0,0,7788,831,1,0,0, + 0,7789,7790,7,110,0,0,7790,833,1,0,0,0,7791,7792,7,111,0,0,7792, + 835,1,0,0,0,7793,7795,3,838,419,0,7794,7793,1,0,0,0,7794,7795,1, + 0,0,0,7795,7806,1,0,0,0,7796,7804,5,178,0,0,7797,7801,3,840,420, + 0,7798,7801,5,178,0,0,7799,7801,3,838,419,0,7800,7797,1,0,0,0,7800, + 7798,1,0,0,0,7800,7799,1,0,0,0,7801,7802,1,0,0,0,7802,7800,1,0,0, + 0,7802,7803,1,0,0,0,7803,7805,1,0,0,0,7804,7800,1,0,0,0,7804,7805, + 1,0,0,0,7805,7807,1,0,0,0,7806,7796,1,0,0,0,7806,7807,1,0,0,0,7807, + 7808,1,0,0,0,7808,7812,5,146,0,0,7809,7811,3,846,423,0,7810,7809, + 1,0,0,0,7811,7814,1,0,0,0,7812,7810,1,0,0,0,7812,7813,1,0,0,0,7813, + 7816,1,0,0,0,7814,7812,1,0,0,0,7815,7817,3,924,462,0,7816,7815,1, + 0,0,0,7816,7817,1,0,0,0,7817,7818,1,0,0,0,7818,7820,5,454,0,0,7819, + 7821,3,928,464,0,7820,7819,1,0,0,0,7820,7821,1,0,0,0,7821,837,1, + 0,0,0,7822,7823,5,18,0,0,7823,7824,3,928,464,0,7824,7825,5,19,0, + 0,7825,839,1,0,0,0,7826,7873,3,928,464,0,7827,7828,5,496,0,0,7828, + 7831,5,62,0,0,7829,7832,5,28,0,0,7830,7832,3,818,409,0,7831,7829, + 1,0,0,0,7831,7830,1,0,0,0,7832,7874,1,0,0,0,7833,7835,5,497,0,0, + 7834,7833,1,0,0,0,7834,7835,1,0,0,0,7835,7836,1,0,0,0,7836,7838, + 3,652,326,0,7837,7839,3,98,49,0,7838,7837,1,0,0,0,7838,7839,1,0, + 0,0,7839,7842,1,0,0,0,7840,7841,5,77,0,0,7841,7843,5,78,0,0,7842, + 7840,1,0,0,0,7842,7843,1,0,0,0,7843,7849,1,0,0,0,7844,7847,3,844, + 422,0,7845,7847,5,53,0,0,7846,7844,1,0,0,0,7846,7845,1,0,0,0,7847, + 7848,1,0,0,0,7848,7850,3,930,465,0,7849,7846,1,0,0,0,7849,7850,1, + 0,0,0,7850,7874,1,0,0,0,7851,7853,5,269,0,0,7852,7851,1,0,0,0,7852, + 7853,1,0,0,0,7853,7854,1,0,0,0,7854,7856,5,324,0,0,7855,7852,1,0, + 0,0,7855,7856,1,0,0,0,7856,7857,1,0,0,0,7857,7869,5,172,0,0,7858, + 7859,5,2,0,0,7859,7864,3,842,421,0,7860,7861,5,6,0,0,7861,7863,3, + 842,421,0,7862,7860,1,0,0,0,7863,7866,1,0,0,0,7864,7862,1,0,0,0, + 7864,7865,1,0,0,0,7865,7867,1,0,0,0,7866,7864,1,0,0,0,7867,7868, + 5,3,0,0,7868,7870,1,0,0,0,7869,7858,1,0,0,0,7869,7870,1,0,0,0,7870, + 7871,1,0,0,0,7871,7872,7,112,0,0,7872,7874,3,560,280,0,7873,7827, + 1,0,0,0,7873,7834,1,0,0,0,7873,7855,1,0,0,0,7874,7875,1,0,0,0,7875, + 7876,5,7,0,0,7876,841,1,0,0,0,7877,7878,3,928,464,0,7878,7879,3, + 652,326,0,7879,843,1,0,0,0,7880,7881,7,113,0,0,7881,845,1,0,0,0, + 7882,7883,3,836,418,0,7883,7884,5,7,0,0,7884,7907,1,0,0,0,7885,7907, + 3,874,437,0,7886,7907,3,876,438,0,7887,7907,3,852,426,0,7888,7907, + 3,860,430,0,7889,7907,3,864,432,0,7890,7907,3,866,433,0,7891,7907, + 3,870,435,0,7892,7907,3,872,436,0,7893,7907,3,880,440,0,7894,7907, + 3,884,442,0,7895,7907,3,886,443,0,7896,7907,3,848,424,0,7897,7907, + 3,850,425,0,7898,7907,3,854,427,0,7899,7907,3,890,445,0,7900,7907, + 3,894,447,0,7901,7907,3,898,449,0,7902,7907,3,914,457,0,7903,7907, + 3,916,458,0,7904,7907,3,918,459,0,7905,7907,3,920,460,0,7906,7882, + 1,0,0,0,7906,7885,1,0,0,0,7906,7886,1,0,0,0,7906,7887,1,0,0,0,7906, + 7888,1,0,0,0,7906,7889,1,0,0,0,7906,7890,1,0,0,0,7906,7891,1,0,0, + 0,7906,7892,1,0,0,0,7906,7893,1,0,0,0,7906,7894,1,0,0,0,7906,7895, + 1,0,0,0,7906,7896,1,0,0,0,7906,7897,1,0,0,0,7906,7898,1,0,0,0,7906, + 7899,1,0,0,0,7906,7900,1,0,0,0,7906,7901,1,0,0,0,7906,7902,1,0,0, + 0,7906,7903,1,0,0,0,7906,7904,1,0,0,0,7906,7905,1,0,0,0,7907,847, + 1,0,0,0,7908,7909,5,498,0,0,7909,7910,3,930,465,0,7910,7911,5,7, + 0,0,7911,849,1,0,0,0,7912,7913,5,433,0,0,7913,7920,3,928,464,0,7914, + 7916,5,2,0,0,7915,7917,3,730,365,0,7916,7915,1,0,0,0,7916,7917,1, + 0,0,0,7917,7918,1,0,0,0,7918,7919,5,3,0,0,7919,7921,5,7,0,0,7920, + 7914,1,0,0,0,7920,7921,1,0,0,0,7921,7932,1,0,0,0,7922,7923,5,57, + 0,0,7923,7924,3,928,464,0,7924,7926,5,2,0,0,7925,7927,3,730,365, + 0,7926,7925,1,0,0,0,7926,7927,1,0,0,0,7927,7928,1,0,0,0,7928,7929, + 5,3,0,0,7929,7930,5,7,0,0,7930,7932,1,0,0,0,7931,7912,1,0,0,0,7931, + 7922,1,0,0,0,7932,851,1,0,0,0,7933,7934,3,858,429,0,7934,7935,3, + 844,422,0,7935,7936,3,930,465,0,7936,7937,5,7,0,0,7937,853,1,0,0, + 0,7938,7940,5,499,0,0,7939,7941,7,114,0,0,7940,7939,1,0,0,0,7940, + 7941,1,0,0,0,7941,7942,1,0,0,0,7942,7943,5,500,0,0,7943,7948,3,856, + 428,0,7944,7945,5,6,0,0,7945,7947,3,856,428,0,7946,7944,1,0,0,0, + 7947,7950,1,0,0,0,7948,7946,1,0,0,0,7948,7949,1,0,0,0,7949,7951, + 1,0,0,0,7950,7948,1,0,0,0,7951,7952,5,7,0,0,7952,855,1,0,0,0,7953, + 7954,3,858,429,0,7954,7955,3,844,422,0,7955,7956,3,818,409,0,7956, + 857,1,0,0,0,7957,7960,3,316,158,0,7958,7960,5,28,0,0,7959,7957,1, + 0,0,0,7959,7958,1,0,0,0,7960,7967,1,0,0,0,7961,7962,5,4,0,0,7962, + 7963,3,674,337,0,7963,7964,5,5,0,0,7964,7966,1,0,0,0,7965,7961,1, + 0,0,0,7966,7969,1,0,0,0,7967,7965,1,0,0,0,7967,7968,1,0,0,0,7968, + 859,1,0,0,0,7969,7967,1,0,0,0,7970,7971,5,220,0,0,7971,7972,3,930, + 465,0,7972,7976,5,93,0,0,7973,7975,3,846,423,0,7974,7973,1,0,0,0, + 7975,7978,1,0,0,0,7976,7974,1,0,0,0,7976,7977,1,0,0,0,7977,7990, + 1,0,0,0,7978,7976,1,0,0,0,7979,7980,5,502,0,0,7980,7981,3,674,337, + 0,7981,7985,5,93,0,0,7982,7984,3,846,423,0,7983,7982,1,0,0,0,7984, + 7987,1,0,0,0,7985,7983,1,0,0,0,7985,7986,1,0,0,0,7986,7989,1,0,0, + 0,7987,7985,1,0,0,0,7988,7979,1,0,0,0,7989,7992,1,0,0,0,7990,7988, + 1,0,0,0,7990,7991,1,0,0,0,7991,7994,1,0,0,0,7992,7990,1,0,0,0,7993, + 7995,3,862,431,0,7994,7993,1,0,0,0,7994,7995,1,0,0,0,7995,7996,1, + 0,0,0,7996,7997,5,454,0,0,7997,7998,5,220,0,0,7998,7999,5,7,0,0, + 7999,861,1,0,0,0,8000,8004,5,58,0,0,8001,8003,3,846,423,0,8002,8001, + 1,0,0,0,8003,8006,1,0,0,0,8004,8002,1,0,0,0,8004,8005,1,0,0,0,8005, + 863,1,0,0,0,8006,8004,1,0,0,0,8007,8009,5,40,0,0,8008,8010,3,930, + 465,0,8009,8008,1,0,0,0,8009,8010,1,0,0,0,8010,8020,1,0,0,0,8011, + 8012,5,102,0,0,8012,8013,3,730,365,0,8013,8017,5,93,0,0,8014,8016, + 3,846,423,0,8015,8014,1,0,0,0,8016,8019,1,0,0,0,8017,8015,1,0,0, + 0,8017,8018,1,0,0,0,8018,8021,1,0,0,0,8019,8017,1,0,0,0,8020,8011, + 1,0,0,0,8021,8022,1,0,0,0,8022,8020,1,0,0,0,8022,8023,1,0,0,0,8023, + 8025,1,0,0,0,8024,8026,3,862,431,0,8025,8024,1,0,0,0,8025,8026,1, + 0,0,0,8026,8027,1,0,0,0,8027,8028,5,454,0,0,8028,8029,5,40,0,0,8029, + 8030,5,7,0,0,8030,865,1,0,0,0,8031,8033,3,838,419,0,8032,8031,1, + 0,0,0,8032,8033,1,0,0,0,8033,8038,1,0,0,0,8034,8035,5,503,0,0,8035, + 8039,3,674,337,0,8036,8037,5,62,0,0,8037,8039,3,868,434,0,8038,8034, + 1,0,0,0,8038,8036,1,0,0,0,8038,8039,1,0,0,0,8039,8040,1,0,0,0,8040, + 8041,3,882,441,0,8041,867,1,0,0,0,8042,8043,3,314,157,0,8043,8066, + 5,68,0,0,8044,8046,3,818,409,0,8045,8047,3,534,267,0,8046,8045,1, + 0,0,0,8046,8047,1,0,0,0,8047,8067,1,0,0,0,8048,8067,3,560,280,0, + 8049,8067,3,520,260,0,8050,8051,5,202,0,0,8051,8054,3,674,337,0, + 8052,8053,5,100,0,0,8053,8055,3,730,365,0,8054,8052,1,0,0,0,8054, + 8055,1,0,0,0,8055,8067,1,0,0,0,8056,8058,5,504,0,0,8057,8056,1,0, + 0,0,8057,8058,1,0,0,0,8058,8059,1,0,0,0,8059,8060,3,674,337,0,8060, + 8061,5,24,0,0,8061,8064,3,674,337,0,8062,8063,5,147,0,0,8063,8065, + 3,674,337,0,8064,8062,1,0,0,0,8064,8065,1,0,0,0,8065,8067,1,0,0, + 0,8066,8044,1,0,0,0,8066,8048,1,0,0,0,8066,8049,1,0,0,0,8066,8050, + 1,0,0,0,8066,8057,1,0,0,0,8067,869,1,0,0,0,8068,8070,3,838,419,0, + 8069,8068,1,0,0,0,8069,8070,1,0,0,0,8070,8071,1,0,0,0,8071,8072, + 5,505,0,0,8072,8075,3,314,157,0,8073,8074,5,506,0,0,8074,8076,5, + 571,0,0,8075,8073,1,0,0,0,8075,8076,1,0,0,0,8076,8077,1,0,0,0,8077, + 8078,5,68,0,0,8078,8079,5,35,0,0,8079,8080,3,674,337,0,8080,8081, + 3,882,441,0,8081,871,1,0,0,0,8082,8084,7,115,0,0,8083,8085,3,928, + 464,0,8084,8083,1,0,0,0,8084,8085,1,0,0,0,8085,8088,1,0,0,0,8086, + 8087,5,102,0,0,8087,8089,3,930,465,0,8088,8086,1,0,0,0,8088,8089, + 1,0,0,0,8089,8090,1,0,0,0,8090,8091,5,7,0,0,8091,873,1,0,0,0,8092, + 8107,5,508,0,0,8093,8094,5,268,0,0,8094,8108,3,930,465,0,8095,8102, + 5,509,0,0,8096,8097,5,202,0,0,8097,8098,3,674,337,0,8098,8099,5, + 100,0,0,8099,8100,3,730,365,0,8100,8103,1,0,0,0,8101,8103,3,560, + 280,0,8102,8096,1,0,0,0,8102,8101,1,0,0,0,8103,8108,1,0,0,0,8104, + 8106,3,930,465,0,8105,8104,1,0,0,0,8105,8106,1,0,0,0,8106,8108,1, + 0,0,0,8107,8093,1,0,0,0,8107,8095,1,0,0,0,8107,8105,1,0,0,0,8108, + 8109,1,0,0,0,8109,8110,5,7,0,0,8110,875,1,0,0,0,8111,8141,5,510, + 0,0,8112,8114,7,116,0,0,8113,8112,1,0,0,0,8113,8114,1,0,0,0,8114, + 8127,1,0,0,0,8115,8128,3,826,413,0,8116,8117,5,511,0,0,8117,8128, + 3,808,404,0,8118,8125,3,808,404,0,8119,8120,5,6,0,0,8120,8122,3, + 674,337,0,8121,8119,1,0,0,0,8122,8123,1,0,0,0,8123,8121,1,0,0,0, + 8123,8124,1,0,0,0,8124,8126,1,0,0,0,8125,8121,1,0,0,0,8125,8126, + 1,0,0,0,8126,8128,1,0,0,0,8127,8115,1,0,0,0,8127,8116,1,0,0,0,8127, + 8118,1,0,0,0,8127,8128,1,0,0,0,8128,8138,1,0,0,0,8129,8130,5,100, + 0,0,8130,8135,3,878,439,0,8131,8132,5,6,0,0,8132,8134,3,878,439, + 0,8133,8131,1,0,0,0,8134,8137,1,0,0,0,8135,8133,1,0,0,0,8135,8136, + 1,0,0,0,8136,8139,1,0,0,0,8137,8135,1,0,0,0,8138,8129,1,0,0,0,8138, + 8139,1,0,0,0,8139,8140,1,0,0,0,8140,8142,5,7,0,0,8141,8113,1,0,0, + 0,8141,8142,1,0,0,0,8142,877,1,0,0,0,8143,8144,3,826,413,0,8144, + 8145,5,10,0,0,8145,8146,3,674,337,0,8146,879,1,0,0,0,8147,8148,5, + 518,0,0,8148,8151,3,930,465,0,8149,8150,5,6,0,0,8150,8152,3,930, + 465,0,8151,8149,1,0,0,0,8151,8152,1,0,0,0,8152,8153,1,0,0,0,8153, + 8154,5,7,0,0,8154,881,1,0,0,0,8155,8159,5,519,0,0,8156,8158,3,846, + 423,0,8157,8156,1,0,0,0,8158,8161,1,0,0,0,8159,8157,1,0,0,0,8159, + 8160,1,0,0,0,8160,8162,1,0,0,0,8161,8159,1,0,0,0,8162,8163,5,454, + 0,0,8163,8165,5,519,0,0,8164,8166,3,928,464,0,8165,8164,1,0,0,0, + 8165,8166,1,0,0,0,8166,8167,1,0,0,0,8167,8168,5,7,0,0,8168,883,1, + 0,0,0,8169,8171,3,4,2,0,8170,8172,3,888,444,0,8171,8170,1,0,0,0, + 8171,8172,1,0,0,0,8172,8173,1,0,0,0,8173,8174,5,7,0,0,8174,885,1, + 0,0,0,8175,8176,5,202,0,0,8176,8192,3,674,337,0,8177,8179,3,888, + 444,0,8178,8177,1,0,0,0,8178,8179,1,0,0,0,8179,8182,1,0,0,0,8180, + 8181,5,100,0,0,8181,8183,3,730,365,0,8182,8180,1,0,0,0,8182,8183, + 1,0,0,0,8183,8193,1,0,0,0,8184,8185,5,100,0,0,8185,8187,3,730,365, + 0,8186,8184,1,0,0,0,8186,8187,1,0,0,0,8187,8189,1,0,0,0,8188,8190, + 3,888,444,0,8189,8188,1,0,0,0,8189,8190,1,0,0,0,8190,8193,1,0,0, + 0,8191,8193,1,0,0,0,8192,8178,1,0,0,0,8192,8186,1,0,0,0,8192,8191, + 1,0,0,0,8193,8194,1,0,0,0,8194,8195,5,7,0,0,8195,887,1,0,0,0,8196, + 8198,5,71,0,0,8197,8199,5,346,0,0,8198,8197,1,0,0,0,8198,8199,1, + 0,0,0,8199,8200,1,0,0,0,8200,8201,3,730,365,0,8201,889,1,0,0,0,8202, + 8234,5,520,0,0,8203,8208,3,922,461,0,8204,8206,5,269,0,0,8205,8204, + 1,0,0,0,8205,8206,1,0,0,0,8206,8207,1,0,0,0,8207,8209,5,324,0,0, + 8208,8205,1,0,0,0,8208,8209,1,0,0,0,8209,8210,1,0,0,0,8210,8218, + 5,62,0,0,8211,8219,3,560,280,0,8212,8213,5,202,0,0,8213,8216,3,930, + 465,0,8214,8215,5,100,0,0,8215,8217,3,730,365,0,8216,8214,1,0,0, + 0,8216,8217,1,0,0,0,8217,8219,1,0,0,0,8218,8211,1,0,0,0,8218,8212, + 1,0,0,0,8219,8235,1,0,0,0,8220,8232,3,818,409,0,8221,8222,5,2,0, + 0,8222,8227,3,892,446,0,8223,8224,5,6,0,0,8224,8226,3,892,446,0, + 8225,8223,1,0,0,0,8226,8229,1,0,0,0,8227,8225,1,0,0,0,8227,8228, + 1,0,0,0,8228,8230,1,0,0,0,8229,8227,1,0,0,0,8230,8231,5,3,0,0,8231, + 8233,1,0,0,0,8232,8221,1,0,0,0,8232,8233,1,0,0,0,8233,8235,1,0,0, + 0,8234,8203,1,0,0,0,8234,8220,1,0,0,0,8235,8236,1,0,0,0,8236,8237, + 5,7,0,0,8237,891,1,0,0,0,8238,8239,3,818,409,0,8239,8240,5,20,0, + 0,8240,8242,1,0,0,0,8241,8238,1,0,0,0,8241,8242,1,0,0,0,8242,8243, + 1,0,0,0,8243,8244,3,674,337,0,8244,893,1,0,0,0,8245,8247,5,61,0, + 0,8246,8248,3,896,448,0,8247,8246,1,0,0,0,8247,8248,1,0,0,0,8248, + 8250,1,0,0,0,8249,8251,3,332,166,0,8250,8249,1,0,0,0,8250,8251,1, + 0,0,0,8251,8252,1,0,0,0,8252,8253,3,922,461,0,8253,8254,5,71,0,0, + 8254,8255,3,730,365,0,8255,8256,5,7,0,0,8256,895,1,0,0,0,8257,8272, + 5,268,0,0,8258,8272,5,293,0,0,8259,8272,5,207,0,0,8260,8272,5,249, + 0,0,8261,8263,7,50,0,0,8262,8261,1,0,0,0,8262,8263,1,0,0,0,8263, + 8264,1,0,0,0,8264,8272,3,674,337,0,8265,8272,5,30,0,0,8266,8269, + 7,117,0,0,8267,8270,3,674,337,0,8268,8270,5,30,0,0,8269,8267,1,0, + 0,0,8269,8268,1,0,0,0,8269,8270,1,0,0,0,8270,8272,1,0,0,0,8271,8257, + 1,0,0,0,8271,8258,1,0,0,0,8271,8259,1,0,0,0,8271,8260,1,0,0,0,8271, + 8262,1,0,0,0,8271,8265,1,0,0,0,8271,8266,1,0,0,0,8272,897,1,0,0, + 0,8273,8275,5,265,0,0,8274,8276,3,896,448,0,8275,8274,1,0,0,0,8275, + 8276,1,0,0,0,8276,8277,1,0,0,0,8277,8278,3,922,461,0,8278,8279,5, + 7,0,0,8279,899,1,0,0,0,8280,8282,3,572,286,0,8281,8280,1,0,0,0,8281, + 8282,1,0,0,0,8282,8283,1,0,0,0,8283,8284,5,525,0,0,8284,8286,5,71, + 0,0,8285,8287,5,81,0,0,8286,8285,1,0,0,0,8286,8287,1,0,0,0,8287, + 8288,1,0,0,0,8288,8290,3,774,387,0,8289,8291,5,9,0,0,8290,8289,1, + 0,0,0,8290,8291,1,0,0,0,8291,8296,1,0,0,0,8292,8294,5,36,0,0,8293, + 8292,1,0,0,0,8293,8294,1,0,0,0,8294,8295,1,0,0,0,8295,8297,3,818, + 409,0,8296,8293,1,0,0,0,8296,8297,1,0,0,0,8297,8298,1,0,0,0,8298, + 8299,5,100,0,0,8299,8300,3,902,451,0,8300,8301,5,80,0,0,8301,8303, + 3,674,337,0,8302,8304,3,904,452,0,8303,8302,1,0,0,0,8304,8305,1, + 0,0,0,8305,8303,1,0,0,0,8305,8306,1,0,0,0,8306,901,1,0,0,0,8307, + 8309,5,81,0,0,8308,8307,1,0,0,0,8308,8309,1,0,0,0,8309,8310,1,0, + 0,0,8310,8312,3,774,387,0,8311,8313,5,9,0,0,8312,8311,1,0,0,0,8312, + 8313,1,0,0,0,8313,8319,1,0,0,0,8314,8317,3,564,282,0,8315,8317,3, + 608,304,0,8316,8314,1,0,0,0,8316,8315,1,0,0,0,8317,8319,1,0,0,0, + 8318,8308,1,0,0,0,8318,8316,1,0,0,0,8319,8324,1,0,0,0,8320,8322, + 5,36,0,0,8321,8320,1,0,0,0,8321,8322,1,0,0,0,8322,8323,1,0,0,0,8323, + 8325,3,818,409,0,8324,8321,1,0,0,0,8324,8325,1,0,0,0,8325,903,1, + 0,0,0,8326,8327,5,102,0,0,8327,8330,5,526,0,0,8328,8329,5,33,0,0, + 8329,8331,3,674,337,0,8330,8328,1,0,0,0,8330,8331,1,0,0,0,8331,8332, + 1,0,0,0,8332,8337,5,93,0,0,8333,8338,3,908,454,0,8334,8338,5,182, + 0,0,8335,8336,5,57,0,0,8336,8338,5,270,0,0,8337,8333,1,0,0,0,8337, + 8334,1,0,0,0,8337,8335,1,0,0,0,8338,8353,1,0,0,0,8339,8340,5,102, + 0,0,8340,8341,5,77,0,0,8341,8344,5,526,0,0,8342,8343,5,33,0,0,8343, + 8345,3,674,337,0,8344,8342,1,0,0,0,8344,8345,1,0,0,0,8345,8346,1, + 0,0,0,8346,8350,5,93,0,0,8347,8351,3,906,453,0,8348,8349,5,57,0, + 0,8349,8351,5,270,0,0,8350,8347,1,0,0,0,8350,8348,1,0,0,0,8351,8353, + 1,0,0,0,8352,8326,1,0,0,0,8352,8339,1,0,0,0,8353,905,1,0,0,0,8354, + 8356,5,241,0,0,8355,8357,3,144,72,0,8356,8355,1,0,0,0,8356,8357, + 1,0,0,0,8357,8361,1,0,0,0,8358,8359,5,463,0,0,8359,8360,7,76,0,0, + 8360,8362,5,450,0,0,8361,8358,1,0,0,0,8361,8362,1,0,0,0,8362,8363, + 1,0,0,0,8363,8364,3,910,455,0,8364,907,1,0,0,0,8365,8366,5,369,0, + 0,8366,8384,5,333,0,0,8367,8368,3,800,400,0,8368,8369,5,10,0,0,8369, + 8370,3,912,456,0,8370,8385,1,0,0,0,8371,8372,3,144,72,0,8372,8373, + 5,10,0,0,8373,8374,5,2,0,0,8374,8379,3,912,456,0,8375,8376,5,6,0, + 0,8376,8378,3,912,456,0,8377,8375,1,0,0,0,8378,8381,1,0,0,0,8379, + 8377,1,0,0,0,8379,8380,1,0,0,0,8380,8382,1,0,0,0,8381,8379,1,0,0, + 0,8382,8383,5,3,0,0,8383,8385,1,0,0,0,8384,8367,1,0,0,0,8384,8371, + 1,0,0,0,8385,8386,1,0,0,0,8386,8384,1,0,0,0,8386,8387,1,0,0,0,8387, + 909,1,0,0,0,8388,8389,5,422,0,0,8389,8390,5,2,0,0,8390,8395,3,912, + 456,0,8391,8392,5,6,0,0,8392,8394,3,912,456,0,8393,8391,1,0,0,0, + 8394,8397,1,0,0,0,8395,8393,1,0,0,0,8395,8396,1,0,0,0,8396,8398, + 1,0,0,0,8397,8395,1,0,0,0,8398,8399,5,3,0,0,8399,8403,1,0,0,0,8400, + 8401,5,53,0,0,8401,8403,5,422,0,0,8402,8388,1,0,0,0,8402,8400,1, + 0,0,0,8403,911,1,0,0,0,8404,8407,3,588,294,0,8405,8407,5,53,0,0, + 8406,8404,1,0,0,0,8406,8405,1,0,0,0,8407,913,1,0,0,0,8408,8409,5, + 157,0,0,8409,8410,3,922,461,0,8410,8411,5,7,0,0,8411,915,1,0,0,0, + 8412,8413,5,78,0,0,8413,8414,5,7,0,0,8414,917,1,0,0,0,8415,8421, + 7,67,0,0,8416,8418,5,33,0,0,8417,8419,5,269,0,0,8418,8417,1,0,0, + 0,8418,8419,1,0,0,0,8419,8420,1,0,0,0,8420,8422,5,153,0,0,8421,8416, + 1,0,0,0,8421,8422,1,0,0,0,8422,8423,1,0,0,0,8423,8424,5,7,0,0,8424, + 919,1,0,0,0,8425,8426,5,333,0,0,8426,8427,3,316,158,0,8427,8428, + 5,94,0,0,8428,8429,5,53,0,0,8429,8430,5,7,0,0,8430,8438,1,0,0,0, + 8431,8434,5,313,0,0,8432,8435,3,316,158,0,8433,8435,5,30,0,0,8434, + 8432,1,0,0,0,8434,8433,1,0,0,0,8435,8436,1,0,0,0,8436,8438,5,7,0, + 0,8437,8425,1,0,0,0,8437,8431,1,0,0,0,8438,921,1,0,0,0,8439,8442, + 3,818,409,0,8440,8442,5,28,0,0,8441,8439,1,0,0,0,8441,8440,1,0,0, + 0,8442,923,1,0,0,0,8443,8460,5,517,0,0,8444,8445,5,102,0,0,8445, + 8450,3,926,463,0,8446,8447,5,82,0,0,8447,8449,3,926,463,0,8448,8446, + 1,0,0,0,8449,8452,1,0,0,0,8450,8448,1,0,0,0,8450,8451,1,0,0,0,8451, + 8453,1,0,0,0,8452,8450,1,0,0,0,8453,8457,5,93,0,0,8454,8456,3,846, + 423,0,8455,8454,1,0,0,0,8456,8459,1,0,0,0,8457,8455,1,0,0,0,8457, + 8458,1,0,0,0,8458,8461,1,0,0,0,8459,8457,1,0,0,0,8460,8444,1,0,0, + 0,8461,8462,1,0,0,0,8462,8460,1,0,0,0,8462,8463,1,0,0,0,8463,925, + 1,0,0,0,8464,8468,3,928,464,0,8465,8466,5,511,0,0,8466,8468,3,808, + 404,0,8467,8464,1,0,0,0,8467,8465,1,0,0,0,8468,927,1,0,0,0,8469, + 8472,3,818,409,0,8470,8472,3,828,414,0,8471,8469,1,0,0,0,8471,8470, + 1,0,0,0,8472,929,1,0,0,0,8473,8475,3,756,378,0,8474,8473,1,0,0,0, + 8474,8475,1,0,0,0,8475,8477,1,0,0,0,8476,8478,3,580,290,0,8477,8476, + 1,0,0,0,8477,8478,1,0,0,0,8478,8480,1,0,0,0,8479,8481,3,610,305, + 0,8480,8479,1,0,0,0,8480,8481,1,0,0,0,8481,8483,1,0,0,0,8482,8484, + 3,638,319,0,8483,8482,1,0,0,0,8483,8484,1,0,0,0,8484,8486,1,0,0, + 0,8485,8487,3,600,300,0,8486,8485,1,0,0,0,8486,8487,1,0,0,0,8487, + 8490,1,0,0,0,8488,8489,5,67,0,0,8489,8491,3,674,337,0,8490,8488, + 1,0,0,0,8490,8491,1,0,0,0,8491,8493,1,0,0,0,8492,8494,3,702,351, + 0,8493,8492,1,0,0,0,8493,8494,1,0,0,0,8494,931,1,0,0,0,1188,935, + 942,1062,1064,1073,1078,1084,1119,1129,1135,1140,1147,1152,1159, + 1170,1178,1182,1194,1200,1206,1210,1215,1219,1232,1242,1244,1250, + 1255,1268,1271,1276,1281,1292,1296,1308,1312,1315,1319,1331,1349, + 1356,1364,1369,1376,1384,1390,1398,1406,1410,1424,1429,1434,1446, + 1452,1464,1469,1479,1485,1490,1498,1503,1510,1515,1520,1530,1535, + 1540,1547,1551,1565,1571,1577,1582,1589,1601,1609,1617,1633,1642, + 1651,1660,1664,1676,1684,1694,1714,1719,1722,1729,1732,1736,1740, + 1743,1748,1753,1757,1766,1772,1776,1785,1788,1794,1803,1815,1819, + 1823,1828,1831,1837,1839,1841,1845,1851,1855,1860,1865,1869,1872, + 1879,1892,1905,1919,1936,1946,1953,1958,1962,1969,1974,1977,1979, + 1984,1988,1992,1996,2001,2004,2008,2011,2015,2023,2028,2031,2035, + 2041,2050,2054,2060,2062,2071,2076,2088,2093,2097,2101,2106,2110, + 2113,2116,2119,2122,2125,2130,2133,2136,2139,2142,2145,2151,2155, + 2158,2161,2164,2167,2169,2176,2184,2194,2199,2209,2212,2217,2222, + 2227,2230,2235,2244,2246,2250,2253,2257,2262,2267,2271,2274,2278, + 2281,2286,2289,2294,2297,2301,2304,2307,2312,2315,2323,2335,2339, + 2346,2351,2354,2357,2360,2365,2376,2382,2386,2389,2392,2397,2404, + 2407,2411,2419,2424,2427,2430,2437,2442,2451,2454,2457,2462,2465, + 2477,2487,2504,2508,2512,2514,2531,2533,2549,2560,2563,2566,2575, + 2584,2600,2603,2606,2614,2618,2625,2634,2638,2644,2648,2651,2654, + 2657,2660,2666,2670,2675,2679,2682,2685,2688,2693,2699,2703,2707, + 2711,2717,2719,2724,2730,2736,2740,2755,2760,2763,2765,2768,2772, + 2776,2779,2782,2790,2796,2798,2804,2809,2814,2818,2825,2827,2838, + 2877,2887,2889,2892,2896,2900,2910,2912,2918,2920,2929,2941,2955, + 2960,2963,2970,2975,2983,2985,2991,2996,3000,3005,3011,3018,3024, + 3026,3035,3041,3049,3055,3060,3065,3073,3088,3090,3094,3098,3101, + 3104,3113,3116,3119,3125,3131,3135,3147,3153,3156,3161,3165,3172, + 3182,3184,3208,3220,3225,3227,3231,3234,3237,3247,3250,3260,3265, + 3270,3273,3276,3284,3290,3297,3305,3308,3319,3323,3329,3336,3339, + 3348,3362,3365,3379,3390,3393,3405,3410,3423,3428,3441,3450,3453, + 3456,3463,3466,3478,3484,3486,3494,3502,3510,3522,3527,3538,3549, + 3557,3565,3572,3579,3581,3584,3589,3594,3613,3622,3625,3652,3661, + 3664,3668,3672,3676,3683,3687,3691,3695,3699,3704,3708,3713,3719, + 3724,3731,3735,3741,3745,3750,3758,3764,3769,3776,3781,3785,3790, + 3796,3803,3808,3815,3820,3827,3831,3839,3843,3845,3848,3853,3863, + 3878,3881,3889,3896,3901,3907,3911,3918,3923,3926,3929,3933,3942, + 3960,3963,3995,4000,4006,4026,4031,4037,4040,4044,4048,4054,4057, + 4061,4065,4070,4073,4076,4079,4092,4098,4106,4113,4118,4121,4128, + 4131,4139,4142,4147,4154,4157,4177,4189,4192,4198,4203,4212,4220, + 4225,4231,4238,4246,4249,4260,4262,4276,4282,4290,4292,4298,4302, + 4305,4308,4313,4318,4322,4325,4328,4331,4334,4342,4353,4356,4359, + 4364,4367,4371,4375,4381,4389,4392,4405,4410,4412,4417,4424,4431, + 4440,4448,4456,4463,4471,4478,4486,4490,4494,4496,4502,4507,4511, + 4518,4523,4528,4533,4535,4545,4555,4571,4589,4601,4608,4623,4628, + 4631,4636,4641,4646,4649,4652,4657,4664,4668,4673,4680,4684,4690, + 4699,4708,4720,4722,4735,4741,4745,4747,4754,4767,4774,4776,4792, + 4796,4800,4805,4810,4815,4820,4823,4835,4888,4897,4901,4910,4914, + 4923,4927,4932,4935,4939,4944,4946,4955,4960,4971,4975,4989,4997, + 5035,5037,5056,5059,5086,5090,5094,5098,5102,5105,5120,5127,5141, + 5154,5179,5198,5213,5229,5236,5247,5250,5269,5272,5285,5289,5309, + 5321,5325,5347,5351,5361,5365,5371,5375,5379,5383,5390,5395,5406, + 5410,5413,5418,5424,5435,5439,5442,5446,5450,5453,5463,5466,5470, + 5475,5481,5484,5489,5492,5499,5501,5507,5511,5520,5525,5527,5537, + 5540,5545,5553,5556,5561,5563,5565,5571,5588,5594,5607,5613,5617, + 5622,5652,5667,5672,5676,5689,5693,5695,5704,5710,5712,5716,5719, + 5722,5725,5728,5730,5733,5737,5745,5750,5753,5759,5763,5767,5772, + 5774,5778,5782,5789,5795,5799,5801,5803,5816,5824,5832,5843,5852, + 5857,5861,5865,5872,5875,5877,5885,5889,5892,5899,5906,5911,5918, + 5921,5923,5926,5932,5937,5941,5948,5958,5965,5968,5971,5975,5986, + 5989,5992,5995,5998,6005,6008,6011,6018,6030,6037,6039,6044,6049, + 6051,6057,6064,6069,6074,6078,6082,6086,6088,6092,6096,6099,6102, + 6104,6114,6116,6121,6125,6130,6134,6141,6146,6150,6153,6159,6162, + 6181,6188,6192,6195,6199,6203,6206,6209,6214,6223,6230,6234,6238, + 6242,6245,6247,6252,6256,6261,6267,6274,6279,6284,6293,6300,6308, + 6319,6324,6328,6331,6335,6340,6344,6349,6357,6368,6373,6377,6380, + 6383,6385,6388,6391,6394,6398,6402,6406,6408,6417,6422,6428,6432, + 6434,6441,6446,6452,6454,6458,6465,6470,6473,6479,6483,6489,6498, + 6504,6506,6511,6514,6523,6530,6532,6539,6544,6547,6557,6568,6573, + 6577,6585,6595,6602,6608,6619,6625,6635,6644,6648,6651,6653,6655, + 6659,6667,6670,6675,6680,6687,6689,6695,6699,6702,6707,6710,6712, + 6718,6727,6733,6736,6744,6747,6751,6757,6759,6762,6766,6771,6778, + 6785,6787,6793,6795,6800,6802,6806,6815,6819,6827,6829,6843,6846, + 6854,6863,6869,6874,6882,6884,6889,6893,6898,6903,6909,6925,6927, + 6936,6951,6956,6959,6965,6970,6983,6988,6992,6999,7018,7030,7035, + 7043,7045,7047,7056,7059,7064,7069,7072,7083,7091,7096,7098,7101, + 7105,7116,7137,7145,7158,7168,7174,7180,7183,7186,7212,7214,7235, + 7245,7258,7263,7267,7269,7281,7288,7294,7300,7304,7315,7325,7329, + 7334,7337,7340,7349,7360,7362,7366,7371,7380,7385,7393,7403,7411, + 7415,7418,7425,7433,7437,7444,7452,7454,7463,7466,7478,7487,7494, + 7503,7513,7518,7522,7524,7527,7532,7537,7545,7553,7556,7563,7571, + 7579,7587,7604,7611,7619,7636,7642,7648,7656,7662,7667,7675,7680, + 7683,7692,7699,7704,7708,7713,7719,7724,7732,7787,7794,7800,7802, + 7804,7806,7812,7816,7820,7831,7834,7838,7842,7846,7849,7852,7855, + 7864,7869,7873,7906,7916,7920,7926,7931,7940,7948,7959,7967,7976, + 7985,7990,7994,8004,8009,8017,8022,8025,8032,8038,8046,8054,8057, + 8064,8066,8069,8075,8084,8088,8102,8105,8107,8113,8123,8125,8127, + 8135,8138,8141,8151,8159,8165,8171,8178,8182,8186,8189,8192,8198, + 8205,8208,8216,8218,8227,8232,8234,8241,8247,8250,8262,8269,8271, + 8275,8281,8286,8290,8293,8296,8305,8308,8312,8316,8318,8321,8324, + 8330,8337,8344,8350,8352,8356,8361,8379,8384,8386,8395,8402,8406, + 8418,8421,8434,8437,8441,8450,8457,8462,8467,8471,8474,8477,8480, + 8483,8486,8490,8493 ]; private static __ATN: antlr.ATN; @@ -62332,6 +62341,7 @@ export class TypedtableelementContext extends antlr.ParserRuleContext { export class Column_defContext extends antlr.ParserRuleContext { + public _colType?: TypenameContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -76512,6 +76522,7 @@ export class Table_refContext extends antlr.ParserRuleContext { export class Alias_clauseContext extends antlr.ParserRuleContext { + public _alias?: ColidContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -76554,6 +76565,7 @@ export class Alias_clauseContext extends antlr.ParserRuleContext { export class Func_alias_clauseContext extends antlr.ParserRuleContext { + public _alias?: ColidContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } diff --git a/src/lib/spark/SparkSqlParser.interp b/src/lib/spark/SparkSqlParser.interp index 71336af6..03dd67a5 100644 --- a/src/lib/spark/SparkSqlParser.interp +++ b/src/lib/spark/SparkSqlParser.interp @@ -959,7 +959,7 @@ colDefinitionDescriptorWithPosition defaultExpression variableDefaultExpression colTypeList -colType +columnType createOrReplaceTableColTypeList createOrReplaceTableColType colDefinitionOption @@ -986,7 +986,7 @@ backQuotedIdentifier number alterColumnAction stringLit -comment +commentStr version ansiNonReserved strictNonReserved diff --git a/src/lib/spark/SparkSqlParser.ts b/src/lib/spark/SparkSqlParser.ts index f842a2f5..c9bb86bd 100644 --- a/src/lib/spark/SparkSqlParser.ts +++ b/src/lib/spark/SparkSqlParser.ts @@ -578,7 +578,7 @@ export class SparkSqlParser extends SQLParserBase { public static readonly RULE_defaultExpression = 165; public static readonly RULE_variableDefaultExpression = 166; public static readonly RULE_colTypeList = 167; - public static readonly RULE_colType = 168; + public static readonly RULE_columnType = 168; public static readonly RULE_createOrReplaceTableColTypeList = 169; public static readonly RULE_createOrReplaceTableColType = 170; public static readonly RULE_colDefinitionOption = 171; @@ -605,7 +605,7 @@ export class SparkSqlParser extends SQLParserBase { public static readonly RULE_number = 192; public static readonly RULE_alterColumnAction = 193; public static readonly RULE_stringLit = 194; - public static readonly RULE_comment = 195; + public static readonly RULE_commentStr = 195; public static readonly RULE_version = 196; public static readonly RULE_ansiNonReserved = 197; public static readonly RULE_strictNonReserved = 198; @@ -803,14 +803,14 @@ export class SparkSqlParser extends SQLParserBase { "qualifiedColTypeWithPositionForAdd", "qualifiedColTypeWithPositionSeqForReplace", "qualifiedColTypeWithPositionForReplace", "colDefinitionDescriptorWithPosition", "defaultExpression", "variableDefaultExpression", "colTypeList", - "colType", "createOrReplaceTableColTypeList", "createOrReplaceTableColType", + "columnType", "createOrReplaceTableColTypeList", "createOrReplaceTableColType", "colDefinitionOption", "generationExpression", "complexColTypeList", "complexColType", "whenClause", "windowClause", "zorderClause", "namedWindow", "windowSpec", "windowFrame", "frameBound", "qualifiedNameList", "functionName", "functionNameCreate", "qualifiedName", "errorCapturingIdentifier", "errorCapturingIdentifierExtra", "identifier", "strictIdentifier", "quotedIdentifier", "backQuotedIdentifier", "number", "alterColumnAction", - "stringLit", "comment", "version", "ansiNonReserved", "strictNonReserved", + "stringLit", "commentStr", "version", "ansiNonReserved", "strictNonReserved", "nonReserved", ]; @@ -1790,7 +1790,7 @@ export class SparkSqlParser extends SQLParserBase { this.state = 664; (localContext as HiveChangeColumnContext)._colName = this.columnName(); this.state = 665; - this.colType(); + this.columnType(); this.state = 667; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -3385,7 +3385,7 @@ export class SparkSqlParser extends SQLParserBase { this.state = 1116; this.match(SparkSqlParser.KW_IS); this.state = 1117; - this.comment(); + this.commentStr(); } break; case 64: @@ -3403,7 +3403,7 @@ export class SparkSqlParser extends SQLParserBase { this.state = 1123; this.match(SparkSqlParser.KW_IS); this.state = 1124; - this.comment(); + this.commentStr(); } break; case 65: @@ -5058,7 +5058,7 @@ export class SparkSqlParser extends SQLParserBase { this.state = 1566; this.match(SparkSqlParser.KW_COMMENT); this.state = 1567; - this.stringLit(); + localContext._comment = this.stringLit(); } } catch (re) { @@ -12854,7 +12854,7 @@ export class SparkSqlParser extends SQLParserBase { break; } this.state = 2900; - this.strictIdentifier(); + localContext._alias = this.strictIdentifier(); this.state = 2902; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 375, this.context) ) { @@ -13803,7 +13803,7 @@ export class SparkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 2); { this.state = 3033; - this.colType(); + this.columnType(); } break; } @@ -16954,7 +16954,7 @@ export class SparkSqlParser extends SQLParserBase { this.enterOuterAlt(localContext, 1); { this.state = 3680; - this.colType(); + this.columnType(); this.state = 3685; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 475, this.context); @@ -16965,7 +16965,7 @@ export class SparkSqlParser extends SQLParserBase { this.state = 3681; this.match(SparkSqlParser.COMMA); this.state = 3682; - this.colType(); + this.columnType(); } } } @@ -16989,9 +16989,9 @@ export class SparkSqlParser extends SQLParserBase { } return localContext; } - public colType(): ColTypeContext { - let localContext = new ColTypeContext(this.context, this.state); - this.enterRule(localContext, 336, SparkSqlParser.RULE_colType); + public columnType(): ColumnTypeContext { + let localContext = new ColumnTypeContext(this.context, this.state); + this.enterRule(localContext, 336, SparkSqlParser.RULE_columnType); try { this.enterOuterAlt(localContext, 1); { @@ -17088,7 +17088,7 @@ export class SparkSqlParser extends SQLParserBase { this.state = 3705; localContext._colName = this.columnNameCreate(); this.state = 3706; - this.dataType(); + localContext._colType = this.dataType(); this.state = 3710; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -18474,9 +18474,9 @@ export class SparkSqlParser extends SQLParserBase { } return localContext; } - public comment(): CommentContext { - let localContext = new CommentContext(this.context, this.state); - this.enterRule(localContext, 390, SparkSqlParser.RULE_comment); + public commentStr(): CommentStrContext { + let localContext = new CommentStrContext(this.context, this.state); + this.enterRule(localContext, 390, SparkSqlParser.RULE_commentStr); try { this.state = 3958; this.errorHandler.sync(this); @@ -22353,8 +22353,8 @@ export class CommentNamespaceContext extends StatementContext { public KW_IS(): antlr.TerminalNode { return this.getToken(SparkSqlParser.KW_IS, 0)!; } - public comment(): CommentContext { - return this.getRuleContext(0, CommentContext)!; + public commentStr(): CommentStrContext { + return this.getRuleContext(0, CommentStrContext)!; } public override enterRule(listener: SparkSqlParserListener): void { if(listener.enterCommentNamespace) { @@ -23024,8 +23024,8 @@ export class HiveChangeColumnContext extends StatementContext { public KW_CHANGE(): antlr.TerminalNode { return this.getToken(SparkSqlParser.KW_CHANGE, 0)!; } - public colType(): ColTypeContext { - return this.getRuleContext(0, ColTypeContext)!; + public columnType(): ColumnTypeContext { + return this.getRuleContext(0, ColumnTypeContext)!; } public tableName(): TableNameContext { return this.getRuleContext(0, TableNameContext)!; @@ -23882,8 +23882,8 @@ export class CommentTableContext extends StatementContext { public KW_IS(): antlr.TerminalNode { return this.getToken(SparkSqlParser.KW_IS, 0)!; } - public comment(): CommentContext { - return this.getRuleContext(0, CommentContext)!; + public commentStr(): CommentStrContext { + return this.getRuleContext(0, CommentStrContext)!; } public override enterRule(listener: SparkSqlParserListener): void { if(listener.enterCommentTable) { @@ -25197,6 +25197,7 @@ export class LocationSpecContext extends antlr.ParserRuleContext { export class CommentSpecContext extends antlr.ParserRuleContext { + public _comment?: StringLitContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -30588,6 +30589,7 @@ export class FunctionTableContext extends antlr.ParserRuleContext { export class TableAliasContext extends antlr.ParserRuleContext { + public _alias?: StrictIdentifierContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -31140,8 +31142,8 @@ export class PartitionFieldContext extends antlr.ParserRuleContext { public transform(): TransformContext | null { return this.getRuleContext(0, TransformContext); } - public colType(): ColTypeContext | null { - return this.getRuleContext(0, ColTypeContext); + public columnType(): ColumnTypeContext | null { + return this.getRuleContext(0, ColumnTypeContext); } public override get ruleIndex(): number { return SparkSqlParser.RULE_partitionField; @@ -33319,14 +33321,14 @@ export class ColTypeListContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public colType(): ColTypeContext[]; - public colType(i: number): ColTypeContext | null; - public colType(i?: number): ColTypeContext[] | ColTypeContext | null { + public columnType(): ColumnTypeContext[]; + public columnType(i: number): ColumnTypeContext | null; + public columnType(i?: number): ColumnTypeContext[] | ColumnTypeContext | null { if (i === undefined) { - return this.getRuleContexts(ColTypeContext); + return this.getRuleContexts(ColumnTypeContext); } - return this.getRuleContext(i, ColTypeContext); + return this.getRuleContext(i, ColumnTypeContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -33360,7 +33362,7 @@ export class ColTypeListContext extends antlr.ParserRuleContext { } -export class ColTypeContext extends antlr.ParserRuleContext { +export class ColumnTypeContext extends antlr.ParserRuleContext { public _colName?: ErrorCapturingIdentifierContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -33381,21 +33383,21 @@ export class ColTypeContext extends antlr.ParserRuleContext { return this.getRuleContext(0, CommentSpecContext); } public override get ruleIndex(): number { - return SparkSqlParser.RULE_colType; + return SparkSqlParser.RULE_columnType; } public override enterRule(listener: SparkSqlParserListener): void { - if(listener.enterColType) { - listener.enterColType(this); + if(listener.enterColumnType) { + listener.enterColumnType(this); } } public override exitRule(listener: SparkSqlParserListener): void { - if(listener.exitColType) { - listener.exitColType(this); + if(listener.exitColumnType) { + listener.exitColumnType(this); } } public override accept(visitor: SparkSqlParserVisitor): Result | null { - if (visitor.visitColType) { - return visitor.visitColType(this); + if (visitor.visitColumnType) { + return visitor.visitColumnType(this); } else { return visitor.visitChildren(this); } @@ -33450,15 +33452,16 @@ export class CreateOrReplaceTableColTypeListContext extends antlr.ParserRuleCont export class CreateOrReplaceTableColTypeContext extends antlr.ParserRuleContext { public _colName?: ColumnNameCreateContext; + public _colType?: DataTypeContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public dataType(): DataTypeContext { - return this.getRuleContext(0, DataTypeContext)!; - } public columnNameCreate(): ColumnNameCreateContext { return this.getRuleContext(0, ColumnNameCreateContext)!; } + public dataType(): DataTypeContext { + return this.getRuleContext(0, DataTypeContext)!; + } public colDefinitionOption(): ColDefinitionOptionContext[]; public colDefinitionOption(i: number): ColDefinitionOptionContext | null; public colDefinitionOption(i?: number): ColDefinitionOptionContext[] | ColDefinitionOptionContext | null { @@ -34556,7 +34559,7 @@ export class StringLitContext extends antlr.ParserRuleContext { } -export class CommentContext extends antlr.ParserRuleContext { +export class CommentStrContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -34567,21 +34570,21 @@ export class CommentContext extends antlr.ParserRuleContext { return this.getToken(SparkSqlParser.KW_NULL, 0); } public override get ruleIndex(): number { - return SparkSqlParser.RULE_comment; + return SparkSqlParser.RULE_commentStr; } public override enterRule(listener: SparkSqlParserListener): void { - if(listener.enterComment) { - listener.enterComment(this); + if(listener.enterCommentStr) { + listener.enterCommentStr(this); } } public override exitRule(listener: SparkSqlParserListener): void { - if(listener.exitComment) { - listener.exitComment(this); + if(listener.exitCommentStr) { + listener.exitCommentStr(this); } } public override accept(visitor: SparkSqlParserVisitor): Result | null { - if (visitor.visitComment) { - return visitor.visitComment(this); + if (visitor.visitCommentStr) { + return visitor.visitCommentStr(this); } else { return visitor.visitChildren(this); } diff --git a/src/lib/spark/SparkSqlParserListener.ts b/src/lib/spark/SparkSqlParserListener.ts index a304ff65..b701ea6a 100644 --- a/src/lib/spark/SparkSqlParserListener.ts +++ b/src/lib/spark/SparkSqlParserListener.ts @@ -270,7 +270,7 @@ import { ColDefinitionDescriptorWithPositionContext } from "./SparkSqlParser.js" import { DefaultExpressionContext } from "./SparkSqlParser.js"; import { VariableDefaultExpressionContext } from "./SparkSqlParser.js"; import { ColTypeListContext } from "./SparkSqlParser.js"; -import { ColTypeContext } from "./SparkSqlParser.js"; +import { ColumnTypeContext } from "./SparkSqlParser.js"; import { CreateOrReplaceTableColTypeListContext } from "./SparkSqlParser.js"; import { CreateOrReplaceTableColTypeContext } from "./SparkSqlParser.js"; import { ColDefinitionOptionContext } from "./SparkSqlParser.js"; @@ -297,7 +297,7 @@ import { BackQuotedIdentifierContext } from "./SparkSqlParser.js"; import { NumberContext } from "./SparkSqlParser.js"; import { AlterColumnActionContext } from "./SparkSqlParser.js"; import { StringLitContext } from "./SparkSqlParser.js"; -import { CommentContext } from "./SparkSqlParser.js"; +import { CommentStrContext } from "./SparkSqlParser.js"; import { VersionContext } from "./SparkSqlParser.js"; import { AnsiNonReservedContext } from "./SparkSqlParser.js"; import { StrictNonReservedContext } from "./SparkSqlParser.js"; @@ -3124,15 +3124,15 @@ export class SparkSqlParserListener implements ParseTreeListener { */ exitColTypeList?: (ctx: ColTypeListContext) => void; /** - * Enter a parse tree produced by `SparkSqlParser.colType`. + * Enter a parse tree produced by `SparkSqlParser.columnType`. * @param ctx the parse tree */ - enterColType?: (ctx: ColTypeContext) => void; + enterColumnType?: (ctx: ColumnTypeContext) => void; /** - * Exit a parse tree produced by `SparkSqlParser.colType`. + * Exit a parse tree produced by `SparkSqlParser.columnType`. * @param ctx the parse tree */ - exitColType?: (ctx: ColTypeContext) => void; + exitColumnType?: (ctx: ColumnTypeContext) => void; /** * Enter a parse tree produced by `SparkSqlParser.createOrReplaceTableColTypeList`. * @param ctx the parse tree @@ -3394,15 +3394,15 @@ export class SparkSqlParserListener implements ParseTreeListener { */ exitStringLit?: (ctx: StringLitContext) => void; /** - * Enter a parse tree produced by `SparkSqlParser.comment`. + * Enter a parse tree produced by `SparkSqlParser.commentStr`. * @param ctx the parse tree */ - enterComment?: (ctx: CommentContext) => void; + enterCommentStr?: (ctx: CommentStrContext) => void; /** - * Exit a parse tree produced by `SparkSqlParser.comment`. + * Exit a parse tree produced by `SparkSqlParser.commentStr`. * @param ctx the parse tree */ - exitComment?: (ctx: CommentContext) => void; + exitCommentStr?: (ctx: CommentStrContext) => void; /** * Enter a parse tree produced by `SparkSqlParser.version`. * @param ctx the parse tree diff --git a/src/lib/spark/SparkSqlParserVisitor.ts b/src/lib/spark/SparkSqlParserVisitor.ts index cec7c43a..f2570994 100644 --- a/src/lib/spark/SparkSqlParserVisitor.ts +++ b/src/lib/spark/SparkSqlParserVisitor.ts @@ -270,7 +270,7 @@ import { ColDefinitionDescriptorWithPositionContext } from "./SparkSqlParser.js" import { DefaultExpressionContext } from "./SparkSqlParser.js"; import { VariableDefaultExpressionContext } from "./SparkSqlParser.js"; import { ColTypeListContext } from "./SparkSqlParser.js"; -import { ColTypeContext } from "./SparkSqlParser.js"; +import { ColumnTypeContext } from "./SparkSqlParser.js"; import { CreateOrReplaceTableColTypeListContext } from "./SparkSqlParser.js"; import { CreateOrReplaceTableColTypeContext } from "./SparkSqlParser.js"; import { ColDefinitionOptionContext } from "./SparkSqlParser.js"; @@ -297,7 +297,7 @@ import { BackQuotedIdentifierContext } from "./SparkSqlParser.js"; import { NumberContext } from "./SparkSqlParser.js"; import { AlterColumnActionContext } from "./SparkSqlParser.js"; import { StringLitContext } from "./SparkSqlParser.js"; -import { CommentContext } from "./SparkSqlParser.js"; +import { CommentStrContext } from "./SparkSqlParser.js"; import { VersionContext } from "./SparkSqlParser.js"; import { AnsiNonReservedContext } from "./SparkSqlParser.js"; import { StrictNonReservedContext } from "./SparkSqlParser.js"; @@ -1982,11 +1982,11 @@ export class SparkSqlParserVisitor extends AbstractParseTreeVisitor Result; /** - * Visit a parse tree produced by `SparkSqlParser.colType`. + * Visit a parse tree produced by `SparkSqlParser.columnType`. * @param ctx the parse tree * @return the visitor result */ - visitColType?: (ctx: ColTypeContext) => Result; + visitColumnType?: (ctx: ColumnTypeContext) => Result; /** * Visit a parse tree produced by `SparkSqlParser.createOrReplaceTableColTypeList`. * @param ctx the parse tree @@ -2144,11 +2144,11 @@ export class SparkSqlParserVisitor extends AbstractParseTreeVisitor Result; /** - * Visit a parse tree produced by `SparkSqlParser.comment`. + * Visit a parse tree produced by `SparkSqlParser.commentStr`. * @param ctx the parse tree * @return the visitor result */ - visitComment?: (ctx: CommentContext) => Result; + visitCommentStr?: (ctx: CommentStrContext) => Result; /** * Visit a parse tree produced by `SparkSqlParser.version`. * @param ctx the parse tree diff --git a/src/lib/sql/SqlLexer.interp b/src/lib/sql/SqlLexer.interp new file mode 100644 index 00000000..6b04808c --- /dev/null +++ b/src/lib/sql/SqlLexer.interp @@ -0,0 +1,1197 @@ +token literal names: +null +';' +'(' +')' +',' +'.' +'[' +']' +'ADD' +'AFTER' +'ALL' +'ALTER' +'ALWAYS' +'ANALYZE' +'AND' +'ANTI' +'ANY' +'ANY_VALUE' +'ARCHIVE' +'ARRAY' +'AS' +'ASC' +'AT' +'AUTHORIZATION' +'BETWEEN' +'BIGINT' +'BINARY' +'BOOLEAN' +'BOTH' +'BUCKET' +'BUCKETS' +'BY' +'BYTE' +'CACHE' +'CASCADE' +'CASE' +'CAST' +'CATALOG' +'CATALOGS' +'CHANGE' +'CHAR' +'CHARACTER' +'CHECK' +'CLEAR' +'CLUSTER' +'CLUSTERED' +'CODEGEN' +'COLLATE' +'COLLECTION' +'COLUMN' +'COLUMNS' +'COMMENT' +'COMMIT' +'COMPACT' +'COMPACTIONS' +'COMPUTE' +'CONCATENATE' +'CONSTRAINT' +'COST' +'CREATE' +'CROSS' +'CUBE' +'CURRENT' +'CURRENT_DATE' +'CURRENT_TIME' +'CURRENT_TIMESTAMP' +'CURRENT_USER' +'DAY' +'DAYS' +'DAYOFYEAR' +'DATA' +'DATE' +'DATABASE' +'DATABASES' +'DATEADD' +'DATE_ADD' +'DATEDIFF' +'DATE_DIFF' +'DBPROPERTIES' +'DEC' +'DECIMAL' +'DECLARE' +'DEFAULT' +'DEFINED' +'DELETE' +'DELIMITED' +'DESC' +'DESCRIBE' +'DFS' +'DIRECTORIES' +'DIRECTORY' +'DISABLE' +'DISTINCT' +'DISTRIBUTE' +'DIV' +'DOUBLE' +'DROP' +'ELSE' +'ENABLE' +'END' +'ESCAPE' +'ESCAPED' +'EXCEPT' +'EXCHANGE' +'EXCLUDE' +'EXISTS' +'EXPLAIN' +'EXPORT' +'EXTENDED' +'EXTERNAL' +'EXTRACT' +'FALSE' +'FETCH' +'FIELDS' +'FILTER' +'FILEFORMAT' +'FIRST' +'FLOAT' +'FOLLOWING' +'FOR' +'FOREIGN' +'FORMAT' +'FORMATTED' +'FROM' +'FULL' +'FUNCTION' +'FUNCTIONS' +'GENERATED' +'GLOBAL' +'GRANT' +'GROUP' +'GROUPING' +'HAVING' +'X' +'HOUR' +'HOURS' +'IDENTIFIER' +'IF' +'IGNORE' +'IMPORT' +'IN' +'INCLUDE' +'INDEX' +'INDEXES' +'INNER' +'INPATH' +'INPUTFORMAT' +'INSERT' +'INTERSECT' +'INTERVAL' +'INT' +'INTEGER' +'INTO' +'IS' +'ITEMS' +'JOIN' +'KEYS' +'LAST' +'LATERAL' +'LAZY' +'LEADING' +'LEFT' +'LIFECYCLE' +'LIKE' +'ILIKE' +'LIMIT' +'LINES' +'LIST' +'LOAD' +'LOCAL' +'LOCATION' +'LOCK' +'LOCKS' +'LOGICAL' +'LONG' +'MACRO' +'MAP' +'MATCHED' +'MERGE' +'MICROSECOND' +'MICROSECONDS' +'MILLISECOND' +'MILLISECONDS' +'MINUTE' +'MINUTES' +'MONTH' +'MONTHS' +'MSCK' +'NAME' +'NAMESPACE' +'NAMESPACES' +'NANOSECOND' +'NANOSECONDS' +'NATURAL' +'NO' +'NOSCAN' +'NOT' +'NULL' +'NULLS' +'NUMERIC' +'OF' +'OFFSET' +'ON' +'ONLY' +'OPTIMIZE' +'OPTION' +'OPTIONS' +'OR' +'ORDER' +'OUT' +'OUTER' +'OUTPUTFORMAT' +'OVER' +'OVERLAPS' +'OVERLAY' +'OVERWRITE' +'PARTITION' +'PARTITIONED' +'PARTITIONS' +'PERCENTILE_CONT' +'PERCENTILE_DISC' +'PERCENT' +'PIVOT' +'PLACING' +'POSITION' +'PRECEDING' +'PRIMARY' +'PRINCIPALS' +'PROPERTIES' +'PURGE' +'QUARTER' +'QUERY' +'RANGE' +'REAL' +'RECORDREADER' +'RECORDWRITER' +'RECOVER' +'REDUCE' +'REFERENCES' +'REFRESH' +'RENAME' +'REPAIR' +'REPEATABLE' +'REPLACE' +'RESET' +'RESPECT' +'RESTRICT' +'REWRITE' +'REVOKE' +'RIGHT' +'RLIKE' +'REGEXP' +'ROLE' +'ROLES' +'ROLLBACK' +'ROLLUP' +'ROW' +'ROWS' +'SECOND' +'SECONDS' +'SCHEMA' +'SCHEMAS' +'SELECT' +'SEMI' +'SEPARATED' +'SERDE' +'SERDEPROPERTIES' +'SESSION_USER' +'SET' +'MINUS' +'SETS' +'SHORT' +'SHOW' +'SINGLE' +'SKEWED' +'SMALLINT' +'SOME' +'SORT' +'SORTED' +'SOURCE' +'START' +'STATISTICS' +'STORED' +'STRATIFY' +'STRING' +'STRUCT' +'SUBSTR' +'SUBSTRING' +'SYNC' +'SYSTEM' +'SYSTEM_TIME' +'SYSTEM_VERSION' +'TABLE' +'TABLES' +'TABLESAMPLE' +'TARGET' +'TBLPROPERTIES' +'TEMPORARY' +'TERMINATED' +'THEN' +'TIME' +'TIMEDIFF' +'TIMESTAMP' +'TIMESTAMP_LTZ' +'TIMESTAMP_NTZ' +'TIMESTAMPADD' +'TIMESTAMPDIFF' +'TINYINT' +'TO' +'TOUCH' +'TRAILING' +'TRANSACTION' +'TRANSACTIONS' +'TRANSFORM' +'TRIM' +'TRUE' +'TRUNCATE' +'TRY_CAST' +'TYPE' +'UNARCHIVE' +'UNBOUNDED' +'UNCACHE' +'UNION' +'UNIQUE' +'UNKNOWN' +'UNLOCK' +'UNPIVOT' +'UNSET' +'UPDATE' +'USE' +'USER' +'USING' +'VALUES' +'VARCHAR' +'VAR' +'VARIABLE' +'VERSION' +'VIEW' +'VIEWS' +'VOID' +'WEEK' +'WEEKS' +'WHEN' +'WHERE' +'WINDOW' +'WITH' +'WITHIN' +'YEAR' +'YEARS' +'ZONE' +'ZORDER' +null +'<=>' +'<>' +'!=' +'<' +null +'>' +null +'!' +'+' +'-' +'*' +'/' +'%' +'~' +'&' +'|' +'||' +'^' +':' +'->' +'=>' +'/*+' +'*/' +'?' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +SEMICOLON +LEFT_PAREN +RIGHT_PAREN +COMMA +DOT +LEFT_BRACKET +RIGHT_BRACKET +KW_ADD +KW_AFTER +KW_ALL +KW_ALTER +KW_ALWAYS +KW_ANALYZE +KW_AND +KW_ANTI +KW_ANY +KW_ANY_VALUE +KW_ARCHIVE +KW_ARRAY +KW_AS +KW_ASC +KW_AT +KW_AUTHORIZATION +KW_BETWEEN +KW_BIGINT +KW_BINARY +KW_BOOLEAN +KW_BOTH +KW_BUCKET +KW_BUCKETS +KW_BY +KW_BYTE +KW_CACHE +KW_CASCADE +KW_CASE +KW_CAST +KW_CATALOG +KW_CATALOGS +KW_CHANGE +KW_CHAR +KW_CHARACTER +KW_CHECK +KW_CLEAR +KW_CLUSTER +KW_CLUSTERED +KW_CODEGEN +KW_COLLATE +KW_COLLECTION +KW_COLUMN +KW_COLUMNS +KW_COMMENT +KW_COMMIT +KW_COMPACT +KW_COMPACTIONS +KW_COMPUTE +KW_CONCATENATE +KW_CONSTRAINT +KW_COST +KW_CREATE +KW_CROSS +KW_CUBE +KW_CURRENT +KW_CURRENT_DATE +KW_CURRENT_TIME +KW_CURRENT_TIMESTAMP +KW_CURRENT_USER +KW_DAY +KW_DAYS +KW_DAYOFYEAR +KW_DATA +KW_DATE +KW_DATABASE +KW_DATABASES +KW_DATEADD +KW_DATE_ADD +KW_DATEDIFF +KW_DATE_DIFF +KW_DBPROPERTIES +KW_DEC +KW_DECIMAL +KW_DECLARE +KW_DEFAULT +KW_DEFINED +KW_DELETE +KW_DELIMITED +KW_DESC +KW_DESCRIBE +KW_DFS +KW_DIRECTORIES +KW_DIRECTORY +KW_DISABLE +KW_DISTINCT +KW_DISTRIBUTE +KW_DIV +KW_DOUBLE +KW_DROP +KW_ELSE +KW_ENABLE +KW_END +KW_ESCAPE +KW_ESCAPED +KW_EXCEPT +KW_EXCHANGE +KW_EXCLUDE +KW_EXISTS +KW_EXPLAIN +KW_EXPORT +KW_EXTENDED +KW_EXTERNAL +KW_EXTRACT +KW_FALSE +KW_FETCH +KW_FIELDS +KW_FILTER +KW_FILEFORMAT +KW_FIRST +KW_FLOAT +KW_FOLLOWING +KW_FOR +KW_FOREIGN +KW_FORMAT +KW_FORMATTED +KW_FROM +KW_FULL +KW_FUNCTION +KW_FUNCTIONS +KW_GENERATED +KW_GLOBAL +KW_GRANT +KW_GROUP +KW_GROUPING +KW_HAVING +KW_BINARY_HEX +KW_HOUR +KW_HOURS +KW_IDENTIFIER +KW_IF +KW_IGNORE +KW_IMPORT +KW_IN +KW_INCLUDE +KW_INDEX +KW_INDEXES +KW_INNER +KW_INPATH +KW_INPUTFORMAT +KW_INSERT +KW_INTERSECT +KW_INTERVAL +KW_INT +KW_INTEGER +KW_INTO +KW_IS +KW_ITEMS +KW_JOIN +KW_KEYS +KW_LAST +KW_LATERAL +KW_LAZY +KW_LEADING +KW_LEFT +KW_LIFECYCLE +KW_LIKE +KW_ILIKE +KW_LIMIT +KW_LINES +KW_LIST +KW_LOAD +KW_LOCAL +KW_LOCATION +KW_LOCK +KW_LOCKS +KW_LOGICAL +KW_LONG +KW_MACRO +KW_MAP +KW_MATCHED +KW_MERGE +KW_MICROSECOND +KW_MICROSECONDS +KW_MILLISECOND +KW_MILLISECONDS +KW_MINUTE +KW_MINUTES +KW_MONTH +KW_MONTHS +KW_MSCK +KW_NAME +KW_NAMESPACE +KW_NAMESPACES +KW_NANOSECOND +KW_NANOSECONDS +KW_NATURAL +KW_NO +KW_NOSCAN +KW_NOT +KW_NULL +KW_NULLS +KW_NUMERIC +KW_OF +KW_OFFSET +KW_ON +KW_ONLY +KW_OPTIMIZE +KW_OPTION +KW_OPTIONS +KW_OR +KW_ORDER +KW_OUT +KW_OUTER +KW_OUTPUTFORMAT +KW_OVER +KW_OVERLAPS +KW_OVERLAY +KW_OVERWRITE +KW_PARTITION +KW_PARTITIONED +KW_PARTITIONS +KW_PERCENTILE_CONT +KW_PERCENTILE_DISC +KW_PERCENTLIT +KW_PIVOT +KW_PLACING +KW_POSITION +KW_PRECEDING +KW_PRIMARY +KW_PRINCIPALS +KW_PROPERTIES +KW_PURGE +KW_QUARTER +KW_QUERY +KW_RANGE +KW_REAL +KW_RECORDREADER +KW_RECORDWRITER +KW_RECOVER +KW_REDUCE +KW_REFERENCES +KW_REFRESH +KW_RENAME +KW_REPAIR +KW_REPEATABLE +KW_REPLACE +KW_RESET +KW_RESPECT +KW_RESTRICT +KW_REWRITE +KW_REVOKE +KW_RIGHT +KW_RLIKE +KW_REGEXP +KW_ROLE +KW_ROLES +KW_ROLLBACK +KW_ROLLUP +KW_ROW +KW_ROWS +KW_SECOND +KW_SECONDS +KW_SCHEMA +KW_SCHEMAS +KW_SELECT +KW_SEMI +KW_SEPARATED +KW_SERDE +KW_SERDEPROPERTIES +KW_SESSION_USER +KW_SET +KW_MINUS +KW_SETS +KW_SHORT +KW_SHOW +KW_SINGLE +KW_SKEWED +KW_SMALLINT +KW_SOME +KW_SORT +KW_SORTED +KW_SOURCE +KW_START +KW_STATISTICS +KW_STORED +KW_STRATIFY +KW_STRING +KW_STRUCT +KW_SUBSTR +KW_SUBSTRING +KW_SYNC +KW_SYSTEM +KW_SYSTEM_TIME +KW_SYSTEM_VERSION +KW_TABLE +KW_TABLES +KW_TABLESAMPLE +KW_TARGET +KW_TBLPROPERTIES +KW_TEMPORARY +KW_TERMINATED +KW_THEN +KW_TIME +KW_TIMEDIFF +KW_TIMESTAMP +KW_TIMESTAMP_LTZ +KW_TIMESTAMP_NTZ +KW_TIMESTAMPADD +KW_TIMESTAMPDIFF +KW_TINYINT +KW_TO +KW_TOUCH +KW_TRAILING +KW_TRANSACTION +KW_TRANSACTIONS +KW_TRANSFORM +KW_TRIM +KW_TRUE +KW_TRUNCATE +KW_TRY_CAST +KW_TYPE +KW_UNARCHIVE +KW_UNBOUNDED +KW_UNCACHE +KW_UNION +KW_UNIQUE +KW_UNKNOWN +KW_UNLOCK +KW_UNPIVOT +KW_UNSET +KW_UPDATE +KW_USE +KW_USER +KW_USING +KW_VALUES +KW_VARCHAR +KW_VAR +KW_VARIABLE +KW_VERSION +KW_VIEW +KW_VIEWS +KW_VOID +KW_WEEK +KW_WEEKS +KW_WHEN +KW_WHERE +KW_WINDOW +KW_WITH +KW_WITHIN +KW_YEAR +KW_YEARS +KW_ZONE +KW_ZORDER +EQ +NSEQ +NEQ +NEQJ +LT +LTE +GT +GTE +NOT +PLUS +MINUS +ASTERISK +SLASH +PERCENT +TILDE +AMPERSAND +PIPE +CONCAT_PIPE +HAT +COLON +ARROW +FAT_ARROW +HENT_START +HENT_END +QUESTION +STRING_LITERAL +DOUBLEQUOTED_STRING +BIGINT_LITERAL +SMALLINT_LITERAL +TINYINT_LITERAL +INTEGER_VALUE +EXPONENT_VALUE +DECIMAL_VALUE +FLOAT_LITERAL +DOUBLE_LITERAL +BIGDECIMAL_LITERAL +IDENTIFIER +BACKQUOTED_IDENTIFIER +SIMPLE_COMMENT +BRACKETED_COMMENT +WS +UNRECOGNIZED + +rule names: +SEMICOLON +LEFT_PAREN +RIGHT_PAREN +COMMA +DOT +LEFT_BRACKET +RIGHT_BRACKET +KW_ADD +KW_AFTER +KW_ALL +KW_ALTER +KW_ALWAYS +KW_ANALYZE +KW_AND +KW_ANTI +KW_ANY +KW_ANY_VALUE +KW_ARCHIVE +KW_ARRAY +KW_AS +KW_ASC +KW_AT +KW_AUTHORIZATION +KW_BETWEEN +KW_BIGINT +KW_BINARY +KW_BOOLEAN +KW_BOTH +KW_BUCKET +KW_BUCKETS +KW_BY +KW_BYTE +KW_CACHE +KW_CASCADE +KW_CASE +KW_CAST +KW_CATALOG +KW_CATALOGS +KW_CHANGE +KW_CHAR +KW_CHARACTER +KW_CHECK +KW_CLEAR +KW_CLUSTER +KW_CLUSTERED +KW_CODEGEN +KW_COLLATE +KW_COLLECTION +KW_COLUMN +KW_COLUMNS +KW_COMMENT +KW_COMMIT +KW_COMPACT +KW_COMPACTIONS +KW_COMPUTE +KW_CONCATENATE +KW_CONSTRAINT +KW_COST +KW_CREATE +KW_CROSS +KW_CUBE +KW_CURRENT +KW_CURRENT_DATE +KW_CURRENT_TIME +KW_CURRENT_TIMESTAMP +KW_CURRENT_USER +KW_DAY +KW_DAYS +KW_DAYOFYEAR +KW_DATA +KW_DATE +KW_DATABASE +KW_DATABASES +KW_DATEADD +KW_DATE_ADD +KW_DATEDIFF +KW_DATE_DIFF +KW_DBPROPERTIES +KW_DEC +KW_DECIMAL +KW_DECLARE +KW_DEFAULT +KW_DEFINED +KW_DELETE +KW_DELIMITED +KW_DESC +KW_DESCRIBE +KW_DFS +KW_DIRECTORIES +KW_DIRECTORY +KW_DISABLE +KW_DISTINCT +KW_DISTRIBUTE +KW_DIV +KW_DOUBLE +KW_DROP +KW_ELSE +KW_ENABLE +KW_END +KW_ESCAPE +KW_ESCAPED +KW_EXCEPT +KW_EXCHANGE +KW_EXCLUDE +KW_EXISTS +KW_EXPLAIN +KW_EXPORT +KW_EXTENDED +KW_EXTERNAL +KW_EXTRACT +KW_FALSE +KW_FETCH +KW_FIELDS +KW_FILTER +KW_FILEFORMAT +KW_FIRST +KW_FLOAT +KW_FOLLOWING +KW_FOR +KW_FOREIGN +KW_FORMAT +KW_FORMATTED +KW_FROM +KW_FULL +KW_FUNCTION +KW_FUNCTIONS +KW_GENERATED +KW_GLOBAL +KW_GRANT +KW_GROUP +KW_GROUPING +KW_HAVING +KW_BINARY_HEX +KW_HOUR +KW_HOURS +KW_IDENTIFIER +KW_IF +KW_IGNORE +KW_IMPORT +KW_IN +KW_INCLUDE +KW_INDEX +KW_INDEXES +KW_INNER +KW_INPATH +KW_INPUTFORMAT +KW_INSERT +KW_INTERSECT +KW_INTERVAL +KW_INT +KW_INTEGER +KW_INTO +KW_IS +KW_ITEMS +KW_JOIN +KW_KEYS +KW_LAST +KW_LATERAL +KW_LAZY +KW_LEADING +KW_LEFT +KW_LIFECYCLE +KW_LIKE +KW_ILIKE +KW_LIMIT +KW_LINES +KW_LIST +KW_LOAD +KW_LOCAL +KW_LOCATION +KW_LOCK +KW_LOCKS +KW_LOGICAL +KW_LONG +KW_MACRO +KW_MAP +KW_MATCHED +KW_MERGE +KW_MICROSECOND +KW_MICROSECONDS +KW_MILLISECOND +KW_MILLISECONDS +KW_MINUTE +KW_MINUTES +KW_MONTH +KW_MONTHS +KW_MSCK +KW_NAME +KW_NAMESPACE +KW_NAMESPACES +KW_NANOSECOND +KW_NANOSECONDS +KW_NATURAL +KW_NO +KW_NOSCAN +KW_NOT +KW_NULL +KW_NULLS +KW_NUMERIC +KW_OF +KW_OFFSET +KW_ON +KW_ONLY +KW_OPTIMIZE +KW_OPTION +KW_OPTIONS +KW_OR +KW_ORDER +KW_OUT +KW_OUTER +KW_OUTPUTFORMAT +KW_OVER +KW_OVERLAPS +KW_OVERLAY +KW_OVERWRITE +KW_PARTITION +KW_PARTITIONED +KW_PARTITIONS +KW_PERCENTILE_CONT +KW_PERCENTILE_DISC +KW_PERCENTLIT +KW_PIVOT +KW_PLACING +KW_POSITION +KW_PRECEDING +KW_PRIMARY +KW_PRINCIPALS +KW_PROPERTIES +KW_PURGE +KW_QUARTER +KW_QUERY +KW_RANGE +KW_REAL +KW_RECORDREADER +KW_RECORDWRITER +KW_RECOVER +KW_REDUCE +KW_REFERENCES +KW_REFRESH +KW_RENAME +KW_REPAIR +KW_REPEATABLE +KW_REPLACE +KW_RESET +KW_RESPECT +KW_RESTRICT +KW_REWRITE +KW_REVOKE +KW_RIGHT +KW_RLIKE +KW_REGEXP +KW_ROLE +KW_ROLES +KW_ROLLBACK +KW_ROLLUP +KW_ROW +KW_ROWS +KW_SECOND +KW_SECONDS +KW_SCHEMA +KW_SCHEMAS +KW_SELECT +KW_SEMI +KW_SEPARATED +KW_SERDE +KW_SERDEPROPERTIES +KW_SESSION_USER +KW_SET +KW_MINUS +KW_SETS +KW_SHORT +KW_SHOW +KW_SINGLE +KW_SKEWED +KW_SMALLINT +KW_SOME +KW_SORT +KW_SORTED +KW_SOURCE +KW_START +KW_STATISTICS +KW_STORED +KW_STRATIFY +KW_STRING +KW_STRUCT +KW_SUBSTR +KW_SUBSTRING +KW_SYNC +KW_SYSTEM +KW_SYSTEM_TIME +KW_SYSTEM_VERSION +KW_TABLE +KW_TABLES +KW_TABLESAMPLE +KW_TARGET +KW_TBLPROPERTIES +KW_TEMPORARY +KW_TERMINATED +KW_THEN +KW_TIME +KW_TIMEDIFF +KW_TIMESTAMP +KW_TIMESTAMP_LTZ +KW_TIMESTAMP_NTZ +KW_TIMESTAMPADD +KW_TIMESTAMPDIFF +KW_TINYINT +KW_TO +KW_TOUCH +KW_TRAILING +KW_TRANSACTION +KW_TRANSACTIONS +KW_TRANSFORM +KW_TRIM +KW_TRUE +KW_TRUNCATE +KW_TRY_CAST +KW_TYPE +KW_UNARCHIVE +KW_UNBOUNDED +KW_UNCACHE +KW_UNION +KW_UNIQUE +KW_UNKNOWN +KW_UNLOCK +KW_UNPIVOT +KW_UNSET +KW_UPDATE +KW_USE +KW_USER +KW_USING +KW_VALUES +KW_VARCHAR +KW_VAR +KW_VARIABLE +KW_VERSION +KW_VIEW +KW_VIEWS +KW_VOID +KW_WEEK +KW_WEEKS +KW_WHEN +KW_WHERE +KW_WINDOW +KW_WITH +KW_WITHIN +KW_YEAR +KW_YEARS +KW_ZONE +KW_ZORDER +EQ +NSEQ +NEQ +NEQJ +LT +LTE +GT +GTE +NOT +PLUS +MINUS +ASTERISK +SLASH +PERCENT +TILDE +AMPERSAND +PIPE +CONCAT_PIPE +HAT +COLON +ARROW +FAT_ARROW +HENT_START +HENT_END +QUESTION +STRING_LITERAL +DOUBLEQUOTED_STRING +BIGINT_LITERAL +SMALLINT_LITERAL +TINYINT_LITERAL +INTEGER_VALUE +EXPONENT_VALUE +DECIMAL_VALUE +FLOAT_LITERAL +DOUBLE_LITERAL +BIGDECIMAL_LITERAL +IDENTIFIER +BACKQUOTED_IDENTIFIER +DECIMAL_DIGITS +EXPONENT +DIGIT +LETTER +SIMPLE_COMMENT +BRACKETED_COMMENT +WS +UNRECOGNIZED + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 392, 3694, 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, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 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, 1, 7, 1, 7, 1, 7, 1, 7, 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, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 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, 16, 1, 17, 1, 17, 1, 17, 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, 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, 22, 1, 22, 1, 22, 1, 22, 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, 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, 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, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 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, 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, 36, 1, 36, 1, 36, 1, 37, 1, 37, 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, 38, 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, 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, 43, 1, 43, 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, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 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, 47, 1, 48, 1, 48, 1, 48, 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, 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, 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, 55, 1, 55, 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, 56, 1, 56, 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, 61, 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, 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, 64, 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, 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, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 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, 71, 1, 71, 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, 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, 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, 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, 77, 1, 77, 1, 77, 1, 77, 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, 80, 1, 80, 1, 80, 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, 83, 1, 84, 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, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 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, 88, 1, 89, 1, 89, 1, 89, 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, 90, 1, 91, 1, 91, 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, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 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, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 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, 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, 102, 1, 103, 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, 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, 107, 1, 107, 1, 107, 1, 107, 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, 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, 112, 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, 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, 117, 1, 117, 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, 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, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 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, 124, 1, 124, 1, 125, 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, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 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, 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, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 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, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 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, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 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, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 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, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 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, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 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, 1, 192, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 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, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 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, 203, 1, 203, 1, 203, 1, 204, 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, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 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, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 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, 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, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 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, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 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, 268, 1, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 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, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 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, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 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, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 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, 345, 1, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 3, 350, 3391, 8, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 3, 355, 3409, 8, 355, 1, 356, 1, 356, 1, 357, 1, 357, 1, 357, 1, 357, 3, 357, 3417, 8, 357, 1, 358, 1, 358, 1, 359, 1, 359, 1, 360, 1, 360, 1, 361, 1, 361, 1, 362, 1, 362, 1, 363, 1, 363, 1, 364, 1, 364, 1, 365, 1, 365, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 369, 1, 369, 1, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 5, 375, 3463, 8, 375, 10, 375, 12, 375, 3466, 9, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 5, 375, 3473, 8, 375, 10, 375, 12, 375, 3476, 9, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 5, 375, 3483, 8, 375, 10, 375, 12, 375, 3486, 9, 375, 1, 375, 3, 375, 3489, 8, 375, 1, 376, 1, 376, 1, 376, 1, 376, 5, 376, 3495, 8, 376, 10, 376, 12, 376, 3498, 9, 376, 1, 376, 1, 376, 1, 377, 4, 377, 3503, 8, 377, 11, 377, 12, 377, 3504, 1, 377, 1, 377, 1, 378, 4, 378, 3510, 8, 378, 11, 378, 12, 378, 3511, 1, 378, 1, 378, 1, 379, 4, 379, 3517, 8, 379, 11, 379, 12, 379, 3518, 1, 379, 1, 379, 1, 380, 4, 380, 3524, 8, 380, 11, 380, 12, 380, 3525, 1, 381, 4, 381, 3529, 8, 381, 11, 381, 12, 381, 3530, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 3, 381, 3538, 8, 381, 1, 382, 1, 382, 1, 383, 4, 383, 3543, 8, 383, 11, 383, 12, 383, 3544, 1, 383, 3, 383, 3548, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 3554, 8, 383, 1, 383, 1, 383, 3, 383, 3558, 8, 383, 1, 384, 4, 384, 3561, 8, 384, 11, 384, 12, 384, 3562, 1, 384, 3, 384, 3566, 8, 384, 1, 384, 1, 384, 1, 384, 1, 384, 3, 384, 3572, 8, 384, 1, 384, 1, 384, 3, 384, 3576, 8, 384, 1, 385, 4, 385, 3579, 8, 385, 11, 385, 12, 385, 3580, 1, 385, 3, 385, 3584, 8, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 3591, 8, 385, 1, 385, 1, 385, 1, 385, 3, 385, 3596, 8, 385, 1, 386, 1, 386, 1, 386, 4, 386, 3601, 8, 386, 11, 386, 12, 386, 3602, 1, 387, 1, 387, 1, 387, 1, 387, 5, 387, 3609, 8, 387, 10, 387, 12, 387, 3612, 9, 387, 1, 387, 1, 387, 1, 388, 4, 388, 3617, 8, 388, 11, 388, 12, 388, 3618, 1, 388, 1, 388, 5, 388, 3623, 8, 388, 10, 388, 12, 388, 3626, 9, 388, 1, 388, 1, 388, 4, 388, 3630, 8, 388, 11, 388, 12, 388, 3631, 3, 388, 3634, 8, 388, 1, 389, 1, 389, 3, 389, 3638, 8, 389, 1, 389, 4, 389, 3641, 8, 389, 11, 389, 12, 389, 3642, 1, 390, 1, 390, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 5, 392, 3655, 8, 392, 10, 392, 12, 392, 3658, 9, 392, 1, 392, 3, 392, 3661, 8, 392, 1, 392, 3, 392, 3664, 8, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 5, 393, 3673, 8, 393, 10, 393, 12, 393, 3676, 9, 393, 1, 393, 1, 393, 1, 393, 1, 393, 3, 393, 3682, 8, 393, 1, 393, 1, 393, 1, 394, 4, 394, 3687, 8, 394, 11, 394, 12, 394, 3688, 1, 394, 1, 394, 1, 395, 1, 395, 1, 3674, 0, 396, 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, 132, 265, 133, 267, 134, 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, 150, 301, 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, 157, 315, 158, 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, 329, 165, 331, 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, 172, 345, 173, 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, 359, 180, 361, 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, 187, 375, 188, 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, 389, 195, 391, 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, 202, 405, 203, 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, 419, 210, 421, 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, 217, 435, 218, 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, 449, 225, 451, 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, 232, 465, 233, 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, 479, 240, 481, 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, 247, 495, 248, 497, 249, 499, 250, 501, 251, 503, 252, 505, 253, 507, 254, 509, 255, 511, 256, 513, 257, 515, 258, 517, 259, 519, 260, 521, 261, 523, 262, 525, 263, 527, 264, 529, 265, 531, 266, 533, 267, 535, 268, 537, 269, 539, 270, 541, 271, 543, 272, 545, 273, 547, 274, 549, 275, 551, 276, 553, 277, 555, 278, 557, 279, 559, 280, 561, 281, 563, 282, 565, 283, 567, 284, 569, 285, 571, 286, 573, 287, 575, 288, 577, 289, 579, 290, 581, 291, 583, 292, 585, 293, 587, 294, 589, 295, 591, 296, 593, 297, 595, 298, 597, 299, 599, 300, 601, 301, 603, 302, 605, 303, 607, 304, 609, 305, 611, 306, 613, 307, 615, 308, 617, 309, 619, 310, 621, 311, 623, 312, 625, 313, 627, 314, 629, 315, 631, 316, 633, 317, 635, 318, 637, 319, 639, 320, 641, 321, 643, 322, 645, 323, 647, 324, 649, 325, 651, 326, 653, 327, 655, 328, 657, 329, 659, 330, 661, 331, 663, 332, 665, 333, 667, 334, 669, 335, 671, 336, 673, 337, 675, 338, 677, 339, 679, 340, 681, 341, 683, 342, 685, 343, 687, 344, 689, 345, 691, 346, 693, 347, 695, 348, 697, 349, 699, 350, 701, 351, 703, 352, 705, 353, 707, 354, 709, 355, 711, 356, 713, 357, 715, 358, 717, 359, 719, 360, 721, 361, 723, 362, 725, 363, 727, 364, 729, 365, 731, 366, 733, 367, 735, 368, 737, 369, 739, 370, 741, 371, 743, 372, 745, 373, 747, 374, 749, 375, 751, 376, 753, 377, 755, 378, 757, 379, 759, 380, 761, 381, 763, 382, 765, 383, 767, 384, 769, 385, 771, 386, 773, 387, 775, 388, 777, 0, 779, 0, 781, 0, 783, 0, 785, 389, 787, 390, 789, 391, 791, 392, 1, 0, 36, 2, 0, 65, 65, 97, 97, 2, 0, 68, 68, 100, 100, 2, 0, 70, 70, 102, 102, 2, 0, 84, 84, 116, 116, 2, 0, 69, 69, 101, 101, 2, 0, 82, 82, 114, 114, 2, 0, 76, 76, 108, 108, 2, 0, 87, 87, 119, 119, 2, 0, 89, 89, 121, 121, 2, 0, 83, 83, 115, 115, 2, 0, 78, 78, 110, 110, 2, 0, 90, 90, 122, 122, 2, 0, 73, 73, 105, 105, 2, 0, 86, 86, 118, 118, 2, 0, 85, 85, 117, 117, 2, 0, 67, 67, 99, 99, 2, 0, 72, 72, 104, 104, 2, 0, 79, 79, 111, 111, 2, 0, 66, 66, 98, 98, 2, 0, 71, 71, 103, 103, 2, 0, 75, 75, 107, 107, 2, 0, 77, 77, 109, 109, 2, 0, 80, 80, 112, 112, 2, 0, 88, 88, 120, 120, 2, 0, 74, 74, 106, 106, 2, 0, 81, 81, 113, 113, 2, 0, 39, 39, 92, 92, 1, 0, 39, 39, 1, 0, 34, 34, 2, 0, 34, 34, 92, 92, 1, 0, 96, 96, 2, 0, 43, 43, 45, 45, 1, 0, 48, 57, 2, 0, 65, 90, 97, 122, 2, 0, 10, 10, 13, 13, 3, 0, 9, 10, 13, 13, 32, 32, 3737, 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, 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, 0, 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, 501, 1, 0, 0, 0, 0, 503, 1, 0, 0, 0, 0, 505, 1, 0, 0, 0, 0, 507, 1, 0, 0, 0, 0, 509, 1, 0, 0, 0, 0, 511, 1, 0, 0, 0, 0, 513, 1, 0, 0, 0, 0, 515, 1, 0, 0, 0, 0, 517, 1, 0, 0, 0, 0, 519, 1, 0, 0, 0, 0, 521, 1, 0, 0, 0, 0, 523, 1, 0, 0, 0, 0, 525, 1, 0, 0, 0, 0, 527, 1, 0, 0, 0, 0, 529, 1, 0, 0, 0, 0, 531, 1, 0, 0, 0, 0, 533, 1, 0, 0, 0, 0, 535, 1, 0, 0, 0, 0, 537, 1, 0, 0, 0, 0, 539, 1, 0, 0, 0, 0, 541, 1, 0, 0, 0, 0, 543, 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, 0, 547, 1, 0, 0, 0, 0, 549, 1, 0, 0, 0, 0, 551, 1, 0, 0, 0, 0, 553, 1, 0, 0, 0, 0, 555, 1, 0, 0, 0, 0, 557, 1, 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, 565, 1, 0, 0, 0, 0, 567, 1, 0, 0, 0, 0, 569, 1, 0, 0, 0, 0, 571, 1, 0, 0, 0, 0, 573, 1, 0, 0, 0, 0, 575, 1, 0, 0, 0, 0, 577, 1, 0, 0, 0, 0, 579, 1, 0, 0, 0, 0, 581, 1, 0, 0, 0, 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, 1, 0, 0, 0, 0, 613, 1, 0, 0, 0, 0, 615, 1, 0, 0, 0, 0, 617, 1, 0, 0, 0, 0, 619, 1, 0, 0, 0, 0, 621, 1, 0, 0, 0, 0, 623, 1, 0, 0, 0, 0, 625, 1, 0, 0, 0, 0, 627, 1, 0, 0, 0, 0, 629, 1, 0, 0, 0, 0, 631, 1, 0, 0, 0, 0, 633, 1, 0, 0, 0, 0, 635, 1, 0, 0, 0, 0, 637, 1, 0, 0, 0, 0, 639, 1, 0, 0, 0, 0, 641, 1, 0, 0, 0, 0, 643, 1, 0, 0, 0, 0, 645, 1, 0, 0, 0, 0, 647, 1, 0, 0, 0, 0, 649, 1, 0, 0, 0, 0, 651, 1, 0, 0, 0, 0, 653, 1, 0, 0, 0, 0, 655, 1, 0, 0, 0, 0, 657, 1, 0, 0, 0, 0, 659, 1, 0, 0, 0, 0, 661, 1, 0, 0, 0, 0, 663, 1, 0, 0, 0, 0, 665, 1, 0, 0, 0, 0, 667, 1, 0, 0, 0, 0, 669, 1, 0, 0, 0, 0, 671, 1, 0, 0, 0, 0, 673, 1, 0, 0, 0, 0, 675, 1, 0, 0, 0, 0, 677, 1, 0, 0, 0, 0, 679, 1, 0, 0, 0, 0, 681, 1, 0, 0, 0, 0, 683, 1, 0, 0, 0, 0, 685, 1, 0, 0, 0, 0, 687, 1, 0, 0, 0, 0, 689, 1, 0, 0, 0, 0, 691, 1, 0, 0, 0, 0, 693, 1, 0, 0, 0, 0, 695, 1, 0, 0, 0, 0, 697, 1, 0, 0, 0, 0, 699, 1, 0, 0, 0, 0, 701, 1, 0, 0, 0, 0, 703, 1, 0, 0, 0, 0, 705, 1, 0, 0, 0, 0, 707, 1, 0, 0, 0, 0, 709, 1, 0, 0, 0, 0, 711, 1, 0, 0, 0, 0, 713, 1, 0, 0, 0, 0, 715, 1, 0, 0, 0, 0, 717, 1, 0, 0, 0, 0, 719, 1, 0, 0, 0, 0, 721, 1, 0, 0, 0, 0, 723, 1, 0, 0, 0, 0, 725, 1, 0, 0, 0, 0, 727, 1, 0, 0, 0, 0, 729, 1, 0, 0, 0, 0, 731, 1, 0, 0, 0, 0, 733, 1, 0, 0, 0, 0, 735, 1, 0, 0, 0, 0, 737, 1, 0, 0, 0, 0, 739, 1, 0, 0, 0, 0, 741, 1, 0, 0, 0, 0, 743, 1, 0, 0, 0, 0, 745, 1, 0, 0, 0, 0, 747, 1, 0, 0, 0, 0, 749, 1, 0, 0, 0, 0, 751, 1, 0, 0, 0, 0, 753, 1, 0, 0, 0, 0, 755, 1, 0, 0, 0, 0, 757, 1, 0, 0, 0, 0, 759, 1, 0, 0, 0, 0, 761, 1, 0, 0, 0, 0, 763, 1, 0, 0, 0, 0, 765, 1, 0, 0, 0, 0, 767, 1, 0, 0, 0, 0, 769, 1, 0, 0, 0, 0, 771, 1, 0, 0, 0, 0, 773, 1, 0, 0, 0, 0, 775, 1, 0, 0, 0, 0, 785, 1, 0, 0, 0, 0, 787, 1, 0, 0, 0, 0, 789, 1, 0, 0, 0, 0, 791, 1, 0, 0, 0, 1, 793, 1, 0, 0, 0, 3, 795, 1, 0, 0, 0, 5, 797, 1, 0, 0, 0, 7, 799, 1, 0, 0, 0, 9, 801, 1, 0, 0, 0, 11, 803, 1, 0, 0, 0, 13, 805, 1, 0, 0, 0, 15, 807, 1, 0, 0, 0, 17, 811, 1, 0, 0, 0, 19, 817, 1, 0, 0, 0, 21, 821, 1, 0, 0, 0, 23, 827, 1, 0, 0, 0, 25, 834, 1, 0, 0, 0, 27, 842, 1, 0, 0, 0, 29, 846, 1, 0, 0, 0, 31, 851, 1, 0, 0, 0, 33, 855, 1, 0, 0, 0, 35, 865, 1, 0, 0, 0, 37, 873, 1, 0, 0, 0, 39, 879, 1, 0, 0, 0, 41, 882, 1, 0, 0, 0, 43, 886, 1, 0, 0, 0, 45, 889, 1, 0, 0, 0, 47, 903, 1, 0, 0, 0, 49, 911, 1, 0, 0, 0, 51, 918, 1, 0, 0, 0, 53, 925, 1, 0, 0, 0, 55, 933, 1, 0, 0, 0, 57, 938, 1, 0, 0, 0, 59, 945, 1, 0, 0, 0, 61, 953, 1, 0, 0, 0, 63, 956, 1, 0, 0, 0, 65, 961, 1, 0, 0, 0, 67, 967, 1, 0, 0, 0, 69, 975, 1, 0, 0, 0, 71, 980, 1, 0, 0, 0, 73, 985, 1, 0, 0, 0, 75, 993, 1, 0, 0, 0, 77, 1002, 1, 0, 0, 0, 79, 1009, 1, 0, 0, 0, 81, 1014, 1, 0, 0, 0, 83, 1024, 1, 0, 0, 0, 85, 1030, 1, 0, 0, 0, 87, 1036, 1, 0, 0, 0, 89, 1044, 1, 0, 0, 0, 91, 1054, 1, 0, 0, 0, 93, 1062, 1, 0, 0, 0, 95, 1070, 1, 0, 0, 0, 97, 1081, 1, 0, 0, 0, 99, 1088, 1, 0, 0, 0, 101, 1096, 1, 0, 0, 0, 103, 1104, 1, 0, 0, 0, 105, 1111, 1, 0, 0, 0, 107, 1119, 1, 0, 0, 0, 109, 1131, 1, 0, 0, 0, 111, 1139, 1, 0, 0, 0, 113, 1151, 1, 0, 0, 0, 115, 1162, 1, 0, 0, 0, 117, 1167, 1, 0, 0, 0, 119, 1174, 1, 0, 0, 0, 121, 1180, 1, 0, 0, 0, 123, 1185, 1, 0, 0, 0, 125, 1193, 1, 0, 0, 0, 127, 1206, 1, 0, 0, 0, 129, 1219, 1, 0, 0, 0, 131, 1237, 1, 0, 0, 0, 133, 1250, 1, 0, 0, 0, 135, 1254, 1, 0, 0, 0, 137, 1259, 1, 0, 0, 0, 139, 1269, 1, 0, 0, 0, 141, 1274, 1, 0, 0, 0, 143, 1279, 1, 0, 0, 0, 145, 1288, 1, 0, 0, 0, 147, 1298, 1, 0, 0, 0, 149, 1306, 1, 0, 0, 0, 151, 1315, 1, 0, 0, 0, 153, 1324, 1, 0, 0, 0, 155, 1334, 1, 0, 0, 0, 157, 1347, 1, 0, 0, 0, 159, 1351, 1, 0, 0, 0, 161, 1359, 1, 0, 0, 0, 163, 1367, 1, 0, 0, 0, 165, 1375, 1, 0, 0, 0, 167, 1383, 1, 0, 0, 0, 169, 1390, 1, 0, 0, 0, 171, 1400, 1, 0, 0, 0, 173, 1405, 1, 0, 0, 0, 175, 1414, 1, 0, 0, 0, 177, 1418, 1, 0, 0, 0, 179, 1430, 1, 0, 0, 0, 181, 1440, 1, 0, 0, 0, 183, 1448, 1, 0, 0, 0, 185, 1457, 1, 0, 0, 0, 187, 1468, 1, 0, 0, 0, 189, 1472, 1, 0, 0, 0, 191, 1479, 1, 0, 0, 0, 193, 1484, 1, 0, 0, 0, 195, 1489, 1, 0, 0, 0, 197, 1496, 1, 0, 0, 0, 199, 1500, 1, 0, 0, 0, 201, 1507, 1, 0, 0, 0, 203, 1515, 1, 0, 0, 0, 205, 1522, 1, 0, 0, 0, 207, 1531, 1, 0, 0, 0, 209, 1539, 1, 0, 0, 0, 211, 1546, 1, 0, 0, 0, 213, 1554, 1, 0, 0, 0, 215, 1561, 1, 0, 0, 0, 217, 1570, 1, 0, 0, 0, 219, 1579, 1, 0, 0, 0, 221, 1587, 1, 0, 0, 0, 223, 1593, 1, 0, 0, 0, 225, 1599, 1, 0, 0, 0, 227, 1606, 1, 0, 0, 0, 229, 1613, 1, 0, 0, 0, 231, 1624, 1, 0, 0, 0, 233, 1630, 1, 0, 0, 0, 235, 1636, 1, 0, 0, 0, 237, 1646, 1, 0, 0, 0, 239, 1650, 1, 0, 0, 0, 241, 1658, 1, 0, 0, 0, 243, 1665, 1, 0, 0, 0, 245, 1675, 1, 0, 0, 0, 247, 1680, 1, 0, 0, 0, 249, 1685, 1, 0, 0, 0, 251, 1694, 1, 0, 0, 0, 253, 1704, 1, 0, 0, 0, 255, 1714, 1, 0, 0, 0, 257, 1721, 1, 0, 0, 0, 259, 1727, 1, 0, 0, 0, 261, 1733, 1, 0, 0, 0, 263, 1742, 1, 0, 0, 0, 265, 1749, 1, 0, 0, 0, 267, 1751, 1, 0, 0, 0, 269, 1756, 1, 0, 0, 0, 271, 1762, 1, 0, 0, 0, 273, 1773, 1, 0, 0, 0, 275, 1776, 1, 0, 0, 0, 277, 1783, 1, 0, 0, 0, 279, 1790, 1, 0, 0, 0, 281, 1793, 1, 0, 0, 0, 283, 1801, 1, 0, 0, 0, 285, 1807, 1, 0, 0, 0, 287, 1815, 1, 0, 0, 0, 289, 1821, 1, 0, 0, 0, 291, 1828, 1, 0, 0, 0, 293, 1840, 1, 0, 0, 0, 295, 1847, 1, 0, 0, 0, 297, 1857, 1, 0, 0, 0, 299, 1866, 1, 0, 0, 0, 301, 1870, 1, 0, 0, 0, 303, 1878, 1, 0, 0, 0, 305, 1883, 1, 0, 0, 0, 307, 1886, 1, 0, 0, 0, 309, 1892, 1, 0, 0, 0, 311, 1897, 1, 0, 0, 0, 313, 1902, 1, 0, 0, 0, 315, 1907, 1, 0, 0, 0, 317, 1915, 1, 0, 0, 0, 319, 1920, 1, 0, 0, 0, 321, 1928, 1, 0, 0, 0, 323, 1933, 1, 0, 0, 0, 325, 1943, 1, 0, 0, 0, 327, 1948, 1, 0, 0, 0, 329, 1954, 1, 0, 0, 0, 331, 1960, 1, 0, 0, 0, 333, 1966, 1, 0, 0, 0, 335, 1971, 1, 0, 0, 0, 337, 1976, 1, 0, 0, 0, 339, 1982, 1, 0, 0, 0, 341, 1991, 1, 0, 0, 0, 343, 1996, 1, 0, 0, 0, 345, 2002, 1, 0, 0, 0, 347, 2010, 1, 0, 0, 0, 349, 2015, 1, 0, 0, 0, 351, 2021, 1, 0, 0, 0, 353, 2025, 1, 0, 0, 0, 355, 2033, 1, 0, 0, 0, 357, 2039, 1, 0, 0, 0, 359, 2051, 1, 0, 0, 0, 361, 2064, 1, 0, 0, 0, 363, 2076, 1, 0, 0, 0, 365, 2089, 1, 0, 0, 0, 367, 2096, 1, 0, 0, 0, 369, 2104, 1, 0, 0, 0, 371, 2110, 1, 0, 0, 0, 373, 2117, 1, 0, 0, 0, 375, 2122, 1, 0, 0, 0, 377, 2127, 1, 0, 0, 0, 379, 2137, 1, 0, 0, 0, 381, 2148, 1, 0, 0, 0, 383, 2159, 1, 0, 0, 0, 385, 2171, 1, 0, 0, 0, 387, 2179, 1, 0, 0, 0, 389, 2182, 1, 0, 0, 0, 391, 2189, 1, 0, 0, 0, 393, 2193, 1, 0, 0, 0, 395, 2198, 1, 0, 0, 0, 397, 2204, 1, 0, 0, 0, 399, 2212, 1, 0, 0, 0, 401, 2215, 1, 0, 0, 0, 403, 2222, 1, 0, 0, 0, 405, 2225, 1, 0, 0, 0, 407, 2230, 1, 0, 0, 0, 409, 2239, 1, 0, 0, 0, 411, 2246, 1, 0, 0, 0, 413, 2254, 1, 0, 0, 0, 415, 2257, 1, 0, 0, 0, 417, 2263, 1, 0, 0, 0, 419, 2267, 1, 0, 0, 0, 421, 2273, 1, 0, 0, 0, 423, 2286, 1, 0, 0, 0, 425, 2291, 1, 0, 0, 0, 427, 2300, 1, 0, 0, 0, 429, 2308, 1, 0, 0, 0, 431, 2318, 1, 0, 0, 0, 433, 2328, 1, 0, 0, 0, 435, 2340, 1, 0, 0, 0, 437, 2351, 1, 0, 0, 0, 439, 2367, 1, 0, 0, 0, 441, 2383, 1, 0, 0, 0, 443, 2391, 1, 0, 0, 0, 445, 2397, 1, 0, 0, 0, 447, 2405, 1, 0, 0, 0, 449, 2414, 1, 0, 0, 0, 451, 2424, 1, 0, 0, 0, 453, 2432, 1, 0, 0, 0, 455, 2443, 1, 0, 0, 0, 457, 2454, 1, 0, 0, 0, 459, 2460, 1, 0, 0, 0, 461, 2468, 1, 0, 0, 0, 463, 2474, 1, 0, 0, 0, 465, 2480, 1, 0, 0, 0, 467, 2485, 1, 0, 0, 0, 469, 2498, 1, 0, 0, 0, 471, 2511, 1, 0, 0, 0, 473, 2519, 1, 0, 0, 0, 475, 2526, 1, 0, 0, 0, 477, 2537, 1, 0, 0, 0, 479, 2545, 1, 0, 0, 0, 481, 2552, 1, 0, 0, 0, 483, 2559, 1, 0, 0, 0, 485, 2570, 1, 0, 0, 0, 487, 2578, 1, 0, 0, 0, 489, 2584, 1, 0, 0, 0, 491, 2592, 1, 0, 0, 0, 493, 2601, 1, 0, 0, 0, 495, 2609, 1, 0, 0, 0, 497, 2616, 1, 0, 0, 0, 499, 2622, 1, 0, 0, 0, 501, 2628, 1, 0, 0, 0, 503, 2635, 1, 0, 0, 0, 505, 2640, 1, 0, 0, 0, 507, 2646, 1, 0, 0, 0, 509, 2655, 1, 0, 0, 0, 511, 2662, 1, 0, 0, 0, 513, 2666, 1, 0, 0, 0, 515, 2671, 1, 0, 0, 0, 517, 2678, 1, 0, 0, 0, 519, 2686, 1, 0, 0, 0, 521, 2693, 1, 0, 0, 0, 523, 2701, 1, 0, 0, 0, 525, 2708, 1, 0, 0, 0, 527, 2713, 1, 0, 0, 0, 529, 2723, 1, 0, 0, 0, 531, 2729, 1, 0, 0, 0, 533, 2745, 1, 0, 0, 0, 535, 2758, 1, 0, 0, 0, 537, 2762, 1, 0, 0, 0, 539, 2768, 1, 0, 0, 0, 541, 2773, 1, 0, 0, 0, 543, 2779, 1, 0, 0, 0, 545, 2784, 1, 0, 0, 0, 547, 2791, 1, 0, 0, 0, 549, 2798, 1, 0, 0, 0, 551, 2807, 1, 0, 0, 0, 553, 2812, 1, 0, 0, 0, 555, 2817, 1, 0, 0, 0, 557, 2824, 1, 0, 0, 0, 559, 2831, 1, 0, 0, 0, 561, 2837, 1, 0, 0, 0, 563, 2848, 1, 0, 0, 0, 565, 2855, 1, 0, 0, 0, 567, 2864, 1, 0, 0, 0, 569, 2871, 1, 0, 0, 0, 571, 2878, 1, 0, 0, 0, 573, 2885, 1, 0, 0, 0, 575, 2895, 1, 0, 0, 0, 577, 2900, 1, 0, 0, 0, 579, 2907, 1, 0, 0, 0, 581, 2919, 1, 0, 0, 0, 583, 2934, 1, 0, 0, 0, 585, 2940, 1, 0, 0, 0, 587, 2947, 1, 0, 0, 0, 589, 2959, 1, 0, 0, 0, 591, 2966, 1, 0, 0, 0, 593, 2980, 1, 0, 0, 0, 595, 2990, 1, 0, 0, 0, 597, 3001, 1, 0, 0, 0, 599, 3006, 1, 0, 0, 0, 601, 3011, 1, 0, 0, 0, 603, 3020, 1, 0, 0, 0, 605, 3030, 1, 0, 0, 0, 607, 3044, 1, 0, 0, 0, 609, 3058, 1, 0, 0, 0, 611, 3071, 1, 0, 0, 0, 613, 3085, 1, 0, 0, 0, 615, 3093, 1, 0, 0, 0, 617, 3096, 1, 0, 0, 0, 619, 3102, 1, 0, 0, 0, 621, 3111, 1, 0, 0, 0, 623, 3123, 1, 0, 0, 0, 625, 3136, 1, 0, 0, 0, 627, 3146, 1, 0, 0, 0, 629, 3151, 1, 0, 0, 0, 631, 3156, 1, 0, 0, 0, 633, 3165, 1, 0, 0, 0, 635, 3174, 1, 0, 0, 0, 637, 3179, 1, 0, 0, 0, 639, 3189, 1, 0, 0, 0, 641, 3199, 1, 0, 0, 0, 643, 3207, 1, 0, 0, 0, 645, 3213, 1, 0, 0, 0, 647, 3220, 1, 0, 0, 0, 649, 3228, 1, 0, 0, 0, 651, 3235, 1, 0, 0, 0, 653, 3243, 1, 0, 0, 0, 655, 3249, 1, 0, 0, 0, 657, 3256, 1, 0, 0, 0, 659, 3260, 1, 0, 0, 0, 661, 3265, 1, 0, 0, 0, 663, 3271, 1, 0, 0, 0, 665, 3278, 1, 0, 0, 0, 667, 3286, 1, 0, 0, 0, 669, 3290, 1, 0, 0, 0, 671, 3299, 1, 0, 0, 0, 673, 3307, 1, 0, 0, 0, 675, 3312, 1, 0, 0, 0, 677, 3318, 1, 0, 0, 0, 679, 3323, 1, 0, 0, 0, 681, 3328, 1, 0, 0, 0, 683, 3334, 1, 0, 0, 0, 685, 3339, 1, 0, 0, 0, 687, 3345, 1, 0, 0, 0, 689, 3352, 1, 0, 0, 0, 691, 3357, 1, 0, 0, 0, 693, 3364, 1, 0, 0, 0, 695, 3369, 1, 0, 0, 0, 697, 3375, 1, 0, 0, 0, 699, 3380, 1, 0, 0, 0, 701, 3390, 1, 0, 0, 0, 703, 3392, 1, 0, 0, 0, 705, 3396, 1, 0, 0, 0, 707, 3399, 1, 0, 0, 0, 709, 3402, 1, 0, 0, 0, 711, 3408, 1, 0, 0, 0, 713, 3410, 1, 0, 0, 0, 715, 3416, 1, 0, 0, 0, 717, 3418, 1, 0, 0, 0, 719, 3420, 1, 0, 0, 0, 721, 3422, 1, 0, 0, 0, 723, 3424, 1, 0, 0, 0, 725, 3426, 1, 0, 0, 0, 727, 3428, 1, 0, 0, 0, 729, 3430, 1, 0, 0, 0, 731, 3432, 1, 0, 0, 0, 733, 3434, 1, 0, 0, 0, 735, 3436, 1, 0, 0, 0, 737, 3439, 1, 0, 0, 0, 739, 3441, 1, 0, 0, 0, 741, 3443, 1, 0, 0, 0, 743, 3446, 1, 0, 0, 0, 745, 3449, 1, 0, 0, 0, 747, 3453, 1, 0, 0, 0, 749, 3456, 1, 0, 0, 0, 751, 3488, 1, 0, 0, 0, 753, 3490, 1, 0, 0, 0, 755, 3502, 1, 0, 0, 0, 757, 3509, 1, 0, 0, 0, 759, 3516, 1, 0, 0, 0, 761, 3523, 1, 0, 0, 0, 763, 3537, 1, 0, 0, 0, 765, 3539, 1, 0, 0, 0, 767, 3557, 1, 0, 0, 0, 769, 3575, 1, 0, 0, 0, 771, 3595, 1, 0, 0, 0, 773, 3600, 1, 0, 0, 0, 775, 3604, 1, 0, 0, 0, 777, 3633, 1, 0, 0, 0, 779, 3635, 1, 0, 0, 0, 781, 3644, 1, 0, 0, 0, 783, 3646, 1, 0, 0, 0, 785, 3648, 1, 0, 0, 0, 787, 3667, 1, 0, 0, 0, 789, 3686, 1, 0, 0, 0, 791, 3692, 1, 0, 0, 0, 793, 794, 5, 59, 0, 0, 794, 2, 1, 0, 0, 0, 795, 796, 5, 40, 0, 0, 796, 4, 1, 0, 0, 0, 797, 798, 5, 41, 0, 0, 798, 6, 1, 0, 0, 0, 799, 800, 5, 44, 0, 0, 800, 8, 1, 0, 0, 0, 801, 802, 5, 46, 0, 0, 802, 10, 1, 0, 0, 0, 803, 804, 5, 91, 0, 0, 804, 12, 1, 0, 0, 0, 805, 806, 5, 93, 0, 0, 806, 14, 1, 0, 0, 0, 807, 808, 7, 0, 0, 0, 808, 809, 7, 1, 0, 0, 809, 810, 7, 1, 0, 0, 810, 16, 1, 0, 0, 0, 811, 812, 7, 0, 0, 0, 812, 813, 7, 2, 0, 0, 813, 814, 7, 3, 0, 0, 814, 815, 7, 4, 0, 0, 815, 816, 7, 5, 0, 0, 816, 18, 1, 0, 0, 0, 817, 818, 7, 0, 0, 0, 818, 819, 7, 6, 0, 0, 819, 820, 7, 6, 0, 0, 820, 20, 1, 0, 0, 0, 821, 822, 7, 0, 0, 0, 822, 823, 7, 6, 0, 0, 823, 824, 7, 3, 0, 0, 824, 825, 7, 4, 0, 0, 825, 826, 7, 5, 0, 0, 826, 22, 1, 0, 0, 0, 827, 828, 7, 0, 0, 0, 828, 829, 7, 6, 0, 0, 829, 830, 7, 7, 0, 0, 830, 831, 7, 0, 0, 0, 831, 832, 7, 8, 0, 0, 832, 833, 7, 9, 0, 0, 833, 24, 1, 0, 0, 0, 834, 835, 7, 0, 0, 0, 835, 836, 7, 10, 0, 0, 836, 837, 7, 0, 0, 0, 837, 838, 7, 6, 0, 0, 838, 839, 7, 8, 0, 0, 839, 840, 7, 11, 0, 0, 840, 841, 7, 4, 0, 0, 841, 26, 1, 0, 0, 0, 842, 843, 7, 0, 0, 0, 843, 844, 7, 10, 0, 0, 844, 845, 7, 1, 0, 0, 845, 28, 1, 0, 0, 0, 846, 847, 7, 0, 0, 0, 847, 848, 7, 10, 0, 0, 848, 849, 7, 3, 0, 0, 849, 850, 7, 12, 0, 0, 850, 30, 1, 0, 0, 0, 851, 852, 7, 0, 0, 0, 852, 853, 7, 10, 0, 0, 853, 854, 7, 8, 0, 0, 854, 32, 1, 0, 0, 0, 855, 856, 7, 0, 0, 0, 856, 857, 7, 10, 0, 0, 857, 858, 7, 8, 0, 0, 858, 859, 5, 95, 0, 0, 859, 860, 7, 13, 0, 0, 860, 861, 7, 0, 0, 0, 861, 862, 7, 6, 0, 0, 862, 863, 7, 14, 0, 0, 863, 864, 7, 4, 0, 0, 864, 34, 1, 0, 0, 0, 865, 866, 7, 0, 0, 0, 866, 867, 7, 5, 0, 0, 867, 868, 7, 15, 0, 0, 868, 869, 7, 16, 0, 0, 869, 870, 7, 12, 0, 0, 870, 871, 7, 13, 0, 0, 871, 872, 7, 4, 0, 0, 872, 36, 1, 0, 0, 0, 873, 874, 7, 0, 0, 0, 874, 875, 7, 5, 0, 0, 875, 876, 7, 5, 0, 0, 876, 877, 7, 0, 0, 0, 877, 878, 7, 8, 0, 0, 878, 38, 1, 0, 0, 0, 879, 880, 7, 0, 0, 0, 880, 881, 7, 9, 0, 0, 881, 40, 1, 0, 0, 0, 882, 883, 7, 0, 0, 0, 883, 884, 7, 9, 0, 0, 884, 885, 7, 15, 0, 0, 885, 42, 1, 0, 0, 0, 886, 887, 7, 0, 0, 0, 887, 888, 7, 3, 0, 0, 888, 44, 1, 0, 0, 0, 889, 890, 7, 0, 0, 0, 890, 891, 7, 14, 0, 0, 891, 892, 7, 3, 0, 0, 892, 893, 7, 16, 0, 0, 893, 894, 7, 17, 0, 0, 894, 895, 7, 5, 0, 0, 895, 896, 7, 12, 0, 0, 896, 897, 7, 11, 0, 0, 897, 898, 7, 0, 0, 0, 898, 899, 7, 3, 0, 0, 899, 900, 7, 12, 0, 0, 900, 901, 7, 17, 0, 0, 901, 902, 7, 10, 0, 0, 902, 46, 1, 0, 0, 0, 903, 904, 7, 18, 0, 0, 904, 905, 7, 4, 0, 0, 905, 906, 7, 3, 0, 0, 906, 907, 7, 7, 0, 0, 907, 908, 7, 4, 0, 0, 908, 909, 7, 4, 0, 0, 909, 910, 7, 10, 0, 0, 910, 48, 1, 0, 0, 0, 911, 912, 7, 18, 0, 0, 912, 913, 7, 12, 0, 0, 913, 914, 7, 19, 0, 0, 914, 915, 7, 12, 0, 0, 915, 916, 7, 10, 0, 0, 916, 917, 7, 3, 0, 0, 917, 50, 1, 0, 0, 0, 918, 919, 7, 18, 0, 0, 919, 920, 7, 12, 0, 0, 920, 921, 7, 10, 0, 0, 921, 922, 7, 0, 0, 0, 922, 923, 7, 5, 0, 0, 923, 924, 7, 8, 0, 0, 924, 52, 1, 0, 0, 0, 925, 926, 7, 18, 0, 0, 926, 927, 7, 17, 0, 0, 927, 928, 7, 17, 0, 0, 928, 929, 7, 6, 0, 0, 929, 930, 7, 4, 0, 0, 930, 931, 7, 0, 0, 0, 931, 932, 7, 10, 0, 0, 932, 54, 1, 0, 0, 0, 933, 934, 7, 18, 0, 0, 934, 935, 7, 17, 0, 0, 935, 936, 7, 3, 0, 0, 936, 937, 7, 16, 0, 0, 937, 56, 1, 0, 0, 0, 938, 939, 7, 18, 0, 0, 939, 940, 7, 14, 0, 0, 940, 941, 7, 15, 0, 0, 941, 942, 7, 20, 0, 0, 942, 943, 7, 4, 0, 0, 943, 944, 7, 3, 0, 0, 944, 58, 1, 0, 0, 0, 945, 946, 7, 18, 0, 0, 946, 947, 7, 14, 0, 0, 947, 948, 7, 15, 0, 0, 948, 949, 7, 20, 0, 0, 949, 950, 7, 4, 0, 0, 950, 951, 7, 3, 0, 0, 951, 952, 7, 9, 0, 0, 952, 60, 1, 0, 0, 0, 953, 954, 7, 18, 0, 0, 954, 955, 7, 8, 0, 0, 955, 62, 1, 0, 0, 0, 956, 957, 7, 18, 0, 0, 957, 958, 7, 8, 0, 0, 958, 959, 7, 3, 0, 0, 959, 960, 7, 4, 0, 0, 960, 64, 1, 0, 0, 0, 961, 962, 7, 15, 0, 0, 962, 963, 7, 0, 0, 0, 963, 964, 7, 15, 0, 0, 964, 965, 7, 16, 0, 0, 965, 966, 7, 4, 0, 0, 966, 66, 1, 0, 0, 0, 967, 968, 7, 15, 0, 0, 968, 969, 7, 0, 0, 0, 969, 970, 7, 9, 0, 0, 970, 971, 7, 15, 0, 0, 971, 972, 7, 0, 0, 0, 972, 973, 7, 1, 0, 0, 973, 974, 7, 4, 0, 0, 974, 68, 1, 0, 0, 0, 975, 976, 7, 15, 0, 0, 976, 977, 7, 0, 0, 0, 977, 978, 7, 9, 0, 0, 978, 979, 7, 4, 0, 0, 979, 70, 1, 0, 0, 0, 980, 981, 7, 15, 0, 0, 981, 982, 7, 0, 0, 0, 982, 983, 7, 9, 0, 0, 983, 984, 7, 3, 0, 0, 984, 72, 1, 0, 0, 0, 985, 986, 7, 15, 0, 0, 986, 987, 7, 0, 0, 0, 987, 988, 7, 3, 0, 0, 988, 989, 7, 0, 0, 0, 989, 990, 7, 6, 0, 0, 990, 991, 7, 17, 0, 0, 991, 992, 7, 19, 0, 0, 992, 74, 1, 0, 0, 0, 993, 994, 7, 15, 0, 0, 994, 995, 7, 0, 0, 0, 995, 996, 7, 3, 0, 0, 996, 997, 7, 0, 0, 0, 997, 998, 7, 6, 0, 0, 998, 999, 7, 17, 0, 0, 999, 1000, 7, 19, 0, 0, 1000, 1001, 7, 9, 0, 0, 1001, 76, 1, 0, 0, 0, 1002, 1003, 7, 15, 0, 0, 1003, 1004, 7, 16, 0, 0, 1004, 1005, 7, 0, 0, 0, 1005, 1006, 7, 10, 0, 0, 1006, 1007, 7, 19, 0, 0, 1007, 1008, 7, 4, 0, 0, 1008, 78, 1, 0, 0, 0, 1009, 1010, 7, 15, 0, 0, 1010, 1011, 7, 16, 0, 0, 1011, 1012, 7, 0, 0, 0, 1012, 1013, 7, 5, 0, 0, 1013, 80, 1, 0, 0, 0, 1014, 1015, 7, 15, 0, 0, 1015, 1016, 7, 16, 0, 0, 1016, 1017, 7, 0, 0, 0, 1017, 1018, 7, 5, 0, 0, 1018, 1019, 7, 0, 0, 0, 1019, 1020, 7, 15, 0, 0, 1020, 1021, 7, 3, 0, 0, 1021, 1022, 7, 4, 0, 0, 1022, 1023, 7, 5, 0, 0, 1023, 82, 1, 0, 0, 0, 1024, 1025, 7, 15, 0, 0, 1025, 1026, 7, 16, 0, 0, 1026, 1027, 7, 4, 0, 0, 1027, 1028, 7, 15, 0, 0, 1028, 1029, 7, 20, 0, 0, 1029, 84, 1, 0, 0, 0, 1030, 1031, 7, 15, 0, 0, 1031, 1032, 7, 6, 0, 0, 1032, 1033, 7, 4, 0, 0, 1033, 1034, 7, 0, 0, 0, 1034, 1035, 7, 5, 0, 0, 1035, 86, 1, 0, 0, 0, 1036, 1037, 7, 15, 0, 0, 1037, 1038, 7, 6, 0, 0, 1038, 1039, 7, 14, 0, 0, 1039, 1040, 7, 9, 0, 0, 1040, 1041, 7, 3, 0, 0, 1041, 1042, 7, 4, 0, 0, 1042, 1043, 7, 5, 0, 0, 1043, 88, 1, 0, 0, 0, 1044, 1045, 7, 15, 0, 0, 1045, 1046, 7, 6, 0, 0, 1046, 1047, 7, 14, 0, 0, 1047, 1048, 7, 9, 0, 0, 1048, 1049, 7, 3, 0, 0, 1049, 1050, 7, 4, 0, 0, 1050, 1051, 7, 5, 0, 0, 1051, 1052, 7, 4, 0, 0, 1052, 1053, 7, 1, 0, 0, 1053, 90, 1, 0, 0, 0, 1054, 1055, 7, 15, 0, 0, 1055, 1056, 7, 17, 0, 0, 1056, 1057, 7, 1, 0, 0, 1057, 1058, 7, 4, 0, 0, 1058, 1059, 7, 19, 0, 0, 1059, 1060, 7, 4, 0, 0, 1060, 1061, 7, 10, 0, 0, 1061, 92, 1, 0, 0, 0, 1062, 1063, 7, 15, 0, 0, 1063, 1064, 7, 17, 0, 0, 1064, 1065, 7, 6, 0, 0, 1065, 1066, 7, 6, 0, 0, 1066, 1067, 7, 0, 0, 0, 1067, 1068, 7, 3, 0, 0, 1068, 1069, 7, 4, 0, 0, 1069, 94, 1, 0, 0, 0, 1070, 1071, 7, 15, 0, 0, 1071, 1072, 7, 17, 0, 0, 1072, 1073, 7, 6, 0, 0, 1073, 1074, 7, 6, 0, 0, 1074, 1075, 7, 4, 0, 0, 1075, 1076, 7, 15, 0, 0, 1076, 1077, 7, 3, 0, 0, 1077, 1078, 7, 12, 0, 0, 1078, 1079, 7, 17, 0, 0, 1079, 1080, 7, 10, 0, 0, 1080, 96, 1, 0, 0, 0, 1081, 1082, 7, 15, 0, 0, 1082, 1083, 7, 17, 0, 0, 1083, 1084, 7, 6, 0, 0, 1084, 1085, 7, 14, 0, 0, 1085, 1086, 7, 21, 0, 0, 1086, 1087, 7, 10, 0, 0, 1087, 98, 1, 0, 0, 0, 1088, 1089, 7, 15, 0, 0, 1089, 1090, 7, 17, 0, 0, 1090, 1091, 7, 6, 0, 0, 1091, 1092, 7, 14, 0, 0, 1092, 1093, 7, 21, 0, 0, 1093, 1094, 7, 10, 0, 0, 1094, 1095, 7, 9, 0, 0, 1095, 100, 1, 0, 0, 0, 1096, 1097, 7, 15, 0, 0, 1097, 1098, 7, 17, 0, 0, 1098, 1099, 7, 21, 0, 0, 1099, 1100, 7, 21, 0, 0, 1100, 1101, 7, 4, 0, 0, 1101, 1102, 7, 10, 0, 0, 1102, 1103, 7, 3, 0, 0, 1103, 102, 1, 0, 0, 0, 1104, 1105, 7, 15, 0, 0, 1105, 1106, 7, 17, 0, 0, 1106, 1107, 7, 21, 0, 0, 1107, 1108, 7, 21, 0, 0, 1108, 1109, 7, 12, 0, 0, 1109, 1110, 7, 3, 0, 0, 1110, 104, 1, 0, 0, 0, 1111, 1112, 7, 15, 0, 0, 1112, 1113, 7, 17, 0, 0, 1113, 1114, 7, 21, 0, 0, 1114, 1115, 7, 22, 0, 0, 1115, 1116, 7, 0, 0, 0, 1116, 1117, 7, 15, 0, 0, 1117, 1118, 7, 3, 0, 0, 1118, 106, 1, 0, 0, 0, 1119, 1120, 7, 15, 0, 0, 1120, 1121, 7, 17, 0, 0, 1121, 1122, 7, 21, 0, 0, 1122, 1123, 7, 22, 0, 0, 1123, 1124, 7, 0, 0, 0, 1124, 1125, 7, 15, 0, 0, 1125, 1126, 7, 3, 0, 0, 1126, 1127, 7, 12, 0, 0, 1127, 1128, 7, 17, 0, 0, 1128, 1129, 7, 10, 0, 0, 1129, 1130, 7, 9, 0, 0, 1130, 108, 1, 0, 0, 0, 1131, 1132, 7, 15, 0, 0, 1132, 1133, 7, 17, 0, 0, 1133, 1134, 7, 21, 0, 0, 1134, 1135, 7, 22, 0, 0, 1135, 1136, 7, 14, 0, 0, 1136, 1137, 7, 3, 0, 0, 1137, 1138, 7, 4, 0, 0, 1138, 110, 1, 0, 0, 0, 1139, 1140, 7, 15, 0, 0, 1140, 1141, 7, 17, 0, 0, 1141, 1142, 7, 10, 0, 0, 1142, 1143, 7, 15, 0, 0, 1143, 1144, 7, 0, 0, 0, 1144, 1145, 7, 3, 0, 0, 1145, 1146, 7, 4, 0, 0, 1146, 1147, 7, 10, 0, 0, 1147, 1148, 7, 0, 0, 0, 1148, 1149, 7, 3, 0, 0, 1149, 1150, 7, 4, 0, 0, 1150, 112, 1, 0, 0, 0, 1151, 1152, 7, 15, 0, 0, 1152, 1153, 7, 17, 0, 0, 1153, 1154, 7, 10, 0, 0, 1154, 1155, 7, 9, 0, 0, 1155, 1156, 7, 3, 0, 0, 1156, 1157, 7, 5, 0, 0, 1157, 1158, 7, 0, 0, 0, 1158, 1159, 7, 12, 0, 0, 1159, 1160, 7, 10, 0, 0, 1160, 1161, 7, 3, 0, 0, 1161, 114, 1, 0, 0, 0, 1162, 1163, 7, 15, 0, 0, 1163, 1164, 7, 17, 0, 0, 1164, 1165, 7, 9, 0, 0, 1165, 1166, 7, 3, 0, 0, 1166, 116, 1, 0, 0, 0, 1167, 1168, 7, 15, 0, 0, 1168, 1169, 7, 5, 0, 0, 1169, 1170, 7, 4, 0, 0, 1170, 1171, 7, 0, 0, 0, 1171, 1172, 7, 3, 0, 0, 1172, 1173, 7, 4, 0, 0, 1173, 118, 1, 0, 0, 0, 1174, 1175, 7, 15, 0, 0, 1175, 1176, 7, 5, 0, 0, 1176, 1177, 7, 17, 0, 0, 1177, 1178, 7, 9, 0, 0, 1178, 1179, 7, 9, 0, 0, 1179, 120, 1, 0, 0, 0, 1180, 1181, 7, 15, 0, 0, 1181, 1182, 7, 14, 0, 0, 1182, 1183, 7, 18, 0, 0, 1183, 1184, 7, 4, 0, 0, 1184, 122, 1, 0, 0, 0, 1185, 1186, 7, 15, 0, 0, 1186, 1187, 7, 14, 0, 0, 1187, 1188, 7, 5, 0, 0, 1188, 1189, 7, 5, 0, 0, 1189, 1190, 7, 4, 0, 0, 1190, 1191, 7, 10, 0, 0, 1191, 1192, 7, 3, 0, 0, 1192, 124, 1, 0, 0, 0, 1193, 1194, 7, 15, 0, 0, 1194, 1195, 7, 14, 0, 0, 1195, 1196, 7, 5, 0, 0, 1196, 1197, 7, 5, 0, 0, 1197, 1198, 7, 4, 0, 0, 1198, 1199, 7, 10, 0, 0, 1199, 1200, 7, 3, 0, 0, 1200, 1201, 5, 95, 0, 0, 1201, 1202, 7, 1, 0, 0, 1202, 1203, 7, 0, 0, 0, 1203, 1204, 7, 3, 0, 0, 1204, 1205, 7, 4, 0, 0, 1205, 126, 1, 0, 0, 0, 1206, 1207, 7, 15, 0, 0, 1207, 1208, 7, 14, 0, 0, 1208, 1209, 7, 5, 0, 0, 1209, 1210, 7, 5, 0, 0, 1210, 1211, 7, 4, 0, 0, 1211, 1212, 7, 10, 0, 0, 1212, 1213, 7, 3, 0, 0, 1213, 1214, 5, 95, 0, 0, 1214, 1215, 7, 3, 0, 0, 1215, 1216, 7, 12, 0, 0, 1216, 1217, 7, 21, 0, 0, 1217, 1218, 7, 4, 0, 0, 1218, 128, 1, 0, 0, 0, 1219, 1220, 7, 15, 0, 0, 1220, 1221, 7, 14, 0, 0, 1221, 1222, 7, 5, 0, 0, 1222, 1223, 7, 5, 0, 0, 1223, 1224, 7, 4, 0, 0, 1224, 1225, 7, 10, 0, 0, 1225, 1226, 7, 3, 0, 0, 1226, 1227, 5, 95, 0, 0, 1227, 1228, 7, 3, 0, 0, 1228, 1229, 7, 12, 0, 0, 1229, 1230, 7, 21, 0, 0, 1230, 1231, 7, 4, 0, 0, 1231, 1232, 7, 9, 0, 0, 1232, 1233, 7, 3, 0, 0, 1233, 1234, 7, 0, 0, 0, 1234, 1235, 7, 21, 0, 0, 1235, 1236, 7, 22, 0, 0, 1236, 130, 1, 0, 0, 0, 1237, 1238, 7, 15, 0, 0, 1238, 1239, 7, 14, 0, 0, 1239, 1240, 7, 5, 0, 0, 1240, 1241, 7, 5, 0, 0, 1241, 1242, 7, 4, 0, 0, 1242, 1243, 7, 10, 0, 0, 1243, 1244, 7, 3, 0, 0, 1244, 1245, 5, 95, 0, 0, 1245, 1246, 7, 14, 0, 0, 1246, 1247, 7, 9, 0, 0, 1247, 1248, 7, 4, 0, 0, 1248, 1249, 7, 5, 0, 0, 1249, 132, 1, 0, 0, 0, 1250, 1251, 7, 1, 0, 0, 1251, 1252, 7, 0, 0, 0, 1252, 1253, 7, 8, 0, 0, 1253, 134, 1, 0, 0, 0, 1254, 1255, 7, 1, 0, 0, 1255, 1256, 7, 0, 0, 0, 1256, 1257, 7, 8, 0, 0, 1257, 1258, 7, 9, 0, 0, 1258, 136, 1, 0, 0, 0, 1259, 1260, 7, 1, 0, 0, 1260, 1261, 7, 0, 0, 0, 1261, 1262, 7, 8, 0, 0, 1262, 1263, 7, 17, 0, 0, 1263, 1264, 7, 2, 0, 0, 1264, 1265, 7, 8, 0, 0, 1265, 1266, 7, 4, 0, 0, 1266, 1267, 7, 0, 0, 0, 1267, 1268, 7, 5, 0, 0, 1268, 138, 1, 0, 0, 0, 1269, 1270, 7, 1, 0, 0, 1270, 1271, 7, 0, 0, 0, 1271, 1272, 7, 3, 0, 0, 1272, 1273, 7, 0, 0, 0, 1273, 140, 1, 0, 0, 0, 1274, 1275, 7, 1, 0, 0, 1275, 1276, 7, 0, 0, 0, 1276, 1277, 7, 3, 0, 0, 1277, 1278, 7, 4, 0, 0, 1278, 142, 1, 0, 0, 0, 1279, 1280, 7, 1, 0, 0, 1280, 1281, 7, 0, 0, 0, 1281, 1282, 7, 3, 0, 0, 1282, 1283, 7, 0, 0, 0, 1283, 1284, 7, 18, 0, 0, 1284, 1285, 7, 0, 0, 0, 1285, 1286, 7, 9, 0, 0, 1286, 1287, 7, 4, 0, 0, 1287, 144, 1, 0, 0, 0, 1288, 1289, 7, 1, 0, 0, 1289, 1290, 7, 0, 0, 0, 1290, 1291, 7, 3, 0, 0, 1291, 1292, 7, 0, 0, 0, 1292, 1293, 7, 18, 0, 0, 1293, 1294, 7, 0, 0, 0, 1294, 1295, 7, 9, 0, 0, 1295, 1296, 7, 4, 0, 0, 1296, 1297, 7, 9, 0, 0, 1297, 146, 1, 0, 0, 0, 1298, 1299, 7, 1, 0, 0, 1299, 1300, 7, 0, 0, 0, 1300, 1301, 7, 3, 0, 0, 1301, 1302, 7, 4, 0, 0, 1302, 1303, 7, 0, 0, 0, 1303, 1304, 7, 1, 0, 0, 1304, 1305, 7, 1, 0, 0, 1305, 148, 1, 0, 0, 0, 1306, 1307, 7, 1, 0, 0, 1307, 1308, 7, 0, 0, 0, 1308, 1309, 7, 3, 0, 0, 1309, 1310, 7, 4, 0, 0, 1310, 1311, 5, 95, 0, 0, 1311, 1312, 7, 0, 0, 0, 1312, 1313, 7, 1, 0, 0, 1313, 1314, 7, 1, 0, 0, 1314, 150, 1, 0, 0, 0, 1315, 1316, 7, 1, 0, 0, 1316, 1317, 7, 0, 0, 0, 1317, 1318, 7, 3, 0, 0, 1318, 1319, 7, 4, 0, 0, 1319, 1320, 7, 1, 0, 0, 1320, 1321, 7, 12, 0, 0, 1321, 1322, 7, 2, 0, 0, 1322, 1323, 7, 2, 0, 0, 1323, 152, 1, 0, 0, 0, 1324, 1325, 7, 1, 0, 0, 1325, 1326, 7, 0, 0, 0, 1326, 1327, 7, 3, 0, 0, 1327, 1328, 7, 4, 0, 0, 1328, 1329, 5, 95, 0, 0, 1329, 1330, 7, 1, 0, 0, 1330, 1331, 7, 12, 0, 0, 1331, 1332, 7, 2, 0, 0, 1332, 1333, 7, 2, 0, 0, 1333, 154, 1, 0, 0, 0, 1334, 1335, 7, 1, 0, 0, 1335, 1336, 7, 18, 0, 0, 1336, 1337, 7, 22, 0, 0, 1337, 1338, 7, 5, 0, 0, 1338, 1339, 7, 17, 0, 0, 1339, 1340, 7, 22, 0, 0, 1340, 1341, 7, 4, 0, 0, 1341, 1342, 7, 5, 0, 0, 1342, 1343, 7, 3, 0, 0, 1343, 1344, 7, 12, 0, 0, 1344, 1345, 7, 4, 0, 0, 1345, 1346, 7, 9, 0, 0, 1346, 156, 1, 0, 0, 0, 1347, 1348, 7, 1, 0, 0, 1348, 1349, 7, 4, 0, 0, 1349, 1350, 7, 15, 0, 0, 1350, 158, 1, 0, 0, 0, 1351, 1352, 7, 1, 0, 0, 1352, 1353, 7, 4, 0, 0, 1353, 1354, 7, 15, 0, 0, 1354, 1355, 7, 12, 0, 0, 1355, 1356, 7, 21, 0, 0, 1356, 1357, 7, 0, 0, 0, 1357, 1358, 7, 6, 0, 0, 1358, 160, 1, 0, 0, 0, 1359, 1360, 7, 1, 0, 0, 1360, 1361, 7, 4, 0, 0, 1361, 1362, 7, 15, 0, 0, 1362, 1363, 7, 6, 0, 0, 1363, 1364, 7, 0, 0, 0, 1364, 1365, 7, 5, 0, 0, 1365, 1366, 7, 4, 0, 0, 1366, 162, 1, 0, 0, 0, 1367, 1368, 7, 1, 0, 0, 1368, 1369, 7, 4, 0, 0, 1369, 1370, 7, 2, 0, 0, 1370, 1371, 7, 0, 0, 0, 1371, 1372, 7, 14, 0, 0, 1372, 1373, 7, 6, 0, 0, 1373, 1374, 7, 3, 0, 0, 1374, 164, 1, 0, 0, 0, 1375, 1376, 7, 1, 0, 0, 1376, 1377, 7, 4, 0, 0, 1377, 1378, 7, 2, 0, 0, 1378, 1379, 7, 12, 0, 0, 1379, 1380, 7, 10, 0, 0, 1380, 1381, 7, 4, 0, 0, 1381, 1382, 7, 1, 0, 0, 1382, 166, 1, 0, 0, 0, 1383, 1384, 7, 1, 0, 0, 1384, 1385, 7, 4, 0, 0, 1385, 1386, 7, 6, 0, 0, 1386, 1387, 7, 4, 0, 0, 1387, 1388, 7, 3, 0, 0, 1388, 1389, 7, 4, 0, 0, 1389, 168, 1, 0, 0, 0, 1390, 1391, 7, 1, 0, 0, 1391, 1392, 7, 4, 0, 0, 1392, 1393, 7, 6, 0, 0, 1393, 1394, 7, 12, 0, 0, 1394, 1395, 7, 21, 0, 0, 1395, 1396, 7, 12, 0, 0, 1396, 1397, 7, 3, 0, 0, 1397, 1398, 7, 4, 0, 0, 1398, 1399, 7, 1, 0, 0, 1399, 170, 1, 0, 0, 0, 1400, 1401, 7, 1, 0, 0, 1401, 1402, 7, 4, 0, 0, 1402, 1403, 7, 9, 0, 0, 1403, 1404, 7, 15, 0, 0, 1404, 172, 1, 0, 0, 0, 1405, 1406, 7, 1, 0, 0, 1406, 1407, 7, 4, 0, 0, 1407, 1408, 7, 9, 0, 0, 1408, 1409, 7, 15, 0, 0, 1409, 1410, 7, 5, 0, 0, 1410, 1411, 7, 12, 0, 0, 1411, 1412, 7, 18, 0, 0, 1412, 1413, 7, 4, 0, 0, 1413, 174, 1, 0, 0, 0, 1414, 1415, 7, 1, 0, 0, 1415, 1416, 7, 2, 0, 0, 1416, 1417, 7, 9, 0, 0, 1417, 176, 1, 0, 0, 0, 1418, 1419, 7, 1, 0, 0, 1419, 1420, 7, 12, 0, 0, 1420, 1421, 7, 5, 0, 0, 1421, 1422, 7, 4, 0, 0, 1422, 1423, 7, 15, 0, 0, 1423, 1424, 7, 3, 0, 0, 1424, 1425, 7, 17, 0, 0, 1425, 1426, 7, 5, 0, 0, 1426, 1427, 7, 12, 0, 0, 1427, 1428, 7, 4, 0, 0, 1428, 1429, 7, 9, 0, 0, 1429, 178, 1, 0, 0, 0, 1430, 1431, 7, 1, 0, 0, 1431, 1432, 7, 12, 0, 0, 1432, 1433, 7, 5, 0, 0, 1433, 1434, 7, 4, 0, 0, 1434, 1435, 7, 15, 0, 0, 1435, 1436, 7, 3, 0, 0, 1436, 1437, 7, 17, 0, 0, 1437, 1438, 7, 5, 0, 0, 1438, 1439, 7, 8, 0, 0, 1439, 180, 1, 0, 0, 0, 1440, 1441, 7, 1, 0, 0, 1441, 1442, 7, 12, 0, 0, 1442, 1443, 7, 9, 0, 0, 1443, 1444, 7, 0, 0, 0, 1444, 1445, 7, 18, 0, 0, 1445, 1446, 7, 6, 0, 0, 1446, 1447, 7, 4, 0, 0, 1447, 182, 1, 0, 0, 0, 1448, 1449, 7, 1, 0, 0, 1449, 1450, 7, 12, 0, 0, 1450, 1451, 7, 9, 0, 0, 1451, 1452, 7, 3, 0, 0, 1452, 1453, 7, 12, 0, 0, 1453, 1454, 7, 10, 0, 0, 1454, 1455, 7, 15, 0, 0, 1455, 1456, 7, 3, 0, 0, 1456, 184, 1, 0, 0, 0, 1457, 1458, 7, 1, 0, 0, 1458, 1459, 7, 12, 0, 0, 1459, 1460, 7, 9, 0, 0, 1460, 1461, 7, 3, 0, 0, 1461, 1462, 7, 5, 0, 0, 1462, 1463, 7, 12, 0, 0, 1463, 1464, 7, 18, 0, 0, 1464, 1465, 7, 14, 0, 0, 1465, 1466, 7, 3, 0, 0, 1466, 1467, 7, 4, 0, 0, 1467, 186, 1, 0, 0, 0, 1468, 1469, 7, 1, 0, 0, 1469, 1470, 7, 12, 0, 0, 1470, 1471, 7, 13, 0, 0, 1471, 188, 1, 0, 0, 0, 1472, 1473, 7, 1, 0, 0, 1473, 1474, 7, 17, 0, 0, 1474, 1475, 7, 14, 0, 0, 1475, 1476, 7, 18, 0, 0, 1476, 1477, 7, 6, 0, 0, 1477, 1478, 7, 4, 0, 0, 1478, 190, 1, 0, 0, 0, 1479, 1480, 7, 1, 0, 0, 1480, 1481, 7, 5, 0, 0, 1481, 1482, 7, 17, 0, 0, 1482, 1483, 7, 22, 0, 0, 1483, 192, 1, 0, 0, 0, 1484, 1485, 7, 4, 0, 0, 1485, 1486, 7, 6, 0, 0, 1486, 1487, 7, 9, 0, 0, 1487, 1488, 7, 4, 0, 0, 1488, 194, 1, 0, 0, 0, 1489, 1490, 7, 4, 0, 0, 1490, 1491, 7, 10, 0, 0, 1491, 1492, 7, 0, 0, 0, 1492, 1493, 7, 18, 0, 0, 1493, 1494, 7, 6, 0, 0, 1494, 1495, 7, 4, 0, 0, 1495, 196, 1, 0, 0, 0, 1496, 1497, 7, 4, 0, 0, 1497, 1498, 7, 10, 0, 0, 1498, 1499, 7, 1, 0, 0, 1499, 198, 1, 0, 0, 0, 1500, 1501, 7, 4, 0, 0, 1501, 1502, 7, 9, 0, 0, 1502, 1503, 7, 15, 0, 0, 1503, 1504, 7, 0, 0, 0, 1504, 1505, 7, 22, 0, 0, 1505, 1506, 7, 4, 0, 0, 1506, 200, 1, 0, 0, 0, 1507, 1508, 7, 4, 0, 0, 1508, 1509, 7, 9, 0, 0, 1509, 1510, 7, 15, 0, 0, 1510, 1511, 7, 0, 0, 0, 1511, 1512, 7, 22, 0, 0, 1512, 1513, 7, 4, 0, 0, 1513, 1514, 7, 1, 0, 0, 1514, 202, 1, 0, 0, 0, 1515, 1516, 7, 4, 0, 0, 1516, 1517, 7, 23, 0, 0, 1517, 1518, 7, 15, 0, 0, 1518, 1519, 7, 4, 0, 0, 1519, 1520, 7, 22, 0, 0, 1520, 1521, 7, 3, 0, 0, 1521, 204, 1, 0, 0, 0, 1522, 1523, 7, 4, 0, 0, 1523, 1524, 7, 23, 0, 0, 1524, 1525, 7, 15, 0, 0, 1525, 1526, 7, 16, 0, 0, 1526, 1527, 7, 0, 0, 0, 1527, 1528, 7, 10, 0, 0, 1528, 1529, 7, 19, 0, 0, 1529, 1530, 7, 4, 0, 0, 1530, 206, 1, 0, 0, 0, 1531, 1532, 7, 4, 0, 0, 1532, 1533, 7, 23, 0, 0, 1533, 1534, 7, 15, 0, 0, 1534, 1535, 7, 6, 0, 0, 1535, 1536, 7, 14, 0, 0, 1536, 1537, 7, 1, 0, 0, 1537, 1538, 7, 4, 0, 0, 1538, 208, 1, 0, 0, 0, 1539, 1540, 7, 4, 0, 0, 1540, 1541, 7, 23, 0, 0, 1541, 1542, 7, 12, 0, 0, 1542, 1543, 7, 9, 0, 0, 1543, 1544, 7, 3, 0, 0, 1544, 1545, 7, 9, 0, 0, 1545, 210, 1, 0, 0, 0, 1546, 1547, 7, 4, 0, 0, 1547, 1548, 7, 23, 0, 0, 1548, 1549, 7, 22, 0, 0, 1549, 1550, 7, 6, 0, 0, 1550, 1551, 7, 0, 0, 0, 1551, 1552, 7, 12, 0, 0, 1552, 1553, 7, 10, 0, 0, 1553, 212, 1, 0, 0, 0, 1554, 1555, 7, 4, 0, 0, 1555, 1556, 7, 23, 0, 0, 1556, 1557, 7, 22, 0, 0, 1557, 1558, 7, 17, 0, 0, 1558, 1559, 7, 5, 0, 0, 1559, 1560, 7, 3, 0, 0, 1560, 214, 1, 0, 0, 0, 1561, 1562, 7, 4, 0, 0, 1562, 1563, 7, 23, 0, 0, 1563, 1564, 7, 3, 0, 0, 1564, 1565, 7, 4, 0, 0, 1565, 1566, 7, 10, 0, 0, 1566, 1567, 7, 1, 0, 0, 1567, 1568, 7, 4, 0, 0, 1568, 1569, 7, 1, 0, 0, 1569, 216, 1, 0, 0, 0, 1570, 1571, 7, 4, 0, 0, 1571, 1572, 7, 23, 0, 0, 1572, 1573, 7, 3, 0, 0, 1573, 1574, 7, 4, 0, 0, 1574, 1575, 7, 5, 0, 0, 1575, 1576, 7, 10, 0, 0, 1576, 1577, 7, 0, 0, 0, 1577, 1578, 7, 6, 0, 0, 1578, 218, 1, 0, 0, 0, 1579, 1580, 7, 4, 0, 0, 1580, 1581, 7, 23, 0, 0, 1581, 1582, 7, 3, 0, 0, 1582, 1583, 7, 5, 0, 0, 1583, 1584, 7, 0, 0, 0, 1584, 1585, 7, 15, 0, 0, 1585, 1586, 7, 3, 0, 0, 1586, 220, 1, 0, 0, 0, 1587, 1588, 7, 2, 0, 0, 1588, 1589, 7, 0, 0, 0, 1589, 1590, 7, 6, 0, 0, 1590, 1591, 7, 9, 0, 0, 1591, 1592, 7, 4, 0, 0, 1592, 222, 1, 0, 0, 0, 1593, 1594, 7, 2, 0, 0, 1594, 1595, 7, 4, 0, 0, 1595, 1596, 7, 3, 0, 0, 1596, 1597, 7, 15, 0, 0, 1597, 1598, 7, 16, 0, 0, 1598, 224, 1, 0, 0, 0, 1599, 1600, 7, 2, 0, 0, 1600, 1601, 7, 12, 0, 0, 1601, 1602, 7, 4, 0, 0, 1602, 1603, 7, 6, 0, 0, 1603, 1604, 7, 1, 0, 0, 1604, 1605, 7, 9, 0, 0, 1605, 226, 1, 0, 0, 0, 1606, 1607, 7, 2, 0, 0, 1607, 1608, 7, 12, 0, 0, 1608, 1609, 7, 6, 0, 0, 1609, 1610, 7, 3, 0, 0, 1610, 1611, 7, 4, 0, 0, 1611, 1612, 7, 5, 0, 0, 1612, 228, 1, 0, 0, 0, 1613, 1614, 7, 2, 0, 0, 1614, 1615, 7, 12, 0, 0, 1615, 1616, 7, 6, 0, 0, 1616, 1617, 7, 4, 0, 0, 1617, 1618, 7, 2, 0, 0, 1618, 1619, 7, 17, 0, 0, 1619, 1620, 7, 5, 0, 0, 1620, 1621, 7, 21, 0, 0, 1621, 1622, 7, 0, 0, 0, 1622, 1623, 7, 3, 0, 0, 1623, 230, 1, 0, 0, 0, 1624, 1625, 7, 2, 0, 0, 1625, 1626, 7, 12, 0, 0, 1626, 1627, 7, 5, 0, 0, 1627, 1628, 7, 9, 0, 0, 1628, 1629, 7, 3, 0, 0, 1629, 232, 1, 0, 0, 0, 1630, 1631, 7, 2, 0, 0, 1631, 1632, 7, 6, 0, 0, 1632, 1633, 7, 17, 0, 0, 1633, 1634, 7, 0, 0, 0, 1634, 1635, 7, 3, 0, 0, 1635, 234, 1, 0, 0, 0, 1636, 1637, 7, 2, 0, 0, 1637, 1638, 7, 17, 0, 0, 1638, 1639, 7, 6, 0, 0, 1639, 1640, 7, 6, 0, 0, 1640, 1641, 7, 17, 0, 0, 1641, 1642, 7, 7, 0, 0, 1642, 1643, 7, 12, 0, 0, 1643, 1644, 7, 10, 0, 0, 1644, 1645, 7, 19, 0, 0, 1645, 236, 1, 0, 0, 0, 1646, 1647, 7, 2, 0, 0, 1647, 1648, 7, 17, 0, 0, 1648, 1649, 7, 5, 0, 0, 1649, 238, 1, 0, 0, 0, 1650, 1651, 7, 2, 0, 0, 1651, 1652, 7, 17, 0, 0, 1652, 1653, 7, 5, 0, 0, 1653, 1654, 7, 4, 0, 0, 1654, 1655, 7, 12, 0, 0, 1655, 1656, 7, 19, 0, 0, 1656, 1657, 7, 10, 0, 0, 1657, 240, 1, 0, 0, 0, 1658, 1659, 7, 2, 0, 0, 1659, 1660, 7, 17, 0, 0, 1660, 1661, 7, 5, 0, 0, 1661, 1662, 7, 21, 0, 0, 1662, 1663, 7, 0, 0, 0, 1663, 1664, 7, 3, 0, 0, 1664, 242, 1, 0, 0, 0, 1665, 1666, 7, 2, 0, 0, 1666, 1667, 7, 17, 0, 0, 1667, 1668, 7, 5, 0, 0, 1668, 1669, 7, 21, 0, 0, 1669, 1670, 7, 0, 0, 0, 1670, 1671, 7, 3, 0, 0, 1671, 1672, 7, 3, 0, 0, 1672, 1673, 7, 4, 0, 0, 1673, 1674, 7, 1, 0, 0, 1674, 244, 1, 0, 0, 0, 1675, 1676, 7, 2, 0, 0, 1676, 1677, 7, 5, 0, 0, 1677, 1678, 7, 17, 0, 0, 1678, 1679, 7, 21, 0, 0, 1679, 246, 1, 0, 0, 0, 1680, 1681, 7, 2, 0, 0, 1681, 1682, 7, 14, 0, 0, 1682, 1683, 7, 6, 0, 0, 1683, 1684, 7, 6, 0, 0, 1684, 248, 1, 0, 0, 0, 1685, 1686, 7, 2, 0, 0, 1686, 1687, 7, 14, 0, 0, 1687, 1688, 7, 10, 0, 0, 1688, 1689, 7, 15, 0, 0, 1689, 1690, 7, 3, 0, 0, 1690, 1691, 7, 12, 0, 0, 1691, 1692, 7, 17, 0, 0, 1692, 1693, 7, 10, 0, 0, 1693, 250, 1, 0, 0, 0, 1694, 1695, 7, 2, 0, 0, 1695, 1696, 7, 14, 0, 0, 1696, 1697, 7, 10, 0, 0, 1697, 1698, 7, 15, 0, 0, 1698, 1699, 7, 3, 0, 0, 1699, 1700, 7, 12, 0, 0, 1700, 1701, 7, 17, 0, 0, 1701, 1702, 7, 10, 0, 0, 1702, 1703, 7, 9, 0, 0, 1703, 252, 1, 0, 0, 0, 1704, 1705, 7, 19, 0, 0, 1705, 1706, 7, 4, 0, 0, 1706, 1707, 7, 10, 0, 0, 1707, 1708, 7, 4, 0, 0, 1708, 1709, 7, 5, 0, 0, 1709, 1710, 7, 0, 0, 0, 1710, 1711, 7, 3, 0, 0, 1711, 1712, 7, 4, 0, 0, 1712, 1713, 7, 1, 0, 0, 1713, 254, 1, 0, 0, 0, 1714, 1715, 7, 19, 0, 0, 1715, 1716, 7, 6, 0, 0, 1716, 1717, 7, 17, 0, 0, 1717, 1718, 7, 18, 0, 0, 1718, 1719, 7, 0, 0, 0, 1719, 1720, 7, 6, 0, 0, 1720, 256, 1, 0, 0, 0, 1721, 1722, 7, 19, 0, 0, 1722, 1723, 7, 5, 0, 0, 1723, 1724, 7, 0, 0, 0, 1724, 1725, 7, 10, 0, 0, 1725, 1726, 7, 3, 0, 0, 1726, 258, 1, 0, 0, 0, 1727, 1728, 7, 19, 0, 0, 1728, 1729, 7, 5, 0, 0, 1729, 1730, 7, 17, 0, 0, 1730, 1731, 7, 14, 0, 0, 1731, 1732, 7, 22, 0, 0, 1732, 260, 1, 0, 0, 0, 1733, 1734, 7, 19, 0, 0, 1734, 1735, 7, 5, 0, 0, 1735, 1736, 7, 17, 0, 0, 1736, 1737, 7, 14, 0, 0, 1737, 1738, 7, 22, 0, 0, 1738, 1739, 7, 12, 0, 0, 1739, 1740, 7, 10, 0, 0, 1740, 1741, 7, 19, 0, 0, 1741, 262, 1, 0, 0, 0, 1742, 1743, 7, 16, 0, 0, 1743, 1744, 7, 0, 0, 0, 1744, 1745, 7, 13, 0, 0, 1745, 1746, 7, 12, 0, 0, 1746, 1747, 7, 10, 0, 0, 1747, 1748, 7, 19, 0, 0, 1748, 264, 1, 0, 0, 0, 1749, 1750, 7, 23, 0, 0, 1750, 266, 1, 0, 0, 0, 1751, 1752, 7, 16, 0, 0, 1752, 1753, 7, 17, 0, 0, 1753, 1754, 7, 14, 0, 0, 1754, 1755, 7, 5, 0, 0, 1755, 268, 1, 0, 0, 0, 1756, 1757, 7, 16, 0, 0, 1757, 1758, 7, 17, 0, 0, 1758, 1759, 7, 14, 0, 0, 1759, 1760, 7, 5, 0, 0, 1760, 1761, 7, 9, 0, 0, 1761, 270, 1, 0, 0, 0, 1762, 1763, 7, 12, 0, 0, 1763, 1764, 7, 1, 0, 0, 1764, 1765, 7, 4, 0, 0, 1765, 1766, 7, 10, 0, 0, 1766, 1767, 7, 3, 0, 0, 1767, 1768, 7, 12, 0, 0, 1768, 1769, 7, 2, 0, 0, 1769, 1770, 7, 12, 0, 0, 1770, 1771, 7, 4, 0, 0, 1771, 1772, 7, 5, 0, 0, 1772, 272, 1, 0, 0, 0, 1773, 1774, 7, 12, 0, 0, 1774, 1775, 7, 2, 0, 0, 1775, 274, 1, 0, 0, 0, 1776, 1777, 7, 12, 0, 0, 1777, 1778, 7, 19, 0, 0, 1778, 1779, 7, 10, 0, 0, 1779, 1780, 7, 17, 0, 0, 1780, 1781, 7, 5, 0, 0, 1781, 1782, 7, 4, 0, 0, 1782, 276, 1, 0, 0, 0, 1783, 1784, 7, 12, 0, 0, 1784, 1785, 7, 21, 0, 0, 1785, 1786, 7, 22, 0, 0, 1786, 1787, 7, 17, 0, 0, 1787, 1788, 7, 5, 0, 0, 1788, 1789, 7, 3, 0, 0, 1789, 278, 1, 0, 0, 0, 1790, 1791, 7, 12, 0, 0, 1791, 1792, 7, 10, 0, 0, 1792, 280, 1, 0, 0, 0, 1793, 1794, 7, 12, 0, 0, 1794, 1795, 7, 10, 0, 0, 1795, 1796, 7, 15, 0, 0, 1796, 1797, 7, 6, 0, 0, 1797, 1798, 7, 14, 0, 0, 1798, 1799, 7, 1, 0, 0, 1799, 1800, 7, 4, 0, 0, 1800, 282, 1, 0, 0, 0, 1801, 1802, 7, 12, 0, 0, 1802, 1803, 7, 10, 0, 0, 1803, 1804, 7, 1, 0, 0, 1804, 1805, 7, 4, 0, 0, 1805, 1806, 7, 23, 0, 0, 1806, 284, 1, 0, 0, 0, 1807, 1808, 7, 12, 0, 0, 1808, 1809, 7, 10, 0, 0, 1809, 1810, 7, 1, 0, 0, 1810, 1811, 7, 4, 0, 0, 1811, 1812, 7, 23, 0, 0, 1812, 1813, 7, 4, 0, 0, 1813, 1814, 7, 9, 0, 0, 1814, 286, 1, 0, 0, 0, 1815, 1816, 7, 12, 0, 0, 1816, 1817, 7, 10, 0, 0, 1817, 1818, 7, 10, 0, 0, 1818, 1819, 7, 4, 0, 0, 1819, 1820, 7, 5, 0, 0, 1820, 288, 1, 0, 0, 0, 1821, 1822, 7, 12, 0, 0, 1822, 1823, 7, 10, 0, 0, 1823, 1824, 7, 22, 0, 0, 1824, 1825, 7, 0, 0, 0, 1825, 1826, 7, 3, 0, 0, 1826, 1827, 7, 16, 0, 0, 1827, 290, 1, 0, 0, 0, 1828, 1829, 7, 12, 0, 0, 1829, 1830, 7, 10, 0, 0, 1830, 1831, 7, 22, 0, 0, 1831, 1832, 7, 14, 0, 0, 1832, 1833, 7, 3, 0, 0, 1833, 1834, 7, 2, 0, 0, 1834, 1835, 7, 17, 0, 0, 1835, 1836, 7, 5, 0, 0, 1836, 1837, 7, 21, 0, 0, 1837, 1838, 7, 0, 0, 0, 1838, 1839, 7, 3, 0, 0, 1839, 292, 1, 0, 0, 0, 1840, 1841, 7, 12, 0, 0, 1841, 1842, 7, 10, 0, 0, 1842, 1843, 7, 9, 0, 0, 1843, 1844, 7, 4, 0, 0, 1844, 1845, 7, 5, 0, 0, 1845, 1846, 7, 3, 0, 0, 1846, 294, 1, 0, 0, 0, 1847, 1848, 7, 12, 0, 0, 1848, 1849, 7, 10, 0, 0, 1849, 1850, 7, 3, 0, 0, 1850, 1851, 7, 4, 0, 0, 1851, 1852, 7, 5, 0, 0, 1852, 1853, 7, 9, 0, 0, 1853, 1854, 7, 4, 0, 0, 1854, 1855, 7, 15, 0, 0, 1855, 1856, 7, 3, 0, 0, 1856, 296, 1, 0, 0, 0, 1857, 1858, 7, 12, 0, 0, 1858, 1859, 7, 10, 0, 0, 1859, 1860, 7, 3, 0, 0, 1860, 1861, 7, 4, 0, 0, 1861, 1862, 7, 5, 0, 0, 1862, 1863, 7, 13, 0, 0, 1863, 1864, 7, 0, 0, 0, 1864, 1865, 7, 6, 0, 0, 1865, 298, 1, 0, 0, 0, 1866, 1867, 7, 12, 0, 0, 1867, 1868, 7, 10, 0, 0, 1868, 1869, 7, 3, 0, 0, 1869, 300, 1, 0, 0, 0, 1870, 1871, 7, 12, 0, 0, 1871, 1872, 7, 10, 0, 0, 1872, 1873, 7, 3, 0, 0, 1873, 1874, 7, 4, 0, 0, 1874, 1875, 7, 19, 0, 0, 1875, 1876, 7, 4, 0, 0, 1876, 1877, 7, 5, 0, 0, 1877, 302, 1, 0, 0, 0, 1878, 1879, 7, 12, 0, 0, 1879, 1880, 7, 10, 0, 0, 1880, 1881, 7, 3, 0, 0, 1881, 1882, 7, 17, 0, 0, 1882, 304, 1, 0, 0, 0, 1883, 1884, 7, 12, 0, 0, 1884, 1885, 7, 9, 0, 0, 1885, 306, 1, 0, 0, 0, 1886, 1887, 7, 12, 0, 0, 1887, 1888, 7, 3, 0, 0, 1888, 1889, 7, 4, 0, 0, 1889, 1890, 7, 21, 0, 0, 1890, 1891, 7, 9, 0, 0, 1891, 308, 1, 0, 0, 0, 1892, 1893, 7, 24, 0, 0, 1893, 1894, 7, 17, 0, 0, 1894, 1895, 7, 12, 0, 0, 1895, 1896, 7, 10, 0, 0, 1896, 310, 1, 0, 0, 0, 1897, 1898, 7, 20, 0, 0, 1898, 1899, 7, 4, 0, 0, 1899, 1900, 7, 8, 0, 0, 1900, 1901, 7, 9, 0, 0, 1901, 312, 1, 0, 0, 0, 1902, 1903, 7, 6, 0, 0, 1903, 1904, 7, 0, 0, 0, 1904, 1905, 7, 9, 0, 0, 1905, 1906, 7, 3, 0, 0, 1906, 314, 1, 0, 0, 0, 1907, 1908, 7, 6, 0, 0, 1908, 1909, 7, 0, 0, 0, 1909, 1910, 7, 3, 0, 0, 1910, 1911, 7, 4, 0, 0, 1911, 1912, 7, 5, 0, 0, 1912, 1913, 7, 0, 0, 0, 1913, 1914, 7, 6, 0, 0, 1914, 316, 1, 0, 0, 0, 1915, 1916, 7, 6, 0, 0, 1916, 1917, 7, 0, 0, 0, 1917, 1918, 7, 11, 0, 0, 1918, 1919, 7, 8, 0, 0, 1919, 318, 1, 0, 0, 0, 1920, 1921, 7, 6, 0, 0, 1921, 1922, 7, 4, 0, 0, 1922, 1923, 7, 0, 0, 0, 1923, 1924, 7, 1, 0, 0, 1924, 1925, 7, 12, 0, 0, 1925, 1926, 7, 10, 0, 0, 1926, 1927, 7, 19, 0, 0, 1927, 320, 1, 0, 0, 0, 1928, 1929, 7, 6, 0, 0, 1929, 1930, 7, 4, 0, 0, 1930, 1931, 7, 2, 0, 0, 1931, 1932, 7, 3, 0, 0, 1932, 322, 1, 0, 0, 0, 1933, 1934, 7, 6, 0, 0, 1934, 1935, 7, 12, 0, 0, 1935, 1936, 7, 2, 0, 0, 1936, 1937, 7, 4, 0, 0, 1937, 1938, 7, 15, 0, 0, 1938, 1939, 7, 8, 0, 0, 1939, 1940, 7, 15, 0, 0, 1940, 1941, 7, 6, 0, 0, 1941, 1942, 7, 4, 0, 0, 1942, 324, 1, 0, 0, 0, 1943, 1944, 7, 6, 0, 0, 1944, 1945, 7, 12, 0, 0, 1945, 1946, 7, 20, 0, 0, 1946, 1947, 7, 4, 0, 0, 1947, 326, 1, 0, 0, 0, 1948, 1949, 7, 12, 0, 0, 1949, 1950, 7, 6, 0, 0, 1950, 1951, 7, 12, 0, 0, 1951, 1952, 7, 20, 0, 0, 1952, 1953, 7, 4, 0, 0, 1953, 328, 1, 0, 0, 0, 1954, 1955, 7, 6, 0, 0, 1955, 1956, 7, 12, 0, 0, 1956, 1957, 7, 21, 0, 0, 1957, 1958, 7, 12, 0, 0, 1958, 1959, 7, 3, 0, 0, 1959, 330, 1, 0, 0, 0, 1960, 1961, 7, 6, 0, 0, 1961, 1962, 7, 12, 0, 0, 1962, 1963, 7, 10, 0, 0, 1963, 1964, 7, 4, 0, 0, 1964, 1965, 7, 9, 0, 0, 1965, 332, 1, 0, 0, 0, 1966, 1967, 7, 6, 0, 0, 1967, 1968, 7, 12, 0, 0, 1968, 1969, 7, 9, 0, 0, 1969, 1970, 7, 3, 0, 0, 1970, 334, 1, 0, 0, 0, 1971, 1972, 7, 6, 0, 0, 1972, 1973, 7, 17, 0, 0, 1973, 1974, 7, 0, 0, 0, 1974, 1975, 7, 1, 0, 0, 1975, 336, 1, 0, 0, 0, 1976, 1977, 7, 6, 0, 0, 1977, 1978, 7, 17, 0, 0, 1978, 1979, 7, 15, 0, 0, 1979, 1980, 7, 0, 0, 0, 1980, 1981, 7, 6, 0, 0, 1981, 338, 1, 0, 0, 0, 1982, 1983, 7, 6, 0, 0, 1983, 1984, 7, 17, 0, 0, 1984, 1985, 7, 15, 0, 0, 1985, 1986, 7, 0, 0, 0, 1986, 1987, 7, 3, 0, 0, 1987, 1988, 7, 12, 0, 0, 1988, 1989, 7, 17, 0, 0, 1989, 1990, 7, 10, 0, 0, 1990, 340, 1, 0, 0, 0, 1991, 1992, 7, 6, 0, 0, 1992, 1993, 7, 17, 0, 0, 1993, 1994, 7, 15, 0, 0, 1994, 1995, 7, 20, 0, 0, 1995, 342, 1, 0, 0, 0, 1996, 1997, 7, 6, 0, 0, 1997, 1998, 7, 17, 0, 0, 1998, 1999, 7, 15, 0, 0, 1999, 2000, 7, 20, 0, 0, 2000, 2001, 7, 9, 0, 0, 2001, 344, 1, 0, 0, 0, 2002, 2003, 7, 6, 0, 0, 2003, 2004, 7, 17, 0, 0, 2004, 2005, 7, 19, 0, 0, 2005, 2006, 7, 12, 0, 0, 2006, 2007, 7, 15, 0, 0, 2007, 2008, 7, 0, 0, 0, 2008, 2009, 7, 6, 0, 0, 2009, 346, 1, 0, 0, 0, 2010, 2011, 7, 6, 0, 0, 2011, 2012, 7, 17, 0, 0, 2012, 2013, 7, 10, 0, 0, 2013, 2014, 7, 19, 0, 0, 2014, 348, 1, 0, 0, 0, 2015, 2016, 7, 21, 0, 0, 2016, 2017, 7, 0, 0, 0, 2017, 2018, 7, 15, 0, 0, 2018, 2019, 7, 5, 0, 0, 2019, 2020, 7, 17, 0, 0, 2020, 350, 1, 0, 0, 0, 2021, 2022, 7, 21, 0, 0, 2022, 2023, 7, 0, 0, 0, 2023, 2024, 7, 22, 0, 0, 2024, 352, 1, 0, 0, 0, 2025, 2026, 7, 21, 0, 0, 2026, 2027, 7, 0, 0, 0, 2027, 2028, 7, 3, 0, 0, 2028, 2029, 7, 15, 0, 0, 2029, 2030, 7, 16, 0, 0, 2030, 2031, 7, 4, 0, 0, 2031, 2032, 7, 1, 0, 0, 2032, 354, 1, 0, 0, 0, 2033, 2034, 7, 21, 0, 0, 2034, 2035, 7, 4, 0, 0, 2035, 2036, 7, 5, 0, 0, 2036, 2037, 7, 19, 0, 0, 2037, 2038, 7, 4, 0, 0, 2038, 356, 1, 0, 0, 0, 2039, 2040, 7, 21, 0, 0, 2040, 2041, 7, 12, 0, 0, 2041, 2042, 7, 15, 0, 0, 2042, 2043, 7, 5, 0, 0, 2043, 2044, 7, 17, 0, 0, 2044, 2045, 7, 9, 0, 0, 2045, 2046, 7, 4, 0, 0, 2046, 2047, 7, 15, 0, 0, 2047, 2048, 7, 17, 0, 0, 2048, 2049, 7, 10, 0, 0, 2049, 2050, 7, 1, 0, 0, 2050, 358, 1, 0, 0, 0, 2051, 2052, 7, 21, 0, 0, 2052, 2053, 7, 12, 0, 0, 2053, 2054, 7, 15, 0, 0, 2054, 2055, 7, 5, 0, 0, 2055, 2056, 7, 17, 0, 0, 2056, 2057, 7, 9, 0, 0, 2057, 2058, 7, 4, 0, 0, 2058, 2059, 7, 15, 0, 0, 2059, 2060, 7, 17, 0, 0, 2060, 2061, 7, 10, 0, 0, 2061, 2062, 7, 1, 0, 0, 2062, 2063, 7, 9, 0, 0, 2063, 360, 1, 0, 0, 0, 2064, 2065, 7, 21, 0, 0, 2065, 2066, 7, 12, 0, 0, 2066, 2067, 7, 6, 0, 0, 2067, 2068, 7, 6, 0, 0, 2068, 2069, 7, 12, 0, 0, 2069, 2070, 7, 9, 0, 0, 2070, 2071, 7, 4, 0, 0, 2071, 2072, 7, 15, 0, 0, 2072, 2073, 7, 17, 0, 0, 2073, 2074, 7, 10, 0, 0, 2074, 2075, 7, 1, 0, 0, 2075, 362, 1, 0, 0, 0, 2076, 2077, 7, 21, 0, 0, 2077, 2078, 7, 12, 0, 0, 2078, 2079, 7, 6, 0, 0, 2079, 2080, 7, 6, 0, 0, 2080, 2081, 7, 12, 0, 0, 2081, 2082, 7, 9, 0, 0, 2082, 2083, 7, 4, 0, 0, 2083, 2084, 7, 15, 0, 0, 2084, 2085, 7, 17, 0, 0, 2085, 2086, 7, 10, 0, 0, 2086, 2087, 7, 1, 0, 0, 2087, 2088, 7, 9, 0, 0, 2088, 364, 1, 0, 0, 0, 2089, 2090, 7, 21, 0, 0, 2090, 2091, 7, 12, 0, 0, 2091, 2092, 7, 10, 0, 0, 2092, 2093, 7, 14, 0, 0, 2093, 2094, 7, 3, 0, 0, 2094, 2095, 7, 4, 0, 0, 2095, 366, 1, 0, 0, 0, 2096, 2097, 7, 21, 0, 0, 2097, 2098, 7, 12, 0, 0, 2098, 2099, 7, 10, 0, 0, 2099, 2100, 7, 14, 0, 0, 2100, 2101, 7, 3, 0, 0, 2101, 2102, 7, 4, 0, 0, 2102, 2103, 7, 9, 0, 0, 2103, 368, 1, 0, 0, 0, 2104, 2105, 7, 21, 0, 0, 2105, 2106, 7, 17, 0, 0, 2106, 2107, 7, 10, 0, 0, 2107, 2108, 7, 3, 0, 0, 2108, 2109, 7, 16, 0, 0, 2109, 370, 1, 0, 0, 0, 2110, 2111, 7, 21, 0, 0, 2111, 2112, 7, 17, 0, 0, 2112, 2113, 7, 10, 0, 0, 2113, 2114, 7, 3, 0, 0, 2114, 2115, 7, 16, 0, 0, 2115, 2116, 7, 9, 0, 0, 2116, 372, 1, 0, 0, 0, 2117, 2118, 7, 21, 0, 0, 2118, 2119, 7, 9, 0, 0, 2119, 2120, 7, 15, 0, 0, 2120, 2121, 7, 20, 0, 0, 2121, 374, 1, 0, 0, 0, 2122, 2123, 7, 10, 0, 0, 2123, 2124, 7, 0, 0, 0, 2124, 2125, 7, 21, 0, 0, 2125, 2126, 7, 4, 0, 0, 2126, 376, 1, 0, 0, 0, 2127, 2128, 7, 10, 0, 0, 2128, 2129, 7, 0, 0, 0, 2129, 2130, 7, 21, 0, 0, 2130, 2131, 7, 4, 0, 0, 2131, 2132, 7, 9, 0, 0, 2132, 2133, 7, 22, 0, 0, 2133, 2134, 7, 0, 0, 0, 2134, 2135, 7, 15, 0, 0, 2135, 2136, 7, 4, 0, 0, 2136, 378, 1, 0, 0, 0, 2137, 2138, 7, 10, 0, 0, 2138, 2139, 7, 0, 0, 0, 2139, 2140, 7, 21, 0, 0, 2140, 2141, 7, 4, 0, 0, 2141, 2142, 7, 9, 0, 0, 2142, 2143, 7, 22, 0, 0, 2143, 2144, 7, 0, 0, 0, 2144, 2145, 7, 15, 0, 0, 2145, 2146, 7, 4, 0, 0, 2146, 2147, 7, 9, 0, 0, 2147, 380, 1, 0, 0, 0, 2148, 2149, 7, 10, 0, 0, 2149, 2150, 7, 0, 0, 0, 2150, 2151, 7, 10, 0, 0, 2151, 2152, 7, 17, 0, 0, 2152, 2153, 7, 9, 0, 0, 2153, 2154, 7, 4, 0, 0, 2154, 2155, 7, 15, 0, 0, 2155, 2156, 7, 17, 0, 0, 2156, 2157, 7, 10, 0, 0, 2157, 2158, 7, 1, 0, 0, 2158, 382, 1, 0, 0, 0, 2159, 2160, 7, 10, 0, 0, 2160, 2161, 7, 0, 0, 0, 2161, 2162, 7, 10, 0, 0, 2162, 2163, 7, 17, 0, 0, 2163, 2164, 7, 9, 0, 0, 2164, 2165, 7, 4, 0, 0, 2165, 2166, 7, 15, 0, 0, 2166, 2167, 7, 17, 0, 0, 2167, 2168, 7, 10, 0, 0, 2168, 2169, 7, 1, 0, 0, 2169, 2170, 7, 9, 0, 0, 2170, 384, 1, 0, 0, 0, 2171, 2172, 7, 10, 0, 0, 2172, 2173, 7, 0, 0, 0, 2173, 2174, 7, 3, 0, 0, 2174, 2175, 7, 14, 0, 0, 2175, 2176, 7, 5, 0, 0, 2176, 2177, 7, 0, 0, 0, 2177, 2178, 7, 6, 0, 0, 2178, 386, 1, 0, 0, 0, 2179, 2180, 7, 10, 0, 0, 2180, 2181, 7, 17, 0, 0, 2181, 388, 1, 0, 0, 0, 2182, 2183, 7, 10, 0, 0, 2183, 2184, 7, 17, 0, 0, 2184, 2185, 7, 9, 0, 0, 2185, 2186, 7, 15, 0, 0, 2186, 2187, 7, 0, 0, 0, 2187, 2188, 7, 10, 0, 0, 2188, 390, 1, 0, 0, 0, 2189, 2190, 7, 10, 0, 0, 2190, 2191, 7, 17, 0, 0, 2191, 2192, 7, 3, 0, 0, 2192, 392, 1, 0, 0, 0, 2193, 2194, 7, 10, 0, 0, 2194, 2195, 7, 14, 0, 0, 2195, 2196, 7, 6, 0, 0, 2196, 2197, 7, 6, 0, 0, 2197, 394, 1, 0, 0, 0, 2198, 2199, 7, 10, 0, 0, 2199, 2200, 7, 14, 0, 0, 2200, 2201, 7, 6, 0, 0, 2201, 2202, 7, 6, 0, 0, 2202, 2203, 7, 9, 0, 0, 2203, 396, 1, 0, 0, 0, 2204, 2205, 7, 10, 0, 0, 2205, 2206, 7, 14, 0, 0, 2206, 2207, 7, 21, 0, 0, 2207, 2208, 7, 4, 0, 0, 2208, 2209, 7, 5, 0, 0, 2209, 2210, 7, 12, 0, 0, 2210, 2211, 7, 15, 0, 0, 2211, 398, 1, 0, 0, 0, 2212, 2213, 7, 17, 0, 0, 2213, 2214, 7, 2, 0, 0, 2214, 400, 1, 0, 0, 0, 2215, 2216, 7, 17, 0, 0, 2216, 2217, 7, 2, 0, 0, 2217, 2218, 7, 2, 0, 0, 2218, 2219, 7, 9, 0, 0, 2219, 2220, 7, 4, 0, 0, 2220, 2221, 7, 3, 0, 0, 2221, 402, 1, 0, 0, 0, 2222, 2223, 7, 17, 0, 0, 2223, 2224, 7, 10, 0, 0, 2224, 404, 1, 0, 0, 0, 2225, 2226, 7, 17, 0, 0, 2226, 2227, 7, 10, 0, 0, 2227, 2228, 7, 6, 0, 0, 2228, 2229, 7, 8, 0, 0, 2229, 406, 1, 0, 0, 0, 2230, 2231, 7, 17, 0, 0, 2231, 2232, 7, 22, 0, 0, 2232, 2233, 7, 3, 0, 0, 2233, 2234, 7, 12, 0, 0, 2234, 2235, 7, 21, 0, 0, 2235, 2236, 7, 12, 0, 0, 2236, 2237, 7, 11, 0, 0, 2237, 2238, 7, 4, 0, 0, 2238, 408, 1, 0, 0, 0, 2239, 2240, 7, 17, 0, 0, 2240, 2241, 7, 22, 0, 0, 2241, 2242, 7, 3, 0, 0, 2242, 2243, 7, 12, 0, 0, 2243, 2244, 7, 17, 0, 0, 2244, 2245, 7, 10, 0, 0, 2245, 410, 1, 0, 0, 0, 2246, 2247, 7, 17, 0, 0, 2247, 2248, 7, 22, 0, 0, 2248, 2249, 7, 3, 0, 0, 2249, 2250, 7, 12, 0, 0, 2250, 2251, 7, 17, 0, 0, 2251, 2252, 7, 10, 0, 0, 2252, 2253, 7, 9, 0, 0, 2253, 412, 1, 0, 0, 0, 2254, 2255, 7, 17, 0, 0, 2255, 2256, 7, 5, 0, 0, 2256, 414, 1, 0, 0, 0, 2257, 2258, 7, 17, 0, 0, 2258, 2259, 7, 5, 0, 0, 2259, 2260, 7, 1, 0, 0, 2260, 2261, 7, 4, 0, 0, 2261, 2262, 7, 5, 0, 0, 2262, 416, 1, 0, 0, 0, 2263, 2264, 7, 17, 0, 0, 2264, 2265, 7, 14, 0, 0, 2265, 2266, 7, 3, 0, 0, 2266, 418, 1, 0, 0, 0, 2267, 2268, 7, 17, 0, 0, 2268, 2269, 7, 14, 0, 0, 2269, 2270, 7, 3, 0, 0, 2270, 2271, 7, 4, 0, 0, 2271, 2272, 7, 5, 0, 0, 2272, 420, 1, 0, 0, 0, 2273, 2274, 7, 17, 0, 0, 2274, 2275, 7, 14, 0, 0, 2275, 2276, 7, 3, 0, 0, 2276, 2277, 7, 22, 0, 0, 2277, 2278, 7, 14, 0, 0, 2278, 2279, 7, 3, 0, 0, 2279, 2280, 7, 2, 0, 0, 2280, 2281, 7, 17, 0, 0, 2281, 2282, 7, 5, 0, 0, 2282, 2283, 7, 21, 0, 0, 2283, 2284, 7, 0, 0, 0, 2284, 2285, 7, 3, 0, 0, 2285, 422, 1, 0, 0, 0, 2286, 2287, 7, 17, 0, 0, 2287, 2288, 7, 13, 0, 0, 2288, 2289, 7, 4, 0, 0, 2289, 2290, 7, 5, 0, 0, 2290, 424, 1, 0, 0, 0, 2291, 2292, 7, 17, 0, 0, 2292, 2293, 7, 13, 0, 0, 2293, 2294, 7, 4, 0, 0, 2294, 2295, 7, 5, 0, 0, 2295, 2296, 7, 6, 0, 0, 2296, 2297, 7, 0, 0, 0, 2297, 2298, 7, 22, 0, 0, 2298, 2299, 7, 9, 0, 0, 2299, 426, 1, 0, 0, 0, 2300, 2301, 7, 17, 0, 0, 2301, 2302, 7, 13, 0, 0, 2302, 2303, 7, 4, 0, 0, 2303, 2304, 7, 5, 0, 0, 2304, 2305, 7, 6, 0, 0, 2305, 2306, 7, 0, 0, 0, 2306, 2307, 7, 8, 0, 0, 2307, 428, 1, 0, 0, 0, 2308, 2309, 7, 17, 0, 0, 2309, 2310, 7, 13, 0, 0, 2310, 2311, 7, 4, 0, 0, 2311, 2312, 7, 5, 0, 0, 2312, 2313, 7, 7, 0, 0, 2313, 2314, 7, 5, 0, 0, 2314, 2315, 7, 12, 0, 0, 2315, 2316, 7, 3, 0, 0, 2316, 2317, 7, 4, 0, 0, 2317, 430, 1, 0, 0, 0, 2318, 2319, 7, 22, 0, 0, 2319, 2320, 7, 0, 0, 0, 2320, 2321, 7, 5, 0, 0, 2321, 2322, 7, 3, 0, 0, 2322, 2323, 7, 12, 0, 0, 2323, 2324, 7, 3, 0, 0, 2324, 2325, 7, 12, 0, 0, 2325, 2326, 7, 17, 0, 0, 2326, 2327, 7, 10, 0, 0, 2327, 432, 1, 0, 0, 0, 2328, 2329, 7, 22, 0, 0, 2329, 2330, 7, 0, 0, 0, 2330, 2331, 7, 5, 0, 0, 2331, 2332, 7, 3, 0, 0, 2332, 2333, 7, 12, 0, 0, 2333, 2334, 7, 3, 0, 0, 2334, 2335, 7, 12, 0, 0, 2335, 2336, 7, 17, 0, 0, 2336, 2337, 7, 10, 0, 0, 2337, 2338, 7, 4, 0, 0, 2338, 2339, 7, 1, 0, 0, 2339, 434, 1, 0, 0, 0, 2340, 2341, 7, 22, 0, 0, 2341, 2342, 7, 0, 0, 0, 2342, 2343, 7, 5, 0, 0, 2343, 2344, 7, 3, 0, 0, 2344, 2345, 7, 12, 0, 0, 2345, 2346, 7, 3, 0, 0, 2346, 2347, 7, 12, 0, 0, 2347, 2348, 7, 17, 0, 0, 2348, 2349, 7, 10, 0, 0, 2349, 2350, 7, 9, 0, 0, 2350, 436, 1, 0, 0, 0, 2351, 2352, 7, 22, 0, 0, 2352, 2353, 7, 4, 0, 0, 2353, 2354, 7, 5, 0, 0, 2354, 2355, 7, 15, 0, 0, 2355, 2356, 7, 4, 0, 0, 2356, 2357, 7, 10, 0, 0, 2357, 2358, 7, 3, 0, 0, 2358, 2359, 7, 12, 0, 0, 2359, 2360, 7, 6, 0, 0, 2360, 2361, 7, 4, 0, 0, 2361, 2362, 5, 95, 0, 0, 2362, 2363, 7, 15, 0, 0, 2363, 2364, 7, 17, 0, 0, 2364, 2365, 7, 10, 0, 0, 2365, 2366, 7, 3, 0, 0, 2366, 438, 1, 0, 0, 0, 2367, 2368, 7, 22, 0, 0, 2368, 2369, 7, 4, 0, 0, 2369, 2370, 7, 5, 0, 0, 2370, 2371, 7, 15, 0, 0, 2371, 2372, 7, 4, 0, 0, 2372, 2373, 7, 10, 0, 0, 2373, 2374, 7, 3, 0, 0, 2374, 2375, 7, 12, 0, 0, 2375, 2376, 7, 6, 0, 0, 2376, 2377, 7, 4, 0, 0, 2377, 2378, 5, 95, 0, 0, 2378, 2379, 7, 1, 0, 0, 2379, 2380, 7, 12, 0, 0, 2380, 2381, 7, 9, 0, 0, 2381, 2382, 7, 15, 0, 0, 2382, 440, 1, 0, 0, 0, 2383, 2384, 7, 22, 0, 0, 2384, 2385, 7, 4, 0, 0, 2385, 2386, 7, 5, 0, 0, 2386, 2387, 7, 15, 0, 0, 2387, 2388, 7, 4, 0, 0, 2388, 2389, 7, 10, 0, 0, 2389, 2390, 7, 3, 0, 0, 2390, 442, 1, 0, 0, 0, 2391, 2392, 7, 22, 0, 0, 2392, 2393, 7, 12, 0, 0, 2393, 2394, 7, 13, 0, 0, 2394, 2395, 7, 17, 0, 0, 2395, 2396, 7, 3, 0, 0, 2396, 444, 1, 0, 0, 0, 2397, 2398, 7, 22, 0, 0, 2398, 2399, 7, 6, 0, 0, 2399, 2400, 7, 0, 0, 0, 2400, 2401, 7, 15, 0, 0, 2401, 2402, 7, 12, 0, 0, 2402, 2403, 7, 10, 0, 0, 2403, 2404, 7, 19, 0, 0, 2404, 446, 1, 0, 0, 0, 2405, 2406, 7, 22, 0, 0, 2406, 2407, 7, 17, 0, 0, 2407, 2408, 7, 9, 0, 0, 2408, 2409, 7, 12, 0, 0, 2409, 2410, 7, 3, 0, 0, 2410, 2411, 7, 12, 0, 0, 2411, 2412, 7, 17, 0, 0, 2412, 2413, 7, 10, 0, 0, 2413, 448, 1, 0, 0, 0, 2414, 2415, 7, 22, 0, 0, 2415, 2416, 7, 5, 0, 0, 2416, 2417, 7, 4, 0, 0, 2417, 2418, 7, 15, 0, 0, 2418, 2419, 7, 4, 0, 0, 2419, 2420, 7, 1, 0, 0, 2420, 2421, 7, 12, 0, 0, 2421, 2422, 7, 10, 0, 0, 2422, 2423, 7, 19, 0, 0, 2423, 450, 1, 0, 0, 0, 2424, 2425, 7, 22, 0, 0, 2425, 2426, 7, 5, 0, 0, 2426, 2427, 7, 12, 0, 0, 2427, 2428, 7, 21, 0, 0, 2428, 2429, 7, 0, 0, 0, 2429, 2430, 7, 5, 0, 0, 2430, 2431, 7, 8, 0, 0, 2431, 452, 1, 0, 0, 0, 2432, 2433, 7, 22, 0, 0, 2433, 2434, 7, 5, 0, 0, 2434, 2435, 7, 12, 0, 0, 2435, 2436, 7, 10, 0, 0, 2436, 2437, 7, 15, 0, 0, 2437, 2438, 7, 12, 0, 0, 2438, 2439, 7, 22, 0, 0, 2439, 2440, 7, 0, 0, 0, 2440, 2441, 7, 6, 0, 0, 2441, 2442, 7, 9, 0, 0, 2442, 454, 1, 0, 0, 0, 2443, 2444, 7, 22, 0, 0, 2444, 2445, 7, 5, 0, 0, 2445, 2446, 7, 17, 0, 0, 2446, 2447, 7, 22, 0, 0, 2447, 2448, 7, 4, 0, 0, 2448, 2449, 7, 5, 0, 0, 2449, 2450, 7, 3, 0, 0, 2450, 2451, 7, 12, 0, 0, 2451, 2452, 7, 4, 0, 0, 2452, 2453, 7, 9, 0, 0, 2453, 456, 1, 0, 0, 0, 2454, 2455, 7, 22, 0, 0, 2455, 2456, 7, 14, 0, 0, 2456, 2457, 7, 5, 0, 0, 2457, 2458, 7, 19, 0, 0, 2458, 2459, 7, 4, 0, 0, 2459, 458, 1, 0, 0, 0, 2460, 2461, 7, 25, 0, 0, 2461, 2462, 7, 14, 0, 0, 2462, 2463, 7, 0, 0, 0, 2463, 2464, 7, 5, 0, 0, 2464, 2465, 7, 3, 0, 0, 2465, 2466, 7, 4, 0, 0, 2466, 2467, 7, 5, 0, 0, 2467, 460, 1, 0, 0, 0, 2468, 2469, 7, 25, 0, 0, 2469, 2470, 7, 14, 0, 0, 2470, 2471, 7, 4, 0, 0, 2471, 2472, 7, 5, 0, 0, 2472, 2473, 7, 8, 0, 0, 2473, 462, 1, 0, 0, 0, 2474, 2475, 7, 5, 0, 0, 2475, 2476, 7, 0, 0, 0, 2476, 2477, 7, 10, 0, 0, 2477, 2478, 7, 19, 0, 0, 2478, 2479, 7, 4, 0, 0, 2479, 464, 1, 0, 0, 0, 2480, 2481, 7, 5, 0, 0, 2481, 2482, 7, 4, 0, 0, 2482, 2483, 7, 0, 0, 0, 2483, 2484, 7, 6, 0, 0, 2484, 466, 1, 0, 0, 0, 2485, 2486, 7, 5, 0, 0, 2486, 2487, 7, 4, 0, 0, 2487, 2488, 7, 15, 0, 0, 2488, 2489, 7, 17, 0, 0, 2489, 2490, 7, 5, 0, 0, 2490, 2491, 7, 1, 0, 0, 2491, 2492, 7, 5, 0, 0, 2492, 2493, 7, 4, 0, 0, 2493, 2494, 7, 0, 0, 0, 2494, 2495, 7, 1, 0, 0, 2495, 2496, 7, 4, 0, 0, 2496, 2497, 7, 5, 0, 0, 2497, 468, 1, 0, 0, 0, 2498, 2499, 7, 5, 0, 0, 2499, 2500, 7, 4, 0, 0, 2500, 2501, 7, 15, 0, 0, 2501, 2502, 7, 17, 0, 0, 2502, 2503, 7, 5, 0, 0, 2503, 2504, 7, 1, 0, 0, 2504, 2505, 7, 7, 0, 0, 2505, 2506, 7, 5, 0, 0, 2506, 2507, 7, 12, 0, 0, 2507, 2508, 7, 3, 0, 0, 2508, 2509, 7, 4, 0, 0, 2509, 2510, 7, 5, 0, 0, 2510, 470, 1, 0, 0, 0, 2511, 2512, 7, 5, 0, 0, 2512, 2513, 7, 4, 0, 0, 2513, 2514, 7, 15, 0, 0, 2514, 2515, 7, 17, 0, 0, 2515, 2516, 7, 13, 0, 0, 2516, 2517, 7, 4, 0, 0, 2517, 2518, 7, 5, 0, 0, 2518, 472, 1, 0, 0, 0, 2519, 2520, 7, 5, 0, 0, 2520, 2521, 7, 4, 0, 0, 2521, 2522, 7, 1, 0, 0, 2522, 2523, 7, 14, 0, 0, 2523, 2524, 7, 15, 0, 0, 2524, 2525, 7, 4, 0, 0, 2525, 474, 1, 0, 0, 0, 2526, 2527, 7, 5, 0, 0, 2527, 2528, 7, 4, 0, 0, 2528, 2529, 7, 2, 0, 0, 2529, 2530, 7, 4, 0, 0, 2530, 2531, 7, 5, 0, 0, 2531, 2532, 7, 4, 0, 0, 2532, 2533, 7, 10, 0, 0, 2533, 2534, 7, 15, 0, 0, 2534, 2535, 7, 4, 0, 0, 2535, 2536, 7, 9, 0, 0, 2536, 476, 1, 0, 0, 0, 2537, 2538, 7, 5, 0, 0, 2538, 2539, 7, 4, 0, 0, 2539, 2540, 7, 2, 0, 0, 2540, 2541, 7, 5, 0, 0, 2541, 2542, 7, 4, 0, 0, 2542, 2543, 7, 9, 0, 0, 2543, 2544, 7, 16, 0, 0, 2544, 478, 1, 0, 0, 0, 2545, 2546, 7, 5, 0, 0, 2546, 2547, 7, 4, 0, 0, 2547, 2548, 7, 10, 0, 0, 2548, 2549, 7, 0, 0, 0, 2549, 2550, 7, 21, 0, 0, 2550, 2551, 7, 4, 0, 0, 2551, 480, 1, 0, 0, 0, 2552, 2553, 7, 5, 0, 0, 2553, 2554, 7, 4, 0, 0, 2554, 2555, 7, 22, 0, 0, 2555, 2556, 7, 0, 0, 0, 2556, 2557, 7, 12, 0, 0, 2557, 2558, 7, 5, 0, 0, 2558, 482, 1, 0, 0, 0, 2559, 2560, 7, 5, 0, 0, 2560, 2561, 7, 4, 0, 0, 2561, 2562, 7, 22, 0, 0, 2562, 2563, 7, 4, 0, 0, 2563, 2564, 7, 0, 0, 0, 2564, 2565, 7, 3, 0, 0, 2565, 2566, 7, 0, 0, 0, 2566, 2567, 7, 18, 0, 0, 2567, 2568, 7, 6, 0, 0, 2568, 2569, 7, 4, 0, 0, 2569, 484, 1, 0, 0, 0, 2570, 2571, 7, 5, 0, 0, 2571, 2572, 7, 4, 0, 0, 2572, 2573, 7, 22, 0, 0, 2573, 2574, 7, 6, 0, 0, 2574, 2575, 7, 0, 0, 0, 2575, 2576, 7, 15, 0, 0, 2576, 2577, 7, 4, 0, 0, 2577, 486, 1, 0, 0, 0, 2578, 2579, 7, 5, 0, 0, 2579, 2580, 7, 4, 0, 0, 2580, 2581, 7, 9, 0, 0, 2581, 2582, 7, 4, 0, 0, 2582, 2583, 7, 3, 0, 0, 2583, 488, 1, 0, 0, 0, 2584, 2585, 7, 5, 0, 0, 2585, 2586, 7, 4, 0, 0, 2586, 2587, 7, 9, 0, 0, 2587, 2588, 7, 22, 0, 0, 2588, 2589, 7, 4, 0, 0, 2589, 2590, 7, 15, 0, 0, 2590, 2591, 7, 3, 0, 0, 2591, 490, 1, 0, 0, 0, 2592, 2593, 7, 5, 0, 0, 2593, 2594, 7, 4, 0, 0, 2594, 2595, 7, 9, 0, 0, 2595, 2596, 7, 3, 0, 0, 2596, 2597, 7, 5, 0, 0, 2597, 2598, 7, 12, 0, 0, 2598, 2599, 7, 15, 0, 0, 2599, 2600, 7, 3, 0, 0, 2600, 492, 1, 0, 0, 0, 2601, 2602, 7, 5, 0, 0, 2602, 2603, 7, 4, 0, 0, 2603, 2604, 7, 7, 0, 0, 2604, 2605, 7, 5, 0, 0, 2605, 2606, 7, 12, 0, 0, 2606, 2607, 7, 3, 0, 0, 2607, 2608, 7, 4, 0, 0, 2608, 494, 1, 0, 0, 0, 2609, 2610, 7, 5, 0, 0, 2610, 2611, 7, 4, 0, 0, 2611, 2612, 7, 13, 0, 0, 2612, 2613, 7, 17, 0, 0, 2613, 2614, 7, 20, 0, 0, 2614, 2615, 7, 4, 0, 0, 2615, 496, 1, 0, 0, 0, 2616, 2617, 7, 5, 0, 0, 2617, 2618, 7, 12, 0, 0, 2618, 2619, 7, 19, 0, 0, 2619, 2620, 7, 16, 0, 0, 2620, 2621, 7, 3, 0, 0, 2621, 498, 1, 0, 0, 0, 2622, 2623, 7, 5, 0, 0, 2623, 2624, 7, 6, 0, 0, 2624, 2625, 7, 12, 0, 0, 2625, 2626, 7, 20, 0, 0, 2626, 2627, 7, 4, 0, 0, 2627, 500, 1, 0, 0, 0, 2628, 2629, 7, 5, 0, 0, 2629, 2630, 7, 4, 0, 0, 2630, 2631, 7, 19, 0, 0, 2631, 2632, 7, 4, 0, 0, 2632, 2633, 7, 23, 0, 0, 2633, 2634, 7, 22, 0, 0, 2634, 502, 1, 0, 0, 0, 2635, 2636, 7, 5, 0, 0, 2636, 2637, 7, 17, 0, 0, 2637, 2638, 7, 6, 0, 0, 2638, 2639, 7, 4, 0, 0, 2639, 504, 1, 0, 0, 0, 2640, 2641, 7, 5, 0, 0, 2641, 2642, 7, 17, 0, 0, 2642, 2643, 7, 6, 0, 0, 2643, 2644, 7, 4, 0, 0, 2644, 2645, 7, 9, 0, 0, 2645, 506, 1, 0, 0, 0, 2646, 2647, 7, 5, 0, 0, 2647, 2648, 7, 17, 0, 0, 2648, 2649, 7, 6, 0, 0, 2649, 2650, 7, 6, 0, 0, 2650, 2651, 7, 18, 0, 0, 2651, 2652, 7, 0, 0, 0, 2652, 2653, 7, 15, 0, 0, 2653, 2654, 7, 20, 0, 0, 2654, 508, 1, 0, 0, 0, 2655, 2656, 7, 5, 0, 0, 2656, 2657, 7, 17, 0, 0, 2657, 2658, 7, 6, 0, 0, 2658, 2659, 7, 6, 0, 0, 2659, 2660, 7, 14, 0, 0, 2660, 2661, 7, 22, 0, 0, 2661, 510, 1, 0, 0, 0, 2662, 2663, 7, 5, 0, 0, 2663, 2664, 7, 17, 0, 0, 2664, 2665, 7, 7, 0, 0, 2665, 512, 1, 0, 0, 0, 2666, 2667, 7, 5, 0, 0, 2667, 2668, 7, 17, 0, 0, 2668, 2669, 7, 7, 0, 0, 2669, 2670, 7, 9, 0, 0, 2670, 514, 1, 0, 0, 0, 2671, 2672, 7, 9, 0, 0, 2672, 2673, 7, 4, 0, 0, 2673, 2674, 7, 15, 0, 0, 2674, 2675, 7, 17, 0, 0, 2675, 2676, 7, 10, 0, 0, 2676, 2677, 7, 1, 0, 0, 2677, 516, 1, 0, 0, 0, 2678, 2679, 7, 9, 0, 0, 2679, 2680, 7, 4, 0, 0, 2680, 2681, 7, 15, 0, 0, 2681, 2682, 7, 17, 0, 0, 2682, 2683, 7, 10, 0, 0, 2683, 2684, 7, 1, 0, 0, 2684, 2685, 7, 9, 0, 0, 2685, 518, 1, 0, 0, 0, 2686, 2687, 7, 9, 0, 0, 2687, 2688, 7, 15, 0, 0, 2688, 2689, 7, 16, 0, 0, 2689, 2690, 7, 4, 0, 0, 2690, 2691, 7, 21, 0, 0, 2691, 2692, 7, 0, 0, 0, 2692, 520, 1, 0, 0, 0, 2693, 2694, 7, 9, 0, 0, 2694, 2695, 7, 15, 0, 0, 2695, 2696, 7, 16, 0, 0, 2696, 2697, 7, 4, 0, 0, 2697, 2698, 7, 21, 0, 0, 2698, 2699, 7, 0, 0, 0, 2699, 2700, 7, 9, 0, 0, 2700, 522, 1, 0, 0, 0, 2701, 2702, 7, 9, 0, 0, 2702, 2703, 7, 4, 0, 0, 2703, 2704, 7, 6, 0, 0, 2704, 2705, 7, 4, 0, 0, 2705, 2706, 7, 15, 0, 0, 2706, 2707, 7, 3, 0, 0, 2707, 524, 1, 0, 0, 0, 2708, 2709, 7, 9, 0, 0, 2709, 2710, 7, 4, 0, 0, 2710, 2711, 7, 21, 0, 0, 2711, 2712, 7, 12, 0, 0, 2712, 526, 1, 0, 0, 0, 2713, 2714, 7, 9, 0, 0, 2714, 2715, 7, 4, 0, 0, 2715, 2716, 7, 22, 0, 0, 2716, 2717, 7, 0, 0, 0, 2717, 2718, 7, 5, 0, 0, 2718, 2719, 7, 0, 0, 0, 2719, 2720, 7, 3, 0, 0, 2720, 2721, 7, 4, 0, 0, 2721, 2722, 7, 1, 0, 0, 2722, 528, 1, 0, 0, 0, 2723, 2724, 7, 9, 0, 0, 2724, 2725, 7, 4, 0, 0, 2725, 2726, 7, 5, 0, 0, 2726, 2727, 7, 1, 0, 0, 2727, 2728, 7, 4, 0, 0, 2728, 530, 1, 0, 0, 0, 2729, 2730, 7, 9, 0, 0, 2730, 2731, 7, 4, 0, 0, 2731, 2732, 7, 5, 0, 0, 2732, 2733, 7, 1, 0, 0, 2733, 2734, 7, 4, 0, 0, 2734, 2735, 7, 22, 0, 0, 2735, 2736, 7, 5, 0, 0, 2736, 2737, 7, 17, 0, 0, 2737, 2738, 7, 22, 0, 0, 2738, 2739, 7, 4, 0, 0, 2739, 2740, 7, 5, 0, 0, 2740, 2741, 7, 3, 0, 0, 2741, 2742, 7, 12, 0, 0, 2742, 2743, 7, 4, 0, 0, 2743, 2744, 7, 9, 0, 0, 2744, 532, 1, 0, 0, 0, 2745, 2746, 7, 9, 0, 0, 2746, 2747, 7, 4, 0, 0, 2747, 2748, 7, 9, 0, 0, 2748, 2749, 7, 9, 0, 0, 2749, 2750, 7, 12, 0, 0, 2750, 2751, 7, 17, 0, 0, 2751, 2752, 7, 10, 0, 0, 2752, 2753, 5, 95, 0, 0, 2753, 2754, 7, 14, 0, 0, 2754, 2755, 7, 9, 0, 0, 2755, 2756, 7, 4, 0, 0, 2756, 2757, 7, 5, 0, 0, 2757, 534, 1, 0, 0, 0, 2758, 2759, 7, 9, 0, 0, 2759, 2760, 7, 4, 0, 0, 2760, 2761, 7, 3, 0, 0, 2761, 536, 1, 0, 0, 0, 2762, 2763, 7, 21, 0, 0, 2763, 2764, 7, 12, 0, 0, 2764, 2765, 7, 10, 0, 0, 2765, 2766, 7, 14, 0, 0, 2766, 2767, 7, 9, 0, 0, 2767, 538, 1, 0, 0, 0, 2768, 2769, 7, 9, 0, 0, 2769, 2770, 7, 4, 0, 0, 2770, 2771, 7, 3, 0, 0, 2771, 2772, 7, 9, 0, 0, 2772, 540, 1, 0, 0, 0, 2773, 2774, 7, 9, 0, 0, 2774, 2775, 7, 16, 0, 0, 2775, 2776, 7, 17, 0, 0, 2776, 2777, 7, 5, 0, 0, 2777, 2778, 7, 3, 0, 0, 2778, 542, 1, 0, 0, 0, 2779, 2780, 7, 9, 0, 0, 2780, 2781, 7, 16, 0, 0, 2781, 2782, 7, 17, 0, 0, 2782, 2783, 7, 7, 0, 0, 2783, 544, 1, 0, 0, 0, 2784, 2785, 7, 9, 0, 0, 2785, 2786, 7, 12, 0, 0, 2786, 2787, 7, 10, 0, 0, 2787, 2788, 7, 19, 0, 0, 2788, 2789, 7, 6, 0, 0, 2789, 2790, 7, 4, 0, 0, 2790, 546, 1, 0, 0, 0, 2791, 2792, 7, 9, 0, 0, 2792, 2793, 7, 20, 0, 0, 2793, 2794, 7, 4, 0, 0, 2794, 2795, 7, 7, 0, 0, 2795, 2796, 7, 4, 0, 0, 2796, 2797, 7, 1, 0, 0, 2797, 548, 1, 0, 0, 0, 2798, 2799, 7, 9, 0, 0, 2799, 2800, 7, 21, 0, 0, 2800, 2801, 7, 0, 0, 0, 2801, 2802, 7, 6, 0, 0, 2802, 2803, 7, 6, 0, 0, 2803, 2804, 7, 12, 0, 0, 2804, 2805, 7, 10, 0, 0, 2805, 2806, 7, 3, 0, 0, 2806, 550, 1, 0, 0, 0, 2807, 2808, 7, 9, 0, 0, 2808, 2809, 7, 17, 0, 0, 2809, 2810, 7, 21, 0, 0, 2810, 2811, 7, 4, 0, 0, 2811, 552, 1, 0, 0, 0, 2812, 2813, 7, 9, 0, 0, 2813, 2814, 7, 17, 0, 0, 2814, 2815, 7, 5, 0, 0, 2815, 2816, 7, 3, 0, 0, 2816, 554, 1, 0, 0, 0, 2817, 2818, 7, 9, 0, 0, 2818, 2819, 7, 17, 0, 0, 2819, 2820, 7, 5, 0, 0, 2820, 2821, 7, 3, 0, 0, 2821, 2822, 7, 4, 0, 0, 2822, 2823, 7, 1, 0, 0, 2823, 556, 1, 0, 0, 0, 2824, 2825, 7, 9, 0, 0, 2825, 2826, 7, 17, 0, 0, 2826, 2827, 7, 14, 0, 0, 2827, 2828, 7, 5, 0, 0, 2828, 2829, 7, 15, 0, 0, 2829, 2830, 7, 4, 0, 0, 2830, 558, 1, 0, 0, 0, 2831, 2832, 7, 9, 0, 0, 2832, 2833, 7, 3, 0, 0, 2833, 2834, 7, 0, 0, 0, 2834, 2835, 7, 5, 0, 0, 2835, 2836, 7, 3, 0, 0, 2836, 560, 1, 0, 0, 0, 2837, 2838, 7, 9, 0, 0, 2838, 2839, 7, 3, 0, 0, 2839, 2840, 7, 0, 0, 0, 2840, 2841, 7, 3, 0, 0, 2841, 2842, 7, 12, 0, 0, 2842, 2843, 7, 9, 0, 0, 2843, 2844, 7, 3, 0, 0, 2844, 2845, 7, 12, 0, 0, 2845, 2846, 7, 15, 0, 0, 2846, 2847, 7, 9, 0, 0, 2847, 562, 1, 0, 0, 0, 2848, 2849, 7, 9, 0, 0, 2849, 2850, 7, 3, 0, 0, 2850, 2851, 7, 17, 0, 0, 2851, 2852, 7, 5, 0, 0, 2852, 2853, 7, 4, 0, 0, 2853, 2854, 7, 1, 0, 0, 2854, 564, 1, 0, 0, 0, 2855, 2856, 7, 9, 0, 0, 2856, 2857, 7, 3, 0, 0, 2857, 2858, 7, 5, 0, 0, 2858, 2859, 7, 0, 0, 0, 2859, 2860, 7, 3, 0, 0, 2860, 2861, 7, 12, 0, 0, 2861, 2862, 7, 2, 0, 0, 2862, 2863, 7, 8, 0, 0, 2863, 566, 1, 0, 0, 0, 2864, 2865, 7, 9, 0, 0, 2865, 2866, 7, 3, 0, 0, 2866, 2867, 7, 5, 0, 0, 2867, 2868, 7, 12, 0, 0, 2868, 2869, 7, 10, 0, 0, 2869, 2870, 7, 19, 0, 0, 2870, 568, 1, 0, 0, 0, 2871, 2872, 7, 9, 0, 0, 2872, 2873, 7, 3, 0, 0, 2873, 2874, 7, 5, 0, 0, 2874, 2875, 7, 14, 0, 0, 2875, 2876, 7, 15, 0, 0, 2876, 2877, 7, 3, 0, 0, 2877, 570, 1, 0, 0, 0, 2878, 2879, 7, 9, 0, 0, 2879, 2880, 7, 14, 0, 0, 2880, 2881, 7, 18, 0, 0, 2881, 2882, 7, 9, 0, 0, 2882, 2883, 7, 3, 0, 0, 2883, 2884, 7, 5, 0, 0, 2884, 572, 1, 0, 0, 0, 2885, 2886, 7, 9, 0, 0, 2886, 2887, 7, 14, 0, 0, 2887, 2888, 7, 18, 0, 0, 2888, 2889, 7, 9, 0, 0, 2889, 2890, 7, 3, 0, 0, 2890, 2891, 7, 5, 0, 0, 2891, 2892, 7, 12, 0, 0, 2892, 2893, 7, 10, 0, 0, 2893, 2894, 7, 19, 0, 0, 2894, 574, 1, 0, 0, 0, 2895, 2896, 7, 9, 0, 0, 2896, 2897, 7, 8, 0, 0, 2897, 2898, 7, 10, 0, 0, 2898, 2899, 7, 15, 0, 0, 2899, 576, 1, 0, 0, 0, 2900, 2901, 7, 9, 0, 0, 2901, 2902, 7, 8, 0, 0, 2902, 2903, 7, 9, 0, 0, 2903, 2904, 7, 3, 0, 0, 2904, 2905, 7, 4, 0, 0, 2905, 2906, 7, 21, 0, 0, 2906, 578, 1, 0, 0, 0, 2907, 2908, 7, 9, 0, 0, 2908, 2909, 7, 8, 0, 0, 2909, 2910, 7, 9, 0, 0, 2910, 2911, 7, 3, 0, 0, 2911, 2912, 7, 4, 0, 0, 2912, 2913, 7, 21, 0, 0, 2913, 2914, 5, 95, 0, 0, 2914, 2915, 7, 3, 0, 0, 2915, 2916, 7, 12, 0, 0, 2916, 2917, 7, 21, 0, 0, 2917, 2918, 7, 4, 0, 0, 2918, 580, 1, 0, 0, 0, 2919, 2920, 7, 9, 0, 0, 2920, 2921, 7, 8, 0, 0, 2921, 2922, 7, 9, 0, 0, 2922, 2923, 7, 3, 0, 0, 2923, 2924, 7, 4, 0, 0, 2924, 2925, 7, 21, 0, 0, 2925, 2926, 5, 95, 0, 0, 2926, 2927, 7, 13, 0, 0, 2927, 2928, 7, 4, 0, 0, 2928, 2929, 7, 5, 0, 0, 2929, 2930, 7, 9, 0, 0, 2930, 2931, 7, 12, 0, 0, 2931, 2932, 7, 17, 0, 0, 2932, 2933, 7, 10, 0, 0, 2933, 582, 1, 0, 0, 0, 2934, 2935, 7, 3, 0, 0, 2935, 2936, 7, 0, 0, 0, 2936, 2937, 7, 18, 0, 0, 2937, 2938, 7, 6, 0, 0, 2938, 2939, 7, 4, 0, 0, 2939, 584, 1, 0, 0, 0, 2940, 2941, 7, 3, 0, 0, 2941, 2942, 7, 0, 0, 0, 2942, 2943, 7, 18, 0, 0, 2943, 2944, 7, 6, 0, 0, 2944, 2945, 7, 4, 0, 0, 2945, 2946, 7, 9, 0, 0, 2946, 586, 1, 0, 0, 0, 2947, 2948, 7, 3, 0, 0, 2948, 2949, 7, 0, 0, 0, 2949, 2950, 7, 18, 0, 0, 2950, 2951, 7, 6, 0, 0, 2951, 2952, 7, 4, 0, 0, 2952, 2953, 7, 9, 0, 0, 2953, 2954, 7, 0, 0, 0, 2954, 2955, 7, 21, 0, 0, 2955, 2956, 7, 22, 0, 0, 2956, 2957, 7, 6, 0, 0, 2957, 2958, 7, 4, 0, 0, 2958, 588, 1, 0, 0, 0, 2959, 2960, 7, 3, 0, 0, 2960, 2961, 7, 0, 0, 0, 2961, 2962, 7, 5, 0, 0, 2962, 2963, 7, 19, 0, 0, 2963, 2964, 7, 4, 0, 0, 2964, 2965, 7, 3, 0, 0, 2965, 590, 1, 0, 0, 0, 2966, 2967, 7, 3, 0, 0, 2967, 2968, 7, 18, 0, 0, 2968, 2969, 7, 6, 0, 0, 2969, 2970, 7, 22, 0, 0, 2970, 2971, 7, 5, 0, 0, 2971, 2972, 7, 17, 0, 0, 2972, 2973, 7, 22, 0, 0, 2973, 2974, 7, 4, 0, 0, 2974, 2975, 7, 5, 0, 0, 2975, 2976, 7, 3, 0, 0, 2976, 2977, 7, 12, 0, 0, 2977, 2978, 7, 4, 0, 0, 2978, 2979, 7, 9, 0, 0, 2979, 592, 1, 0, 0, 0, 2980, 2981, 7, 3, 0, 0, 2981, 2982, 7, 4, 0, 0, 2982, 2983, 7, 21, 0, 0, 2983, 2984, 7, 22, 0, 0, 2984, 2985, 7, 17, 0, 0, 2985, 2986, 7, 5, 0, 0, 2986, 2987, 7, 0, 0, 0, 2987, 2988, 7, 5, 0, 0, 2988, 2989, 7, 8, 0, 0, 2989, 594, 1, 0, 0, 0, 2990, 2991, 7, 3, 0, 0, 2991, 2992, 7, 4, 0, 0, 2992, 2993, 7, 5, 0, 0, 2993, 2994, 7, 21, 0, 0, 2994, 2995, 7, 12, 0, 0, 2995, 2996, 7, 10, 0, 0, 2996, 2997, 7, 0, 0, 0, 2997, 2998, 7, 3, 0, 0, 2998, 2999, 7, 4, 0, 0, 2999, 3000, 7, 1, 0, 0, 3000, 596, 1, 0, 0, 0, 3001, 3002, 7, 3, 0, 0, 3002, 3003, 7, 16, 0, 0, 3003, 3004, 7, 4, 0, 0, 3004, 3005, 7, 10, 0, 0, 3005, 598, 1, 0, 0, 0, 3006, 3007, 7, 3, 0, 0, 3007, 3008, 7, 12, 0, 0, 3008, 3009, 7, 21, 0, 0, 3009, 3010, 7, 4, 0, 0, 3010, 600, 1, 0, 0, 0, 3011, 3012, 7, 3, 0, 0, 3012, 3013, 7, 12, 0, 0, 3013, 3014, 7, 21, 0, 0, 3014, 3015, 7, 4, 0, 0, 3015, 3016, 7, 1, 0, 0, 3016, 3017, 7, 12, 0, 0, 3017, 3018, 7, 2, 0, 0, 3018, 3019, 7, 2, 0, 0, 3019, 602, 1, 0, 0, 0, 3020, 3021, 7, 3, 0, 0, 3021, 3022, 7, 12, 0, 0, 3022, 3023, 7, 21, 0, 0, 3023, 3024, 7, 4, 0, 0, 3024, 3025, 7, 9, 0, 0, 3025, 3026, 7, 3, 0, 0, 3026, 3027, 7, 0, 0, 0, 3027, 3028, 7, 21, 0, 0, 3028, 3029, 7, 22, 0, 0, 3029, 604, 1, 0, 0, 0, 3030, 3031, 7, 3, 0, 0, 3031, 3032, 7, 12, 0, 0, 3032, 3033, 7, 21, 0, 0, 3033, 3034, 7, 4, 0, 0, 3034, 3035, 7, 9, 0, 0, 3035, 3036, 7, 3, 0, 0, 3036, 3037, 7, 0, 0, 0, 3037, 3038, 7, 21, 0, 0, 3038, 3039, 7, 22, 0, 0, 3039, 3040, 5, 95, 0, 0, 3040, 3041, 7, 6, 0, 0, 3041, 3042, 7, 3, 0, 0, 3042, 3043, 7, 11, 0, 0, 3043, 606, 1, 0, 0, 0, 3044, 3045, 7, 3, 0, 0, 3045, 3046, 7, 12, 0, 0, 3046, 3047, 7, 21, 0, 0, 3047, 3048, 7, 4, 0, 0, 3048, 3049, 7, 9, 0, 0, 3049, 3050, 7, 3, 0, 0, 3050, 3051, 7, 0, 0, 0, 3051, 3052, 7, 21, 0, 0, 3052, 3053, 7, 22, 0, 0, 3053, 3054, 5, 95, 0, 0, 3054, 3055, 7, 10, 0, 0, 3055, 3056, 7, 3, 0, 0, 3056, 3057, 7, 11, 0, 0, 3057, 608, 1, 0, 0, 0, 3058, 3059, 7, 3, 0, 0, 3059, 3060, 7, 12, 0, 0, 3060, 3061, 7, 21, 0, 0, 3061, 3062, 7, 4, 0, 0, 3062, 3063, 7, 9, 0, 0, 3063, 3064, 7, 3, 0, 0, 3064, 3065, 7, 0, 0, 0, 3065, 3066, 7, 21, 0, 0, 3066, 3067, 7, 22, 0, 0, 3067, 3068, 7, 0, 0, 0, 3068, 3069, 7, 1, 0, 0, 3069, 3070, 7, 1, 0, 0, 3070, 610, 1, 0, 0, 0, 3071, 3072, 7, 3, 0, 0, 3072, 3073, 7, 12, 0, 0, 3073, 3074, 7, 21, 0, 0, 3074, 3075, 7, 4, 0, 0, 3075, 3076, 7, 9, 0, 0, 3076, 3077, 7, 3, 0, 0, 3077, 3078, 7, 0, 0, 0, 3078, 3079, 7, 21, 0, 0, 3079, 3080, 7, 22, 0, 0, 3080, 3081, 7, 1, 0, 0, 3081, 3082, 7, 12, 0, 0, 3082, 3083, 7, 2, 0, 0, 3083, 3084, 7, 2, 0, 0, 3084, 612, 1, 0, 0, 0, 3085, 3086, 7, 3, 0, 0, 3086, 3087, 7, 12, 0, 0, 3087, 3088, 7, 10, 0, 0, 3088, 3089, 7, 8, 0, 0, 3089, 3090, 7, 12, 0, 0, 3090, 3091, 7, 10, 0, 0, 3091, 3092, 7, 3, 0, 0, 3092, 614, 1, 0, 0, 0, 3093, 3094, 7, 3, 0, 0, 3094, 3095, 7, 17, 0, 0, 3095, 616, 1, 0, 0, 0, 3096, 3097, 7, 3, 0, 0, 3097, 3098, 7, 17, 0, 0, 3098, 3099, 7, 14, 0, 0, 3099, 3100, 7, 15, 0, 0, 3100, 3101, 7, 16, 0, 0, 3101, 618, 1, 0, 0, 0, 3102, 3103, 7, 3, 0, 0, 3103, 3104, 7, 5, 0, 0, 3104, 3105, 7, 0, 0, 0, 3105, 3106, 7, 12, 0, 0, 3106, 3107, 7, 6, 0, 0, 3107, 3108, 7, 12, 0, 0, 3108, 3109, 7, 10, 0, 0, 3109, 3110, 7, 19, 0, 0, 3110, 620, 1, 0, 0, 0, 3111, 3112, 7, 3, 0, 0, 3112, 3113, 7, 5, 0, 0, 3113, 3114, 7, 0, 0, 0, 3114, 3115, 7, 10, 0, 0, 3115, 3116, 7, 9, 0, 0, 3116, 3117, 7, 0, 0, 0, 3117, 3118, 7, 15, 0, 0, 3118, 3119, 7, 3, 0, 0, 3119, 3120, 7, 12, 0, 0, 3120, 3121, 7, 17, 0, 0, 3121, 3122, 7, 10, 0, 0, 3122, 622, 1, 0, 0, 0, 3123, 3124, 7, 3, 0, 0, 3124, 3125, 7, 5, 0, 0, 3125, 3126, 7, 0, 0, 0, 3126, 3127, 7, 10, 0, 0, 3127, 3128, 7, 9, 0, 0, 3128, 3129, 7, 0, 0, 0, 3129, 3130, 7, 15, 0, 0, 3130, 3131, 7, 3, 0, 0, 3131, 3132, 7, 12, 0, 0, 3132, 3133, 7, 17, 0, 0, 3133, 3134, 7, 10, 0, 0, 3134, 3135, 7, 9, 0, 0, 3135, 624, 1, 0, 0, 0, 3136, 3137, 7, 3, 0, 0, 3137, 3138, 7, 5, 0, 0, 3138, 3139, 7, 0, 0, 0, 3139, 3140, 7, 10, 0, 0, 3140, 3141, 7, 9, 0, 0, 3141, 3142, 7, 2, 0, 0, 3142, 3143, 7, 17, 0, 0, 3143, 3144, 7, 5, 0, 0, 3144, 3145, 7, 21, 0, 0, 3145, 626, 1, 0, 0, 0, 3146, 3147, 7, 3, 0, 0, 3147, 3148, 7, 5, 0, 0, 3148, 3149, 7, 12, 0, 0, 3149, 3150, 7, 21, 0, 0, 3150, 628, 1, 0, 0, 0, 3151, 3152, 7, 3, 0, 0, 3152, 3153, 7, 5, 0, 0, 3153, 3154, 7, 14, 0, 0, 3154, 3155, 7, 4, 0, 0, 3155, 630, 1, 0, 0, 0, 3156, 3157, 7, 3, 0, 0, 3157, 3158, 7, 5, 0, 0, 3158, 3159, 7, 14, 0, 0, 3159, 3160, 7, 10, 0, 0, 3160, 3161, 7, 15, 0, 0, 3161, 3162, 7, 0, 0, 0, 3162, 3163, 7, 3, 0, 0, 3163, 3164, 7, 4, 0, 0, 3164, 632, 1, 0, 0, 0, 3165, 3166, 7, 3, 0, 0, 3166, 3167, 7, 5, 0, 0, 3167, 3168, 7, 8, 0, 0, 3168, 3169, 5, 95, 0, 0, 3169, 3170, 7, 15, 0, 0, 3170, 3171, 7, 0, 0, 0, 3171, 3172, 7, 9, 0, 0, 3172, 3173, 7, 3, 0, 0, 3173, 634, 1, 0, 0, 0, 3174, 3175, 7, 3, 0, 0, 3175, 3176, 7, 8, 0, 0, 3176, 3177, 7, 22, 0, 0, 3177, 3178, 7, 4, 0, 0, 3178, 636, 1, 0, 0, 0, 3179, 3180, 7, 14, 0, 0, 3180, 3181, 7, 10, 0, 0, 3181, 3182, 7, 0, 0, 0, 3182, 3183, 7, 5, 0, 0, 3183, 3184, 7, 15, 0, 0, 3184, 3185, 7, 16, 0, 0, 3185, 3186, 7, 12, 0, 0, 3186, 3187, 7, 13, 0, 0, 3187, 3188, 7, 4, 0, 0, 3188, 638, 1, 0, 0, 0, 3189, 3190, 7, 14, 0, 0, 3190, 3191, 7, 10, 0, 0, 3191, 3192, 7, 18, 0, 0, 3192, 3193, 7, 17, 0, 0, 3193, 3194, 7, 14, 0, 0, 3194, 3195, 7, 10, 0, 0, 3195, 3196, 7, 1, 0, 0, 3196, 3197, 7, 4, 0, 0, 3197, 3198, 7, 1, 0, 0, 3198, 640, 1, 0, 0, 0, 3199, 3200, 7, 14, 0, 0, 3200, 3201, 7, 10, 0, 0, 3201, 3202, 7, 15, 0, 0, 3202, 3203, 7, 0, 0, 0, 3203, 3204, 7, 15, 0, 0, 3204, 3205, 7, 16, 0, 0, 3205, 3206, 7, 4, 0, 0, 3206, 642, 1, 0, 0, 0, 3207, 3208, 7, 14, 0, 0, 3208, 3209, 7, 10, 0, 0, 3209, 3210, 7, 12, 0, 0, 3210, 3211, 7, 17, 0, 0, 3211, 3212, 7, 10, 0, 0, 3212, 644, 1, 0, 0, 0, 3213, 3214, 7, 14, 0, 0, 3214, 3215, 7, 10, 0, 0, 3215, 3216, 7, 12, 0, 0, 3216, 3217, 7, 25, 0, 0, 3217, 3218, 7, 14, 0, 0, 3218, 3219, 7, 4, 0, 0, 3219, 646, 1, 0, 0, 0, 3220, 3221, 7, 14, 0, 0, 3221, 3222, 7, 10, 0, 0, 3222, 3223, 7, 20, 0, 0, 3223, 3224, 7, 10, 0, 0, 3224, 3225, 7, 17, 0, 0, 3225, 3226, 7, 7, 0, 0, 3226, 3227, 7, 10, 0, 0, 3227, 648, 1, 0, 0, 0, 3228, 3229, 7, 14, 0, 0, 3229, 3230, 7, 10, 0, 0, 3230, 3231, 7, 6, 0, 0, 3231, 3232, 7, 17, 0, 0, 3232, 3233, 7, 15, 0, 0, 3233, 3234, 7, 20, 0, 0, 3234, 650, 1, 0, 0, 0, 3235, 3236, 7, 14, 0, 0, 3236, 3237, 7, 10, 0, 0, 3237, 3238, 7, 22, 0, 0, 3238, 3239, 7, 12, 0, 0, 3239, 3240, 7, 13, 0, 0, 3240, 3241, 7, 17, 0, 0, 3241, 3242, 7, 3, 0, 0, 3242, 652, 1, 0, 0, 0, 3243, 3244, 7, 14, 0, 0, 3244, 3245, 7, 10, 0, 0, 3245, 3246, 7, 9, 0, 0, 3246, 3247, 7, 4, 0, 0, 3247, 3248, 7, 3, 0, 0, 3248, 654, 1, 0, 0, 0, 3249, 3250, 7, 14, 0, 0, 3250, 3251, 7, 22, 0, 0, 3251, 3252, 7, 1, 0, 0, 3252, 3253, 7, 0, 0, 0, 3253, 3254, 7, 3, 0, 0, 3254, 3255, 7, 4, 0, 0, 3255, 656, 1, 0, 0, 0, 3256, 3257, 7, 14, 0, 0, 3257, 3258, 7, 9, 0, 0, 3258, 3259, 7, 4, 0, 0, 3259, 658, 1, 0, 0, 0, 3260, 3261, 7, 14, 0, 0, 3261, 3262, 7, 9, 0, 0, 3262, 3263, 7, 4, 0, 0, 3263, 3264, 7, 5, 0, 0, 3264, 660, 1, 0, 0, 0, 3265, 3266, 7, 14, 0, 0, 3266, 3267, 7, 9, 0, 0, 3267, 3268, 7, 12, 0, 0, 3268, 3269, 7, 10, 0, 0, 3269, 3270, 7, 19, 0, 0, 3270, 662, 1, 0, 0, 0, 3271, 3272, 7, 13, 0, 0, 3272, 3273, 7, 0, 0, 0, 3273, 3274, 7, 6, 0, 0, 3274, 3275, 7, 14, 0, 0, 3275, 3276, 7, 4, 0, 0, 3276, 3277, 7, 9, 0, 0, 3277, 664, 1, 0, 0, 0, 3278, 3279, 7, 13, 0, 0, 3279, 3280, 7, 0, 0, 0, 3280, 3281, 7, 5, 0, 0, 3281, 3282, 7, 15, 0, 0, 3282, 3283, 7, 16, 0, 0, 3283, 3284, 7, 0, 0, 0, 3284, 3285, 7, 5, 0, 0, 3285, 666, 1, 0, 0, 0, 3286, 3287, 7, 13, 0, 0, 3287, 3288, 7, 0, 0, 0, 3288, 3289, 7, 5, 0, 0, 3289, 668, 1, 0, 0, 0, 3290, 3291, 7, 13, 0, 0, 3291, 3292, 7, 0, 0, 0, 3292, 3293, 7, 5, 0, 0, 3293, 3294, 7, 12, 0, 0, 3294, 3295, 7, 0, 0, 0, 3295, 3296, 7, 18, 0, 0, 3296, 3297, 7, 6, 0, 0, 3297, 3298, 7, 4, 0, 0, 3298, 670, 1, 0, 0, 0, 3299, 3300, 7, 13, 0, 0, 3300, 3301, 7, 4, 0, 0, 3301, 3302, 7, 5, 0, 0, 3302, 3303, 7, 9, 0, 0, 3303, 3304, 7, 12, 0, 0, 3304, 3305, 7, 17, 0, 0, 3305, 3306, 7, 10, 0, 0, 3306, 672, 1, 0, 0, 0, 3307, 3308, 7, 13, 0, 0, 3308, 3309, 7, 12, 0, 0, 3309, 3310, 7, 4, 0, 0, 3310, 3311, 7, 7, 0, 0, 3311, 674, 1, 0, 0, 0, 3312, 3313, 7, 13, 0, 0, 3313, 3314, 7, 12, 0, 0, 3314, 3315, 7, 4, 0, 0, 3315, 3316, 7, 7, 0, 0, 3316, 3317, 7, 9, 0, 0, 3317, 676, 1, 0, 0, 0, 3318, 3319, 7, 13, 0, 0, 3319, 3320, 7, 17, 0, 0, 3320, 3321, 7, 12, 0, 0, 3321, 3322, 7, 1, 0, 0, 3322, 678, 1, 0, 0, 0, 3323, 3324, 7, 7, 0, 0, 3324, 3325, 7, 4, 0, 0, 3325, 3326, 7, 4, 0, 0, 3326, 3327, 7, 20, 0, 0, 3327, 680, 1, 0, 0, 0, 3328, 3329, 7, 7, 0, 0, 3329, 3330, 7, 4, 0, 0, 3330, 3331, 7, 4, 0, 0, 3331, 3332, 7, 20, 0, 0, 3332, 3333, 7, 9, 0, 0, 3333, 682, 1, 0, 0, 0, 3334, 3335, 7, 7, 0, 0, 3335, 3336, 7, 16, 0, 0, 3336, 3337, 7, 4, 0, 0, 3337, 3338, 7, 10, 0, 0, 3338, 684, 1, 0, 0, 0, 3339, 3340, 7, 7, 0, 0, 3340, 3341, 7, 16, 0, 0, 3341, 3342, 7, 4, 0, 0, 3342, 3343, 7, 5, 0, 0, 3343, 3344, 7, 4, 0, 0, 3344, 686, 1, 0, 0, 0, 3345, 3346, 7, 7, 0, 0, 3346, 3347, 7, 12, 0, 0, 3347, 3348, 7, 10, 0, 0, 3348, 3349, 7, 1, 0, 0, 3349, 3350, 7, 17, 0, 0, 3350, 3351, 7, 7, 0, 0, 3351, 688, 1, 0, 0, 0, 3352, 3353, 7, 7, 0, 0, 3353, 3354, 7, 12, 0, 0, 3354, 3355, 7, 3, 0, 0, 3355, 3356, 7, 16, 0, 0, 3356, 690, 1, 0, 0, 0, 3357, 3358, 7, 7, 0, 0, 3358, 3359, 7, 12, 0, 0, 3359, 3360, 7, 3, 0, 0, 3360, 3361, 7, 16, 0, 0, 3361, 3362, 7, 12, 0, 0, 3362, 3363, 7, 10, 0, 0, 3363, 692, 1, 0, 0, 0, 3364, 3365, 7, 8, 0, 0, 3365, 3366, 7, 4, 0, 0, 3366, 3367, 7, 0, 0, 0, 3367, 3368, 7, 5, 0, 0, 3368, 694, 1, 0, 0, 0, 3369, 3370, 7, 8, 0, 0, 3370, 3371, 7, 4, 0, 0, 3371, 3372, 7, 0, 0, 0, 3372, 3373, 7, 5, 0, 0, 3373, 3374, 7, 9, 0, 0, 3374, 696, 1, 0, 0, 0, 3375, 3376, 7, 11, 0, 0, 3376, 3377, 7, 17, 0, 0, 3377, 3378, 7, 10, 0, 0, 3378, 3379, 7, 4, 0, 0, 3379, 698, 1, 0, 0, 0, 3380, 3381, 7, 11, 0, 0, 3381, 3382, 7, 17, 0, 0, 3382, 3383, 7, 5, 0, 0, 3383, 3384, 7, 1, 0, 0, 3384, 3385, 7, 4, 0, 0, 3385, 3386, 7, 5, 0, 0, 3386, 700, 1, 0, 0, 0, 3387, 3391, 5, 61, 0, 0, 3388, 3389, 5, 61, 0, 0, 3389, 3391, 5, 61, 0, 0, 3390, 3387, 1, 0, 0, 0, 3390, 3388, 1, 0, 0, 0, 3391, 702, 1, 0, 0, 0, 3392, 3393, 5, 60, 0, 0, 3393, 3394, 5, 61, 0, 0, 3394, 3395, 5, 62, 0, 0, 3395, 704, 1, 0, 0, 0, 3396, 3397, 5, 60, 0, 0, 3397, 3398, 5, 62, 0, 0, 3398, 706, 1, 0, 0, 0, 3399, 3400, 5, 33, 0, 0, 3400, 3401, 5, 61, 0, 0, 3401, 708, 1, 0, 0, 0, 3402, 3403, 5, 60, 0, 0, 3403, 710, 1, 0, 0, 0, 3404, 3405, 5, 60, 0, 0, 3405, 3409, 5, 61, 0, 0, 3406, 3407, 5, 33, 0, 0, 3407, 3409, 5, 62, 0, 0, 3408, 3404, 1, 0, 0, 0, 3408, 3406, 1, 0, 0, 0, 3409, 712, 1, 0, 0, 0, 3410, 3411, 5, 62, 0, 0, 3411, 714, 1, 0, 0, 0, 3412, 3413, 5, 62, 0, 0, 3413, 3417, 5, 61, 0, 0, 3414, 3415, 5, 33, 0, 0, 3415, 3417, 5, 60, 0, 0, 3416, 3412, 1, 0, 0, 0, 3416, 3414, 1, 0, 0, 0, 3417, 716, 1, 0, 0, 0, 3418, 3419, 5, 33, 0, 0, 3419, 718, 1, 0, 0, 0, 3420, 3421, 5, 43, 0, 0, 3421, 720, 1, 0, 0, 0, 3422, 3423, 5, 45, 0, 0, 3423, 722, 1, 0, 0, 0, 3424, 3425, 5, 42, 0, 0, 3425, 724, 1, 0, 0, 0, 3426, 3427, 5, 47, 0, 0, 3427, 726, 1, 0, 0, 0, 3428, 3429, 5, 37, 0, 0, 3429, 728, 1, 0, 0, 0, 3430, 3431, 5, 126, 0, 0, 3431, 730, 1, 0, 0, 0, 3432, 3433, 5, 38, 0, 0, 3433, 732, 1, 0, 0, 0, 3434, 3435, 5, 124, 0, 0, 3435, 734, 1, 0, 0, 0, 3436, 3437, 5, 124, 0, 0, 3437, 3438, 5, 124, 0, 0, 3438, 736, 1, 0, 0, 0, 3439, 3440, 5, 94, 0, 0, 3440, 738, 1, 0, 0, 0, 3441, 3442, 5, 58, 0, 0, 3442, 740, 1, 0, 0, 0, 3443, 3444, 5, 45, 0, 0, 3444, 3445, 5, 62, 0, 0, 3445, 742, 1, 0, 0, 0, 3446, 3447, 5, 61, 0, 0, 3447, 3448, 5, 62, 0, 0, 3448, 744, 1, 0, 0, 0, 3449, 3450, 5, 47, 0, 0, 3450, 3451, 5, 42, 0, 0, 3451, 3452, 5, 43, 0, 0, 3452, 746, 1, 0, 0, 0, 3453, 3454, 5, 42, 0, 0, 3454, 3455, 5, 47, 0, 0, 3455, 748, 1, 0, 0, 0, 3456, 3457, 5, 63, 0, 0, 3457, 750, 1, 0, 0, 0, 3458, 3464, 5, 39, 0, 0, 3459, 3463, 8, 26, 0, 0, 3460, 3461, 5, 92, 0, 0, 3461, 3463, 9, 0, 0, 0, 3462, 3459, 1, 0, 0, 0, 3462, 3460, 1, 0, 0, 0, 3463, 3466, 1, 0, 0, 0, 3464, 3462, 1, 0, 0, 0, 3464, 3465, 1, 0, 0, 0, 3465, 3467, 1, 0, 0, 0, 3466, 3464, 1, 0, 0, 0, 3467, 3489, 5, 39, 0, 0, 3468, 3469, 7, 5, 0, 0, 3469, 3470, 5, 39, 0, 0, 3470, 3474, 1, 0, 0, 0, 3471, 3473, 8, 27, 0, 0, 3472, 3471, 1, 0, 0, 0, 3473, 3476, 1, 0, 0, 0, 3474, 3472, 1, 0, 0, 0, 3474, 3475, 1, 0, 0, 0, 3475, 3477, 1, 0, 0, 0, 3476, 3474, 1, 0, 0, 0, 3477, 3489, 5, 39, 0, 0, 3478, 3479, 7, 5, 0, 0, 3479, 3480, 5, 34, 0, 0, 3480, 3484, 1, 0, 0, 0, 3481, 3483, 8, 28, 0, 0, 3482, 3481, 1, 0, 0, 0, 3483, 3486, 1, 0, 0, 0, 3484, 3482, 1, 0, 0, 0, 3484, 3485, 1, 0, 0, 0, 3485, 3487, 1, 0, 0, 0, 3486, 3484, 1, 0, 0, 0, 3487, 3489, 5, 34, 0, 0, 3488, 3458, 1, 0, 0, 0, 3488, 3468, 1, 0, 0, 0, 3488, 3478, 1, 0, 0, 0, 3489, 752, 1, 0, 0, 0, 3490, 3496, 5, 34, 0, 0, 3491, 3495, 8, 29, 0, 0, 3492, 3493, 5, 92, 0, 0, 3493, 3495, 9, 0, 0, 0, 3494, 3491, 1, 0, 0, 0, 3494, 3492, 1, 0, 0, 0, 3495, 3498, 1, 0, 0, 0, 3496, 3494, 1, 0, 0, 0, 3496, 3497, 1, 0, 0, 0, 3497, 3499, 1, 0, 0, 0, 3498, 3496, 1, 0, 0, 0, 3499, 3500, 5, 34, 0, 0, 3500, 754, 1, 0, 0, 0, 3501, 3503, 3, 781, 390, 0, 3502, 3501, 1, 0, 0, 0, 3503, 3504, 1, 0, 0, 0, 3504, 3502, 1, 0, 0, 0, 3504, 3505, 1, 0, 0, 0, 3505, 3506, 1, 0, 0, 0, 3506, 3507, 7, 6, 0, 0, 3507, 756, 1, 0, 0, 0, 3508, 3510, 3, 781, 390, 0, 3509, 3508, 1, 0, 0, 0, 3510, 3511, 1, 0, 0, 0, 3511, 3509, 1, 0, 0, 0, 3511, 3512, 1, 0, 0, 0, 3512, 3513, 1, 0, 0, 0, 3513, 3514, 7, 9, 0, 0, 3514, 758, 1, 0, 0, 0, 3515, 3517, 3, 781, 390, 0, 3516, 3515, 1, 0, 0, 0, 3517, 3518, 1, 0, 0, 0, 3518, 3516, 1, 0, 0, 0, 3518, 3519, 1, 0, 0, 0, 3519, 3520, 1, 0, 0, 0, 3520, 3521, 7, 8, 0, 0, 3521, 760, 1, 0, 0, 0, 3522, 3524, 3, 781, 390, 0, 3523, 3522, 1, 0, 0, 0, 3524, 3525, 1, 0, 0, 0, 3525, 3523, 1, 0, 0, 0, 3525, 3526, 1, 0, 0, 0, 3526, 762, 1, 0, 0, 0, 3527, 3529, 3, 781, 390, 0, 3528, 3527, 1, 0, 0, 0, 3529, 3530, 1, 0, 0, 0, 3530, 3528, 1, 0, 0, 0, 3530, 3531, 1, 0, 0, 0, 3531, 3532, 1, 0, 0, 0, 3532, 3533, 3, 779, 389, 0, 3533, 3538, 1, 0, 0, 0, 3534, 3535, 3, 777, 388, 0, 3535, 3536, 3, 779, 389, 0, 3536, 3538, 1, 0, 0, 0, 3537, 3528, 1, 0, 0, 0, 3537, 3534, 1, 0, 0, 0, 3538, 764, 1, 0, 0, 0, 3539, 3540, 3, 777, 388, 0, 3540, 766, 1, 0, 0, 0, 3541, 3543, 3, 781, 390, 0, 3542, 3541, 1, 0, 0, 0, 3543, 3544, 1, 0, 0, 0, 3544, 3542, 1, 0, 0, 0, 3544, 3545, 1, 0, 0, 0, 3545, 3547, 1, 0, 0, 0, 3546, 3548, 3, 779, 389, 0, 3547, 3546, 1, 0, 0, 0, 3547, 3548, 1, 0, 0, 0, 3548, 3549, 1, 0, 0, 0, 3549, 3550, 7, 2, 0, 0, 3550, 3558, 1, 0, 0, 0, 3551, 3553, 3, 777, 388, 0, 3552, 3554, 3, 779, 389, 0, 3553, 3552, 1, 0, 0, 0, 3553, 3554, 1, 0, 0, 0, 3554, 3555, 1, 0, 0, 0, 3555, 3556, 7, 2, 0, 0, 3556, 3558, 1, 0, 0, 0, 3557, 3542, 1, 0, 0, 0, 3557, 3551, 1, 0, 0, 0, 3558, 768, 1, 0, 0, 0, 3559, 3561, 3, 781, 390, 0, 3560, 3559, 1, 0, 0, 0, 3561, 3562, 1, 0, 0, 0, 3562, 3560, 1, 0, 0, 0, 3562, 3563, 1, 0, 0, 0, 3563, 3565, 1, 0, 0, 0, 3564, 3566, 3, 779, 389, 0, 3565, 3564, 1, 0, 0, 0, 3565, 3566, 1, 0, 0, 0, 3566, 3567, 1, 0, 0, 0, 3567, 3568, 7, 1, 0, 0, 3568, 3576, 1, 0, 0, 0, 3569, 3571, 3, 777, 388, 0, 3570, 3572, 3, 779, 389, 0, 3571, 3570, 1, 0, 0, 0, 3571, 3572, 1, 0, 0, 0, 3572, 3573, 1, 0, 0, 0, 3573, 3574, 7, 1, 0, 0, 3574, 3576, 1, 0, 0, 0, 3575, 3560, 1, 0, 0, 0, 3575, 3569, 1, 0, 0, 0, 3576, 770, 1, 0, 0, 0, 3577, 3579, 3, 781, 390, 0, 3578, 3577, 1, 0, 0, 0, 3579, 3580, 1, 0, 0, 0, 3580, 3578, 1, 0, 0, 0, 3580, 3581, 1, 0, 0, 0, 3581, 3583, 1, 0, 0, 0, 3582, 3584, 3, 779, 389, 0, 3583, 3582, 1, 0, 0, 0, 3583, 3584, 1, 0, 0, 0, 3584, 3585, 1, 0, 0, 0, 3585, 3586, 7, 18, 0, 0, 3586, 3587, 7, 1, 0, 0, 3587, 3596, 1, 0, 0, 0, 3588, 3590, 3, 777, 388, 0, 3589, 3591, 3, 779, 389, 0, 3590, 3589, 1, 0, 0, 0, 3590, 3591, 1, 0, 0, 0, 3591, 3592, 1, 0, 0, 0, 3592, 3593, 7, 18, 0, 0, 3593, 3594, 7, 1, 0, 0, 3594, 3596, 1, 0, 0, 0, 3595, 3578, 1, 0, 0, 0, 3595, 3588, 1, 0, 0, 0, 3596, 772, 1, 0, 0, 0, 3597, 3601, 3, 783, 391, 0, 3598, 3601, 3, 781, 390, 0, 3599, 3601, 5, 95, 0, 0, 3600, 3597, 1, 0, 0, 0, 3600, 3598, 1, 0, 0, 0, 3600, 3599, 1, 0, 0, 0, 3601, 3602, 1, 0, 0, 0, 3602, 3600, 1, 0, 0, 0, 3602, 3603, 1, 0, 0, 0, 3603, 774, 1, 0, 0, 0, 3604, 3610, 5, 96, 0, 0, 3605, 3609, 8, 30, 0, 0, 3606, 3607, 5, 96, 0, 0, 3607, 3609, 5, 96, 0, 0, 3608, 3605, 1, 0, 0, 0, 3608, 3606, 1, 0, 0, 0, 3609, 3612, 1, 0, 0, 0, 3610, 3608, 1, 0, 0, 0, 3610, 3611, 1, 0, 0, 0, 3611, 3613, 1, 0, 0, 0, 3612, 3610, 1, 0, 0, 0, 3613, 3614, 5, 96, 0, 0, 3614, 776, 1, 0, 0, 0, 3615, 3617, 3, 781, 390, 0, 3616, 3615, 1, 0, 0, 0, 3617, 3618, 1, 0, 0, 0, 3618, 3616, 1, 0, 0, 0, 3618, 3619, 1, 0, 0, 0, 3619, 3620, 1, 0, 0, 0, 3620, 3624, 5, 46, 0, 0, 3621, 3623, 3, 781, 390, 0, 3622, 3621, 1, 0, 0, 0, 3623, 3626, 1, 0, 0, 0, 3624, 3622, 1, 0, 0, 0, 3624, 3625, 1, 0, 0, 0, 3625, 3634, 1, 0, 0, 0, 3626, 3624, 1, 0, 0, 0, 3627, 3629, 5, 46, 0, 0, 3628, 3630, 3, 781, 390, 0, 3629, 3628, 1, 0, 0, 0, 3630, 3631, 1, 0, 0, 0, 3631, 3629, 1, 0, 0, 0, 3631, 3632, 1, 0, 0, 0, 3632, 3634, 1, 0, 0, 0, 3633, 3616, 1, 0, 0, 0, 3633, 3627, 1, 0, 0, 0, 3634, 778, 1, 0, 0, 0, 3635, 3637, 7, 4, 0, 0, 3636, 3638, 7, 31, 0, 0, 3637, 3636, 1, 0, 0, 0, 3637, 3638, 1, 0, 0, 0, 3638, 3640, 1, 0, 0, 0, 3639, 3641, 3, 781, 390, 0, 3640, 3639, 1, 0, 0, 0, 3641, 3642, 1, 0, 0, 0, 3642, 3640, 1, 0, 0, 0, 3642, 3643, 1, 0, 0, 0, 3643, 780, 1, 0, 0, 0, 3644, 3645, 7, 32, 0, 0, 3645, 782, 1, 0, 0, 0, 3646, 3647, 7, 33, 0, 0, 3647, 784, 1, 0, 0, 0, 3648, 3649, 5, 45, 0, 0, 3649, 3650, 5, 45, 0, 0, 3650, 3656, 1, 0, 0, 0, 3651, 3652, 5, 92, 0, 0, 3652, 3655, 5, 10, 0, 0, 3653, 3655, 8, 34, 0, 0, 3654, 3651, 1, 0, 0, 0, 3654, 3653, 1, 0, 0, 0, 3655, 3658, 1, 0, 0, 0, 3656, 3654, 1, 0, 0, 0, 3656, 3657, 1, 0, 0, 0, 3657, 3660, 1, 0, 0, 0, 3658, 3656, 1, 0, 0, 0, 3659, 3661, 5, 13, 0, 0, 3660, 3659, 1, 0, 0, 0, 3660, 3661, 1, 0, 0, 0, 3661, 3663, 1, 0, 0, 0, 3662, 3664, 5, 10, 0, 0, 3663, 3662, 1, 0, 0, 0, 3663, 3664, 1, 0, 0, 0, 3664, 3665, 1, 0, 0, 0, 3665, 3666, 6, 392, 0, 0, 3666, 786, 1, 0, 0, 0, 3667, 3668, 5, 47, 0, 0, 3668, 3669, 5, 42, 0, 0, 3669, 3674, 1, 0, 0, 0, 3670, 3673, 3, 787, 393, 0, 3671, 3673, 9, 0, 0, 0, 3672, 3670, 1, 0, 0, 0, 3672, 3671, 1, 0, 0, 0, 3673, 3676, 1, 0, 0, 0, 3674, 3675, 1, 0, 0, 0, 3674, 3672, 1, 0, 0, 0, 3675, 3681, 1, 0, 0, 0, 3676, 3674, 1, 0, 0, 0, 3677, 3678, 5, 42, 0, 0, 3678, 3682, 5, 47, 0, 0, 3679, 3680, 6, 393, 1, 0, 3680, 3682, 5, 0, 0, 1, 3681, 3677, 1, 0, 0, 0, 3681, 3679, 1, 0, 0, 0, 3682, 3683, 1, 0, 0, 0, 3683, 3684, 6, 393, 0, 0, 3684, 788, 1, 0, 0, 0, 3685, 3687, 7, 35, 0, 0, 3686, 3685, 1, 0, 0, 0, 3687, 3688, 1, 0, 0, 0, 3688, 3686, 1, 0, 0, 0, 3688, 3689, 1, 0, 0, 0, 3689, 3690, 1, 0, 0, 0, 3690, 3691, 6, 394, 0, 0, 3691, 790, 1, 0, 0, 0, 3692, 3693, 9, 0, 0, 0, 3693, 792, 1, 0, 0, 0, 47, 0, 3390, 3408, 3416, 3462, 3464, 3474, 3484, 3488, 3494, 3496, 3504, 3511, 3518, 3525, 3530, 3537, 3544, 3547, 3553, 3557, 3562, 3565, 3571, 3575, 3580, 3583, 3590, 3595, 3600, 3602, 3608, 3610, 3618, 3624, 3631, 3633, 3637, 3642, 3654, 3656, 3660, 3663, 3672, 3674, 3681, 3688, 2, 0, 1, 0, 1, 393, 0] \ No newline at end of file diff --git a/src/lib/sql/SqlLexer.tokens b/src/lib/sql/SqlLexer.tokens new file mode 100644 index 00000000..59f750a7 --- /dev/null +++ b/src/lib/sql/SqlLexer.tokens @@ -0,0 +1,764 @@ +SEMICOLON=1 +LEFT_PAREN=2 +RIGHT_PAREN=3 +COMMA=4 +DOT=5 +LEFT_BRACKET=6 +RIGHT_BRACKET=7 +KW_ADD=8 +KW_AFTER=9 +KW_ALL=10 +KW_ALTER=11 +KW_ALWAYS=12 +KW_ANALYZE=13 +KW_AND=14 +KW_ANTI=15 +KW_ANY=16 +KW_ANY_VALUE=17 +KW_ARCHIVE=18 +KW_ARRAY=19 +KW_AS=20 +KW_ASC=21 +KW_AT=22 +KW_AUTHORIZATION=23 +KW_BETWEEN=24 +KW_BIGINT=25 +KW_BINARY=26 +KW_BOOLEAN=27 +KW_BOTH=28 +KW_BUCKET=29 +KW_BUCKETS=30 +KW_BY=31 +KW_BYTE=32 +KW_CACHE=33 +KW_CASCADE=34 +KW_CASE=35 +KW_CAST=36 +KW_CATALOG=37 +KW_CATALOGS=38 +KW_CHANGE=39 +KW_CHAR=40 +KW_CHARACTER=41 +KW_CHECK=42 +KW_CLEAR=43 +KW_CLUSTER=44 +KW_CLUSTERED=45 +KW_CODEGEN=46 +KW_COLLATE=47 +KW_COLLECTION=48 +KW_COLUMN=49 +KW_COLUMNS=50 +KW_COMMENT=51 +KW_COMMIT=52 +KW_COMPACT=53 +KW_COMPACTIONS=54 +KW_COMPUTE=55 +KW_CONCATENATE=56 +KW_CONSTRAINT=57 +KW_COST=58 +KW_CREATE=59 +KW_CROSS=60 +KW_CUBE=61 +KW_CURRENT=62 +KW_CURRENT_DATE=63 +KW_CURRENT_TIME=64 +KW_CURRENT_TIMESTAMP=65 +KW_CURRENT_USER=66 +KW_DAY=67 +KW_DAYS=68 +KW_DAYOFYEAR=69 +KW_DATA=70 +KW_DATE=71 +KW_DATABASE=72 +KW_DATABASES=73 +KW_DATEADD=74 +KW_DATE_ADD=75 +KW_DATEDIFF=76 +KW_DATE_DIFF=77 +KW_DBPROPERTIES=78 +KW_DEC=79 +KW_DECIMAL=80 +KW_DECLARE=81 +KW_DEFAULT=82 +KW_DEFINED=83 +KW_DELETE=84 +KW_DELIMITED=85 +KW_DESC=86 +KW_DESCRIBE=87 +KW_DFS=88 +KW_DIRECTORIES=89 +KW_DIRECTORY=90 +KW_DISABLE=91 +KW_DISTINCT=92 +KW_DISTRIBUTE=93 +KW_DIV=94 +KW_DOUBLE=95 +KW_DROP=96 +KW_ELSE=97 +KW_ENABLE=98 +KW_END=99 +KW_ESCAPE=100 +KW_ESCAPED=101 +KW_EXCEPT=102 +KW_EXCHANGE=103 +KW_EXCLUDE=104 +KW_EXISTS=105 +KW_EXPLAIN=106 +KW_EXPORT=107 +KW_EXTENDED=108 +KW_EXTERNAL=109 +KW_EXTRACT=110 +KW_FALSE=111 +KW_FETCH=112 +KW_FIELDS=113 +KW_FILTER=114 +KW_FILEFORMAT=115 +KW_FIRST=116 +KW_FLOAT=117 +KW_FOLLOWING=118 +KW_FOR=119 +KW_FOREIGN=120 +KW_FORMAT=121 +KW_FORMATTED=122 +KW_FROM=123 +KW_FULL=124 +KW_FUNCTION=125 +KW_FUNCTIONS=126 +KW_GENERATED=127 +KW_GLOBAL=128 +KW_GRANT=129 +KW_GROUP=130 +KW_GROUPING=131 +KW_HAVING=132 +KW_BINARY_HEX=133 +KW_HOUR=134 +KW_HOURS=135 +KW_IDENTIFIER=136 +KW_IF=137 +KW_IGNORE=138 +KW_IMPORT=139 +KW_IN=140 +KW_INCLUDE=141 +KW_INDEX=142 +KW_INDEXES=143 +KW_INNER=144 +KW_INPATH=145 +KW_INPUTFORMAT=146 +KW_INSERT=147 +KW_INTERSECT=148 +KW_INTERVAL=149 +KW_INT=150 +KW_INTEGER=151 +KW_INTO=152 +KW_IS=153 +KW_ITEMS=154 +KW_JOIN=155 +KW_KEYS=156 +KW_LAST=157 +KW_LATERAL=158 +KW_LAZY=159 +KW_LEADING=160 +KW_LEFT=161 +KW_LIFECYCLE=162 +KW_LIKE=163 +KW_ILIKE=164 +KW_LIMIT=165 +KW_LINES=166 +KW_LIST=167 +KW_LOAD=168 +KW_LOCAL=169 +KW_LOCATION=170 +KW_LOCK=171 +KW_LOCKS=172 +KW_LOGICAL=173 +KW_LONG=174 +KW_MACRO=175 +KW_MAP=176 +KW_MATCHED=177 +KW_MERGE=178 +KW_MICROSECOND=179 +KW_MICROSECONDS=180 +KW_MILLISECOND=181 +KW_MILLISECONDS=182 +KW_MINUTE=183 +KW_MINUTES=184 +KW_MONTH=185 +KW_MONTHS=186 +KW_MSCK=187 +KW_NAME=188 +KW_NAMESPACE=189 +KW_NAMESPACES=190 +KW_NANOSECOND=191 +KW_NANOSECONDS=192 +KW_NATURAL=193 +KW_NO=194 +KW_NOSCAN=195 +KW_NOT=196 +KW_NULL=197 +KW_NULLS=198 +KW_NUMERIC=199 +KW_OF=200 +KW_OFFSET=201 +KW_ON=202 +KW_ONLY=203 +KW_OPTIMIZE=204 +KW_OPTION=205 +KW_OPTIONS=206 +KW_OR=207 +KW_ORDER=208 +KW_OUT=209 +KW_OUTER=210 +KW_OUTPUTFORMAT=211 +KW_OVER=212 +KW_OVERLAPS=213 +KW_OVERLAY=214 +KW_OVERWRITE=215 +KW_PARTITION=216 +KW_PARTITIONED=217 +KW_PARTITIONS=218 +KW_PERCENTILE_CONT=219 +KW_PERCENTILE_DISC=220 +KW_PERCENTLIT=221 +KW_PIVOT=222 +KW_PLACING=223 +KW_POSITION=224 +KW_PRECEDING=225 +KW_PRIMARY=226 +KW_PRINCIPALS=227 +KW_PROPERTIES=228 +KW_PURGE=229 +KW_QUARTER=230 +KW_QUERY=231 +KW_RANGE=232 +KW_REAL=233 +KW_RECORDREADER=234 +KW_RECORDWRITER=235 +KW_RECOVER=236 +KW_REDUCE=237 +KW_REFERENCES=238 +KW_REFRESH=239 +KW_RENAME=240 +KW_REPAIR=241 +KW_REPEATABLE=242 +KW_REPLACE=243 +KW_RESET=244 +KW_RESPECT=245 +KW_RESTRICT=246 +KW_REWRITE=247 +KW_REVOKE=248 +KW_RIGHT=249 +KW_RLIKE=250 +KW_REGEXP=251 +KW_ROLE=252 +KW_ROLES=253 +KW_ROLLBACK=254 +KW_ROLLUP=255 +KW_ROW=256 +KW_ROWS=257 +KW_SECOND=258 +KW_SECONDS=259 +KW_SCHEMA=260 +KW_SCHEMAS=261 +KW_SELECT=262 +KW_SEMI=263 +KW_SEPARATED=264 +KW_SERDE=265 +KW_SERDEPROPERTIES=266 +KW_SESSION_USER=267 +KW_SET=268 +KW_MINUS=269 +KW_SETS=270 +KW_SHORT=271 +KW_SHOW=272 +KW_SINGLE=273 +KW_SKEWED=274 +KW_SMALLINT=275 +KW_SOME=276 +KW_SORT=277 +KW_SORTED=278 +KW_SOURCE=279 +KW_START=280 +KW_STATISTICS=281 +KW_STORED=282 +KW_STRATIFY=283 +KW_STRING=284 +KW_STRUCT=285 +KW_SUBSTR=286 +KW_SUBSTRING=287 +KW_SYNC=288 +KW_SYSTEM=289 +KW_SYSTEM_TIME=290 +KW_SYSTEM_VERSION=291 +KW_TABLE=292 +KW_TABLES=293 +KW_TABLESAMPLE=294 +KW_TARGET=295 +KW_TBLPROPERTIES=296 +KW_TEMPORARY=297 +KW_TERMINATED=298 +KW_THEN=299 +KW_TIME=300 +KW_TIMEDIFF=301 +KW_TIMESTAMP=302 +KW_TIMESTAMP_LTZ=303 +KW_TIMESTAMP_NTZ=304 +KW_TIMESTAMPADD=305 +KW_TIMESTAMPDIFF=306 +KW_TINYINT=307 +KW_TO=308 +KW_TOUCH=309 +KW_TRAILING=310 +KW_TRANSACTION=311 +KW_TRANSACTIONS=312 +KW_TRANSFORM=313 +KW_TRIM=314 +KW_TRUE=315 +KW_TRUNCATE=316 +KW_TRY_CAST=317 +KW_TYPE=318 +KW_UNARCHIVE=319 +KW_UNBOUNDED=320 +KW_UNCACHE=321 +KW_UNION=322 +KW_UNIQUE=323 +KW_UNKNOWN=324 +KW_UNLOCK=325 +KW_UNPIVOT=326 +KW_UNSET=327 +KW_UPDATE=328 +KW_USE=329 +KW_USER=330 +KW_USING=331 +KW_VALUES=332 +KW_VARCHAR=333 +KW_VAR=334 +KW_VARIABLE=335 +KW_VERSION=336 +KW_VIEW=337 +KW_VIEWS=338 +KW_VOID=339 +KW_WEEK=340 +KW_WEEKS=341 +KW_WHEN=342 +KW_WHERE=343 +KW_WINDOW=344 +KW_WITH=345 +KW_WITHIN=346 +KW_YEAR=347 +KW_YEARS=348 +KW_ZONE=349 +KW_ZORDER=350 +EQ=351 +NSEQ=352 +NEQ=353 +NEQJ=354 +LT=355 +LTE=356 +GT=357 +GTE=358 +NOT=359 +PLUS=360 +MINUS=361 +ASTERISK=362 +SLASH=363 +PERCENT=364 +TILDE=365 +AMPERSAND=366 +PIPE=367 +CONCAT_PIPE=368 +HAT=369 +COLON=370 +ARROW=371 +FAT_ARROW=372 +HENT_START=373 +HENT_END=374 +QUESTION=375 +STRING_LITERAL=376 +DOUBLEQUOTED_STRING=377 +BIGINT_LITERAL=378 +SMALLINT_LITERAL=379 +TINYINT_LITERAL=380 +INTEGER_VALUE=381 +EXPONENT_VALUE=382 +DECIMAL_VALUE=383 +FLOAT_LITERAL=384 +DOUBLE_LITERAL=385 +BIGDECIMAL_LITERAL=386 +IDENTIFIER=387 +BACKQUOTED_IDENTIFIER=388 +SIMPLE_COMMENT=389 +BRACKETED_COMMENT=390 +WS=391 +UNRECOGNIZED=392 +';'=1 +'('=2 +')'=3 +','=4 +'.'=5 +'['=6 +']'=7 +'ADD'=8 +'AFTER'=9 +'ALL'=10 +'ALTER'=11 +'ALWAYS'=12 +'ANALYZE'=13 +'AND'=14 +'ANTI'=15 +'ANY'=16 +'ANY_VALUE'=17 +'ARCHIVE'=18 +'ARRAY'=19 +'AS'=20 +'ASC'=21 +'AT'=22 +'AUTHORIZATION'=23 +'BETWEEN'=24 +'BIGINT'=25 +'BINARY'=26 +'BOOLEAN'=27 +'BOTH'=28 +'BUCKET'=29 +'BUCKETS'=30 +'BY'=31 +'BYTE'=32 +'CACHE'=33 +'CASCADE'=34 +'CASE'=35 +'CAST'=36 +'CATALOG'=37 +'CATALOGS'=38 +'CHANGE'=39 +'CHAR'=40 +'CHARACTER'=41 +'CHECK'=42 +'CLEAR'=43 +'CLUSTER'=44 +'CLUSTERED'=45 +'CODEGEN'=46 +'COLLATE'=47 +'COLLECTION'=48 +'COLUMN'=49 +'COLUMNS'=50 +'COMMENT'=51 +'COMMIT'=52 +'COMPACT'=53 +'COMPACTIONS'=54 +'COMPUTE'=55 +'CONCATENATE'=56 +'CONSTRAINT'=57 +'COST'=58 +'CREATE'=59 +'CROSS'=60 +'CUBE'=61 +'CURRENT'=62 +'CURRENT_DATE'=63 +'CURRENT_TIME'=64 +'CURRENT_TIMESTAMP'=65 +'CURRENT_USER'=66 +'DAY'=67 +'DAYS'=68 +'DAYOFYEAR'=69 +'DATA'=70 +'DATE'=71 +'DATABASE'=72 +'DATABASES'=73 +'DATEADD'=74 +'DATE_ADD'=75 +'DATEDIFF'=76 +'DATE_DIFF'=77 +'DBPROPERTIES'=78 +'DEC'=79 +'DECIMAL'=80 +'DECLARE'=81 +'DEFAULT'=82 +'DEFINED'=83 +'DELETE'=84 +'DELIMITED'=85 +'DESC'=86 +'DESCRIBE'=87 +'DFS'=88 +'DIRECTORIES'=89 +'DIRECTORY'=90 +'DISABLE'=91 +'DISTINCT'=92 +'DISTRIBUTE'=93 +'DIV'=94 +'DOUBLE'=95 +'DROP'=96 +'ELSE'=97 +'ENABLE'=98 +'END'=99 +'ESCAPE'=100 +'ESCAPED'=101 +'EXCEPT'=102 +'EXCHANGE'=103 +'EXCLUDE'=104 +'EXISTS'=105 +'EXPLAIN'=106 +'EXPORT'=107 +'EXTENDED'=108 +'EXTERNAL'=109 +'EXTRACT'=110 +'FALSE'=111 +'FETCH'=112 +'FIELDS'=113 +'FILTER'=114 +'FILEFORMAT'=115 +'FIRST'=116 +'FLOAT'=117 +'FOLLOWING'=118 +'FOR'=119 +'FOREIGN'=120 +'FORMAT'=121 +'FORMATTED'=122 +'FROM'=123 +'FULL'=124 +'FUNCTION'=125 +'FUNCTIONS'=126 +'GENERATED'=127 +'GLOBAL'=128 +'GRANT'=129 +'GROUP'=130 +'GROUPING'=131 +'HAVING'=132 +'X'=133 +'HOUR'=134 +'HOURS'=135 +'IDENTIFIER'=136 +'IF'=137 +'IGNORE'=138 +'IMPORT'=139 +'IN'=140 +'INCLUDE'=141 +'INDEX'=142 +'INDEXES'=143 +'INNER'=144 +'INPATH'=145 +'INPUTFORMAT'=146 +'INSERT'=147 +'INTERSECT'=148 +'INTERVAL'=149 +'INT'=150 +'INTEGER'=151 +'INTO'=152 +'IS'=153 +'ITEMS'=154 +'JOIN'=155 +'KEYS'=156 +'LAST'=157 +'LATERAL'=158 +'LAZY'=159 +'LEADING'=160 +'LEFT'=161 +'LIFECYCLE'=162 +'LIKE'=163 +'ILIKE'=164 +'LIMIT'=165 +'LINES'=166 +'LIST'=167 +'LOAD'=168 +'LOCAL'=169 +'LOCATION'=170 +'LOCK'=171 +'LOCKS'=172 +'LOGICAL'=173 +'LONG'=174 +'MACRO'=175 +'MAP'=176 +'MATCHED'=177 +'MERGE'=178 +'MICROSECOND'=179 +'MICROSECONDS'=180 +'MILLISECOND'=181 +'MILLISECONDS'=182 +'MINUTE'=183 +'MINUTES'=184 +'MONTH'=185 +'MONTHS'=186 +'MSCK'=187 +'NAME'=188 +'NAMESPACE'=189 +'NAMESPACES'=190 +'NANOSECOND'=191 +'NANOSECONDS'=192 +'NATURAL'=193 +'NO'=194 +'NOSCAN'=195 +'NOT'=196 +'NULL'=197 +'NULLS'=198 +'NUMERIC'=199 +'OF'=200 +'OFFSET'=201 +'ON'=202 +'ONLY'=203 +'OPTIMIZE'=204 +'OPTION'=205 +'OPTIONS'=206 +'OR'=207 +'ORDER'=208 +'OUT'=209 +'OUTER'=210 +'OUTPUTFORMAT'=211 +'OVER'=212 +'OVERLAPS'=213 +'OVERLAY'=214 +'OVERWRITE'=215 +'PARTITION'=216 +'PARTITIONED'=217 +'PARTITIONS'=218 +'PERCENTILE_CONT'=219 +'PERCENTILE_DISC'=220 +'PERCENT'=221 +'PIVOT'=222 +'PLACING'=223 +'POSITION'=224 +'PRECEDING'=225 +'PRIMARY'=226 +'PRINCIPALS'=227 +'PROPERTIES'=228 +'PURGE'=229 +'QUARTER'=230 +'QUERY'=231 +'RANGE'=232 +'REAL'=233 +'RECORDREADER'=234 +'RECORDWRITER'=235 +'RECOVER'=236 +'REDUCE'=237 +'REFERENCES'=238 +'REFRESH'=239 +'RENAME'=240 +'REPAIR'=241 +'REPEATABLE'=242 +'REPLACE'=243 +'RESET'=244 +'RESPECT'=245 +'RESTRICT'=246 +'REWRITE'=247 +'REVOKE'=248 +'RIGHT'=249 +'RLIKE'=250 +'REGEXP'=251 +'ROLE'=252 +'ROLES'=253 +'ROLLBACK'=254 +'ROLLUP'=255 +'ROW'=256 +'ROWS'=257 +'SECOND'=258 +'SECONDS'=259 +'SCHEMA'=260 +'SCHEMAS'=261 +'SELECT'=262 +'SEMI'=263 +'SEPARATED'=264 +'SERDE'=265 +'SERDEPROPERTIES'=266 +'SESSION_USER'=267 +'SET'=268 +'MINUS'=269 +'SETS'=270 +'SHORT'=271 +'SHOW'=272 +'SINGLE'=273 +'SKEWED'=274 +'SMALLINT'=275 +'SOME'=276 +'SORT'=277 +'SORTED'=278 +'SOURCE'=279 +'START'=280 +'STATISTICS'=281 +'STORED'=282 +'STRATIFY'=283 +'STRING'=284 +'STRUCT'=285 +'SUBSTR'=286 +'SUBSTRING'=287 +'SYNC'=288 +'SYSTEM'=289 +'SYSTEM_TIME'=290 +'SYSTEM_VERSION'=291 +'TABLE'=292 +'TABLES'=293 +'TABLESAMPLE'=294 +'TARGET'=295 +'TBLPROPERTIES'=296 +'TEMPORARY'=297 +'TERMINATED'=298 +'THEN'=299 +'TIME'=300 +'TIMEDIFF'=301 +'TIMESTAMP'=302 +'TIMESTAMP_LTZ'=303 +'TIMESTAMP_NTZ'=304 +'TIMESTAMPADD'=305 +'TIMESTAMPDIFF'=306 +'TINYINT'=307 +'TO'=308 +'TOUCH'=309 +'TRAILING'=310 +'TRANSACTION'=311 +'TRANSACTIONS'=312 +'TRANSFORM'=313 +'TRIM'=314 +'TRUE'=315 +'TRUNCATE'=316 +'TRY_CAST'=317 +'TYPE'=318 +'UNARCHIVE'=319 +'UNBOUNDED'=320 +'UNCACHE'=321 +'UNION'=322 +'UNIQUE'=323 +'UNKNOWN'=324 +'UNLOCK'=325 +'UNPIVOT'=326 +'UNSET'=327 +'UPDATE'=328 +'USE'=329 +'USER'=330 +'USING'=331 +'VALUES'=332 +'VARCHAR'=333 +'VAR'=334 +'VARIABLE'=335 +'VERSION'=336 +'VIEW'=337 +'VIEWS'=338 +'VOID'=339 +'WEEK'=340 +'WEEKS'=341 +'WHEN'=342 +'WHERE'=343 +'WINDOW'=344 +'WITH'=345 +'WITHIN'=346 +'YEAR'=347 +'YEARS'=348 +'ZONE'=349 +'ZORDER'=350 +'<=>'=352 +'<>'=353 +'!='=354 +'<'=355 +'>'=357 +'!'=359 +'+'=360 +'-'=361 +'*'=362 +'/'=363 +'%'=364 +'~'=365 +'&'=366 +'|'=367 +'||'=368 +'^'=369 +':'=370 +'->'=371 +'=>'=372 +'/*+'=373 +'*/'=374 +'?'=375 diff --git a/src/lib/sql/SqlLexer.ts b/src/lib/sql/SqlLexer.ts new file mode 100644 index 00000000..8c64f180 --- /dev/null +++ b/src/lib/sql/SqlLexer.ts @@ -0,0 +1,2094 @@ +// Generated from dt-sql-parser/src/grammar/sql/SqlLexer.g4 by ANTLR 4.13.1 + +// @ts-nocheck + +import * as antlr from "antlr4ng"; +import { Token } from "antlr4ng"; + + +export class SqlLexer extends antlr.Lexer { + public static readonly SEMICOLON = 1; + public static readonly LEFT_PAREN = 2; + public static readonly RIGHT_PAREN = 3; + public static readonly COMMA = 4; + public static readonly DOT = 5; + public static readonly LEFT_BRACKET = 6; + public static readonly RIGHT_BRACKET = 7; + public static readonly KW_ADD = 8; + public static readonly KW_AFTER = 9; + public static readonly KW_ALL = 10; + public static readonly KW_ALTER = 11; + public static readonly KW_ALWAYS = 12; + public static readonly KW_ANALYZE = 13; + public static readonly KW_AND = 14; + public static readonly KW_ANTI = 15; + public static readonly KW_ANY = 16; + public static readonly KW_ANY_VALUE = 17; + public static readonly KW_ARCHIVE = 18; + public static readonly KW_ARRAY = 19; + public static readonly KW_AS = 20; + public static readonly KW_ASC = 21; + public static readonly KW_AT = 22; + public static readonly KW_AUTHORIZATION = 23; + public static readonly KW_BETWEEN = 24; + public static readonly KW_BIGINT = 25; + public static readonly KW_BINARY = 26; + public static readonly KW_BOOLEAN = 27; + public static readonly KW_BOTH = 28; + public static readonly KW_BUCKET = 29; + public static readonly KW_BUCKETS = 30; + public static readonly KW_BY = 31; + public static readonly KW_BYTE = 32; + public static readonly KW_CACHE = 33; + public static readonly KW_CASCADE = 34; + public static readonly KW_CASE = 35; + public static readonly KW_CAST = 36; + public static readonly KW_CATALOG = 37; + public static readonly KW_CATALOGS = 38; + public static readonly KW_CHANGE = 39; + public static readonly KW_CHAR = 40; + public static readonly KW_CHARACTER = 41; + public static readonly KW_CHECK = 42; + public static readonly KW_CLEAR = 43; + public static readonly KW_CLUSTER = 44; + public static readonly KW_CLUSTERED = 45; + public static readonly KW_CODEGEN = 46; + public static readonly KW_COLLATE = 47; + public static readonly KW_COLLECTION = 48; + public static readonly KW_COLUMN = 49; + public static readonly KW_COLUMNS = 50; + public static readonly KW_COMMENT = 51; + public static readonly KW_COMMIT = 52; + public static readonly KW_COMPACT = 53; + public static readonly KW_COMPACTIONS = 54; + public static readonly KW_COMPUTE = 55; + public static readonly KW_CONCATENATE = 56; + public static readonly KW_CONSTRAINT = 57; + public static readonly KW_COST = 58; + public static readonly KW_CREATE = 59; + public static readonly KW_CROSS = 60; + public static readonly KW_CUBE = 61; + public static readonly KW_CURRENT = 62; + public static readonly KW_CURRENT_DATE = 63; + public static readonly KW_CURRENT_TIME = 64; + public static readonly KW_CURRENT_TIMESTAMP = 65; + public static readonly KW_CURRENT_USER = 66; + public static readonly KW_DAY = 67; + public static readonly KW_DAYS = 68; + public static readonly KW_DAYOFYEAR = 69; + public static readonly KW_DATA = 70; + public static readonly KW_DATE = 71; + public static readonly KW_DATABASE = 72; + public static readonly KW_DATABASES = 73; + public static readonly KW_DATEADD = 74; + public static readonly KW_DATE_ADD = 75; + public static readonly KW_DATEDIFF = 76; + public static readonly KW_DATE_DIFF = 77; + public static readonly KW_DBPROPERTIES = 78; + public static readonly KW_DEC = 79; + public static readonly KW_DECIMAL = 80; + public static readonly KW_DECLARE = 81; + public static readonly KW_DEFAULT = 82; + public static readonly KW_DEFINED = 83; + public static readonly KW_DELETE = 84; + public static readonly KW_DELIMITED = 85; + public static readonly KW_DESC = 86; + public static readonly KW_DESCRIBE = 87; + public static readonly KW_DFS = 88; + public static readonly KW_DIRECTORIES = 89; + public static readonly KW_DIRECTORY = 90; + public static readonly KW_DISABLE = 91; + public static readonly KW_DISTINCT = 92; + public static readonly KW_DISTRIBUTE = 93; + public static readonly KW_DIV = 94; + public static readonly KW_DOUBLE = 95; + public static readonly KW_DROP = 96; + public static readonly KW_ELSE = 97; + public static readonly KW_ENABLE = 98; + public static readonly KW_END = 99; + public static readonly KW_ESCAPE = 100; + public static readonly KW_ESCAPED = 101; + public static readonly KW_EXCEPT = 102; + public static readonly KW_EXCHANGE = 103; + public static readonly KW_EXCLUDE = 104; + public static readonly KW_EXISTS = 105; + public static readonly KW_EXPLAIN = 106; + public static readonly KW_EXPORT = 107; + public static readonly KW_EXTENDED = 108; + public static readonly KW_EXTERNAL = 109; + public static readonly KW_EXTRACT = 110; + public static readonly KW_FALSE = 111; + public static readonly KW_FETCH = 112; + public static readonly KW_FIELDS = 113; + public static readonly KW_FILTER = 114; + public static readonly KW_FILEFORMAT = 115; + public static readonly KW_FIRST = 116; + public static readonly KW_FLOAT = 117; + public static readonly KW_FOLLOWING = 118; + public static readonly KW_FOR = 119; + public static readonly KW_FOREIGN = 120; + public static readonly KW_FORMAT = 121; + public static readonly KW_FORMATTED = 122; + public static readonly KW_FROM = 123; + public static readonly KW_FULL = 124; + public static readonly KW_FUNCTION = 125; + public static readonly KW_FUNCTIONS = 126; + public static readonly KW_GENERATED = 127; + public static readonly KW_GLOBAL = 128; + public static readonly KW_GRANT = 129; + public static readonly KW_GROUP = 130; + public static readonly KW_GROUPING = 131; + public static readonly KW_HAVING = 132; + public static readonly KW_BINARY_HEX = 133; + public static readonly KW_HOUR = 134; + public static readonly KW_HOURS = 135; + public static readonly KW_IDENTIFIER = 136; + public static readonly KW_IF = 137; + public static readonly KW_IGNORE = 138; + public static readonly KW_IMPORT = 139; + public static readonly KW_IN = 140; + public static readonly KW_INCLUDE = 141; + public static readonly KW_INDEX = 142; + public static readonly KW_INDEXES = 143; + public static readonly KW_INNER = 144; + public static readonly KW_INPATH = 145; + public static readonly KW_INPUTFORMAT = 146; + public static readonly KW_INSERT = 147; + public static readonly KW_INTERSECT = 148; + public static readonly KW_INTERVAL = 149; + public static readonly KW_INT = 150; + public static readonly KW_INTEGER = 151; + public static readonly KW_INTO = 152; + public static readonly KW_IS = 153; + public static readonly KW_ITEMS = 154; + public static readonly KW_JOIN = 155; + public static readonly KW_KEYS = 156; + public static readonly KW_LAST = 157; + public static readonly KW_LATERAL = 158; + public static readonly KW_LAZY = 159; + public static readonly KW_LEADING = 160; + public static readonly KW_LEFT = 161; + public static readonly KW_LIFECYCLE = 162; + public static readonly KW_LIKE = 163; + public static readonly KW_ILIKE = 164; + public static readonly KW_LIMIT = 165; + public static readonly KW_LINES = 166; + public static readonly KW_LIST = 167; + public static readonly KW_LOAD = 168; + public static readonly KW_LOCAL = 169; + public static readonly KW_LOCATION = 170; + public static readonly KW_LOCK = 171; + public static readonly KW_LOCKS = 172; + public static readonly KW_LOGICAL = 173; + public static readonly KW_LONG = 174; + public static readonly KW_MACRO = 175; + public static readonly KW_MAP = 176; + public static readonly KW_MATCHED = 177; + public static readonly KW_MERGE = 178; + public static readonly KW_MICROSECOND = 179; + public static readonly KW_MICROSECONDS = 180; + public static readonly KW_MILLISECOND = 181; + public static readonly KW_MILLISECONDS = 182; + public static readonly KW_MINUTE = 183; + public static readonly KW_MINUTES = 184; + public static readonly KW_MONTH = 185; + public static readonly KW_MONTHS = 186; + public static readonly KW_MSCK = 187; + public static readonly KW_NAME = 188; + public static readonly KW_NAMESPACE = 189; + public static readonly KW_NAMESPACES = 190; + public static readonly KW_NANOSECOND = 191; + public static readonly KW_NANOSECONDS = 192; + public static readonly KW_NATURAL = 193; + public static readonly KW_NO = 194; + public static readonly KW_NOSCAN = 195; + public static readonly KW_NOT = 196; + public static readonly KW_NULL = 197; + public static readonly KW_NULLS = 198; + public static readonly KW_NUMERIC = 199; + public static readonly KW_OF = 200; + public static readonly KW_OFFSET = 201; + public static readonly KW_ON = 202; + public static readonly KW_ONLY = 203; + public static readonly KW_OPTIMIZE = 204; + public static readonly KW_OPTION = 205; + public static readonly KW_OPTIONS = 206; + public static readonly KW_OR = 207; + public static readonly KW_ORDER = 208; + public static readonly KW_OUT = 209; + public static readonly KW_OUTER = 210; + public static readonly KW_OUTPUTFORMAT = 211; + public static readonly KW_OVER = 212; + public static readonly KW_OVERLAPS = 213; + public static readonly KW_OVERLAY = 214; + public static readonly KW_OVERWRITE = 215; + public static readonly KW_PARTITION = 216; + public static readonly KW_PARTITIONED = 217; + public static readonly KW_PARTITIONS = 218; + public static readonly KW_PERCENTILE_CONT = 219; + public static readonly KW_PERCENTILE_DISC = 220; + public static readonly KW_PERCENTLIT = 221; + public static readonly KW_PIVOT = 222; + public static readonly KW_PLACING = 223; + public static readonly KW_POSITION = 224; + public static readonly KW_PRECEDING = 225; + public static readonly KW_PRIMARY = 226; + public static readonly KW_PRINCIPALS = 227; + public static readonly KW_PROPERTIES = 228; + public static readonly KW_PURGE = 229; + public static readonly KW_QUARTER = 230; + public static readonly KW_QUERY = 231; + public static readonly KW_RANGE = 232; + public static readonly KW_REAL = 233; + public static readonly KW_RECORDREADER = 234; + public static readonly KW_RECORDWRITER = 235; + public static readonly KW_RECOVER = 236; + public static readonly KW_REDUCE = 237; + public static readonly KW_REFERENCES = 238; + public static readonly KW_REFRESH = 239; + public static readonly KW_RENAME = 240; + public static readonly KW_REPAIR = 241; + public static readonly KW_REPEATABLE = 242; + public static readonly KW_REPLACE = 243; + public static readonly KW_RESET = 244; + public static readonly KW_RESPECT = 245; + public static readonly KW_RESTRICT = 246; + public static readonly KW_REWRITE = 247; + public static readonly KW_REVOKE = 248; + public static readonly KW_RIGHT = 249; + public static readonly KW_RLIKE = 250; + public static readonly KW_REGEXP = 251; + public static readonly KW_ROLE = 252; + public static readonly KW_ROLES = 253; + public static readonly KW_ROLLBACK = 254; + public static readonly KW_ROLLUP = 255; + public static readonly KW_ROW = 256; + public static readonly KW_ROWS = 257; + public static readonly KW_SECOND = 258; + public static readonly KW_SECONDS = 259; + public static readonly KW_SCHEMA = 260; + public static readonly KW_SCHEMAS = 261; + public static readonly KW_SELECT = 262; + public static readonly KW_SEMI = 263; + public static readonly KW_SEPARATED = 264; + public static readonly KW_SERDE = 265; + public static readonly KW_SERDEPROPERTIES = 266; + public static readonly KW_SESSION_USER = 267; + public static readonly KW_SET = 268; + public static readonly KW_MINUS = 269; + public static readonly KW_SETS = 270; + public static readonly KW_SHORT = 271; + public static readonly KW_SHOW = 272; + public static readonly KW_SINGLE = 273; + public static readonly KW_SKEWED = 274; + public static readonly KW_SMALLINT = 275; + public static readonly KW_SOME = 276; + public static readonly KW_SORT = 277; + public static readonly KW_SORTED = 278; + public static readonly KW_SOURCE = 279; + public static readonly KW_START = 280; + public static readonly KW_STATISTICS = 281; + public static readonly KW_STORED = 282; + public static readonly KW_STRATIFY = 283; + public static readonly KW_STRING = 284; + public static readonly KW_STRUCT = 285; + public static readonly KW_SUBSTR = 286; + public static readonly KW_SUBSTRING = 287; + public static readonly KW_SYNC = 288; + public static readonly KW_SYSTEM = 289; + public static readonly KW_SYSTEM_TIME = 290; + public static readonly KW_SYSTEM_VERSION = 291; + public static readonly KW_TABLE = 292; + public static readonly KW_TABLES = 293; + public static readonly KW_TABLESAMPLE = 294; + public static readonly KW_TARGET = 295; + public static readonly KW_TBLPROPERTIES = 296; + public static readonly KW_TEMPORARY = 297; + public static readonly KW_TERMINATED = 298; + public static readonly KW_THEN = 299; + public static readonly KW_TIME = 300; + public static readonly KW_TIMEDIFF = 301; + public static readonly KW_TIMESTAMP = 302; + public static readonly KW_TIMESTAMP_LTZ = 303; + public static readonly KW_TIMESTAMP_NTZ = 304; + public static readonly KW_TIMESTAMPADD = 305; + public static readonly KW_TIMESTAMPDIFF = 306; + public static readonly KW_TINYINT = 307; + public static readonly KW_TO = 308; + public static readonly KW_TOUCH = 309; + public static readonly KW_TRAILING = 310; + public static readonly KW_TRANSACTION = 311; + public static readonly KW_TRANSACTIONS = 312; + public static readonly KW_TRANSFORM = 313; + public static readonly KW_TRIM = 314; + public static readonly KW_TRUE = 315; + public static readonly KW_TRUNCATE = 316; + public static readonly KW_TRY_CAST = 317; + public static readonly KW_TYPE = 318; + public static readonly KW_UNARCHIVE = 319; + public static readonly KW_UNBOUNDED = 320; + public static readonly KW_UNCACHE = 321; + public static readonly KW_UNION = 322; + public static readonly KW_UNIQUE = 323; + public static readonly KW_UNKNOWN = 324; + public static readonly KW_UNLOCK = 325; + public static readonly KW_UNPIVOT = 326; + public static readonly KW_UNSET = 327; + public static readonly KW_UPDATE = 328; + public static readonly KW_USE = 329; + public static readonly KW_USER = 330; + public static readonly KW_USING = 331; + public static readonly KW_VALUES = 332; + public static readonly KW_VARCHAR = 333; + public static readonly KW_VAR = 334; + public static readonly KW_VARIABLE = 335; + public static readonly KW_VERSION = 336; + public static readonly KW_VIEW = 337; + public static readonly KW_VIEWS = 338; + public static readonly KW_VOID = 339; + public static readonly KW_WEEK = 340; + public static readonly KW_WEEKS = 341; + public static readonly KW_WHEN = 342; + public static readonly KW_WHERE = 343; + public static readonly KW_WINDOW = 344; + public static readonly KW_WITH = 345; + public static readonly KW_WITHIN = 346; + public static readonly KW_YEAR = 347; + public static readonly KW_YEARS = 348; + public static readonly KW_ZONE = 349; + public static readonly KW_ZORDER = 350; + public static readonly EQ = 351; + public static readonly NSEQ = 352; + public static readonly NEQ = 353; + public static readonly NEQJ = 354; + public static readonly LT = 355; + public static readonly LTE = 356; + public static readonly GT = 357; + public static readonly GTE = 358; + public static readonly NOT = 359; + public static readonly PLUS = 360; + public static readonly MINUS = 361; + public static readonly ASTERISK = 362; + public static readonly SLASH = 363; + public static readonly PERCENT = 364; + public static readonly TILDE = 365; + public static readonly AMPERSAND = 366; + public static readonly PIPE = 367; + public static readonly CONCAT_PIPE = 368; + public static readonly HAT = 369; + public static readonly COLON = 370; + public static readonly ARROW = 371; + public static readonly FAT_ARROW = 372; + public static readonly HENT_START = 373; + public static readonly HENT_END = 374; + public static readonly QUESTION = 375; + public static readonly STRING_LITERAL = 376; + public static readonly DOUBLEQUOTED_STRING = 377; + public static readonly BIGINT_LITERAL = 378; + public static readonly SMALLINT_LITERAL = 379; + public static readonly TINYINT_LITERAL = 380; + public static readonly INTEGER_VALUE = 381; + public static readonly EXPONENT_VALUE = 382; + public static readonly DECIMAL_VALUE = 383; + public static readonly FLOAT_LITERAL = 384; + public static readonly DOUBLE_LITERAL = 385; + public static readonly BIGDECIMAL_LITERAL = 386; + public static readonly IDENTIFIER = 387; + public static readonly BACKQUOTED_IDENTIFIER = 388; + public static readonly SIMPLE_COMMENT = 389; + public static readonly BRACKETED_COMMENT = 390; + public static readonly WS = 391; + public static readonly UNRECOGNIZED = 392; + + public static readonly channelNames = [ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + ]; + + public static readonly literalNames = [ + null, "';'", "'('", "')'", "','", "'.'", "'['", "']'", "'ADD'", + "'AFTER'", "'ALL'", "'ALTER'", "'ALWAYS'", "'ANALYZE'", "'AND'", + "'ANTI'", "'ANY'", "'ANY_VALUE'", "'ARCHIVE'", "'ARRAY'", "'AS'", + "'ASC'", "'AT'", "'AUTHORIZATION'", "'BETWEEN'", "'BIGINT'", "'BINARY'", + "'BOOLEAN'", "'BOTH'", "'BUCKET'", "'BUCKETS'", "'BY'", "'BYTE'", + "'CACHE'", "'CASCADE'", "'CASE'", "'CAST'", "'CATALOG'", "'CATALOGS'", + "'CHANGE'", "'CHAR'", "'CHARACTER'", "'CHECK'", "'CLEAR'", "'CLUSTER'", + "'CLUSTERED'", "'CODEGEN'", "'COLLATE'", "'COLLECTION'", "'COLUMN'", + "'COLUMNS'", "'COMMENT'", "'COMMIT'", "'COMPACT'", "'COMPACTIONS'", + "'COMPUTE'", "'CONCATENATE'", "'CONSTRAINT'", "'COST'", "'CREATE'", + "'CROSS'", "'CUBE'", "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_TIME'", + "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'DAY'", "'DAYS'", "'DAYOFYEAR'", + "'DATA'", "'DATE'", "'DATABASE'", "'DATABASES'", "'DATEADD'", "'DATE_ADD'", + "'DATEDIFF'", "'DATE_DIFF'", "'DBPROPERTIES'", "'DEC'", "'DECIMAL'", + "'DECLARE'", "'DEFAULT'", "'DEFINED'", "'DELETE'", "'DELIMITED'", + "'DESC'", "'DESCRIBE'", "'DFS'", "'DIRECTORIES'", "'DIRECTORY'", + "'DISABLE'", "'DISTINCT'", "'DISTRIBUTE'", "'DIV'", "'DOUBLE'", + "'DROP'", "'ELSE'", "'ENABLE'", "'END'", "'ESCAPE'", "'ESCAPED'", + "'EXCEPT'", "'EXCHANGE'", "'EXCLUDE'", "'EXISTS'", "'EXPLAIN'", + "'EXPORT'", "'EXTENDED'", "'EXTERNAL'", "'EXTRACT'", "'FALSE'", + "'FETCH'", "'FIELDS'", "'FILTER'", "'FILEFORMAT'", "'FIRST'", "'FLOAT'", + "'FOLLOWING'", "'FOR'", "'FOREIGN'", "'FORMAT'", "'FORMATTED'", + "'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GENERATED'", + "'GLOBAL'", "'GRANT'", "'GROUP'", "'GROUPING'", "'HAVING'", "'X'", + "'HOUR'", "'HOURS'", "'IDENTIFIER'", "'IF'", "'IGNORE'", "'IMPORT'", + "'IN'", "'INCLUDE'", "'INDEX'", "'INDEXES'", "'INNER'", "'INPATH'", + "'INPUTFORMAT'", "'INSERT'", "'INTERSECT'", "'INTERVAL'", "'INT'", + "'INTEGER'", "'INTO'", "'IS'", "'ITEMS'", "'JOIN'", "'KEYS'", "'LAST'", + "'LATERAL'", "'LAZY'", "'LEADING'", "'LEFT'", "'LIFECYCLE'", "'LIKE'", + "'ILIKE'", "'LIMIT'", "'LINES'", "'LIST'", "'LOAD'", "'LOCAL'", + "'LOCATION'", "'LOCK'", "'LOCKS'", "'LOGICAL'", "'LONG'", "'MACRO'", + "'MAP'", "'MATCHED'", "'MERGE'", "'MICROSECOND'", "'MICROSECONDS'", + "'MILLISECOND'", "'MILLISECONDS'", "'MINUTE'", "'MINUTES'", "'MONTH'", + "'MONTHS'", "'MSCK'", "'NAME'", "'NAMESPACE'", "'NAMESPACES'", "'NANOSECOND'", + "'NANOSECONDS'", "'NATURAL'", "'NO'", "'NOSCAN'", "'NOT'", "'NULL'", + "'NULLS'", "'NUMERIC'", "'OF'", "'OFFSET'", "'ON'", "'ONLY'", "'OPTIMIZE'", + "'OPTION'", "'OPTIONS'", "'OR'", "'ORDER'", "'OUT'", "'OUTER'", + "'OUTPUTFORMAT'", "'OVER'", "'OVERLAPS'", "'OVERLAY'", "'OVERWRITE'", + "'PARTITION'", "'PARTITIONED'", "'PARTITIONS'", "'PERCENTILE_CONT'", + "'PERCENTILE_DISC'", "'PERCENT'", "'PIVOT'", "'PLACING'", "'POSITION'", + "'PRECEDING'", "'PRIMARY'", "'PRINCIPALS'", "'PROPERTIES'", "'PURGE'", + "'QUARTER'", "'QUERY'", "'RANGE'", "'REAL'", "'RECORDREADER'", "'RECORDWRITER'", + "'RECOVER'", "'REDUCE'", "'REFERENCES'", "'REFRESH'", "'RENAME'", + "'REPAIR'", "'REPEATABLE'", "'REPLACE'", "'RESET'", "'RESPECT'", + "'RESTRICT'", "'REWRITE'", "'REVOKE'", "'RIGHT'", "'RLIKE'", "'REGEXP'", + "'ROLE'", "'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROW'", "'ROWS'", + "'SECOND'", "'SECONDS'", "'SCHEMA'", "'SCHEMAS'", "'SELECT'", "'SEMI'", + "'SEPARATED'", "'SERDE'", "'SERDEPROPERTIES'", "'SESSION_USER'", + "'SET'", "'MINUS'", "'SETS'", "'SHORT'", "'SHOW'", "'SINGLE'", "'SKEWED'", + "'SMALLINT'", "'SOME'", "'SORT'", "'SORTED'", "'SOURCE'", "'START'", + "'STATISTICS'", "'STORED'", "'STRATIFY'", "'STRING'", "'STRUCT'", + "'SUBSTR'", "'SUBSTRING'", "'SYNC'", "'SYSTEM'", "'SYSTEM_TIME'", + "'SYSTEM_VERSION'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TARGET'", + "'TBLPROPERTIES'", "'TEMPORARY'", "'TERMINATED'", "'THEN'", "'TIME'", + "'TIMEDIFF'", "'TIMESTAMP'", "'TIMESTAMP_LTZ'", "'TIMESTAMP_NTZ'", + "'TIMESTAMPADD'", "'TIMESTAMPDIFF'", "'TINYINT'", "'TO'", "'TOUCH'", + "'TRAILING'", "'TRANSACTION'", "'TRANSACTIONS'", "'TRANSFORM'", + "'TRIM'", "'TRUE'", "'TRUNCATE'", "'TRY_CAST'", "'TYPE'", "'UNARCHIVE'", + "'UNBOUNDED'", "'UNCACHE'", "'UNION'", "'UNIQUE'", "'UNKNOWN'", + "'UNLOCK'", "'UNPIVOT'", "'UNSET'", "'UPDATE'", "'USE'", "'USER'", + "'USING'", "'VALUES'", "'VARCHAR'", "'VAR'", "'VARIABLE'", "'VERSION'", + "'VIEW'", "'VIEWS'", "'VOID'", "'WEEK'", "'WEEKS'", "'WHEN'", "'WHERE'", + "'WINDOW'", "'WITH'", "'WITHIN'", "'YEAR'", "'YEARS'", "'ZONE'", + "'ZORDER'", null, "'<=>'", "'<>'", "'!='", "'<'", null, "'>'", null, + "'!'", "'+'", "'-'", "'*'", "'/'", "'%'", "'~'", "'&'", "'|'", "'||'", + "'^'", "':'", "'->'", "'=>'", "'/*+'", "'*/'", "'?'" + ]; + + public static readonly symbolicNames = [ + null, "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT", + "LEFT_BRACKET", "RIGHT_BRACKET", "KW_ADD", "KW_AFTER", "KW_ALL", + "KW_ALTER", "KW_ALWAYS", "KW_ANALYZE", "KW_AND", "KW_ANTI", "KW_ANY", + "KW_ANY_VALUE", "KW_ARCHIVE", "KW_ARRAY", "KW_AS", "KW_ASC", "KW_AT", + "KW_AUTHORIZATION", "KW_BETWEEN", "KW_BIGINT", "KW_BINARY", "KW_BOOLEAN", + "KW_BOTH", "KW_BUCKET", "KW_BUCKETS", "KW_BY", "KW_BYTE", "KW_CACHE", + "KW_CASCADE", "KW_CASE", "KW_CAST", "KW_CATALOG", "KW_CATALOGS", + "KW_CHANGE", "KW_CHAR", "KW_CHARACTER", "KW_CHECK", "KW_CLEAR", + "KW_CLUSTER", "KW_CLUSTERED", "KW_CODEGEN", "KW_COLLATE", "KW_COLLECTION", + "KW_COLUMN", "KW_COLUMNS", "KW_COMMENT", "KW_COMMIT", "KW_COMPACT", + "KW_COMPACTIONS", "KW_COMPUTE", "KW_CONCATENATE", "KW_CONSTRAINT", + "KW_COST", "KW_CREATE", "KW_CROSS", "KW_CUBE", "KW_CURRENT", "KW_CURRENT_DATE", + "KW_CURRENT_TIME", "KW_CURRENT_TIMESTAMP", "KW_CURRENT_USER", "KW_DAY", + "KW_DAYS", "KW_DAYOFYEAR", "KW_DATA", "KW_DATE", "KW_DATABASE", + "KW_DATABASES", "KW_DATEADD", "KW_DATE_ADD", "KW_DATEDIFF", "KW_DATE_DIFF", + "KW_DBPROPERTIES", "KW_DEC", "KW_DECIMAL", "KW_DECLARE", "KW_DEFAULT", + "KW_DEFINED", "KW_DELETE", "KW_DELIMITED", "KW_DESC", "KW_DESCRIBE", + "KW_DFS", "KW_DIRECTORIES", "KW_DIRECTORY", "KW_DISABLE", "KW_DISTINCT", + "KW_DISTRIBUTE", "KW_DIV", "KW_DOUBLE", "KW_DROP", "KW_ELSE", "KW_ENABLE", + "KW_END", "KW_ESCAPE", "KW_ESCAPED", "KW_EXCEPT", "KW_EXCHANGE", + "KW_EXCLUDE", "KW_EXISTS", "KW_EXPLAIN", "KW_EXPORT", "KW_EXTENDED", + "KW_EXTERNAL", "KW_EXTRACT", "KW_FALSE", "KW_FETCH", "KW_FIELDS", + "KW_FILTER", "KW_FILEFORMAT", "KW_FIRST", "KW_FLOAT", "KW_FOLLOWING", + "KW_FOR", "KW_FOREIGN", "KW_FORMAT", "KW_FORMATTED", "KW_FROM", + "KW_FULL", "KW_FUNCTION", "KW_FUNCTIONS", "KW_GENERATED", "KW_GLOBAL", + "KW_GRANT", "KW_GROUP", "KW_GROUPING", "KW_HAVING", "KW_BINARY_HEX", + "KW_HOUR", "KW_HOURS", "KW_IDENTIFIER", "KW_IF", "KW_IGNORE", "KW_IMPORT", + "KW_IN", "KW_INCLUDE", "KW_INDEX", "KW_INDEXES", "KW_INNER", "KW_INPATH", + "KW_INPUTFORMAT", "KW_INSERT", "KW_INTERSECT", "KW_INTERVAL", "KW_INT", + "KW_INTEGER", "KW_INTO", "KW_IS", "KW_ITEMS", "KW_JOIN", "KW_KEYS", + "KW_LAST", "KW_LATERAL", "KW_LAZY", "KW_LEADING", "KW_LEFT", "KW_LIFECYCLE", + "KW_LIKE", "KW_ILIKE", "KW_LIMIT", "KW_LINES", "KW_LIST", "KW_LOAD", + "KW_LOCAL", "KW_LOCATION", "KW_LOCK", "KW_LOCKS", "KW_LOGICAL", + "KW_LONG", "KW_MACRO", "KW_MAP", "KW_MATCHED", "KW_MERGE", "KW_MICROSECOND", + "KW_MICROSECONDS", "KW_MILLISECOND", "KW_MILLISECONDS", "KW_MINUTE", + "KW_MINUTES", "KW_MONTH", "KW_MONTHS", "KW_MSCK", "KW_NAME", "KW_NAMESPACE", + "KW_NAMESPACES", "KW_NANOSECOND", "KW_NANOSECONDS", "KW_NATURAL", + "KW_NO", "KW_NOSCAN", "KW_NOT", "KW_NULL", "KW_NULLS", "KW_NUMERIC", + "KW_OF", "KW_OFFSET", "KW_ON", "KW_ONLY", "KW_OPTIMIZE", "KW_OPTION", + "KW_OPTIONS", "KW_OR", "KW_ORDER", "KW_OUT", "KW_OUTER", "KW_OUTPUTFORMAT", + "KW_OVER", "KW_OVERLAPS", "KW_OVERLAY", "KW_OVERWRITE", "KW_PARTITION", + "KW_PARTITIONED", "KW_PARTITIONS", "KW_PERCENTILE_CONT", "KW_PERCENTILE_DISC", + "KW_PERCENTLIT", "KW_PIVOT", "KW_PLACING", "KW_POSITION", "KW_PRECEDING", + "KW_PRIMARY", "KW_PRINCIPALS", "KW_PROPERTIES", "KW_PURGE", "KW_QUARTER", + "KW_QUERY", "KW_RANGE", "KW_REAL", "KW_RECORDREADER", "KW_RECORDWRITER", + "KW_RECOVER", "KW_REDUCE", "KW_REFERENCES", "KW_REFRESH", "KW_RENAME", + "KW_REPAIR", "KW_REPEATABLE", "KW_REPLACE", "KW_RESET", "KW_RESPECT", + "KW_RESTRICT", "KW_REWRITE", "KW_REVOKE", "KW_RIGHT", "KW_RLIKE", + "KW_REGEXP", "KW_ROLE", "KW_ROLES", "KW_ROLLBACK", "KW_ROLLUP", + "KW_ROW", "KW_ROWS", "KW_SECOND", "KW_SECONDS", "KW_SCHEMA", "KW_SCHEMAS", + "KW_SELECT", "KW_SEMI", "KW_SEPARATED", "KW_SERDE", "KW_SERDEPROPERTIES", + "KW_SESSION_USER", "KW_SET", "KW_MINUS", "KW_SETS", "KW_SHORT", + "KW_SHOW", "KW_SINGLE", "KW_SKEWED", "KW_SMALLINT", "KW_SOME", "KW_SORT", + "KW_SORTED", "KW_SOURCE", "KW_START", "KW_STATISTICS", "KW_STORED", + "KW_STRATIFY", "KW_STRING", "KW_STRUCT", "KW_SUBSTR", "KW_SUBSTRING", + "KW_SYNC", "KW_SYSTEM", "KW_SYSTEM_TIME", "KW_SYSTEM_VERSION", "KW_TABLE", + "KW_TABLES", "KW_TABLESAMPLE", "KW_TARGET", "KW_TBLPROPERTIES", + "KW_TEMPORARY", "KW_TERMINATED", "KW_THEN", "KW_TIME", "KW_TIMEDIFF", + "KW_TIMESTAMP", "KW_TIMESTAMP_LTZ", "KW_TIMESTAMP_NTZ", "KW_TIMESTAMPADD", + "KW_TIMESTAMPDIFF", "KW_TINYINT", "KW_TO", "KW_TOUCH", "KW_TRAILING", + "KW_TRANSACTION", "KW_TRANSACTIONS", "KW_TRANSFORM", "KW_TRIM", + "KW_TRUE", "KW_TRUNCATE", "KW_TRY_CAST", "KW_TYPE", "KW_UNARCHIVE", + "KW_UNBOUNDED", "KW_UNCACHE", "KW_UNION", "KW_UNIQUE", "KW_UNKNOWN", + "KW_UNLOCK", "KW_UNPIVOT", "KW_UNSET", "KW_UPDATE", "KW_USE", "KW_USER", + "KW_USING", "KW_VALUES", "KW_VARCHAR", "KW_VAR", "KW_VARIABLE", + "KW_VERSION", "KW_VIEW", "KW_VIEWS", "KW_VOID", "KW_WEEK", "KW_WEEKS", + "KW_WHEN", "KW_WHERE", "KW_WINDOW", "KW_WITH", "KW_WITHIN", "KW_YEAR", + "KW_YEARS", "KW_ZONE", "KW_ZORDER", "EQ", "NSEQ", "NEQ", "NEQJ", + "LT", "LTE", "GT", "GTE", "NOT", "PLUS", "MINUS", "ASTERISK", "SLASH", + "PERCENT", "TILDE", "AMPERSAND", "PIPE", "CONCAT_PIPE", "HAT", "COLON", + "ARROW", "FAT_ARROW", "HENT_START", "HENT_END", "QUESTION", "STRING_LITERAL", + "DOUBLEQUOTED_STRING", "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", + "INTEGER_VALUE", "EXPONENT_VALUE", "DECIMAL_VALUE", "FLOAT_LITERAL", + "DOUBLE_LITERAL", "BIGDECIMAL_LITERAL", "IDENTIFIER", "BACKQUOTED_IDENTIFIER", + "SIMPLE_COMMENT", "BRACKETED_COMMENT", "WS", "UNRECOGNIZED" + ]; + + public static readonly modeNames = [ + "DEFAULT_MODE", + ]; + + public static readonly ruleNames = [ + "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT", "LEFT_BRACKET", + "RIGHT_BRACKET", "KW_ADD", "KW_AFTER", "KW_ALL", "KW_ALTER", "KW_ALWAYS", + "KW_ANALYZE", "KW_AND", "KW_ANTI", "KW_ANY", "KW_ANY_VALUE", "KW_ARCHIVE", + "KW_ARRAY", "KW_AS", "KW_ASC", "KW_AT", "KW_AUTHORIZATION", "KW_BETWEEN", + "KW_BIGINT", "KW_BINARY", "KW_BOOLEAN", "KW_BOTH", "KW_BUCKET", + "KW_BUCKETS", "KW_BY", "KW_BYTE", "KW_CACHE", "KW_CASCADE", "KW_CASE", + "KW_CAST", "KW_CATALOG", "KW_CATALOGS", "KW_CHANGE", "KW_CHAR", + "KW_CHARACTER", "KW_CHECK", "KW_CLEAR", "KW_CLUSTER", "KW_CLUSTERED", + "KW_CODEGEN", "KW_COLLATE", "KW_COLLECTION", "KW_COLUMN", "KW_COLUMNS", + "KW_COMMENT", "KW_COMMIT", "KW_COMPACT", "KW_COMPACTIONS", "KW_COMPUTE", + "KW_CONCATENATE", "KW_CONSTRAINT", "KW_COST", "KW_CREATE", "KW_CROSS", + "KW_CUBE", "KW_CURRENT", "KW_CURRENT_DATE", "KW_CURRENT_TIME", "KW_CURRENT_TIMESTAMP", + "KW_CURRENT_USER", "KW_DAY", "KW_DAYS", "KW_DAYOFYEAR", "KW_DATA", + "KW_DATE", "KW_DATABASE", "KW_DATABASES", "KW_DATEADD", "KW_DATE_ADD", + "KW_DATEDIFF", "KW_DATE_DIFF", "KW_DBPROPERTIES", "KW_DEC", "KW_DECIMAL", + "KW_DECLARE", "KW_DEFAULT", "KW_DEFINED", "KW_DELETE", "KW_DELIMITED", + "KW_DESC", "KW_DESCRIBE", "KW_DFS", "KW_DIRECTORIES", "KW_DIRECTORY", + "KW_DISABLE", "KW_DISTINCT", "KW_DISTRIBUTE", "KW_DIV", "KW_DOUBLE", + "KW_DROP", "KW_ELSE", "KW_ENABLE", "KW_END", "KW_ESCAPE", "KW_ESCAPED", + "KW_EXCEPT", "KW_EXCHANGE", "KW_EXCLUDE", "KW_EXISTS", "KW_EXPLAIN", + "KW_EXPORT", "KW_EXTENDED", "KW_EXTERNAL", "KW_EXTRACT", "KW_FALSE", + "KW_FETCH", "KW_FIELDS", "KW_FILTER", "KW_FILEFORMAT", "KW_FIRST", + "KW_FLOAT", "KW_FOLLOWING", "KW_FOR", "KW_FOREIGN", "KW_FORMAT", + "KW_FORMATTED", "KW_FROM", "KW_FULL", "KW_FUNCTION", "KW_FUNCTIONS", + "KW_GENERATED", "KW_GLOBAL", "KW_GRANT", "KW_GROUP", "KW_GROUPING", + "KW_HAVING", "KW_BINARY_HEX", "KW_HOUR", "KW_HOURS", "KW_IDENTIFIER", + "KW_IF", "KW_IGNORE", "KW_IMPORT", "KW_IN", "KW_INCLUDE", "KW_INDEX", + "KW_INDEXES", "KW_INNER", "KW_INPATH", "KW_INPUTFORMAT", "KW_INSERT", + "KW_INTERSECT", "KW_INTERVAL", "KW_INT", "KW_INTEGER", "KW_INTO", + "KW_IS", "KW_ITEMS", "KW_JOIN", "KW_KEYS", "KW_LAST", "KW_LATERAL", + "KW_LAZY", "KW_LEADING", "KW_LEFT", "KW_LIFECYCLE", "KW_LIKE", "KW_ILIKE", + "KW_LIMIT", "KW_LINES", "KW_LIST", "KW_LOAD", "KW_LOCAL", "KW_LOCATION", + "KW_LOCK", "KW_LOCKS", "KW_LOGICAL", "KW_LONG", "KW_MACRO", "KW_MAP", + "KW_MATCHED", "KW_MERGE", "KW_MICROSECOND", "KW_MICROSECONDS", "KW_MILLISECOND", + "KW_MILLISECONDS", "KW_MINUTE", "KW_MINUTES", "KW_MONTH", "KW_MONTHS", + "KW_MSCK", "KW_NAME", "KW_NAMESPACE", "KW_NAMESPACES", "KW_NANOSECOND", + "KW_NANOSECONDS", "KW_NATURAL", "KW_NO", "KW_NOSCAN", "KW_NOT", + "KW_NULL", "KW_NULLS", "KW_NUMERIC", "KW_OF", "KW_OFFSET", "KW_ON", + "KW_ONLY", "KW_OPTIMIZE", "KW_OPTION", "KW_OPTIONS", "KW_OR", "KW_ORDER", + "KW_OUT", "KW_OUTER", "KW_OUTPUTFORMAT", "KW_OVER", "KW_OVERLAPS", + "KW_OVERLAY", "KW_OVERWRITE", "KW_PARTITION", "KW_PARTITIONED", + "KW_PARTITIONS", "KW_PERCENTILE_CONT", "KW_PERCENTILE_DISC", "KW_PERCENTLIT", + "KW_PIVOT", "KW_PLACING", "KW_POSITION", "KW_PRECEDING", "KW_PRIMARY", + "KW_PRINCIPALS", "KW_PROPERTIES", "KW_PURGE", "KW_QUARTER", "KW_QUERY", + "KW_RANGE", "KW_REAL", "KW_RECORDREADER", "KW_RECORDWRITER", "KW_RECOVER", + "KW_REDUCE", "KW_REFERENCES", "KW_REFRESH", "KW_RENAME", "KW_REPAIR", + "KW_REPEATABLE", "KW_REPLACE", "KW_RESET", "KW_RESPECT", "KW_RESTRICT", + "KW_REWRITE", "KW_REVOKE", "KW_RIGHT", "KW_RLIKE", "KW_REGEXP", + "KW_ROLE", "KW_ROLES", "KW_ROLLBACK", "KW_ROLLUP", "KW_ROW", "KW_ROWS", + "KW_SECOND", "KW_SECONDS", "KW_SCHEMA", "KW_SCHEMAS", "KW_SELECT", + "KW_SEMI", "KW_SEPARATED", "KW_SERDE", "KW_SERDEPROPERTIES", "KW_SESSION_USER", + "KW_SET", "KW_MINUS", "KW_SETS", "KW_SHORT", "KW_SHOW", "KW_SINGLE", + "KW_SKEWED", "KW_SMALLINT", "KW_SOME", "KW_SORT", "KW_SORTED", "KW_SOURCE", + "KW_START", "KW_STATISTICS", "KW_STORED", "KW_STRATIFY", "KW_STRING", + "KW_STRUCT", "KW_SUBSTR", "KW_SUBSTRING", "KW_SYNC", "KW_SYSTEM", + "KW_SYSTEM_TIME", "KW_SYSTEM_VERSION", "KW_TABLE", "KW_TABLES", + "KW_TABLESAMPLE", "KW_TARGET", "KW_TBLPROPERTIES", "KW_TEMPORARY", + "KW_TERMINATED", "KW_THEN", "KW_TIME", "KW_TIMEDIFF", "KW_TIMESTAMP", + "KW_TIMESTAMP_LTZ", "KW_TIMESTAMP_NTZ", "KW_TIMESTAMPADD", "KW_TIMESTAMPDIFF", + "KW_TINYINT", "KW_TO", "KW_TOUCH", "KW_TRAILING", "KW_TRANSACTION", + "KW_TRANSACTIONS", "KW_TRANSFORM", "KW_TRIM", "KW_TRUE", "KW_TRUNCATE", + "KW_TRY_CAST", "KW_TYPE", "KW_UNARCHIVE", "KW_UNBOUNDED", "KW_UNCACHE", + "KW_UNION", "KW_UNIQUE", "KW_UNKNOWN", "KW_UNLOCK", "KW_UNPIVOT", + "KW_UNSET", "KW_UPDATE", "KW_USE", "KW_USER", "KW_USING", "KW_VALUES", + "KW_VARCHAR", "KW_VAR", "KW_VARIABLE", "KW_VERSION", "KW_VIEW", + "KW_VIEWS", "KW_VOID", "KW_WEEK", "KW_WEEKS", "KW_WHEN", "KW_WHERE", + "KW_WINDOW", "KW_WITH", "KW_WITHIN", "KW_YEAR", "KW_YEARS", "KW_ZONE", + "KW_ZORDER", "EQ", "NSEQ", "NEQ", "NEQJ", "LT", "LTE", "GT", "GTE", + "NOT", "PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", "TILDE", + "AMPERSAND", "PIPE", "CONCAT_PIPE", "HAT", "COLON", "ARROW", "FAT_ARROW", + "HENT_START", "HENT_END", "QUESTION", "STRING_LITERAL", "DOUBLEQUOTED_STRING", + "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", "INTEGER_VALUE", + "EXPONENT_VALUE", "DECIMAL_VALUE", "FLOAT_LITERAL", "DOUBLE_LITERAL", + "BIGDECIMAL_LITERAL", "IDENTIFIER", "BACKQUOTED_IDENTIFIER", "DECIMAL_DIGITS", + "EXPONENT", "DIGIT", "LETTER", "SIMPLE_COMMENT", "BRACKETED_COMMENT", + "WS", "UNRECOGNIZED", + ]; + + + /** + * When true, parser should throw ParseException for unclosed bracketed comment. + */ + public has_unclosed_bracketed_comment = false; + + /** + * This method will be called when the character stream ends and try to find out the + * unclosed bracketed comment. + * If the method be called, it means the end of the entire character stream match, + * and we set the flag and fail later. + */ + public markUnclosedComment() { + this.has_unclosed_bracketed_comment = true; + } + + + public constructor(input: antlr.CharStream) { + super(input); + this.interpreter = new antlr.LexerATNSimulator(this, SqlLexer._ATN, SqlLexer.decisionsToDFA, new antlr.PredictionContextCache()); + } + + public get grammarFileName(): string { return "SqlLexer.g4"; } + + public get literalNames(): (string | null)[] { return SqlLexer.literalNames; } + public get symbolicNames(): (string | null)[] { return SqlLexer.symbolicNames; } + public get ruleNames(): string[] { return SqlLexer.ruleNames; } + + public get serializedATN(): number[] { return SqlLexer._serializedATN; } + + public get channelNames(): string[] { return SqlLexer.channelNames; } + + public get modeNames(): string[] { return SqlLexer.modeNames; } + + public override action(localContext: antlr.RuleContext | null, ruleIndex: number, actionIndex: number): void { + switch (ruleIndex) { + case 393: + this.BRACKETED_COMMENT_action(localContext, actionIndex); + break; + } + } + private BRACKETED_COMMENT_action(localContext: antlr.RuleContext | null, actionIndex: number): void { + switch (actionIndex) { + case 0: + this.markUnclosedComment(); + break; + } + } + + public static readonly _serializedATN: number[] = [ + 4,0,392,3694,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,2,360,7,360,2,361,7,361, + 2,362,7,362,2,363,7,363,2,364,7,364,2,365,7,365,2,366,7,366,2,367, + 7,367,2,368,7,368,2,369,7,369,2,370,7,370,2,371,7,371,2,372,7,372, + 2,373,7,373,2,374,7,374,2,375,7,375,2,376,7,376,2,377,7,377,2,378, + 7,378,2,379,7,379,2,380,7,380,2,381,7,381,2,382,7,382,2,383,7,383, + 2,384,7,384,2,385,7,385,2,386,7,386,2,387,7,387,2,388,7,388,2,389, + 7,389,2,390,7,390,2,391,7,391,2,392,7,392,2,393,7,393,2,394,7,394, + 2,395,7,395,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,1,7,1,7,1,7,1,7,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,12, + 1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,13,1,13,1,13,1,13,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,16,1,17,1,17,1,17,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,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,22, + 1,22,1,22,1,22,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,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,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,31,1,31,1,31,1,31,1,31,1,32,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,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,36, + 1,36,1,36,1,37,1,37,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,38,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,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,43,1,43,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,44,1,44,1,44,1,44,1,45,1,45, + 1,45,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,47,1,48, + 1,48,1,48,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,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,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,55,1,55,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,56,1,56,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,61, + 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,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,64,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,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,65,1,66, + 1,66,1,66,1,66,1,67,1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68, + 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,71,1,71,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,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,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,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,77,1,77,1,77,1,77,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,80,1,80,1,80,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,83,1,84,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,86,1,86, + 1,86,1,86,1,86,1,86,1,86,1,86,1,86,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,88,1,89,1,89,1,89, + 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,90,1,91,1,91,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,92,1,92,1,92,1,92,1,93,1,93,1,93,1,93, + 1,94,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,96,1,97,1,97,1,97,1,97,1,97,1,97,1,97,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,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,102,1,103, + 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,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,107,1,107,1,107,1,107, + 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,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,112,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,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,117,1,117,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,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,120,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121, + 1,122,1,122,1,122,1,122,1,122,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,124,1,124,1,125,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,127,1,127,1,127,1,127,1,127, + 1,127,1,127,1,128,1,128,1,128,1,128,1,128,1,128,1,129,1,129,1,129, + 1,129,1,129,1,129,1,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130, + 1,130,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,132,1,132,1,133, + 1,133,1,133,1,133,1,133,1,134,1,134,1,134,1,134,1,134,1,134,1,135, + 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,136, + 1,136,1,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,138,1,138, + 1,138,1,138,1,138,1,138,1,138,1,139,1,139,1,139,1,140,1,140,1,140, + 1,140,1,140,1,140,1,140,1,140,1,141,1,141,1,141,1,141,1,141,1,141, + 1,142,1,142,1,142,1,142,1,142,1,142,1,142,1,142,1,143,1,143,1,143, + 1,143,1,143,1,143,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,145, + 1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145, + 1,146,1,146,1,146,1,146,1,146,1,146,1,146,1,147,1,147,1,147,1,147, + 1,147,1,147,1,147,1,147,1,147,1,147,1,148,1,148,1,148,1,148,1,148, + 1,148,1,148,1,148,1,148,1,149,1,149,1,149,1,149,1,150,1,150,1,150, + 1,150,1,150,1,150,1,150,1,150,1,151,1,151,1,151,1,151,1,151,1,152, + 1,152,1,152,1,153,1,153,1,153,1,153,1,153,1,153,1,154,1,154,1,154, + 1,154,1,154,1,155,1,155,1,155,1,155,1,155,1,156,1,156,1,156,1,156, + 1,156,1,157,1,157,1,157,1,157,1,157,1,157,1,157,1,157,1,158,1,158, + 1,158,1,158,1,158,1,159,1,159,1,159,1,159,1,159,1,159,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,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,163,1,164,1,164,1,164,1,164,1,164,1,164,1,165, + 1,165,1,165,1,165,1,165,1,165,1,166,1,166,1,166,1,166,1,166,1,167, + 1,167,1,167,1,167,1,167,1,168,1,168,1,168,1,168,1,168,1,168,1,169, + 1,169,1,169,1,169,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,1,171,1,171,1,171,1,172,1,172,1,172, + 1,172,1,172,1,172,1,172,1,172,1,173,1,173,1,173,1,173,1,173,1,174, + 1,174,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,176,1,176,1,176,1,176,1,177,1,177,1,177,1,177,1,177, + 1,177,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, + 1,178,1,178,1,179,1,179,1,179,1,179,1,179,1,179,1,179,1,179,1,179, + 1,179,1,179,1,179,1,179,1,180,1,180,1,180,1,180,1,180,1,180,1,180, + 1,180,1,180,1,180,1,180,1,180,1,181,1,181,1,181,1,181,1,181,1,181, + 1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,182,1,182,1,182,1,182, + 1,182,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,185,1,185,1,185,1,185,1,185, + 1,185,1,185,1,186,1,186,1,186,1,186,1,186,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,188,1,188,1,188, + 1,189,1,189,1,189,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,190,1,190,1,190, + 1,191,1,191,1,191,1,191,1,191,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,1,192,1,193,1,193, + 1,193,1,194,1,194,1,194,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,196,1,197,1,197,1,197,1,197,1,197, + 1,197,1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,199,1,199, + 1,199,1,200,1,200,1,200,1,200,1,200,1,200,1,200,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,203,1,203,1,203,1,204,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,205,1,205,1,206,1,206,1,206,1,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,1,209,1,209,1,210,1,210,1,210,1,210,1,210,1,210,1,210, + 1,210,1,210,1,210,1,210,1,210,1,210,1,211,1,211,1,211,1,211,1,211, + 1,212,1,212,1,212,1,212,1,212,1,212,1,212,1,212,1,212,1,213,1,213, + 1,213,1,213,1,213,1,213,1,213,1,213,1,214,1,214,1,214,1,214,1,214, + 1,214,1,214,1,214,1,214,1,214,1,215,1,215,1,215,1,215,1,215,1,215, + 1,215,1,215,1,215,1,215,1,216,1,216,1,216,1,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,1,216,1,217,1,217,1,217,1,217,1,217,1,217, + 1,217,1,217,1,217,1,217,1,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,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,220,1,220,1,220,1,220,1,220,1,220,1,220, + 1,220,1,221,1,221,1,221,1,221,1,221,1,221,1,222,1,222,1,222,1,222, + 1,222,1,222,1,222,1,222,1,223,1,223,1,223,1,223,1,223,1,223,1,223, + 1,223,1,223,1,224,1,224,1,224,1,224,1,224,1,224,1,224,1,224,1,224, + 1,224,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,226,1,226, + 1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,227,1,227, + 1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,228,1,228, + 1,228,1,228,1,228,1,228,1,229,1,229,1,229,1,229,1,229,1,229,1,229, + 1,229,1,230,1,230,1,230,1,230,1,230,1,230,1,231,1,231,1,231,1,231, + 1,231,1,231,1,232,1,232,1,232,1,232,1,232,1,233,1,233,1,233,1,233, + 1,233,1,233,1,233,1,233,1,233,1,233,1,233,1,233,1,233,1,234,1,234, + 1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234, + 1,235,1,235,1,235,1,235,1,235,1,235,1,235,1,235,1,236,1,236,1,236, + 1,236,1,236,1,236,1,236,1,237,1,237,1,237,1,237,1,237,1,237,1,237, + 1,237,1,237,1,237,1,237,1,238,1,238,1,238,1,238,1,238,1,238,1,238, + 1,238,1,239,1,239,1,239,1,239,1,239,1,239,1,239,1,240,1,240,1,240, + 1,240,1,240,1,240,1,240,1,241,1,241,1,241,1,241,1,241,1,241,1,241, + 1,241,1,241,1,241,1,241,1,242,1,242,1,242,1,242,1,242,1,242,1,242, + 1,242,1,243,1,243,1,243,1,243,1,243,1,243,1,244,1,244,1,244,1,244, + 1,244,1,244,1,244,1,244,1,245,1,245,1,245,1,245,1,245,1,245,1,245, + 1,245,1,245,1,246,1,246,1,246,1,246,1,246,1,246,1,246,1,246,1,247, + 1,247,1,247,1,247,1,247,1,247,1,247,1,248,1,248,1,248,1,248,1,248, + 1,248,1,249,1,249,1,249,1,249,1,249,1,249,1,250,1,250,1,250,1,250, + 1,250,1,250,1,250,1,251,1,251,1,251,1,251,1,251,1,252,1,252,1,252, + 1,252,1,252,1,252,1,253,1,253,1,253,1,253,1,253,1,253,1,253,1,253, + 1,253,1,254,1,254,1,254,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,256,1,257,1,257,1,257,1,257,1,257, + 1,257,1,257,1,258,1,258,1,258,1,258,1,258,1,258,1,258,1,258,1,259, + 1,259,1,259,1,259,1,259,1,259,1,259,1,260,1,260,1,260,1,260,1,260, + 1,260,1,260,1,260,1,261,1,261,1,261,1,261,1,261,1,261,1,261,1,262, + 1,262,1,262,1,262,1,262,1,263,1,263,1,263,1,263,1,263,1,263,1,263, + 1,263,1,263,1,263,1,264,1,264,1,264,1,264,1,264,1,264,1,265,1,265, + 1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,265, + 1,265,1,265,1,265,1,266,1,266,1,266,1,266,1,266,1,266,1,266,1,266, + 1,266,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,268,1,268,1,269,1,269,1,269,1,269,1,269,1,270,1,270, + 1,270,1,270,1,270,1,270,1,271,1,271,1,271,1,271,1,271,1,272,1,272, + 1,272,1,272,1,272,1,272,1,272,1,273,1,273,1,273,1,273,1,273,1,273, + 1,273,1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,275, + 1,275,1,275,1,275,1,275,1,276,1,276,1,276,1,276,1,276,1,277,1,277, + 1,277,1,277,1,277,1,277,1,277,1,278,1,278,1,278,1,278,1,278,1,278, + 1,278,1,279,1,279,1,279,1,279,1,279,1,279,1,280,1,280,1,280,1,280, + 1,280,1,280,1,280,1,280,1,280,1,280,1,280,1,281,1,281,1,281,1,281, + 1,281,1,281,1,281,1,282,1,282,1,282,1,282,1,282,1,282,1,282,1,282, + 1,282,1,283,1,283,1,283,1,283,1,283,1,283,1,283,1,284,1,284,1,284, + 1,284,1,284,1,284,1,284,1,285,1,285,1,285,1,285,1,285,1,285,1,285, + 1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,287, + 1,287,1,287,1,287,1,287,1,288,1,288,1,288,1,288,1,288,1,288,1,288, + 1,289,1,289,1,289,1,289,1,289,1,289,1,289,1,289,1,289,1,289,1,289, + 1,289,1,290,1,290,1,290,1,290,1,290,1,290,1,290,1,290,1,290,1,290, + 1,290,1,290,1,290,1,290,1,290,1,291,1,291,1,291,1,291,1,291,1,291, + 1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,293,1,293,1,293,1,293, + 1,293,1,293,1,293,1,293,1,293,1,293,1,293,1,293,1,294,1,294,1,294, + 1,294,1,294,1,294,1,294,1,295,1,295,1,295,1,295,1,295,1,295,1,295, + 1,295,1,295,1,295,1,295,1,295,1,295,1,295,1,296,1,296,1,296,1,296, + 1,296,1,296,1,296,1,296,1,296,1,296,1,297,1,297,1,297,1,297,1,297, + 1,297,1,297,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,299,1,300,1,300,1,300,1,300,1,300,1,300, + 1,300,1,300,1,300,1,301,1,301,1,301,1,301,1,301,1,301,1,301,1,301, + 1,301,1,301,1,302,1,302,1,302,1,302,1,302,1,302,1,302,1,302,1,302, + 1,302,1,302,1,302,1,302,1,302,1,303,1,303,1,303,1,303,1,303,1,303, + 1,303,1,303,1,303,1,303,1,303,1,303,1,303,1,303,1,304,1,304,1,304, + 1,304,1,304,1,304,1,304,1,304,1,304,1,304,1,304,1,304,1,304,1,305, + 1,305,1,305,1,305,1,305,1,305,1,305,1,305,1,305,1,305,1,305,1,305, + 1,305,1,305,1,306,1,306,1,306,1,306,1,306,1,306,1,306,1,306,1,307, + 1,307,1,307,1,308,1,308,1,308,1,308,1,308,1,308,1,309,1,309,1,309, + 1,309,1,309,1,309,1,309,1,309,1,309,1,310,1,310,1,310,1,310,1,310, + 1,310,1,310,1,310,1,310,1,310,1,310,1,310,1,311,1,311,1,311,1,311, + 1,311,1,311,1,311,1,311,1,311,1,311,1,311,1,311,1,311,1,312,1,312, + 1,312,1,312,1,312,1,312,1,312,1,312,1,312,1,312,1,313,1,313,1,313, + 1,313,1,313,1,314,1,314,1,314,1,314,1,314,1,315,1,315,1,315,1,315, + 1,315,1,315,1,315,1,315,1,315,1,316,1,316,1,316,1,316,1,316,1,316, + 1,316,1,316,1,316,1,317,1,317,1,317,1,317,1,317,1,318,1,318,1,318, + 1,318,1,318,1,318,1,318,1,318,1,318,1,318,1,319,1,319,1,319,1,319, + 1,319,1,319,1,319,1,319,1,319,1,319,1,320,1,320,1,320,1,320,1,320, + 1,320,1,320,1,320,1,321,1,321,1,321,1,321,1,321,1,321,1,322,1,322, + 1,322,1,322,1,322,1,322,1,322,1,323,1,323,1,323,1,323,1,323,1,323, + 1,323,1,323,1,324,1,324,1,324,1,324,1,324,1,324,1,324,1,325,1,325, + 1,325,1,325,1,325,1,325,1,325,1,325,1,326,1,326,1,326,1,326,1,326, + 1,326,1,327,1,327,1,327,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,329,1,330,1,330,1,330,1,330,1,330, + 1,330,1,331,1,331,1,331,1,331,1,331,1,331,1,331,1,332,1,332,1,332, + 1,332,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,334,1,334,1,334,1,334,1,334,1,335,1,335,1,335,1,335, + 1,335,1,335,1,335,1,335,1,336,1,336,1,336,1,336,1,336,1,337,1,337, + 1,337,1,337,1,337,1,337,1,338,1,338,1,338,1,338,1,338,1,339,1,339, + 1,339,1,339,1,339,1,340,1,340,1,340,1,340,1,340,1,340,1,341,1,341, + 1,341,1,341,1,341,1,342,1,342,1,342,1,342,1,342,1,342,1,343,1,343, + 1,343,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,345,1,345,1,346,1,346,1,346,1,346,1,346, + 1,347,1,347,1,347,1,347,1,347,1,347,1,348,1,348,1,348,1,348,1,348, + 1,349,1,349,1,349,1,349,1,349,1,349,1,349,1,350,1,350,1,350,3,350, + 3391,8,350,1,351,1,351,1,351,1,351,1,352,1,352,1,352,1,353,1,353, + 1,353,1,354,1,354,1,355,1,355,1,355,1,355,3,355,3409,8,355,1,356, + 1,356,1,357,1,357,1,357,1,357,3,357,3417,8,357,1,358,1,358,1,359, + 1,359,1,360,1,360,1,361,1,361,1,362,1,362,1,363,1,363,1,364,1,364, + 1,365,1,365,1,366,1,366,1,367,1,367,1,367,1,368,1,368,1,369,1,369, + 1,370,1,370,1,370,1,371,1,371,1,371,1,372,1,372,1,372,1,372,1,373, + 1,373,1,373,1,374,1,374,1,375,1,375,1,375,1,375,5,375,3463,8,375, + 10,375,12,375,3466,9,375,1,375,1,375,1,375,1,375,1,375,5,375,3473, + 8,375,10,375,12,375,3476,9,375,1,375,1,375,1,375,1,375,1,375,5,375, + 3483,8,375,10,375,12,375,3486,9,375,1,375,3,375,3489,8,375,1,376, + 1,376,1,376,1,376,5,376,3495,8,376,10,376,12,376,3498,9,376,1,376, + 1,376,1,377,4,377,3503,8,377,11,377,12,377,3504,1,377,1,377,1,378, + 4,378,3510,8,378,11,378,12,378,3511,1,378,1,378,1,379,4,379,3517, + 8,379,11,379,12,379,3518,1,379,1,379,1,380,4,380,3524,8,380,11,380, + 12,380,3525,1,381,4,381,3529,8,381,11,381,12,381,3530,1,381,1,381, + 1,381,1,381,1,381,3,381,3538,8,381,1,382,1,382,1,383,4,383,3543, + 8,383,11,383,12,383,3544,1,383,3,383,3548,8,383,1,383,1,383,1,383, + 1,383,3,383,3554,8,383,1,383,1,383,3,383,3558,8,383,1,384,4,384, + 3561,8,384,11,384,12,384,3562,1,384,3,384,3566,8,384,1,384,1,384, + 1,384,1,384,3,384,3572,8,384,1,384,1,384,3,384,3576,8,384,1,385, + 4,385,3579,8,385,11,385,12,385,3580,1,385,3,385,3584,8,385,1,385, + 1,385,1,385,1,385,1,385,3,385,3591,8,385,1,385,1,385,1,385,3,385, + 3596,8,385,1,386,1,386,1,386,4,386,3601,8,386,11,386,12,386,3602, + 1,387,1,387,1,387,1,387,5,387,3609,8,387,10,387,12,387,3612,9,387, + 1,387,1,387,1,388,4,388,3617,8,388,11,388,12,388,3618,1,388,1,388, + 5,388,3623,8,388,10,388,12,388,3626,9,388,1,388,1,388,4,388,3630, + 8,388,11,388,12,388,3631,3,388,3634,8,388,1,389,1,389,3,389,3638, + 8,389,1,389,4,389,3641,8,389,11,389,12,389,3642,1,390,1,390,1,391, + 1,391,1,392,1,392,1,392,1,392,1,392,1,392,5,392,3655,8,392,10,392, + 12,392,3658,9,392,1,392,3,392,3661,8,392,1,392,3,392,3664,8,392, + 1,392,1,392,1,393,1,393,1,393,1,393,1,393,5,393,3673,8,393,10,393, + 12,393,3676,9,393,1,393,1,393,1,393,1,393,3,393,3682,8,393,1,393, + 1,393,1,394,4,394,3687,8,394,11,394,12,394,3688,1,394,1,394,1,395, + 1,395,1,3674,0,396,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,132,265, + 133,267,134,269,135,271,136,273,137,275,138,277,139,279,140,281, + 141,283,142,285,143,287,144,289,145,291,146,293,147,295,148,297, + 149,299,150,301,151,303,152,305,153,307,154,309,155,311,156,313, + 157,315,158,317,159,319,160,321,161,323,162,325,163,327,164,329, + 165,331,166,333,167,335,168,337,169,339,170,341,171,343,172,345, + 173,347,174,349,175,351,176,353,177,355,178,357,179,359,180,361, + 181,363,182,365,183,367,184,369,185,371,186,373,187,375,188,377, + 189,379,190,381,191,383,192,385,193,387,194,389,195,391,196,393, + 197,395,198,397,199,399,200,401,201,403,202,405,203,407,204,409, + 205,411,206,413,207,415,208,417,209,419,210,421,211,423,212,425, + 213,427,214,429,215,431,216,433,217,435,218,437,219,439,220,441, + 221,443,222,445,223,447,224,449,225,451,226,453,227,455,228,457, + 229,459,230,461,231,463,232,465,233,467,234,469,235,471,236,473, + 237,475,238,477,239,479,240,481,241,483,242,485,243,487,244,489, + 245,491,246,493,247,495,248,497,249,499,250,501,251,503,252,505, + 253,507,254,509,255,511,256,513,257,515,258,517,259,519,260,521, + 261,523,262,525,263,527,264,529,265,531,266,533,267,535,268,537, + 269,539,270,541,271,543,272,545,273,547,274,549,275,551,276,553, + 277,555,278,557,279,559,280,561,281,563,282,565,283,567,284,569, + 285,571,286,573,287,575,288,577,289,579,290,581,291,583,292,585, + 293,587,294,589,295,591,296,593,297,595,298,597,299,599,300,601, + 301,603,302,605,303,607,304,609,305,611,306,613,307,615,308,617, + 309,619,310,621,311,623,312,625,313,627,314,629,315,631,316,633, + 317,635,318,637,319,639,320,641,321,643,322,645,323,647,324,649, + 325,651,326,653,327,655,328,657,329,659,330,661,331,663,332,665, + 333,667,334,669,335,671,336,673,337,675,338,677,339,679,340,681, + 341,683,342,685,343,687,344,689,345,691,346,693,347,695,348,697, + 349,699,350,701,351,703,352,705,353,707,354,709,355,711,356,713, + 357,715,358,717,359,719,360,721,361,723,362,725,363,727,364,729, + 365,731,366,733,367,735,368,737,369,739,370,741,371,743,372,745, + 373,747,374,749,375,751,376,753,377,755,378,757,379,759,380,761, + 381,763,382,765,383,767,384,769,385,771,386,773,387,775,388,777, + 0,779,0,781,0,783,0,785,389,787,390,789,391,791,392,1,0,36,2,0,65, + 65,97,97,2,0,68,68,100,100,2,0,70,70,102,102,2,0,84,84,116,116,2, + 0,69,69,101,101,2,0,82,82,114,114,2,0,76,76,108,108,2,0,87,87,119, + 119,2,0,89,89,121,121,2,0,83,83,115,115,2,0,78,78,110,110,2,0,90, + 90,122,122,2,0,73,73,105,105,2,0,86,86,118,118,2,0,85,85,117,117, + 2,0,67,67,99,99,2,0,72,72,104,104,2,0,79,79,111,111,2,0,66,66,98, + 98,2,0,71,71,103,103,2,0,75,75,107,107,2,0,77,77,109,109,2,0,80, + 80,112,112,2,0,88,88,120,120,2,0,74,74,106,106,2,0,81,81,113,113, + 2,0,39,39,92,92,1,0,39,39,1,0,34,34,2,0,34,34,92,92,1,0,96,96,2, + 0,43,43,45,45,1,0,48,57,2,0,65,90,97,122,2,0,10,10,13,13,3,0,9,10, + 13,13,32,32,3737,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,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,0,347, + 1,0,0,0,0,349,1,0,0,0,0,351,1,0,0,0,0,353,1,0,0,0,0,355,1,0,0,0, + 0,357,1,0,0,0,0,359,1,0,0,0,0,361,1,0,0,0,0,363,1,0,0,0,0,365,1, + 0,0,0,0,367,1,0,0,0,0,369,1,0,0,0,0,371,1,0,0,0,0,373,1,0,0,0,0, + 375,1,0,0,0,0,377,1,0,0,0,0,379,1,0,0,0,0,381,1,0,0,0,0,383,1,0, + 0,0,0,385,1,0,0,0,0,387,1,0,0,0,0,389,1,0,0,0,0,391,1,0,0,0,0,393, + 1,0,0,0,0,395,1,0,0,0,0,397,1,0,0,0,0,399,1,0,0,0,0,401,1,0,0,0, + 0,403,1,0,0,0,0,405,1,0,0,0,0,407,1,0,0,0,0,409,1,0,0,0,0,411,1, + 0,0,0,0,413,1,0,0,0,0,415,1,0,0,0,0,417,1,0,0,0,0,419,1,0,0,0,0, + 421,1,0,0,0,0,423,1,0,0,0,0,425,1,0,0,0,0,427,1,0,0,0,0,429,1,0, + 0,0,0,431,1,0,0,0,0,433,1,0,0,0,0,435,1,0,0,0,0,437,1,0,0,0,0,439, + 1,0,0,0,0,441,1,0,0,0,0,443,1,0,0,0,0,445,1,0,0,0,0,447,1,0,0,0, + 0,449,1,0,0,0,0,451,1,0,0,0,0,453,1,0,0,0,0,455,1,0,0,0,0,457,1, + 0,0,0,0,459,1,0,0,0,0,461,1,0,0,0,0,463,1,0,0,0,0,465,1,0,0,0,0, + 467,1,0,0,0,0,469,1,0,0,0,0,471,1,0,0,0,0,473,1,0,0,0,0,475,1,0, + 0,0,0,477,1,0,0,0,0,479,1,0,0,0,0,481,1,0,0,0,0,483,1,0,0,0,0,485, + 1,0,0,0,0,487,1,0,0,0,0,489,1,0,0,0,0,491,1,0,0,0,0,493,1,0,0,0, + 0,495,1,0,0,0,0,497,1,0,0,0,0,499,1,0,0,0,0,501,1,0,0,0,0,503,1, + 0,0,0,0,505,1,0,0,0,0,507,1,0,0,0,0,509,1,0,0,0,0,511,1,0,0,0,0, + 513,1,0,0,0,0,515,1,0,0,0,0,517,1,0,0,0,0,519,1,0,0,0,0,521,1,0, + 0,0,0,523,1,0,0,0,0,525,1,0,0,0,0,527,1,0,0,0,0,529,1,0,0,0,0,531, + 1,0,0,0,0,533,1,0,0,0,0,535,1,0,0,0,0,537,1,0,0,0,0,539,1,0,0,0, + 0,541,1,0,0,0,0,543,1,0,0,0,0,545,1,0,0,0,0,547,1,0,0,0,0,549,1, + 0,0,0,0,551,1,0,0,0,0,553,1,0,0,0,0,555,1,0,0,0,0,557,1,0,0,0,0, + 559,1,0,0,0,0,561,1,0,0,0,0,563,1,0,0,0,0,565,1,0,0,0,0,567,1,0, + 0,0,0,569,1,0,0,0,0,571,1,0,0,0,0,573,1,0,0,0,0,575,1,0,0,0,0,577, + 1,0,0,0,0,579,1,0,0,0,0,581,1,0,0,0,0,583,1,0,0,0,0,585,1,0,0,0, + 0,587,1,0,0,0,0,589,1,0,0,0,0,591,1,0,0,0,0,593,1,0,0,0,0,595,1, + 0,0,0,0,597,1,0,0,0,0,599,1,0,0,0,0,601,1,0,0,0,0,603,1,0,0,0,0, + 605,1,0,0,0,0,607,1,0,0,0,0,609,1,0,0,0,0,611,1,0,0,0,0,613,1,0, + 0,0,0,615,1,0,0,0,0,617,1,0,0,0,0,619,1,0,0,0,0,621,1,0,0,0,0,623, + 1,0,0,0,0,625,1,0,0,0,0,627,1,0,0,0,0,629,1,0,0,0,0,631,1,0,0,0, + 0,633,1,0,0,0,0,635,1,0,0,0,0,637,1,0,0,0,0,639,1,0,0,0,0,641,1, + 0,0,0,0,643,1,0,0,0,0,645,1,0,0,0,0,647,1,0,0,0,0,649,1,0,0,0,0, + 651,1,0,0,0,0,653,1,0,0,0,0,655,1,0,0,0,0,657,1,0,0,0,0,659,1,0, + 0,0,0,661,1,0,0,0,0,663,1,0,0,0,0,665,1,0,0,0,0,667,1,0,0,0,0,669, + 1,0,0,0,0,671,1,0,0,0,0,673,1,0,0,0,0,675,1,0,0,0,0,677,1,0,0,0, + 0,679,1,0,0,0,0,681,1,0,0,0,0,683,1,0,0,0,0,685,1,0,0,0,0,687,1, + 0,0,0,0,689,1,0,0,0,0,691,1,0,0,0,0,693,1,0,0,0,0,695,1,0,0,0,0, + 697,1,0,0,0,0,699,1,0,0,0,0,701,1,0,0,0,0,703,1,0,0,0,0,705,1,0, + 0,0,0,707,1,0,0,0,0,709,1,0,0,0,0,711,1,0,0,0,0,713,1,0,0,0,0,715, + 1,0,0,0,0,717,1,0,0,0,0,719,1,0,0,0,0,721,1,0,0,0,0,723,1,0,0,0, + 0,725,1,0,0,0,0,727,1,0,0,0,0,729,1,0,0,0,0,731,1,0,0,0,0,733,1, + 0,0,0,0,735,1,0,0,0,0,737,1,0,0,0,0,739,1,0,0,0,0,741,1,0,0,0,0, + 743,1,0,0,0,0,745,1,0,0,0,0,747,1,0,0,0,0,749,1,0,0,0,0,751,1,0, + 0,0,0,753,1,0,0,0,0,755,1,0,0,0,0,757,1,0,0,0,0,759,1,0,0,0,0,761, + 1,0,0,0,0,763,1,0,0,0,0,765,1,0,0,0,0,767,1,0,0,0,0,769,1,0,0,0, + 0,771,1,0,0,0,0,773,1,0,0,0,0,775,1,0,0,0,0,785,1,0,0,0,0,787,1, + 0,0,0,0,789,1,0,0,0,0,791,1,0,0,0,1,793,1,0,0,0,3,795,1,0,0,0,5, + 797,1,0,0,0,7,799,1,0,0,0,9,801,1,0,0,0,11,803,1,0,0,0,13,805,1, + 0,0,0,15,807,1,0,0,0,17,811,1,0,0,0,19,817,1,0,0,0,21,821,1,0,0, + 0,23,827,1,0,0,0,25,834,1,0,0,0,27,842,1,0,0,0,29,846,1,0,0,0,31, + 851,1,0,0,0,33,855,1,0,0,0,35,865,1,0,0,0,37,873,1,0,0,0,39,879, + 1,0,0,0,41,882,1,0,0,0,43,886,1,0,0,0,45,889,1,0,0,0,47,903,1,0, + 0,0,49,911,1,0,0,0,51,918,1,0,0,0,53,925,1,0,0,0,55,933,1,0,0,0, + 57,938,1,0,0,0,59,945,1,0,0,0,61,953,1,0,0,0,63,956,1,0,0,0,65,961, + 1,0,0,0,67,967,1,0,0,0,69,975,1,0,0,0,71,980,1,0,0,0,73,985,1,0, + 0,0,75,993,1,0,0,0,77,1002,1,0,0,0,79,1009,1,0,0,0,81,1014,1,0,0, + 0,83,1024,1,0,0,0,85,1030,1,0,0,0,87,1036,1,0,0,0,89,1044,1,0,0, + 0,91,1054,1,0,0,0,93,1062,1,0,0,0,95,1070,1,0,0,0,97,1081,1,0,0, + 0,99,1088,1,0,0,0,101,1096,1,0,0,0,103,1104,1,0,0,0,105,1111,1,0, + 0,0,107,1119,1,0,0,0,109,1131,1,0,0,0,111,1139,1,0,0,0,113,1151, + 1,0,0,0,115,1162,1,0,0,0,117,1167,1,0,0,0,119,1174,1,0,0,0,121,1180, + 1,0,0,0,123,1185,1,0,0,0,125,1193,1,0,0,0,127,1206,1,0,0,0,129,1219, + 1,0,0,0,131,1237,1,0,0,0,133,1250,1,0,0,0,135,1254,1,0,0,0,137,1259, + 1,0,0,0,139,1269,1,0,0,0,141,1274,1,0,0,0,143,1279,1,0,0,0,145,1288, + 1,0,0,0,147,1298,1,0,0,0,149,1306,1,0,0,0,151,1315,1,0,0,0,153,1324, + 1,0,0,0,155,1334,1,0,0,0,157,1347,1,0,0,0,159,1351,1,0,0,0,161,1359, + 1,0,0,0,163,1367,1,0,0,0,165,1375,1,0,0,0,167,1383,1,0,0,0,169,1390, + 1,0,0,0,171,1400,1,0,0,0,173,1405,1,0,0,0,175,1414,1,0,0,0,177,1418, + 1,0,0,0,179,1430,1,0,0,0,181,1440,1,0,0,0,183,1448,1,0,0,0,185,1457, + 1,0,0,0,187,1468,1,0,0,0,189,1472,1,0,0,0,191,1479,1,0,0,0,193,1484, + 1,0,0,0,195,1489,1,0,0,0,197,1496,1,0,0,0,199,1500,1,0,0,0,201,1507, + 1,0,0,0,203,1515,1,0,0,0,205,1522,1,0,0,0,207,1531,1,0,0,0,209,1539, + 1,0,0,0,211,1546,1,0,0,0,213,1554,1,0,0,0,215,1561,1,0,0,0,217,1570, + 1,0,0,0,219,1579,1,0,0,0,221,1587,1,0,0,0,223,1593,1,0,0,0,225,1599, + 1,0,0,0,227,1606,1,0,0,0,229,1613,1,0,0,0,231,1624,1,0,0,0,233,1630, + 1,0,0,0,235,1636,1,0,0,0,237,1646,1,0,0,0,239,1650,1,0,0,0,241,1658, + 1,0,0,0,243,1665,1,0,0,0,245,1675,1,0,0,0,247,1680,1,0,0,0,249,1685, + 1,0,0,0,251,1694,1,0,0,0,253,1704,1,0,0,0,255,1714,1,0,0,0,257,1721, + 1,0,0,0,259,1727,1,0,0,0,261,1733,1,0,0,0,263,1742,1,0,0,0,265,1749, + 1,0,0,0,267,1751,1,0,0,0,269,1756,1,0,0,0,271,1762,1,0,0,0,273,1773, + 1,0,0,0,275,1776,1,0,0,0,277,1783,1,0,0,0,279,1790,1,0,0,0,281,1793, + 1,0,0,0,283,1801,1,0,0,0,285,1807,1,0,0,0,287,1815,1,0,0,0,289,1821, + 1,0,0,0,291,1828,1,0,0,0,293,1840,1,0,0,0,295,1847,1,0,0,0,297,1857, + 1,0,0,0,299,1866,1,0,0,0,301,1870,1,0,0,0,303,1878,1,0,0,0,305,1883, + 1,0,0,0,307,1886,1,0,0,0,309,1892,1,0,0,0,311,1897,1,0,0,0,313,1902, + 1,0,0,0,315,1907,1,0,0,0,317,1915,1,0,0,0,319,1920,1,0,0,0,321,1928, + 1,0,0,0,323,1933,1,0,0,0,325,1943,1,0,0,0,327,1948,1,0,0,0,329,1954, + 1,0,0,0,331,1960,1,0,0,0,333,1966,1,0,0,0,335,1971,1,0,0,0,337,1976, + 1,0,0,0,339,1982,1,0,0,0,341,1991,1,0,0,0,343,1996,1,0,0,0,345,2002, + 1,0,0,0,347,2010,1,0,0,0,349,2015,1,0,0,0,351,2021,1,0,0,0,353,2025, + 1,0,0,0,355,2033,1,0,0,0,357,2039,1,0,0,0,359,2051,1,0,0,0,361,2064, + 1,0,0,0,363,2076,1,0,0,0,365,2089,1,0,0,0,367,2096,1,0,0,0,369,2104, + 1,0,0,0,371,2110,1,0,0,0,373,2117,1,0,0,0,375,2122,1,0,0,0,377,2127, + 1,0,0,0,379,2137,1,0,0,0,381,2148,1,0,0,0,383,2159,1,0,0,0,385,2171, + 1,0,0,0,387,2179,1,0,0,0,389,2182,1,0,0,0,391,2189,1,0,0,0,393,2193, + 1,0,0,0,395,2198,1,0,0,0,397,2204,1,0,0,0,399,2212,1,0,0,0,401,2215, + 1,0,0,0,403,2222,1,0,0,0,405,2225,1,0,0,0,407,2230,1,0,0,0,409,2239, + 1,0,0,0,411,2246,1,0,0,0,413,2254,1,0,0,0,415,2257,1,0,0,0,417,2263, + 1,0,0,0,419,2267,1,0,0,0,421,2273,1,0,0,0,423,2286,1,0,0,0,425,2291, + 1,0,0,0,427,2300,1,0,0,0,429,2308,1,0,0,0,431,2318,1,0,0,0,433,2328, + 1,0,0,0,435,2340,1,0,0,0,437,2351,1,0,0,0,439,2367,1,0,0,0,441,2383, + 1,0,0,0,443,2391,1,0,0,0,445,2397,1,0,0,0,447,2405,1,0,0,0,449,2414, + 1,0,0,0,451,2424,1,0,0,0,453,2432,1,0,0,0,455,2443,1,0,0,0,457,2454, + 1,0,0,0,459,2460,1,0,0,0,461,2468,1,0,0,0,463,2474,1,0,0,0,465,2480, + 1,0,0,0,467,2485,1,0,0,0,469,2498,1,0,0,0,471,2511,1,0,0,0,473,2519, + 1,0,0,0,475,2526,1,0,0,0,477,2537,1,0,0,0,479,2545,1,0,0,0,481,2552, + 1,0,0,0,483,2559,1,0,0,0,485,2570,1,0,0,0,487,2578,1,0,0,0,489,2584, + 1,0,0,0,491,2592,1,0,0,0,493,2601,1,0,0,0,495,2609,1,0,0,0,497,2616, + 1,0,0,0,499,2622,1,0,0,0,501,2628,1,0,0,0,503,2635,1,0,0,0,505,2640, + 1,0,0,0,507,2646,1,0,0,0,509,2655,1,0,0,0,511,2662,1,0,0,0,513,2666, + 1,0,0,0,515,2671,1,0,0,0,517,2678,1,0,0,0,519,2686,1,0,0,0,521,2693, + 1,0,0,0,523,2701,1,0,0,0,525,2708,1,0,0,0,527,2713,1,0,0,0,529,2723, + 1,0,0,0,531,2729,1,0,0,0,533,2745,1,0,0,0,535,2758,1,0,0,0,537,2762, + 1,0,0,0,539,2768,1,0,0,0,541,2773,1,0,0,0,543,2779,1,0,0,0,545,2784, + 1,0,0,0,547,2791,1,0,0,0,549,2798,1,0,0,0,551,2807,1,0,0,0,553,2812, + 1,0,0,0,555,2817,1,0,0,0,557,2824,1,0,0,0,559,2831,1,0,0,0,561,2837, + 1,0,0,0,563,2848,1,0,0,0,565,2855,1,0,0,0,567,2864,1,0,0,0,569,2871, + 1,0,0,0,571,2878,1,0,0,0,573,2885,1,0,0,0,575,2895,1,0,0,0,577,2900, + 1,0,0,0,579,2907,1,0,0,0,581,2919,1,0,0,0,583,2934,1,0,0,0,585,2940, + 1,0,0,0,587,2947,1,0,0,0,589,2959,1,0,0,0,591,2966,1,0,0,0,593,2980, + 1,0,0,0,595,2990,1,0,0,0,597,3001,1,0,0,0,599,3006,1,0,0,0,601,3011, + 1,0,0,0,603,3020,1,0,0,0,605,3030,1,0,0,0,607,3044,1,0,0,0,609,3058, + 1,0,0,0,611,3071,1,0,0,0,613,3085,1,0,0,0,615,3093,1,0,0,0,617,3096, + 1,0,0,0,619,3102,1,0,0,0,621,3111,1,0,0,0,623,3123,1,0,0,0,625,3136, + 1,0,0,0,627,3146,1,0,0,0,629,3151,1,0,0,0,631,3156,1,0,0,0,633,3165, + 1,0,0,0,635,3174,1,0,0,0,637,3179,1,0,0,0,639,3189,1,0,0,0,641,3199, + 1,0,0,0,643,3207,1,0,0,0,645,3213,1,0,0,0,647,3220,1,0,0,0,649,3228, + 1,0,0,0,651,3235,1,0,0,0,653,3243,1,0,0,0,655,3249,1,0,0,0,657,3256, + 1,0,0,0,659,3260,1,0,0,0,661,3265,1,0,0,0,663,3271,1,0,0,0,665,3278, + 1,0,0,0,667,3286,1,0,0,0,669,3290,1,0,0,0,671,3299,1,0,0,0,673,3307, + 1,0,0,0,675,3312,1,0,0,0,677,3318,1,0,0,0,679,3323,1,0,0,0,681,3328, + 1,0,0,0,683,3334,1,0,0,0,685,3339,1,0,0,0,687,3345,1,0,0,0,689,3352, + 1,0,0,0,691,3357,1,0,0,0,693,3364,1,0,0,0,695,3369,1,0,0,0,697,3375, + 1,0,0,0,699,3380,1,0,0,0,701,3390,1,0,0,0,703,3392,1,0,0,0,705,3396, + 1,0,0,0,707,3399,1,0,0,0,709,3402,1,0,0,0,711,3408,1,0,0,0,713,3410, + 1,0,0,0,715,3416,1,0,0,0,717,3418,1,0,0,0,719,3420,1,0,0,0,721,3422, + 1,0,0,0,723,3424,1,0,0,0,725,3426,1,0,0,0,727,3428,1,0,0,0,729,3430, + 1,0,0,0,731,3432,1,0,0,0,733,3434,1,0,0,0,735,3436,1,0,0,0,737,3439, + 1,0,0,0,739,3441,1,0,0,0,741,3443,1,0,0,0,743,3446,1,0,0,0,745,3449, + 1,0,0,0,747,3453,1,0,0,0,749,3456,1,0,0,0,751,3488,1,0,0,0,753,3490, + 1,0,0,0,755,3502,1,0,0,0,757,3509,1,0,0,0,759,3516,1,0,0,0,761,3523, + 1,0,0,0,763,3537,1,0,0,0,765,3539,1,0,0,0,767,3557,1,0,0,0,769,3575, + 1,0,0,0,771,3595,1,0,0,0,773,3600,1,0,0,0,775,3604,1,0,0,0,777,3633, + 1,0,0,0,779,3635,1,0,0,0,781,3644,1,0,0,0,783,3646,1,0,0,0,785,3648, + 1,0,0,0,787,3667,1,0,0,0,789,3686,1,0,0,0,791,3692,1,0,0,0,793,794, + 5,59,0,0,794,2,1,0,0,0,795,796,5,40,0,0,796,4,1,0,0,0,797,798,5, + 41,0,0,798,6,1,0,0,0,799,800,5,44,0,0,800,8,1,0,0,0,801,802,5,46, + 0,0,802,10,1,0,0,0,803,804,5,91,0,0,804,12,1,0,0,0,805,806,5,93, + 0,0,806,14,1,0,0,0,807,808,7,0,0,0,808,809,7,1,0,0,809,810,7,1,0, + 0,810,16,1,0,0,0,811,812,7,0,0,0,812,813,7,2,0,0,813,814,7,3,0,0, + 814,815,7,4,0,0,815,816,7,5,0,0,816,18,1,0,0,0,817,818,7,0,0,0,818, + 819,7,6,0,0,819,820,7,6,0,0,820,20,1,0,0,0,821,822,7,0,0,0,822,823, + 7,6,0,0,823,824,7,3,0,0,824,825,7,4,0,0,825,826,7,5,0,0,826,22,1, + 0,0,0,827,828,7,0,0,0,828,829,7,6,0,0,829,830,7,7,0,0,830,831,7, + 0,0,0,831,832,7,8,0,0,832,833,7,9,0,0,833,24,1,0,0,0,834,835,7,0, + 0,0,835,836,7,10,0,0,836,837,7,0,0,0,837,838,7,6,0,0,838,839,7,8, + 0,0,839,840,7,11,0,0,840,841,7,4,0,0,841,26,1,0,0,0,842,843,7,0, + 0,0,843,844,7,10,0,0,844,845,7,1,0,0,845,28,1,0,0,0,846,847,7,0, + 0,0,847,848,7,10,0,0,848,849,7,3,0,0,849,850,7,12,0,0,850,30,1,0, + 0,0,851,852,7,0,0,0,852,853,7,10,0,0,853,854,7,8,0,0,854,32,1,0, + 0,0,855,856,7,0,0,0,856,857,7,10,0,0,857,858,7,8,0,0,858,859,5,95, + 0,0,859,860,7,13,0,0,860,861,7,0,0,0,861,862,7,6,0,0,862,863,7,14, + 0,0,863,864,7,4,0,0,864,34,1,0,0,0,865,866,7,0,0,0,866,867,7,5,0, + 0,867,868,7,15,0,0,868,869,7,16,0,0,869,870,7,12,0,0,870,871,7,13, + 0,0,871,872,7,4,0,0,872,36,1,0,0,0,873,874,7,0,0,0,874,875,7,5,0, + 0,875,876,7,5,0,0,876,877,7,0,0,0,877,878,7,8,0,0,878,38,1,0,0,0, + 879,880,7,0,0,0,880,881,7,9,0,0,881,40,1,0,0,0,882,883,7,0,0,0,883, + 884,7,9,0,0,884,885,7,15,0,0,885,42,1,0,0,0,886,887,7,0,0,0,887, + 888,7,3,0,0,888,44,1,0,0,0,889,890,7,0,0,0,890,891,7,14,0,0,891, + 892,7,3,0,0,892,893,7,16,0,0,893,894,7,17,0,0,894,895,7,5,0,0,895, + 896,7,12,0,0,896,897,7,11,0,0,897,898,7,0,0,0,898,899,7,3,0,0,899, + 900,7,12,0,0,900,901,7,17,0,0,901,902,7,10,0,0,902,46,1,0,0,0,903, + 904,7,18,0,0,904,905,7,4,0,0,905,906,7,3,0,0,906,907,7,7,0,0,907, + 908,7,4,0,0,908,909,7,4,0,0,909,910,7,10,0,0,910,48,1,0,0,0,911, + 912,7,18,0,0,912,913,7,12,0,0,913,914,7,19,0,0,914,915,7,12,0,0, + 915,916,7,10,0,0,916,917,7,3,0,0,917,50,1,0,0,0,918,919,7,18,0,0, + 919,920,7,12,0,0,920,921,7,10,0,0,921,922,7,0,0,0,922,923,7,5,0, + 0,923,924,7,8,0,0,924,52,1,0,0,0,925,926,7,18,0,0,926,927,7,17,0, + 0,927,928,7,17,0,0,928,929,7,6,0,0,929,930,7,4,0,0,930,931,7,0,0, + 0,931,932,7,10,0,0,932,54,1,0,0,0,933,934,7,18,0,0,934,935,7,17, + 0,0,935,936,7,3,0,0,936,937,7,16,0,0,937,56,1,0,0,0,938,939,7,18, + 0,0,939,940,7,14,0,0,940,941,7,15,0,0,941,942,7,20,0,0,942,943,7, + 4,0,0,943,944,7,3,0,0,944,58,1,0,0,0,945,946,7,18,0,0,946,947,7, + 14,0,0,947,948,7,15,0,0,948,949,7,20,0,0,949,950,7,4,0,0,950,951, + 7,3,0,0,951,952,7,9,0,0,952,60,1,0,0,0,953,954,7,18,0,0,954,955, + 7,8,0,0,955,62,1,0,0,0,956,957,7,18,0,0,957,958,7,8,0,0,958,959, + 7,3,0,0,959,960,7,4,0,0,960,64,1,0,0,0,961,962,7,15,0,0,962,963, + 7,0,0,0,963,964,7,15,0,0,964,965,7,16,0,0,965,966,7,4,0,0,966,66, + 1,0,0,0,967,968,7,15,0,0,968,969,7,0,0,0,969,970,7,9,0,0,970,971, + 7,15,0,0,971,972,7,0,0,0,972,973,7,1,0,0,973,974,7,4,0,0,974,68, + 1,0,0,0,975,976,7,15,0,0,976,977,7,0,0,0,977,978,7,9,0,0,978,979, + 7,4,0,0,979,70,1,0,0,0,980,981,7,15,0,0,981,982,7,0,0,0,982,983, + 7,9,0,0,983,984,7,3,0,0,984,72,1,0,0,0,985,986,7,15,0,0,986,987, + 7,0,0,0,987,988,7,3,0,0,988,989,7,0,0,0,989,990,7,6,0,0,990,991, + 7,17,0,0,991,992,7,19,0,0,992,74,1,0,0,0,993,994,7,15,0,0,994,995, + 7,0,0,0,995,996,7,3,0,0,996,997,7,0,0,0,997,998,7,6,0,0,998,999, + 7,17,0,0,999,1000,7,19,0,0,1000,1001,7,9,0,0,1001,76,1,0,0,0,1002, + 1003,7,15,0,0,1003,1004,7,16,0,0,1004,1005,7,0,0,0,1005,1006,7,10, + 0,0,1006,1007,7,19,0,0,1007,1008,7,4,0,0,1008,78,1,0,0,0,1009,1010, + 7,15,0,0,1010,1011,7,16,0,0,1011,1012,7,0,0,0,1012,1013,7,5,0,0, + 1013,80,1,0,0,0,1014,1015,7,15,0,0,1015,1016,7,16,0,0,1016,1017, + 7,0,0,0,1017,1018,7,5,0,0,1018,1019,7,0,0,0,1019,1020,7,15,0,0,1020, + 1021,7,3,0,0,1021,1022,7,4,0,0,1022,1023,7,5,0,0,1023,82,1,0,0,0, + 1024,1025,7,15,0,0,1025,1026,7,16,0,0,1026,1027,7,4,0,0,1027,1028, + 7,15,0,0,1028,1029,7,20,0,0,1029,84,1,0,0,0,1030,1031,7,15,0,0,1031, + 1032,7,6,0,0,1032,1033,7,4,0,0,1033,1034,7,0,0,0,1034,1035,7,5,0, + 0,1035,86,1,0,0,0,1036,1037,7,15,0,0,1037,1038,7,6,0,0,1038,1039, + 7,14,0,0,1039,1040,7,9,0,0,1040,1041,7,3,0,0,1041,1042,7,4,0,0,1042, + 1043,7,5,0,0,1043,88,1,0,0,0,1044,1045,7,15,0,0,1045,1046,7,6,0, + 0,1046,1047,7,14,0,0,1047,1048,7,9,0,0,1048,1049,7,3,0,0,1049,1050, + 7,4,0,0,1050,1051,7,5,0,0,1051,1052,7,4,0,0,1052,1053,7,1,0,0,1053, + 90,1,0,0,0,1054,1055,7,15,0,0,1055,1056,7,17,0,0,1056,1057,7,1,0, + 0,1057,1058,7,4,0,0,1058,1059,7,19,0,0,1059,1060,7,4,0,0,1060,1061, + 7,10,0,0,1061,92,1,0,0,0,1062,1063,7,15,0,0,1063,1064,7,17,0,0,1064, + 1065,7,6,0,0,1065,1066,7,6,0,0,1066,1067,7,0,0,0,1067,1068,7,3,0, + 0,1068,1069,7,4,0,0,1069,94,1,0,0,0,1070,1071,7,15,0,0,1071,1072, + 7,17,0,0,1072,1073,7,6,0,0,1073,1074,7,6,0,0,1074,1075,7,4,0,0,1075, + 1076,7,15,0,0,1076,1077,7,3,0,0,1077,1078,7,12,0,0,1078,1079,7,17, + 0,0,1079,1080,7,10,0,0,1080,96,1,0,0,0,1081,1082,7,15,0,0,1082,1083, + 7,17,0,0,1083,1084,7,6,0,0,1084,1085,7,14,0,0,1085,1086,7,21,0,0, + 1086,1087,7,10,0,0,1087,98,1,0,0,0,1088,1089,7,15,0,0,1089,1090, + 7,17,0,0,1090,1091,7,6,0,0,1091,1092,7,14,0,0,1092,1093,7,21,0,0, + 1093,1094,7,10,0,0,1094,1095,7,9,0,0,1095,100,1,0,0,0,1096,1097, + 7,15,0,0,1097,1098,7,17,0,0,1098,1099,7,21,0,0,1099,1100,7,21,0, + 0,1100,1101,7,4,0,0,1101,1102,7,10,0,0,1102,1103,7,3,0,0,1103,102, + 1,0,0,0,1104,1105,7,15,0,0,1105,1106,7,17,0,0,1106,1107,7,21,0,0, + 1107,1108,7,21,0,0,1108,1109,7,12,0,0,1109,1110,7,3,0,0,1110,104, + 1,0,0,0,1111,1112,7,15,0,0,1112,1113,7,17,0,0,1113,1114,7,21,0,0, + 1114,1115,7,22,0,0,1115,1116,7,0,0,0,1116,1117,7,15,0,0,1117,1118, + 7,3,0,0,1118,106,1,0,0,0,1119,1120,7,15,0,0,1120,1121,7,17,0,0,1121, + 1122,7,21,0,0,1122,1123,7,22,0,0,1123,1124,7,0,0,0,1124,1125,7,15, + 0,0,1125,1126,7,3,0,0,1126,1127,7,12,0,0,1127,1128,7,17,0,0,1128, + 1129,7,10,0,0,1129,1130,7,9,0,0,1130,108,1,0,0,0,1131,1132,7,15, + 0,0,1132,1133,7,17,0,0,1133,1134,7,21,0,0,1134,1135,7,22,0,0,1135, + 1136,7,14,0,0,1136,1137,7,3,0,0,1137,1138,7,4,0,0,1138,110,1,0,0, + 0,1139,1140,7,15,0,0,1140,1141,7,17,0,0,1141,1142,7,10,0,0,1142, + 1143,7,15,0,0,1143,1144,7,0,0,0,1144,1145,7,3,0,0,1145,1146,7,4, + 0,0,1146,1147,7,10,0,0,1147,1148,7,0,0,0,1148,1149,7,3,0,0,1149, + 1150,7,4,0,0,1150,112,1,0,0,0,1151,1152,7,15,0,0,1152,1153,7,17, + 0,0,1153,1154,7,10,0,0,1154,1155,7,9,0,0,1155,1156,7,3,0,0,1156, + 1157,7,5,0,0,1157,1158,7,0,0,0,1158,1159,7,12,0,0,1159,1160,7,10, + 0,0,1160,1161,7,3,0,0,1161,114,1,0,0,0,1162,1163,7,15,0,0,1163,1164, + 7,17,0,0,1164,1165,7,9,0,0,1165,1166,7,3,0,0,1166,116,1,0,0,0,1167, + 1168,7,15,0,0,1168,1169,7,5,0,0,1169,1170,7,4,0,0,1170,1171,7,0, + 0,0,1171,1172,7,3,0,0,1172,1173,7,4,0,0,1173,118,1,0,0,0,1174,1175, + 7,15,0,0,1175,1176,7,5,0,0,1176,1177,7,17,0,0,1177,1178,7,9,0,0, + 1178,1179,7,9,0,0,1179,120,1,0,0,0,1180,1181,7,15,0,0,1181,1182, + 7,14,0,0,1182,1183,7,18,0,0,1183,1184,7,4,0,0,1184,122,1,0,0,0,1185, + 1186,7,15,0,0,1186,1187,7,14,0,0,1187,1188,7,5,0,0,1188,1189,7,5, + 0,0,1189,1190,7,4,0,0,1190,1191,7,10,0,0,1191,1192,7,3,0,0,1192, + 124,1,0,0,0,1193,1194,7,15,0,0,1194,1195,7,14,0,0,1195,1196,7,5, + 0,0,1196,1197,7,5,0,0,1197,1198,7,4,0,0,1198,1199,7,10,0,0,1199, + 1200,7,3,0,0,1200,1201,5,95,0,0,1201,1202,7,1,0,0,1202,1203,7,0, + 0,0,1203,1204,7,3,0,0,1204,1205,7,4,0,0,1205,126,1,0,0,0,1206,1207, + 7,15,0,0,1207,1208,7,14,0,0,1208,1209,7,5,0,0,1209,1210,7,5,0,0, + 1210,1211,7,4,0,0,1211,1212,7,10,0,0,1212,1213,7,3,0,0,1213,1214, + 5,95,0,0,1214,1215,7,3,0,0,1215,1216,7,12,0,0,1216,1217,7,21,0,0, + 1217,1218,7,4,0,0,1218,128,1,0,0,0,1219,1220,7,15,0,0,1220,1221, + 7,14,0,0,1221,1222,7,5,0,0,1222,1223,7,5,0,0,1223,1224,7,4,0,0,1224, + 1225,7,10,0,0,1225,1226,7,3,0,0,1226,1227,5,95,0,0,1227,1228,7,3, + 0,0,1228,1229,7,12,0,0,1229,1230,7,21,0,0,1230,1231,7,4,0,0,1231, + 1232,7,9,0,0,1232,1233,7,3,0,0,1233,1234,7,0,0,0,1234,1235,7,21, + 0,0,1235,1236,7,22,0,0,1236,130,1,0,0,0,1237,1238,7,15,0,0,1238, + 1239,7,14,0,0,1239,1240,7,5,0,0,1240,1241,7,5,0,0,1241,1242,7,4, + 0,0,1242,1243,7,10,0,0,1243,1244,7,3,0,0,1244,1245,5,95,0,0,1245, + 1246,7,14,0,0,1246,1247,7,9,0,0,1247,1248,7,4,0,0,1248,1249,7,5, + 0,0,1249,132,1,0,0,0,1250,1251,7,1,0,0,1251,1252,7,0,0,0,1252,1253, + 7,8,0,0,1253,134,1,0,0,0,1254,1255,7,1,0,0,1255,1256,7,0,0,0,1256, + 1257,7,8,0,0,1257,1258,7,9,0,0,1258,136,1,0,0,0,1259,1260,7,1,0, + 0,1260,1261,7,0,0,0,1261,1262,7,8,0,0,1262,1263,7,17,0,0,1263,1264, + 7,2,0,0,1264,1265,7,8,0,0,1265,1266,7,4,0,0,1266,1267,7,0,0,0,1267, + 1268,7,5,0,0,1268,138,1,0,0,0,1269,1270,7,1,0,0,1270,1271,7,0,0, + 0,1271,1272,7,3,0,0,1272,1273,7,0,0,0,1273,140,1,0,0,0,1274,1275, + 7,1,0,0,1275,1276,7,0,0,0,1276,1277,7,3,0,0,1277,1278,7,4,0,0,1278, + 142,1,0,0,0,1279,1280,7,1,0,0,1280,1281,7,0,0,0,1281,1282,7,3,0, + 0,1282,1283,7,0,0,0,1283,1284,7,18,0,0,1284,1285,7,0,0,0,1285,1286, + 7,9,0,0,1286,1287,7,4,0,0,1287,144,1,0,0,0,1288,1289,7,1,0,0,1289, + 1290,7,0,0,0,1290,1291,7,3,0,0,1291,1292,7,0,0,0,1292,1293,7,18, + 0,0,1293,1294,7,0,0,0,1294,1295,7,9,0,0,1295,1296,7,4,0,0,1296,1297, + 7,9,0,0,1297,146,1,0,0,0,1298,1299,7,1,0,0,1299,1300,7,0,0,0,1300, + 1301,7,3,0,0,1301,1302,7,4,0,0,1302,1303,7,0,0,0,1303,1304,7,1,0, + 0,1304,1305,7,1,0,0,1305,148,1,0,0,0,1306,1307,7,1,0,0,1307,1308, + 7,0,0,0,1308,1309,7,3,0,0,1309,1310,7,4,0,0,1310,1311,5,95,0,0,1311, + 1312,7,0,0,0,1312,1313,7,1,0,0,1313,1314,7,1,0,0,1314,150,1,0,0, + 0,1315,1316,7,1,0,0,1316,1317,7,0,0,0,1317,1318,7,3,0,0,1318,1319, + 7,4,0,0,1319,1320,7,1,0,0,1320,1321,7,12,0,0,1321,1322,7,2,0,0,1322, + 1323,7,2,0,0,1323,152,1,0,0,0,1324,1325,7,1,0,0,1325,1326,7,0,0, + 0,1326,1327,7,3,0,0,1327,1328,7,4,0,0,1328,1329,5,95,0,0,1329,1330, + 7,1,0,0,1330,1331,7,12,0,0,1331,1332,7,2,0,0,1332,1333,7,2,0,0,1333, + 154,1,0,0,0,1334,1335,7,1,0,0,1335,1336,7,18,0,0,1336,1337,7,22, + 0,0,1337,1338,7,5,0,0,1338,1339,7,17,0,0,1339,1340,7,22,0,0,1340, + 1341,7,4,0,0,1341,1342,7,5,0,0,1342,1343,7,3,0,0,1343,1344,7,12, + 0,0,1344,1345,7,4,0,0,1345,1346,7,9,0,0,1346,156,1,0,0,0,1347,1348, + 7,1,0,0,1348,1349,7,4,0,0,1349,1350,7,15,0,0,1350,158,1,0,0,0,1351, + 1352,7,1,0,0,1352,1353,7,4,0,0,1353,1354,7,15,0,0,1354,1355,7,12, + 0,0,1355,1356,7,21,0,0,1356,1357,7,0,0,0,1357,1358,7,6,0,0,1358, + 160,1,0,0,0,1359,1360,7,1,0,0,1360,1361,7,4,0,0,1361,1362,7,15,0, + 0,1362,1363,7,6,0,0,1363,1364,7,0,0,0,1364,1365,7,5,0,0,1365,1366, + 7,4,0,0,1366,162,1,0,0,0,1367,1368,7,1,0,0,1368,1369,7,4,0,0,1369, + 1370,7,2,0,0,1370,1371,7,0,0,0,1371,1372,7,14,0,0,1372,1373,7,6, + 0,0,1373,1374,7,3,0,0,1374,164,1,0,0,0,1375,1376,7,1,0,0,1376,1377, + 7,4,0,0,1377,1378,7,2,0,0,1378,1379,7,12,0,0,1379,1380,7,10,0,0, + 1380,1381,7,4,0,0,1381,1382,7,1,0,0,1382,166,1,0,0,0,1383,1384,7, + 1,0,0,1384,1385,7,4,0,0,1385,1386,7,6,0,0,1386,1387,7,4,0,0,1387, + 1388,7,3,0,0,1388,1389,7,4,0,0,1389,168,1,0,0,0,1390,1391,7,1,0, + 0,1391,1392,7,4,0,0,1392,1393,7,6,0,0,1393,1394,7,12,0,0,1394,1395, + 7,21,0,0,1395,1396,7,12,0,0,1396,1397,7,3,0,0,1397,1398,7,4,0,0, + 1398,1399,7,1,0,0,1399,170,1,0,0,0,1400,1401,7,1,0,0,1401,1402,7, + 4,0,0,1402,1403,7,9,0,0,1403,1404,7,15,0,0,1404,172,1,0,0,0,1405, + 1406,7,1,0,0,1406,1407,7,4,0,0,1407,1408,7,9,0,0,1408,1409,7,15, + 0,0,1409,1410,7,5,0,0,1410,1411,7,12,0,0,1411,1412,7,18,0,0,1412, + 1413,7,4,0,0,1413,174,1,0,0,0,1414,1415,7,1,0,0,1415,1416,7,2,0, + 0,1416,1417,7,9,0,0,1417,176,1,0,0,0,1418,1419,7,1,0,0,1419,1420, + 7,12,0,0,1420,1421,7,5,0,0,1421,1422,7,4,0,0,1422,1423,7,15,0,0, + 1423,1424,7,3,0,0,1424,1425,7,17,0,0,1425,1426,7,5,0,0,1426,1427, + 7,12,0,0,1427,1428,7,4,0,0,1428,1429,7,9,0,0,1429,178,1,0,0,0,1430, + 1431,7,1,0,0,1431,1432,7,12,0,0,1432,1433,7,5,0,0,1433,1434,7,4, + 0,0,1434,1435,7,15,0,0,1435,1436,7,3,0,0,1436,1437,7,17,0,0,1437, + 1438,7,5,0,0,1438,1439,7,8,0,0,1439,180,1,0,0,0,1440,1441,7,1,0, + 0,1441,1442,7,12,0,0,1442,1443,7,9,0,0,1443,1444,7,0,0,0,1444,1445, + 7,18,0,0,1445,1446,7,6,0,0,1446,1447,7,4,0,0,1447,182,1,0,0,0,1448, + 1449,7,1,0,0,1449,1450,7,12,0,0,1450,1451,7,9,0,0,1451,1452,7,3, + 0,0,1452,1453,7,12,0,0,1453,1454,7,10,0,0,1454,1455,7,15,0,0,1455, + 1456,7,3,0,0,1456,184,1,0,0,0,1457,1458,7,1,0,0,1458,1459,7,12,0, + 0,1459,1460,7,9,0,0,1460,1461,7,3,0,0,1461,1462,7,5,0,0,1462,1463, + 7,12,0,0,1463,1464,7,18,0,0,1464,1465,7,14,0,0,1465,1466,7,3,0,0, + 1466,1467,7,4,0,0,1467,186,1,0,0,0,1468,1469,7,1,0,0,1469,1470,7, + 12,0,0,1470,1471,7,13,0,0,1471,188,1,0,0,0,1472,1473,7,1,0,0,1473, + 1474,7,17,0,0,1474,1475,7,14,0,0,1475,1476,7,18,0,0,1476,1477,7, + 6,0,0,1477,1478,7,4,0,0,1478,190,1,0,0,0,1479,1480,7,1,0,0,1480, + 1481,7,5,0,0,1481,1482,7,17,0,0,1482,1483,7,22,0,0,1483,192,1,0, + 0,0,1484,1485,7,4,0,0,1485,1486,7,6,0,0,1486,1487,7,9,0,0,1487,1488, + 7,4,0,0,1488,194,1,0,0,0,1489,1490,7,4,0,0,1490,1491,7,10,0,0,1491, + 1492,7,0,0,0,1492,1493,7,18,0,0,1493,1494,7,6,0,0,1494,1495,7,4, + 0,0,1495,196,1,0,0,0,1496,1497,7,4,0,0,1497,1498,7,10,0,0,1498,1499, + 7,1,0,0,1499,198,1,0,0,0,1500,1501,7,4,0,0,1501,1502,7,9,0,0,1502, + 1503,7,15,0,0,1503,1504,7,0,0,0,1504,1505,7,22,0,0,1505,1506,7,4, + 0,0,1506,200,1,0,0,0,1507,1508,7,4,0,0,1508,1509,7,9,0,0,1509,1510, + 7,15,0,0,1510,1511,7,0,0,0,1511,1512,7,22,0,0,1512,1513,7,4,0,0, + 1513,1514,7,1,0,0,1514,202,1,0,0,0,1515,1516,7,4,0,0,1516,1517,7, + 23,0,0,1517,1518,7,15,0,0,1518,1519,7,4,0,0,1519,1520,7,22,0,0,1520, + 1521,7,3,0,0,1521,204,1,0,0,0,1522,1523,7,4,0,0,1523,1524,7,23,0, + 0,1524,1525,7,15,0,0,1525,1526,7,16,0,0,1526,1527,7,0,0,0,1527,1528, + 7,10,0,0,1528,1529,7,19,0,0,1529,1530,7,4,0,0,1530,206,1,0,0,0,1531, + 1532,7,4,0,0,1532,1533,7,23,0,0,1533,1534,7,15,0,0,1534,1535,7,6, + 0,0,1535,1536,7,14,0,0,1536,1537,7,1,0,0,1537,1538,7,4,0,0,1538, + 208,1,0,0,0,1539,1540,7,4,0,0,1540,1541,7,23,0,0,1541,1542,7,12, + 0,0,1542,1543,7,9,0,0,1543,1544,7,3,0,0,1544,1545,7,9,0,0,1545,210, + 1,0,0,0,1546,1547,7,4,0,0,1547,1548,7,23,0,0,1548,1549,7,22,0,0, + 1549,1550,7,6,0,0,1550,1551,7,0,0,0,1551,1552,7,12,0,0,1552,1553, + 7,10,0,0,1553,212,1,0,0,0,1554,1555,7,4,0,0,1555,1556,7,23,0,0,1556, + 1557,7,22,0,0,1557,1558,7,17,0,0,1558,1559,7,5,0,0,1559,1560,7,3, + 0,0,1560,214,1,0,0,0,1561,1562,7,4,0,0,1562,1563,7,23,0,0,1563,1564, + 7,3,0,0,1564,1565,7,4,0,0,1565,1566,7,10,0,0,1566,1567,7,1,0,0,1567, + 1568,7,4,0,0,1568,1569,7,1,0,0,1569,216,1,0,0,0,1570,1571,7,4,0, + 0,1571,1572,7,23,0,0,1572,1573,7,3,0,0,1573,1574,7,4,0,0,1574,1575, + 7,5,0,0,1575,1576,7,10,0,0,1576,1577,7,0,0,0,1577,1578,7,6,0,0,1578, + 218,1,0,0,0,1579,1580,7,4,0,0,1580,1581,7,23,0,0,1581,1582,7,3,0, + 0,1582,1583,7,5,0,0,1583,1584,7,0,0,0,1584,1585,7,15,0,0,1585,1586, + 7,3,0,0,1586,220,1,0,0,0,1587,1588,7,2,0,0,1588,1589,7,0,0,0,1589, + 1590,7,6,0,0,1590,1591,7,9,0,0,1591,1592,7,4,0,0,1592,222,1,0,0, + 0,1593,1594,7,2,0,0,1594,1595,7,4,0,0,1595,1596,7,3,0,0,1596,1597, + 7,15,0,0,1597,1598,7,16,0,0,1598,224,1,0,0,0,1599,1600,7,2,0,0,1600, + 1601,7,12,0,0,1601,1602,7,4,0,0,1602,1603,7,6,0,0,1603,1604,7,1, + 0,0,1604,1605,7,9,0,0,1605,226,1,0,0,0,1606,1607,7,2,0,0,1607,1608, + 7,12,0,0,1608,1609,7,6,0,0,1609,1610,7,3,0,0,1610,1611,7,4,0,0,1611, + 1612,7,5,0,0,1612,228,1,0,0,0,1613,1614,7,2,0,0,1614,1615,7,12,0, + 0,1615,1616,7,6,0,0,1616,1617,7,4,0,0,1617,1618,7,2,0,0,1618,1619, + 7,17,0,0,1619,1620,7,5,0,0,1620,1621,7,21,0,0,1621,1622,7,0,0,0, + 1622,1623,7,3,0,0,1623,230,1,0,0,0,1624,1625,7,2,0,0,1625,1626,7, + 12,0,0,1626,1627,7,5,0,0,1627,1628,7,9,0,0,1628,1629,7,3,0,0,1629, + 232,1,0,0,0,1630,1631,7,2,0,0,1631,1632,7,6,0,0,1632,1633,7,17,0, + 0,1633,1634,7,0,0,0,1634,1635,7,3,0,0,1635,234,1,0,0,0,1636,1637, + 7,2,0,0,1637,1638,7,17,0,0,1638,1639,7,6,0,0,1639,1640,7,6,0,0,1640, + 1641,7,17,0,0,1641,1642,7,7,0,0,1642,1643,7,12,0,0,1643,1644,7,10, + 0,0,1644,1645,7,19,0,0,1645,236,1,0,0,0,1646,1647,7,2,0,0,1647,1648, + 7,17,0,0,1648,1649,7,5,0,0,1649,238,1,0,0,0,1650,1651,7,2,0,0,1651, + 1652,7,17,0,0,1652,1653,7,5,0,0,1653,1654,7,4,0,0,1654,1655,7,12, + 0,0,1655,1656,7,19,0,0,1656,1657,7,10,0,0,1657,240,1,0,0,0,1658, + 1659,7,2,0,0,1659,1660,7,17,0,0,1660,1661,7,5,0,0,1661,1662,7,21, + 0,0,1662,1663,7,0,0,0,1663,1664,7,3,0,0,1664,242,1,0,0,0,1665,1666, + 7,2,0,0,1666,1667,7,17,0,0,1667,1668,7,5,0,0,1668,1669,7,21,0,0, + 1669,1670,7,0,0,0,1670,1671,7,3,0,0,1671,1672,7,3,0,0,1672,1673, + 7,4,0,0,1673,1674,7,1,0,0,1674,244,1,0,0,0,1675,1676,7,2,0,0,1676, + 1677,7,5,0,0,1677,1678,7,17,0,0,1678,1679,7,21,0,0,1679,246,1,0, + 0,0,1680,1681,7,2,0,0,1681,1682,7,14,0,0,1682,1683,7,6,0,0,1683, + 1684,7,6,0,0,1684,248,1,0,0,0,1685,1686,7,2,0,0,1686,1687,7,14,0, + 0,1687,1688,7,10,0,0,1688,1689,7,15,0,0,1689,1690,7,3,0,0,1690,1691, + 7,12,0,0,1691,1692,7,17,0,0,1692,1693,7,10,0,0,1693,250,1,0,0,0, + 1694,1695,7,2,0,0,1695,1696,7,14,0,0,1696,1697,7,10,0,0,1697,1698, + 7,15,0,0,1698,1699,7,3,0,0,1699,1700,7,12,0,0,1700,1701,7,17,0,0, + 1701,1702,7,10,0,0,1702,1703,7,9,0,0,1703,252,1,0,0,0,1704,1705, + 7,19,0,0,1705,1706,7,4,0,0,1706,1707,7,10,0,0,1707,1708,7,4,0,0, + 1708,1709,7,5,0,0,1709,1710,7,0,0,0,1710,1711,7,3,0,0,1711,1712, + 7,4,0,0,1712,1713,7,1,0,0,1713,254,1,0,0,0,1714,1715,7,19,0,0,1715, + 1716,7,6,0,0,1716,1717,7,17,0,0,1717,1718,7,18,0,0,1718,1719,7,0, + 0,0,1719,1720,7,6,0,0,1720,256,1,0,0,0,1721,1722,7,19,0,0,1722,1723, + 7,5,0,0,1723,1724,7,0,0,0,1724,1725,7,10,0,0,1725,1726,7,3,0,0,1726, + 258,1,0,0,0,1727,1728,7,19,0,0,1728,1729,7,5,0,0,1729,1730,7,17, + 0,0,1730,1731,7,14,0,0,1731,1732,7,22,0,0,1732,260,1,0,0,0,1733, + 1734,7,19,0,0,1734,1735,7,5,0,0,1735,1736,7,17,0,0,1736,1737,7,14, + 0,0,1737,1738,7,22,0,0,1738,1739,7,12,0,0,1739,1740,7,10,0,0,1740, + 1741,7,19,0,0,1741,262,1,0,0,0,1742,1743,7,16,0,0,1743,1744,7,0, + 0,0,1744,1745,7,13,0,0,1745,1746,7,12,0,0,1746,1747,7,10,0,0,1747, + 1748,7,19,0,0,1748,264,1,0,0,0,1749,1750,7,23,0,0,1750,266,1,0,0, + 0,1751,1752,7,16,0,0,1752,1753,7,17,0,0,1753,1754,7,14,0,0,1754, + 1755,7,5,0,0,1755,268,1,0,0,0,1756,1757,7,16,0,0,1757,1758,7,17, + 0,0,1758,1759,7,14,0,0,1759,1760,7,5,0,0,1760,1761,7,9,0,0,1761, + 270,1,0,0,0,1762,1763,7,12,0,0,1763,1764,7,1,0,0,1764,1765,7,4,0, + 0,1765,1766,7,10,0,0,1766,1767,7,3,0,0,1767,1768,7,12,0,0,1768,1769, + 7,2,0,0,1769,1770,7,12,0,0,1770,1771,7,4,0,0,1771,1772,7,5,0,0,1772, + 272,1,0,0,0,1773,1774,7,12,0,0,1774,1775,7,2,0,0,1775,274,1,0,0, + 0,1776,1777,7,12,0,0,1777,1778,7,19,0,0,1778,1779,7,10,0,0,1779, + 1780,7,17,0,0,1780,1781,7,5,0,0,1781,1782,7,4,0,0,1782,276,1,0,0, + 0,1783,1784,7,12,0,0,1784,1785,7,21,0,0,1785,1786,7,22,0,0,1786, + 1787,7,17,0,0,1787,1788,7,5,0,0,1788,1789,7,3,0,0,1789,278,1,0,0, + 0,1790,1791,7,12,0,0,1791,1792,7,10,0,0,1792,280,1,0,0,0,1793,1794, + 7,12,0,0,1794,1795,7,10,0,0,1795,1796,7,15,0,0,1796,1797,7,6,0,0, + 1797,1798,7,14,0,0,1798,1799,7,1,0,0,1799,1800,7,4,0,0,1800,282, + 1,0,0,0,1801,1802,7,12,0,0,1802,1803,7,10,0,0,1803,1804,7,1,0,0, + 1804,1805,7,4,0,0,1805,1806,7,23,0,0,1806,284,1,0,0,0,1807,1808, + 7,12,0,0,1808,1809,7,10,0,0,1809,1810,7,1,0,0,1810,1811,7,4,0,0, + 1811,1812,7,23,0,0,1812,1813,7,4,0,0,1813,1814,7,9,0,0,1814,286, + 1,0,0,0,1815,1816,7,12,0,0,1816,1817,7,10,0,0,1817,1818,7,10,0,0, + 1818,1819,7,4,0,0,1819,1820,7,5,0,0,1820,288,1,0,0,0,1821,1822,7, + 12,0,0,1822,1823,7,10,0,0,1823,1824,7,22,0,0,1824,1825,7,0,0,0,1825, + 1826,7,3,0,0,1826,1827,7,16,0,0,1827,290,1,0,0,0,1828,1829,7,12, + 0,0,1829,1830,7,10,0,0,1830,1831,7,22,0,0,1831,1832,7,14,0,0,1832, + 1833,7,3,0,0,1833,1834,7,2,0,0,1834,1835,7,17,0,0,1835,1836,7,5, + 0,0,1836,1837,7,21,0,0,1837,1838,7,0,0,0,1838,1839,7,3,0,0,1839, + 292,1,0,0,0,1840,1841,7,12,0,0,1841,1842,7,10,0,0,1842,1843,7,9, + 0,0,1843,1844,7,4,0,0,1844,1845,7,5,0,0,1845,1846,7,3,0,0,1846,294, + 1,0,0,0,1847,1848,7,12,0,0,1848,1849,7,10,0,0,1849,1850,7,3,0,0, + 1850,1851,7,4,0,0,1851,1852,7,5,0,0,1852,1853,7,9,0,0,1853,1854, + 7,4,0,0,1854,1855,7,15,0,0,1855,1856,7,3,0,0,1856,296,1,0,0,0,1857, + 1858,7,12,0,0,1858,1859,7,10,0,0,1859,1860,7,3,0,0,1860,1861,7,4, + 0,0,1861,1862,7,5,0,0,1862,1863,7,13,0,0,1863,1864,7,0,0,0,1864, + 1865,7,6,0,0,1865,298,1,0,0,0,1866,1867,7,12,0,0,1867,1868,7,10, + 0,0,1868,1869,7,3,0,0,1869,300,1,0,0,0,1870,1871,7,12,0,0,1871,1872, + 7,10,0,0,1872,1873,7,3,0,0,1873,1874,7,4,0,0,1874,1875,7,19,0,0, + 1875,1876,7,4,0,0,1876,1877,7,5,0,0,1877,302,1,0,0,0,1878,1879,7, + 12,0,0,1879,1880,7,10,0,0,1880,1881,7,3,0,0,1881,1882,7,17,0,0,1882, + 304,1,0,0,0,1883,1884,7,12,0,0,1884,1885,7,9,0,0,1885,306,1,0,0, + 0,1886,1887,7,12,0,0,1887,1888,7,3,0,0,1888,1889,7,4,0,0,1889,1890, + 7,21,0,0,1890,1891,7,9,0,0,1891,308,1,0,0,0,1892,1893,7,24,0,0,1893, + 1894,7,17,0,0,1894,1895,7,12,0,0,1895,1896,7,10,0,0,1896,310,1,0, + 0,0,1897,1898,7,20,0,0,1898,1899,7,4,0,0,1899,1900,7,8,0,0,1900, + 1901,7,9,0,0,1901,312,1,0,0,0,1902,1903,7,6,0,0,1903,1904,7,0,0, + 0,1904,1905,7,9,0,0,1905,1906,7,3,0,0,1906,314,1,0,0,0,1907,1908, + 7,6,0,0,1908,1909,7,0,0,0,1909,1910,7,3,0,0,1910,1911,7,4,0,0,1911, + 1912,7,5,0,0,1912,1913,7,0,0,0,1913,1914,7,6,0,0,1914,316,1,0,0, + 0,1915,1916,7,6,0,0,1916,1917,7,0,0,0,1917,1918,7,11,0,0,1918,1919, + 7,8,0,0,1919,318,1,0,0,0,1920,1921,7,6,0,0,1921,1922,7,4,0,0,1922, + 1923,7,0,0,0,1923,1924,7,1,0,0,1924,1925,7,12,0,0,1925,1926,7,10, + 0,0,1926,1927,7,19,0,0,1927,320,1,0,0,0,1928,1929,7,6,0,0,1929,1930, + 7,4,0,0,1930,1931,7,2,0,0,1931,1932,7,3,0,0,1932,322,1,0,0,0,1933, + 1934,7,6,0,0,1934,1935,7,12,0,0,1935,1936,7,2,0,0,1936,1937,7,4, + 0,0,1937,1938,7,15,0,0,1938,1939,7,8,0,0,1939,1940,7,15,0,0,1940, + 1941,7,6,0,0,1941,1942,7,4,0,0,1942,324,1,0,0,0,1943,1944,7,6,0, + 0,1944,1945,7,12,0,0,1945,1946,7,20,0,0,1946,1947,7,4,0,0,1947,326, + 1,0,0,0,1948,1949,7,12,0,0,1949,1950,7,6,0,0,1950,1951,7,12,0,0, + 1951,1952,7,20,0,0,1952,1953,7,4,0,0,1953,328,1,0,0,0,1954,1955, + 7,6,0,0,1955,1956,7,12,0,0,1956,1957,7,21,0,0,1957,1958,7,12,0,0, + 1958,1959,7,3,0,0,1959,330,1,0,0,0,1960,1961,7,6,0,0,1961,1962,7, + 12,0,0,1962,1963,7,10,0,0,1963,1964,7,4,0,0,1964,1965,7,9,0,0,1965, + 332,1,0,0,0,1966,1967,7,6,0,0,1967,1968,7,12,0,0,1968,1969,7,9,0, + 0,1969,1970,7,3,0,0,1970,334,1,0,0,0,1971,1972,7,6,0,0,1972,1973, + 7,17,0,0,1973,1974,7,0,0,0,1974,1975,7,1,0,0,1975,336,1,0,0,0,1976, + 1977,7,6,0,0,1977,1978,7,17,0,0,1978,1979,7,15,0,0,1979,1980,7,0, + 0,0,1980,1981,7,6,0,0,1981,338,1,0,0,0,1982,1983,7,6,0,0,1983,1984, + 7,17,0,0,1984,1985,7,15,0,0,1985,1986,7,0,0,0,1986,1987,7,3,0,0, + 1987,1988,7,12,0,0,1988,1989,7,17,0,0,1989,1990,7,10,0,0,1990,340, + 1,0,0,0,1991,1992,7,6,0,0,1992,1993,7,17,0,0,1993,1994,7,15,0,0, + 1994,1995,7,20,0,0,1995,342,1,0,0,0,1996,1997,7,6,0,0,1997,1998, + 7,17,0,0,1998,1999,7,15,0,0,1999,2000,7,20,0,0,2000,2001,7,9,0,0, + 2001,344,1,0,0,0,2002,2003,7,6,0,0,2003,2004,7,17,0,0,2004,2005, + 7,19,0,0,2005,2006,7,12,0,0,2006,2007,7,15,0,0,2007,2008,7,0,0,0, + 2008,2009,7,6,0,0,2009,346,1,0,0,0,2010,2011,7,6,0,0,2011,2012,7, + 17,0,0,2012,2013,7,10,0,0,2013,2014,7,19,0,0,2014,348,1,0,0,0,2015, + 2016,7,21,0,0,2016,2017,7,0,0,0,2017,2018,7,15,0,0,2018,2019,7,5, + 0,0,2019,2020,7,17,0,0,2020,350,1,0,0,0,2021,2022,7,21,0,0,2022, + 2023,7,0,0,0,2023,2024,7,22,0,0,2024,352,1,0,0,0,2025,2026,7,21, + 0,0,2026,2027,7,0,0,0,2027,2028,7,3,0,0,2028,2029,7,15,0,0,2029, + 2030,7,16,0,0,2030,2031,7,4,0,0,2031,2032,7,1,0,0,2032,354,1,0,0, + 0,2033,2034,7,21,0,0,2034,2035,7,4,0,0,2035,2036,7,5,0,0,2036,2037, + 7,19,0,0,2037,2038,7,4,0,0,2038,356,1,0,0,0,2039,2040,7,21,0,0,2040, + 2041,7,12,0,0,2041,2042,7,15,0,0,2042,2043,7,5,0,0,2043,2044,7,17, + 0,0,2044,2045,7,9,0,0,2045,2046,7,4,0,0,2046,2047,7,15,0,0,2047, + 2048,7,17,0,0,2048,2049,7,10,0,0,2049,2050,7,1,0,0,2050,358,1,0, + 0,0,2051,2052,7,21,0,0,2052,2053,7,12,0,0,2053,2054,7,15,0,0,2054, + 2055,7,5,0,0,2055,2056,7,17,0,0,2056,2057,7,9,0,0,2057,2058,7,4, + 0,0,2058,2059,7,15,0,0,2059,2060,7,17,0,0,2060,2061,7,10,0,0,2061, + 2062,7,1,0,0,2062,2063,7,9,0,0,2063,360,1,0,0,0,2064,2065,7,21,0, + 0,2065,2066,7,12,0,0,2066,2067,7,6,0,0,2067,2068,7,6,0,0,2068,2069, + 7,12,0,0,2069,2070,7,9,0,0,2070,2071,7,4,0,0,2071,2072,7,15,0,0, + 2072,2073,7,17,0,0,2073,2074,7,10,0,0,2074,2075,7,1,0,0,2075,362, + 1,0,0,0,2076,2077,7,21,0,0,2077,2078,7,12,0,0,2078,2079,7,6,0,0, + 2079,2080,7,6,0,0,2080,2081,7,12,0,0,2081,2082,7,9,0,0,2082,2083, + 7,4,0,0,2083,2084,7,15,0,0,2084,2085,7,17,0,0,2085,2086,7,10,0,0, + 2086,2087,7,1,0,0,2087,2088,7,9,0,0,2088,364,1,0,0,0,2089,2090,7, + 21,0,0,2090,2091,7,12,0,0,2091,2092,7,10,0,0,2092,2093,7,14,0,0, + 2093,2094,7,3,0,0,2094,2095,7,4,0,0,2095,366,1,0,0,0,2096,2097,7, + 21,0,0,2097,2098,7,12,0,0,2098,2099,7,10,0,0,2099,2100,7,14,0,0, + 2100,2101,7,3,0,0,2101,2102,7,4,0,0,2102,2103,7,9,0,0,2103,368,1, + 0,0,0,2104,2105,7,21,0,0,2105,2106,7,17,0,0,2106,2107,7,10,0,0,2107, + 2108,7,3,0,0,2108,2109,7,16,0,0,2109,370,1,0,0,0,2110,2111,7,21, + 0,0,2111,2112,7,17,0,0,2112,2113,7,10,0,0,2113,2114,7,3,0,0,2114, + 2115,7,16,0,0,2115,2116,7,9,0,0,2116,372,1,0,0,0,2117,2118,7,21, + 0,0,2118,2119,7,9,0,0,2119,2120,7,15,0,0,2120,2121,7,20,0,0,2121, + 374,1,0,0,0,2122,2123,7,10,0,0,2123,2124,7,0,0,0,2124,2125,7,21, + 0,0,2125,2126,7,4,0,0,2126,376,1,0,0,0,2127,2128,7,10,0,0,2128,2129, + 7,0,0,0,2129,2130,7,21,0,0,2130,2131,7,4,0,0,2131,2132,7,9,0,0,2132, + 2133,7,22,0,0,2133,2134,7,0,0,0,2134,2135,7,15,0,0,2135,2136,7,4, + 0,0,2136,378,1,0,0,0,2137,2138,7,10,0,0,2138,2139,7,0,0,0,2139,2140, + 7,21,0,0,2140,2141,7,4,0,0,2141,2142,7,9,0,0,2142,2143,7,22,0,0, + 2143,2144,7,0,0,0,2144,2145,7,15,0,0,2145,2146,7,4,0,0,2146,2147, + 7,9,0,0,2147,380,1,0,0,0,2148,2149,7,10,0,0,2149,2150,7,0,0,0,2150, + 2151,7,10,0,0,2151,2152,7,17,0,0,2152,2153,7,9,0,0,2153,2154,7,4, + 0,0,2154,2155,7,15,0,0,2155,2156,7,17,0,0,2156,2157,7,10,0,0,2157, + 2158,7,1,0,0,2158,382,1,0,0,0,2159,2160,7,10,0,0,2160,2161,7,0,0, + 0,2161,2162,7,10,0,0,2162,2163,7,17,0,0,2163,2164,7,9,0,0,2164,2165, + 7,4,0,0,2165,2166,7,15,0,0,2166,2167,7,17,0,0,2167,2168,7,10,0,0, + 2168,2169,7,1,0,0,2169,2170,7,9,0,0,2170,384,1,0,0,0,2171,2172,7, + 10,0,0,2172,2173,7,0,0,0,2173,2174,7,3,0,0,2174,2175,7,14,0,0,2175, + 2176,7,5,0,0,2176,2177,7,0,0,0,2177,2178,7,6,0,0,2178,386,1,0,0, + 0,2179,2180,7,10,0,0,2180,2181,7,17,0,0,2181,388,1,0,0,0,2182,2183, + 7,10,0,0,2183,2184,7,17,0,0,2184,2185,7,9,0,0,2185,2186,7,15,0,0, + 2186,2187,7,0,0,0,2187,2188,7,10,0,0,2188,390,1,0,0,0,2189,2190, + 7,10,0,0,2190,2191,7,17,0,0,2191,2192,7,3,0,0,2192,392,1,0,0,0,2193, + 2194,7,10,0,0,2194,2195,7,14,0,0,2195,2196,7,6,0,0,2196,2197,7,6, + 0,0,2197,394,1,0,0,0,2198,2199,7,10,0,0,2199,2200,7,14,0,0,2200, + 2201,7,6,0,0,2201,2202,7,6,0,0,2202,2203,7,9,0,0,2203,396,1,0,0, + 0,2204,2205,7,10,0,0,2205,2206,7,14,0,0,2206,2207,7,21,0,0,2207, + 2208,7,4,0,0,2208,2209,7,5,0,0,2209,2210,7,12,0,0,2210,2211,7,15, + 0,0,2211,398,1,0,0,0,2212,2213,7,17,0,0,2213,2214,7,2,0,0,2214,400, + 1,0,0,0,2215,2216,7,17,0,0,2216,2217,7,2,0,0,2217,2218,7,2,0,0,2218, + 2219,7,9,0,0,2219,2220,7,4,0,0,2220,2221,7,3,0,0,2221,402,1,0,0, + 0,2222,2223,7,17,0,0,2223,2224,7,10,0,0,2224,404,1,0,0,0,2225,2226, + 7,17,0,0,2226,2227,7,10,0,0,2227,2228,7,6,0,0,2228,2229,7,8,0,0, + 2229,406,1,0,0,0,2230,2231,7,17,0,0,2231,2232,7,22,0,0,2232,2233, + 7,3,0,0,2233,2234,7,12,0,0,2234,2235,7,21,0,0,2235,2236,7,12,0,0, + 2236,2237,7,11,0,0,2237,2238,7,4,0,0,2238,408,1,0,0,0,2239,2240, + 7,17,0,0,2240,2241,7,22,0,0,2241,2242,7,3,0,0,2242,2243,7,12,0,0, + 2243,2244,7,17,0,0,2244,2245,7,10,0,0,2245,410,1,0,0,0,2246,2247, + 7,17,0,0,2247,2248,7,22,0,0,2248,2249,7,3,0,0,2249,2250,7,12,0,0, + 2250,2251,7,17,0,0,2251,2252,7,10,0,0,2252,2253,7,9,0,0,2253,412, + 1,0,0,0,2254,2255,7,17,0,0,2255,2256,7,5,0,0,2256,414,1,0,0,0,2257, + 2258,7,17,0,0,2258,2259,7,5,0,0,2259,2260,7,1,0,0,2260,2261,7,4, + 0,0,2261,2262,7,5,0,0,2262,416,1,0,0,0,2263,2264,7,17,0,0,2264,2265, + 7,14,0,0,2265,2266,7,3,0,0,2266,418,1,0,0,0,2267,2268,7,17,0,0,2268, + 2269,7,14,0,0,2269,2270,7,3,0,0,2270,2271,7,4,0,0,2271,2272,7,5, + 0,0,2272,420,1,0,0,0,2273,2274,7,17,0,0,2274,2275,7,14,0,0,2275, + 2276,7,3,0,0,2276,2277,7,22,0,0,2277,2278,7,14,0,0,2278,2279,7,3, + 0,0,2279,2280,7,2,0,0,2280,2281,7,17,0,0,2281,2282,7,5,0,0,2282, + 2283,7,21,0,0,2283,2284,7,0,0,0,2284,2285,7,3,0,0,2285,422,1,0,0, + 0,2286,2287,7,17,0,0,2287,2288,7,13,0,0,2288,2289,7,4,0,0,2289,2290, + 7,5,0,0,2290,424,1,0,0,0,2291,2292,7,17,0,0,2292,2293,7,13,0,0,2293, + 2294,7,4,0,0,2294,2295,7,5,0,0,2295,2296,7,6,0,0,2296,2297,7,0,0, + 0,2297,2298,7,22,0,0,2298,2299,7,9,0,0,2299,426,1,0,0,0,2300,2301, + 7,17,0,0,2301,2302,7,13,0,0,2302,2303,7,4,0,0,2303,2304,7,5,0,0, + 2304,2305,7,6,0,0,2305,2306,7,0,0,0,2306,2307,7,8,0,0,2307,428,1, + 0,0,0,2308,2309,7,17,0,0,2309,2310,7,13,0,0,2310,2311,7,4,0,0,2311, + 2312,7,5,0,0,2312,2313,7,7,0,0,2313,2314,7,5,0,0,2314,2315,7,12, + 0,0,2315,2316,7,3,0,0,2316,2317,7,4,0,0,2317,430,1,0,0,0,2318,2319, + 7,22,0,0,2319,2320,7,0,0,0,2320,2321,7,5,0,0,2321,2322,7,3,0,0,2322, + 2323,7,12,0,0,2323,2324,7,3,0,0,2324,2325,7,12,0,0,2325,2326,7,17, + 0,0,2326,2327,7,10,0,0,2327,432,1,0,0,0,2328,2329,7,22,0,0,2329, + 2330,7,0,0,0,2330,2331,7,5,0,0,2331,2332,7,3,0,0,2332,2333,7,12, + 0,0,2333,2334,7,3,0,0,2334,2335,7,12,0,0,2335,2336,7,17,0,0,2336, + 2337,7,10,0,0,2337,2338,7,4,0,0,2338,2339,7,1,0,0,2339,434,1,0,0, + 0,2340,2341,7,22,0,0,2341,2342,7,0,0,0,2342,2343,7,5,0,0,2343,2344, + 7,3,0,0,2344,2345,7,12,0,0,2345,2346,7,3,0,0,2346,2347,7,12,0,0, + 2347,2348,7,17,0,0,2348,2349,7,10,0,0,2349,2350,7,9,0,0,2350,436, + 1,0,0,0,2351,2352,7,22,0,0,2352,2353,7,4,0,0,2353,2354,7,5,0,0,2354, + 2355,7,15,0,0,2355,2356,7,4,0,0,2356,2357,7,10,0,0,2357,2358,7,3, + 0,0,2358,2359,7,12,0,0,2359,2360,7,6,0,0,2360,2361,7,4,0,0,2361, + 2362,5,95,0,0,2362,2363,7,15,0,0,2363,2364,7,17,0,0,2364,2365,7, + 10,0,0,2365,2366,7,3,0,0,2366,438,1,0,0,0,2367,2368,7,22,0,0,2368, + 2369,7,4,0,0,2369,2370,7,5,0,0,2370,2371,7,15,0,0,2371,2372,7,4, + 0,0,2372,2373,7,10,0,0,2373,2374,7,3,0,0,2374,2375,7,12,0,0,2375, + 2376,7,6,0,0,2376,2377,7,4,0,0,2377,2378,5,95,0,0,2378,2379,7,1, + 0,0,2379,2380,7,12,0,0,2380,2381,7,9,0,0,2381,2382,7,15,0,0,2382, + 440,1,0,0,0,2383,2384,7,22,0,0,2384,2385,7,4,0,0,2385,2386,7,5,0, + 0,2386,2387,7,15,0,0,2387,2388,7,4,0,0,2388,2389,7,10,0,0,2389,2390, + 7,3,0,0,2390,442,1,0,0,0,2391,2392,7,22,0,0,2392,2393,7,12,0,0,2393, + 2394,7,13,0,0,2394,2395,7,17,0,0,2395,2396,7,3,0,0,2396,444,1,0, + 0,0,2397,2398,7,22,0,0,2398,2399,7,6,0,0,2399,2400,7,0,0,0,2400, + 2401,7,15,0,0,2401,2402,7,12,0,0,2402,2403,7,10,0,0,2403,2404,7, + 19,0,0,2404,446,1,0,0,0,2405,2406,7,22,0,0,2406,2407,7,17,0,0,2407, + 2408,7,9,0,0,2408,2409,7,12,0,0,2409,2410,7,3,0,0,2410,2411,7,12, + 0,0,2411,2412,7,17,0,0,2412,2413,7,10,0,0,2413,448,1,0,0,0,2414, + 2415,7,22,0,0,2415,2416,7,5,0,0,2416,2417,7,4,0,0,2417,2418,7,15, + 0,0,2418,2419,7,4,0,0,2419,2420,7,1,0,0,2420,2421,7,12,0,0,2421, + 2422,7,10,0,0,2422,2423,7,19,0,0,2423,450,1,0,0,0,2424,2425,7,22, + 0,0,2425,2426,7,5,0,0,2426,2427,7,12,0,0,2427,2428,7,21,0,0,2428, + 2429,7,0,0,0,2429,2430,7,5,0,0,2430,2431,7,8,0,0,2431,452,1,0,0, + 0,2432,2433,7,22,0,0,2433,2434,7,5,0,0,2434,2435,7,12,0,0,2435,2436, + 7,10,0,0,2436,2437,7,15,0,0,2437,2438,7,12,0,0,2438,2439,7,22,0, + 0,2439,2440,7,0,0,0,2440,2441,7,6,0,0,2441,2442,7,9,0,0,2442,454, + 1,0,0,0,2443,2444,7,22,0,0,2444,2445,7,5,0,0,2445,2446,7,17,0,0, + 2446,2447,7,22,0,0,2447,2448,7,4,0,0,2448,2449,7,5,0,0,2449,2450, + 7,3,0,0,2450,2451,7,12,0,0,2451,2452,7,4,0,0,2452,2453,7,9,0,0,2453, + 456,1,0,0,0,2454,2455,7,22,0,0,2455,2456,7,14,0,0,2456,2457,7,5, + 0,0,2457,2458,7,19,0,0,2458,2459,7,4,0,0,2459,458,1,0,0,0,2460,2461, + 7,25,0,0,2461,2462,7,14,0,0,2462,2463,7,0,0,0,2463,2464,7,5,0,0, + 2464,2465,7,3,0,0,2465,2466,7,4,0,0,2466,2467,7,5,0,0,2467,460,1, + 0,0,0,2468,2469,7,25,0,0,2469,2470,7,14,0,0,2470,2471,7,4,0,0,2471, + 2472,7,5,0,0,2472,2473,7,8,0,0,2473,462,1,0,0,0,2474,2475,7,5,0, + 0,2475,2476,7,0,0,0,2476,2477,7,10,0,0,2477,2478,7,19,0,0,2478,2479, + 7,4,0,0,2479,464,1,0,0,0,2480,2481,7,5,0,0,2481,2482,7,4,0,0,2482, + 2483,7,0,0,0,2483,2484,7,6,0,0,2484,466,1,0,0,0,2485,2486,7,5,0, + 0,2486,2487,7,4,0,0,2487,2488,7,15,0,0,2488,2489,7,17,0,0,2489,2490, + 7,5,0,0,2490,2491,7,1,0,0,2491,2492,7,5,0,0,2492,2493,7,4,0,0,2493, + 2494,7,0,0,0,2494,2495,7,1,0,0,2495,2496,7,4,0,0,2496,2497,7,5,0, + 0,2497,468,1,0,0,0,2498,2499,7,5,0,0,2499,2500,7,4,0,0,2500,2501, + 7,15,0,0,2501,2502,7,17,0,0,2502,2503,7,5,0,0,2503,2504,7,1,0,0, + 2504,2505,7,7,0,0,2505,2506,7,5,0,0,2506,2507,7,12,0,0,2507,2508, + 7,3,0,0,2508,2509,7,4,0,0,2509,2510,7,5,0,0,2510,470,1,0,0,0,2511, + 2512,7,5,0,0,2512,2513,7,4,0,0,2513,2514,7,15,0,0,2514,2515,7,17, + 0,0,2515,2516,7,13,0,0,2516,2517,7,4,0,0,2517,2518,7,5,0,0,2518, + 472,1,0,0,0,2519,2520,7,5,0,0,2520,2521,7,4,0,0,2521,2522,7,1,0, + 0,2522,2523,7,14,0,0,2523,2524,7,15,0,0,2524,2525,7,4,0,0,2525,474, + 1,0,0,0,2526,2527,7,5,0,0,2527,2528,7,4,0,0,2528,2529,7,2,0,0,2529, + 2530,7,4,0,0,2530,2531,7,5,0,0,2531,2532,7,4,0,0,2532,2533,7,10, + 0,0,2533,2534,7,15,0,0,2534,2535,7,4,0,0,2535,2536,7,9,0,0,2536, + 476,1,0,0,0,2537,2538,7,5,0,0,2538,2539,7,4,0,0,2539,2540,7,2,0, + 0,2540,2541,7,5,0,0,2541,2542,7,4,0,0,2542,2543,7,9,0,0,2543,2544, + 7,16,0,0,2544,478,1,0,0,0,2545,2546,7,5,0,0,2546,2547,7,4,0,0,2547, + 2548,7,10,0,0,2548,2549,7,0,0,0,2549,2550,7,21,0,0,2550,2551,7,4, + 0,0,2551,480,1,0,0,0,2552,2553,7,5,0,0,2553,2554,7,4,0,0,2554,2555, + 7,22,0,0,2555,2556,7,0,0,0,2556,2557,7,12,0,0,2557,2558,7,5,0,0, + 2558,482,1,0,0,0,2559,2560,7,5,0,0,2560,2561,7,4,0,0,2561,2562,7, + 22,0,0,2562,2563,7,4,0,0,2563,2564,7,0,0,0,2564,2565,7,3,0,0,2565, + 2566,7,0,0,0,2566,2567,7,18,0,0,2567,2568,7,6,0,0,2568,2569,7,4, + 0,0,2569,484,1,0,0,0,2570,2571,7,5,0,0,2571,2572,7,4,0,0,2572,2573, + 7,22,0,0,2573,2574,7,6,0,0,2574,2575,7,0,0,0,2575,2576,7,15,0,0, + 2576,2577,7,4,0,0,2577,486,1,0,0,0,2578,2579,7,5,0,0,2579,2580,7, + 4,0,0,2580,2581,7,9,0,0,2581,2582,7,4,0,0,2582,2583,7,3,0,0,2583, + 488,1,0,0,0,2584,2585,7,5,0,0,2585,2586,7,4,0,0,2586,2587,7,9,0, + 0,2587,2588,7,22,0,0,2588,2589,7,4,0,0,2589,2590,7,15,0,0,2590,2591, + 7,3,0,0,2591,490,1,0,0,0,2592,2593,7,5,0,0,2593,2594,7,4,0,0,2594, + 2595,7,9,0,0,2595,2596,7,3,0,0,2596,2597,7,5,0,0,2597,2598,7,12, + 0,0,2598,2599,7,15,0,0,2599,2600,7,3,0,0,2600,492,1,0,0,0,2601,2602, + 7,5,0,0,2602,2603,7,4,0,0,2603,2604,7,7,0,0,2604,2605,7,5,0,0,2605, + 2606,7,12,0,0,2606,2607,7,3,0,0,2607,2608,7,4,0,0,2608,494,1,0,0, + 0,2609,2610,7,5,0,0,2610,2611,7,4,0,0,2611,2612,7,13,0,0,2612,2613, + 7,17,0,0,2613,2614,7,20,0,0,2614,2615,7,4,0,0,2615,496,1,0,0,0,2616, + 2617,7,5,0,0,2617,2618,7,12,0,0,2618,2619,7,19,0,0,2619,2620,7,16, + 0,0,2620,2621,7,3,0,0,2621,498,1,0,0,0,2622,2623,7,5,0,0,2623,2624, + 7,6,0,0,2624,2625,7,12,0,0,2625,2626,7,20,0,0,2626,2627,7,4,0,0, + 2627,500,1,0,0,0,2628,2629,7,5,0,0,2629,2630,7,4,0,0,2630,2631,7, + 19,0,0,2631,2632,7,4,0,0,2632,2633,7,23,0,0,2633,2634,7,22,0,0,2634, + 502,1,0,0,0,2635,2636,7,5,0,0,2636,2637,7,17,0,0,2637,2638,7,6,0, + 0,2638,2639,7,4,0,0,2639,504,1,0,0,0,2640,2641,7,5,0,0,2641,2642, + 7,17,0,0,2642,2643,7,6,0,0,2643,2644,7,4,0,0,2644,2645,7,9,0,0,2645, + 506,1,0,0,0,2646,2647,7,5,0,0,2647,2648,7,17,0,0,2648,2649,7,6,0, + 0,2649,2650,7,6,0,0,2650,2651,7,18,0,0,2651,2652,7,0,0,0,2652,2653, + 7,15,0,0,2653,2654,7,20,0,0,2654,508,1,0,0,0,2655,2656,7,5,0,0,2656, + 2657,7,17,0,0,2657,2658,7,6,0,0,2658,2659,7,6,0,0,2659,2660,7,14, + 0,0,2660,2661,7,22,0,0,2661,510,1,0,0,0,2662,2663,7,5,0,0,2663,2664, + 7,17,0,0,2664,2665,7,7,0,0,2665,512,1,0,0,0,2666,2667,7,5,0,0,2667, + 2668,7,17,0,0,2668,2669,7,7,0,0,2669,2670,7,9,0,0,2670,514,1,0,0, + 0,2671,2672,7,9,0,0,2672,2673,7,4,0,0,2673,2674,7,15,0,0,2674,2675, + 7,17,0,0,2675,2676,7,10,0,0,2676,2677,7,1,0,0,2677,516,1,0,0,0,2678, + 2679,7,9,0,0,2679,2680,7,4,0,0,2680,2681,7,15,0,0,2681,2682,7,17, + 0,0,2682,2683,7,10,0,0,2683,2684,7,1,0,0,2684,2685,7,9,0,0,2685, + 518,1,0,0,0,2686,2687,7,9,0,0,2687,2688,7,15,0,0,2688,2689,7,16, + 0,0,2689,2690,7,4,0,0,2690,2691,7,21,0,0,2691,2692,7,0,0,0,2692, + 520,1,0,0,0,2693,2694,7,9,0,0,2694,2695,7,15,0,0,2695,2696,7,16, + 0,0,2696,2697,7,4,0,0,2697,2698,7,21,0,0,2698,2699,7,0,0,0,2699, + 2700,7,9,0,0,2700,522,1,0,0,0,2701,2702,7,9,0,0,2702,2703,7,4,0, + 0,2703,2704,7,6,0,0,2704,2705,7,4,0,0,2705,2706,7,15,0,0,2706,2707, + 7,3,0,0,2707,524,1,0,0,0,2708,2709,7,9,0,0,2709,2710,7,4,0,0,2710, + 2711,7,21,0,0,2711,2712,7,12,0,0,2712,526,1,0,0,0,2713,2714,7,9, + 0,0,2714,2715,7,4,0,0,2715,2716,7,22,0,0,2716,2717,7,0,0,0,2717, + 2718,7,5,0,0,2718,2719,7,0,0,0,2719,2720,7,3,0,0,2720,2721,7,4,0, + 0,2721,2722,7,1,0,0,2722,528,1,0,0,0,2723,2724,7,9,0,0,2724,2725, + 7,4,0,0,2725,2726,7,5,0,0,2726,2727,7,1,0,0,2727,2728,7,4,0,0,2728, + 530,1,0,0,0,2729,2730,7,9,0,0,2730,2731,7,4,0,0,2731,2732,7,5,0, + 0,2732,2733,7,1,0,0,2733,2734,7,4,0,0,2734,2735,7,22,0,0,2735,2736, + 7,5,0,0,2736,2737,7,17,0,0,2737,2738,7,22,0,0,2738,2739,7,4,0,0, + 2739,2740,7,5,0,0,2740,2741,7,3,0,0,2741,2742,7,12,0,0,2742,2743, + 7,4,0,0,2743,2744,7,9,0,0,2744,532,1,0,0,0,2745,2746,7,9,0,0,2746, + 2747,7,4,0,0,2747,2748,7,9,0,0,2748,2749,7,9,0,0,2749,2750,7,12, + 0,0,2750,2751,7,17,0,0,2751,2752,7,10,0,0,2752,2753,5,95,0,0,2753, + 2754,7,14,0,0,2754,2755,7,9,0,0,2755,2756,7,4,0,0,2756,2757,7,5, + 0,0,2757,534,1,0,0,0,2758,2759,7,9,0,0,2759,2760,7,4,0,0,2760,2761, + 7,3,0,0,2761,536,1,0,0,0,2762,2763,7,21,0,0,2763,2764,7,12,0,0,2764, + 2765,7,10,0,0,2765,2766,7,14,0,0,2766,2767,7,9,0,0,2767,538,1,0, + 0,0,2768,2769,7,9,0,0,2769,2770,7,4,0,0,2770,2771,7,3,0,0,2771,2772, + 7,9,0,0,2772,540,1,0,0,0,2773,2774,7,9,0,0,2774,2775,7,16,0,0,2775, + 2776,7,17,0,0,2776,2777,7,5,0,0,2777,2778,7,3,0,0,2778,542,1,0,0, + 0,2779,2780,7,9,0,0,2780,2781,7,16,0,0,2781,2782,7,17,0,0,2782,2783, + 7,7,0,0,2783,544,1,0,0,0,2784,2785,7,9,0,0,2785,2786,7,12,0,0,2786, + 2787,7,10,0,0,2787,2788,7,19,0,0,2788,2789,7,6,0,0,2789,2790,7,4, + 0,0,2790,546,1,0,0,0,2791,2792,7,9,0,0,2792,2793,7,20,0,0,2793,2794, + 7,4,0,0,2794,2795,7,7,0,0,2795,2796,7,4,0,0,2796,2797,7,1,0,0,2797, + 548,1,0,0,0,2798,2799,7,9,0,0,2799,2800,7,21,0,0,2800,2801,7,0,0, + 0,2801,2802,7,6,0,0,2802,2803,7,6,0,0,2803,2804,7,12,0,0,2804,2805, + 7,10,0,0,2805,2806,7,3,0,0,2806,550,1,0,0,0,2807,2808,7,9,0,0,2808, + 2809,7,17,0,0,2809,2810,7,21,0,0,2810,2811,7,4,0,0,2811,552,1,0, + 0,0,2812,2813,7,9,0,0,2813,2814,7,17,0,0,2814,2815,7,5,0,0,2815, + 2816,7,3,0,0,2816,554,1,0,0,0,2817,2818,7,9,0,0,2818,2819,7,17,0, + 0,2819,2820,7,5,0,0,2820,2821,7,3,0,0,2821,2822,7,4,0,0,2822,2823, + 7,1,0,0,2823,556,1,0,0,0,2824,2825,7,9,0,0,2825,2826,7,17,0,0,2826, + 2827,7,14,0,0,2827,2828,7,5,0,0,2828,2829,7,15,0,0,2829,2830,7,4, + 0,0,2830,558,1,0,0,0,2831,2832,7,9,0,0,2832,2833,7,3,0,0,2833,2834, + 7,0,0,0,2834,2835,7,5,0,0,2835,2836,7,3,0,0,2836,560,1,0,0,0,2837, + 2838,7,9,0,0,2838,2839,7,3,0,0,2839,2840,7,0,0,0,2840,2841,7,3,0, + 0,2841,2842,7,12,0,0,2842,2843,7,9,0,0,2843,2844,7,3,0,0,2844,2845, + 7,12,0,0,2845,2846,7,15,0,0,2846,2847,7,9,0,0,2847,562,1,0,0,0,2848, + 2849,7,9,0,0,2849,2850,7,3,0,0,2850,2851,7,17,0,0,2851,2852,7,5, + 0,0,2852,2853,7,4,0,0,2853,2854,7,1,0,0,2854,564,1,0,0,0,2855,2856, + 7,9,0,0,2856,2857,7,3,0,0,2857,2858,7,5,0,0,2858,2859,7,0,0,0,2859, + 2860,7,3,0,0,2860,2861,7,12,0,0,2861,2862,7,2,0,0,2862,2863,7,8, + 0,0,2863,566,1,0,0,0,2864,2865,7,9,0,0,2865,2866,7,3,0,0,2866,2867, + 7,5,0,0,2867,2868,7,12,0,0,2868,2869,7,10,0,0,2869,2870,7,19,0,0, + 2870,568,1,0,0,0,2871,2872,7,9,0,0,2872,2873,7,3,0,0,2873,2874,7, + 5,0,0,2874,2875,7,14,0,0,2875,2876,7,15,0,0,2876,2877,7,3,0,0,2877, + 570,1,0,0,0,2878,2879,7,9,0,0,2879,2880,7,14,0,0,2880,2881,7,18, + 0,0,2881,2882,7,9,0,0,2882,2883,7,3,0,0,2883,2884,7,5,0,0,2884,572, + 1,0,0,0,2885,2886,7,9,0,0,2886,2887,7,14,0,0,2887,2888,7,18,0,0, + 2888,2889,7,9,0,0,2889,2890,7,3,0,0,2890,2891,7,5,0,0,2891,2892, + 7,12,0,0,2892,2893,7,10,0,0,2893,2894,7,19,0,0,2894,574,1,0,0,0, + 2895,2896,7,9,0,0,2896,2897,7,8,0,0,2897,2898,7,10,0,0,2898,2899, + 7,15,0,0,2899,576,1,0,0,0,2900,2901,7,9,0,0,2901,2902,7,8,0,0,2902, + 2903,7,9,0,0,2903,2904,7,3,0,0,2904,2905,7,4,0,0,2905,2906,7,21, + 0,0,2906,578,1,0,0,0,2907,2908,7,9,0,0,2908,2909,7,8,0,0,2909,2910, + 7,9,0,0,2910,2911,7,3,0,0,2911,2912,7,4,0,0,2912,2913,7,21,0,0,2913, + 2914,5,95,0,0,2914,2915,7,3,0,0,2915,2916,7,12,0,0,2916,2917,7,21, + 0,0,2917,2918,7,4,0,0,2918,580,1,0,0,0,2919,2920,7,9,0,0,2920,2921, + 7,8,0,0,2921,2922,7,9,0,0,2922,2923,7,3,0,0,2923,2924,7,4,0,0,2924, + 2925,7,21,0,0,2925,2926,5,95,0,0,2926,2927,7,13,0,0,2927,2928,7, + 4,0,0,2928,2929,7,5,0,0,2929,2930,7,9,0,0,2930,2931,7,12,0,0,2931, + 2932,7,17,0,0,2932,2933,7,10,0,0,2933,582,1,0,0,0,2934,2935,7,3, + 0,0,2935,2936,7,0,0,0,2936,2937,7,18,0,0,2937,2938,7,6,0,0,2938, + 2939,7,4,0,0,2939,584,1,0,0,0,2940,2941,7,3,0,0,2941,2942,7,0,0, + 0,2942,2943,7,18,0,0,2943,2944,7,6,0,0,2944,2945,7,4,0,0,2945,2946, + 7,9,0,0,2946,586,1,0,0,0,2947,2948,7,3,0,0,2948,2949,7,0,0,0,2949, + 2950,7,18,0,0,2950,2951,7,6,0,0,2951,2952,7,4,0,0,2952,2953,7,9, + 0,0,2953,2954,7,0,0,0,2954,2955,7,21,0,0,2955,2956,7,22,0,0,2956, + 2957,7,6,0,0,2957,2958,7,4,0,0,2958,588,1,0,0,0,2959,2960,7,3,0, + 0,2960,2961,7,0,0,0,2961,2962,7,5,0,0,2962,2963,7,19,0,0,2963,2964, + 7,4,0,0,2964,2965,7,3,0,0,2965,590,1,0,0,0,2966,2967,7,3,0,0,2967, + 2968,7,18,0,0,2968,2969,7,6,0,0,2969,2970,7,22,0,0,2970,2971,7,5, + 0,0,2971,2972,7,17,0,0,2972,2973,7,22,0,0,2973,2974,7,4,0,0,2974, + 2975,7,5,0,0,2975,2976,7,3,0,0,2976,2977,7,12,0,0,2977,2978,7,4, + 0,0,2978,2979,7,9,0,0,2979,592,1,0,0,0,2980,2981,7,3,0,0,2981,2982, + 7,4,0,0,2982,2983,7,21,0,0,2983,2984,7,22,0,0,2984,2985,7,17,0,0, + 2985,2986,7,5,0,0,2986,2987,7,0,0,0,2987,2988,7,5,0,0,2988,2989, + 7,8,0,0,2989,594,1,0,0,0,2990,2991,7,3,0,0,2991,2992,7,4,0,0,2992, + 2993,7,5,0,0,2993,2994,7,21,0,0,2994,2995,7,12,0,0,2995,2996,7,10, + 0,0,2996,2997,7,0,0,0,2997,2998,7,3,0,0,2998,2999,7,4,0,0,2999,3000, + 7,1,0,0,3000,596,1,0,0,0,3001,3002,7,3,0,0,3002,3003,7,16,0,0,3003, + 3004,7,4,0,0,3004,3005,7,10,0,0,3005,598,1,0,0,0,3006,3007,7,3,0, + 0,3007,3008,7,12,0,0,3008,3009,7,21,0,0,3009,3010,7,4,0,0,3010,600, + 1,0,0,0,3011,3012,7,3,0,0,3012,3013,7,12,0,0,3013,3014,7,21,0,0, + 3014,3015,7,4,0,0,3015,3016,7,1,0,0,3016,3017,7,12,0,0,3017,3018, + 7,2,0,0,3018,3019,7,2,0,0,3019,602,1,0,0,0,3020,3021,7,3,0,0,3021, + 3022,7,12,0,0,3022,3023,7,21,0,0,3023,3024,7,4,0,0,3024,3025,7,9, + 0,0,3025,3026,7,3,0,0,3026,3027,7,0,0,0,3027,3028,7,21,0,0,3028, + 3029,7,22,0,0,3029,604,1,0,0,0,3030,3031,7,3,0,0,3031,3032,7,12, + 0,0,3032,3033,7,21,0,0,3033,3034,7,4,0,0,3034,3035,7,9,0,0,3035, + 3036,7,3,0,0,3036,3037,7,0,0,0,3037,3038,7,21,0,0,3038,3039,7,22, + 0,0,3039,3040,5,95,0,0,3040,3041,7,6,0,0,3041,3042,7,3,0,0,3042, + 3043,7,11,0,0,3043,606,1,0,0,0,3044,3045,7,3,0,0,3045,3046,7,12, + 0,0,3046,3047,7,21,0,0,3047,3048,7,4,0,0,3048,3049,7,9,0,0,3049, + 3050,7,3,0,0,3050,3051,7,0,0,0,3051,3052,7,21,0,0,3052,3053,7,22, + 0,0,3053,3054,5,95,0,0,3054,3055,7,10,0,0,3055,3056,7,3,0,0,3056, + 3057,7,11,0,0,3057,608,1,0,0,0,3058,3059,7,3,0,0,3059,3060,7,12, + 0,0,3060,3061,7,21,0,0,3061,3062,7,4,0,0,3062,3063,7,9,0,0,3063, + 3064,7,3,0,0,3064,3065,7,0,0,0,3065,3066,7,21,0,0,3066,3067,7,22, + 0,0,3067,3068,7,0,0,0,3068,3069,7,1,0,0,3069,3070,7,1,0,0,3070,610, + 1,0,0,0,3071,3072,7,3,0,0,3072,3073,7,12,0,0,3073,3074,7,21,0,0, + 3074,3075,7,4,0,0,3075,3076,7,9,0,0,3076,3077,7,3,0,0,3077,3078, + 7,0,0,0,3078,3079,7,21,0,0,3079,3080,7,22,0,0,3080,3081,7,1,0,0, + 3081,3082,7,12,0,0,3082,3083,7,2,0,0,3083,3084,7,2,0,0,3084,612, + 1,0,0,0,3085,3086,7,3,0,0,3086,3087,7,12,0,0,3087,3088,7,10,0,0, + 3088,3089,7,8,0,0,3089,3090,7,12,0,0,3090,3091,7,10,0,0,3091,3092, + 7,3,0,0,3092,614,1,0,0,0,3093,3094,7,3,0,0,3094,3095,7,17,0,0,3095, + 616,1,0,0,0,3096,3097,7,3,0,0,3097,3098,7,17,0,0,3098,3099,7,14, + 0,0,3099,3100,7,15,0,0,3100,3101,7,16,0,0,3101,618,1,0,0,0,3102, + 3103,7,3,0,0,3103,3104,7,5,0,0,3104,3105,7,0,0,0,3105,3106,7,12, + 0,0,3106,3107,7,6,0,0,3107,3108,7,12,0,0,3108,3109,7,10,0,0,3109, + 3110,7,19,0,0,3110,620,1,0,0,0,3111,3112,7,3,0,0,3112,3113,7,5,0, + 0,3113,3114,7,0,0,0,3114,3115,7,10,0,0,3115,3116,7,9,0,0,3116,3117, + 7,0,0,0,3117,3118,7,15,0,0,3118,3119,7,3,0,0,3119,3120,7,12,0,0, + 3120,3121,7,17,0,0,3121,3122,7,10,0,0,3122,622,1,0,0,0,3123,3124, + 7,3,0,0,3124,3125,7,5,0,0,3125,3126,7,0,0,0,3126,3127,7,10,0,0,3127, + 3128,7,9,0,0,3128,3129,7,0,0,0,3129,3130,7,15,0,0,3130,3131,7,3, + 0,0,3131,3132,7,12,0,0,3132,3133,7,17,0,0,3133,3134,7,10,0,0,3134, + 3135,7,9,0,0,3135,624,1,0,0,0,3136,3137,7,3,0,0,3137,3138,7,5,0, + 0,3138,3139,7,0,0,0,3139,3140,7,10,0,0,3140,3141,7,9,0,0,3141,3142, + 7,2,0,0,3142,3143,7,17,0,0,3143,3144,7,5,0,0,3144,3145,7,21,0,0, + 3145,626,1,0,0,0,3146,3147,7,3,0,0,3147,3148,7,5,0,0,3148,3149,7, + 12,0,0,3149,3150,7,21,0,0,3150,628,1,0,0,0,3151,3152,7,3,0,0,3152, + 3153,7,5,0,0,3153,3154,7,14,0,0,3154,3155,7,4,0,0,3155,630,1,0,0, + 0,3156,3157,7,3,0,0,3157,3158,7,5,0,0,3158,3159,7,14,0,0,3159,3160, + 7,10,0,0,3160,3161,7,15,0,0,3161,3162,7,0,0,0,3162,3163,7,3,0,0, + 3163,3164,7,4,0,0,3164,632,1,0,0,0,3165,3166,7,3,0,0,3166,3167,7, + 5,0,0,3167,3168,7,8,0,0,3168,3169,5,95,0,0,3169,3170,7,15,0,0,3170, + 3171,7,0,0,0,3171,3172,7,9,0,0,3172,3173,7,3,0,0,3173,634,1,0,0, + 0,3174,3175,7,3,0,0,3175,3176,7,8,0,0,3176,3177,7,22,0,0,3177,3178, + 7,4,0,0,3178,636,1,0,0,0,3179,3180,7,14,0,0,3180,3181,7,10,0,0,3181, + 3182,7,0,0,0,3182,3183,7,5,0,0,3183,3184,7,15,0,0,3184,3185,7,16, + 0,0,3185,3186,7,12,0,0,3186,3187,7,13,0,0,3187,3188,7,4,0,0,3188, + 638,1,0,0,0,3189,3190,7,14,0,0,3190,3191,7,10,0,0,3191,3192,7,18, + 0,0,3192,3193,7,17,0,0,3193,3194,7,14,0,0,3194,3195,7,10,0,0,3195, + 3196,7,1,0,0,3196,3197,7,4,0,0,3197,3198,7,1,0,0,3198,640,1,0,0, + 0,3199,3200,7,14,0,0,3200,3201,7,10,0,0,3201,3202,7,15,0,0,3202, + 3203,7,0,0,0,3203,3204,7,15,0,0,3204,3205,7,16,0,0,3205,3206,7,4, + 0,0,3206,642,1,0,0,0,3207,3208,7,14,0,0,3208,3209,7,10,0,0,3209, + 3210,7,12,0,0,3210,3211,7,17,0,0,3211,3212,7,10,0,0,3212,644,1,0, + 0,0,3213,3214,7,14,0,0,3214,3215,7,10,0,0,3215,3216,7,12,0,0,3216, + 3217,7,25,0,0,3217,3218,7,14,0,0,3218,3219,7,4,0,0,3219,646,1,0, + 0,0,3220,3221,7,14,0,0,3221,3222,7,10,0,0,3222,3223,7,20,0,0,3223, + 3224,7,10,0,0,3224,3225,7,17,0,0,3225,3226,7,7,0,0,3226,3227,7,10, + 0,0,3227,648,1,0,0,0,3228,3229,7,14,0,0,3229,3230,7,10,0,0,3230, + 3231,7,6,0,0,3231,3232,7,17,0,0,3232,3233,7,15,0,0,3233,3234,7,20, + 0,0,3234,650,1,0,0,0,3235,3236,7,14,0,0,3236,3237,7,10,0,0,3237, + 3238,7,22,0,0,3238,3239,7,12,0,0,3239,3240,7,13,0,0,3240,3241,7, + 17,0,0,3241,3242,7,3,0,0,3242,652,1,0,0,0,3243,3244,7,14,0,0,3244, + 3245,7,10,0,0,3245,3246,7,9,0,0,3246,3247,7,4,0,0,3247,3248,7,3, + 0,0,3248,654,1,0,0,0,3249,3250,7,14,0,0,3250,3251,7,22,0,0,3251, + 3252,7,1,0,0,3252,3253,7,0,0,0,3253,3254,7,3,0,0,3254,3255,7,4,0, + 0,3255,656,1,0,0,0,3256,3257,7,14,0,0,3257,3258,7,9,0,0,3258,3259, + 7,4,0,0,3259,658,1,0,0,0,3260,3261,7,14,0,0,3261,3262,7,9,0,0,3262, + 3263,7,4,0,0,3263,3264,7,5,0,0,3264,660,1,0,0,0,3265,3266,7,14,0, + 0,3266,3267,7,9,0,0,3267,3268,7,12,0,0,3268,3269,7,10,0,0,3269,3270, + 7,19,0,0,3270,662,1,0,0,0,3271,3272,7,13,0,0,3272,3273,7,0,0,0,3273, + 3274,7,6,0,0,3274,3275,7,14,0,0,3275,3276,7,4,0,0,3276,3277,7,9, + 0,0,3277,664,1,0,0,0,3278,3279,7,13,0,0,3279,3280,7,0,0,0,3280,3281, + 7,5,0,0,3281,3282,7,15,0,0,3282,3283,7,16,0,0,3283,3284,7,0,0,0, + 3284,3285,7,5,0,0,3285,666,1,0,0,0,3286,3287,7,13,0,0,3287,3288, + 7,0,0,0,3288,3289,7,5,0,0,3289,668,1,0,0,0,3290,3291,7,13,0,0,3291, + 3292,7,0,0,0,3292,3293,7,5,0,0,3293,3294,7,12,0,0,3294,3295,7,0, + 0,0,3295,3296,7,18,0,0,3296,3297,7,6,0,0,3297,3298,7,4,0,0,3298, + 670,1,0,0,0,3299,3300,7,13,0,0,3300,3301,7,4,0,0,3301,3302,7,5,0, + 0,3302,3303,7,9,0,0,3303,3304,7,12,0,0,3304,3305,7,17,0,0,3305,3306, + 7,10,0,0,3306,672,1,0,0,0,3307,3308,7,13,0,0,3308,3309,7,12,0,0, + 3309,3310,7,4,0,0,3310,3311,7,7,0,0,3311,674,1,0,0,0,3312,3313,7, + 13,0,0,3313,3314,7,12,0,0,3314,3315,7,4,0,0,3315,3316,7,7,0,0,3316, + 3317,7,9,0,0,3317,676,1,0,0,0,3318,3319,7,13,0,0,3319,3320,7,17, + 0,0,3320,3321,7,12,0,0,3321,3322,7,1,0,0,3322,678,1,0,0,0,3323,3324, + 7,7,0,0,3324,3325,7,4,0,0,3325,3326,7,4,0,0,3326,3327,7,20,0,0,3327, + 680,1,0,0,0,3328,3329,7,7,0,0,3329,3330,7,4,0,0,3330,3331,7,4,0, + 0,3331,3332,7,20,0,0,3332,3333,7,9,0,0,3333,682,1,0,0,0,3334,3335, + 7,7,0,0,3335,3336,7,16,0,0,3336,3337,7,4,0,0,3337,3338,7,10,0,0, + 3338,684,1,0,0,0,3339,3340,7,7,0,0,3340,3341,7,16,0,0,3341,3342, + 7,4,0,0,3342,3343,7,5,0,0,3343,3344,7,4,0,0,3344,686,1,0,0,0,3345, + 3346,7,7,0,0,3346,3347,7,12,0,0,3347,3348,7,10,0,0,3348,3349,7,1, + 0,0,3349,3350,7,17,0,0,3350,3351,7,7,0,0,3351,688,1,0,0,0,3352,3353, + 7,7,0,0,3353,3354,7,12,0,0,3354,3355,7,3,0,0,3355,3356,7,16,0,0, + 3356,690,1,0,0,0,3357,3358,7,7,0,0,3358,3359,7,12,0,0,3359,3360, + 7,3,0,0,3360,3361,7,16,0,0,3361,3362,7,12,0,0,3362,3363,7,10,0,0, + 3363,692,1,0,0,0,3364,3365,7,8,0,0,3365,3366,7,4,0,0,3366,3367,7, + 0,0,0,3367,3368,7,5,0,0,3368,694,1,0,0,0,3369,3370,7,8,0,0,3370, + 3371,7,4,0,0,3371,3372,7,0,0,0,3372,3373,7,5,0,0,3373,3374,7,9,0, + 0,3374,696,1,0,0,0,3375,3376,7,11,0,0,3376,3377,7,17,0,0,3377,3378, + 7,10,0,0,3378,3379,7,4,0,0,3379,698,1,0,0,0,3380,3381,7,11,0,0,3381, + 3382,7,17,0,0,3382,3383,7,5,0,0,3383,3384,7,1,0,0,3384,3385,7,4, + 0,0,3385,3386,7,5,0,0,3386,700,1,0,0,0,3387,3391,5,61,0,0,3388,3389, + 5,61,0,0,3389,3391,5,61,0,0,3390,3387,1,0,0,0,3390,3388,1,0,0,0, + 3391,702,1,0,0,0,3392,3393,5,60,0,0,3393,3394,5,61,0,0,3394,3395, + 5,62,0,0,3395,704,1,0,0,0,3396,3397,5,60,0,0,3397,3398,5,62,0,0, + 3398,706,1,0,0,0,3399,3400,5,33,0,0,3400,3401,5,61,0,0,3401,708, + 1,0,0,0,3402,3403,5,60,0,0,3403,710,1,0,0,0,3404,3405,5,60,0,0,3405, + 3409,5,61,0,0,3406,3407,5,33,0,0,3407,3409,5,62,0,0,3408,3404,1, + 0,0,0,3408,3406,1,0,0,0,3409,712,1,0,0,0,3410,3411,5,62,0,0,3411, + 714,1,0,0,0,3412,3413,5,62,0,0,3413,3417,5,61,0,0,3414,3415,5,33, + 0,0,3415,3417,5,60,0,0,3416,3412,1,0,0,0,3416,3414,1,0,0,0,3417, + 716,1,0,0,0,3418,3419,5,33,0,0,3419,718,1,0,0,0,3420,3421,5,43,0, + 0,3421,720,1,0,0,0,3422,3423,5,45,0,0,3423,722,1,0,0,0,3424,3425, + 5,42,0,0,3425,724,1,0,0,0,3426,3427,5,47,0,0,3427,726,1,0,0,0,3428, + 3429,5,37,0,0,3429,728,1,0,0,0,3430,3431,5,126,0,0,3431,730,1,0, + 0,0,3432,3433,5,38,0,0,3433,732,1,0,0,0,3434,3435,5,124,0,0,3435, + 734,1,0,0,0,3436,3437,5,124,0,0,3437,3438,5,124,0,0,3438,736,1,0, + 0,0,3439,3440,5,94,0,0,3440,738,1,0,0,0,3441,3442,5,58,0,0,3442, + 740,1,0,0,0,3443,3444,5,45,0,0,3444,3445,5,62,0,0,3445,742,1,0,0, + 0,3446,3447,5,61,0,0,3447,3448,5,62,0,0,3448,744,1,0,0,0,3449,3450, + 5,47,0,0,3450,3451,5,42,0,0,3451,3452,5,43,0,0,3452,746,1,0,0,0, + 3453,3454,5,42,0,0,3454,3455,5,47,0,0,3455,748,1,0,0,0,3456,3457, + 5,63,0,0,3457,750,1,0,0,0,3458,3464,5,39,0,0,3459,3463,8,26,0,0, + 3460,3461,5,92,0,0,3461,3463,9,0,0,0,3462,3459,1,0,0,0,3462,3460, + 1,0,0,0,3463,3466,1,0,0,0,3464,3462,1,0,0,0,3464,3465,1,0,0,0,3465, + 3467,1,0,0,0,3466,3464,1,0,0,0,3467,3489,5,39,0,0,3468,3469,7,5, + 0,0,3469,3470,5,39,0,0,3470,3474,1,0,0,0,3471,3473,8,27,0,0,3472, + 3471,1,0,0,0,3473,3476,1,0,0,0,3474,3472,1,0,0,0,3474,3475,1,0,0, + 0,3475,3477,1,0,0,0,3476,3474,1,0,0,0,3477,3489,5,39,0,0,3478,3479, + 7,5,0,0,3479,3480,5,34,0,0,3480,3484,1,0,0,0,3481,3483,8,28,0,0, + 3482,3481,1,0,0,0,3483,3486,1,0,0,0,3484,3482,1,0,0,0,3484,3485, + 1,0,0,0,3485,3487,1,0,0,0,3486,3484,1,0,0,0,3487,3489,5,34,0,0,3488, + 3458,1,0,0,0,3488,3468,1,0,0,0,3488,3478,1,0,0,0,3489,752,1,0,0, + 0,3490,3496,5,34,0,0,3491,3495,8,29,0,0,3492,3493,5,92,0,0,3493, + 3495,9,0,0,0,3494,3491,1,0,0,0,3494,3492,1,0,0,0,3495,3498,1,0,0, + 0,3496,3494,1,0,0,0,3496,3497,1,0,0,0,3497,3499,1,0,0,0,3498,3496, + 1,0,0,0,3499,3500,5,34,0,0,3500,754,1,0,0,0,3501,3503,3,781,390, + 0,3502,3501,1,0,0,0,3503,3504,1,0,0,0,3504,3502,1,0,0,0,3504,3505, + 1,0,0,0,3505,3506,1,0,0,0,3506,3507,7,6,0,0,3507,756,1,0,0,0,3508, + 3510,3,781,390,0,3509,3508,1,0,0,0,3510,3511,1,0,0,0,3511,3509,1, + 0,0,0,3511,3512,1,0,0,0,3512,3513,1,0,0,0,3513,3514,7,9,0,0,3514, + 758,1,0,0,0,3515,3517,3,781,390,0,3516,3515,1,0,0,0,3517,3518,1, + 0,0,0,3518,3516,1,0,0,0,3518,3519,1,0,0,0,3519,3520,1,0,0,0,3520, + 3521,7,8,0,0,3521,760,1,0,0,0,3522,3524,3,781,390,0,3523,3522,1, + 0,0,0,3524,3525,1,0,0,0,3525,3523,1,0,0,0,3525,3526,1,0,0,0,3526, + 762,1,0,0,0,3527,3529,3,781,390,0,3528,3527,1,0,0,0,3529,3530,1, + 0,0,0,3530,3528,1,0,0,0,3530,3531,1,0,0,0,3531,3532,1,0,0,0,3532, + 3533,3,779,389,0,3533,3538,1,0,0,0,3534,3535,3,777,388,0,3535,3536, + 3,779,389,0,3536,3538,1,0,0,0,3537,3528,1,0,0,0,3537,3534,1,0,0, + 0,3538,764,1,0,0,0,3539,3540,3,777,388,0,3540,766,1,0,0,0,3541,3543, + 3,781,390,0,3542,3541,1,0,0,0,3543,3544,1,0,0,0,3544,3542,1,0,0, + 0,3544,3545,1,0,0,0,3545,3547,1,0,0,0,3546,3548,3,779,389,0,3547, + 3546,1,0,0,0,3547,3548,1,0,0,0,3548,3549,1,0,0,0,3549,3550,7,2,0, + 0,3550,3558,1,0,0,0,3551,3553,3,777,388,0,3552,3554,3,779,389,0, + 3553,3552,1,0,0,0,3553,3554,1,0,0,0,3554,3555,1,0,0,0,3555,3556, + 7,2,0,0,3556,3558,1,0,0,0,3557,3542,1,0,0,0,3557,3551,1,0,0,0,3558, + 768,1,0,0,0,3559,3561,3,781,390,0,3560,3559,1,0,0,0,3561,3562,1, + 0,0,0,3562,3560,1,0,0,0,3562,3563,1,0,0,0,3563,3565,1,0,0,0,3564, + 3566,3,779,389,0,3565,3564,1,0,0,0,3565,3566,1,0,0,0,3566,3567,1, + 0,0,0,3567,3568,7,1,0,0,3568,3576,1,0,0,0,3569,3571,3,777,388,0, + 3570,3572,3,779,389,0,3571,3570,1,0,0,0,3571,3572,1,0,0,0,3572,3573, + 1,0,0,0,3573,3574,7,1,0,0,3574,3576,1,0,0,0,3575,3560,1,0,0,0,3575, + 3569,1,0,0,0,3576,770,1,0,0,0,3577,3579,3,781,390,0,3578,3577,1, + 0,0,0,3579,3580,1,0,0,0,3580,3578,1,0,0,0,3580,3581,1,0,0,0,3581, + 3583,1,0,0,0,3582,3584,3,779,389,0,3583,3582,1,0,0,0,3583,3584,1, + 0,0,0,3584,3585,1,0,0,0,3585,3586,7,18,0,0,3586,3587,7,1,0,0,3587, + 3596,1,0,0,0,3588,3590,3,777,388,0,3589,3591,3,779,389,0,3590,3589, + 1,0,0,0,3590,3591,1,0,0,0,3591,3592,1,0,0,0,3592,3593,7,18,0,0,3593, + 3594,7,1,0,0,3594,3596,1,0,0,0,3595,3578,1,0,0,0,3595,3588,1,0,0, + 0,3596,772,1,0,0,0,3597,3601,3,783,391,0,3598,3601,3,781,390,0,3599, + 3601,5,95,0,0,3600,3597,1,0,0,0,3600,3598,1,0,0,0,3600,3599,1,0, + 0,0,3601,3602,1,0,0,0,3602,3600,1,0,0,0,3602,3603,1,0,0,0,3603,774, + 1,0,0,0,3604,3610,5,96,0,0,3605,3609,8,30,0,0,3606,3607,5,96,0,0, + 3607,3609,5,96,0,0,3608,3605,1,0,0,0,3608,3606,1,0,0,0,3609,3612, + 1,0,0,0,3610,3608,1,0,0,0,3610,3611,1,0,0,0,3611,3613,1,0,0,0,3612, + 3610,1,0,0,0,3613,3614,5,96,0,0,3614,776,1,0,0,0,3615,3617,3,781, + 390,0,3616,3615,1,0,0,0,3617,3618,1,0,0,0,3618,3616,1,0,0,0,3618, + 3619,1,0,0,0,3619,3620,1,0,0,0,3620,3624,5,46,0,0,3621,3623,3,781, + 390,0,3622,3621,1,0,0,0,3623,3626,1,0,0,0,3624,3622,1,0,0,0,3624, + 3625,1,0,0,0,3625,3634,1,0,0,0,3626,3624,1,0,0,0,3627,3629,5,46, + 0,0,3628,3630,3,781,390,0,3629,3628,1,0,0,0,3630,3631,1,0,0,0,3631, + 3629,1,0,0,0,3631,3632,1,0,0,0,3632,3634,1,0,0,0,3633,3616,1,0,0, + 0,3633,3627,1,0,0,0,3634,778,1,0,0,0,3635,3637,7,4,0,0,3636,3638, + 7,31,0,0,3637,3636,1,0,0,0,3637,3638,1,0,0,0,3638,3640,1,0,0,0,3639, + 3641,3,781,390,0,3640,3639,1,0,0,0,3641,3642,1,0,0,0,3642,3640,1, + 0,0,0,3642,3643,1,0,0,0,3643,780,1,0,0,0,3644,3645,7,32,0,0,3645, + 782,1,0,0,0,3646,3647,7,33,0,0,3647,784,1,0,0,0,3648,3649,5,45,0, + 0,3649,3650,5,45,0,0,3650,3656,1,0,0,0,3651,3652,5,92,0,0,3652,3655, + 5,10,0,0,3653,3655,8,34,0,0,3654,3651,1,0,0,0,3654,3653,1,0,0,0, + 3655,3658,1,0,0,0,3656,3654,1,0,0,0,3656,3657,1,0,0,0,3657,3660, + 1,0,0,0,3658,3656,1,0,0,0,3659,3661,5,13,0,0,3660,3659,1,0,0,0,3660, + 3661,1,0,0,0,3661,3663,1,0,0,0,3662,3664,5,10,0,0,3663,3662,1,0, + 0,0,3663,3664,1,0,0,0,3664,3665,1,0,0,0,3665,3666,6,392,0,0,3666, + 786,1,0,0,0,3667,3668,5,47,0,0,3668,3669,5,42,0,0,3669,3674,1,0, + 0,0,3670,3673,3,787,393,0,3671,3673,9,0,0,0,3672,3670,1,0,0,0,3672, + 3671,1,0,0,0,3673,3676,1,0,0,0,3674,3675,1,0,0,0,3674,3672,1,0,0, + 0,3675,3681,1,0,0,0,3676,3674,1,0,0,0,3677,3678,5,42,0,0,3678,3682, + 5,47,0,0,3679,3680,6,393,1,0,3680,3682,5,0,0,1,3681,3677,1,0,0,0, + 3681,3679,1,0,0,0,3682,3683,1,0,0,0,3683,3684,6,393,0,0,3684,788, + 1,0,0,0,3685,3687,7,35,0,0,3686,3685,1,0,0,0,3687,3688,1,0,0,0,3688, + 3686,1,0,0,0,3688,3689,1,0,0,0,3689,3690,1,0,0,0,3690,3691,6,394, + 0,0,3691,790,1,0,0,0,3692,3693,9,0,0,0,3693,792,1,0,0,0,47,0,3390, + 3408,3416,3462,3464,3474,3484,3488,3494,3496,3504,3511,3518,3525, + 3530,3537,3544,3547,3553,3557,3562,3565,3571,3575,3580,3583,3590, + 3595,3600,3602,3608,3610,3618,3624,3631,3633,3637,3642,3654,3656, + 3660,3663,3672,3674,3681,3688,2,0,1,0,1,393,0 + ]; + + private static __ATN: antlr.ATN; + public static get _ATN(): antlr.ATN { + if (!SqlLexer.__ATN) { + SqlLexer.__ATN = new antlr.ATNDeserializer().deserialize(SqlLexer._serializedATN); + } + + return SqlLexer.__ATN; + } + + + private static readonly vocabulary = new antlr.Vocabulary(SqlLexer.literalNames, SqlLexer.symbolicNames, []); + + public override get vocabulary(): antlr.Vocabulary { + return SqlLexer.vocabulary; + } + + private static readonly decisionsToDFA = SqlLexer._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) ); +} \ No newline at end of file diff --git a/src/lib/sql/SqlParser.interp b/src/lib/sql/SqlParser.interp new file mode 100644 index 00000000..bd267ba9 --- /dev/null +++ b/src/lib/sql/SqlParser.interp @@ -0,0 +1,966 @@ +token literal names: +null +';' +'(' +')' +',' +'.' +'[' +']' +'ADD' +'AFTER' +'ALL' +'ALTER' +'ALWAYS' +'ANALYZE' +'AND' +'ANTI' +'ANY' +'ANY_VALUE' +'ARCHIVE' +'ARRAY' +'AS' +'ASC' +'AT' +'AUTHORIZATION' +'BETWEEN' +'BIGINT' +'BINARY' +'BOOLEAN' +'BOTH' +'BUCKET' +'BUCKETS' +'BY' +'BYTE' +'CACHE' +'CASCADE' +'CASE' +'CAST' +'CATALOG' +'CATALOGS' +'CHANGE' +'CHAR' +'CHARACTER' +'CHECK' +'CLEAR' +'CLUSTER' +'CLUSTERED' +'CODEGEN' +'COLLATE' +'COLLECTION' +'COLUMN' +'COLUMNS' +'COMMENT' +'COMMIT' +'COMPACT' +'COMPACTIONS' +'COMPUTE' +'CONCATENATE' +'CONSTRAINT' +'COST' +'CREATE' +'CROSS' +'CUBE' +'CURRENT' +'CURRENT_DATE' +'CURRENT_TIME' +'CURRENT_TIMESTAMP' +'CURRENT_USER' +'DAY' +'DAYS' +'DAYOFYEAR' +'DATA' +'DATE' +'DATABASE' +'DATABASES' +'DATEADD' +'DATE_ADD' +'DATEDIFF' +'DATE_DIFF' +'DBPROPERTIES' +'DEC' +'DECIMAL' +'DECLARE' +'DEFAULT' +'DEFINED' +'DELETE' +'DELIMITED' +'DESC' +'DESCRIBE' +'DFS' +'DIRECTORIES' +'DIRECTORY' +'DISABLE' +'DISTINCT' +'DISTRIBUTE' +'DIV' +'DOUBLE' +'DROP' +'ELSE' +'ENABLE' +'END' +'ESCAPE' +'ESCAPED' +'EXCEPT' +'EXCHANGE' +'EXCLUDE' +'EXISTS' +'EXPLAIN' +'EXPORT' +'EXTENDED' +'EXTERNAL' +'EXTRACT' +'FALSE' +'FETCH' +'FIELDS' +'FILTER' +'FILEFORMAT' +'FIRST' +'FLOAT' +'FOLLOWING' +'FOR' +'FOREIGN' +'FORMAT' +'FORMATTED' +'FROM' +'FULL' +'FUNCTION' +'FUNCTIONS' +'GENERATED' +'GLOBAL' +'GRANT' +'GROUP' +'GROUPING' +'HAVING' +'X' +'HOUR' +'HOURS' +'IDENTIFIER' +'IF' +'IGNORE' +'IMPORT' +'IN' +'INCLUDE' +'INDEX' +'INDEXES' +'INNER' +'INPATH' +'INPUTFORMAT' +'INSERT' +'INTERSECT' +'INTERVAL' +'INT' +'INTEGER' +'INTO' +'IS' +'ITEMS' +'JOIN' +'KEYS' +'LAST' +'LATERAL' +'LAZY' +'LEADING' +'LEFT' +'LIFECYCLE' +'LIKE' +'ILIKE' +'LIMIT' +'LINES' +'LIST' +'LOAD' +'LOCAL' +'LOCATION' +'LOCK' +'LOCKS' +'LOGICAL' +'LONG' +'MACRO' +'MAP' +'MATCHED' +'MERGE' +'MICROSECOND' +'MICROSECONDS' +'MILLISECOND' +'MILLISECONDS' +'MINUTE' +'MINUTES' +'MONTH' +'MONTHS' +'MSCK' +'NAME' +'NAMESPACE' +'NAMESPACES' +'NANOSECOND' +'NANOSECONDS' +'NATURAL' +'NO' +'NOSCAN' +'NOT' +'NULL' +'NULLS' +'NUMERIC' +'OF' +'OFFSET' +'ON' +'ONLY' +'OPTIMIZE' +'OPTION' +'OPTIONS' +'OR' +'ORDER' +'OUT' +'OUTER' +'OUTPUTFORMAT' +'OVER' +'OVERLAPS' +'OVERLAY' +'OVERWRITE' +'PARTITION' +'PARTITIONED' +'PARTITIONS' +'PERCENTILE_CONT' +'PERCENTILE_DISC' +'PERCENT' +'PIVOT' +'PLACING' +'POSITION' +'PRECEDING' +'PRIMARY' +'PRINCIPALS' +'PROPERTIES' +'PURGE' +'QUARTER' +'QUERY' +'RANGE' +'REAL' +'RECORDREADER' +'RECORDWRITER' +'RECOVER' +'REDUCE' +'REFERENCES' +'REFRESH' +'RENAME' +'REPAIR' +'REPEATABLE' +'REPLACE' +'RESET' +'RESPECT' +'RESTRICT' +'REWRITE' +'REVOKE' +'RIGHT' +'RLIKE' +'REGEXP' +'ROLE' +'ROLES' +'ROLLBACK' +'ROLLUP' +'ROW' +'ROWS' +'SECOND' +'SECONDS' +'SCHEMA' +'SCHEMAS' +'SELECT' +'SEMI' +'SEPARATED' +'SERDE' +'SERDEPROPERTIES' +'SESSION_USER' +'SET' +'MINUS' +'SETS' +'SHORT' +'SHOW' +'SINGLE' +'SKEWED' +'SMALLINT' +'SOME' +'SORT' +'SORTED' +'SOURCE' +'START' +'STATISTICS' +'STORED' +'STRATIFY' +'STRING' +'STRUCT' +'SUBSTR' +'SUBSTRING' +'SYNC' +'SYSTEM' +'SYSTEM_TIME' +'SYSTEM_VERSION' +'TABLE' +'TABLES' +'TABLESAMPLE' +'TARGET' +'TBLPROPERTIES' +'TEMPORARY' +'TERMINATED' +'THEN' +'TIME' +'TIMEDIFF' +'TIMESTAMP' +'TIMESTAMP_LTZ' +'TIMESTAMP_NTZ' +'TIMESTAMPADD' +'TIMESTAMPDIFF' +'TINYINT' +'TO' +'TOUCH' +'TRAILING' +'TRANSACTION' +'TRANSACTIONS' +'TRANSFORM' +'TRIM' +'TRUE' +'TRUNCATE' +'TRY_CAST' +'TYPE' +'UNARCHIVE' +'UNBOUNDED' +'UNCACHE' +'UNION' +'UNIQUE' +'UNKNOWN' +'UNLOCK' +'UNPIVOT' +'UNSET' +'UPDATE' +'USE' +'USER' +'USING' +'VALUES' +'VARCHAR' +'VAR' +'VARIABLE' +'VERSION' +'VIEW' +'VIEWS' +'VOID' +'WEEK' +'WEEKS' +'WHEN' +'WHERE' +'WINDOW' +'WITH' +'WITHIN' +'YEAR' +'YEARS' +'ZONE' +'ZORDER' +null +'<=>' +'<>' +'!=' +'<' +null +'>' +null +'!' +'+' +'-' +'*' +'/' +'%' +'~' +'&' +'|' +'||' +'^' +':' +'->' +'=>' +'/*+' +'*/' +'?' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +SEMICOLON +LEFT_PAREN +RIGHT_PAREN +COMMA +DOT +LEFT_BRACKET +RIGHT_BRACKET +KW_ADD +KW_AFTER +KW_ALL +KW_ALTER +KW_ALWAYS +KW_ANALYZE +KW_AND +KW_ANTI +KW_ANY +KW_ANY_VALUE +KW_ARCHIVE +KW_ARRAY +KW_AS +KW_ASC +KW_AT +KW_AUTHORIZATION +KW_BETWEEN +KW_BIGINT +KW_BINARY +KW_BOOLEAN +KW_BOTH +KW_BUCKET +KW_BUCKETS +KW_BY +KW_BYTE +KW_CACHE +KW_CASCADE +KW_CASE +KW_CAST +KW_CATALOG +KW_CATALOGS +KW_CHANGE +KW_CHAR +KW_CHARACTER +KW_CHECK +KW_CLEAR +KW_CLUSTER +KW_CLUSTERED +KW_CODEGEN +KW_COLLATE +KW_COLLECTION +KW_COLUMN +KW_COLUMNS +KW_COMMENT +KW_COMMIT +KW_COMPACT +KW_COMPACTIONS +KW_COMPUTE +KW_CONCATENATE +KW_CONSTRAINT +KW_COST +KW_CREATE +KW_CROSS +KW_CUBE +KW_CURRENT +KW_CURRENT_DATE +KW_CURRENT_TIME +KW_CURRENT_TIMESTAMP +KW_CURRENT_USER +KW_DAY +KW_DAYS +KW_DAYOFYEAR +KW_DATA +KW_DATE +KW_DATABASE +KW_DATABASES +KW_DATEADD +KW_DATE_ADD +KW_DATEDIFF +KW_DATE_DIFF +KW_DBPROPERTIES +KW_DEC +KW_DECIMAL +KW_DECLARE +KW_DEFAULT +KW_DEFINED +KW_DELETE +KW_DELIMITED +KW_DESC +KW_DESCRIBE +KW_DFS +KW_DIRECTORIES +KW_DIRECTORY +KW_DISABLE +KW_DISTINCT +KW_DISTRIBUTE +KW_DIV +KW_DOUBLE +KW_DROP +KW_ELSE +KW_ENABLE +KW_END +KW_ESCAPE +KW_ESCAPED +KW_EXCEPT +KW_EXCHANGE +KW_EXCLUDE +KW_EXISTS +KW_EXPLAIN +KW_EXPORT +KW_EXTENDED +KW_EXTERNAL +KW_EXTRACT +KW_FALSE +KW_FETCH +KW_FIELDS +KW_FILTER +KW_FILEFORMAT +KW_FIRST +KW_FLOAT +KW_FOLLOWING +KW_FOR +KW_FOREIGN +KW_FORMAT +KW_FORMATTED +KW_FROM +KW_FULL +KW_FUNCTION +KW_FUNCTIONS +KW_GENERATED +KW_GLOBAL +KW_GRANT +KW_GROUP +KW_GROUPING +KW_HAVING +KW_BINARY_HEX +KW_HOUR +KW_HOURS +KW_IDENTIFIER +KW_IF +KW_IGNORE +KW_IMPORT +KW_IN +KW_INCLUDE +KW_INDEX +KW_INDEXES +KW_INNER +KW_INPATH +KW_INPUTFORMAT +KW_INSERT +KW_INTERSECT +KW_INTERVAL +KW_INT +KW_INTEGER +KW_INTO +KW_IS +KW_ITEMS +KW_JOIN +KW_KEYS +KW_LAST +KW_LATERAL +KW_LAZY +KW_LEADING +KW_LEFT +KW_LIFECYCLE +KW_LIKE +KW_ILIKE +KW_LIMIT +KW_LINES +KW_LIST +KW_LOAD +KW_LOCAL +KW_LOCATION +KW_LOCK +KW_LOCKS +KW_LOGICAL +KW_LONG +KW_MACRO +KW_MAP +KW_MATCHED +KW_MERGE +KW_MICROSECOND +KW_MICROSECONDS +KW_MILLISECOND +KW_MILLISECONDS +KW_MINUTE +KW_MINUTES +KW_MONTH +KW_MONTHS +KW_MSCK +KW_NAME +KW_NAMESPACE +KW_NAMESPACES +KW_NANOSECOND +KW_NANOSECONDS +KW_NATURAL +KW_NO +KW_NOSCAN +KW_NOT +KW_NULL +KW_NULLS +KW_NUMERIC +KW_OF +KW_OFFSET +KW_ON +KW_ONLY +KW_OPTIMIZE +KW_OPTION +KW_OPTIONS +KW_OR +KW_ORDER +KW_OUT +KW_OUTER +KW_OUTPUTFORMAT +KW_OVER +KW_OVERLAPS +KW_OVERLAY +KW_OVERWRITE +KW_PARTITION +KW_PARTITIONED +KW_PARTITIONS +KW_PERCENTILE_CONT +KW_PERCENTILE_DISC +KW_PERCENTLIT +KW_PIVOT +KW_PLACING +KW_POSITION +KW_PRECEDING +KW_PRIMARY +KW_PRINCIPALS +KW_PROPERTIES +KW_PURGE +KW_QUARTER +KW_QUERY +KW_RANGE +KW_REAL +KW_RECORDREADER +KW_RECORDWRITER +KW_RECOVER +KW_REDUCE +KW_REFERENCES +KW_REFRESH +KW_RENAME +KW_REPAIR +KW_REPEATABLE +KW_REPLACE +KW_RESET +KW_RESPECT +KW_RESTRICT +KW_REWRITE +KW_REVOKE +KW_RIGHT +KW_RLIKE +KW_REGEXP +KW_ROLE +KW_ROLES +KW_ROLLBACK +KW_ROLLUP +KW_ROW +KW_ROWS +KW_SECOND +KW_SECONDS +KW_SCHEMA +KW_SCHEMAS +KW_SELECT +KW_SEMI +KW_SEPARATED +KW_SERDE +KW_SERDEPROPERTIES +KW_SESSION_USER +KW_SET +KW_MINUS +KW_SETS +KW_SHORT +KW_SHOW +KW_SINGLE +KW_SKEWED +KW_SMALLINT +KW_SOME +KW_SORT +KW_SORTED +KW_SOURCE +KW_START +KW_STATISTICS +KW_STORED +KW_STRATIFY +KW_STRING +KW_STRUCT +KW_SUBSTR +KW_SUBSTRING +KW_SYNC +KW_SYSTEM +KW_SYSTEM_TIME +KW_SYSTEM_VERSION +KW_TABLE +KW_TABLES +KW_TABLESAMPLE +KW_TARGET +KW_TBLPROPERTIES +KW_TEMPORARY +KW_TERMINATED +KW_THEN +KW_TIME +KW_TIMEDIFF +KW_TIMESTAMP +KW_TIMESTAMP_LTZ +KW_TIMESTAMP_NTZ +KW_TIMESTAMPADD +KW_TIMESTAMPDIFF +KW_TINYINT +KW_TO +KW_TOUCH +KW_TRAILING +KW_TRANSACTION +KW_TRANSACTIONS +KW_TRANSFORM +KW_TRIM +KW_TRUE +KW_TRUNCATE +KW_TRY_CAST +KW_TYPE +KW_UNARCHIVE +KW_UNBOUNDED +KW_UNCACHE +KW_UNION +KW_UNIQUE +KW_UNKNOWN +KW_UNLOCK +KW_UNPIVOT +KW_UNSET +KW_UPDATE +KW_USE +KW_USER +KW_USING +KW_VALUES +KW_VARCHAR +KW_VAR +KW_VARIABLE +KW_VERSION +KW_VIEW +KW_VIEWS +KW_VOID +KW_WEEK +KW_WEEKS +KW_WHEN +KW_WHERE +KW_WINDOW +KW_WITH +KW_WITHIN +KW_YEAR +KW_YEARS +KW_ZONE +KW_ZORDER +EQ +NSEQ +NEQ +NEQJ +LT +LTE +GT +GTE +NOT +PLUS +MINUS +ASTERISK +SLASH +PERCENT +TILDE +AMPERSAND +PIPE +CONCAT_PIPE +HAT +COLON +ARROW +FAT_ARROW +HENT_START +HENT_END +QUESTION +STRING_LITERAL +DOUBLEQUOTED_STRING +BIGINT_LITERAL +SMALLINT_LITERAL +TINYINT_LITERAL +INTEGER_VALUE +EXPONENT_VALUE +DECIMAL_VALUE +FLOAT_LITERAL +DOUBLE_LITERAL +BIGDECIMAL_LITERAL +IDENTIFIER +BACKQUOTED_IDENTIFIER +SIMPLE_COMMENT +BRACKETED_COMMENT +WS +UNRECOGNIZED + +rule names: +program +singleStatement +statement +alterStatement +createStatement +dropStatement +dmlStatementNoWith +insertInto +showStatement +unsupportedCommands +bucketSpec +skewSpec +query +partitionSpecLocation +partitionSpec +partitionVal +namespace +describeFuncName +describeColName +ctes +namedQuery +tableProvider +createTableClauses +tableLifecycle +propertyList +property +propertyKey +propertyValue +expressionPropertyList +expressionProperty +constantList +nestedConstantList +createFileFormat +fileFormat +storageHandler +namespaceName +namespaceNameCreate +tableNameCreate +tableName +viewNameCreate +viewName +columnName +columnNameSeq +columnNameCreate +identifierReference +queryOrganization +queryTerm +queryPrimary +sortItem +fromStatementBody +querySpecification +transformClause +selectClause +setClause +matchedClause +notMatchedClause +notMatchedBySourceClause +notMatchedAction +assignmentList +assignment +whereClause +havingClause +hint +hintStatement +fromClause +temporalClause +aggregationClause +groupByClause +groupingAnalytics +groupingSet +pivotClause +pivotColumn +pivotValue +unpivotClause +unpivotSingleValueColumnClause +unpivotMultiValueColumnClause +unpivotColumnSet +unpivotColumnAndAlias +ifNotExists +ifExists +lateralView +setQuantifier +relation +joinRelation +joinType +joinCriteria +sample +sampleMethod +identifierList +identifierSeq +orderedIdentifierList +orderedIdentifier +identifierCommentList +identifierComment +relationPrimary +functionTableSubqueryArgument +tableArgumentPartitioning +functionTableNamedArgumentExpression +functionTableReferenceArgument +functionTableArgument +tableAlias +rowFormat +multipartIdentifierList +multipartIdentifier +multipartIdentifierPropertyList +multipartIdentifierProperty +tableIdentifier +viewIdentifier +namedExpression +namedExpressionSeq +partitionFieldList +partitionField +transform +transformArgument +expression +namedArgumentExpression +functionArgument +expressionSeq +booleanExpression +predicate +valueExpression +datetimeUnit +primaryExpression +literalType +constant +comparisonOperator +arithmeticOperator +predicateOperator +booleanValue +interval +errorCapturingMultiUnitsInterval +errorCapturingUnitToUnitInterval +multiUnitsInterval +unitToUnitInterval +intervalValue +unitInMultiUnits +unitInUnitToUnit +colPosition +type +dataType +qualifiedColTypeWithPositionSeqForAdd +qualifiedColTypeWithPositionForAdd +qualifiedColTypeWithPositionSeqForReplace +qualifiedColTypeWithPositionForReplace +colDefinitionDescriptorWithPosition +variableDefaultExpression +colTypeList +columnType +createOrReplaceTableColTypeList +createOrReplaceTableColType +colDefinitionOption +complexColType +whenClause +windowClause +windowSpec +windowFrame +frameBound +qualifiedNameList +functionName +functionNameCreate +qualifiedName +errorCapturingIdentifier +errorCapturingIdentifierExtra +identifier +strictIdentifier +number +alterColumnAction +stringLit +ansiNonReserved +strictNonReserved +nonReserved + + +atn: +[4, 1, 392, 3679, 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, 5, 0, 344, 8, 0, 10, 0, 12, 0, 347, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 353, 8, 1, 1, 2, 1, 2, 3, 2, 357, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 362, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 373, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 379, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 390, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 396, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 401, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 406, 8, 2, 1, 2, 3, 2, 409, 8, 2, 1, 2, 1, 2, 3, 2, 413, 8, 2, 1, 2, 3, 2, 416, 8, 2, 1, 2, 1, 2, 3, 2, 420, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 426, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 432, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 437, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 442, 8, 2, 1, 2, 3, 2, 445, 8, 2, 1, 2, 1, 2, 3, 2, 449, 8, 2, 1, 2, 3, 2, 452, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 461, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 466, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 477, 8, 2, 10, 2, 12, 2, 480, 9, 2, 3, 2, 482, 8, 2, 1, 2, 1, 2, 3, 2, 486, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 492, 8, 2, 1, 2, 3, 2, 495, 8, 2, 1, 2, 3, 2, 498, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 503, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 511, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 516, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 522, 8, 2, 1, 2, 3, 2, 525, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 532, 8, 2, 1, 2, 1, 2, 1, 2, 5, 2, 537, 8, 2, 10, 2, 12, 2, 540, 9, 2, 1, 2, 1, 2, 5, 2, 544, 8, 2, 10, 2, 12, 2, 547, 9, 2, 1, 2, 1, 2, 5, 2, 551, 8, 2, 10, 2, 12, 2, 554, 9, 2, 1, 2, 1, 2, 1, 2, 3, 2, 559, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 567, 8, 2, 10, 2, 12, 2, 570, 9, 2, 3, 2, 572, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 582, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 590, 8, 3, 1, 3, 1, 3, 3, 3, 594, 8, 3, 1, 3, 3, 3, 597, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 605, 8, 3, 1, 3, 3, 3, 608, 8, 3, 1, 3, 1, 3, 3, 3, 612, 8, 3, 1, 3, 3, 3, 615, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 622, 8, 3, 1, 3, 1, 3, 1, 3, 3, 3, 627, 8, 3, 1, 3, 1, 3, 1, 3, 3, 3, 632, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 639, 8, 3, 1, 3, 1, 3, 1, 3, 3, 3, 644, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 653, 8, 3, 1, 3, 1, 3, 3, 3, 657, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 663, 8, 3, 1, 3, 1, 3, 3, 3, 667, 8, 3, 1, 3, 1, 3, 3, 3, 671, 8, 3, 1, 3, 1, 3, 1, 3, 3, 3, 676, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 682, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 689, 8, 3, 1, 3, 1, 3, 1, 3, 3, 3, 694, 8, 3, 1, 3, 4, 3, 697, 8, 3, 11, 3, 12, 3, 698, 1, 3, 3, 3, 702, 8, 3, 1, 3, 1, 3, 5, 3, 706, 8, 3, 10, 3, 12, 3, 709, 9, 3, 1, 3, 3, 3, 712, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 718, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 726, 8, 3, 1, 3, 1, 3, 3, 3, 730, 8, 3, 1, 3, 1, 3, 1, 3, 3, 3, 735, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 741, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 753, 8, 3, 1, 3, 1, 3, 1, 3, 3, 3, 758, 8, 3, 1, 3, 3, 3, 761, 8, 3, 1, 3, 3, 3, 764, 8, 3, 1, 3, 3, 3, 767, 8, 3, 1, 3, 3, 3, 770, 8, 3, 1, 3, 3, 3, 773, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 788, 8, 3, 1, 3, 1, 3, 3, 3, 792, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 801, 8, 3, 1, 3, 1, 3, 3, 3, 805, 8, 3, 1, 3, 1, 3, 1, 3, 5, 3, 810, 8, 3, 10, 3, 12, 3, 813, 9, 3, 1, 3, 3, 3, 816, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 827, 8, 3, 10, 3, 12, 3, 830, 9, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 837, 8, 3, 1, 3, 5, 3, 840, 8, 3, 10, 3, 12, 3, 843, 9, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 851, 8, 3, 1, 3, 3, 3, 854, 8, 3, 1, 3, 3, 3, 857, 8, 3, 1, 3, 5, 3, 860, 8, 3, 10, 3, 12, 3, 863, 9, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 871, 8, 3, 10, 3, 12, 3, 874, 9, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 880, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 888, 8, 3, 1, 3, 5, 3, 891, 8, 3, 10, 3, 12, 3, 894, 9, 3, 3, 3, 896, 8, 3, 1, 4, 1, 4, 1, 4, 3, 4, 901, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 5, 4, 911, 8, 4, 10, 4, 12, 4, 914, 9, 4, 1, 4, 1, 4, 3, 4, 918, 8, 4, 1, 4, 3, 4, 921, 8, 4, 1, 4, 1, 4, 3, 4, 925, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 932, 8, 4, 1, 4, 3, 4, 935, 8, 4, 1, 4, 1, 4, 3, 4, 939, 8, 4, 1, 4, 3, 4, 942, 8, 4, 1, 4, 1, 4, 3, 4, 946, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 955, 8, 4, 1, 4, 3, 4, 958, 8, 4, 1, 4, 1, 4, 3, 4, 962, 8, 4, 1, 4, 3, 4, 965, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 970, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 5, 4, 983, 8, 4, 10, 4, 12, 4, 986, 9, 4, 1, 4, 1, 4, 1, 4, 3, 4, 991, 8, 4, 1, 4, 3, 4, 994, 8, 4, 1, 4, 3, 4, 997, 8, 4, 1, 4, 1, 4, 3, 4, 1001, 8, 4, 1, 4, 1, 4, 3, 4, 1005, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 5, 4, 1014, 8, 4, 10, 4, 12, 4, 1017, 9, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1025, 8, 4, 1, 4, 3, 4, 1028, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1037, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1042, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1047, 8, 4, 1, 4, 3, 4, 1050, 8, 4, 1, 4, 1, 4, 3, 4, 1054, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 5, 4, 1067, 8, 4, 10, 4, 12, 4, 1070, 9, 4, 3, 4, 1072, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1077, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1082, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1087, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1094, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1101, 8, 4, 1, 4, 5, 4, 1104, 8, 4, 10, 4, 12, 4, 1107, 9, 4, 3, 4, 1109, 8, 4, 1, 5, 1, 5, 1, 5, 3, 5, 1114, 8, 5, 1, 5, 1, 5, 3, 5, 1118, 8, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1123, 8, 5, 1, 5, 1, 5, 3, 5, 1127, 8, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1132, 8, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1137, 8, 5, 1, 5, 1, 5, 3, 5, 1141, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1148, 8, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1153, 8, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1158, 8, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1163, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1170, 8, 5, 1, 5, 5, 5, 1173, 8, 5, 10, 5, 12, 5, 1176, 9, 5, 3, 5, 1178, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 4, 6, 1187, 8, 6, 11, 6, 12, 6, 1188, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 1196, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 1203, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 1215, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 5, 6, 1221, 8, 6, 10, 6, 12, 6, 1224, 9, 6, 1, 6, 5, 6, 1227, 8, 6, 10, 6, 12, 6, 1230, 9, 6, 1, 6, 5, 6, 1233, 8, 6, 10, 6, 12, 6, 1236, 9, 6, 3, 6, 1238, 8, 6, 1, 7, 1, 7, 1, 7, 3, 7, 1243, 8, 7, 1, 7, 1, 7, 3, 7, 1247, 8, 7, 1, 7, 3, 7, 1250, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 1258, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 1263, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 1272, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 1277, 8, 7, 3, 7, 1279, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 1287, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 1292, 8, 7, 1, 7, 1, 7, 3, 7, 1296, 8, 7, 1, 7, 3, 7, 1299, 8, 7, 1, 7, 3, 7, 1302, 8, 7, 1, 7, 3, 7, 1305, 8, 7, 1, 7, 1, 7, 3, 7, 1309, 8, 7, 3, 7, 1311, 8, 7, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1317, 8, 8, 1, 8, 3, 8, 1320, 8, 8, 1, 8, 3, 8, 1323, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1329, 8, 8, 1, 8, 3, 8, 1332, 8, 8, 1, 8, 3, 8, 1335, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1342, 8, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1347, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1356, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1364, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1370, 8, 8, 1, 8, 3, 8, 1373, 8, 8, 1, 8, 3, 8, 1376, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1382, 8, 8, 1, 8, 1, 8, 3, 8, 1386, 8, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1391, 8, 8, 1, 8, 3, 8, 1394, 8, 8, 1, 8, 1, 8, 3, 8, 1398, 8, 8, 3, 8, 1400, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1408, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1416, 8, 8, 1, 8, 3, 8, 1419, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1431, 8, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1437, 8, 8, 1, 8, 5, 8, 1440, 8, 8, 10, 8, 12, 8, 1443, 9, 8, 3, 8, 1445, 8, 8, 1, 9, 1, 9, 3, 9, 1449, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 1460, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 1468, 8, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1480, 8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1485, 8, 11, 1, 12, 3, 12, 1488, 8, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 3, 13, 1496, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 1503, 8, 14, 10, 14, 12, 14, 1506, 9, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 3, 15, 1513, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1519, 8, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1528, 8, 17, 1, 18, 1, 18, 1, 18, 5, 18, 1533, 8, 18, 10, 18, 12, 18, 1536, 9, 18, 1, 19, 1, 19, 1, 19, 1, 19, 5, 19, 1542, 8, 19, 10, 19, 12, 19, 1545, 9, 19, 1, 20, 1, 20, 3, 20, 1549, 8, 20, 1, 20, 3, 20, 1552, 8, 20, 1, 20, 1, 20, 1, 20, 1, 20, 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, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 1577, 8, 22, 10, 22, 12, 22, 1580, 9, 22, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 5, 24, 1589, 8, 24, 10, 24, 12, 24, 1592, 9, 24, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 1598, 8, 25, 1, 25, 3, 25, 1601, 8, 25, 1, 26, 1, 26, 1, 26, 5, 26, 1606, 8, 26, 10, 26, 12, 26, 1609, 9, 26, 1, 26, 3, 26, 1612, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 1618, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 1624, 8, 28, 10, 28, 12, 28, 1627, 9, 28, 1, 28, 1, 28, 1, 29, 1, 29, 3, 29, 1633, 8, 29, 1, 29, 3, 29, 1636, 8, 29, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 1642, 8, 30, 10, 30, 12, 30, 1645, 9, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 5, 31, 1653, 8, 31, 10, 31, 12, 31, 1656, 9, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1666, 8, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1674, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1680, 8, 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, 3, 41, 1696, 8, 41, 1, 42, 1, 42, 1, 42, 5, 42, 1701, 8, 42, 10, 42, 12, 42, 1704, 9, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1714, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1721, 8, 45, 10, 45, 12, 45, 1724, 9, 45, 3, 45, 1726, 8, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1733, 8, 45, 10, 45, 12, 45, 1736, 9, 45, 3, 45, 1738, 8, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1745, 8, 45, 10, 45, 12, 45, 1748, 9, 45, 3, 45, 1750, 8, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1757, 8, 45, 10, 45, 12, 45, 1760, 9, 45, 3, 45, 1762, 8, 45, 1, 45, 3, 45, 1765, 8, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1770, 8, 45, 3, 45, 1772, 8, 45, 1, 45, 1, 45, 3, 45, 1776, 8, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1784, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1790, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1796, 8, 46, 1, 46, 5, 46, 1799, 8, 46, 10, 46, 12, 46, 1802, 9, 46, 1, 47, 1, 47, 1, 47, 4, 47, 1807, 8, 47, 11, 47, 12, 47, 1808, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 5, 47, 1817, 8, 47, 10, 47, 12, 47, 1820, 9, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1828, 8, 47, 1, 48, 1, 48, 3, 48, 1832, 8, 48, 1, 48, 3, 48, 1835, 8, 48, 1, 48, 1, 48, 3, 48, 1839, 8, 48, 1, 49, 1, 49, 3, 49, 1843, 8, 49, 1, 49, 1, 49, 1, 49, 1, 49, 5, 49, 1849, 8, 49, 10, 49, 12, 49, 1852, 9, 49, 1, 49, 3, 49, 1855, 8, 49, 1, 49, 3, 49, 1858, 8, 49, 1, 49, 3, 49, 1861, 8, 49, 1, 49, 3, 49, 1864, 8, 49, 1, 49, 1, 49, 3, 49, 1868, 8, 49, 1, 50, 1, 50, 3, 50, 1872, 8, 50, 1, 50, 5, 50, 1875, 8, 50, 10, 50, 12, 50, 1878, 9, 50, 1, 50, 3, 50, 1881, 8, 50, 1, 50, 3, 50, 1884, 8, 50, 1, 50, 3, 50, 1887, 8, 50, 1, 50, 3, 50, 1890, 8, 50, 1, 50, 1, 50, 3, 50, 1894, 8, 50, 1, 50, 5, 50, 1897, 8, 50, 10, 50, 12, 50, 1900, 9, 50, 1, 50, 3, 50, 1903, 8, 50, 1, 50, 3, 50, 1906, 8, 50, 1, 50, 3, 50, 1909, 8, 50, 1, 50, 3, 50, 1912, 8, 50, 3, 50, 1914, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1920, 8, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1927, 8, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1932, 8, 51, 1, 51, 3, 51, 1935, 8, 51, 1, 51, 3, 51, 1938, 8, 51, 1, 51, 1, 51, 3, 51, 1942, 8, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1952, 8, 51, 1, 51, 1, 51, 3, 51, 1956, 8, 51, 3, 51, 1958, 8, 51, 1, 51, 3, 51, 1961, 8, 51, 1, 51, 1, 51, 3, 51, 1965, 8, 51, 1, 52, 1, 52, 5, 52, 1969, 8, 52, 10, 52, 12, 52, 1972, 9, 52, 1, 52, 3, 52, 1975, 8, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 1986, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 1994, 8, 54, 3, 54, 1996, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 2003, 8, 55, 1, 55, 1, 55, 3, 55, 2007, 8, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 2019, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 2026, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 5, 57, 2039, 8, 57, 10, 57, 12, 57, 2042, 9, 57, 1, 57, 1, 57, 3, 57, 2046, 8, 57, 1, 58, 1, 58, 1, 58, 5, 58, 2051, 8, 58, 10, 58, 12, 58, 2054, 9, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 3, 62, 2069, 8, 62, 1, 62, 5, 62, 2072, 8, 62, 10, 62, 12, 62, 2075, 9, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 2085, 8, 63, 10, 63, 12, 63, 2088, 9, 63, 1, 63, 1, 63, 3, 63, 2092, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 5, 64, 2098, 8, 64, 10, 64, 12, 64, 2101, 9, 64, 1, 64, 5, 64, 2104, 8, 64, 10, 64, 12, 64, 2107, 9, 64, 1, 64, 3, 64, 2110, 8, 64, 1, 64, 3, 64, 2113, 8, 64, 1, 65, 3, 65, 2116, 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 2123, 8, 65, 1, 65, 3, 65, 2126, 8, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 2132, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 5, 66, 2139, 8, 66, 10, 66, 12, 66, 2142, 9, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 5, 66, 2149, 8, 66, 10, 66, 12, 66, 2152, 9, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 5, 66, 2164, 8, 66, 10, 66, 12, 66, 2167, 9, 66, 1, 66, 1, 66, 3, 66, 2171, 8, 66, 3, 66, 2173, 8, 66, 1, 67, 1, 67, 1, 67, 3, 67, 2178, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 5, 68, 2185, 8, 68, 10, 68, 12, 68, 2188, 9, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2197, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2202, 8, 68, 5, 68, 2204, 8, 68, 10, 68, 12, 68, 2207, 9, 68, 1, 68, 1, 68, 3, 68, 2211, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 2218, 8, 69, 1, 69, 1, 69, 1, 69, 3, 69, 2223, 8, 69, 5, 69, 2225, 8, 69, 10, 69, 12, 69, 2228, 9, 69, 3, 69, 2230, 8, 69, 1, 69, 3, 69, 2233, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 5, 70, 2245, 8, 70, 10, 70, 12, 70, 2248, 9, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2258, 8, 71, 10, 71, 12, 71, 2261, 9, 71, 1, 71, 1, 71, 3, 71, 2265, 8, 71, 1, 72, 1, 72, 3, 72, 2269, 8, 72, 1, 72, 3, 72, 2272, 8, 72, 1, 73, 1, 73, 1, 73, 3, 73, 2277, 8, 73, 1, 73, 1, 73, 1, 73, 3, 73, 2282, 8, 73, 1, 73, 1, 73, 3, 73, 2286, 8, 73, 1, 73, 3, 73, 2289, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 5, 74, 2299, 8, 74, 10, 74, 12, 74, 2302, 9, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 5, 75, 2310, 8, 75, 10, 75, 12, 75, 2313, 9, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 5, 75, 2323, 8, 75, 10, 75, 12, 75, 2326, 9, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 5, 76, 2334, 8, 76, 10, 76, 12, 76, 2337, 9, 76, 1, 76, 1, 76, 3, 76, 2341, 8, 76, 1, 76, 3, 76, 2344, 8, 76, 1, 77, 1, 77, 3, 77, 2348, 8, 77, 1, 77, 3, 77, 2351, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 3, 80, 2363, 8, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 5, 80, 2370, 8, 80, 10, 80, 12, 80, 2373, 9, 80, 3, 80, 2375, 8, 80, 1, 80, 1, 80, 1, 80, 3, 80, 2380, 8, 80, 1, 80, 1, 80, 1, 80, 5, 80, 2385, 8, 80, 10, 80, 12, 80, 2388, 9, 80, 3, 80, 2390, 8, 80, 1, 81, 1, 81, 1, 82, 1, 82, 3, 82, 2396, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 5, 82, 2402, 8, 82, 10, 82, 12, 82, 2405, 9, 82, 3, 82, 2407, 8, 82, 1, 83, 1, 83, 1, 83, 3, 83, 2412, 8, 83, 1, 83, 1, 83, 3, 83, 2416, 8, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 2422, 8, 83, 1, 83, 1, 83, 3, 83, 2426, 8, 83, 1, 84, 3, 84, 2429, 8, 84, 1, 84, 1, 84, 1, 84, 3, 84, 2434, 8, 84, 1, 84, 3, 84, 2437, 8, 84, 1, 84, 1, 84, 1, 84, 3, 84, 2442, 8, 84, 3, 84, 2444, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 2450, 8, 85, 1, 86, 1, 86, 1, 86, 3, 86, 2455, 8, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 2462, 8, 86, 1, 87, 3, 87, 2465, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2483, 8, 87, 3, 87, 2485, 8, 87, 1, 87, 3, 87, 2488, 8, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 5, 89, 2497, 8, 89, 10, 89, 12, 89, 2500, 9, 89, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 2506, 8, 90, 10, 90, 12, 90, 2509, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 3, 91, 2515, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 5, 92, 2521, 8, 92, 10, 92, 12, 92, 2524, 9, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 3, 93, 2531, 8, 93, 1, 94, 1, 94, 1, 94, 3, 94, 2536, 8, 94, 1, 94, 3, 94, 2539, 8, 94, 1, 94, 3, 94, 2542, 8, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 2550, 8, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 2558, 8, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 5, 94, 2566, 8, 94, 10, 94, 12, 94, 2569, 9, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 5, 94, 2578, 8, 94, 10, 94, 12, 94, 2581, 9, 94, 3, 94, 2583, 8, 94, 1, 94, 1, 94, 1, 94, 3, 94, 2588, 8, 94, 1, 95, 1, 95, 1, 95, 3, 95, 2593, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 2600, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 2607, 8, 95, 3, 95, 2609, 8, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 5, 96, 2620, 8, 96, 10, 96, 12, 96, 2623, 9, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2628, 8, 96, 3, 96, 2630, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 5, 96, 2638, 8, 96, 10, 96, 12, 96, 2641, 9, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2646, 8, 96, 3, 96, 2648, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 3, 98, 2656, 8, 98, 1, 99, 1, 99, 3, 99, 2660, 8, 99, 1, 100, 3, 100, 2663, 8, 100, 1, 100, 1, 100, 3, 100, 2667, 8, 100, 3, 100, 2669, 8, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2678, 8, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2690, 8, 101, 3, 101, 2692, 8, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2699, 8, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2706, 8, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2712, 8, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2718, 8, 101, 3, 101, 2720, 8, 101, 1, 102, 1, 102, 1, 102, 5, 102, 2725, 8, 102, 10, 102, 12, 102, 2728, 9, 102, 1, 103, 1, 103, 1, 103, 5, 103, 2733, 8, 103, 10, 103, 12, 103, 2736, 9, 103, 1, 104, 1, 104, 1, 104, 5, 104, 2741, 8, 104, 10, 104, 12, 104, 2744, 9, 104, 1, 105, 1, 105, 1, 105, 3, 105, 2749, 8, 105, 1, 106, 1, 106, 1, 106, 3, 106, 2754, 8, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 3, 107, 2761, 8, 107, 1, 107, 1, 107, 1, 108, 1, 108, 3, 108, 2767, 8, 108, 1, 108, 3, 108, 2770, 8, 108, 1, 108, 1, 108, 3, 108, 2774, 8, 108, 3, 108, 2776, 8, 108, 1, 109, 1, 109, 1, 109, 5, 109, 2781, 8, 109, 10, 109, 12, 109, 2784, 9, 109, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 2790, 8, 110, 10, 110, 12, 110, 2793, 9, 110, 1, 110, 1, 110, 1, 111, 1, 111, 3, 111, 2799, 8, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 5, 112, 2807, 8, 112, 10, 112, 12, 112, 2810, 9, 112, 1, 112, 1, 112, 3, 112, 2814, 8, 112, 1, 113, 1, 113, 3, 113, 2818, 8, 113, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 3, 116, 2828, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 2833, 8, 117, 10, 117, 12, 117, 2836, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2848, 8, 118, 3, 118, 2850, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 5, 118, 2858, 8, 118, 10, 118, 12, 118, 2861, 9, 118, 1, 119, 3, 119, 2864, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2872, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2879, 8, 119, 10, 119, 12, 119, 2882, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2887, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2895, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2900, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2910, 8, 119, 10, 119, 12, 119, 2913, 9, 119, 1, 119, 1, 119, 3, 119, 2917, 8, 119, 1, 119, 3, 119, 2920, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2926, 8, 119, 1, 119, 1, 119, 3, 119, 2930, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2935, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2940, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2945, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2951, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 5, 120, 2972, 8, 120, 10, 120, 12, 120, 2975, 9, 120, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2985, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2997, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 4, 122, 3007, 8, 122, 11, 122, 12, 122, 3008, 1, 122, 1, 122, 3, 122, 3013, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 4, 122, 3020, 8, 122, 11, 122, 12, 122, 3021, 1, 122, 1, 122, 3, 122, 3026, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 5, 122, 3042, 8, 122, 10, 122, 12, 122, 3045, 9, 122, 3, 122, 3047, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3055, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3064, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3073, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 4, 122, 3094, 8, 122, 11, 122, 12, 122, 3095, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3112, 8, 122, 1, 122, 1, 122, 1, 122, 5, 122, 3117, 8, 122, 10, 122, 12, 122, 3120, 9, 122, 3, 122, 3122, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3131, 8, 122, 1, 122, 1, 122, 3, 122, 3135, 8, 122, 1, 122, 1, 122, 3, 122, 3139, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 4, 122, 3149, 8, 122, 11, 122, 12, 122, 3150, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3176, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3183, 8, 122, 1, 122, 3, 122, 3186, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3201, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3222, 8, 122, 1, 122, 1, 122, 3, 122, 3226, 8, 122, 3, 122, 3228, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 5, 122, 3238, 8, 122, 10, 122, 12, 122, 3241, 9, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3250, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 4, 124, 3263, 8, 124, 11, 124, 12, 124, 3264, 3, 124, 3267, 8, 124, 1, 125, 1, 125, 1, 126, 1, 126, 1, 127, 1, 127, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 3, 129, 3280, 8, 129, 1, 130, 1, 130, 3, 130, 3284, 8, 130, 1, 131, 1, 131, 1, 131, 3, 131, 3289, 8, 131, 1, 132, 1, 132, 1, 132, 4, 132, 3294, 8, 132, 11, 132, 12, 132, 3295, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 3, 134, 3304, 8, 134, 1, 134, 1, 134, 1, 134, 3, 134, 3309, 8, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 3, 137, 3318, 8, 137, 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, 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, 3350, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 5, 139, 3369, 8, 139, 10, 139, 12, 139, 3372, 9, 139, 3, 139, 3374, 8, 139, 1, 139, 1, 139, 3, 139, 3378, 8, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 3384, 8, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 3390, 8, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 5, 139, 3397, 8, 139, 10, 139, 12, 139, 3400, 9, 139, 1, 139, 3, 139, 3403, 8, 139, 3, 139, 3405, 8, 139, 1, 140, 1, 140, 1, 140, 5, 140, 3410, 8, 140, 10, 140, 12, 140, 3413, 9, 140, 1, 141, 1, 141, 1, 141, 5, 141, 3418, 8, 141, 10, 141, 12, 141, 3421, 9, 141, 1, 142, 1, 142, 1, 142, 5, 142, 3426, 8, 142, 10, 142, 12, 142, 3429, 9, 142, 1, 143, 1, 143, 1, 143, 5, 143, 3434, 8, 143, 10, 143, 12, 143, 3437, 9, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 3446, 8, 144, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 5, 146, 3454, 8, 146, 10, 146, 12, 146, 3457, 9, 146, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3463, 8, 147, 1, 147, 1, 147, 3, 147, 3467, 8, 147, 1, 148, 1, 148, 1, 148, 5, 148, 3472, 8, 148, 10, 148, 12, 148, 3475, 9, 148, 1, 149, 1, 149, 1, 149, 5, 149, 3480, 8, 149, 10, 149, 12, 149, 3483, 9, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 3, 150, 3498, 8, 150, 1, 151, 1, 151, 3, 151, 3502, 8, 151, 1, 151, 1, 151, 1, 151, 3, 151, 3507, 8, 151, 1, 151, 1, 151, 3, 151, 3511, 8, 151, 1, 152, 1, 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, 5, 153, 3527, 8, 153, 10, 153, 12, 153, 3530, 9, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3543, 8, 154, 10, 154, 12, 154, 3546, 9, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3553, 8, 154, 10, 154, 12, 154, 3556, 9, 154, 3, 154, 3558, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3565, 8, 154, 10, 154, 12, 154, 3568, 9, 154, 3, 154, 3570, 8, 154, 3, 154, 3572, 8, 154, 1, 154, 3, 154, 3575, 8, 154, 1, 154, 3, 154, 3578, 8, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3588, 8, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 3597, 8, 156, 1, 157, 1, 157, 1, 157, 5, 157, 3602, 8, 157, 10, 157, 12, 157, 3605, 9, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 3616, 8, 158, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 5, 160, 3623, 8, 160, 10, 160, 12, 160, 3626, 9, 160, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, 4, 162, 3633, 8, 162, 11, 162, 12, 162, 3634, 1, 162, 3, 162, 3638, 8, 162, 1, 163, 1, 163, 3, 163, 3642, 8, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 3, 164, 3649, 8, 164, 1, 165, 3, 165, 3652, 8, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3669, 8, 166, 1, 167, 1, 167, 1, 168, 1, 168, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 13, 478, 538, 545, 552, 568, 828, 841, 861, 872, 892, 1105, 1174, 1441, 4, 92, 236, 240, 244, 171, 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, 0, 75, 2, 0, 123, 123, 140, 140, 5, 0, 46, 46, 58, 58, 108, 108, 122, 122, 173, 173, 1, 0, 86, 87, 2, 0, 108, 108, 122, 122, 3, 0, 8, 8, 96, 96, 288, 288, 2, 0, 8, 8, 167, 167, 2, 0, 78, 78, 228, 228, 1, 0, 49, 50, 2, 0, 268, 268, 327, 327, 2, 0, 11, 11, 39, 39, 2, 0, 8, 8, 96, 96, 3, 0, 45, 45, 274, 274, 309, 309, 2, 0, 196, 196, 268, 268, 4, 0, 45, 45, 274, 274, 278, 278, 282, 282, 3, 0, 18, 18, 103, 103, 319, 319, 2, 0, 34, 34, 246, 246, 3, 0, 142, 142, 252, 252, 297, 297, 3, 0, 73, 73, 190, 190, 261, 261, 3, 0, 10, 10, 289, 289, 330, 330, 2, 0, 129, 129, 248, 248, 4, 0, 107, 107, 139, 139, 171, 171, 325, 325, 2, 0, 171, 171, 325, 325, 3, 0, 72, 72, 189, 189, 260, 260, 4, 0, 102, 102, 148, 148, 269, 269, 322, 322, 3, 0, 102, 102, 269, 269, 322, 322, 2, 0, 21, 21, 86, 86, 2, 0, 116, 116, 157, 157, 2, 0, 291, 291, 336, 336, 2, 0, 290, 290, 302, 302, 2, 0, 61, 61, 255, 255, 2, 0, 104, 104, 141, 141, 2, 0, 10, 10, 92, 92, 2, 0, 15, 15, 263, 263, 2, 0, 124, 124, 249, 249, 2, 0, 381, 381, 383, 383, 2, 0, 93, 93, 216, 216, 2, 0, 208, 208, 277, 277, 2, 0, 196, 196, 359, 359, 1, 0, 250, 251, 1, 0, 163, 164, 3, 0, 10, 10, 16, 16, 276, 276, 3, 0, 111, 111, 315, 315, 324, 324, 2, 0, 360, 361, 365, 365, 2, 0, 94, 94, 362, 364, 2, 0, 360, 361, 368, 368, 11, 0, 67, 67, 69, 69, 134, 134, 179, 179, 181, 181, 183, 183, 185, 185, 230, 230, 258, 258, 340, 340, 347, 347, 4, 0, 63, 63, 65, 66, 267, 267, 330, 330, 2, 0, 74, 75, 305, 305, 3, 0, 76, 77, 301, 301, 306, 306, 2, 0, 36, 36, 317, 317, 2, 0, 138, 138, 245, 245, 1, 0, 286, 287, 2, 0, 4, 4, 123, 123, 2, 0, 4, 4, 119, 119, 3, 0, 28, 28, 160, 160, 310, 310, 1, 0, 219, 220, 1, 0, 351, 358, 2, 0, 94, 94, 360, 369, 4, 0, 14, 14, 140, 140, 196, 196, 207, 207, 2, 0, 111, 111, 315, 315, 1, 0, 360, 361, 7, 0, 67, 68, 134, 135, 179, 186, 191, 192, 258, 259, 340, 341, 347, 348, 6, 0, 67, 67, 134, 134, 183, 183, 185, 185, 258, 258, 347, 347, 2, 0, 185, 185, 347, 347, 4, 0, 67, 67, 134, 134, 183, 183, 258, 258, 3, 0, 134, 134, 183, 183, 258, 258, 2, 0, 82, 82, 351, 351, 2, 0, 232, 232, 257, 257, 2, 0, 118, 118, 225, 225, 1, 0, 378, 386, 2, 0, 96, 96, 268, 268, 1, 0, 376, 377, 52, 0, 8, 9, 11, 13, 15, 15, 17, 19, 21, 22, 24, 27, 29, 34, 37, 41, 43, 46, 48, 48, 50, 56, 58, 58, 61, 62, 67, 91, 93, 96, 98, 98, 101, 101, 103, 110, 113, 113, 115, 118, 121, 122, 125, 128, 131, 131, 133, 139, 141, 143, 145, 147, 149, 151, 154, 154, 156, 157, 159, 159, 163, 192, 194, 194, 198, 200, 204, 206, 209, 209, 211, 212, 214, 218, 221, 225, 227, 237, 239, 248, 250, 261, 263, 266, 268, 275, 277, 291, 293, 298, 301, 307, 309, 309, 311, 321, 325, 329, 332, 341, 344, 344, 347, 350, 16, 0, 15, 15, 60, 60, 102, 102, 124, 124, 144, 144, 148, 148, 155, 155, 158, 158, 161, 161, 193, 193, 202, 202, 249, 249, 263, 263, 269, 269, 322, 322, 331, 331, 19, 0, 8, 14, 16, 59, 61, 101, 103, 122, 125, 143, 145, 147, 149, 154, 156, 157, 159, 160, 162, 192, 194, 194, 196, 201, 203, 248, 250, 261, 264, 268, 270, 291, 293, 321, 323, 330, 332, 350, 4271, 0, 345, 1, 0, 0, 0, 2, 350, 1, 0, 0, 0, 4, 571, 1, 0, 0, 0, 6, 895, 1, 0, 0, 0, 8, 1108, 1, 0, 0, 0, 10, 1177, 1, 0, 0, 0, 12, 1237, 1, 0, 0, 0, 14, 1310, 1, 0, 0, 0, 16, 1444, 1, 0, 0, 0, 18, 1459, 1, 0, 0, 0, 20, 1461, 1, 0, 0, 0, 22, 1473, 1, 0, 0, 0, 24, 1487, 1, 0, 0, 0, 26, 1492, 1, 0, 0, 0, 28, 1497, 1, 0, 0, 0, 30, 1518, 1, 0, 0, 0, 32, 1520, 1, 0, 0, 0, 34, 1527, 1, 0, 0, 0, 36, 1529, 1, 0, 0, 0, 38, 1537, 1, 0, 0, 0, 40, 1546, 1, 0, 0, 0, 42, 1557, 1, 0, 0, 0, 44, 1578, 1, 0, 0, 0, 46, 1581, 1, 0, 0, 0, 48, 1584, 1, 0, 0, 0, 50, 1595, 1, 0, 0, 0, 52, 1611, 1, 0, 0, 0, 54, 1617, 1, 0, 0, 0, 56, 1619, 1, 0, 0, 0, 58, 1630, 1, 0, 0, 0, 60, 1637, 1, 0, 0, 0, 62, 1648, 1, 0, 0, 0, 64, 1665, 1, 0, 0, 0, 66, 1673, 1, 0, 0, 0, 68, 1675, 1, 0, 0, 0, 70, 1681, 1, 0, 0, 0, 72, 1683, 1, 0, 0, 0, 74, 1685, 1, 0, 0, 0, 76, 1687, 1, 0, 0, 0, 78, 1689, 1, 0, 0, 0, 80, 1691, 1, 0, 0, 0, 82, 1695, 1, 0, 0, 0, 84, 1697, 1, 0, 0, 0, 86, 1705, 1, 0, 0, 0, 88, 1713, 1, 0, 0, 0, 90, 1725, 1, 0, 0, 0, 92, 1777, 1, 0, 0, 0, 94, 1827, 1, 0, 0, 0, 96, 1831, 1, 0, 0, 0, 98, 1867, 1, 0, 0, 0, 100, 1913, 1, 0, 0, 0, 102, 1934, 1, 0, 0, 0, 104, 1966, 1, 0, 0, 0, 106, 1978, 1, 0, 0, 0, 108, 1981, 1, 0, 0, 0, 110, 1997, 1, 0, 0, 0, 112, 2011, 1, 0, 0, 0, 114, 2045, 1, 0, 0, 0, 116, 2047, 1, 0, 0, 0, 118, 2055, 1, 0, 0, 0, 120, 2059, 1, 0, 0, 0, 122, 2062, 1, 0, 0, 0, 124, 2065, 1, 0, 0, 0, 126, 2091, 1, 0, 0, 0, 128, 2093, 1, 0, 0, 0, 130, 2131, 1, 0, 0, 0, 132, 2172, 1, 0, 0, 0, 134, 2177, 1, 0, 0, 0, 136, 2210, 1, 0, 0, 0, 138, 2232, 1, 0, 0, 0, 140, 2234, 1, 0, 0, 0, 142, 2264, 1, 0, 0, 0, 144, 2266, 1, 0, 0, 0, 146, 2273, 1, 0, 0, 0, 148, 2290, 1, 0, 0, 0, 150, 2305, 1, 0, 0, 0, 152, 2329, 1, 0, 0, 0, 154, 2345, 1, 0, 0, 0, 156, 2352, 1, 0, 0, 0, 158, 2356, 1, 0, 0, 0, 160, 2359, 1, 0, 0, 0, 162, 2391, 1, 0, 0, 0, 164, 2406, 1, 0, 0, 0, 166, 2425, 1, 0, 0, 0, 168, 2443, 1, 0, 0, 0, 170, 2449, 1, 0, 0, 0, 172, 2451, 1, 0, 0, 0, 174, 2487, 1, 0, 0, 0, 176, 2489, 1, 0, 0, 0, 178, 2493, 1, 0, 0, 0, 180, 2501, 1, 0, 0, 0, 182, 2512, 1, 0, 0, 0, 184, 2516, 1, 0, 0, 0, 186, 2527, 1, 0, 0, 0, 188, 2587, 1, 0, 0, 0, 190, 2608, 1, 0, 0, 0, 192, 2629, 1, 0, 0, 0, 194, 2649, 1, 0, 0, 0, 196, 2655, 1, 0, 0, 0, 198, 2659, 1, 0, 0, 0, 200, 2668, 1, 0, 0, 0, 202, 2719, 1, 0, 0, 0, 204, 2721, 1, 0, 0, 0, 206, 2729, 1, 0, 0, 0, 208, 2737, 1, 0, 0, 0, 210, 2745, 1, 0, 0, 0, 212, 2753, 1, 0, 0, 0, 214, 2760, 1, 0, 0, 0, 216, 2766, 1, 0, 0, 0, 218, 2777, 1, 0, 0, 0, 220, 2785, 1, 0, 0, 0, 222, 2798, 1, 0, 0, 0, 224, 2813, 1, 0, 0, 0, 226, 2817, 1, 0, 0, 0, 228, 2819, 1, 0, 0, 0, 230, 2821, 1, 0, 0, 0, 232, 2827, 1, 0, 0, 0, 234, 2829, 1, 0, 0, 0, 236, 2849, 1, 0, 0, 0, 238, 2944, 1, 0, 0, 0, 240, 2950, 1, 0, 0, 0, 242, 2976, 1, 0, 0, 0, 244, 3227, 1, 0, 0, 0, 246, 3249, 1, 0, 0, 0, 248, 3266, 1, 0, 0, 0, 250, 3268, 1, 0, 0, 0, 252, 3270, 1, 0, 0, 0, 254, 3272, 1, 0, 0, 0, 256, 3274, 1, 0, 0, 0, 258, 3276, 1, 0, 0, 0, 260, 3281, 1, 0, 0, 0, 262, 3285, 1, 0, 0, 0, 264, 3293, 1, 0, 0, 0, 266, 3297, 1, 0, 0, 0, 268, 3303, 1, 0, 0, 0, 270, 3310, 1, 0, 0, 0, 272, 3312, 1, 0, 0, 0, 274, 3317, 1, 0, 0, 0, 276, 3349, 1, 0, 0, 0, 278, 3404, 1, 0, 0, 0, 280, 3406, 1, 0, 0, 0, 282, 3414, 1, 0, 0, 0, 284, 3422, 1, 0, 0, 0, 286, 3430, 1, 0, 0, 0, 288, 3445, 1, 0, 0, 0, 290, 3447, 1, 0, 0, 0, 292, 3450, 1, 0, 0, 0, 294, 3458, 1, 0, 0, 0, 296, 3468, 1, 0, 0, 0, 298, 3476, 1, 0, 0, 0, 300, 3497, 1, 0, 0, 0, 302, 3499, 1, 0, 0, 0, 304, 3512, 1, 0, 0, 0, 306, 3517, 1, 0, 0, 0, 308, 3577, 1, 0, 0, 0, 310, 3587, 1, 0, 0, 0, 312, 3596, 1, 0, 0, 0, 314, 3598, 1, 0, 0, 0, 316, 3615, 1, 0, 0, 0, 318, 3617, 1, 0, 0, 0, 320, 3619, 1, 0, 0, 0, 322, 3627, 1, 0, 0, 0, 324, 3637, 1, 0, 0, 0, 326, 3641, 1, 0, 0, 0, 328, 3648, 1, 0, 0, 0, 330, 3651, 1, 0, 0, 0, 332, 3668, 1, 0, 0, 0, 334, 3670, 1, 0, 0, 0, 336, 3672, 1, 0, 0, 0, 338, 3674, 1, 0, 0, 0, 340, 3676, 1, 0, 0, 0, 342, 344, 3, 2, 1, 0, 343, 342, 1, 0, 0, 0, 344, 347, 1, 0, 0, 0, 345, 343, 1, 0, 0, 0, 345, 346, 1, 0, 0, 0, 346, 348, 1, 0, 0, 0, 347, 345, 1, 0, 0, 0, 348, 349, 5, 0, 0, 1, 349, 1, 1, 0, 0, 0, 350, 352, 3, 4, 2, 0, 351, 353, 5, 1, 0, 0, 352, 351, 1, 0, 0, 0, 352, 353, 1, 0, 0, 0, 353, 3, 1, 0, 0, 0, 354, 572, 3, 24, 12, 0, 355, 357, 3, 38, 19, 0, 356, 355, 1, 0, 0, 0, 356, 357, 1, 0, 0, 0, 357, 358, 1, 0, 0, 0, 358, 572, 3, 12, 6, 0, 359, 361, 5, 329, 0, 0, 360, 362, 3, 32, 16, 0, 361, 360, 1, 0, 0, 0, 361, 362, 1, 0, 0, 0, 362, 363, 1, 0, 0, 0, 363, 572, 3, 70, 35, 0, 364, 572, 3, 6, 3, 0, 365, 572, 3, 8, 4, 0, 366, 572, 3, 10, 5, 0, 367, 572, 3, 16, 8, 0, 368, 369, 5, 316, 0, 0, 369, 370, 5, 292, 0, 0, 370, 372, 3, 76, 38, 0, 371, 373, 3, 28, 14, 0, 372, 371, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 572, 1, 0, 0, 0, 374, 375, 5, 13, 0, 0, 375, 376, 5, 292, 0, 0, 376, 378, 3, 76, 38, 0, 377, 379, 3, 28, 14, 0, 378, 377, 1, 0, 0, 0, 378, 379, 1, 0, 0, 0, 379, 380, 1, 0, 0, 0, 380, 381, 5, 55, 0, 0, 381, 389, 5, 281, 0, 0, 382, 390, 5, 195, 0, 0, 383, 384, 5, 119, 0, 0, 384, 385, 5, 50, 0, 0, 385, 390, 3, 84, 42, 0, 386, 387, 5, 119, 0, 0, 387, 388, 5, 10, 0, 0, 388, 390, 5, 50, 0, 0, 389, 382, 1, 0, 0, 0, 389, 383, 1, 0, 0, 0, 389, 386, 1, 0, 0, 0, 389, 390, 1, 0, 0, 0, 390, 572, 1, 0, 0, 0, 391, 392, 5, 13, 0, 0, 392, 395, 5, 293, 0, 0, 393, 394, 7, 0, 0, 0, 394, 396, 3, 70, 35, 0, 395, 393, 1, 0, 0, 0, 395, 396, 1, 0, 0, 0, 396, 397, 1, 0, 0, 0, 397, 398, 5, 55, 0, 0, 398, 400, 5, 281, 0, 0, 399, 401, 5, 195, 0, 0, 400, 399, 1, 0, 0, 0, 400, 401, 1, 0, 0, 0, 401, 572, 1, 0, 0, 0, 402, 405, 5, 81, 0, 0, 403, 404, 5, 207, 0, 0, 404, 406, 5, 243, 0, 0, 405, 403, 1, 0, 0, 0, 405, 406, 1, 0, 0, 0, 406, 408, 1, 0, 0, 0, 407, 409, 5, 335, 0, 0, 408, 407, 1, 0, 0, 0, 408, 409, 1, 0, 0, 0, 409, 410, 1, 0, 0, 0, 410, 412, 3, 316, 158, 0, 411, 413, 3, 278, 139, 0, 412, 411, 1, 0, 0, 0, 412, 413, 1, 0, 0, 0, 413, 415, 1, 0, 0, 0, 414, 416, 3, 290, 145, 0, 415, 414, 1, 0, 0, 0, 415, 416, 1, 0, 0, 0, 416, 572, 1, 0, 0, 0, 417, 419, 5, 106, 0, 0, 418, 420, 7, 1, 0, 0, 419, 418, 1, 0, 0, 0, 419, 420, 1, 0, 0, 0, 420, 421, 1, 0, 0, 0, 421, 572, 3, 4, 2, 0, 422, 423, 7, 2, 0, 0, 423, 425, 5, 125, 0, 0, 424, 426, 5, 108, 0, 0, 425, 424, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 427, 1, 0, 0, 0, 427, 572, 3, 34, 17, 0, 428, 429, 7, 2, 0, 0, 429, 431, 5, 72, 0, 0, 430, 432, 5, 108, 0, 0, 431, 430, 1, 0, 0, 0, 431, 432, 1, 0, 0, 0, 432, 433, 1, 0, 0, 0, 433, 572, 3, 70, 35, 0, 434, 436, 7, 2, 0, 0, 435, 437, 5, 231, 0, 0, 436, 435, 1, 0, 0, 0, 436, 437, 1, 0, 0, 0, 437, 438, 1, 0, 0, 0, 438, 572, 3, 24, 12, 0, 439, 441, 7, 2, 0, 0, 440, 442, 5, 292, 0, 0, 441, 440, 1, 0, 0, 0, 441, 442, 1, 0, 0, 0, 442, 444, 1, 0, 0, 0, 443, 445, 7, 3, 0, 0, 444, 443, 1, 0, 0, 0, 444, 445, 1, 0, 0, 0, 445, 446, 1, 0, 0, 0, 446, 448, 3, 76, 38, 0, 447, 449, 3, 28, 14, 0, 448, 447, 1, 0, 0, 0, 448, 449, 1, 0, 0, 0, 449, 451, 1, 0, 0, 0, 450, 452, 3, 36, 18, 0, 451, 450, 1, 0, 0, 0, 451, 452, 1, 0, 0, 0, 452, 572, 1, 0, 0, 0, 453, 454, 5, 51, 0, 0, 454, 460, 5, 202, 0, 0, 455, 456, 3, 32, 16, 0, 456, 457, 3, 70, 35, 0, 457, 461, 1, 0, 0, 0, 458, 459, 5, 292, 0, 0, 459, 461, 3, 76, 38, 0, 460, 455, 1, 0, 0, 0, 460, 458, 1, 0, 0, 0, 461, 462, 1, 0, 0, 0, 462, 465, 5, 153, 0, 0, 463, 466, 3, 334, 167, 0, 464, 466, 5, 197, 0, 0, 465, 463, 1, 0, 0, 0, 465, 464, 1, 0, 0, 0, 466, 572, 1, 0, 0, 0, 467, 468, 5, 239, 0, 0, 468, 469, 5, 292, 0, 0, 469, 572, 3, 76, 38, 0, 470, 471, 5, 239, 0, 0, 471, 472, 5, 125, 0, 0, 472, 572, 3, 316, 158, 0, 473, 481, 5, 239, 0, 0, 474, 482, 3, 334, 167, 0, 475, 477, 9, 0, 0, 0, 476, 475, 1, 0, 0, 0, 477, 480, 1, 0, 0, 0, 478, 479, 1, 0, 0, 0, 478, 476, 1, 0, 0, 0, 479, 482, 1, 0, 0, 0, 480, 478, 1, 0, 0, 0, 481, 474, 1, 0, 0, 0, 481, 478, 1, 0, 0, 0, 482, 572, 1, 0, 0, 0, 483, 485, 5, 33, 0, 0, 484, 486, 5, 159, 0, 0, 485, 484, 1, 0, 0, 0, 485, 486, 1, 0, 0, 0, 486, 487, 1, 0, 0, 0, 487, 488, 5, 292, 0, 0, 488, 491, 3, 76, 38, 0, 489, 490, 5, 206, 0, 0, 490, 492, 3, 48, 24, 0, 491, 489, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 497, 1, 0, 0, 0, 493, 495, 5, 20, 0, 0, 494, 493, 1, 0, 0, 0, 494, 495, 1, 0, 0, 0, 495, 496, 1, 0, 0, 0, 496, 498, 3, 24, 12, 0, 497, 494, 1, 0, 0, 0, 497, 498, 1, 0, 0, 0, 498, 572, 1, 0, 0, 0, 499, 500, 5, 321, 0, 0, 500, 502, 5, 292, 0, 0, 501, 503, 3, 158, 79, 0, 502, 501, 1, 0, 0, 0, 502, 503, 1, 0, 0, 0, 503, 504, 1, 0, 0, 0, 504, 572, 3, 76, 38, 0, 505, 506, 5, 43, 0, 0, 506, 572, 5, 33, 0, 0, 507, 508, 5, 168, 0, 0, 508, 510, 5, 70, 0, 0, 509, 511, 5, 169, 0, 0, 510, 509, 1, 0, 0, 0, 510, 511, 1, 0, 0, 0, 511, 512, 1, 0, 0, 0, 512, 513, 5, 145, 0, 0, 513, 515, 3, 334, 167, 0, 514, 516, 5, 215, 0, 0, 515, 514, 1, 0, 0, 0, 515, 516, 1, 0, 0, 0, 516, 517, 1, 0, 0, 0, 517, 518, 5, 152, 0, 0, 518, 519, 5, 292, 0, 0, 519, 521, 3, 76, 38, 0, 520, 522, 3, 28, 14, 0, 521, 520, 1, 0, 0, 0, 521, 522, 1, 0, 0, 0, 522, 572, 1, 0, 0, 0, 523, 525, 5, 187, 0, 0, 524, 523, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525, 526, 1, 0, 0, 0, 526, 527, 5, 241, 0, 0, 527, 528, 5, 292, 0, 0, 528, 531, 3, 76, 38, 0, 529, 530, 7, 4, 0, 0, 530, 532, 5, 218, 0, 0, 531, 529, 1, 0, 0, 0, 531, 532, 1, 0, 0, 0, 532, 572, 1, 0, 0, 0, 533, 534, 7, 5, 0, 0, 534, 538, 3, 326, 163, 0, 535, 537, 9, 0, 0, 0, 536, 535, 1, 0, 0, 0, 537, 540, 1, 0, 0, 0, 538, 539, 1, 0, 0, 0, 538, 536, 1, 0, 0, 0, 539, 572, 1, 0, 0, 0, 540, 538, 1, 0, 0, 0, 541, 545, 5, 268, 0, 0, 542, 544, 9, 0, 0, 0, 543, 542, 1, 0, 0, 0, 544, 547, 1, 0, 0, 0, 545, 546, 1, 0, 0, 0, 545, 543, 1, 0, 0, 0, 546, 572, 1, 0, 0, 0, 547, 545, 1, 0, 0, 0, 548, 552, 5, 244, 0, 0, 549, 551, 9, 0, 0, 0, 550, 549, 1, 0, 0, 0, 551, 554, 1, 0, 0, 0, 552, 553, 1, 0, 0, 0, 552, 550, 1, 0, 0, 0, 553, 572, 1, 0, 0, 0, 554, 552, 1, 0, 0, 0, 555, 556, 5, 204, 0, 0, 556, 558, 3, 76, 38, 0, 557, 559, 3, 120, 60, 0, 558, 557, 1, 0, 0, 0, 558, 559, 1, 0, 0, 0, 559, 560, 1, 0, 0, 0, 560, 561, 5, 350, 0, 0, 561, 562, 5, 31, 0, 0, 562, 563, 3, 84, 42, 0, 563, 572, 1, 0, 0, 0, 564, 568, 3, 18, 9, 0, 565, 567, 9, 0, 0, 0, 566, 565, 1, 0, 0, 0, 567, 570, 1, 0, 0, 0, 568, 569, 1, 0, 0, 0, 568, 566, 1, 0, 0, 0, 569, 572, 1, 0, 0, 0, 570, 568, 1, 0, 0, 0, 571, 354, 1, 0, 0, 0, 571, 356, 1, 0, 0, 0, 571, 359, 1, 0, 0, 0, 571, 364, 1, 0, 0, 0, 571, 365, 1, 0, 0, 0, 571, 366, 1, 0, 0, 0, 571, 367, 1, 0, 0, 0, 571, 368, 1, 0, 0, 0, 571, 374, 1, 0, 0, 0, 571, 391, 1, 0, 0, 0, 571, 402, 1, 0, 0, 0, 571, 417, 1, 0, 0, 0, 571, 422, 1, 0, 0, 0, 571, 428, 1, 0, 0, 0, 571, 434, 1, 0, 0, 0, 571, 439, 1, 0, 0, 0, 571, 453, 1, 0, 0, 0, 571, 467, 1, 0, 0, 0, 571, 470, 1, 0, 0, 0, 571, 473, 1, 0, 0, 0, 571, 483, 1, 0, 0, 0, 571, 499, 1, 0, 0, 0, 571, 505, 1, 0, 0, 0, 571, 507, 1, 0, 0, 0, 571, 524, 1, 0, 0, 0, 571, 533, 1, 0, 0, 0, 571, 541, 1, 0, 0, 0, 571, 548, 1, 0, 0, 0, 571, 555, 1, 0, 0, 0, 571, 564, 1, 0, 0, 0, 572, 5, 1, 0, 0, 0, 573, 574, 5, 11, 0, 0, 574, 575, 3, 32, 16, 0, 575, 576, 3, 70, 35, 0, 576, 581, 5, 268, 0, 0, 577, 578, 7, 6, 0, 0, 578, 582, 3, 48, 24, 0, 579, 580, 5, 170, 0, 0, 580, 582, 3, 334, 167, 0, 581, 577, 1, 0, 0, 0, 581, 579, 1, 0, 0, 0, 582, 896, 1, 0, 0, 0, 583, 584, 5, 11, 0, 0, 584, 585, 5, 292, 0, 0, 585, 586, 3, 76, 38, 0, 586, 587, 5, 8, 0, 0, 587, 589, 7, 7, 0, 0, 588, 590, 5, 2, 0, 0, 589, 588, 1, 0, 0, 0, 589, 590, 1, 0, 0, 0, 590, 593, 1, 0, 0, 0, 591, 594, 3, 282, 141, 0, 592, 594, 3, 280, 140, 0, 593, 591, 1, 0, 0, 0, 593, 592, 1, 0, 0, 0, 594, 596, 1, 0, 0, 0, 595, 597, 5, 3, 0, 0, 596, 595, 1, 0, 0, 0, 596, 597, 1, 0, 0, 0, 597, 896, 1, 0, 0, 0, 598, 599, 5, 11, 0, 0, 599, 600, 5, 292, 0, 0, 600, 601, 3, 76, 38, 0, 601, 602, 5, 96, 0, 0, 602, 604, 7, 7, 0, 0, 603, 605, 3, 158, 79, 0, 604, 603, 1, 0, 0, 0, 604, 605, 1, 0, 0, 0, 605, 607, 1, 0, 0, 0, 606, 608, 5, 2, 0, 0, 607, 606, 1, 0, 0, 0, 607, 608, 1, 0, 0, 0, 608, 611, 1, 0, 0, 0, 609, 612, 3, 82, 41, 0, 610, 612, 3, 84, 42, 0, 611, 609, 1, 0, 0, 0, 611, 610, 1, 0, 0, 0, 612, 614, 1, 0, 0, 0, 613, 615, 5, 3, 0, 0, 614, 613, 1, 0, 0, 0, 614, 615, 1, 0, 0, 0, 615, 896, 1, 0, 0, 0, 616, 621, 5, 11, 0, 0, 617, 618, 5, 292, 0, 0, 618, 622, 3, 76, 38, 0, 619, 620, 5, 337, 0, 0, 620, 622, 3, 80, 40, 0, 621, 617, 1, 0, 0, 0, 621, 619, 1, 0, 0, 0, 622, 623, 1, 0, 0, 0, 623, 626, 5, 240, 0, 0, 624, 625, 5, 49, 0, 0, 625, 627, 3, 82, 41, 0, 626, 624, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 628, 1, 0, 0, 0, 628, 631, 5, 308, 0, 0, 629, 632, 3, 86, 43, 0, 630, 632, 3, 206, 103, 0, 631, 629, 1, 0, 0, 0, 631, 630, 1, 0, 0, 0, 632, 896, 1, 0, 0, 0, 633, 638, 5, 11, 0, 0, 634, 635, 5, 292, 0, 0, 635, 639, 3, 76, 38, 0, 636, 637, 5, 337, 0, 0, 637, 639, 3, 80, 40, 0, 638, 634, 1, 0, 0, 0, 638, 636, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, 640, 641, 7, 8, 0, 0, 641, 643, 5, 296, 0, 0, 642, 644, 3, 158, 79, 0, 643, 642, 1, 0, 0, 0, 643, 644, 1, 0, 0, 0, 644, 645, 1, 0, 0, 0, 645, 646, 3, 48, 24, 0, 646, 896, 1, 0, 0, 0, 647, 648, 5, 11, 0, 0, 648, 649, 5, 292, 0, 0, 649, 650, 3, 76, 38, 0, 650, 652, 7, 9, 0, 0, 651, 653, 5, 49, 0, 0, 652, 651, 1, 0, 0, 0, 652, 653, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 656, 3, 82, 41, 0, 655, 657, 3, 332, 166, 0, 656, 655, 1, 0, 0, 0, 656, 657, 1, 0, 0, 0, 657, 896, 1, 0, 0, 0, 658, 659, 5, 11, 0, 0, 659, 660, 5, 292, 0, 0, 660, 662, 3, 76, 38, 0, 661, 663, 3, 28, 14, 0, 662, 661, 1, 0, 0, 0, 662, 663, 1, 0, 0, 0, 663, 670, 1, 0, 0, 0, 664, 666, 5, 39, 0, 0, 665, 667, 5, 49, 0, 0, 666, 665, 1, 0, 0, 0, 666, 667, 1, 0, 0, 0, 667, 671, 1, 0, 0, 0, 668, 669, 5, 243, 0, 0, 669, 671, 5, 50, 0, 0, 670, 664, 1, 0, 0, 0, 670, 668, 1, 0, 0, 0, 671, 681, 1, 0, 0, 0, 672, 673, 3, 82, 41, 0, 673, 675, 3, 294, 147, 0, 674, 676, 3, 274, 137, 0, 675, 674, 1, 0, 0, 0, 675, 676, 1, 0, 0, 0, 676, 682, 1, 0, 0, 0, 677, 678, 5, 2, 0, 0, 678, 679, 3, 284, 142, 0, 679, 680, 5, 3, 0, 0, 680, 682, 1, 0, 0, 0, 681, 672, 1, 0, 0, 0, 681, 677, 1, 0, 0, 0, 682, 896, 1, 0, 0, 0, 683, 688, 5, 11, 0, 0, 684, 685, 5, 292, 0, 0, 685, 689, 3, 76, 38, 0, 686, 687, 5, 337, 0, 0, 687, 689, 3, 80, 40, 0, 688, 684, 1, 0, 0, 0, 688, 686, 1, 0, 0, 0, 689, 690, 1, 0, 0, 0, 690, 693, 7, 10, 0, 0, 691, 694, 3, 156, 78, 0, 692, 694, 3, 158, 79, 0, 693, 691, 1, 0, 0, 0, 693, 692, 1, 0, 0, 0, 693, 694, 1, 0, 0, 0, 694, 701, 1, 0, 0, 0, 695, 697, 3, 26, 13, 0, 696, 695, 1, 0, 0, 0, 697, 698, 1, 0, 0, 0, 698, 696, 1, 0, 0, 0, 698, 699, 1, 0, 0, 0, 699, 702, 1, 0, 0, 0, 700, 702, 3, 28, 14, 0, 701, 696, 1, 0, 0, 0, 701, 700, 1, 0, 0, 0, 702, 707, 1, 0, 0, 0, 703, 704, 5, 4, 0, 0, 704, 706, 3, 28, 14, 0, 705, 703, 1, 0, 0, 0, 706, 709, 1, 0, 0, 0, 707, 705, 1, 0, 0, 0, 707, 708, 1, 0, 0, 0, 708, 711, 1, 0, 0, 0, 709, 707, 1, 0, 0, 0, 710, 712, 5, 229, 0, 0, 711, 710, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 896, 1, 0, 0, 0, 713, 714, 5, 11, 0, 0, 714, 715, 5, 337, 0, 0, 715, 717, 3, 80, 40, 0, 716, 718, 5, 20, 0, 0, 717, 716, 1, 0, 0, 0, 717, 718, 1, 0, 0, 0, 718, 719, 1, 0, 0, 0, 719, 720, 3, 24, 12, 0, 720, 896, 1, 0, 0, 0, 721, 722, 5, 11, 0, 0, 722, 723, 5, 292, 0, 0, 723, 725, 3, 76, 38, 0, 724, 726, 3, 28, 14, 0, 725, 724, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 727, 1, 0, 0, 0, 727, 729, 5, 39, 0, 0, 728, 730, 5, 49, 0, 0, 729, 728, 1, 0, 0, 0, 729, 730, 1, 0, 0, 0, 730, 731, 1, 0, 0, 0, 731, 732, 3, 82, 41, 0, 732, 734, 3, 294, 147, 0, 733, 735, 3, 274, 137, 0, 734, 733, 1, 0, 0, 0, 734, 735, 1, 0, 0, 0, 735, 896, 1, 0, 0, 0, 736, 737, 5, 11, 0, 0, 737, 738, 5, 292, 0, 0, 738, 740, 3, 76, 38, 0, 739, 741, 3, 28, 14, 0, 740, 739, 1, 0, 0, 0, 740, 741, 1, 0, 0, 0, 741, 742, 1, 0, 0, 0, 742, 743, 5, 243, 0, 0, 743, 744, 5, 50, 0, 0, 744, 745, 5, 2, 0, 0, 745, 746, 3, 284, 142, 0, 746, 747, 5, 3, 0, 0, 747, 896, 1, 0, 0, 0, 748, 749, 5, 11, 0, 0, 749, 750, 5, 292, 0, 0, 750, 752, 3, 76, 38, 0, 751, 753, 3, 28, 14, 0, 752, 751, 1, 0, 0, 0, 752, 753, 1, 0, 0, 0, 753, 754, 1, 0, 0, 0, 754, 757, 5, 268, 0, 0, 755, 756, 5, 170, 0, 0, 756, 758, 3, 334, 167, 0, 757, 755, 1, 0, 0, 0, 757, 758, 1, 0, 0, 0, 758, 760, 1, 0, 0, 0, 759, 761, 5, 265, 0, 0, 760, 759, 1, 0, 0, 0, 760, 761, 1, 0, 0, 0, 761, 763, 1, 0, 0, 0, 762, 764, 3, 334, 167, 0, 763, 762, 1, 0, 0, 0, 763, 764, 1, 0, 0, 0, 764, 766, 1, 0, 0, 0, 765, 767, 5, 345, 0, 0, 766, 765, 1, 0, 0, 0, 766, 767, 1, 0, 0, 0, 767, 769, 1, 0, 0, 0, 768, 770, 5, 266, 0, 0, 769, 768, 1, 0, 0, 0, 769, 770, 1, 0, 0, 0, 770, 772, 1, 0, 0, 0, 771, 773, 3, 48, 24, 0, 772, 771, 1, 0, 0, 0, 772, 773, 1, 0, 0, 0, 773, 896, 1, 0, 0, 0, 774, 775, 5, 11, 0, 0, 775, 776, 5, 292, 0, 0, 776, 777, 3, 76, 38, 0, 777, 778, 3, 28, 14, 0, 778, 779, 5, 240, 0, 0, 779, 780, 5, 308, 0, 0, 780, 781, 3, 28, 14, 0, 781, 896, 1, 0, 0, 0, 782, 787, 5, 11, 0, 0, 783, 784, 5, 292, 0, 0, 784, 788, 3, 76, 38, 0, 785, 786, 5, 337, 0, 0, 786, 788, 3, 80, 40, 0, 787, 783, 1, 0, 0, 0, 787, 785, 1, 0, 0, 0, 788, 789, 1, 0, 0, 0, 789, 791, 5, 8, 0, 0, 790, 792, 3, 156, 78, 0, 791, 790, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 793, 1, 0, 0, 0, 793, 794, 3, 26, 13, 0, 794, 896, 1, 0, 0, 0, 795, 800, 5, 11, 0, 0, 796, 797, 5, 292, 0, 0, 797, 801, 3, 76, 38, 0, 798, 799, 5, 337, 0, 0, 799, 801, 3, 80, 40, 0, 800, 796, 1, 0, 0, 0, 800, 798, 1, 0, 0, 0, 801, 802, 1, 0, 0, 0, 802, 804, 5, 96, 0, 0, 803, 805, 3, 158, 79, 0, 804, 803, 1, 0, 0, 0, 804, 805, 1, 0, 0, 0, 805, 806, 1, 0, 0, 0, 806, 811, 3, 28, 14, 0, 807, 808, 5, 4, 0, 0, 808, 810, 3, 28, 14, 0, 809, 807, 1, 0, 0, 0, 810, 813, 1, 0, 0, 0, 811, 809, 1, 0, 0, 0, 811, 812, 1, 0, 0, 0, 812, 815, 1, 0, 0, 0, 813, 811, 1, 0, 0, 0, 814, 816, 5, 229, 0, 0, 815, 814, 1, 0, 0, 0, 815, 816, 1, 0, 0, 0, 816, 896, 1, 0, 0, 0, 817, 818, 5, 11, 0, 0, 818, 819, 5, 292, 0, 0, 819, 820, 3, 76, 38, 0, 820, 821, 5, 236, 0, 0, 821, 822, 5, 218, 0, 0, 822, 896, 1, 0, 0, 0, 823, 824, 5, 11, 0, 0, 824, 828, 5, 142, 0, 0, 825, 827, 9, 0, 0, 0, 826, 825, 1, 0, 0, 0, 827, 830, 1, 0, 0, 0, 828, 829, 1, 0, 0, 0, 828, 826, 1, 0, 0, 0, 829, 896, 1, 0, 0, 0, 830, 828, 1, 0, 0, 0, 831, 832, 5, 11, 0, 0, 832, 833, 5, 292, 0, 0, 833, 834, 3, 76, 38, 0, 834, 836, 7, 11, 0, 0, 835, 837, 5, 31, 0, 0, 836, 835, 1, 0, 0, 0, 836, 837, 1, 0, 0, 0, 837, 841, 1, 0, 0, 0, 838, 840, 9, 0, 0, 0, 839, 838, 1, 0, 0, 0, 840, 843, 1, 0, 0, 0, 841, 842, 1, 0, 0, 0, 841, 839, 1, 0, 0, 0, 842, 896, 1, 0, 0, 0, 843, 841, 1, 0, 0, 0, 844, 845, 5, 11, 0, 0, 845, 846, 5, 292, 0, 0, 846, 847, 3, 76, 38, 0, 847, 848, 7, 12, 0, 0, 848, 850, 7, 13, 0, 0, 849, 851, 5, 170, 0, 0, 850, 849, 1, 0, 0, 0, 850, 851, 1, 0, 0, 0, 851, 853, 1, 0, 0, 0, 852, 854, 5, 20, 0, 0, 853, 852, 1, 0, 0, 0, 853, 854, 1, 0, 0, 0, 854, 856, 1, 0, 0, 0, 855, 857, 5, 89, 0, 0, 856, 855, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 857, 861, 1, 0, 0, 0, 858, 860, 9, 0, 0, 0, 859, 858, 1, 0, 0, 0, 860, 863, 1, 0, 0, 0, 861, 862, 1, 0, 0, 0, 861, 859, 1, 0, 0, 0, 862, 896, 1, 0, 0, 0, 863, 861, 1, 0, 0, 0, 864, 865, 5, 11, 0, 0, 865, 866, 5, 292, 0, 0, 866, 867, 3, 76, 38, 0, 867, 868, 7, 14, 0, 0, 868, 872, 5, 216, 0, 0, 869, 871, 9, 0, 0, 0, 870, 869, 1, 0, 0, 0, 871, 874, 1, 0, 0, 0, 872, 873, 1, 0, 0, 0, 872, 870, 1, 0, 0, 0, 873, 896, 1, 0, 0, 0, 874, 872, 1, 0, 0, 0, 875, 876, 5, 11, 0, 0, 876, 877, 5, 292, 0, 0, 877, 879, 3, 76, 38, 0, 878, 880, 3, 28, 14, 0, 879, 878, 1, 0, 0, 0, 879, 880, 1, 0, 0, 0, 880, 887, 1, 0, 0, 0, 881, 888, 5, 53, 0, 0, 882, 888, 5, 56, 0, 0, 883, 884, 5, 268, 0, 0, 884, 888, 5, 115, 0, 0, 885, 886, 5, 243, 0, 0, 886, 888, 5, 50, 0, 0, 887, 881, 1, 0, 0, 0, 887, 882, 1, 0, 0, 0, 887, 883, 1, 0, 0, 0, 887, 885, 1, 0, 0, 0, 888, 892, 1, 0, 0, 0, 889, 891, 9, 0, 0, 0, 890, 889, 1, 0, 0, 0, 891, 894, 1, 0, 0, 0, 892, 893, 1, 0, 0, 0, 892, 890, 1, 0, 0, 0, 893, 896, 1, 0, 0, 0, 894, 892, 1, 0, 0, 0, 895, 573, 1, 0, 0, 0, 895, 583, 1, 0, 0, 0, 895, 598, 1, 0, 0, 0, 895, 616, 1, 0, 0, 0, 895, 633, 1, 0, 0, 0, 895, 647, 1, 0, 0, 0, 895, 658, 1, 0, 0, 0, 895, 683, 1, 0, 0, 0, 895, 713, 1, 0, 0, 0, 895, 721, 1, 0, 0, 0, 895, 736, 1, 0, 0, 0, 895, 748, 1, 0, 0, 0, 895, 774, 1, 0, 0, 0, 895, 782, 1, 0, 0, 0, 895, 795, 1, 0, 0, 0, 895, 817, 1, 0, 0, 0, 895, 823, 1, 0, 0, 0, 895, 831, 1, 0, 0, 0, 895, 844, 1, 0, 0, 0, 895, 864, 1, 0, 0, 0, 895, 875, 1, 0, 0, 0, 896, 7, 1, 0, 0, 0, 897, 898, 5, 59, 0, 0, 898, 900, 3, 32, 16, 0, 899, 901, 3, 156, 78, 0, 900, 899, 1, 0, 0, 0, 900, 901, 1, 0, 0, 0, 901, 902, 1, 0, 0, 0, 902, 912, 3, 72, 36, 0, 903, 904, 5, 51, 0, 0, 904, 911, 3, 334, 167, 0, 905, 906, 5, 170, 0, 0, 906, 911, 3, 334, 167, 0, 907, 908, 5, 345, 0, 0, 908, 909, 7, 6, 0, 0, 909, 911, 3, 48, 24, 0, 910, 903, 1, 0, 0, 0, 910, 905, 1, 0, 0, 0, 910, 907, 1, 0, 0, 0, 911, 914, 1, 0, 0, 0, 912, 910, 1, 0, 0, 0, 912, 913, 1, 0, 0, 0, 913, 1109, 1, 0, 0, 0, 914, 912, 1, 0, 0, 0, 915, 917, 5, 59, 0, 0, 916, 918, 5, 297, 0, 0, 917, 916, 1, 0, 0, 0, 917, 918, 1, 0, 0, 0, 918, 920, 1, 0, 0, 0, 919, 921, 5, 109, 0, 0, 920, 919, 1, 0, 0, 0, 920, 921, 1, 0, 0, 0, 921, 922, 1, 0, 0, 0, 922, 924, 5, 292, 0, 0, 923, 925, 3, 156, 78, 0, 924, 923, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 926, 1, 0, 0, 0, 926, 931, 3, 74, 37, 0, 927, 928, 5, 2, 0, 0, 928, 929, 3, 296, 148, 0, 929, 930, 5, 3, 0, 0, 930, 932, 1, 0, 0, 0, 931, 927, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 934, 1, 0, 0, 0, 933, 935, 3, 42, 21, 0, 934, 933, 1, 0, 0, 0, 934, 935, 1, 0, 0, 0, 935, 936, 1, 0, 0, 0, 936, 941, 3, 44, 22, 0, 937, 939, 5, 20, 0, 0, 938, 937, 1, 0, 0, 0, 938, 939, 1, 0, 0, 0, 939, 940, 1, 0, 0, 0, 940, 942, 3, 24, 12, 0, 941, 938, 1, 0, 0, 0, 941, 942, 1, 0, 0, 0, 942, 1109, 1, 0, 0, 0, 943, 944, 5, 59, 0, 0, 944, 946, 5, 207, 0, 0, 945, 943, 1, 0, 0, 0, 945, 946, 1, 0, 0, 0, 946, 947, 1, 0, 0, 0, 947, 948, 5, 243, 0, 0, 948, 949, 5, 292, 0, 0, 949, 954, 3, 74, 37, 0, 950, 951, 5, 2, 0, 0, 951, 952, 3, 296, 148, 0, 952, 953, 5, 3, 0, 0, 953, 955, 1, 0, 0, 0, 954, 950, 1, 0, 0, 0, 954, 955, 1, 0, 0, 0, 955, 957, 1, 0, 0, 0, 956, 958, 3, 42, 21, 0, 957, 956, 1, 0, 0, 0, 957, 958, 1, 0, 0, 0, 958, 959, 1, 0, 0, 0, 959, 964, 3, 44, 22, 0, 960, 962, 5, 20, 0, 0, 961, 960, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 963, 1, 0, 0, 0, 963, 965, 3, 24, 12, 0, 964, 961, 1, 0, 0, 0, 964, 965, 1, 0, 0, 0, 965, 1109, 1, 0, 0, 0, 966, 967, 5, 59, 0, 0, 967, 969, 5, 292, 0, 0, 968, 970, 3, 156, 78, 0, 969, 968, 1, 0, 0, 0, 969, 970, 1, 0, 0, 0, 970, 971, 1, 0, 0, 0, 971, 972, 3, 74, 37, 0, 972, 973, 5, 163, 0, 0, 973, 984, 3, 76, 38, 0, 974, 983, 3, 42, 21, 0, 975, 983, 3, 202, 101, 0, 976, 983, 3, 64, 32, 0, 977, 978, 5, 170, 0, 0, 978, 983, 3, 334, 167, 0, 979, 980, 5, 296, 0, 0, 980, 983, 3, 48, 24, 0, 981, 983, 3, 46, 23, 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, 979, 1, 0, 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, 1109, 1, 0, 0, 0, 986, 984, 1, 0, 0, 0, 987, 990, 5, 59, 0, 0, 988, 989, 5, 207, 0, 0, 989, 991, 5, 243, 0, 0, 990, 988, 1, 0, 0, 0, 990, 991, 1, 0, 0, 0, 991, 996, 1, 0, 0, 0, 992, 994, 5, 128, 0, 0, 993, 992, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 994, 995, 1, 0, 0, 0, 995, 997, 5, 297, 0, 0, 996, 993, 1, 0, 0, 0, 996, 997, 1, 0, 0, 0, 997, 998, 1, 0, 0, 0, 998, 1000, 5, 337, 0, 0, 999, 1001, 3, 156, 78, 0, 1000, 999, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1002, 1, 0, 0, 0, 1002, 1004, 3, 78, 39, 0, 1003, 1005, 3, 184, 92, 0, 1004, 1003, 1, 0, 0, 0, 1004, 1005, 1, 0, 0, 0, 1005, 1015, 1, 0, 0, 0, 1006, 1007, 5, 51, 0, 0, 1007, 1014, 3, 334, 167, 0, 1008, 1009, 5, 217, 0, 0, 1009, 1010, 5, 202, 0, 0, 1010, 1014, 3, 176, 88, 0, 1011, 1012, 5, 296, 0, 0, 1012, 1014, 3, 48, 24, 0, 1013, 1006, 1, 0, 0, 0, 1013, 1008, 1, 0, 0, 0, 1013, 1011, 1, 0, 0, 0, 1014, 1017, 1, 0, 0, 0, 1015, 1013, 1, 0, 0, 0, 1015, 1016, 1, 0, 0, 0, 1016, 1018, 1, 0, 0, 0, 1017, 1015, 1, 0, 0, 0, 1018, 1019, 5, 20, 0, 0, 1019, 1020, 3, 24, 12, 0, 1020, 1109, 1, 0, 0, 0, 1021, 1024, 5, 59, 0, 0, 1022, 1023, 5, 207, 0, 0, 1023, 1025, 5, 243, 0, 0, 1024, 1022, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1027, 1, 0, 0, 0, 1026, 1028, 5, 128, 0, 0, 1027, 1026, 1, 0, 0, 0, 1027, 1028, 1, 0, 0, 0, 1028, 1029, 1, 0, 0, 0, 1029, 1030, 5, 297, 0, 0, 1030, 1031, 5, 337, 0, 0, 1031, 1036, 3, 78, 39, 0, 1032, 1033, 5, 2, 0, 0, 1033, 1034, 3, 292, 146, 0, 1034, 1035, 5, 3, 0, 0, 1035, 1037, 1, 0, 0, 0, 1036, 1032, 1, 0, 0, 0, 1036, 1037, 1, 0, 0, 0, 1037, 1038, 1, 0, 0, 0, 1038, 1041, 3, 42, 21, 0, 1039, 1040, 5, 206, 0, 0, 1040, 1042, 3, 48, 24, 0, 1041, 1039, 1, 0, 0, 0, 1041, 1042, 1, 0, 0, 0, 1042, 1109, 1, 0, 0, 0, 1043, 1046, 5, 59, 0, 0, 1044, 1045, 5, 207, 0, 0, 1045, 1047, 5, 243, 0, 0, 1046, 1044, 1, 0, 0, 0, 1046, 1047, 1, 0, 0, 0, 1047, 1049, 1, 0, 0, 0, 1048, 1050, 5, 297, 0, 0, 1049, 1048, 1, 0, 0, 0, 1049, 1050, 1, 0, 0, 0, 1050, 1051, 1, 0, 0, 0, 1051, 1053, 5, 125, 0, 0, 1052, 1054, 3, 156, 78, 0, 1053, 1052, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1054, 1055, 1, 0, 0, 0, 1055, 1056, 3, 318, 159, 0, 1056, 1057, 5, 20, 0, 0, 1057, 1071, 3, 334, 167, 0, 1058, 1059, 5, 331, 0, 0, 1059, 1060, 3, 326, 163, 0, 1060, 1061, 3, 334, 167, 0, 1061, 1068, 1, 0, 0, 0, 1062, 1063, 5, 4, 0, 0, 1063, 1064, 3, 326, 163, 0, 1064, 1065, 3, 334, 167, 0, 1065, 1067, 1, 0, 0, 0, 1066, 1062, 1, 0, 0, 0, 1067, 1070, 1, 0, 0, 0, 1068, 1066, 1, 0, 0, 0, 1068, 1069, 1, 0, 0, 0, 1069, 1072, 1, 0, 0, 0, 1070, 1068, 1, 0, 0, 0, 1071, 1058, 1, 0, 0, 0, 1071, 1072, 1, 0, 0, 0, 1072, 1109, 1, 0, 0, 0, 1073, 1074, 5, 59, 0, 0, 1074, 1076, 5, 142, 0, 0, 1075, 1077, 3, 156, 78, 0, 1076, 1075, 1, 0, 0, 0, 1076, 1077, 1, 0, 0, 0, 1077, 1078, 1, 0, 0, 0, 1078, 1079, 3, 326, 163, 0, 1079, 1081, 5, 202, 0, 0, 1080, 1082, 5, 292, 0, 0, 1081, 1080, 1, 0, 0, 0, 1081, 1082, 1, 0, 0, 0, 1082, 1083, 1, 0, 0, 0, 1083, 1086, 3, 76, 38, 0, 1084, 1085, 5, 331, 0, 0, 1085, 1087, 3, 326, 163, 0, 1086, 1084, 1, 0, 0, 0, 1086, 1087, 1, 0, 0, 0, 1087, 1088, 1, 0, 0, 0, 1088, 1089, 5, 2, 0, 0, 1089, 1090, 3, 208, 104, 0, 1090, 1093, 5, 3, 0, 0, 1091, 1092, 5, 206, 0, 0, 1092, 1094, 3, 48, 24, 0, 1093, 1091, 1, 0, 0, 0, 1093, 1094, 1, 0, 0, 0, 1094, 1109, 1, 0, 0, 0, 1095, 1100, 5, 59, 0, 0, 1096, 1101, 5, 252, 0, 0, 1097, 1101, 5, 142, 0, 0, 1098, 1099, 5, 297, 0, 0, 1099, 1101, 5, 175, 0, 0, 1100, 1096, 1, 0, 0, 0, 1100, 1097, 1, 0, 0, 0, 1100, 1098, 1, 0, 0, 0, 1101, 1105, 1, 0, 0, 0, 1102, 1104, 9, 0, 0, 0, 1103, 1102, 1, 0, 0, 0, 1104, 1107, 1, 0, 0, 0, 1105, 1106, 1, 0, 0, 0, 1105, 1103, 1, 0, 0, 0, 1106, 1109, 1, 0, 0, 0, 1107, 1105, 1, 0, 0, 0, 1108, 897, 1, 0, 0, 0, 1108, 915, 1, 0, 0, 0, 1108, 945, 1, 0, 0, 0, 1108, 966, 1, 0, 0, 0, 1108, 987, 1, 0, 0, 0, 1108, 1021, 1, 0, 0, 0, 1108, 1043, 1, 0, 0, 0, 1108, 1073, 1, 0, 0, 0, 1108, 1095, 1, 0, 0, 0, 1109, 9, 1, 0, 0, 0, 1110, 1111, 5, 96, 0, 0, 1111, 1113, 3, 32, 16, 0, 1112, 1114, 3, 158, 79, 0, 1113, 1112, 1, 0, 0, 0, 1113, 1114, 1, 0, 0, 0, 1114, 1115, 1, 0, 0, 0, 1115, 1117, 3, 70, 35, 0, 1116, 1118, 7, 15, 0, 0, 1117, 1116, 1, 0, 0, 0, 1117, 1118, 1, 0, 0, 0, 1118, 1178, 1, 0, 0, 0, 1119, 1120, 5, 96, 0, 0, 1120, 1122, 5, 292, 0, 0, 1121, 1123, 3, 158, 79, 0, 1122, 1121, 1, 0, 0, 0, 1122, 1123, 1, 0, 0, 0, 1123, 1124, 1, 0, 0, 0, 1124, 1126, 3, 76, 38, 0, 1125, 1127, 5, 229, 0, 0, 1126, 1125, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1178, 1, 0, 0, 0, 1128, 1129, 5, 96, 0, 0, 1129, 1131, 5, 337, 0, 0, 1130, 1132, 3, 158, 79, 0, 1131, 1130, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 1133, 1, 0, 0, 0, 1133, 1178, 3, 80, 40, 0, 1134, 1136, 5, 96, 0, 0, 1135, 1137, 5, 297, 0, 0, 1136, 1135, 1, 0, 0, 0, 1136, 1137, 1, 0, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, 1140, 5, 125, 0, 0, 1139, 1141, 3, 158, 79, 0, 1140, 1139, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 1142, 1, 0, 0, 0, 1142, 1178, 3, 316, 158, 0, 1143, 1144, 5, 96, 0, 0, 1144, 1145, 5, 297, 0, 0, 1145, 1147, 5, 335, 0, 0, 1146, 1148, 3, 158, 79, 0, 1147, 1146, 1, 0, 0, 0, 1147, 1148, 1, 0, 0, 0, 1148, 1152, 1, 0, 0, 0, 1149, 1153, 3, 76, 38, 0, 1150, 1153, 3, 80, 40, 0, 1151, 1153, 3, 316, 158, 0, 1152, 1149, 1, 0, 0, 0, 1152, 1150, 1, 0, 0, 0, 1152, 1151, 1, 0, 0, 0, 1153, 1178, 1, 0, 0, 0, 1154, 1155, 5, 96, 0, 0, 1155, 1157, 5, 142, 0, 0, 1156, 1158, 3, 158, 79, 0, 1157, 1156, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1160, 3, 326, 163, 0, 1160, 1162, 5, 202, 0, 0, 1161, 1163, 5, 292, 0, 0, 1162, 1161, 1, 0, 0, 0, 1162, 1163, 1, 0, 0, 0, 1163, 1164, 1, 0, 0, 0, 1164, 1165, 3, 76, 38, 0, 1165, 1178, 1, 0, 0, 0, 1166, 1167, 5, 96, 0, 0, 1167, 1169, 7, 16, 0, 0, 1168, 1170, 5, 175, 0, 0, 1169, 1168, 1, 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1174, 1, 0, 0, 0, 1171, 1173, 9, 0, 0, 0, 1172, 1171, 1, 0, 0, 0, 1173, 1176, 1, 0, 0, 0, 1174, 1175, 1, 0, 0, 0, 1174, 1172, 1, 0, 0, 0, 1175, 1178, 1, 0, 0, 0, 1176, 1174, 1, 0, 0, 0, 1177, 1110, 1, 0, 0, 0, 1177, 1119, 1, 0, 0, 0, 1177, 1128, 1, 0, 0, 0, 1177, 1134, 1, 0, 0, 0, 1177, 1143, 1, 0, 0, 0, 1177, 1154, 1, 0, 0, 0, 1177, 1166, 1, 0, 0, 0, 1178, 11, 1, 0, 0, 0, 1179, 1180, 3, 14, 7, 0, 1180, 1181, 3, 24, 12, 0, 1181, 1238, 1, 0, 0, 0, 1182, 1186, 3, 128, 64, 0, 1183, 1184, 3, 14, 7, 0, 1184, 1185, 3, 98, 49, 0, 1185, 1187, 1, 0, 0, 0, 1186, 1183, 1, 0, 0, 0, 1187, 1188, 1, 0, 0, 0, 1188, 1186, 1, 0, 0, 0, 1188, 1189, 1, 0, 0, 0, 1189, 1238, 1, 0, 0, 0, 1190, 1191, 5, 84, 0, 0, 1191, 1192, 5, 123, 0, 0, 1192, 1193, 3, 76, 38, 0, 1193, 1195, 3, 200, 100, 0, 1194, 1196, 3, 120, 60, 0, 1195, 1194, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1238, 1, 0, 0, 0, 1197, 1198, 5, 328, 0, 0, 1198, 1199, 3, 76, 38, 0, 1199, 1200, 3, 200, 100, 0, 1200, 1202, 3, 106, 53, 0, 1201, 1203, 3, 120, 60, 0, 1202, 1201, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 1238, 1, 0, 0, 0, 1204, 1205, 5, 178, 0, 0, 1205, 1206, 5, 152, 0, 0, 1206, 1207, 3, 76, 38, 0, 1207, 1208, 3, 200, 100, 0, 1208, 1214, 5, 331, 0, 0, 1209, 1215, 3, 88, 44, 0, 1210, 1211, 5, 2, 0, 0, 1211, 1212, 3, 24, 12, 0, 1212, 1213, 5, 3, 0, 0, 1213, 1215, 1, 0, 0, 0, 1214, 1209, 1, 0, 0, 0, 1214, 1210, 1, 0, 0, 0, 1215, 1216, 1, 0, 0, 0, 1216, 1217, 3, 200, 100, 0, 1217, 1218, 5, 202, 0, 0, 1218, 1222, 3, 236, 118, 0, 1219, 1221, 3, 108, 54, 0, 1220, 1219, 1, 0, 0, 0, 1221, 1224, 1, 0, 0, 0, 1222, 1220, 1, 0, 0, 0, 1222, 1223, 1, 0, 0, 0, 1223, 1228, 1, 0, 0, 0, 1224, 1222, 1, 0, 0, 0, 1225, 1227, 3, 110, 55, 0, 1226, 1225, 1, 0, 0, 0, 1227, 1230, 1, 0, 0, 0, 1228, 1226, 1, 0, 0, 0, 1228, 1229, 1, 0, 0, 0, 1229, 1234, 1, 0, 0, 0, 1230, 1228, 1, 0, 0, 0, 1231, 1233, 3, 112, 56, 0, 1232, 1231, 1, 0, 0, 0, 1233, 1236, 1, 0, 0, 0, 1234, 1232, 1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1238, 1, 0, 0, 0, 1236, 1234, 1, 0, 0, 0, 1237, 1179, 1, 0, 0, 0, 1237, 1182, 1, 0, 0, 0, 1237, 1190, 1, 0, 0, 0, 1237, 1197, 1, 0, 0, 0, 1237, 1204, 1, 0, 0, 0, 1238, 13, 1, 0, 0, 0, 1239, 1240, 5, 147, 0, 0, 1240, 1242, 5, 152, 0, 0, 1241, 1243, 5, 292, 0, 0, 1242, 1241, 1, 0, 0, 0, 1242, 1243, 1, 0, 0, 0, 1243, 1244, 1, 0, 0, 0, 1244, 1246, 3, 76, 38, 0, 1245, 1247, 3, 28, 14, 0, 1246, 1245, 1, 0, 0, 0, 1246, 1247, 1, 0, 0, 0, 1247, 1249, 1, 0, 0, 0, 1248, 1250, 3, 156, 78, 0, 1249, 1248, 1, 0, 0, 0, 1249, 1250, 1, 0, 0, 0, 1250, 1257, 1, 0, 0, 0, 1251, 1252, 5, 31, 0, 0, 1252, 1258, 5, 188, 0, 0, 1253, 1254, 5, 2, 0, 0, 1254, 1255, 3, 84, 42, 0, 1255, 1256, 5, 3, 0, 0, 1256, 1258, 1, 0, 0, 0, 1257, 1251, 1, 0, 0, 0, 1257, 1253, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1311, 1, 0, 0, 0, 1259, 1260, 5, 147, 0, 0, 1260, 1262, 5, 152, 0, 0, 1261, 1263, 5, 292, 0, 0, 1262, 1261, 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 1264, 1, 0, 0, 0, 1264, 1265, 3, 76, 38, 0, 1265, 1266, 5, 243, 0, 0, 1266, 1267, 3, 120, 60, 0, 1267, 1311, 1, 0, 0, 0, 1268, 1269, 5, 147, 0, 0, 1269, 1271, 5, 215, 0, 0, 1270, 1272, 5, 292, 0, 0, 1271, 1270, 1, 0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 1273, 1, 0, 0, 0, 1273, 1278, 3, 76, 38, 0, 1274, 1276, 3, 28, 14, 0, 1275, 1277, 3, 156, 78, 0, 1276, 1275, 1, 0, 0, 0, 1276, 1277, 1, 0, 0, 0, 1277, 1279, 1, 0, 0, 0, 1278, 1274, 1, 0, 0, 0, 1278, 1279, 1, 0, 0, 0, 1279, 1286, 1, 0, 0, 0, 1280, 1281, 5, 31, 0, 0, 1281, 1287, 5, 188, 0, 0, 1282, 1283, 5, 2, 0, 0, 1283, 1284, 3, 84, 42, 0, 1284, 1285, 5, 3, 0, 0, 1285, 1287, 1, 0, 0, 0, 1286, 1280, 1, 0, 0, 0, 1286, 1282, 1, 0, 0, 0, 1286, 1287, 1, 0, 0, 0, 1287, 1311, 1, 0, 0, 0, 1288, 1289, 5, 147, 0, 0, 1289, 1291, 5, 215, 0, 0, 1290, 1292, 5, 169, 0, 0, 1291, 1290, 1, 0, 0, 0, 1291, 1292, 1, 0, 0, 0, 1292, 1293, 1, 0, 0, 0, 1293, 1295, 5, 90, 0, 0, 1294, 1296, 3, 334, 167, 0, 1295, 1294, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1298, 1, 0, 0, 0, 1297, 1299, 3, 202, 101, 0, 1298, 1297, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1301, 1, 0, 0, 0, 1300, 1302, 3, 64, 32, 0, 1301, 1300, 1, 0, 0, 0, 1301, 1302, 1, 0, 0, 0, 1302, 1304, 1, 0, 0, 0, 1303, 1305, 3, 42, 21, 0, 1304, 1303, 1, 0, 0, 0, 1304, 1305, 1, 0, 0, 0, 1305, 1308, 1, 0, 0, 0, 1306, 1307, 5, 206, 0, 0, 1307, 1309, 3, 48, 24, 0, 1308, 1306, 1, 0, 0, 0, 1308, 1309, 1, 0, 0, 0, 1309, 1311, 1, 0, 0, 0, 1310, 1239, 1, 0, 0, 0, 1310, 1259, 1, 0, 0, 0, 1310, 1268, 1, 0, 0, 0, 1310, 1288, 1, 0, 0, 0, 1311, 15, 1, 0, 0, 0, 1312, 1313, 5, 272, 0, 0, 1313, 1316, 7, 17, 0, 0, 1314, 1315, 7, 0, 0, 0, 1315, 1317, 3, 206, 103, 0, 1316, 1314, 1, 0, 0, 0, 1316, 1317, 1, 0, 0, 0, 1317, 1322, 1, 0, 0, 0, 1318, 1320, 5, 163, 0, 0, 1319, 1318, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 1321, 1, 0, 0, 0, 1321, 1323, 3, 334, 167, 0, 1322, 1319, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 1445, 1, 0, 0, 0, 1324, 1325, 5, 272, 0, 0, 1325, 1328, 5, 293, 0, 0, 1326, 1327, 7, 0, 0, 0, 1327, 1329, 3, 70, 35, 0, 1328, 1326, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, 0, 1329, 1334, 1, 0, 0, 0, 1330, 1332, 5, 163, 0, 0, 1331, 1330, 1, 0, 0, 0, 1331, 1332, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 1335, 3, 334, 167, 0, 1334, 1331, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 1445, 1, 0, 0, 0, 1336, 1337, 5, 272, 0, 0, 1337, 1338, 5, 292, 0, 0, 1338, 1341, 5, 108, 0, 0, 1339, 1340, 7, 0, 0, 0, 1340, 1342, 3, 70, 35, 0, 1341, 1339, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 1344, 5, 163, 0, 0, 1344, 1346, 3, 334, 167, 0, 1345, 1347, 3, 28, 14, 0, 1346, 1345, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1445, 1, 0, 0, 0, 1348, 1349, 5, 272, 0, 0, 1349, 1350, 5, 296, 0, 0, 1350, 1355, 3, 76, 38, 0, 1351, 1352, 5, 2, 0, 0, 1352, 1353, 3, 52, 26, 0, 1353, 1354, 5, 3, 0, 0, 1354, 1356, 1, 0, 0, 0, 1355, 1351, 1, 0, 0, 0, 1355, 1356, 1, 0, 0, 0, 1356, 1445, 1, 0, 0, 0, 1357, 1358, 5, 272, 0, 0, 1358, 1359, 5, 50, 0, 0, 1359, 1360, 7, 0, 0, 0, 1360, 1363, 3, 76, 38, 0, 1361, 1362, 7, 0, 0, 0, 1362, 1364, 3, 70, 35, 0, 1363, 1361, 1, 0, 0, 0, 1363, 1364, 1, 0, 0, 0, 1364, 1445, 1, 0, 0, 0, 1365, 1366, 5, 272, 0, 0, 1366, 1369, 5, 338, 0, 0, 1367, 1368, 7, 0, 0, 0, 1368, 1370, 3, 70, 35, 0, 1369, 1367, 1, 0, 0, 0, 1369, 1370, 1, 0, 0, 0, 1370, 1375, 1, 0, 0, 0, 1371, 1373, 5, 163, 0, 0, 1372, 1371, 1, 0, 0, 0, 1372, 1373, 1, 0, 0, 0, 1373, 1374, 1, 0, 0, 0, 1374, 1376, 3, 334, 167, 0, 1375, 1372, 1, 0, 0, 0, 1375, 1376, 1, 0, 0, 0, 1376, 1445, 1, 0, 0, 0, 1377, 1378, 5, 272, 0, 0, 1378, 1379, 5, 218, 0, 0, 1379, 1381, 3, 76, 38, 0, 1380, 1382, 3, 28, 14, 0, 1381, 1380, 1, 0, 0, 0, 1381, 1382, 1, 0, 0, 0, 1382, 1445, 1, 0, 0, 0, 1383, 1385, 5, 272, 0, 0, 1384, 1386, 7, 18, 0, 0, 1385, 1384, 1, 0, 0, 0, 1385, 1386, 1, 0, 0, 0, 1386, 1387, 1, 0, 0, 0, 1387, 1390, 5, 126, 0, 0, 1388, 1389, 7, 0, 0, 0, 1389, 1391, 3, 70, 35, 0, 1390, 1388, 1, 0, 0, 0, 1390, 1391, 1, 0, 0, 0, 1391, 1399, 1, 0, 0, 0, 1392, 1394, 5, 163, 0, 0, 1393, 1392, 1, 0, 0, 0, 1393, 1394, 1, 0, 0, 0, 1394, 1397, 1, 0, 0, 0, 1395, 1398, 3, 206, 103, 0, 1396, 1398, 3, 334, 167, 0, 1397, 1395, 1, 0, 0, 0, 1397, 1396, 1, 0, 0, 0, 1398, 1400, 1, 0, 0, 0, 1399, 1393, 1, 0, 0, 0, 1399, 1400, 1, 0, 0, 0, 1400, 1445, 1, 0, 0, 0, 1401, 1402, 5, 272, 0, 0, 1402, 1403, 5, 59, 0, 0, 1403, 1404, 5, 292, 0, 0, 1404, 1407, 3, 76, 38, 0, 1405, 1406, 5, 20, 0, 0, 1406, 1408, 5, 265, 0, 0, 1407, 1405, 1, 0, 0, 0, 1407, 1408, 1, 0, 0, 0, 1408, 1445, 1, 0, 0, 0, 1409, 1410, 5, 272, 0, 0, 1410, 1411, 5, 62, 0, 0, 1411, 1445, 3, 32, 16, 0, 1412, 1413, 5, 272, 0, 0, 1413, 1418, 5, 38, 0, 0, 1414, 1416, 5, 163, 0, 0, 1415, 1414, 1, 0, 0, 0, 1415, 1416, 1, 0, 0, 0, 1416, 1417, 1, 0, 0, 0, 1417, 1419, 3, 334, 167, 0, 1418, 1415, 1, 0, 0, 0, 1418, 1419, 1, 0, 0, 0, 1419, 1445, 1, 0, 0, 0, 1420, 1436, 5, 272, 0, 0, 1421, 1437, 5, 129, 0, 0, 1422, 1437, 5, 227, 0, 0, 1423, 1437, 5, 253, 0, 0, 1424, 1437, 5, 54, 0, 0, 1425, 1437, 5, 312, 0, 0, 1426, 1437, 5, 143, 0, 0, 1427, 1437, 5, 172, 0, 0, 1428, 1430, 5, 252, 0, 0, 1429, 1431, 5, 129, 0, 0, 1430, 1429, 1, 0, 0, 0, 1430, 1431, 1, 0, 0, 0, 1431, 1437, 1, 0, 0, 0, 1432, 1433, 5, 62, 0, 0, 1433, 1437, 5, 253, 0, 0, 1434, 1435, 5, 59, 0, 0, 1435, 1437, 5, 292, 0, 0, 1436, 1421, 1, 0, 0, 0, 1436, 1422, 1, 0, 0, 0, 1436, 1423, 1, 0, 0, 0, 1436, 1424, 1, 0, 0, 0, 1436, 1425, 1, 0, 0, 0, 1436, 1426, 1, 0, 0, 0, 1436, 1427, 1, 0, 0, 0, 1436, 1428, 1, 0, 0, 0, 1436, 1432, 1, 0, 0, 0, 1436, 1434, 1, 0, 0, 0, 1437, 1441, 1, 0, 0, 0, 1438, 1440, 9, 0, 0, 0, 1439, 1438, 1, 0, 0, 0, 1440, 1443, 1, 0, 0, 0, 1441, 1442, 1, 0, 0, 0, 1441, 1439, 1, 0, 0, 0, 1442, 1445, 1, 0, 0, 0, 1443, 1441, 1, 0, 0, 0, 1444, 1312, 1, 0, 0, 0, 1444, 1324, 1, 0, 0, 0, 1444, 1336, 1, 0, 0, 0, 1444, 1348, 1, 0, 0, 0, 1444, 1357, 1, 0, 0, 0, 1444, 1365, 1, 0, 0, 0, 1444, 1377, 1, 0, 0, 0, 1444, 1383, 1, 0, 0, 0, 1444, 1401, 1, 0, 0, 0, 1444, 1409, 1, 0, 0, 0, 1444, 1412, 1, 0, 0, 0, 1444, 1420, 1, 0, 0, 0, 1445, 17, 1, 0, 0, 0, 1446, 1448, 7, 19, 0, 0, 1447, 1449, 5, 252, 0, 0, 1448, 1447, 1, 0, 0, 0, 1448, 1449, 1, 0, 0, 0, 1449, 1460, 1, 0, 0, 0, 1450, 1451, 7, 20, 0, 0, 1451, 1460, 5, 292, 0, 0, 1452, 1453, 7, 21, 0, 0, 1453, 1460, 5, 72, 0, 0, 1454, 1455, 5, 280, 0, 0, 1455, 1460, 5, 311, 0, 0, 1456, 1460, 5, 52, 0, 0, 1457, 1460, 5, 254, 0, 0, 1458, 1460, 5, 88, 0, 0, 1459, 1446, 1, 0, 0, 0, 1459, 1450, 1, 0, 0, 0, 1459, 1452, 1, 0, 0, 0, 1459, 1454, 1, 0, 0, 0, 1459, 1456, 1, 0, 0, 0, 1459, 1457, 1, 0, 0, 0, 1459, 1458, 1, 0, 0, 0, 1460, 19, 1, 0, 0, 0, 1461, 1462, 5, 45, 0, 0, 1462, 1463, 5, 31, 0, 0, 1463, 1467, 3, 176, 88, 0, 1464, 1465, 5, 278, 0, 0, 1465, 1466, 5, 31, 0, 0, 1466, 1468, 3, 180, 90, 0, 1467, 1464, 1, 0, 0, 0, 1467, 1468, 1, 0, 0, 0, 1468, 1469, 1, 0, 0, 0, 1469, 1470, 5, 152, 0, 0, 1470, 1471, 5, 381, 0, 0, 1471, 1472, 5, 30, 0, 0, 1472, 21, 1, 0, 0, 0, 1473, 1474, 5, 274, 0, 0, 1474, 1475, 5, 31, 0, 0, 1475, 1476, 3, 176, 88, 0, 1476, 1479, 5, 202, 0, 0, 1477, 1480, 3, 60, 30, 0, 1478, 1480, 3, 62, 31, 0, 1479, 1477, 1, 0, 0, 0, 1479, 1478, 1, 0, 0, 0, 1480, 1484, 1, 0, 0, 0, 1481, 1482, 5, 282, 0, 0, 1482, 1483, 5, 20, 0, 0, 1483, 1485, 5, 89, 0, 0, 1484, 1481, 1, 0, 0, 0, 1484, 1485, 1, 0, 0, 0, 1485, 23, 1, 0, 0, 0, 1486, 1488, 3, 38, 19, 0, 1487, 1486, 1, 0, 0, 0, 1487, 1488, 1, 0, 0, 0, 1488, 1489, 1, 0, 0, 0, 1489, 1490, 3, 92, 46, 0, 1490, 1491, 3, 90, 45, 0, 1491, 25, 1, 0, 0, 0, 1492, 1495, 3, 28, 14, 0, 1493, 1494, 5, 170, 0, 0, 1494, 1496, 3, 334, 167, 0, 1495, 1493, 1, 0, 0, 0, 1495, 1496, 1, 0, 0, 0, 1496, 27, 1, 0, 0, 0, 1497, 1498, 5, 216, 0, 0, 1498, 1499, 5, 2, 0, 0, 1499, 1504, 3, 30, 15, 0, 1500, 1501, 5, 4, 0, 0, 1501, 1503, 3, 30, 15, 0, 1502, 1500, 1, 0, 0, 0, 1503, 1506, 1, 0, 0, 0, 1504, 1502, 1, 0, 0, 0, 1504, 1505, 1, 0, 0, 0, 1505, 1507, 1, 0, 0, 0, 1506, 1504, 1, 0, 0, 0, 1507, 1508, 5, 3, 0, 0, 1508, 29, 1, 0, 0, 0, 1509, 1512, 3, 326, 163, 0, 1510, 1511, 5, 351, 0, 0, 1511, 1513, 3, 248, 124, 0, 1512, 1510, 1, 0, 0, 0, 1512, 1513, 1, 0, 0, 0, 1513, 1519, 1, 0, 0, 0, 1514, 1515, 3, 326, 163, 0, 1515, 1516, 5, 351, 0, 0, 1516, 1517, 5, 82, 0, 0, 1517, 1519, 1, 0, 0, 0, 1518, 1509, 1, 0, 0, 0, 1518, 1514, 1, 0, 0, 0, 1519, 31, 1, 0, 0, 0, 1520, 1521, 7, 22, 0, 0, 1521, 33, 1, 0, 0, 0, 1522, 1528, 3, 88, 44, 0, 1523, 1528, 3, 334, 167, 0, 1524, 1528, 3, 250, 125, 0, 1525, 1528, 3, 252, 126, 0, 1526, 1528, 3, 254, 127, 0, 1527, 1522, 1, 0, 0, 0, 1527, 1523, 1, 0, 0, 0, 1527, 1524, 1, 0, 0, 0, 1527, 1525, 1, 0, 0, 0, 1527, 1526, 1, 0, 0, 0, 1528, 35, 1, 0, 0, 0, 1529, 1534, 3, 326, 163, 0, 1530, 1531, 5, 5, 0, 0, 1531, 1533, 3, 326, 163, 0, 1532, 1530, 1, 0, 0, 0, 1533, 1536, 1, 0, 0, 0, 1534, 1532, 1, 0, 0, 0, 1534, 1535, 1, 0, 0, 0, 1535, 37, 1, 0, 0, 0, 1536, 1534, 1, 0, 0, 0, 1537, 1538, 5, 345, 0, 0, 1538, 1543, 3, 40, 20, 0, 1539, 1540, 5, 4, 0, 0, 1540, 1542, 3, 40, 20, 0, 1541, 1539, 1, 0, 0, 0, 1542, 1545, 1, 0, 0, 0, 1543, 1541, 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 39, 1, 0, 0, 0, 1545, 1543, 1, 0, 0, 0, 1546, 1548, 3, 322, 161, 0, 1547, 1549, 3, 176, 88, 0, 1548, 1547, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1551, 1, 0, 0, 0, 1550, 1552, 5, 20, 0, 0, 1551, 1550, 1, 0, 0, 0, 1551, 1552, 1, 0, 0, 0, 1552, 1553, 1, 0, 0, 0, 1553, 1554, 5, 2, 0, 0, 1554, 1555, 3, 24, 12, 0, 1555, 1556, 5, 3, 0, 0, 1556, 41, 1, 0, 0, 0, 1557, 1558, 5, 331, 0, 0, 1558, 1559, 3, 206, 103, 0, 1559, 43, 1, 0, 0, 0, 1560, 1561, 5, 206, 0, 0, 1561, 1577, 3, 56, 28, 0, 1562, 1563, 5, 217, 0, 0, 1563, 1564, 5, 31, 0, 0, 1564, 1577, 3, 220, 110, 0, 1565, 1577, 3, 22, 11, 0, 1566, 1577, 3, 20, 10, 0, 1567, 1577, 3, 202, 101, 0, 1568, 1577, 3, 64, 32, 0, 1569, 1570, 5, 170, 0, 0, 1570, 1577, 3, 334, 167, 0, 1571, 1572, 5, 51, 0, 0, 1572, 1577, 3, 334, 167, 0, 1573, 1574, 5, 296, 0, 0, 1574, 1577, 3, 48, 24, 0, 1575, 1577, 3, 46, 23, 0, 1576, 1560, 1, 0, 0, 0, 1576, 1562, 1, 0, 0, 0, 1576, 1565, 1, 0, 0, 0, 1576, 1566, 1, 0, 0, 0, 1576, 1567, 1, 0, 0, 0, 1576, 1568, 1, 0, 0, 0, 1576, 1569, 1, 0, 0, 0, 1576, 1571, 1, 0, 0, 0, 1576, 1573, 1, 0, 0, 0, 1576, 1575, 1, 0, 0, 0, 1577, 1580, 1, 0, 0, 0, 1578, 1576, 1, 0, 0, 0, 1578, 1579, 1, 0, 0, 0, 1579, 45, 1, 0, 0, 0, 1580, 1578, 1, 0, 0, 0, 1581, 1582, 5, 162, 0, 0, 1582, 1583, 5, 381, 0, 0, 1583, 47, 1, 0, 0, 0, 1584, 1585, 5, 2, 0, 0, 1585, 1590, 3, 50, 25, 0, 1586, 1587, 5, 4, 0, 0, 1587, 1589, 3, 50, 25, 0, 1588, 1586, 1, 0, 0, 0, 1589, 1592, 1, 0, 0, 0, 1590, 1588, 1, 0, 0, 0, 1590, 1591, 1, 0, 0, 0, 1591, 1593, 1, 0, 0, 0, 1592, 1590, 1, 0, 0, 0, 1593, 1594, 5, 3, 0, 0, 1594, 49, 1, 0, 0, 0, 1595, 1600, 3, 52, 26, 0, 1596, 1598, 5, 351, 0, 0, 1597, 1596, 1, 0, 0, 0, 1597, 1598, 1, 0, 0, 0, 1598, 1599, 1, 0, 0, 0, 1599, 1601, 3, 54, 27, 0, 1600, 1597, 1, 0, 0, 0, 1600, 1601, 1, 0, 0, 0, 1601, 51, 1, 0, 0, 0, 1602, 1607, 3, 326, 163, 0, 1603, 1604, 5, 5, 0, 0, 1604, 1606, 3, 326, 163, 0, 1605, 1603, 1, 0, 0, 0, 1606, 1609, 1, 0, 0, 0, 1607, 1605, 1, 0, 0, 0, 1607, 1608, 1, 0, 0, 0, 1608, 1612, 1, 0, 0, 0, 1609, 1607, 1, 0, 0, 0, 1610, 1612, 3, 334, 167, 0, 1611, 1602, 1, 0, 0, 0, 1611, 1610, 1, 0, 0, 0, 1612, 53, 1, 0, 0, 0, 1613, 1618, 5, 381, 0, 0, 1614, 1618, 5, 383, 0, 0, 1615, 1618, 3, 256, 128, 0, 1616, 1618, 3, 334, 167, 0, 1617, 1613, 1, 0, 0, 0, 1617, 1614, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1616, 1, 0, 0, 0, 1618, 55, 1, 0, 0, 0, 1619, 1620, 5, 2, 0, 0, 1620, 1625, 3, 58, 29, 0, 1621, 1622, 5, 4, 0, 0, 1622, 1624, 3, 58, 29, 0, 1623, 1621, 1, 0, 0, 0, 1624, 1627, 1, 0, 0, 0, 1625, 1623, 1, 0, 0, 0, 1625, 1626, 1, 0, 0, 0, 1626, 1628, 1, 0, 0, 0, 1627, 1625, 1, 0, 0, 0, 1628, 1629, 5, 3, 0, 0, 1629, 57, 1, 0, 0, 0, 1630, 1635, 3, 52, 26, 0, 1631, 1633, 5, 351, 0, 0, 1632, 1631, 1, 0, 0, 0, 1632, 1633, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 1636, 3, 228, 114, 0, 1635, 1632, 1, 0, 0, 0, 1635, 1636, 1, 0, 0, 0, 1636, 59, 1, 0, 0, 0, 1637, 1638, 5, 2, 0, 0, 1638, 1643, 3, 248, 124, 0, 1639, 1640, 5, 4, 0, 0, 1640, 1642, 3, 248, 124, 0, 1641, 1639, 1, 0, 0, 0, 1642, 1645, 1, 0, 0, 0, 1643, 1641, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1646, 1, 0, 0, 0, 1645, 1643, 1, 0, 0, 0, 1646, 1647, 5, 3, 0, 0, 1647, 61, 1, 0, 0, 0, 1648, 1649, 5, 2, 0, 0, 1649, 1654, 3, 60, 30, 0, 1650, 1651, 5, 4, 0, 0, 1651, 1653, 3, 60, 30, 0, 1652, 1650, 1, 0, 0, 0, 1653, 1656, 1, 0, 0, 0, 1654, 1652, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1657, 1, 0, 0, 0, 1656, 1654, 1, 0, 0, 0, 1657, 1658, 5, 3, 0, 0, 1658, 63, 1, 0, 0, 0, 1659, 1660, 5, 282, 0, 0, 1660, 1661, 5, 20, 0, 0, 1661, 1666, 3, 66, 33, 0, 1662, 1663, 5, 282, 0, 0, 1663, 1664, 5, 31, 0, 0, 1664, 1666, 3, 68, 34, 0, 1665, 1659, 1, 0, 0, 0, 1665, 1662, 1, 0, 0, 0, 1666, 65, 1, 0, 0, 0, 1667, 1668, 5, 146, 0, 0, 1668, 1669, 3, 334, 167, 0, 1669, 1670, 5, 211, 0, 0, 1670, 1671, 3, 334, 167, 0, 1671, 1674, 1, 0, 0, 0, 1672, 1674, 3, 326, 163, 0, 1673, 1667, 1, 0, 0, 0, 1673, 1672, 1, 0, 0, 0, 1674, 67, 1, 0, 0, 0, 1675, 1679, 3, 334, 167, 0, 1676, 1677, 5, 345, 0, 0, 1677, 1678, 5, 266, 0, 0, 1678, 1680, 3, 48, 24, 0, 1679, 1676, 1, 0, 0, 0, 1679, 1680, 1, 0, 0, 0, 1680, 69, 1, 0, 0, 0, 1681, 1682, 3, 88, 44, 0, 1682, 71, 1, 0, 0, 0, 1683, 1684, 3, 88, 44, 0, 1684, 73, 1, 0, 0, 0, 1685, 1686, 3, 212, 106, 0, 1686, 75, 1, 0, 0, 0, 1687, 1688, 3, 212, 106, 0, 1688, 77, 1, 0, 0, 0, 1689, 1690, 3, 214, 107, 0, 1690, 79, 1, 0, 0, 0, 1691, 1692, 3, 214, 107, 0, 1692, 81, 1, 0, 0, 0, 1693, 1696, 3, 206, 103, 0, 1694, 1696, 4, 41, 0, 0, 1695, 1693, 1, 0, 0, 0, 1695, 1694, 1, 0, 0, 0, 1696, 83, 1, 0, 0, 0, 1697, 1702, 3, 82, 41, 0, 1698, 1699, 5, 4, 0, 0, 1699, 1701, 3, 82, 41, 0, 1700, 1698, 1, 0, 0, 0, 1701, 1704, 1, 0, 0, 0, 1702, 1700, 1, 0, 0, 0, 1702, 1703, 1, 0, 0, 0, 1703, 85, 1, 0, 0, 0, 1704, 1702, 1, 0, 0, 0, 1705, 1706, 3, 322, 161, 0, 1706, 87, 1, 0, 0, 0, 1707, 1708, 5, 136, 0, 0, 1708, 1709, 5, 2, 0, 0, 1709, 1710, 3, 228, 114, 0, 1710, 1711, 5, 3, 0, 0, 1711, 1714, 1, 0, 0, 0, 1712, 1714, 3, 206, 103, 0, 1713, 1707, 1, 0, 0, 0, 1713, 1712, 1, 0, 0, 0, 1714, 89, 1, 0, 0, 0, 1715, 1716, 5, 208, 0, 0, 1716, 1717, 5, 31, 0, 0, 1717, 1722, 3, 96, 48, 0, 1718, 1719, 5, 4, 0, 0, 1719, 1721, 3, 96, 48, 0, 1720, 1718, 1, 0, 0, 0, 1721, 1724, 1, 0, 0, 0, 1722, 1720, 1, 0, 0, 0, 1722, 1723, 1, 0, 0, 0, 1723, 1726, 1, 0, 0, 0, 1724, 1722, 1, 0, 0, 0, 1725, 1715, 1, 0, 0, 0, 1725, 1726, 1, 0, 0, 0, 1726, 1737, 1, 0, 0, 0, 1727, 1728, 5, 44, 0, 0, 1728, 1729, 5, 31, 0, 0, 1729, 1734, 3, 228, 114, 0, 1730, 1731, 5, 4, 0, 0, 1731, 1733, 3, 228, 114, 0, 1732, 1730, 1, 0, 0, 0, 1733, 1736, 1, 0, 0, 0, 1734, 1732, 1, 0, 0, 0, 1734, 1735, 1, 0, 0, 0, 1735, 1738, 1, 0, 0, 0, 1736, 1734, 1, 0, 0, 0, 1737, 1727, 1, 0, 0, 0, 1737, 1738, 1, 0, 0, 0, 1738, 1749, 1, 0, 0, 0, 1739, 1740, 5, 93, 0, 0, 1740, 1741, 5, 31, 0, 0, 1741, 1746, 3, 228, 114, 0, 1742, 1743, 5, 4, 0, 0, 1743, 1745, 3, 228, 114, 0, 1744, 1742, 1, 0, 0, 0, 1745, 1748, 1, 0, 0, 0, 1746, 1744, 1, 0, 0, 0, 1746, 1747, 1, 0, 0, 0, 1747, 1750, 1, 0, 0, 0, 1748, 1746, 1, 0, 0, 0, 1749, 1739, 1, 0, 0, 0, 1749, 1750, 1, 0, 0, 0, 1750, 1761, 1, 0, 0, 0, 1751, 1752, 5, 277, 0, 0, 1752, 1753, 5, 31, 0, 0, 1753, 1758, 3, 96, 48, 0, 1754, 1755, 5, 4, 0, 0, 1755, 1757, 3, 96, 48, 0, 1756, 1754, 1, 0, 0, 0, 1757, 1760, 1, 0, 0, 0, 1758, 1756, 1, 0, 0, 0, 1758, 1759, 1, 0, 0, 0, 1759, 1762, 1, 0, 0, 0, 1760, 1758, 1, 0, 0, 0, 1761, 1751, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762, 1764, 1, 0, 0, 0, 1763, 1765, 3, 306, 153, 0, 1764, 1763, 1, 0, 0, 0, 1764, 1765, 1, 0, 0, 0, 1765, 1771, 1, 0, 0, 0, 1766, 1769, 5, 165, 0, 0, 1767, 1770, 5, 10, 0, 0, 1768, 1770, 3, 228, 114, 0, 1769, 1767, 1, 0, 0, 0, 1769, 1768, 1, 0, 0, 0, 1770, 1772, 1, 0, 0, 0, 1771, 1766, 1, 0, 0, 0, 1771, 1772, 1, 0, 0, 0, 1772, 1775, 1, 0, 0, 0, 1773, 1774, 5, 201, 0, 0, 1774, 1776, 3, 228, 114, 0, 1775, 1773, 1, 0, 0, 0, 1775, 1776, 1, 0, 0, 0, 1776, 91, 1, 0, 0, 0, 1777, 1778, 6, 46, -1, 0, 1778, 1779, 3, 94, 47, 0, 1779, 1800, 1, 0, 0, 0, 1780, 1781, 10, 3, 0, 0, 1781, 1783, 7, 23, 0, 0, 1782, 1784, 3, 162, 81, 0, 1783, 1782, 1, 0, 0, 0, 1783, 1784, 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1799, 3, 92, 46, 4, 1786, 1787, 10, 2, 0, 0, 1787, 1789, 5, 148, 0, 0, 1788, 1790, 3, 162, 81, 0, 1789, 1788, 1, 0, 0, 0, 1789, 1790, 1, 0, 0, 0, 1790, 1791, 1, 0, 0, 0, 1791, 1799, 3, 92, 46, 3, 1792, 1793, 10, 1, 0, 0, 1793, 1795, 7, 24, 0, 0, 1794, 1796, 3, 162, 81, 0, 1795, 1794, 1, 0, 0, 0, 1795, 1796, 1, 0, 0, 0, 1796, 1797, 1, 0, 0, 0, 1797, 1799, 3, 92, 46, 2, 1798, 1780, 1, 0, 0, 0, 1798, 1786, 1, 0, 0, 0, 1798, 1792, 1, 0, 0, 0, 1799, 1802, 1, 0, 0, 0, 1800, 1798, 1, 0, 0, 0, 1800, 1801, 1, 0, 0, 0, 1801, 93, 1, 0, 0, 0, 1802, 1800, 1, 0, 0, 0, 1803, 1828, 3, 100, 50, 0, 1804, 1806, 3, 128, 64, 0, 1805, 1807, 3, 98, 49, 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, 1828, 1, 0, 0, 0, 1810, 1811, 5, 292, 0, 0, 1811, 1828, 3, 76, 38, 0, 1812, 1813, 5, 332, 0, 0, 1813, 1818, 3, 228, 114, 0, 1814, 1815, 5, 4, 0, 0, 1815, 1817, 3, 228, 114, 0, 1816, 1814, 1, 0, 0, 0, 1817, 1820, 1, 0, 0, 0, 1818, 1816, 1, 0, 0, 0, 1818, 1819, 1, 0, 0, 0, 1819, 1821, 1, 0, 0, 0, 1820, 1818, 1, 0, 0, 0, 1821, 1822, 3, 200, 100, 0, 1822, 1828, 1, 0, 0, 0, 1823, 1824, 5, 2, 0, 0, 1824, 1825, 3, 24, 12, 0, 1825, 1826, 5, 3, 0, 0, 1826, 1828, 1, 0, 0, 0, 1827, 1803, 1, 0, 0, 0, 1827, 1804, 1, 0, 0, 0, 1827, 1810, 1, 0, 0, 0, 1827, 1812, 1, 0, 0, 0, 1827, 1823, 1, 0, 0, 0, 1828, 95, 1, 0, 0, 0, 1829, 1832, 3, 82, 41, 0, 1830, 1832, 3, 228, 114, 0, 1831, 1829, 1, 0, 0, 0, 1831, 1830, 1, 0, 0, 0, 1832, 1834, 1, 0, 0, 0, 1833, 1835, 7, 25, 0, 0, 1834, 1833, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0, 1835, 1838, 1, 0, 0, 0, 1836, 1837, 5, 198, 0, 0, 1837, 1839, 7, 26, 0, 0, 1838, 1836, 1, 0, 0, 0, 1838, 1839, 1, 0, 0, 0, 1839, 97, 1, 0, 0, 0, 1840, 1842, 3, 102, 51, 0, 1841, 1843, 3, 120, 60, 0, 1842, 1841, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1845, 3, 90, 45, 0, 1845, 1868, 1, 0, 0, 0, 1846, 1850, 3, 104, 52, 0, 1847, 1849, 3, 160, 80, 0, 1848, 1847, 1, 0, 0, 0, 1849, 1852, 1, 0, 0, 0, 1850, 1848, 1, 0, 0, 0, 1850, 1851, 1, 0, 0, 0, 1851, 1854, 1, 0, 0, 0, 1852, 1850, 1, 0, 0, 0, 1853, 1855, 3, 120, 60, 0, 1854, 1853, 1, 0, 0, 0, 1854, 1855, 1, 0, 0, 0, 1855, 1857, 1, 0, 0, 0, 1856, 1858, 3, 132, 66, 0, 1857, 1856, 1, 0, 0, 0, 1857, 1858, 1, 0, 0, 0, 1858, 1860, 1, 0, 0, 0, 1859, 1861, 3, 122, 61, 0, 1860, 1859, 1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1863, 1, 0, 0, 0, 1862, 1864, 3, 306, 153, 0, 1863, 1862, 1, 0, 0, 0, 1863, 1864, 1, 0, 0, 0, 1864, 1865, 1, 0, 0, 0, 1865, 1866, 3, 90, 45, 0, 1866, 1868, 1, 0, 0, 0, 1867, 1840, 1, 0, 0, 0, 1867, 1846, 1, 0, 0, 0, 1868, 99, 1, 0, 0, 0, 1869, 1871, 3, 102, 51, 0, 1870, 1872, 3, 128, 64, 0, 1871, 1870, 1, 0, 0, 0, 1871, 1872, 1, 0, 0, 0, 1872, 1876, 1, 0, 0, 0, 1873, 1875, 3, 160, 80, 0, 1874, 1873, 1, 0, 0, 0, 1875, 1878, 1, 0, 0, 0, 1876, 1874, 1, 0, 0, 0, 1876, 1877, 1, 0, 0, 0, 1877, 1880, 1, 0, 0, 0, 1878, 1876, 1, 0, 0, 0, 1879, 1881, 3, 120, 60, 0, 1880, 1879, 1, 0, 0, 0, 1880, 1881, 1, 0, 0, 0, 1881, 1883, 1, 0, 0, 0, 1882, 1884, 3, 132, 66, 0, 1883, 1882, 1, 0, 0, 0, 1883, 1884, 1, 0, 0, 0, 1884, 1886, 1, 0, 0, 0, 1885, 1887, 3, 122, 61, 0, 1886, 1885, 1, 0, 0, 0, 1886, 1887, 1, 0, 0, 0, 1887, 1889, 1, 0, 0, 0, 1888, 1890, 3, 306, 153, 0, 1889, 1888, 1, 0, 0, 0, 1889, 1890, 1, 0, 0, 0, 1890, 1914, 1, 0, 0, 0, 1891, 1893, 3, 104, 52, 0, 1892, 1894, 3, 128, 64, 0, 1893, 1892, 1, 0, 0, 0, 1893, 1894, 1, 0, 0, 0, 1894, 1898, 1, 0, 0, 0, 1895, 1897, 3, 160, 80, 0, 1896, 1895, 1, 0, 0, 0, 1897, 1900, 1, 0, 0, 0, 1898, 1896, 1, 0, 0, 0, 1898, 1899, 1, 0, 0, 0, 1899, 1902, 1, 0, 0, 0, 1900, 1898, 1, 0, 0, 0, 1901, 1903, 3, 120, 60, 0, 1902, 1901, 1, 0, 0, 0, 1902, 1903, 1, 0, 0, 0, 1903, 1905, 1, 0, 0, 0, 1904, 1906, 3, 132, 66, 0, 1905, 1904, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 1908, 1, 0, 0, 0, 1907, 1909, 3, 122, 61, 0, 1908, 1907, 1, 0, 0, 0, 1908, 1909, 1, 0, 0, 0, 1909, 1911, 1, 0, 0, 0, 1910, 1912, 3, 306, 153, 0, 1911, 1910, 1, 0, 0, 0, 1911, 1912, 1, 0, 0, 0, 1912, 1914, 1, 0, 0, 0, 1913, 1869, 1, 0, 0, 0, 1913, 1891, 1, 0, 0, 0, 1914, 101, 1, 0, 0, 0, 1915, 1916, 5, 262, 0, 0, 1916, 1917, 5, 313, 0, 0, 1917, 1919, 5, 2, 0, 0, 1918, 1920, 3, 162, 81, 0, 1919, 1918, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1921, 1, 0, 0, 0, 1921, 1922, 3, 234, 117, 0, 1922, 1923, 5, 3, 0, 0, 1923, 1935, 1, 0, 0, 0, 1924, 1926, 5, 176, 0, 0, 1925, 1927, 3, 162, 81, 0, 1926, 1925, 1, 0, 0, 0, 1926, 1927, 1, 0, 0, 0, 1927, 1928, 1, 0, 0, 0, 1928, 1935, 3, 234, 117, 0, 1929, 1931, 5, 237, 0, 0, 1930, 1932, 3, 162, 81, 0, 1931, 1930, 1, 0, 0, 0, 1931, 1932, 1, 0, 0, 0, 1932, 1933, 1, 0, 0, 0, 1933, 1935, 3, 234, 117, 0, 1934, 1915, 1, 0, 0, 0, 1934, 1924, 1, 0, 0, 0, 1934, 1929, 1, 0, 0, 0, 1935, 1937, 1, 0, 0, 0, 1936, 1938, 3, 202, 101, 0, 1937, 1936, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1941, 1, 0, 0, 0, 1939, 1940, 5, 235, 0, 0, 1940, 1942, 3, 334, 167, 0, 1941, 1939, 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1944, 5, 331, 0, 0, 1944, 1957, 3, 334, 167, 0, 1945, 1955, 5, 20, 0, 0, 1946, 1956, 3, 178, 89, 0, 1947, 1956, 3, 292, 146, 0, 1948, 1951, 5, 2, 0, 0, 1949, 1952, 3, 178, 89, 0, 1950, 1952, 3, 292, 146, 0, 1951, 1949, 1, 0, 0, 0, 1951, 1950, 1, 0, 0, 0, 1952, 1953, 1, 0, 0, 0, 1953, 1954, 5, 3, 0, 0, 1954, 1956, 1, 0, 0, 0, 1955, 1946, 1, 0, 0, 0, 1955, 1947, 1, 0, 0, 0, 1955, 1948, 1, 0, 0, 0, 1956, 1958, 1, 0, 0, 0, 1957, 1945, 1, 0, 0, 0, 1957, 1958, 1, 0, 0, 0, 1958, 1960, 1, 0, 0, 0, 1959, 1961, 3, 202, 101, 0, 1960, 1959, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1964, 1, 0, 0, 0, 1962, 1963, 5, 234, 0, 0, 1963, 1965, 3, 334, 167, 0, 1964, 1962, 1, 0, 0, 0, 1964, 1965, 1, 0, 0, 0, 1965, 103, 1, 0, 0, 0, 1966, 1970, 5, 262, 0, 0, 1967, 1969, 3, 124, 62, 0, 1968, 1967, 1, 0, 0, 0, 1969, 1972, 1, 0, 0, 0, 1970, 1968, 1, 0, 0, 0, 1970, 1971, 1, 0, 0, 0, 1971, 1974, 1, 0, 0, 0, 1972, 1970, 1, 0, 0, 0, 1973, 1975, 3, 162, 81, 0, 1974, 1973, 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 1977, 3, 218, 109, 0, 1977, 105, 1, 0, 0, 0, 1978, 1979, 5, 268, 0, 0, 1979, 1980, 3, 116, 58, 0, 1980, 107, 1, 0, 0, 0, 1981, 1982, 5, 342, 0, 0, 1982, 1985, 5, 177, 0, 0, 1983, 1984, 5, 14, 0, 0, 1984, 1986, 3, 236, 118, 0, 1985, 1983, 1, 0, 0, 0, 1985, 1986, 1, 0, 0, 0, 1986, 1987, 1, 0, 0, 0, 1987, 1995, 5, 299, 0, 0, 1988, 1996, 5, 84, 0, 0, 1989, 1990, 5, 328, 0, 0, 1990, 1993, 5, 268, 0, 0, 1991, 1994, 5, 362, 0, 0, 1992, 1994, 3, 116, 58, 0, 1993, 1991, 1, 0, 0, 0, 1993, 1992, 1, 0, 0, 0, 1994, 1996, 1, 0, 0, 0, 1995, 1988, 1, 0, 0, 0, 1995, 1989, 1, 0, 0, 0, 1996, 109, 1, 0, 0, 0, 1997, 1998, 5, 342, 0, 0, 1998, 1999, 5, 196, 0, 0, 1999, 2002, 5, 177, 0, 0, 2000, 2001, 5, 31, 0, 0, 2001, 2003, 5, 295, 0, 0, 2002, 2000, 1, 0, 0, 0, 2002, 2003, 1, 0, 0, 0, 2003, 2006, 1, 0, 0, 0, 2004, 2005, 5, 14, 0, 0, 2005, 2007, 3, 236, 118, 0, 2006, 2004, 1, 0, 0, 0, 2006, 2007, 1, 0, 0, 0, 2007, 2008, 1, 0, 0, 0, 2008, 2009, 5, 299, 0, 0, 2009, 2010, 3, 114, 57, 0, 2010, 111, 1, 0, 0, 0, 2011, 2012, 5, 342, 0, 0, 2012, 2013, 5, 196, 0, 0, 2013, 2014, 5, 177, 0, 0, 2014, 2015, 5, 31, 0, 0, 2015, 2018, 5, 279, 0, 0, 2016, 2017, 5, 14, 0, 0, 2017, 2019, 3, 236, 118, 0, 2018, 2016, 1, 0, 0, 0, 2018, 2019, 1, 0, 0, 0, 2019, 2020, 1, 0, 0, 0, 2020, 2025, 5, 299, 0, 0, 2021, 2026, 5, 84, 0, 0, 2022, 2023, 5, 328, 0, 0, 2023, 2024, 5, 268, 0, 0, 2024, 2026, 3, 116, 58, 0, 2025, 2021, 1, 0, 0, 0, 2025, 2022, 1, 0, 0, 0, 2026, 113, 1, 0, 0, 0, 2027, 2028, 5, 147, 0, 0, 2028, 2046, 5, 362, 0, 0, 2029, 2030, 5, 147, 0, 0, 2030, 2031, 5, 2, 0, 0, 2031, 2032, 3, 204, 102, 0, 2032, 2033, 5, 3, 0, 0, 2033, 2034, 5, 332, 0, 0, 2034, 2035, 5, 2, 0, 0, 2035, 2040, 3, 228, 114, 0, 2036, 2037, 5, 4, 0, 0, 2037, 2039, 3, 228, 114, 0, 2038, 2036, 1, 0, 0, 0, 2039, 2042, 1, 0, 0, 0, 2040, 2038, 1, 0, 0, 0, 2040, 2041, 1, 0, 0, 0, 2041, 2043, 1, 0, 0, 0, 2042, 2040, 1, 0, 0, 0, 2043, 2044, 5, 3, 0, 0, 2044, 2046, 1, 0, 0, 0, 2045, 2027, 1, 0, 0, 0, 2045, 2029, 1, 0, 0, 0, 2046, 115, 1, 0, 0, 0, 2047, 2052, 3, 118, 59, 0, 2048, 2049, 5, 4, 0, 0, 2049, 2051, 3, 118, 59, 0, 2050, 2048, 1, 0, 0, 0, 2051, 2054, 1, 0, 0, 0, 2052, 2050, 1, 0, 0, 0, 2052, 2053, 1, 0, 0, 0, 2053, 117, 1, 0, 0, 0, 2054, 2052, 1, 0, 0, 0, 2055, 2056, 3, 206, 103, 0, 2056, 2057, 5, 351, 0, 0, 2057, 2058, 3, 228, 114, 0, 2058, 119, 1, 0, 0, 0, 2059, 2060, 5, 343, 0, 0, 2060, 2061, 3, 236, 118, 0, 2061, 121, 1, 0, 0, 0, 2062, 2063, 5, 132, 0, 0, 2063, 2064, 3, 236, 118, 0, 2064, 123, 1, 0, 0, 0, 2065, 2066, 5, 373, 0, 0, 2066, 2073, 3, 126, 63, 0, 2067, 2069, 5, 4, 0, 0, 2068, 2067, 1, 0, 0, 0, 2068, 2069, 1, 0, 0, 0, 2069, 2070, 1, 0, 0, 0, 2070, 2072, 3, 126, 63, 0, 2071, 2068, 1, 0, 0, 0, 2072, 2075, 1, 0, 0, 0, 2073, 2071, 1, 0, 0, 0, 2073, 2074, 1, 0, 0, 0, 2074, 2076, 1, 0, 0, 0, 2075, 2073, 1, 0, 0, 0, 2076, 2077, 5, 374, 0, 0, 2077, 125, 1, 0, 0, 0, 2078, 2092, 3, 326, 163, 0, 2079, 2080, 3, 326, 163, 0, 2080, 2081, 5, 2, 0, 0, 2081, 2086, 3, 244, 122, 0, 2082, 2083, 5, 4, 0, 0, 2083, 2085, 3, 244, 122, 0, 2084, 2082, 1, 0, 0, 0, 2085, 2088, 1, 0, 0, 0, 2086, 2084, 1, 0, 0, 0, 2086, 2087, 1, 0, 0, 0, 2087, 2089, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2089, 2090, 5, 3, 0, 0, 2090, 2092, 1, 0, 0, 0, 2091, 2078, 1, 0, 0, 0, 2091, 2079, 1, 0, 0, 0, 2092, 127, 1, 0, 0, 0, 2093, 2094, 5, 123, 0, 0, 2094, 2099, 3, 164, 82, 0, 2095, 2096, 5, 4, 0, 0, 2096, 2098, 3, 164, 82, 0, 2097, 2095, 1, 0, 0, 0, 2098, 2101, 1, 0, 0, 0, 2099, 2097, 1, 0, 0, 0, 2099, 2100, 1, 0, 0, 0, 2100, 2105, 1, 0, 0, 0, 2101, 2099, 1, 0, 0, 0, 2102, 2104, 3, 160, 80, 0, 2103, 2102, 1, 0, 0, 0, 2104, 2107, 1, 0, 0, 0, 2105, 2103, 1, 0, 0, 0, 2105, 2106, 1, 0, 0, 0, 2106, 2109, 1, 0, 0, 0, 2107, 2105, 1, 0, 0, 0, 2108, 2110, 3, 140, 70, 0, 2109, 2108, 1, 0, 0, 0, 2109, 2110, 1, 0, 0, 0, 2110, 2112, 1, 0, 0, 0, 2111, 2113, 3, 146, 73, 0, 2112, 2111, 1, 0, 0, 0, 2112, 2113, 1, 0, 0, 0, 2113, 129, 1, 0, 0, 0, 2114, 2116, 5, 119, 0, 0, 2115, 2114, 1, 0, 0, 0, 2115, 2116, 1, 0, 0, 0, 2116, 2117, 1, 0, 0, 0, 2117, 2118, 7, 27, 0, 0, 2118, 2119, 5, 20, 0, 0, 2119, 2122, 5, 200, 0, 0, 2120, 2123, 5, 381, 0, 0, 2121, 2123, 3, 334, 167, 0, 2122, 2120, 1, 0, 0, 0, 2122, 2121, 1, 0, 0, 0, 2123, 2132, 1, 0, 0, 0, 2124, 2126, 5, 119, 0, 0, 2125, 2124, 1, 0, 0, 0, 2125, 2126, 1, 0, 0, 0, 2126, 2127, 1, 0, 0, 0, 2127, 2128, 7, 28, 0, 0, 2128, 2129, 5, 20, 0, 0, 2129, 2130, 5, 200, 0, 0, 2130, 2132, 3, 240, 120, 0, 2131, 2115, 1, 0, 0, 0, 2131, 2125, 1, 0, 0, 0, 2132, 131, 1, 0, 0, 0, 2133, 2134, 5, 130, 0, 0, 2134, 2135, 5, 31, 0, 0, 2135, 2140, 3, 134, 67, 0, 2136, 2137, 5, 4, 0, 0, 2137, 2139, 3, 134, 67, 0, 2138, 2136, 1, 0, 0, 0, 2139, 2142, 1, 0, 0, 0, 2140, 2138, 1, 0, 0, 0, 2140, 2141, 1, 0, 0, 0, 2141, 2173, 1, 0, 0, 0, 2142, 2140, 1, 0, 0, 0, 2143, 2144, 5, 130, 0, 0, 2144, 2145, 5, 31, 0, 0, 2145, 2150, 3, 228, 114, 0, 2146, 2147, 5, 4, 0, 0, 2147, 2149, 3, 228, 114, 0, 2148, 2146, 1, 0, 0, 0, 2149, 2152, 1, 0, 0, 0, 2150, 2148, 1, 0, 0, 0, 2150, 2151, 1, 0, 0, 0, 2151, 2170, 1, 0, 0, 0, 2152, 2150, 1, 0, 0, 0, 2153, 2154, 5, 345, 0, 0, 2154, 2171, 5, 255, 0, 0, 2155, 2156, 5, 345, 0, 0, 2156, 2171, 5, 61, 0, 0, 2157, 2158, 5, 131, 0, 0, 2158, 2159, 5, 270, 0, 0, 2159, 2160, 5, 2, 0, 0, 2160, 2165, 3, 138, 69, 0, 2161, 2162, 5, 4, 0, 0, 2162, 2164, 3, 138, 69, 0, 2163, 2161, 1, 0, 0, 0, 2164, 2167, 1, 0, 0, 0, 2165, 2163, 1, 0, 0, 0, 2165, 2166, 1, 0, 0, 0, 2166, 2168, 1, 0, 0, 0, 2167, 2165, 1, 0, 0, 0, 2168, 2169, 5, 3, 0, 0, 2169, 2171, 1, 0, 0, 0, 2170, 2153, 1, 0, 0, 0, 2170, 2155, 1, 0, 0, 0, 2170, 2157, 1, 0, 0, 0, 2170, 2171, 1, 0, 0, 0, 2171, 2173, 1, 0, 0, 0, 2172, 2133, 1, 0, 0, 0, 2172, 2143, 1, 0, 0, 0, 2173, 133, 1, 0, 0, 0, 2174, 2178, 3, 82, 41, 0, 2175, 2178, 3, 136, 68, 0, 2176, 2178, 3, 228, 114, 0, 2177, 2174, 1, 0, 0, 0, 2177, 2175, 1, 0, 0, 0, 2177, 2176, 1, 0, 0, 0, 2178, 135, 1, 0, 0, 0, 2179, 2180, 7, 29, 0, 0, 2180, 2181, 5, 2, 0, 0, 2181, 2186, 3, 138, 69, 0, 2182, 2183, 5, 4, 0, 0, 2183, 2185, 3, 138, 69, 0, 2184, 2182, 1, 0, 0, 0, 2185, 2188, 1, 0, 0, 0, 2186, 2184, 1, 0, 0, 0, 2186, 2187, 1, 0, 0, 0, 2187, 2189, 1, 0, 0, 0, 2188, 2186, 1, 0, 0, 0, 2189, 2190, 5, 3, 0, 0, 2190, 2211, 1, 0, 0, 0, 2191, 2192, 5, 131, 0, 0, 2192, 2193, 5, 270, 0, 0, 2193, 2196, 5, 2, 0, 0, 2194, 2197, 3, 136, 68, 0, 2195, 2197, 3, 138, 69, 0, 2196, 2194, 1, 0, 0, 0, 2196, 2195, 1, 0, 0, 0, 2197, 2205, 1, 0, 0, 0, 2198, 2201, 5, 4, 0, 0, 2199, 2202, 3, 136, 68, 0, 2200, 2202, 3, 138, 69, 0, 2201, 2199, 1, 0, 0, 0, 2201, 2200, 1, 0, 0, 0, 2202, 2204, 1, 0, 0, 0, 2203, 2198, 1, 0, 0, 0, 2204, 2207, 1, 0, 0, 0, 2205, 2203, 1, 0, 0, 0, 2205, 2206, 1, 0, 0, 0, 2206, 2208, 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2209, 5, 3, 0, 0, 2209, 2211, 1, 0, 0, 0, 2210, 2179, 1, 0, 0, 0, 2210, 2191, 1, 0, 0, 0, 2211, 137, 1, 0, 0, 0, 2212, 2233, 3, 82, 41, 0, 2213, 2233, 3, 228, 114, 0, 2214, 2229, 5, 2, 0, 0, 2215, 2218, 3, 82, 41, 0, 2216, 2218, 3, 228, 114, 0, 2217, 2215, 1, 0, 0, 0, 2217, 2216, 1, 0, 0, 0, 2218, 2226, 1, 0, 0, 0, 2219, 2222, 5, 4, 0, 0, 2220, 2223, 3, 82, 41, 0, 2221, 2223, 3, 228, 114, 0, 2222, 2220, 1, 0, 0, 0, 2222, 2221, 1, 0, 0, 0, 2223, 2225, 1, 0, 0, 0, 2224, 2219, 1, 0, 0, 0, 2225, 2228, 1, 0, 0, 0, 2226, 2224, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2230, 1, 0, 0, 0, 2228, 2226, 1, 0, 0, 0, 2229, 2217, 1, 0, 0, 0, 2229, 2230, 1, 0, 0, 0, 2230, 2231, 1, 0, 0, 0, 2231, 2233, 5, 3, 0, 0, 2232, 2212, 1, 0, 0, 0, 2232, 2213, 1, 0, 0, 0, 2232, 2214, 1, 0, 0, 0, 2233, 139, 1, 0, 0, 0, 2234, 2235, 5, 222, 0, 0, 2235, 2236, 5, 2, 0, 0, 2236, 2237, 3, 218, 109, 0, 2237, 2238, 5, 119, 0, 0, 2238, 2239, 3, 142, 71, 0, 2239, 2240, 5, 140, 0, 0, 2240, 2241, 5, 2, 0, 0, 2241, 2246, 3, 144, 72, 0, 2242, 2243, 5, 4, 0, 0, 2243, 2245, 3, 144, 72, 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, 2249, 1, 0, 0, 0, 2248, 2246, 1, 0, 0, 0, 2249, 2250, 5, 3, 0, 0, 2250, 2251, 5, 3, 0, 0, 2251, 141, 1, 0, 0, 0, 2252, 2265, 3, 326, 163, 0, 2253, 2254, 5, 2, 0, 0, 2254, 2259, 3, 326, 163, 0, 2255, 2256, 5, 4, 0, 0, 2256, 2258, 3, 326, 163, 0, 2257, 2255, 1, 0, 0, 0, 2258, 2261, 1, 0, 0, 0, 2259, 2257, 1, 0, 0, 0, 2259, 2260, 1, 0, 0, 0, 2260, 2262, 1, 0, 0, 0, 2261, 2259, 1, 0, 0, 0, 2262, 2263, 5, 3, 0, 0, 2263, 2265, 1, 0, 0, 0, 2264, 2252, 1, 0, 0, 0, 2264, 2253, 1, 0, 0, 0, 2265, 143, 1, 0, 0, 0, 2266, 2271, 3, 228, 114, 0, 2267, 2269, 5, 20, 0, 0, 2268, 2267, 1, 0, 0, 0, 2268, 2269, 1, 0, 0, 0, 2269, 2270, 1, 0, 0, 0, 2270, 2272, 3, 326, 163, 0, 2271, 2268, 1, 0, 0, 0, 2271, 2272, 1, 0, 0, 0, 2272, 145, 1, 0, 0, 0, 2273, 2276, 5, 326, 0, 0, 2274, 2275, 7, 30, 0, 0, 2275, 2277, 5, 198, 0, 0, 2276, 2274, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, 0, 2277, 2278, 1, 0, 0, 0, 2278, 2281, 5, 2, 0, 0, 2279, 2282, 3, 148, 74, 0, 2280, 2282, 3, 150, 75, 0, 2281, 2279, 1, 0, 0, 0, 2281, 2280, 1, 0, 0, 0, 2282, 2283, 1, 0, 0, 0, 2283, 2288, 5, 3, 0, 0, 2284, 2286, 5, 20, 0, 0, 2285, 2284, 1, 0, 0, 0, 2285, 2286, 1, 0, 0, 0, 2286, 2287, 1, 0, 0, 0, 2287, 2289, 3, 326, 163, 0, 2288, 2285, 1, 0, 0, 0, 2288, 2289, 1, 0, 0, 0, 2289, 147, 1, 0, 0, 0, 2290, 2291, 3, 326, 163, 0, 2291, 2292, 5, 119, 0, 0, 2292, 2293, 3, 326, 163, 0, 2293, 2294, 5, 140, 0, 0, 2294, 2295, 5, 2, 0, 0, 2295, 2300, 3, 154, 77, 0, 2296, 2297, 5, 4, 0, 0, 2297, 2299, 3, 154, 77, 0, 2298, 2296, 1, 0, 0, 0, 2299, 2302, 1, 0, 0, 0, 2300, 2298, 1, 0, 0, 0, 2300, 2301, 1, 0, 0, 0, 2301, 2303, 1, 0, 0, 0, 2302, 2300, 1, 0, 0, 0, 2303, 2304, 5, 3, 0, 0, 2304, 149, 1, 0, 0, 0, 2305, 2306, 5, 2, 0, 0, 2306, 2311, 3, 326, 163, 0, 2307, 2308, 5, 4, 0, 0, 2308, 2310, 3, 326, 163, 0, 2309, 2307, 1, 0, 0, 0, 2310, 2313, 1, 0, 0, 0, 2311, 2309, 1, 0, 0, 0, 2311, 2312, 1, 0, 0, 0, 2312, 2314, 1, 0, 0, 0, 2313, 2311, 1, 0, 0, 0, 2314, 2315, 5, 3, 0, 0, 2315, 2316, 5, 119, 0, 0, 2316, 2317, 3, 326, 163, 0, 2317, 2318, 5, 140, 0, 0, 2318, 2319, 5, 2, 0, 0, 2319, 2324, 3, 152, 76, 0, 2320, 2321, 5, 4, 0, 0, 2321, 2323, 3, 152, 76, 0, 2322, 2320, 1, 0, 0, 0, 2323, 2326, 1, 0, 0, 0, 2324, 2322, 1, 0, 0, 0, 2324, 2325, 1, 0, 0, 0, 2325, 2327, 1, 0, 0, 0, 2326, 2324, 1, 0, 0, 0, 2327, 2328, 5, 3, 0, 0, 2328, 151, 1, 0, 0, 0, 2329, 2330, 5, 2, 0, 0, 2330, 2335, 3, 206, 103, 0, 2331, 2332, 5, 4, 0, 0, 2332, 2334, 3, 206, 103, 0, 2333, 2331, 1, 0, 0, 0, 2334, 2337, 1, 0, 0, 0, 2335, 2333, 1, 0, 0, 0, 2335, 2336, 1, 0, 0, 0, 2336, 2338, 1, 0, 0, 0, 2337, 2335, 1, 0, 0, 0, 2338, 2343, 5, 3, 0, 0, 2339, 2341, 5, 20, 0, 0, 2340, 2339, 1, 0, 0, 0, 2340, 2341, 1, 0, 0, 0, 2341, 2342, 1, 0, 0, 0, 2342, 2344, 3, 326, 163, 0, 2343, 2340, 1, 0, 0, 0, 2343, 2344, 1, 0, 0, 0, 2344, 153, 1, 0, 0, 0, 2345, 2350, 3, 206, 103, 0, 2346, 2348, 5, 20, 0, 0, 2347, 2346, 1, 0, 0, 0, 2347, 2348, 1, 0, 0, 0, 2348, 2349, 1, 0, 0, 0, 2349, 2351, 3, 326, 163, 0, 2350, 2347, 1, 0, 0, 0, 2350, 2351, 1, 0, 0, 0, 2351, 155, 1, 0, 0, 0, 2352, 2353, 5, 137, 0, 0, 2353, 2354, 5, 196, 0, 0, 2354, 2355, 5, 105, 0, 0, 2355, 157, 1, 0, 0, 0, 2356, 2357, 5, 137, 0, 0, 2357, 2358, 5, 105, 0, 0, 2358, 159, 1, 0, 0, 0, 2359, 2360, 5, 158, 0, 0, 2360, 2362, 5, 337, 0, 0, 2361, 2363, 5, 210, 0, 0, 2362, 2361, 1, 0, 0, 0, 2362, 2363, 1, 0, 0, 0, 2363, 2364, 1, 0, 0, 0, 2364, 2365, 3, 80, 40, 0, 2365, 2374, 5, 2, 0, 0, 2366, 2371, 3, 228, 114, 0, 2367, 2368, 5, 4, 0, 0, 2368, 2370, 3, 228, 114, 0, 2369, 2367, 1, 0, 0, 0, 2370, 2373, 1, 0, 0, 0, 2371, 2369, 1, 0, 0, 0, 2371, 2372, 1, 0, 0, 0, 2372, 2375, 1, 0, 0, 0, 2373, 2371, 1, 0, 0, 0, 2374, 2366, 1, 0, 0, 0, 2374, 2375, 1, 0, 0, 0, 2375, 2376, 1, 0, 0, 0, 2376, 2377, 5, 3, 0, 0, 2377, 2389, 3, 200, 100, 0, 2378, 2380, 5, 20, 0, 0, 2379, 2378, 1, 0, 0, 0, 2379, 2380, 1, 0, 0, 0, 2380, 2381, 1, 0, 0, 0, 2381, 2386, 3, 326, 163, 0, 2382, 2383, 5, 4, 0, 0, 2383, 2385, 3, 326, 163, 0, 2384, 2382, 1, 0, 0, 0, 2385, 2388, 1, 0, 0, 0, 2386, 2384, 1, 0, 0, 0, 2386, 2387, 1, 0, 0, 0, 2387, 2390, 1, 0, 0, 0, 2388, 2386, 1, 0, 0, 0, 2389, 2379, 1, 0, 0, 0, 2389, 2390, 1, 0, 0, 0, 2390, 161, 1, 0, 0, 0, 2391, 2392, 7, 31, 0, 0, 2392, 163, 1, 0, 0, 0, 2393, 2407, 3, 76, 38, 0, 2394, 2396, 5, 158, 0, 0, 2395, 2394, 1, 0, 0, 0, 2395, 2396, 1, 0, 0, 0, 2396, 2397, 1, 0, 0, 0, 2397, 2403, 3, 188, 94, 0, 2398, 2402, 3, 166, 83, 0, 2399, 2402, 3, 140, 70, 0, 2400, 2402, 3, 146, 73, 0, 2401, 2398, 1, 0, 0, 0, 2401, 2399, 1, 0, 0, 0, 2401, 2400, 1, 0, 0, 0, 2402, 2405, 1, 0, 0, 0, 2403, 2401, 1, 0, 0, 0, 2403, 2404, 1, 0, 0, 0, 2404, 2407, 1, 0, 0, 0, 2405, 2403, 1, 0, 0, 0, 2406, 2393, 1, 0, 0, 0, 2406, 2395, 1, 0, 0, 0, 2407, 165, 1, 0, 0, 0, 2408, 2409, 3, 168, 84, 0, 2409, 2411, 5, 155, 0, 0, 2410, 2412, 5, 158, 0, 0, 2411, 2410, 1, 0, 0, 0, 2411, 2412, 1, 0, 0, 0, 2412, 2413, 1, 0, 0, 0, 2413, 2415, 3, 188, 94, 0, 2414, 2416, 3, 170, 85, 0, 2415, 2414, 1, 0, 0, 0, 2415, 2416, 1, 0, 0, 0, 2416, 2426, 1, 0, 0, 0, 2417, 2418, 5, 193, 0, 0, 2418, 2419, 3, 168, 84, 0, 2419, 2421, 5, 155, 0, 0, 2420, 2422, 5, 158, 0, 0, 2421, 2420, 1, 0, 0, 0, 2421, 2422, 1, 0, 0, 0, 2422, 2423, 1, 0, 0, 0, 2423, 2424, 3, 188, 94, 0, 2424, 2426, 1, 0, 0, 0, 2425, 2408, 1, 0, 0, 0, 2425, 2417, 1, 0, 0, 0, 2426, 167, 1, 0, 0, 0, 2427, 2429, 5, 144, 0, 0, 2428, 2427, 1, 0, 0, 0, 2428, 2429, 1, 0, 0, 0, 2429, 2444, 1, 0, 0, 0, 2430, 2444, 5, 60, 0, 0, 2431, 2433, 5, 161, 0, 0, 2432, 2434, 5, 210, 0, 0, 2433, 2432, 1, 0, 0, 0, 2433, 2434, 1, 0, 0, 0, 2434, 2444, 1, 0, 0, 0, 2435, 2437, 5, 161, 0, 0, 2436, 2435, 1, 0, 0, 0, 2436, 2437, 1, 0, 0, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2444, 7, 32, 0, 0, 2439, 2441, 7, 33, 0, 0, 2440, 2442, 5, 210, 0, 0, 2441, 2440, 1, 0, 0, 0, 2441, 2442, 1, 0, 0, 0, 2442, 2444, 1, 0, 0, 0, 2443, 2428, 1, 0, 0, 0, 2443, 2430, 1, 0, 0, 0, 2443, 2431, 1, 0, 0, 0, 2443, 2436, 1, 0, 0, 0, 2443, 2439, 1, 0, 0, 0, 2444, 169, 1, 0, 0, 0, 2445, 2446, 5, 202, 0, 0, 2446, 2450, 3, 236, 118, 0, 2447, 2448, 5, 331, 0, 0, 2448, 2450, 3, 176, 88, 0, 2449, 2445, 1, 0, 0, 0, 2449, 2447, 1, 0, 0, 0, 2450, 171, 1, 0, 0, 0, 2451, 2452, 5, 294, 0, 0, 2452, 2454, 5, 2, 0, 0, 2453, 2455, 3, 174, 87, 0, 2454, 2453, 1, 0, 0, 0, 2454, 2455, 1, 0, 0, 0, 2455, 2456, 1, 0, 0, 0, 2456, 2461, 5, 3, 0, 0, 2457, 2458, 5, 242, 0, 0, 2458, 2459, 5, 2, 0, 0, 2459, 2460, 5, 381, 0, 0, 2460, 2462, 5, 3, 0, 0, 2461, 2457, 1, 0, 0, 0, 2461, 2462, 1, 0, 0, 0, 2462, 173, 1, 0, 0, 0, 2463, 2465, 5, 361, 0, 0, 2464, 2463, 1, 0, 0, 0, 2464, 2465, 1, 0, 0, 0, 2465, 2466, 1, 0, 0, 0, 2466, 2467, 7, 34, 0, 0, 2467, 2488, 5, 221, 0, 0, 2468, 2469, 3, 228, 114, 0, 2469, 2470, 5, 257, 0, 0, 2470, 2488, 1, 0, 0, 0, 2471, 2472, 5, 29, 0, 0, 2472, 2473, 5, 381, 0, 0, 2473, 2474, 5, 209, 0, 0, 2474, 2475, 5, 200, 0, 0, 2475, 2484, 5, 381, 0, 0, 2476, 2482, 5, 202, 0, 0, 2477, 2483, 3, 326, 163, 0, 2478, 2479, 3, 320, 160, 0, 2479, 2480, 5, 2, 0, 0, 2480, 2481, 5, 3, 0, 0, 2481, 2483, 1, 0, 0, 0, 2482, 2477, 1, 0, 0, 0, 2482, 2478, 1, 0, 0, 0, 2483, 2485, 1, 0, 0, 0, 2484, 2476, 1, 0, 0, 0, 2484, 2485, 1, 0, 0, 0, 2485, 2488, 1, 0, 0, 0, 2486, 2488, 3, 228, 114, 0, 2487, 2464, 1, 0, 0, 0, 2487, 2468, 1, 0, 0, 0, 2487, 2471, 1, 0, 0, 0, 2487, 2486, 1, 0, 0, 0, 2488, 175, 1, 0, 0, 0, 2489, 2490, 5, 2, 0, 0, 2490, 2491, 3, 178, 89, 0, 2491, 2492, 5, 3, 0, 0, 2492, 177, 1, 0, 0, 0, 2493, 2498, 3, 322, 161, 0, 2494, 2495, 5, 4, 0, 0, 2495, 2497, 3, 322, 161, 0, 2496, 2494, 1, 0, 0, 0, 2497, 2500, 1, 0, 0, 0, 2498, 2496, 1, 0, 0, 0, 2498, 2499, 1, 0, 0, 0, 2499, 179, 1, 0, 0, 0, 2500, 2498, 1, 0, 0, 0, 2501, 2502, 5, 2, 0, 0, 2502, 2507, 3, 182, 91, 0, 2503, 2504, 5, 4, 0, 0, 2504, 2506, 3, 182, 91, 0, 2505, 2503, 1, 0, 0, 0, 2506, 2509, 1, 0, 0, 0, 2507, 2505, 1, 0, 0, 0, 2507, 2508, 1, 0, 0, 0, 2508, 2510, 1, 0, 0, 0, 2509, 2507, 1, 0, 0, 0, 2510, 2511, 5, 3, 0, 0, 2511, 181, 1, 0, 0, 0, 2512, 2514, 3, 322, 161, 0, 2513, 2515, 7, 25, 0, 0, 2514, 2513, 1, 0, 0, 0, 2514, 2515, 1, 0, 0, 0, 2515, 183, 1, 0, 0, 0, 2516, 2517, 5, 2, 0, 0, 2517, 2522, 3, 186, 93, 0, 2518, 2519, 5, 4, 0, 0, 2519, 2521, 3, 186, 93, 0, 2520, 2518, 1, 0, 0, 0, 2521, 2524, 1, 0, 0, 0, 2522, 2520, 1, 0, 0, 0, 2522, 2523, 1, 0, 0, 0, 2523, 2525, 1, 0, 0, 0, 2524, 2522, 1, 0, 0, 0, 2525, 2526, 5, 3, 0, 0, 2526, 185, 1, 0, 0, 0, 2527, 2530, 3, 86, 43, 0, 2528, 2529, 5, 51, 0, 0, 2529, 2531, 3, 334, 167, 0, 2530, 2528, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 187, 1, 0, 0, 0, 2532, 2536, 3, 76, 38, 0, 2533, 2536, 3, 80, 40, 0, 2534, 2536, 3, 88, 44, 0, 2535, 2532, 1, 0, 0, 0, 2535, 2533, 1, 0, 0, 0, 2535, 2534, 1, 0, 0, 0, 2536, 2538, 1, 0, 0, 0, 2537, 2539, 3, 130, 65, 0, 2538, 2537, 1, 0, 0, 0, 2538, 2539, 1, 0, 0, 0, 2539, 2541, 1, 0, 0, 0, 2540, 2542, 3, 172, 86, 0, 2541, 2540, 1, 0, 0, 0, 2541, 2542, 1, 0, 0, 0, 2542, 2543, 1, 0, 0, 0, 2543, 2544, 3, 200, 100, 0, 2544, 2588, 1, 0, 0, 0, 2545, 2546, 5, 2, 0, 0, 2546, 2547, 3, 24, 12, 0, 2547, 2549, 5, 3, 0, 0, 2548, 2550, 3, 172, 86, 0, 2549, 2548, 1, 0, 0, 0, 2549, 2550, 1, 0, 0, 0, 2550, 2551, 1, 0, 0, 0, 2551, 2552, 3, 200, 100, 0, 2552, 2588, 1, 0, 0, 0, 2553, 2554, 5, 2, 0, 0, 2554, 2555, 3, 164, 82, 0, 2555, 2557, 5, 3, 0, 0, 2556, 2558, 3, 172, 86, 0, 2557, 2556, 1, 0, 0, 0, 2557, 2558, 1, 0, 0, 0, 2558, 2559, 1, 0, 0, 0, 2559, 2560, 3, 200, 100, 0, 2560, 2588, 1, 0, 0, 0, 2561, 2562, 5, 332, 0, 0, 2562, 2567, 3, 228, 114, 0, 2563, 2564, 5, 4, 0, 0, 2564, 2566, 3, 228, 114, 0, 2565, 2563, 1, 0, 0, 0, 2566, 2569, 1, 0, 0, 0, 2567, 2565, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2570, 1, 0, 0, 0, 2569, 2567, 1, 0, 0, 0, 2570, 2571, 3, 200, 100, 0, 2571, 2588, 1, 0, 0, 0, 2572, 2573, 3, 316, 158, 0, 2573, 2582, 5, 2, 0, 0, 2574, 2579, 3, 198, 99, 0, 2575, 2576, 5, 4, 0, 0, 2576, 2578, 3, 198, 99, 0, 2577, 2575, 1, 0, 0, 0, 2578, 2581, 1, 0, 0, 0, 2579, 2577, 1, 0, 0, 0, 2579, 2580, 1, 0, 0, 0, 2580, 2583, 1, 0, 0, 0, 2581, 2579, 1, 0, 0, 0, 2582, 2574, 1, 0, 0, 0, 2582, 2583, 1, 0, 0, 0, 2583, 2584, 1, 0, 0, 0, 2584, 2585, 5, 3, 0, 0, 2585, 2586, 3, 200, 100, 0, 2586, 2588, 1, 0, 0, 0, 2587, 2535, 1, 0, 0, 0, 2587, 2545, 1, 0, 0, 0, 2587, 2553, 1, 0, 0, 0, 2587, 2561, 1, 0, 0, 0, 2587, 2572, 1, 0, 0, 0, 2588, 189, 1, 0, 0, 0, 2589, 2590, 5, 292, 0, 0, 2590, 2592, 3, 76, 38, 0, 2591, 2593, 3, 192, 96, 0, 2592, 2591, 1, 0, 0, 0, 2592, 2593, 1, 0, 0, 0, 2593, 2609, 1, 0, 0, 0, 2594, 2595, 5, 292, 0, 0, 2595, 2596, 5, 2, 0, 0, 2596, 2597, 3, 76, 38, 0, 2597, 2599, 5, 3, 0, 0, 2598, 2600, 3, 192, 96, 0, 2599, 2598, 1, 0, 0, 0, 2599, 2600, 1, 0, 0, 0, 2600, 2609, 1, 0, 0, 0, 2601, 2602, 5, 292, 0, 0, 2602, 2603, 5, 2, 0, 0, 2603, 2604, 3, 24, 12, 0, 2604, 2606, 5, 3, 0, 0, 2605, 2607, 3, 192, 96, 0, 2606, 2605, 1, 0, 0, 0, 2606, 2607, 1, 0, 0, 0, 2607, 2609, 1, 0, 0, 0, 2608, 2589, 1, 0, 0, 0, 2608, 2594, 1, 0, 0, 0, 2608, 2601, 1, 0, 0, 0, 2609, 191, 1, 0, 0, 0, 2610, 2611, 5, 345, 0, 0, 2611, 2612, 5, 273, 0, 0, 2612, 2630, 5, 216, 0, 0, 2613, 2614, 7, 35, 0, 0, 2614, 2627, 5, 31, 0, 0, 2615, 2616, 5, 2, 0, 0, 2616, 2621, 3, 228, 114, 0, 2617, 2618, 5, 4, 0, 0, 2618, 2620, 3, 228, 114, 0, 2619, 2617, 1, 0, 0, 0, 2620, 2623, 1, 0, 0, 0, 2621, 2619, 1, 0, 0, 0, 2621, 2622, 1, 0, 0, 0, 2622, 2624, 1, 0, 0, 0, 2623, 2621, 1, 0, 0, 0, 2624, 2625, 5, 3, 0, 0, 2625, 2628, 1, 0, 0, 0, 2626, 2628, 3, 228, 114, 0, 2627, 2615, 1, 0, 0, 0, 2627, 2626, 1, 0, 0, 0, 2628, 2630, 1, 0, 0, 0, 2629, 2610, 1, 0, 0, 0, 2629, 2613, 1, 0, 0, 0, 2630, 2647, 1, 0, 0, 0, 2631, 2632, 7, 36, 0, 0, 2632, 2645, 5, 31, 0, 0, 2633, 2634, 5, 2, 0, 0, 2634, 2639, 3, 96, 48, 0, 2635, 2636, 5, 4, 0, 0, 2636, 2638, 3, 96, 48, 0, 2637, 2635, 1, 0, 0, 0, 2638, 2641, 1, 0, 0, 0, 2639, 2637, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, 2642, 1, 0, 0, 0, 2641, 2639, 1, 0, 0, 0, 2642, 2643, 5, 3, 0, 0, 2643, 2646, 1, 0, 0, 0, 2644, 2646, 3, 96, 48, 0, 2645, 2633, 1, 0, 0, 0, 2645, 2644, 1, 0, 0, 0, 2646, 2648, 1, 0, 0, 0, 2647, 2631, 1, 0, 0, 0, 2647, 2648, 1, 0, 0, 0, 2648, 193, 1, 0, 0, 0, 2649, 2650, 3, 326, 163, 0, 2650, 2651, 5, 372, 0, 0, 2651, 2652, 3, 190, 95, 0, 2652, 195, 1, 0, 0, 0, 2653, 2656, 3, 190, 95, 0, 2654, 2656, 3, 194, 97, 0, 2655, 2653, 1, 0, 0, 0, 2655, 2654, 1, 0, 0, 0, 2656, 197, 1, 0, 0, 0, 2657, 2660, 3, 196, 98, 0, 2658, 2660, 3, 232, 116, 0, 2659, 2657, 1, 0, 0, 0, 2659, 2658, 1, 0, 0, 0, 2660, 199, 1, 0, 0, 0, 2661, 2663, 5, 20, 0, 0, 2662, 2661, 1, 0, 0, 0, 2662, 2663, 1, 0, 0, 0, 2663, 2664, 1, 0, 0, 0, 2664, 2666, 3, 328, 164, 0, 2665, 2667, 3, 176, 88, 0, 2666, 2665, 1, 0, 0, 0, 2666, 2667, 1, 0, 0, 0, 2667, 2669, 1, 0, 0, 0, 2668, 2662, 1, 0, 0, 0, 2668, 2669, 1, 0, 0, 0, 2669, 201, 1, 0, 0, 0, 2670, 2671, 5, 256, 0, 0, 2671, 2672, 5, 121, 0, 0, 2672, 2673, 5, 265, 0, 0, 2673, 2677, 3, 334, 167, 0, 2674, 2675, 5, 345, 0, 0, 2675, 2676, 5, 266, 0, 0, 2676, 2678, 3, 48, 24, 0, 2677, 2674, 1, 0, 0, 0, 2677, 2678, 1, 0, 0, 0, 2678, 2720, 1, 0, 0, 0, 2679, 2680, 5, 256, 0, 0, 2680, 2681, 5, 121, 0, 0, 2681, 2691, 5, 85, 0, 0, 2682, 2683, 5, 113, 0, 0, 2683, 2684, 5, 298, 0, 0, 2684, 2685, 5, 31, 0, 0, 2685, 2689, 3, 334, 167, 0, 2686, 2687, 5, 101, 0, 0, 2687, 2688, 5, 31, 0, 0, 2688, 2690, 3, 334, 167, 0, 2689, 2686, 1, 0, 0, 0, 2689, 2690, 1, 0, 0, 0, 2690, 2692, 1, 0, 0, 0, 2691, 2682, 1, 0, 0, 0, 2691, 2692, 1, 0, 0, 0, 2692, 2698, 1, 0, 0, 0, 2693, 2694, 5, 48, 0, 0, 2694, 2695, 5, 154, 0, 0, 2695, 2696, 5, 298, 0, 0, 2696, 2697, 5, 31, 0, 0, 2697, 2699, 3, 334, 167, 0, 2698, 2693, 1, 0, 0, 0, 2698, 2699, 1, 0, 0, 0, 2699, 2705, 1, 0, 0, 0, 2700, 2701, 5, 176, 0, 0, 2701, 2702, 5, 156, 0, 0, 2702, 2703, 5, 298, 0, 0, 2703, 2704, 5, 31, 0, 0, 2704, 2706, 3, 334, 167, 0, 2705, 2700, 1, 0, 0, 0, 2705, 2706, 1, 0, 0, 0, 2706, 2711, 1, 0, 0, 0, 2707, 2708, 5, 166, 0, 0, 2708, 2709, 5, 298, 0, 0, 2709, 2710, 5, 31, 0, 0, 2710, 2712, 3, 334, 167, 0, 2711, 2707, 1, 0, 0, 0, 2711, 2712, 1, 0, 0, 0, 2712, 2717, 1, 0, 0, 0, 2713, 2714, 5, 197, 0, 0, 2714, 2715, 5, 83, 0, 0, 2715, 2716, 5, 20, 0, 0, 2716, 2718, 3, 334, 167, 0, 2717, 2713, 1, 0, 0, 0, 2717, 2718, 1, 0, 0, 0, 2718, 2720, 1, 0, 0, 0, 2719, 2670, 1, 0, 0, 0, 2719, 2679, 1, 0, 0, 0, 2720, 203, 1, 0, 0, 0, 2721, 2726, 3, 206, 103, 0, 2722, 2723, 5, 4, 0, 0, 2723, 2725, 3, 206, 103, 0, 2724, 2722, 1, 0, 0, 0, 2725, 2728, 1, 0, 0, 0, 2726, 2724, 1, 0, 0, 0, 2726, 2727, 1, 0, 0, 0, 2727, 205, 1, 0, 0, 0, 2728, 2726, 1, 0, 0, 0, 2729, 2734, 3, 322, 161, 0, 2730, 2731, 5, 5, 0, 0, 2731, 2733, 3, 322, 161, 0, 2732, 2730, 1, 0, 0, 0, 2733, 2736, 1, 0, 0, 0, 2734, 2732, 1, 0, 0, 0, 2734, 2735, 1, 0, 0, 0, 2735, 207, 1, 0, 0, 0, 2736, 2734, 1, 0, 0, 0, 2737, 2742, 3, 210, 105, 0, 2738, 2739, 5, 4, 0, 0, 2739, 2741, 3, 210, 105, 0, 2740, 2738, 1, 0, 0, 0, 2741, 2744, 1, 0, 0, 0, 2742, 2740, 1, 0, 0, 0, 2742, 2743, 1, 0, 0, 0, 2743, 209, 1, 0, 0, 0, 2744, 2742, 1, 0, 0, 0, 2745, 2748, 3, 206, 103, 0, 2746, 2747, 5, 206, 0, 0, 2747, 2749, 3, 48, 24, 0, 2748, 2746, 1, 0, 0, 0, 2748, 2749, 1, 0, 0, 0, 2749, 211, 1, 0, 0, 0, 2750, 2751, 3, 322, 161, 0, 2751, 2752, 5, 5, 0, 0, 2752, 2754, 1, 0, 0, 0, 2753, 2750, 1, 0, 0, 0, 2753, 2754, 1, 0, 0, 0, 2754, 2755, 1, 0, 0, 0, 2755, 2756, 3, 322, 161, 0, 2756, 213, 1, 0, 0, 0, 2757, 2758, 3, 322, 161, 0, 2758, 2759, 5, 5, 0, 0, 2759, 2761, 1, 0, 0, 0, 2760, 2757, 1, 0, 0, 0, 2760, 2761, 1, 0, 0, 0, 2761, 2762, 1, 0, 0, 0, 2762, 2763, 3, 322, 161, 0, 2763, 215, 1, 0, 0, 0, 2764, 2767, 3, 82, 41, 0, 2765, 2767, 3, 228, 114, 0, 2766, 2764, 1, 0, 0, 0, 2766, 2765, 1, 0, 0, 0, 2767, 2775, 1, 0, 0, 0, 2768, 2770, 5, 20, 0, 0, 2769, 2768, 1, 0, 0, 0, 2769, 2770, 1, 0, 0, 0, 2770, 2773, 1, 0, 0, 0, 2771, 2774, 3, 322, 161, 0, 2772, 2774, 3, 176, 88, 0, 2773, 2771, 1, 0, 0, 0, 2773, 2772, 1, 0, 0, 0, 2774, 2776, 1, 0, 0, 0, 2775, 2769, 1, 0, 0, 0, 2775, 2776, 1, 0, 0, 0, 2776, 217, 1, 0, 0, 0, 2777, 2782, 3, 216, 108, 0, 2778, 2779, 5, 4, 0, 0, 2779, 2781, 3, 216, 108, 0, 2780, 2778, 1, 0, 0, 0, 2781, 2784, 1, 0, 0, 0, 2782, 2780, 1, 0, 0, 0, 2782, 2783, 1, 0, 0, 0, 2783, 219, 1, 0, 0, 0, 2784, 2782, 1, 0, 0, 0, 2785, 2786, 5, 2, 0, 0, 2786, 2791, 3, 222, 111, 0, 2787, 2788, 5, 4, 0, 0, 2788, 2790, 3, 222, 111, 0, 2789, 2787, 1, 0, 0, 0, 2790, 2793, 1, 0, 0, 0, 2791, 2789, 1, 0, 0, 0, 2791, 2792, 1, 0, 0, 0, 2792, 2794, 1, 0, 0, 0, 2793, 2791, 1, 0, 0, 0, 2794, 2795, 5, 3, 0, 0, 2795, 221, 1, 0, 0, 0, 2796, 2799, 3, 224, 112, 0, 2797, 2799, 3, 294, 147, 0, 2798, 2796, 1, 0, 0, 0, 2798, 2797, 1, 0, 0, 0, 2799, 223, 1, 0, 0, 0, 2800, 2814, 3, 320, 160, 0, 2801, 2802, 3, 326, 163, 0, 2802, 2803, 5, 2, 0, 0, 2803, 2808, 3, 226, 113, 0, 2804, 2805, 5, 4, 0, 0, 2805, 2807, 3, 226, 113, 0, 2806, 2804, 1, 0, 0, 0, 2807, 2810, 1, 0, 0, 0, 2808, 2806, 1, 0, 0, 0, 2808, 2809, 1, 0, 0, 0, 2809, 2811, 1, 0, 0, 0, 2810, 2808, 1, 0, 0, 0, 2811, 2812, 5, 3, 0, 0, 2812, 2814, 1, 0, 0, 0, 2813, 2800, 1, 0, 0, 0, 2813, 2801, 1, 0, 0, 0, 2814, 225, 1, 0, 0, 0, 2815, 2818, 3, 320, 160, 0, 2816, 2818, 3, 248, 124, 0, 2817, 2815, 1, 0, 0, 0, 2817, 2816, 1, 0, 0, 0, 2818, 227, 1, 0, 0, 0, 2819, 2820, 3, 236, 118, 0, 2820, 229, 1, 0, 0, 0, 2821, 2822, 3, 326, 163, 0, 2822, 2823, 5, 372, 0, 0, 2823, 2824, 3, 228, 114, 0, 2824, 231, 1, 0, 0, 0, 2825, 2828, 3, 228, 114, 0, 2826, 2828, 3, 230, 115, 0, 2827, 2825, 1, 0, 0, 0, 2827, 2826, 1, 0, 0, 0, 2828, 233, 1, 0, 0, 0, 2829, 2834, 3, 228, 114, 0, 2830, 2831, 5, 4, 0, 0, 2831, 2833, 3, 228, 114, 0, 2832, 2830, 1, 0, 0, 0, 2833, 2836, 1, 0, 0, 0, 2834, 2832, 1, 0, 0, 0, 2834, 2835, 1, 0, 0, 0, 2835, 235, 1, 0, 0, 0, 2836, 2834, 1, 0, 0, 0, 2837, 2838, 6, 118, -1, 0, 2838, 2839, 7, 37, 0, 0, 2839, 2850, 3, 236, 118, 5, 2840, 2841, 5, 105, 0, 0, 2841, 2842, 5, 2, 0, 0, 2842, 2843, 3, 24, 12, 0, 2843, 2844, 5, 3, 0, 0, 2844, 2850, 1, 0, 0, 0, 2845, 2847, 3, 240, 120, 0, 2846, 2848, 3, 238, 119, 0, 2847, 2846, 1, 0, 0, 0, 2847, 2848, 1, 0, 0, 0, 2848, 2850, 1, 0, 0, 0, 2849, 2837, 1, 0, 0, 0, 2849, 2840, 1, 0, 0, 0, 2849, 2845, 1, 0, 0, 0, 2850, 2859, 1, 0, 0, 0, 2851, 2852, 10, 2, 0, 0, 2852, 2853, 5, 14, 0, 0, 2853, 2858, 3, 236, 118, 3, 2854, 2855, 10, 1, 0, 0, 2855, 2856, 5, 207, 0, 0, 2856, 2858, 3, 236, 118, 2, 2857, 2851, 1, 0, 0, 0, 2857, 2854, 1, 0, 0, 0, 2858, 2861, 1, 0, 0, 0, 2859, 2857, 1, 0, 0, 0, 2859, 2860, 1, 0, 0, 0, 2860, 237, 1, 0, 0, 0, 2861, 2859, 1, 0, 0, 0, 2862, 2864, 5, 196, 0, 0, 2863, 2862, 1, 0, 0, 0, 2863, 2864, 1, 0, 0, 0, 2864, 2865, 1, 0, 0, 0, 2865, 2866, 5, 24, 0, 0, 2866, 2867, 3, 240, 120, 0, 2867, 2868, 5, 14, 0, 0, 2868, 2869, 3, 240, 120, 0, 2869, 2945, 1, 0, 0, 0, 2870, 2872, 5, 196, 0, 0, 2871, 2870, 1, 0, 0, 0, 2871, 2872, 1, 0, 0, 0, 2872, 2873, 1, 0, 0, 0, 2873, 2874, 5, 140, 0, 0, 2874, 2875, 5, 2, 0, 0, 2875, 2880, 3, 228, 114, 0, 2876, 2877, 5, 4, 0, 0, 2877, 2879, 3, 228, 114, 0, 2878, 2876, 1, 0, 0, 0, 2879, 2882, 1, 0, 0, 0, 2880, 2878, 1, 0, 0, 0, 2880, 2881, 1, 0, 0, 0, 2881, 2883, 1, 0, 0, 0, 2882, 2880, 1, 0, 0, 0, 2883, 2884, 5, 3, 0, 0, 2884, 2945, 1, 0, 0, 0, 2885, 2887, 5, 196, 0, 0, 2886, 2885, 1, 0, 0, 0, 2886, 2887, 1, 0, 0, 0, 2887, 2888, 1, 0, 0, 0, 2888, 2889, 5, 140, 0, 0, 2889, 2890, 5, 2, 0, 0, 2890, 2891, 3, 24, 12, 0, 2891, 2892, 5, 3, 0, 0, 2892, 2945, 1, 0, 0, 0, 2893, 2895, 5, 196, 0, 0, 2894, 2893, 1, 0, 0, 0, 2894, 2895, 1, 0, 0, 0, 2895, 2896, 1, 0, 0, 0, 2896, 2897, 7, 38, 0, 0, 2897, 2945, 3, 240, 120, 0, 2898, 2900, 5, 196, 0, 0, 2899, 2898, 1, 0, 0, 0, 2899, 2900, 1, 0, 0, 0, 2900, 2901, 1, 0, 0, 0, 2901, 2902, 7, 39, 0, 0, 2902, 2916, 7, 40, 0, 0, 2903, 2904, 5, 2, 0, 0, 2904, 2917, 5, 3, 0, 0, 2905, 2906, 5, 2, 0, 0, 2906, 2911, 3, 228, 114, 0, 2907, 2908, 5, 4, 0, 0, 2908, 2910, 3, 228, 114, 0, 2909, 2907, 1, 0, 0, 0, 2910, 2913, 1, 0, 0, 0, 2911, 2909, 1, 0, 0, 0, 2911, 2912, 1, 0, 0, 0, 2912, 2914, 1, 0, 0, 0, 2913, 2911, 1, 0, 0, 0, 2914, 2915, 5, 3, 0, 0, 2915, 2917, 1, 0, 0, 0, 2916, 2903, 1, 0, 0, 0, 2916, 2905, 1, 0, 0, 0, 2917, 2945, 1, 0, 0, 0, 2918, 2920, 5, 196, 0, 0, 2919, 2918, 1, 0, 0, 0, 2919, 2920, 1, 0, 0, 0, 2920, 2921, 1, 0, 0, 0, 2921, 2922, 7, 39, 0, 0, 2922, 2925, 3, 240, 120, 0, 2923, 2924, 5, 100, 0, 0, 2924, 2926, 3, 334, 167, 0, 2925, 2923, 1, 0, 0, 0, 2925, 2926, 1, 0, 0, 0, 2926, 2945, 1, 0, 0, 0, 2927, 2929, 5, 153, 0, 0, 2928, 2930, 5, 196, 0, 0, 2929, 2928, 1, 0, 0, 0, 2929, 2930, 1, 0, 0, 0, 2930, 2931, 1, 0, 0, 0, 2931, 2945, 5, 197, 0, 0, 2932, 2934, 5, 153, 0, 0, 2933, 2935, 5, 196, 0, 0, 2934, 2933, 1, 0, 0, 0, 2934, 2935, 1, 0, 0, 0, 2935, 2936, 1, 0, 0, 0, 2936, 2945, 7, 41, 0, 0, 2937, 2939, 5, 153, 0, 0, 2938, 2940, 5, 196, 0, 0, 2939, 2938, 1, 0, 0, 0, 2939, 2940, 1, 0, 0, 0, 2940, 2941, 1, 0, 0, 0, 2941, 2942, 5, 92, 0, 0, 2942, 2943, 5, 123, 0, 0, 2943, 2945, 3, 240, 120, 0, 2944, 2863, 1, 0, 0, 0, 2944, 2871, 1, 0, 0, 0, 2944, 2886, 1, 0, 0, 0, 2944, 2894, 1, 0, 0, 0, 2944, 2899, 1, 0, 0, 0, 2944, 2919, 1, 0, 0, 0, 2944, 2927, 1, 0, 0, 0, 2944, 2932, 1, 0, 0, 0, 2944, 2937, 1, 0, 0, 0, 2945, 239, 1, 0, 0, 0, 2946, 2947, 6, 120, -1, 0, 2947, 2951, 3, 244, 122, 0, 2948, 2949, 7, 42, 0, 0, 2949, 2951, 3, 240, 120, 7, 2950, 2946, 1, 0, 0, 0, 2950, 2948, 1, 0, 0, 0, 2951, 2973, 1, 0, 0, 0, 2952, 2953, 10, 6, 0, 0, 2953, 2954, 7, 43, 0, 0, 2954, 2972, 3, 240, 120, 7, 2955, 2956, 10, 5, 0, 0, 2956, 2957, 7, 44, 0, 0, 2957, 2972, 3, 240, 120, 6, 2958, 2959, 10, 4, 0, 0, 2959, 2960, 5, 366, 0, 0, 2960, 2972, 3, 240, 120, 5, 2961, 2962, 10, 3, 0, 0, 2962, 2963, 5, 369, 0, 0, 2963, 2972, 3, 240, 120, 4, 2964, 2965, 10, 2, 0, 0, 2965, 2966, 5, 367, 0, 0, 2966, 2972, 3, 240, 120, 3, 2967, 2968, 10, 1, 0, 0, 2968, 2969, 3, 250, 125, 0, 2969, 2970, 3, 240, 120, 2, 2970, 2972, 1, 0, 0, 0, 2971, 2952, 1, 0, 0, 0, 2971, 2955, 1, 0, 0, 0, 2971, 2958, 1, 0, 0, 0, 2971, 2961, 1, 0, 0, 0, 2971, 2964, 1, 0, 0, 0, 2971, 2967, 1, 0, 0, 0, 2972, 2975, 1, 0, 0, 0, 2973, 2971, 1, 0, 0, 0, 2973, 2974, 1, 0, 0, 0, 2974, 241, 1, 0, 0, 0, 2975, 2973, 1, 0, 0, 0, 2976, 2977, 7, 45, 0, 0, 2977, 243, 1, 0, 0, 0, 2978, 2979, 6, 122, -1, 0, 2979, 3228, 7, 46, 0, 0, 2980, 2981, 7, 47, 0, 0, 2981, 2984, 5, 2, 0, 0, 2982, 2985, 3, 242, 121, 0, 2983, 2985, 3, 334, 167, 0, 2984, 2982, 1, 0, 0, 0, 2984, 2983, 1, 0, 0, 0, 2985, 2986, 1, 0, 0, 0, 2986, 2987, 5, 4, 0, 0, 2987, 2988, 3, 240, 120, 0, 2988, 2989, 5, 4, 0, 0, 2989, 2990, 3, 240, 120, 0, 2990, 2991, 5, 3, 0, 0, 2991, 3228, 1, 0, 0, 0, 2992, 2993, 7, 48, 0, 0, 2993, 2996, 5, 2, 0, 0, 2994, 2997, 3, 242, 121, 0, 2995, 2997, 3, 334, 167, 0, 2996, 2994, 1, 0, 0, 0, 2996, 2995, 1, 0, 0, 0, 2997, 2998, 1, 0, 0, 0, 2998, 2999, 5, 4, 0, 0, 2999, 3000, 3, 240, 120, 0, 3000, 3001, 5, 4, 0, 0, 3001, 3002, 3, 240, 120, 0, 3002, 3003, 5, 3, 0, 0, 3003, 3228, 1, 0, 0, 0, 3004, 3006, 5, 35, 0, 0, 3005, 3007, 3, 304, 152, 0, 3006, 3005, 1, 0, 0, 0, 3007, 3008, 1, 0, 0, 0, 3008, 3006, 1, 0, 0, 0, 3008, 3009, 1, 0, 0, 0, 3009, 3012, 1, 0, 0, 0, 3010, 3011, 5, 97, 0, 0, 3011, 3013, 3, 228, 114, 0, 3012, 3010, 1, 0, 0, 0, 3012, 3013, 1, 0, 0, 0, 3013, 3014, 1, 0, 0, 0, 3014, 3015, 5, 99, 0, 0, 3015, 3228, 1, 0, 0, 0, 3016, 3017, 5, 35, 0, 0, 3017, 3019, 3, 228, 114, 0, 3018, 3020, 3, 304, 152, 0, 3019, 3018, 1, 0, 0, 0, 3020, 3021, 1, 0, 0, 0, 3021, 3019, 1, 0, 0, 0, 3021, 3022, 1, 0, 0, 0, 3022, 3025, 1, 0, 0, 0, 3023, 3024, 5, 97, 0, 0, 3024, 3026, 3, 228, 114, 0, 3025, 3023, 1, 0, 0, 0, 3025, 3026, 1, 0, 0, 0, 3026, 3027, 1, 0, 0, 0, 3027, 3028, 5, 99, 0, 0, 3028, 3228, 1, 0, 0, 0, 3029, 3030, 7, 49, 0, 0, 3030, 3031, 5, 2, 0, 0, 3031, 3032, 3, 228, 114, 0, 3032, 3033, 5, 20, 0, 0, 3033, 3034, 3, 278, 139, 0, 3034, 3035, 5, 3, 0, 0, 3035, 3228, 1, 0, 0, 0, 3036, 3037, 5, 285, 0, 0, 3037, 3046, 5, 2, 0, 0, 3038, 3043, 3, 216, 108, 0, 3039, 3040, 5, 4, 0, 0, 3040, 3042, 3, 216, 108, 0, 3041, 3039, 1, 0, 0, 0, 3042, 3045, 1, 0, 0, 0, 3043, 3041, 1, 0, 0, 0, 3043, 3044, 1, 0, 0, 0, 3044, 3047, 1, 0, 0, 0, 3045, 3043, 1, 0, 0, 0, 3046, 3038, 1, 0, 0, 0, 3046, 3047, 1, 0, 0, 0, 3047, 3048, 1, 0, 0, 0, 3048, 3228, 5, 3, 0, 0, 3049, 3050, 5, 116, 0, 0, 3050, 3051, 5, 2, 0, 0, 3051, 3054, 3, 228, 114, 0, 3052, 3053, 5, 138, 0, 0, 3053, 3055, 5, 198, 0, 0, 3054, 3052, 1, 0, 0, 0, 3054, 3055, 1, 0, 0, 0, 3055, 3056, 1, 0, 0, 0, 3056, 3057, 5, 3, 0, 0, 3057, 3228, 1, 0, 0, 0, 3058, 3059, 5, 17, 0, 0, 3059, 3060, 5, 2, 0, 0, 3060, 3063, 3, 228, 114, 0, 3061, 3062, 5, 138, 0, 0, 3062, 3064, 5, 198, 0, 0, 3063, 3061, 1, 0, 0, 0, 3063, 3064, 1, 0, 0, 0, 3064, 3065, 1, 0, 0, 0, 3065, 3066, 5, 3, 0, 0, 3066, 3228, 1, 0, 0, 0, 3067, 3068, 5, 157, 0, 0, 3068, 3069, 5, 2, 0, 0, 3069, 3072, 3, 228, 114, 0, 3070, 3071, 5, 138, 0, 0, 3071, 3073, 5, 198, 0, 0, 3072, 3070, 1, 0, 0, 0, 3072, 3073, 1, 0, 0, 0, 3073, 3074, 1, 0, 0, 0, 3074, 3075, 5, 3, 0, 0, 3075, 3228, 1, 0, 0, 0, 3076, 3077, 5, 224, 0, 0, 3077, 3078, 5, 2, 0, 0, 3078, 3079, 3, 240, 120, 0, 3079, 3080, 5, 140, 0, 0, 3080, 3081, 3, 240, 120, 0, 3081, 3082, 5, 3, 0, 0, 3082, 3228, 1, 0, 0, 0, 3083, 3228, 3, 248, 124, 0, 3084, 3228, 5, 362, 0, 0, 3085, 3086, 3, 320, 160, 0, 3086, 3087, 5, 5, 0, 0, 3087, 3088, 5, 362, 0, 0, 3088, 3228, 1, 0, 0, 0, 3089, 3090, 5, 2, 0, 0, 3090, 3093, 3, 216, 108, 0, 3091, 3092, 5, 4, 0, 0, 3092, 3094, 3, 216, 108, 0, 3093, 3091, 1, 0, 0, 0, 3094, 3095, 1, 0, 0, 0, 3095, 3093, 1, 0, 0, 0, 3095, 3096, 1, 0, 0, 0, 3096, 3097, 1, 0, 0, 0, 3097, 3098, 5, 3, 0, 0, 3098, 3228, 1, 0, 0, 0, 3099, 3100, 5, 2, 0, 0, 3100, 3101, 3, 24, 12, 0, 3101, 3102, 5, 3, 0, 0, 3102, 3228, 1, 0, 0, 0, 3103, 3104, 5, 136, 0, 0, 3104, 3105, 5, 2, 0, 0, 3105, 3106, 3, 228, 114, 0, 3106, 3107, 5, 3, 0, 0, 3107, 3228, 1, 0, 0, 0, 3108, 3109, 3, 316, 158, 0, 3109, 3121, 5, 2, 0, 0, 3110, 3112, 3, 162, 81, 0, 3111, 3110, 1, 0, 0, 0, 3111, 3112, 1, 0, 0, 0, 3112, 3113, 1, 0, 0, 0, 3113, 3118, 3, 232, 116, 0, 3114, 3115, 5, 4, 0, 0, 3115, 3117, 3, 232, 116, 0, 3116, 3114, 1, 0, 0, 0, 3117, 3120, 1, 0, 0, 0, 3118, 3116, 1, 0, 0, 0, 3118, 3119, 1, 0, 0, 0, 3119, 3122, 1, 0, 0, 0, 3120, 3118, 1, 0, 0, 0, 3121, 3111, 1, 0, 0, 0, 3121, 3122, 1, 0, 0, 0, 3122, 3123, 1, 0, 0, 0, 3123, 3130, 5, 3, 0, 0, 3124, 3125, 5, 114, 0, 0, 3125, 3126, 5, 2, 0, 0, 3126, 3127, 5, 343, 0, 0, 3127, 3128, 3, 236, 118, 0, 3128, 3129, 5, 3, 0, 0, 3129, 3131, 1, 0, 0, 0, 3130, 3124, 1, 0, 0, 0, 3130, 3131, 1, 0, 0, 0, 3131, 3134, 1, 0, 0, 0, 3132, 3133, 7, 50, 0, 0, 3133, 3135, 5, 198, 0, 0, 3134, 3132, 1, 0, 0, 0, 3134, 3135, 1, 0, 0, 0, 3135, 3138, 1, 0, 0, 0, 3136, 3137, 5, 212, 0, 0, 3137, 3139, 3, 308, 154, 0, 3138, 3136, 1, 0, 0, 0, 3138, 3139, 1, 0, 0, 0, 3139, 3228, 1, 0, 0, 0, 3140, 3141, 3, 326, 163, 0, 3141, 3142, 5, 371, 0, 0, 3142, 3143, 3, 228, 114, 0, 3143, 3228, 1, 0, 0, 0, 3144, 3145, 5, 2, 0, 0, 3145, 3148, 3, 326, 163, 0, 3146, 3147, 5, 4, 0, 0, 3147, 3149, 3, 326, 163, 0, 3148, 3146, 1, 0, 0, 0, 3149, 3150, 1, 0, 0, 0, 3150, 3148, 1, 0, 0, 0, 3150, 3151, 1, 0, 0, 0, 3151, 3152, 1, 0, 0, 0, 3152, 3153, 5, 3, 0, 0, 3153, 3154, 5, 371, 0, 0, 3154, 3155, 3, 228, 114, 0, 3155, 3228, 1, 0, 0, 0, 3156, 3228, 3, 326, 163, 0, 3157, 3158, 5, 2, 0, 0, 3158, 3159, 3, 228, 114, 0, 3159, 3160, 5, 3, 0, 0, 3160, 3228, 1, 0, 0, 0, 3161, 3162, 5, 110, 0, 0, 3162, 3163, 5, 2, 0, 0, 3163, 3164, 3, 326, 163, 0, 3164, 3165, 5, 123, 0, 0, 3165, 3166, 3, 240, 120, 0, 3166, 3167, 5, 3, 0, 0, 3167, 3228, 1, 0, 0, 0, 3168, 3169, 7, 51, 0, 0, 3169, 3170, 5, 2, 0, 0, 3170, 3171, 3, 240, 120, 0, 3171, 3172, 7, 52, 0, 0, 3172, 3175, 3, 240, 120, 0, 3173, 3174, 7, 53, 0, 0, 3174, 3176, 3, 240, 120, 0, 3175, 3173, 1, 0, 0, 0, 3175, 3176, 1, 0, 0, 0, 3176, 3177, 1, 0, 0, 0, 3177, 3178, 5, 3, 0, 0, 3178, 3228, 1, 0, 0, 0, 3179, 3180, 5, 314, 0, 0, 3180, 3182, 5, 2, 0, 0, 3181, 3183, 7, 54, 0, 0, 3182, 3181, 1, 0, 0, 0, 3182, 3183, 1, 0, 0, 0, 3183, 3185, 1, 0, 0, 0, 3184, 3186, 3, 240, 120, 0, 3185, 3184, 1, 0, 0, 0, 3185, 3186, 1, 0, 0, 0, 3186, 3187, 1, 0, 0, 0, 3187, 3188, 5, 123, 0, 0, 3188, 3189, 3, 240, 120, 0, 3189, 3190, 5, 3, 0, 0, 3190, 3228, 1, 0, 0, 0, 3191, 3192, 5, 214, 0, 0, 3192, 3193, 5, 2, 0, 0, 3193, 3194, 3, 240, 120, 0, 3194, 3195, 5, 223, 0, 0, 3195, 3196, 3, 240, 120, 0, 3196, 3197, 5, 123, 0, 0, 3197, 3200, 3, 240, 120, 0, 3198, 3199, 5, 119, 0, 0, 3199, 3201, 3, 240, 120, 0, 3200, 3198, 1, 0, 0, 0, 3200, 3201, 1, 0, 0, 0, 3201, 3202, 1, 0, 0, 0, 3202, 3203, 5, 3, 0, 0, 3203, 3228, 1, 0, 0, 0, 3204, 3205, 7, 55, 0, 0, 3205, 3206, 5, 2, 0, 0, 3206, 3207, 3, 240, 120, 0, 3207, 3208, 5, 3, 0, 0, 3208, 3209, 5, 346, 0, 0, 3209, 3210, 5, 130, 0, 0, 3210, 3211, 5, 2, 0, 0, 3211, 3212, 5, 208, 0, 0, 3212, 3213, 5, 31, 0, 0, 3213, 3214, 3, 96, 48, 0, 3214, 3221, 5, 3, 0, 0, 3215, 3216, 5, 114, 0, 0, 3216, 3217, 5, 2, 0, 0, 3217, 3218, 5, 343, 0, 0, 3218, 3219, 3, 236, 118, 0, 3219, 3220, 5, 3, 0, 0, 3220, 3222, 1, 0, 0, 0, 3221, 3215, 1, 0, 0, 0, 3221, 3222, 1, 0, 0, 0, 3222, 3225, 1, 0, 0, 0, 3223, 3224, 5, 212, 0, 0, 3224, 3226, 3, 308, 154, 0, 3225, 3223, 1, 0, 0, 0, 3225, 3226, 1, 0, 0, 0, 3226, 3228, 1, 0, 0, 0, 3227, 2978, 1, 0, 0, 0, 3227, 2980, 1, 0, 0, 0, 3227, 2992, 1, 0, 0, 0, 3227, 3004, 1, 0, 0, 0, 3227, 3016, 1, 0, 0, 0, 3227, 3029, 1, 0, 0, 0, 3227, 3036, 1, 0, 0, 0, 3227, 3049, 1, 0, 0, 0, 3227, 3058, 1, 0, 0, 0, 3227, 3067, 1, 0, 0, 0, 3227, 3076, 1, 0, 0, 0, 3227, 3083, 1, 0, 0, 0, 3227, 3084, 1, 0, 0, 0, 3227, 3085, 1, 0, 0, 0, 3227, 3089, 1, 0, 0, 0, 3227, 3099, 1, 0, 0, 0, 3227, 3103, 1, 0, 0, 0, 3227, 3108, 1, 0, 0, 0, 3227, 3140, 1, 0, 0, 0, 3227, 3144, 1, 0, 0, 0, 3227, 3156, 1, 0, 0, 0, 3227, 3157, 1, 0, 0, 0, 3227, 3161, 1, 0, 0, 0, 3227, 3168, 1, 0, 0, 0, 3227, 3179, 1, 0, 0, 0, 3227, 3191, 1, 0, 0, 0, 3227, 3204, 1, 0, 0, 0, 3228, 3239, 1, 0, 0, 0, 3229, 3230, 10, 9, 0, 0, 3230, 3231, 5, 6, 0, 0, 3231, 3232, 3, 240, 120, 0, 3232, 3233, 5, 7, 0, 0, 3233, 3238, 1, 0, 0, 0, 3234, 3235, 10, 7, 0, 0, 3235, 3236, 5, 5, 0, 0, 3236, 3238, 3, 326, 163, 0, 3237, 3229, 1, 0, 0, 0, 3237, 3234, 1, 0, 0, 0, 3238, 3241, 1, 0, 0, 0, 3239, 3237, 1, 0, 0, 0, 3239, 3240, 1, 0, 0, 0, 3240, 245, 1, 0, 0, 0, 3241, 3239, 1, 0, 0, 0, 3242, 3250, 5, 71, 0, 0, 3243, 3250, 5, 302, 0, 0, 3244, 3250, 5, 303, 0, 0, 3245, 3250, 5, 304, 0, 0, 3246, 3250, 5, 149, 0, 0, 3247, 3250, 5, 133, 0, 0, 3248, 3250, 3, 326, 163, 0, 3249, 3242, 1, 0, 0, 0, 3249, 3243, 1, 0, 0, 0, 3249, 3244, 1, 0, 0, 0, 3249, 3245, 1, 0, 0, 0, 3249, 3246, 1, 0, 0, 0, 3249, 3247, 1, 0, 0, 0, 3249, 3248, 1, 0, 0, 0, 3250, 247, 1, 0, 0, 0, 3251, 3267, 5, 197, 0, 0, 3252, 3267, 5, 375, 0, 0, 3253, 3254, 5, 370, 0, 0, 3254, 3267, 3, 326, 163, 0, 3255, 3267, 3, 258, 129, 0, 3256, 3257, 3, 246, 123, 0, 3257, 3258, 3, 334, 167, 0, 3258, 3267, 1, 0, 0, 0, 3259, 3267, 3, 330, 165, 0, 3260, 3267, 3, 256, 128, 0, 3261, 3263, 3, 334, 167, 0, 3262, 3261, 1, 0, 0, 0, 3263, 3264, 1, 0, 0, 0, 3264, 3262, 1, 0, 0, 0, 3264, 3265, 1, 0, 0, 0, 3265, 3267, 1, 0, 0, 0, 3266, 3251, 1, 0, 0, 0, 3266, 3252, 1, 0, 0, 0, 3266, 3253, 1, 0, 0, 0, 3266, 3255, 1, 0, 0, 0, 3266, 3256, 1, 0, 0, 0, 3266, 3259, 1, 0, 0, 0, 3266, 3260, 1, 0, 0, 0, 3266, 3262, 1, 0, 0, 0, 3267, 249, 1, 0, 0, 0, 3268, 3269, 7, 56, 0, 0, 3269, 251, 1, 0, 0, 0, 3270, 3271, 7, 57, 0, 0, 3271, 253, 1, 0, 0, 0, 3272, 3273, 7, 58, 0, 0, 3273, 255, 1, 0, 0, 0, 3274, 3275, 7, 59, 0, 0, 3275, 257, 1, 0, 0, 0, 3276, 3279, 5, 149, 0, 0, 3277, 3280, 3, 260, 130, 0, 3278, 3280, 3, 262, 131, 0, 3279, 3277, 1, 0, 0, 0, 3279, 3278, 1, 0, 0, 0, 3280, 259, 1, 0, 0, 0, 3281, 3283, 3, 264, 132, 0, 3282, 3284, 3, 266, 133, 0, 3283, 3282, 1, 0, 0, 0, 3283, 3284, 1, 0, 0, 0, 3284, 261, 1, 0, 0, 0, 3285, 3288, 3, 266, 133, 0, 3286, 3289, 3, 264, 132, 0, 3287, 3289, 3, 266, 133, 0, 3288, 3286, 1, 0, 0, 0, 3288, 3287, 1, 0, 0, 0, 3288, 3289, 1, 0, 0, 0, 3289, 263, 1, 0, 0, 0, 3290, 3291, 3, 268, 134, 0, 3291, 3292, 3, 270, 135, 0, 3292, 3294, 1, 0, 0, 0, 3293, 3290, 1, 0, 0, 0, 3294, 3295, 1, 0, 0, 0, 3295, 3293, 1, 0, 0, 0, 3295, 3296, 1, 0, 0, 0, 3296, 265, 1, 0, 0, 0, 3297, 3298, 3, 268, 134, 0, 3298, 3299, 3, 272, 136, 0, 3299, 3300, 5, 308, 0, 0, 3300, 3301, 3, 272, 136, 0, 3301, 267, 1, 0, 0, 0, 3302, 3304, 7, 60, 0, 0, 3303, 3302, 1, 0, 0, 0, 3303, 3304, 1, 0, 0, 0, 3304, 3308, 1, 0, 0, 0, 3305, 3309, 5, 381, 0, 0, 3306, 3309, 5, 383, 0, 0, 3307, 3309, 3, 334, 167, 0, 3308, 3305, 1, 0, 0, 0, 3308, 3306, 1, 0, 0, 0, 3308, 3307, 1, 0, 0, 0, 3309, 269, 1, 0, 0, 0, 3310, 3311, 7, 61, 0, 0, 3311, 271, 1, 0, 0, 0, 3312, 3313, 7, 62, 0, 0, 3313, 273, 1, 0, 0, 0, 3314, 3318, 5, 116, 0, 0, 3315, 3316, 5, 9, 0, 0, 3316, 3318, 3, 322, 161, 0, 3317, 3314, 1, 0, 0, 0, 3317, 3315, 1, 0, 0, 0, 3318, 275, 1, 0, 0, 0, 3319, 3350, 5, 27, 0, 0, 3320, 3350, 5, 307, 0, 0, 3321, 3350, 5, 32, 0, 0, 3322, 3350, 5, 275, 0, 0, 3323, 3350, 5, 271, 0, 0, 3324, 3350, 5, 150, 0, 0, 3325, 3350, 5, 151, 0, 0, 3326, 3350, 5, 25, 0, 0, 3327, 3350, 5, 174, 0, 0, 3328, 3350, 5, 117, 0, 0, 3329, 3350, 5, 233, 0, 0, 3330, 3350, 5, 95, 0, 0, 3331, 3350, 5, 71, 0, 0, 3332, 3350, 5, 302, 0, 0, 3333, 3350, 5, 304, 0, 0, 3334, 3350, 5, 303, 0, 0, 3335, 3350, 5, 284, 0, 0, 3336, 3350, 5, 41, 0, 0, 3337, 3350, 5, 40, 0, 0, 3338, 3350, 5, 333, 0, 0, 3339, 3350, 5, 26, 0, 0, 3340, 3350, 5, 80, 0, 0, 3341, 3350, 5, 79, 0, 0, 3342, 3350, 5, 199, 0, 0, 3343, 3350, 5, 339, 0, 0, 3344, 3350, 5, 149, 0, 0, 3345, 3350, 5, 19, 0, 0, 3346, 3350, 5, 285, 0, 0, 3347, 3350, 5, 176, 0, 0, 3348, 3350, 3, 326, 163, 0, 3349, 3319, 1, 0, 0, 0, 3349, 3320, 1, 0, 0, 0, 3349, 3321, 1, 0, 0, 0, 3349, 3322, 1, 0, 0, 0, 3349, 3323, 1, 0, 0, 0, 3349, 3324, 1, 0, 0, 0, 3349, 3325, 1, 0, 0, 0, 3349, 3326, 1, 0, 0, 0, 3349, 3327, 1, 0, 0, 0, 3349, 3328, 1, 0, 0, 0, 3349, 3329, 1, 0, 0, 0, 3349, 3330, 1, 0, 0, 0, 3349, 3331, 1, 0, 0, 0, 3349, 3332, 1, 0, 0, 0, 3349, 3333, 1, 0, 0, 0, 3349, 3334, 1, 0, 0, 0, 3349, 3335, 1, 0, 0, 0, 3349, 3336, 1, 0, 0, 0, 3349, 3337, 1, 0, 0, 0, 3349, 3338, 1, 0, 0, 0, 3349, 3339, 1, 0, 0, 0, 3349, 3340, 1, 0, 0, 0, 3349, 3341, 1, 0, 0, 0, 3349, 3342, 1, 0, 0, 0, 3349, 3343, 1, 0, 0, 0, 3349, 3344, 1, 0, 0, 0, 3349, 3345, 1, 0, 0, 0, 3349, 3346, 1, 0, 0, 0, 3349, 3347, 1, 0, 0, 0, 3349, 3348, 1, 0, 0, 0, 3350, 277, 1, 0, 0, 0, 3351, 3352, 5, 19, 0, 0, 3352, 3353, 5, 355, 0, 0, 3353, 3354, 3, 278, 139, 0, 3354, 3355, 5, 357, 0, 0, 3355, 3405, 1, 0, 0, 0, 3356, 3357, 5, 176, 0, 0, 3357, 3358, 5, 355, 0, 0, 3358, 3359, 3, 278, 139, 0, 3359, 3360, 5, 4, 0, 0, 3360, 3361, 3, 278, 139, 0, 3361, 3362, 5, 357, 0, 0, 3362, 3405, 1, 0, 0, 0, 3363, 3377, 5, 285, 0, 0, 3364, 3373, 5, 355, 0, 0, 3365, 3370, 3, 302, 151, 0, 3366, 3367, 5, 4, 0, 0, 3367, 3369, 3, 302, 151, 0, 3368, 3366, 1, 0, 0, 0, 3369, 3372, 1, 0, 0, 0, 3370, 3368, 1, 0, 0, 0, 3370, 3371, 1, 0, 0, 0, 3371, 3374, 1, 0, 0, 0, 3372, 3370, 1, 0, 0, 0, 3373, 3365, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 3375, 1, 0, 0, 0, 3375, 3378, 5, 357, 0, 0, 3376, 3378, 5, 353, 0, 0, 3377, 3364, 1, 0, 0, 0, 3377, 3376, 1, 0, 0, 0, 3378, 3405, 1, 0, 0, 0, 3379, 3380, 5, 149, 0, 0, 3380, 3383, 7, 63, 0, 0, 3381, 3382, 5, 308, 0, 0, 3382, 3384, 5, 185, 0, 0, 3383, 3381, 1, 0, 0, 0, 3383, 3384, 1, 0, 0, 0, 3384, 3405, 1, 0, 0, 0, 3385, 3386, 5, 149, 0, 0, 3386, 3389, 7, 64, 0, 0, 3387, 3388, 5, 308, 0, 0, 3388, 3390, 7, 65, 0, 0, 3389, 3387, 1, 0, 0, 0, 3389, 3390, 1, 0, 0, 0, 3390, 3405, 1, 0, 0, 0, 3391, 3402, 3, 276, 138, 0, 3392, 3393, 5, 2, 0, 0, 3393, 3398, 5, 381, 0, 0, 3394, 3395, 5, 4, 0, 0, 3395, 3397, 5, 381, 0, 0, 3396, 3394, 1, 0, 0, 0, 3397, 3400, 1, 0, 0, 0, 3398, 3396, 1, 0, 0, 0, 3398, 3399, 1, 0, 0, 0, 3399, 3401, 1, 0, 0, 0, 3400, 3398, 1, 0, 0, 0, 3401, 3403, 5, 3, 0, 0, 3402, 3392, 1, 0, 0, 0, 3402, 3403, 1, 0, 0, 0, 3403, 3405, 1, 0, 0, 0, 3404, 3351, 1, 0, 0, 0, 3404, 3356, 1, 0, 0, 0, 3404, 3363, 1, 0, 0, 0, 3404, 3379, 1, 0, 0, 0, 3404, 3385, 1, 0, 0, 0, 3404, 3391, 1, 0, 0, 0, 3405, 279, 1, 0, 0, 0, 3406, 3411, 3, 282, 141, 0, 3407, 3408, 5, 4, 0, 0, 3408, 3410, 3, 282, 141, 0, 3409, 3407, 1, 0, 0, 0, 3410, 3413, 1, 0, 0, 0, 3411, 3409, 1, 0, 0, 0, 3411, 3412, 1, 0, 0, 0, 3412, 281, 1, 0, 0, 0, 3413, 3411, 1, 0, 0, 0, 3414, 3415, 3, 86, 43, 0, 3415, 3419, 3, 278, 139, 0, 3416, 3418, 3, 288, 144, 0, 3417, 3416, 1, 0, 0, 0, 3418, 3421, 1, 0, 0, 0, 3419, 3417, 1, 0, 0, 0, 3419, 3420, 1, 0, 0, 0, 3420, 283, 1, 0, 0, 0, 3421, 3419, 1, 0, 0, 0, 3422, 3427, 3, 286, 143, 0, 3423, 3424, 5, 4, 0, 0, 3424, 3426, 3, 286, 143, 0, 3425, 3423, 1, 0, 0, 0, 3426, 3429, 1, 0, 0, 0, 3427, 3425, 1, 0, 0, 0, 3427, 3428, 1, 0, 0, 0, 3428, 285, 1, 0, 0, 0, 3429, 3427, 1, 0, 0, 0, 3430, 3431, 3, 82, 41, 0, 3431, 3435, 3, 278, 139, 0, 3432, 3434, 3, 288, 144, 0, 3433, 3432, 1, 0, 0, 0, 3434, 3437, 1, 0, 0, 0, 3435, 3433, 1, 0, 0, 0, 3435, 3436, 1, 0, 0, 0, 3436, 287, 1, 0, 0, 0, 3437, 3435, 1, 0, 0, 0, 3438, 3439, 5, 196, 0, 0, 3439, 3446, 5, 197, 0, 0, 3440, 3441, 5, 82, 0, 0, 3441, 3446, 3, 228, 114, 0, 3442, 3443, 5, 51, 0, 0, 3443, 3446, 3, 334, 167, 0, 3444, 3446, 3, 274, 137, 0, 3445, 3438, 1, 0, 0, 0, 3445, 3440, 1, 0, 0, 0, 3445, 3442, 1, 0, 0, 0, 3445, 3444, 1, 0, 0, 0, 3446, 289, 1, 0, 0, 0, 3447, 3448, 7, 66, 0, 0, 3448, 3449, 3, 228, 114, 0, 3449, 291, 1, 0, 0, 0, 3450, 3455, 3, 294, 147, 0, 3451, 3452, 5, 4, 0, 0, 3452, 3454, 3, 294, 147, 0, 3453, 3451, 1, 0, 0, 0, 3454, 3457, 1, 0, 0, 0, 3455, 3453, 1, 0, 0, 0, 3455, 3456, 1, 0, 0, 0, 3456, 293, 1, 0, 0, 0, 3457, 3455, 1, 0, 0, 0, 3458, 3459, 3, 322, 161, 0, 3459, 3462, 3, 278, 139, 0, 3460, 3461, 5, 196, 0, 0, 3461, 3463, 5, 197, 0, 0, 3462, 3460, 1, 0, 0, 0, 3462, 3463, 1, 0, 0, 0, 3463, 3466, 1, 0, 0, 0, 3464, 3465, 5, 51, 0, 0, 3465, 3467, 3, 334, 167, 0, 3466, 3464, 1, 0, 0, 0, 3466, 3467, 1, 0, 0, 0, 3467, 295, 1, 0, 0, 0, 3468, 3473, 3, 298, 149, 0, 3469, 3470, 5, 4, 0, 0, 3470, 3472, 3, 298, 149, 0, 3471, 3469, 1, 0, 0, 0, 3472, 3475, 1, 0, 0, 0, 3473, 3471, 1, 0, 0, 0, 3473, 3474, 1, 0, 0, 0, 3474, 297, 1, 0, 0, 0, 3475, 3473, 1, 0, 0, 0, 3476, 3477, 3, 86, 43, 0, 3477, 3481, 3, 278, 139, 0, 3478, 3480, 3, 300, 150, 0, 3479, 3478, 1, 0, 0, 0, 3480, 3483, 1, 0, 0, 0, 3481, 3479, 1, 0, 0, 0, 3481, 3482, 1, 0, 0, 0, 3482, 299, 1, 0, 0, 0, 3483, 3481, 1, 0, 0, 0, 3484, 3485, 5, 196, 0, 0, 3485, 3498, 5, 197, 0, 0, 3486, 3487, 5, 82, 0, 0, 3487, 3498, 3, 228, 114, 0, 3488, 3489, 5, 127, 0, 0, 3489, 3490, 5, 12, 0, 0, 3490, 3491, 5, 20, 0, 0, 3491, 3492, 5, 2, 0, 0, 3492, 3493, 3, 228, 114, 0, 3493, 3494, 5, 3, 0, 0, 3494, 3498, 1, 0, 0, 0, 3495, 3496, 5, 51, 0, 0, 3496, 3498, 3, 334, 167, 0, 3497, 3484, 1, 0, 0, 0, 3497, 3486, 1, 0, 0, 0, 3497, 3488, 1, 0, 0, 0, 3497, 3495, 1, 0, 0, 0, 3498, 301, 1, 0, 0, 0, 3499, 3501, 3, 326, 163, 0, 3500, 3502, 5, 370, 0, 0, 3501, 3500, 1, 0, 0, 0, 3501, 3502, 1, 0, 0, 0, 3502, 3503, 1, 0, 0, 0, 3503, 3506, 3, 278, 139, 0, 3504, 3505, 5, 196, 0, 0, 3505, 3507, 5, 197, 0, 0, 3506, 3504, 1, 0, 0, 0, 3506, 3507, 1, 0, 0, 0, 3507, 3510, 1, 0, 0, 0, 3508, 3509, 5, 51, 0, 0, 3509, 3511, 3, 334, 167, 0, 3510, 3508, 1, 0, 0, 0, 3510, 3511, 1, 0, 0, 0, 3511, 303, 1, 0, 0, 0, 3512, 3513, 5, 342, 0, 0, 3513, 3514, 3, 228, 114, 0, 3514, 3515, 5, 299, 0, 0, 3515, 3516, 3, 228, 114, 0, 3516, 305, 1, 0, 0, 0, 3517, 3518, 5, 344, 0, 0, 3518, 3519, 3, 322, 161, 0, 3519, 3520, 5, 20, 0, 0, 3520, 3528, 3, 308, 154, 0, 3521, 3522, 5, 4, 0, 0, 3522, 3523, 3, 322, 161, 0, 3523, 3524, 5, 20, 0, 0, 3524, 3525, 3, 308, 154, 0, 3525, 3527, 1, 0, 0, 0, 3526, 3521, 1, 0, 0, 0, 3527, 3530, 1, 0, 0, 0, 3528, 3526, 1, 0, 0, 0, 3528, 3529, 1, 0, 0, 0, 3529, 307, 1, 0, 0, 0, 3530, 3528, 1, 0, 0, 0, 3531, 3578, 3, 322, 161, 0, 3532, 3533, 5, 2, 0, 0, 3533, 3534, 3, 322, 161, 0, 3534, 3535, 5, 3, 0, 0, 3535, 3578, 1, 0, 0, 0, 3536, 3571, 5, 2, 0, 0, 3537, 3538, 5, 44, 0, 0, 3538, 3539, 5, 31, 0, 0, 3539, 3544, 3, 228, 114, 0, 3540, 3541, 5, 4, 0, 0, 3541, 3543, 3, 228, 114, 0, 3542, 3540, 1, 0, 0, 0, 3543, 3546, 1, 0, 0, 0, 3544, 3542, 1, 0, 0, 0, 3544, 3545, 1, 0, 0, 0, 3545, 3572, 1, 0, 0, 0, 3546, 3544, 1, 0, 0, 0, 3547, 3548, 7, 35, 0, 0, 3548, 3549, 5, 31, 0, 0, 3549, 3554, 3, 228, 114, 0, 3550, 3551, 5, 4, 0, 0, 3551, 3553, 3, 228, 114, 0, 3552, 3550, 1, 0, 0, 0, 3553, 3556, 1, 0, 0, 0, 3554, 3552, 1, 0, 0, 0, 3554, 3555, 1, 0, 0, 0, 3555, 3558, 1, 0, 0, 0, 3556, 3554, 1, 0, 0, 0, 3557, 3547, 1, 0, 0, 0, 3557, 3558, 1, 0, 0, 0, 3558, 3569, 1, 0, 0, 0, 3559, 3560, 7, 36, 0, 0, 3560, 3561, 5, 31, 0, 0, 3561, 3566, 3, 96, 48, 0, 3562, 3563, 5, 4, 0, 0, 3563, 3565, 3, 96, 48, 0, 3564, 3562, 1, 0, 0, 0, 3565, 3568, 1, 0, 0, 0, 3566, 3564, 1, 0, 0, 0, 3566, 3567, 1, 0, 0, 0, 3567, 3570, 1, 0, 0, 0, 3568, 3566, 1, 0, 0, 0, 3569, 3559, 1, 0, 0, 0, 3569, 3570, 1, 0, 0, 0, 3570, 3572, 1, 0, 0, 0, 3571, 3537, 1, 0, 0, 0, 3571, 3557, 1, 0, 0, 0, 3572, 3574, 1, 0, 0, 0, 3573, 3575, 3, 310, 155, 0, 3574, 3573, 1, 0, 0, 0, 3574, 3575, 1, 0, 0, 0, 3575, 3576, 1, 0, 0, 0, 3576, 3578, 5, 3, 0, 0, 3577, 3531, 1, 0, 0, 0, 3577, 3532, 1, 0, 0, 0, 3577, 3536, 1, 0, 0, 0, 3578, 309, 1, 0, 0, 0, 3579, 3580, 7, 67, 0, 0, 3580, 3588, 3, 312, 156, 0, 3581, 3582, 7, 67, 0, 0, 3582, 3583, 5, 24, 0, 0, 3583, 3584, 3, 312, 156, 0, 3584, 3585, 5, 14, 0, 0, 3585, 3586, 3, 312, 156, 0, 3586, 3588, 1, 0, 0, 0, 3587, 3579, 1, 0, 0, 0, 3587, 3581, 1, 0, 0, 0, 3588, 311, 1, 0, 0, 0, 3589, 3590, 5, 320, 0, 0, 3590, 3597, 7, 68, 0, 0, 3591, 3592, 5, 62, 0, 0, 3592, 3597, 5, 256, 0, 0, 3593, 3594, 3, 228, 114, 0, 3594, 3595, 7, 68, 0, 0, 3595, 3597, 1, 0, 0, 0, 3596, 3589, 1, 0, 0, 0, 3596, 3591, 1, 0, 0, 0, 3596, 3593, 1, 0, 0, 0, 3597, 313, 1, 0, 0, 0, 3598, 3603, 3, 320, 160, 0, 3599, 3600, 5, 4, 0, 0, 3600, 3602, 3, 320, 160, 0, 3601, 3599, 1, 0, 0, 0, 3602, 3605, 1, 0, 0, 0, 3603, 3601, 1, 0, 0, 0, 3603, 3604, 1, 0, 0, 0, 3604, 315, 1, 0, 0, 0, 3605, 3603, 1, 0, 0, 0, 3606, 3607, 5, 136, 0, 0, 3607, 3608, 5, 2, 0, 0, 3608, 3609, 3, 228, 114, 0, 3609, 3610, 5, 3, 0, 0, 3610, 3616, 1, 0, 0, 0, 3611, 3616, 3, 320, 160, 0, 3612, 3616, 5, 114, 0, 0, 3613, 3616, 5, 161, 0, 0, 3614, 3616, 5, 249, 0, 0, 3615, 3606, 1, 0, 0, 0, 3615, 3611, 1, 0, 0, 0, 3615, 3612, 1, 0, 0, 0, 3615, 3613, 1, 0, 0, 0, 3615, 3614, 1, 0, 0, 0, 3616, 317, 1, 0, 0, 0, 3617, 3618, 3, 320, 160, 0, 3618, 319, 1, 0, 0, 0, 3619, 3624, 3, 326, 163, 0, 3620, 3621, 5, 5, 0, 0, 3621, 3623, 3, 326, 163, 0, 3622, 3620, 1, 0, 0, 0, 3623, 3626, 1, 0, 0, 0, 3624, 3622, 1, 0, 0, 0, 3624, 3625, 1, 0, 0, 0, 3625, 321, 1, 0, 0, 0, 3626, 3624, 1, 0, 0, 0, 3627, 3628, 3, 326, 163, 0, 3628, 3629, 3, 324, 162, 0, 3629, 323, 1, 0, 0, 0, 3630, 3631, 5, 361, 0, 0, 3631, 3633, 3, 326, 163, 0, 3632, 3630, 1, 0, 0, 0, 3633, 3634, 1, 0, 0, 0, 3634, 3632, 1, 0, 0, 0, 3634, 3635, 1, 0, 0, 0, 3635, 3638, 1, 0, 0, 0, 3636, 3638, 1, 0, 0, 0, 3637, 3632, 1, 0, 0, 0, 3637, 3636, 1, 0, 0, 0, 3638, 325, 1, 0, 0, 0, 3639, 3642, 3, 328, 164, 0, 3640, 3642, 3, 338, 169, 0, 3641, 3639, 1, 0, 0, 0, 3641, 3640, 1, 0, 0, 0, 3642, 327, 1, 0, 0, 0, 3643, 3649, 5, 387, 0, 0, 3644, 3649, 5, 388, 0, 0, 3645, 3649, 5, 377, 0, 0, 3646, 3649, 3, 336, 168, 0, 3647, 3649, 3, 340, 170, 0, 3648, 3643, 1, 0, 0, 0, 3648, 3644, 1, 0, 0, 0, 3648, 3645, 1, 0, 0, 0, 3648, 3646, 1, 0, 0, 0, 3648, 3647, 1, 0, 0, 0, 3649, 329, 1, 0, 0, 0, 3650, 3652, 5, 361, 0, 0, 3651, 3650, 1, 0, 0, 0, 3651, 3652, 1, 0, 0, 0, 3652, 3653, 1, 0, 0, 0, 3653, 3654, 7, 69, 0, 0, 3654, 331, 1, 0, 0, 0, 3655, 3656, 5, 318, 0, 0, 3656, 3669, 3, 278, 139, 0, 3657, 3658, 5, 51, 0, 0, 3658, 3669, 3, 334, 167, 0, 3659, 3669, 3, 274, 137, 0, 3660, 3661, 7, 70, 0, 0, 3661, 3662, 5, 196, 0, 0, 3662, 3669, 5, 197, 0, 0, 3663, 3664, 5, 268, 0, 0, 3664, 3665, 5, 82, 0, 0, 3665, 3669, 3, 228, 114, 0, 3666, 3667, 5, 96, 0, 0, 3667, 3669, 5, 82, 0, 0, 3668, 3655, 1, 0, 0, 0, 3668, 3657, 1, 0, 0, 0, 3668, 3659, 1, 0, 0, 0, 3668, 3660, 1, 0, 0, 0, 3668, 3663, 1, 0, 0, 0, 3668, 3666, 1, 0, 0, 0, 3669, 333, 1, 0, 0, 0, 3670, 3671, 7, 71, 0, 0, 3671, 335, 1, 0, 0, 0, 3672, 3673, 7, 72, 0, 0, 3673, 337, 1, 0, 0, 0, 3674, 3675, 7, 73, 0, 0, 3675, 339, 1, 0, 0, 0, 3676, 3677, 7, 74, 0, 0, 3677, 341, 1, 0, 0, 0, 530, 345, 352, 356, 361, 372, 378, 389, 395, 400, 405, 408, 412, 415, 419, 425, 431, 436, 441, 444, 448, 451, 460, 465, 478, 481, 485, 491, 494, 497, 502, 510, 515, 521, 524, 531, 538, 545, 552, 558, 568, 571, 581, 589, 593, 596, 604, 607, 611, 614, 621, 626, 631, 638, 643, 652, 656, 662, 666, 670, 675, 681, 688, 693, 698, 701, 707, 711, 717, 725, 729, 734, 740, 752, 757, 760, 763, 766, 769, 772, 787, 791, 800, 804, 811, 815, 828, 836, 841, 850, 853, 856, 861, 872, 879, 887, 892, 895, 900, 910, 912, 917, 920, 924, 931, 934, 938, 941, 945, 954, 957, 961, 964, 969, 982, 984, 990, 993, 996, 1000, 1004, 1013, 1015, 1024, 1027, 1036, 1041, 1046, 1049, 1053, 1068, 1071, 1076, 1081, 1086, 1093, 1100, 1105, 1108, 1113, 1117, 1122, 1126, 1131, 1136, 1140, 1147, 1152, 1157, 1162, 1169, 1174, 1177, 1188, 1195, 1202, 1214, 1222, 1228, 1234, 1237, 1242, 1246, 1249, 1257, 1262, 1271, 1276, 1278, 1286, 1291, 1295, 1298, 1301, 1304, 1308, 1310, 1316, 1319, 1322, 1328, 1331, 1334, 1341, 1346, 1355, 1363, 1369, 1372, 1375, 1381, 1385, 1390, 1393, 1397, 1399, 1407, 1415, 1418, 1430, 1436, 1441, 1444, 1448, 1459, 1467, 1479, 1484, 1487, 1495, 1504, 1512, 1518, 1527, 1534, 1543, 1548, 1551, 1576, 1578, 1590, 1597, 1600, 1607, 1611, 1617, 1625, 1632, 1635, 1643, 1654, 1665, 1673, 1679, 1695, 1702, 1713, 1722, 1725, 1734, 1737, 1746, 1749, 1758, 1761, 1764, 1769, 1771, 1775, 1783, 1789, 1795, 1798, 1800, 1808, 1818, 1827, 1831, 1834, 1838, 1842, 1850, 1854, 1857, 1860, 1863, 1867, 1871, 1876, 1880, 1883, 1886, 1889, 1893, 1898, 1902, 1905, 1908, 1911, 1913, 1919, 1926, 1931, 1934, 1937, 1941, 1951, 1955, 1957, 1960, 1964, 1970, 1974, 1985, 1993, 1995, 2002, 2006, 2018, 2025, 2040, 2045, 2052, 2068, 2073, 2086, 2091, 2099, 2105, 2109, 2112, 2115, 2122, 2125, 2131, 2140, 2150, 2165, 2170, 2172, 2177, 2186, 2196, 2201, 2205, 2210, 2217, 2222, 2226, 2229, 2232, 2246, 2259, 2264, 2268, 2271, 2276, 2281, 2285, 2288, 2300, 2311, 2324, 2335, 2340, 2343, 2347, 2350, 2362, 2371, 2374, 2379, 2386, 2389, 2395, 2401, 2403, 2406, 2411, 2415, 2421, 2425, 2428, 2433, 2436, 2441, 2443, 2449, 2454, 2461, 2464, 2482, 2484, 2487, 2498, 2507, 2514, 2522, 2530, 2535, 2538, 2541, 2549, 2557, 2567, 2579, 2582, 2587, 2592, 2599, 2606, 2608, 2621, 2627, 2629, 2639, 2645, 2647, 2655, 2659, 2662, 2666, 2668, 2677, 2689, 2691, 2698, 2705, 2711, 2717, 2719, 2726, 2734, 2742, 2748, 2753, 2760, 2766, 2769, 2773, 2775, 2782, 2791, 2798, 2808, 2813, 2817, 2827, 2834, 2847, 2849, 2857, 2859, 2863, 2871, 2880, 2886, 2894, 2899, 2911, 2916, 2919, 2925, 2929, 2934, 2939, 2944, 2950, 2971, 2973, 2984, 2996, 3008, 3012, 3021, 3025, 3043, 3046, 3054, 3063, 3072, 3095, 3111, 3118, 3121, 3130, 3134, 3138, 3150, 3175, 3182, 3185, 3200, 3221, 3225, 3227, 3237, 3239, 3249, 3264, 3266, 3279, 3283, 3288, 3295, 3303, 3308, 3317, 3349, 3370, 3373, 3377, 3383, 3389, 3398, 3402, 3404, 3411, 3419, 3427, 3435, 3445, 3455, 3462, 3466, 3473, 3481, 3497, 3501, 3506, 3510, 3528, 3544, 3554, 3557, 3566, 3569, 3571, 3574, 3577, 3587, 3596, 3603, 3615, 3624, 3634, 3637, 3641, 3648, 3651, 3668] \ No newline at end of file diff --git a/src/lib/sql/SqlParser.tokens b/src/lib/sql/SqlParser.tokens new file mode 100644 index 00000000..59f750a7 --- /dev/null +++ b/src/lib/sql/SqlParser.tokens @@ -0,0 +1,764 @@ +SEMICOLON=1 +LEFT_PAREN=2 +RIGHT_PAREN=3 +COMMA=4 +DOT=5 +LEFT_BRACKET=6 +RIGHT_BRACKET=7 +KW_ADD=8 +KW_AFTER=9 +KW_ALL=10 +KW_ALTER=11 +KW_ALWAYS=12 +KW_ANALYZE=13 +KW_AND=14 +KW_ANTI=15 +KW_ANY=16 +KW_ANY_VALUE=17 +KW_ARCHIVE=18 +KW_ARRAY=19 +KW_AS=20 +KW_ASC=21 +KW_AT=22 +KW_AUTHORIZATION=23 +KW_BETWEEN=24 +KW_BIGINT=25 +KW_BINARY=26 +KW_BOOLEAN=27 +KW_BOTH=28 +KW_BUCKET=29 +KW_BUCKETS=30 +KW_BY=31 +KW_BYTE=32 +KW_CACHE=33 +KW_CASCADE=34 +KW_CASE=35 +KW_CAST=36 +KW_CATALOG=37 +KW_CATALOGS=38 +KW_CHANGE=39 +KW_CHAR=40 +KW_CHARACTER=41 +KW_CHECK=42 +KW_CLEAR=43 +KW_CLUSTER=44 +KW_CLUSTERED=45 +KW_CODEGEN=46 +KW_COLLATE=47 +KW_COLLECTION=48 +KW_COLUMN=49 +KW_COLUMNS=50 +KW_COMMENT=51 +KW_COMMIT=52 +KW_COMPACT=53 +KW_COMPACTIONS=54 +KW_COMPUTE=55 +KW_CONCATENATE=56 +KW_CONSTRAINT=57 +KW_COST=58 +KW_CREATE=59 +KW_CROSS=60 +KW_CUBE=61 +KW_CURRENT=62 +KW_CURRENT_DATE=63 +KW_CURRENT_TIME=64 +KW_CURRENT_TIMESTAMP=65 +KW_CURRENT_USER=66 +KW_DAY=67 +KW_DAYS=68 +KW_DAYOFYEAR=69 +KW_DATA=70 +KW_DATE=71 +KW_DATABASE=72 +KW_DATABASES=73 +KW_DATEADD=74 +KW_DATE_ADD=75 +KW_DATEDIFF=76 +KW_DATE_DIFF=77 +KW_DBPROPERTIES=78 +KW_DEC=79 +KW_DECIMAL=80 +KW_DECLARE=81 +KW_DEFAULT=82 +KW_DEFINED=83 +KW_DELETE=84 +KW_DELIMITED=85 +KW_DESC=86 +KW_DESCRIBE=87 +KW_DFS=88 +KW_DIRECTORIES=89 +KW_DIRECTORY=90 +KW_DISABLE=91 +KW_DISTINCT=92 +KW_DISTRIBUTE=93 +KW_DIV=94 +KW_DOUBLE=95 +KW_DROP=96 +KW_ELSE=97 +KW_ENABLE=98 +KW_END=99 +KW_ESCAPE=100 +KW_ESCAPED=101 +KW_EXCEPT=102 +KW_EXCHANGE=103 +KW_EXCLUDE=104 +KW_EXISTS=105 +KW_EXPLAIN=106 +KW_EXPORT=107 +KW_EXTENDED=108 +KW_EXTERNAL=109 +KW_EXTRACT=110 +KW_FALSE=111 +KW_FETCH=112 +KW_FIELDS=113 +KW_FILTER=114 +KW_FILEFORMAT=115 +KW_FIRST=116 +KW_FLOAT=117 +KW_FOLLOWING=118 +KW_FOR=119 +KW_FOREIGN=120 +KW_FORMAT=121 +KW_FORMATTED=122 +KW_FROM=123 +KW_FULL=124 +KW_FUNCTION=125 +KW_FUNCTIONS=126 +KW_GENERATED=127 +KW_GLOBAL=128 +KW_GRANT=129 +KW_GROUP=130 +KW_GROUPING=131 +KW_HAVING=132 +KW_BINARY_HEX=133 +KW_HOUR=134 +KW_HOURS=135 +KW_IDENTIFIER=136 +KW_IF=137 +KW_IGNORE=138 +KW_IMPORT=139 +KW_IN=140 +KW_INCLUDE=141 +KW_INDEX=142 +KW_INDEXES=143 +KW_INNER=144 +KW_INPATH=145 +KW_INPUTFORMAT=146 +KW_INSERT=147 +KW_INTERSECT=148 +KW_INTERVAL=149 +KW_INT=150 +KW_INTEGER=151 +KW_INTO=152 +KW_IS=153 +KW_ITEMS=154 +KW_JOIN=155 +KW_KEYS=156 +KW_LAST=157 +KW_LATERAL=158 +KW_LAZY=159 +KW_LEADING=160 +KW_LEFT=161 +KW_LIFECYCLE=162 +KW_LIKE=163 +KW_ILIKE=164 +KW_LIMIT=165 +KW_LINES=166 +KW_LIST=167 +KW_LOAD=168 +KW_LOCAL=169 +KW_LOCATION=170 +KW_LOCK=171 +KW_LOCKS=172 +KW_LOGICAL=173 +KW_LONG=174 +KW_MACRO=175 +KW_MAP=176 +KW_MATCHED=177 +KW_MERGE=178 +KW_MICROSECOND=179 +KW_MICROSECONDS=180 +KW_MILLISECOND=181 +KW_MILLISECONDS=182 +KW_MINUTE=183 +KW_MINUTES=184 +KW_MONTH=185 +KW_MONTHS=186 +KW_MSCK=187 +KW_NAME=188 +KW_NAMESPACE=189 +KW_NAMESPACES=190 +KW_NANOSECOND=191 +KW_NANOSECONDS=192 +KW_NATURAL=193 +KW_NO=194 +KW_NOSCAN=195 +KW_NOT=196 +KW_NULL=197 +KW_NULLS=198 +KW_NUMERIC=199 +KW_OF=200 +KW_OFFSET=201 +KW_ON=202 +KW_ONLY=203 +KW_OPTIMIZE=204 +KW_OPTION=205 +KW_OPTIONS=206 +KW_OR=207 +KW_ORDER=208 +KW_OUT=209 +KW_OUTER=210 +KW_OUTPUTFORMAT=211 +KW_OVER=212 +KW_OVERLAPS=213 +KW_OVERLAY=214 +KW_OVERWRITE=215 +KW_PARTITION=216 +KW_PARTITIONED=217 +KW_PARTITIONS=218 +KW_PERCENTILE_CONT=219 +KW_PERCENTILE_DISC=220 +KW_PERCENTLIT=221 +KW_PIVOT=222 +KW_PLACING=223 +KW_POSITION=224 +KW_PRECEDING=225 +KW_PRIMARY=226 +KW_PRINCIPALS=227 +KW_PROPERTIES=228 +KW_PURGE=229 +KW_QUARTER=230 +KW_QUERY=231 +KW_RANGE=232 +KW_REAL=233 +KW_RECORDREADER=234 +KW_RECORDWRITER=235 +KW_RECOVER=236 +KW_REDUCE=237 +KW_REFERENCES=238 +KW_REFRESH=239 +KW_RENAME=240 +KW_REPAIR=241 +KW_REPEATABLE=242 +KW_REPLACE=243 +KW_RESET=244 +KW_RESPECT=245 +KW_RESTRICT=246 +KW_REWRITE=247 +KW_REVOKE=248 +KW_RIGHT=249 +KW_RLIKE=250 +KW_REGEXP=251 +KW_ROLE=252 +KW_ROLES=253 +KW_ROLLBACK=254 +KW_ROLLUP=255 +KW_ROW=256 +KW_ROWS=257 +KW_SECOND=258 +KW_SECONDS=259 +KW_SCHEMA=260 +KW_SCHEMAS=261 +KW_SELECT=262 +KW_SEMI=263 +KW_SEPARATED=264 +KW_SERDE=265 +KW_SERDEPROPERTIES=266 +KW_SESSION_USER=267 +KW_SET=268 +KW_MINUS=269 +KW_SETS=270 +KW_SHORT=271 +KW_SHOW=272 +KW_SINGLE=273 +KW_SKEWED=274 +KW_SMALLINT=275 +KW_SOME=276 +KW_SORT=277 +KW_SORTED=278 +KW_SOURCE=279 +KW_START=280 +KW_STATISTICS=281 +KW_STORED=282 +KW_STRATIFY=283 +KW_STRING=284 +KW_STRUCT=285 +KW_SUBSTR=286 +KW_SUBSTRING=287 +KW_SYNC=288 +KW_SYSTEM=289 +KW_SYSTEM_TIME=290 +KW_SYSTEM_VERSION=291 +KW_TABLE=292 +KW_TABLES=293 +KW_TABLESAMPLE=294 +KW_TARGET=295 +KW_TBLPROPERTIES=296 +KW_TEMPORARY=297 +KW_TERMINATED=298 +KW_THEN=299 +KW_TIME=300 +KW_TIMEDIFF=301 +KW_TIMESTAMP=302 +KW_TIMESTAMP_LTZ=303 +KW_TIMESTAMP_NTZ=304 +KW_TIMESTAMPADD=305 +KW_TIMESTAMPDIFF=306 +KW_TINYINT=307 +KW_TO=308 +KW_TOUCH=309 +KW_TRAILING=310 +KW_TRANSACTION=311 +KW_TRANSACTIONS=312 +KW_TRANSFORM=313 +KW_TRIM=314 +KW_TRUE=315 +KW_TRUNCATE=316 +KW_TRY_CAST=317 +KW_TYPE=318 +KW_UNARCHIVE=319 +KW_UNBOUNDED=320 +KW_UNCACHE=321 +KW_UNION=322 +KW_UNIQUE=323 +KW_UNKNOWN=324 +KW_UNLOCK=325 +KW_UNPIVOT=326 +KW_UNSET=327 +KW_UPDATE=328 +KW_USE=329 +KW_USER=330 +KW_USING=331 +KW_VALUES=332 +KW_VARCHAR=333 +KW_VAR=334 +KW_VARIABLE=335 +KW_VERSION=336 +KW_VIEW=337 +KW_VIEWS=338 +KW_VOID=339 +KW_WEEK=340 +KW_WEEKS=341 +KW_WHEN=342 +KW_WHERE=343 +KW_WINDOW=344 +KW_WITH=345 +KW_WITHIN=346 +KW_YEAR=347 +KW_YEARS=348 +KW_ZONE=349 +KW_ZORDER=350 +EQ=351 +NSEQ=352 +NEQ=353 +NEQJ=354 +LT=355 +LTE=356 +GT=357 +GTE=358 +NOT=359 +PLUS=360 +MINUS=361 +ASTERISK=362 +SLASH=363 +PERCENT=364 +TILDE=365 +AMPERSAND=366 +PIPE=367 +CONCAT_PIPE=368 +HAT=369 +COLON=370 +ARROW=371 +FAT_ARROW=372 +HENT_START=373 +HENT_END=374 +QUESTION=375 +STRING_LITERAL=376 +DOUBLEQUOTED_STRING=377 +BIGINT_LITERAL=378 +SMALLINT_LITERAL=379 +TINYINT_LITERAL=380 +INTEGER_VALUE=381 +EXPONENT_VALUE=382 +DECIMAL_VALUE=383 +FLOAT_LITERAL=384 +DOUBLE_LITERAL=385 +BIGDECIMAL_LITERAL=386 +IDENTIFIER=387 +BACKQUOTED_IDENTIFIER=388 +SIMPLE_COMMENT=389 +BRACKETED_COMMENT=390 +WS=391 +UNRECOGNIZED=392 +';'=1 +'('=2 +')'=3 +','=4 +'.'=5 +'['=6 +']'=7 +'ADD'=8 +'AFTER'=9 +'ALL'=10 +'ALTER'=11 +'ALWAYS'=12 +'ANALYZE'=13 +'AND'=14 +'ANTI'=15 +'ANY'=16 +'ANY_VALUE'=17 +'ARCHIVE'=18 +'ARRAY'=19 +'AS'=20 +'ASC'=21 +'AT'=22 +'AUTHORIZATION'=23 +'BETWEEN'=24 +'BIGINT'=25 +'BINARY'=26 +'BOOLEAN'=27 +'BOTH'=28 +'BUCKET'=29 +'BUCKETS'=30 +'BY'=31 +'BYTE'=32 +'CACHE'=33 +'CASCADE'=34 +'CASE'=35 +'CAST'=36 +'CATALOG'=37 +'CATALOGS'=38 +'CHANGE'=39 +'CHAR'=40 +'CHARACTER'=41 +'CHECK'=42 +'CLEAR'=43 +'CLUSTER'=44 +'CLUSTERED'=45 +'CODEGEN'=46 +'COLLATE'=47 +'COLLECTION'=48 +'COLUMN'=49 +'COLUMNS'=50 +'COMMENT'=51 +'COMMIT'=52 +'COMPACT'=53 +'COMPACTIONS'=54 +'COMPUTE'=55 +'CONCATENATE'=56 +'CONSTRAINT'=57 +'COST'=58 +'CREATE'=59 +'CROSS'=60 +'CUBE'=61 +'CURRENT'=62 +'CURRENT_DATE'=63 +'CURRENT_TIME'=64 +'CURRENT_TIMESTAMP'=65 +'CURRENT_USER'=66 +'DAY'=67 +'DAYS'=68 +'DAYOFYEAR'=69 +'DATA'=70 +'DATE'=71 +'DATABASE'=72 +'DATABASES'=73 +'DATEADD'=74 +'DATE_ADD'=75 +'DATEDIFF'=76 +'DATE_DIFF'=77 +'DBPROPERTIES'=78 +'DEC'=79 +'DECIMAL'=80 +'DECLARE'=81 +'DEFAULT'=82 +'DEFINED'=83 +'DELETE'=84 +'DELIMITED'=85 +'DESC'=86 +'DESCRIBE'=87 +'DFS'=88 +'DIRECTORIES'=89 +'DIRECTORY'=90 +'DISABLE'=91 +'DISTINCT'=92 +'DISTRIBUTE'=93 +'DIV'=94 +'DOUBLE'=95 +'DROP'=96 +'ELSE'=97 +'ENABLE'=98 +'END'=99 +'ESCAPE'=100 +'ESCAPED'=101 +'EXCEPT'=102 +'EXCHANGE'=103 +'EXCLUDE'=104 +'EXISTS'=105 +'EXPLAIN'=106 +'EXPORT'=107 +'EXTENDED'=108 +'EXTERNAL'=109 +'EXTRACT'=110 +'FALSE'=111 +'FETCH'=112 +'FIELDS'=113 +'FILTER'=114 +'FILEFORMAT'=115 +'FIRST'=116 +'FLOAT'=117 +'FOLLOWING'=118 +'FOR'=119 +'FOREIGN'=120 +'FORMAT'=121 +'FORMATTED'=122 +'FROM'=123 +'FULL'=124 +'FUNCTION'=125 +'FUNCTIONS'=126 +'GENERATED'=127 +'GLOBAL'=128 +'GRANT'=129 +'GROUP'=130 +'GROUPING'=131 +'HAVING'=132 +'X'=133 +'HOUR'=134 +'HOURS'=135 +'IDENTIFIER'=136 +'IF'=137 +'IGNORE'=138 +'IMPORT'=139 +'IN'=140 +'INCLUDE'=141 +'INDEX'=142 +'INDEXES'=143 +'INNER'=144 +'INPATH'=145 +'INPUTFORMAT'=146 +'INSERT'=147 +'INTERSECT'=148 +'INTERVAL'=149 +'INT'=150 +'INTEGER'=151 +'INTO'=152 +'IS'=153 +'ITEMS'=154 +'JOIN'=155 +'KEYS'=156 +'LAST'=157 +'LATERAL'=158 +'LAZY'=159 +'LEADING'=160 +'LEFT'=161 +'LIFECYCLE'=162 +'LIKE'=163 +'ILIKE'=164 +'LIMIT'=165 +'LINES'=166 +'LIST'=167 +'LOAD'=168 +'LOCAL'=169 +'LOCATION'=170 +'LOCK'=171 +'LOCKS'=172 +'LOGICAL'=173 +'LONG'=174 +'MACRO'=175 +'MAP'=176 +'MATCHED'=177 +'MERGE'=178 +'MICROSECOND'=179 +'MICROSECONDS'=180 +'MILLISECOND'=181 +'MILLISECONDS'=182 +'MINUTE'=183 +'MINUTES'=184 +'MONTH'=185 +'MONTHS'=186 +'MSCK'=187 +'NAME'=188 +'NAMESPACE'=189 +'NAMESPACES'=190 +'NANOSECOND'=191 +'NANOSECONDS'=192 +'NATURAL'=193 +'NO'=194 +'NOSCAN'=195 +'NOT'=196 +'NULL'=197 +'NULLS'=198 +'NUMERIC'=199 +'OF'=200 +'OFFSET'=201 +'ON'=202 +'ONLY'=203 +'OPTIMIZE'=204 +'OPTION'=205 +'OPTIONS'=206 +'OR'=207 +'ORDER'=208 +'OUT'=209 +'OUTER'=210 +'OUTPUTFORMAT'=211 +'OVER'=212 +'OVERLAPS'=213 +'OVERLAY'=214 +'OVERWRITE'=215 +'PARTITION'=216 +'PARTITIONED'=217 +'PARTITIONS'=218 +'PERCENTILE_CONT'=219 +'PERCENTILE_DISC'=220 +'PERCENT'=221 +'PIVOT'=222 +'PLACING'=223 +'POSITION'=224 +'PRECEDING'=225 +'PRIMARY'=226 +'PRINCIPALS'=227 +'PROPERTIES'=228 +'PURGE'=229 +'QUARTER'=230 +'QUERY'=231 +'RANGE'=232 +'REAL'=233 +'RECORDREADER'=234 +'RECORDWRITER'=235 +'RECOVER'=236 +'REDUCE'=237 +'REFERENCES'=238 +'REFRESH'=239 +'RENAME'=240 +'REPAIR'=241 +'REPEATABLE'=242 +'REPLACE'=243 +'RESET'=244 +'RESPECT'=245 +'RESTRICT'=246 +'REWRITE'=247 +'REVOKE'=248 +'RIGHT'=249 +'RLIKE'=250 +'REGEXP'=251 +'ROLE'=252 +'ROLES'=253 +'ROLLBACK'=254 +'ROLLUP'=255 +'ROW'=256 +'ROWS'=257 +'SECOND'=258 +'SECONDS'=259 +'SCHEMA'=260 +'SCHEMAS'=261 +'SELECT'=262 +'SEMI'=263 +'SEPARATED'=264 +'SERDE'=265 +'SERDEPROPERTIES'=266 +'SESSION_USER'=267 +'SET'=268 +'MINUS'=269 +'SETS'=270 +'SHORT'=271 +'SHOW'=272 +'SINGLE'=273 +'SKEWED'=274 +'SMALLINT'=275 +'SOME'=276 +'SORT'=277 +'SORTED'=278 +'SOURCE'=279 +'START'=280 +'STATISTICS'=281 +'STORED'=282 +'STRATIFY'=283 +'STRING'=284 +'STRUCT'=285 +'SUBSTR'=286 +'SUBSTRING'=287 +'SYNC'=288 +'SYSTEM'=289 +'SYSTEM_TIME'=290 +'SYSTEM_VERSION'=291 +'TABLE'=292 +'TABLES'=293 +'TABLESAMPLE'=294 +'TARGET'=295 +'TBLPROPERTIES'=296 +'TEMPORARY'=297 +'TERMINATED'=298 +'THEN'=299 +'TIME'=300 +'TIMEDIFF'=301 +'TIMESTAMP'=302 +'TIMESTAMP_LTZ'=303 +'TIMESTAMP_NTZ'=304 +'TIMESTAMPADD'=305 +'TIMESTAMPDIFF'=306 +'TINYINT'=307 +'TO'=308 +'TOUCH'=309 +'TRAILING'=310 +'TRANSACTION'=311 +'TRANSACTIONS'=312 +'TRANSFORM'=313 +'TRIM'=314 +'TRUE'=315 +'TRUNCATE'=316 +'TRY_CAST'=317 +'TYPE'=318 +'UNARCHIVE'=319 +'UNBOUNDED'=320 +'UNCACHE'=321 +'UNION'=322 +'UNIQUE'=323 +'UNKNOWN'=324 +'UNLOCK'=325 +'UNPIVOT'=326 +'UNSET'=327 +'UPDATE'=328 +'USE'=329 +'USER'=330 +'USING'=331 +'VALUES'=332 +'VARCHAR'=333 +'VAR'=334 +'VARIABLE'=335 +'VERSION'=336 +'VIEW'=337 +'VIEWS'=338 +'VOID'=339 +'WEEK'=340 +'WEEKS'=341 +'WHEN'=342 +'WHERE'=343 +'WINDOW'=344 +'WITH'=345 +'WITHIN'=346 +'YEAR'=347 +'YEARS'=348 +'ZONE'=349 +'ZORDER'=350 +'<=>'=352 +'<>'=353 +'!='=354 +'<'=355 +'>'=357 +'!'=359 +'+'=360 +'-'=361 +'*'=362 +'/'=363 +'%'=364 +'~'=365 +'&'=366 +'|'=367 +'||'=368 +'^'=369 +':'=370 +'->'=371 +'=>'=372 +'/*+'=373 +'*/'=374 +'?'=375 diff --git a/src/lib/sql/SqlParser.ts b/src/lib/sql/SqlParser.ts new file mode 100644 index 00000000..00266cbe --- /dev/null +++ b/src/lib/sql/SqlParser.ts @@ -0,0 +1,33245 @@ +// Generated from dt-sql-parser/src/grammar/sql/SqlParser.g4 by ANTLR 4.13.1 + +// @ts-nocheck + +import * as antlr from "antlr4ng"; +import { Token } from "antlr4ng"; + +import { SqlParserListener } from "./SqlParserListener.js"; +import { SqlParserVisitor } from "./SqlParserVisitor.js"; + +// for running tests with parameters, TODO: discuss strategy for typed parameters in CI +// eslint-disable-next-line no-unused-vars +type int = number; + + +import { SQLParserBase } from '../SQLParserBase'; + + +export class SqlParser extends SQLParserBase { + public static readonly SEMICOLON = 1; + public static readonly LEFT_PAREN = 2; + public static readonly RIGHT_PAREN = 3; + public static readonly COMMA = 4; + public static readonly DOT = 5; + public static readonly LEFT_BRACKET = 6; + public static readonly RIGHT_BRACKET = 7; + public static readonly KW_ADD = 8; + public static readonly KW_AFTER = 9; + public static readonly KW_ALL = 10; + public static readonly KW_ALTER = 11; + public static readonly KW_ALWAYS = 12; + public static readonly KW_ANALYZE = 13; + public static readonly KW_AND = 14; + public static readonly KW_ANTI = 15; + public static readonly KW_ANY = 16; + public static readonly KW_ANY_VALUE = 17; + public static readonly KW_ARCHIVE = 18; + public static readonly KW_ARRAY = 19; + public static readonly KW_AS = 20; + public static readonly KW_ASC = 21; + public static readonly KW_AT = 22; + public static readonly KW_AUTHORIZATION = 23; + public static readonly KW_BETWEEN = 24; + public static readonly KW_BIGINT = 25; + public static readonly KW_BINARY = 26; + public static readonly KW_BOOLEAN = 27; + public static readonly KW_BOTH = 28; + public static readonly KW_BUCKET = 29; + public static readonly KW_BUCKETS = 30; + public static readonly KW_BY = 31; + public static readonly KW_BYTE = 32; + public static readonly KW_CACHE = 33; + public static readonly KW_CASCADE = 34; + public static readonly KW_CASE = 35; + public static readonly KW_CAST = 36; + public static readonly KW_CATALOG = 37; + public static readonly KW_CATALOGS = 38; + public static readonly KW_CHANGE = 39; + public static readonly KW_CHAR = 40; + public static readonly KW_CHARACTER = 41; + public static readonly KW_CHECK = 42; + public static readonly KW_CLEAR = 43; + public static readonly KW_CLUSTER = 44; + public static readonly KW_CLUSTERED = 45; + public static readonly KW_CODEGEN = 46; + public static readonly KW_COLLATE = 47; + public static readonly KW_COLLECTION = 48; + public static readonly KW_COLUMN = 49; + public static readonly KW_COLUMNS = 50; + public static readonly KW_COMMENT = 51; + public static readonly KW_COMMIT = 52; + public static readonly KW_COMPACT = 53; + public static readonly KW_COMPACTIONS = 54; + public static readonly KW_COMPUTE = 55; + public static readonly KW_CONCATENATE = 56; + public static readonly KW_CONSTRAINT = 57; + public static readonly KW_COST = 58; + public static readonly KW_CREATE = 59; + public static readonly KW_CROSS = 60; + public static readonly KW_CUBE = 61; + public static readonly KW_CURRENT = 62; + public static readonly KW_CURRENT_DATE = 63; + public static readonly KW_CURRENT_TIME = 64; + public static readonly KW_CURRENT_TIMESTAMP = 65; + public static readonly KW_CURRENT_USER = 66; + public static readonly KW_DAY = 67; + public static readonly KW_DAYS = 68; + public static readonly KW_DAYOFYEAR = 69; + public static readonly KW_DATA = 70; + public static readonly KW_DATE = 71; + public static readonly KW_DATABASE = 72; + public static readonly KW_DATABASES = 73; + public static readonly KW_DATEADD = 74; + public static readonly KW_DATE_ADD = 75; + public static readonly KW_DATEDIFF = 76; + public static readonly KW_DATE_DIFF = 77; + public static readonly KW_DBPROPERTIES = 78; + public static readonly KW_DEC = 79; + public static readonly KW_DECIMAL = 80; + public static readonly KW_DECLARE = 81; + public static readonly KW_DEFAULT = 82; + public static readonly KW_DEFINED = 83; + public static readonly KW_DELETE = 84; + public static readonly KW_DELIMITED = 85; + public static readonly KW_DESC = 86; + public static readonly KW_DESCRIBE = 87; + public static readonly KW_DFS = 88; + public static readonly KW_DIRECTORIES = 89; + public static readonly KW_DIRECTORY = 90; + public static readonly KW_DISABLE = 91; + public static readonly KW_DISTINCT = 92; + public static readonly KW_DISTRIBUTE = 93; + public static readonly KW_DIV = 94; + public static readonly KW_DOUBLE = 95; + public static readonly KW_DROP = 96; + public static readonly KW_ELSE = 97; + public static readonly KW_ENABLE = 98; + public static readonly KW_END = 99; + public static readonly KW_ESCAPE = 100; + public static readonly KW_ESCAPED = 101; + public static readonly KW_EXCEPT = 102; + public static readonly KW_EXCHANGE = 103; + public static readonly KW_EXCLUDE = 104; + public static readonly KW_EXISTS = 105; + public static readonly KW_EXPLAIN = 106; + public static readonly KW_EXPORT = 107; + public static readonly KW_EXTENDED = 108; + public static readonly KW_EXTERNAL = 109; + public static readonly KW_EXTRACT = 110; + public static readonly KW_FALSE = 111; + public static readonly KW_FETCH = 112; + public static readonly KW_FIELDS = 113; + public static readonly KW_FILTER = 114; + public static readonly KW_FILEFORMAT = 115; + public static readonly KW_FIRST = 116; + public static readonly KW_FLOAT = 117; + public static readonly KW_FOLLOWING = 118; + public static readonly KW_FOR = 119; + public static readonly KW_FOREIGN = 120; + public static readonly KW_FORMAT = 121; + public static readonly KW_FORMATTED = 122; + public static readonly KW_FROM = 123; + public static readonly KW_FULL = 124; + public static readonly KW_FUNCTION = 125; + public static readonly KW_FUNCTIONS = 126; + public static readonly KW_GENERATED = 127; + public static readonly KW_GLOBAL = 128; + public static readonly KW_GRANT = 129; + public static readonly KW_GROUP = 130; + public static readonly KW_GROUPING = 131; + public static readonly KW_HAVING = 132; + public static readonly KW_BINARY_HEX = 133; + public static readonly KW_HOUR = 134; + public static readonly KW_HOURS = 135; + public static readonly KW_IDENTIFIER = 136; + public static readonly KW_IF = 137; + public static readonly KW_IGNORE = 138; + public static readonly KW_IMPORT = 139; + public static readonly KW_IN = 140; + public static readonly KW_INCLUDE = 141; + public static readonly KW_INDEX = 142; + public static readonly KW_INDEXES = 143; + public static readonly KW_INNER = 144; + public static readonly KW_INPATH = 145; + public static readonly KW_INPUTFORMAT = 146; + public static readonly KW_INSERT = 147; + public static readonly KW_INTERSECT = 148; + public static readonly KW_INTERVAL = 149; + public static readonly KW_INT = 150; + public static readonly KW_INTEGER = 151; + public static readonly KW_INTO = 152; + public static readonly KW_IS = 153; + public static readonly KW_ITEMS = 154; + public static readonly KW_JOIN = 155; + public static readonly KW_KEYS = 156; + public static readonly KW_LAST = 157; + public static readonly KW_LATERAL = 158; + public static readonly KW_LAZY = 159; + public static readonly KW_LEADING = 160; + public static readonly KW_LEFT = 161; + public static readonly KW_LIFECYCLE = 162; + public static readonly KW_LIKE = 163; + public static readonly KW_ILIKE = 164; + public static readonly KW_LIMIT = 165; + public static readonly KW_LINES = 166; + public static readonly KW_LIST = 167; + public static readonly KW_LOAD = 168; + public static readonly KW_LOCAL = 169; + public static readonly KW_LOCATION = 170; + public static readonly KW_LOCK = 171; + public static readonly KW_LOCKS = 172; + public static readonly KW_LOGICAL = 173; + public static readonly KW_LONG = 174; + public static readonly KW_MACRO = 175; + public static readonly KW_MAP = 176; + public static readonly KW_MATCHED = 177; + public static readonly KW_MERGE = 178; + public static readonly KW_MICROSECOND = 179; + public static readonly KW_MICROSECONDS = 180; + public static readonly KW_MILLISECOND = 181; + public static readonly KW_MILLISECONDS = 182; + public static readonly KW_MINUTE = 183; + public static readonly KW_MINUTES = 184; + public static readonly KW_MONTH = 185; + public static readonly KW_MONTHS = 186; + public static readonly KW_MSCK = 187; + public static readonly KW_NAME = 188; + public static readonly KW_NAMESPACE = 189; + public static readonly KW_NAMESPACES = 190; + public static readonly KW_NANOSECOND = 191; + public static readonly KW_NANOSECONDS = 192; + public static readonly KW_NATURAL = 193; + public static readonly KW_NO = 194; + public static readonly KW_NOSCAN = 195; + public static readonly KW_NOT = 196; + public static readonly KW_NULL = 197; + public static readonly KW_NULLS = 198; + public static readonly KW_NUMERIC = 199; + public static readonly KW_OF = 200; + public static readonly KW_OFFSET = 201; + public static readonly KW_ON = 202; + public static readonly KW_ONLY = 203; + public static readonly KW_OPTIMIZE = 204; + public static readonly KW_OPTION = 205; + public static readonly KW_OPTIONS = 206; + public static readonly KW_OR = 207; + public static readonly KW_ORDER = 208; + public static readonly KW_OUT = 209; + public static readonly KW_OUTER = 210; + public static readonly KW_OUTPUTFORMAT = 211; + public static readonly KW_OVER = 212; + public static readonly KW_OVERLAPS = 213; + public static readonly KW_OVERLAY = 214; + public static readonly KW_OVERWRITE = 215; + public static readonly KW_PARTITION = 216; + public static readonly KW_PARTITIONED = 217; + public static readonly KW_PARTITIONS = 218; + public static readonly KW_PERCENTILE_CONT = 219; + public static readonly KW_PERCENTILE_DISC = 220; + public static readonly KW_PERCENTLIT = 221; + public static readonly KW_PIVOT = 222; + public static readonly KW_PLACING = 223; + public static readonly KW_POSITION = 224; + public static readonly KW_PRECEDING = 225; + public static readonly KW_PRIMARY = 226; + public static readonly KW_PRINCIPALS = 227; + public static readonly KW_PROPERTIES = 228; + public static readonly KW_PURGE = 229; + public static readonly KW_QUARTER = 230; + public static readonly KW_QUERY = 231; + public static readonly KW_RANGE = 232; + public static readonly KW_REAL = 233; + public static readonly KW_RECORDREADER = 234; + public static readonly KW_RECORDWRITER = 235; + public static readonly KW_RECOVER = 236; + public static readonly KW_REDUCE = 237; + public static readonly KW_REFERENCES = 238; + public static readonly KW_REFRESH = 239; + public static readonly KW_RENAME = 240; + public static readonly KW_REPAIR = 241; + public static readonly KW_REPEATABLE = 242; + public static readonly KW_REPLACE = 243; + public static readonly KW_RESET = 244; + public static readonly KW_RESPECT = 245; + public static readonly KW_RESTRICT = 246; + public static readonly KW_REWRITE = 247; + public static readonly KW_REVOKE = 248; + public static readonly KW_RIGHT = 249; + public static readonly KW_RLIKE = 250; + public static readonly KW_REGEXP = 251; + public static readonly KW_ROLE = 252; + public static readonly KW_ROLES = 253; + public static readonly KW_ROLLBACK = 254; + public static readonly KW_ROLLUP = 255; + public static readonly KW_ROW = 256; + public static readonly KW_ROWS = 257; + public static readonly KW_SECOND = 258; + public static readonly KW_SECONDS = 259; + public static readonly KW_SCHEMA = 260; + public static readonly KW_SCHEMAS = 261; + public static readonly KW_SELECT = 262; + public static readonly KW_SEMI = 263; + public static readonly KW_SEPARATED = 264; + public static readonly KW_SERDE = 265; + public static readonly KW_SERDEPROPERTIES = 266; + public static readonly KW_SESSION_USER = 267; + public static readonly KW_SET = 268; + public static readonly KW_MINUS = 269; + public static readonly KW_SETS = 270; + public static readonly KW_SHORT = 271; + public static readonly KW_SHOW = 272; + public static readonly KW_SINGLE = 273; + public static readonly KW_SKEWED = 274; + public static readonly KW_SMALLINT = 275; + public static readonly KW_SOME = 276; + public static readonly KW_SORT = 277; + public static readonly KW_SORTED = 278; + public static readonly KW_SOURCE = 279; + public static readonly KW_START = 280; + public static readonly KW_STATISTICS = 281; + public static readonly KW_STORED = 282; + public static readonly KW_STRATIFY = 283; + public static readonly KW_STRING = 284; + public static readonly KW_STRUCT = 285; + public static readonly KW_SUBSTR = 286; + public static readonly KW_SUBSTRING = 287; + public static readonly KW_SYNC = 288; + public static readonly KW_SYSTEM = 289; + public static readonly KW_SYSTEM_TIME = 290; + public static readonly KW_SYSTEM_VERSION = 291; + public static readonly KW_TABLE = 292; + public static readonly KW_TABLES = 293; + public static readonly KW_TABLESAMPLE = 294; + public static readonly KW_TARGET = 295; + public static readonly KW_TBLPROPERTIES = 296; + public static readonly KW_TEMPORARY = 297; + public static readonly KW_TERMINATED = 298; + public static readonly KW_THEN = 299; + public static readonly KW_TIME = 300; + public static readonly KW_TIMEDIFF = 301; + public static readonly KW_TIMESTAMP = 302; + public static readonly KW_TIMESTAMP_LTZ = 303; + public static readonly KW_TIMESTAMP_NTZ = 304; + public static readonly KW_TIMESTAMPADD = 305; + public static readonly KW_TIMESTAMPDIFF = 306; + public static readonly KW_TINYINT = 307; + public static readonly KW_TO = 308; + public static readonly KW_TOUCH = 309; + public static readonly KW_TRAILING = 310; + public static readonly KW_TRANSACTION = 311; + public static readonly KW_TRANSACTIONS = 312; + public static readonly KW_TRANSFORM = 313; + public static readonly KW_TRIM = 314; + public static readonly KW_TRUE = 315; + public static readonly KW_TRUNCATE = 316; + public static readonly KW_TRY_CAST = 317; + public static readonly KW_TYPE = 318; + public static readonly KW_UNARCHIVE = 319; + public static readonly KW_UNBOUNDED = 320; + public static readonly KW_UNCACHE = 321; + public static readonly KW_UNION = 322; + public static readonly KW_UNIQUE = 323; + public static readonly KW_UNKNOWN = 324; + public static readonly KW_UNLOCK = 325; + public static readonly KW_UNPIVOT = 326; + public static readonly KW_UNSET = 327; + public static readonly KW_UPDATE = 328; + public static readonly KW_USE = 329; + public static readonly KW_USER = 330; + public static readonly KW_USING = 331; + public static readonly KW_VALUES = 332; + public static readonly KW_VARCHAR = 333; + public static readonly KW_VAR = 334; + public static readonly KW_VARIABLE = 335; + public static readonly KW_VERSION = 336; + public static readonly KW_VIEW = 337; + public static readonly KW_VIEWS = 338; + public static readonly KW_VOID = 339; + public static readonly KW_WEEK = 340; + public static readonly KW_WEEKS = 341; + public static readonly KW_WHEN = 342; + public static readonly KW_WHERE = 343; + public static readonly KW_WINDOW = 344; + public static readonly KW_WITH = 345; + public static readonly KW_WITHIN = 346; + public static readonly KW_YEAR = 347; + public static readonly KW_YEARS = 348; + public static readonly KW_ZONE = 349; + public static readonly KW_ZORDER = 350; + public static readonly EQ = 351; + public static readonly NSEQ = 352; + public static readonly NEQ = 353; + public static readonly NEQJ = 354; + public static readonly LT = 355; + public static readonly LTE = 356; + public static readonly GT = 357; + public static readonly GTE = 358; + public static readonly NOT = 359; + public static readonly PLUS = 360; + public static readonly MINUS = 361; + public static readonly ASTERISK = 362; + public static readonly SLASH = 363; + public static readonly PERCENT = 364; + public static readonly TILDE = 365; + public static readonly AMPERSAND = 366; + public static readonly PIPE = 367; + public static readonly CONCAT_PIPE = 368; + public static readonly HAT = 369; + public static readonly COLON = 370; + public static readonly ARROW = 371; + public static readonly FAT_ARROW = 372; + public static readonly HENT_START = 373; + public static readonly HENT_END = 374; + public static readonly QUESTION = 375; + public static readonly STRING_LITERAL = 376; + public static readonly DOUBLEQUOTED_STRING = 377; + public static readonly BIGINT_LITERAL = 378; + public static readonly SMALLINT_LITERAL = 379; + public static readonly TINYINT_LITERAL = 380; + public static readonly INTEGER_VALUE = 381; + public static readonly EXPONENT_VALUE = 382; + public static readonly DECIMAL_VALUE = 383; + public static readonly FLOAT_LITERAL = 384; + public static readonly DOUBLE_LITERAL = 385; + public static readonly BIGDECIMAL_LITERAL = 386; + public static readonly IDENTIFIER = 387; + public static readonly BACKQUOTED_IDENTIFIER = 388; + public static readonly SIMPLE_COMMENT = 389; + public static readonly BRACKETED_COMMENT = 390; + public static readonly WS = 391; + public static readonly UNRECOGNIZED = 392; + public static readonly RULE_program = 0; + public static readonly RULE_singleStatement = 1; + public static readonly RULE_statement = 2; + public static readonly RULE_alterStatement = 3; + public static readonly RULE_createStatement = 4; + public static readonly RULE_dropStatement = 5; + public static readonly RULE_dmlStatementNoWith = 6; + public static readonly RULE_insertInto = 7; + public static readonly RULE_showStatement = 8; + public static readonly RULE_unsupportedCommands = 9; + public static readonly RULE_bucketSpec = 10; + public static readonly RULE_skewSpec = 11; + public static readonly RULE_query = 12; + public static readonly RULE_partitionSpecLocation = 13; + public static readonly RULE_partitionSpec = 14; + public static readonly RULE_partitionVal = 15; + public static readonly RULE_namespace = 16; + public static readonly RULE_describeFuncName = 17; + public static readonly RULE_describeColName = 18; + public static readonly RULE_ctes = 19; + public static readonly RULE_namedQuery = 20; + public static readonly RULE_tableProvider = 21; + public static readonly RULE_createTableClauses = 22; + public static readonly RULE_tableLifecycle = 23; + public static readonly RULE_propertyList = 24; + public static readonly RULE_property = 25; + public static readonly RULE_propertyKey = 26; + public static readonly RULE_propertyValue = 27; + public static readonly RULE_expressionPropertyList = 28; + public static readonly RULE_expressionProperty = 29; + public static readonly RULE_constantList = 30; + public static readonly RULE_nestedConstantList = 31; + public static readonly RULE_createFileFormat = 32; + public static readonly RULE_fileFormat = 33; + public static readonly RULE_storageHandler = 34; + public static readonly RULE_namespaceName = 35; + public static readonly RULE_namespaceNameCreate = 36; + public static readonly RULE_tableNameCreate = 37; + public static readonly RULE_tableName = 38; + public static readonly RULE_viewNameCreate = 39; + public static readonly RULE_viewName = 40; + public static readonly RULE_columnName = 41; + public static readonly RULE_columnNameSeq = 42; + public static readonly RULE_columnNameCreate = 43; + public static readonly RULE_identifierReference = 44; + public static readonly RULE_queryOrganization = 45; + public static readonly RULE_queryTerm = 46; + public static readonly RULE_queryPrimary = 47; + public static readonly RULE_sortItem = 48; + public static readonly RULE_fromStatementBody = 49; + public static readonly RULE_querySpecification = 50; + public static readonly RULE_transformClause = 51; + public static readonly RULE_selectClause = 52; + public static readonly RULE_setClause = 53; + public static readonly RULE_matchedClause = 54; + public static readonly RULE_notMatchedClause = 55; + public static readonly RULE_notMatchedBySourceClause = 56; + public static readonly RULE_notMatchedAction = 57; + public static readonly RULE_assignmentList = 58; + public static readonly RULE_assignment = 59; + public static readonly RULE_whereClause = 60; + public static readonly RULE_havingClause = 61; + public static readonly RULE_hint = 62; + public static readonly RULE_hintStatement = 63; + public static readonly RULE_fromClause = 64; + public static readonly RULE_temporalClause = 65; + public static readonly RULE_aggregationClause = 66; + public static readonly RULE_groupByClause = 67; + public static readonly RULE_groupingAnalytics = 68; + public static readonly RULE_groupingSet = 69; + public static readonly RULE_pivotClause = 70; + public static readonly RULE_pivotColumn = 71; + public static readonly RULE_pivotValue = 72; + public static readonly RULE_unpivotClause = 73; + public static readonly RULE_unpivotSingleValueColumnClause = 74; + public static readonly RULE_unpivotMultiValueColumnClause = 75; + public static readonly RULE_unpivotColumnSet = 76; + public static readonly RULE_unpivotColumnAndAlias = 77; + public static readonly RULE_ifNotExists = 78; + public static readonly RULE_ifExists = 79; + public static readonly RULE_lateralView = 80; + public static readonly RULE_setQuantifier = 81; + public static readonly RULE_relation = 82; + public static readonly RULE_joinRelation = 83; + public static readonly RULE_joinType = 84; + public static readonly RULE_joinCriteria = 85; + public static readonly RULE_sample = 86; + public static readonly RULE_sampleMethod = 87; + public static readonly RULE_identifierList = 88; + public static readonly RULE_identifierSeq = 89; + public static readonly RULE_orderedIdentifierList = 90; + public static readonly RULE_orderedIdentifier = 91; + public static readonly RULE_identifierCommentList = 92; + public static readonly RULE_identifierComment = 93; + public static readonly RULE_relationPrimary = 94; + public static readonly RULE_functionTableSubqueryArgument = 95; + public static readonly RULE_tableArgumentPartitioning = 96; + public static readonly RULE_functionTableNamedArgumentExpression = 97; + public static readonly RULE_functionTableReferenceArgument = 98; + public static readonly RULE_functionTableArgument = 99; + public static readonly RULE_tableAlias = 100; + public static readonly RULE_rowFormat = 101; + public static readonly RULE_multipartIdentifierList = 102; + public static readonly RULE_multipartIdentifier = 103; + public static readonly RULE_multipartIdentifierPropertyList = 104; + public static readonly RULE_multipartIdentifierProperty = 105; + public static readonly RULE_tableIdentifier = 106; + public static readonly RULE_viewIdentifier = 107; + public static readonly RULE_namedExpression = 108; + public static readonly RULE_namedExpressionSeq = 109; + public static readonly RULE_partitionFieldList = 110; + public static readonly RULE_partitionField = 111; + public static readonly RULE_transform = 112; + public static readonly RULE_transformArgument = 113; + public static readonly RULE_expression = 114; + public static readonly RULE_namedArgumentExpression = 115; + public static readonly RULE_functionArgument = 116; + public static readonly RULE_expressionSeq = 117; + public static readonly RULE_booleanExpression = 118; + public static readonly RULE_predicate = 119; + public static readonly RULE_valueExpression = 120; + public static readonly RULE_datetimeUnit = 121; + public static readonly RULE_primaryExpression = 122; + public static readonly RULE_literalType = 123; + public static readonly RULE_constant = 124; + public static readonly RULE_comparisonOperator = 125; + public static readonly RULE_arithmeticOperator = 126; + public static readonly RULE_predicateOperator = 127; + public static readonly RULE_booleanValue = 128; + public static readonly RULE_interval = 129; + public static readonly RULE_errorCapturingMultiUnitsInterval = 130; + public static readonly RULE_errorCapturingUnitToUnitInterval = 131; + public static readonly RULE_multiUnitsInterval = 132; + public static readonly RULE_unitToUnitInterval = 133; + public static readonly RULE_intervalValue = 134; + public static readonly RULE_unitInMultiUnits = 135; + public static readonly RULE_unitInUnitToUnit = 136; + public static readonly RULE_colPosition = 137; + public static readonly RULE_type = 138; + public static readonly RULE_dataType = 139; + public static readonly RULE_qualifiedColTypeWithPositionSeqForAdd = 140; + public static readonly RULE_qualifiedColTypeWithPositionForAdd = 141; + public static readonly RULE_qualifiedColTypeWithPositionSeqForReplace = 142; + public static readonly RULE_qualifiedColTypeWithPositionForReplace = 143; + public static readonly RULE_colDefinitionDescriptorWithPosition = 144; + public static readonly RULE_variableDefaultExpression = 145; + public static readonly RULE_colTypeList = 146; + public static readonly RULE_columnType = 147; + public static readonly RULE_createOrReplaceTableColTypeList = 148; + public static readonly RULE_createOrReplaceTableColType = 149; + public static readonly RULE_colDefinitionOption = 150; + public static readonly RULE_complexColType = 151; + public static readonly RULE_whenClause = 152; + public static readonly RULE_windowClause = 153; + public static readonly RULE_windowSpec = 154; + public static readonly RULE_windowFrame = 155; + public static readonly RULE_frameBound = 156; + public static readonly RULE_qualifiedNameList = 157; + public static readonly RULE_functionName = 158; + public static readonly RULE_functionNameCreate = 159; + public static readonly RULE_qualifiedName = 160; + public static readonly RULE_errorCapturingIdentifier = 161; + public static readonly RULE_errorCapturingIdentifierExtra = 162; + public static readonly RULE_identifier = 163; + public static readonly RULE_strictIdentifier = 164; + public static readonly RULE_number = 165; + public static readonly RULE_alterColumnAction = 166; + public static readonly RULE_stringLit = 167; + public static readonly RULE_ansiNonReserved = 168; + public static readonly RULE_strictNonReserved = 169; + public static readonly RULE_nonReserved = 170; + + public static readonly literalNames = [ + null, "';'", "'('", "')'", "','", "'.'", "'['", "']'", "'ADD'", + "'AFTER'", "'ALL'", "'ALTER'", "'ALWAYS'", "'ANALYZE'", "'AND'", + "'ANTI'", "'ANY'", "'ANY_VALUE'", "'ARCHIVE'", "'ARRAY'", "'AS'", + "'ASC'", "'AT'", "'AUTHORIZATION'", "'BETWEEN'", "'BIGINT'", "'BINARY'", + "'BOOLEAN'", "'BOTH'", "'BUCKET'", "'BUCKETS'", "'BY'", "'BYTE'", + "'CACHE'", "'CASCADE'", "'CASE'", "'CAST'", "'CATALOG'", "'CATALOGS'", + "'CHANGE'", "'CHAR'", "'CHARACTER'", "'CHECK'", "'CLEAR'", "'CLUSTER'", + "'CLUSTERED'", "'CODEGEN'", "'COLLATE'", "'COLLECTION'", "'COLUMN'", + "'COLUMNS'", "'COMMENT'", "'COMMIT'", "'COMPACT'", "'COMPACTIONS'", + "'COMPUTE'", "'CONCATENATE'", "'CONSTRAINT'", "'COST'", "'CREATE'", + "'CROSS'", "'CUBE'", "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_TIME'", + "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'DAY'", "'DAYS'", "'DAYOFYEAR'", + "'DATA'", "'DATE'", "'DATABASE'", "'DATABASES'", "'DATEADD'", "'DATE_ADD'", + "'DATEDIFF'", "'DATE_DIFF'", "'DBPROPERTIES'", "'DEC'", "'DECIMAL'", + "'DECLARE'", "'DEFAULT'", "'DEFINED'", "'DELETE'", "'DELIMITED'", + "'DESC'", "'DESCRIBE'", "'DFS'", "'DIRECTORIES'", "'DIRECTORY'", + "'DISABLE'", "'DISTINCT'", "'DISTRIBUTE'", "'DIV'", "'DOUBLE'", + "'DROP'", "'ELSE'", "'ENABLE'", "'END'", "'ESCAPE'", "'ESCAPED'", + "'EXCEPT'", "'EXCHANGE'", "'EXCLUDE'", "'EXISTS'", "'EXPLAIN'", + "'EXPORT'", "'EXTENDED'", "'EXTERNAL'", "'EXTRACT'", "'FALSE'", + "'FETCH'", "'FIELDS'", "'FILTER'", "'FILEFORMAT'", "'FIRST'", "'FLOAT'", + "'FOLLOWING'", "'FOR'", "'FOREIGN'", "'FORMAT'", "'FORMATTED'", + "'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GENERATED'", + "'GLOBAL'", "'GRANT'", "'GROUP'", "'GROUPING'", "'HAVING'", "'X'", + "'HOUR'", "'HOURS'", "'IDENTIFIER'", "'IF'", "'IGNORE'", "'IMPORT'", + "'IN'", "'INCLUDE'", "'INDEX'", "'INDEXES'", "'INNER'", "'INPATH'", + "'INPUTFORMAT'", "'INSERT'", "'INTERSECT'", "'INTERVAL'", "'INT'", + "'INTEGER'", "'INTO'", "'IS'", "'ITEMS'", "'JOIN'", "'KEYS'", "'LAST'", + "'LATERAL'", "'LAZY'", "'LEADING'", "'LEFT'", "'LIFECYCLE'", "'LIKE'", + "'ILIKE'", "'LIMIT'", "'LINES'", "'LIST'", "'LOAD'", "'LOCAL'", + "'LOCATION'", "'LOCK'", "'LOCKS'", "'LOGICAL'", "'LONG'", "'MACRO'", + "'MAP'", "'MATCHED'", "'MERGE'", "'MICROSECOND'", "'MICROSECONDS'", + "'MILLISECOND'", "'MILLISECONDS'", "'MINUTE'", "'MINUTES'", "'MONTH'", + "'MONTHS'", "'MSCK'", "'NAME'", "'NAMESPACE'", "'NAMESPACES'", "'NANOSECOND'", + "'NANOSECONDS'", "'NATURAL'", "'NO'", "'NOSCAN'", "'NOT'", "'NULL'", + "'NULLS'", "'NUMERIC'", "'OF'", "'OFFSET'", "'ON'", "'ONLY'", "'OPTIMIZE'", + "'OPTION'", "'OPTIONS'", "'OR'", "'ORDER'", "'OUT'", "'OUTER'", + "'OUTPUTFORMAT'", "'OVER'", "'OVERLAPS'", "'OVERLAY'", "'OVERWRITE'", + "'PARTITION'", "'PARTITIONED'", "'PARTITIONS'", "'PERCENTILE_CONT'", + "'PERCENTILE_DISC'", "'PERCENT'", "'PIVOT'", "'PLACING'", "'POSITION'", + "'PRECEDING'", "'PRIMARY'", "'PRINCIPALS'", "'PROPERTIES'", "'PURGE'", + "'QUARTER'", "'QUERY'", "'RANGE'", "'REAL'", "'RECORDREADER'", "'RECORDWRITER'", + "'RECOVER'", "'REDUCE'", "'REFERENCES'", "'REFRESH'", "'RENAME'", + "'REPAIR'", "'REPEATABLE'", "'REPLACE'", "'RESET'", "'RESPECT'", + "'RESTRICT'", "'REWRITE'", "'REVOKE'", "'RIGHT'", "'RLIKE'", "'REGEXP'", + "'ROLE'", "'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROW'", "'ROWS'", + "'SECOND'", "'SECONDS'", "'SCHEMA'", "'SCHEMAS'", "'SELECT'", "'SEMI'", + "'SEPARATED'", "'SERDE'", "'SERDEPROPERTIES'", "'SESSION_USER'", + "'SET'", "'MINUS'", "'SETS'", "'SHORT'", "'SHOW'", "'SINGLE'", "'SKEWED'", + "'SMALLINT'", "'SOME'", "'SORT'", "'SORTED'", "'SOURCE'", "'START'", + "'STATISTICS'", "'STORED'", "'STRATIFY'", "'STRING'", "'STRUCT'", + "'SUBSTR'", "'SUBSTRING'", "'SYNC'", "'SYSTEM'", "'SYSTEM_TIME'", + "'SYSTEM_VERSION'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TARGET'", + "'TBLPROPERTIES'", "'TEMPORARY'", "'TERMINATED'", "'THEN'", "'TIME'", + "'TIMEDIFF'", "'TIMESTAMP'", "'TIMESTAMP_LTZ'", "'TIMESTAMP_NTZ'", + "'TIMESTAMPADD'", "'TIMESTAMPDIFF'", "'TINYINT'", "'TO'", "'TOUCH'", + "'TRAILING'", "'TRANSACTION'", "'TRANSACTIONS'", "'TRANSFORM'", + "'TRIM'", "'TRUE'", "'TRUNCATE'", "'TRY_CAST'", "'TYPE'", "'UNARCHIVE'", + "'UNBOUNDED'", "'UNCACHE'", "'UNION'", "'UNIQUE'", "'UNKNOWN'", + "'UNLOCK'", "'UNPIVOT'", "'UNSET'", "'UPDATE'", "'USE'", "'USER'", + "'USING'", "'VALUES'", "'VARCHAR'", "'VAR'", "'VARIABLE'", "'VERSION'", + "'VIEW'", "'VIEWS'", "'VOID'", "'WEEK'", "'WEEKS'", "'WHEN'", "'WHERE'", + "'WINDOW'", "'WITH'", "'WITHIN'", "'YEAR'", "'YEARS'", "'ZONE'", + "'ZORDER'", null, "'<=>'", "'<>'", "'!='", "'<'", null, "'>'", null, + "'!'", "'+'", "'-'", "'*'", "'/'", "'%'", "'~'", "'&'", "'|'", "'||'", + "'^'", "':'", "'->'", "'=>'", "'/*+'", "'*/'", "'?'" + ]; + + public static readonly symbolicNames = [ + null, "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT", + "LEFT_BRACKET", "RIGHT_BRACKET", "KW_ADD", "KW_AFTER", "KW_ALL", + "KW_ALTER", "KW_ALWAYS", "KW_ANALYZE", "KW_AND", "KW_ANTI", "KW_ANY", + "KW_ANY_VALUE", "KW_ARCHIVE", "KW_ARRAY", "KW_AS", "KW_ASC", "KW_AT", + "KW_AUTHORIZATION", "KW_BETWEEN", "KW_BIGINT", "KW_BINARY", "KW_BOOLEAN", + "KW_BOTH", "KW_BUCKET", "KW_BUCKETS", "KW_BY", "KW_BYTE", "KW_CACHE", + "KW_CASCADE", "KW_CASE", "KW_CAST", "KW_CATALOG", "KW_CATALOGS", + "KW_CHANGE", "KW_CHAR", "KW_CHARACTER", "KW_CHECK", "KW_CLEAR", + "KW_CLUSTER", "KW_CLUSTERED", "KW_CODEGEN", "KW_COLLATE", "KW_COLLECTION", + "KW_COLUMN", "KW_COLUMNS", "KW_COMMENT", "KW_COMMIT", "KW_COMPACT", + "KW_COMPACTIONS", "KW_COMPUTE", "KW_CONCATENATE", "KW_CONSTRAINT", + "KW_COST", "KW_CREATE", "KW_CROSS", "KW_CUBE", "KW_CURRENT", "KW_CURRENT_DATE", + "KW_CURRENT_TIME", "KW_CURRENT_TIMESTAMP", "KW_CURRENT_USER", "KW_DAY", + "KW_DAYS", "KW_DAYOFYEAR", "KW_DATA", "KW_DATE", "KW_DATABASE", + "KW_DATABASES", "KW_DATEADD", "KW_DATE_ADD", "KW_DATEDIFF", "KW_DATE_DIFF", + "KW_DBPROPERTIES", "KW_DEC", "KW_DECIMAL", "KW_DECLARE", "KW_DEFAULT", + "KW_DEFINED", "KW_DELETE", "KW_DELIMITED", "KW_DESC", "KW_DESCRIBE", + "KW_DFS", "KW_DIRECTORIES", "KW_DIRECTORY", "KW_DISABLE", "KW_DISTINCT", + "KW_DISTRIBUTE", "KW_DIV", "KW_DOUBLE", "KW_DROP", "KW_ELSE", "KW_ENABLE", + "KW_END", "KW_ESCAPE", "KW_ESCAPED", "KW_EXCEPT", "KW_EXCHANGE", + "KW_EXCLUDE", "KW_EXISTS", "KW_EXPLAIN", "KW_EXPORT", "KW_EXTENDED", + "KW_EXTERNAL", "KW_EXTRACT", "KW_FALSE", "KW_FETCH", "KW_FIELDS", + "KW_FILTER", "KW_FILEFORMAT", "KW_FIRST", "KW_FLOAT", "KW_FOLLOWING", + "KW_FOR", "KW_FOREIGN", "KW_FORMAT", "KW_FORMATTED", "KW_FROM", + "KW_FULL", "KW_FUNCTION", "KW_FUNCTIONS", "KW_GENERATED", "KW_GLOBAL", + "KW_GRANT", "KW_GROUP", "KW_GROUPING", "KW_HAVING", "KW_BINARY_HEX", + "KW_HOUR", "KW_HOURS", "KW_IDENTIFIER", "KW_IF", "KW_IGNORE", "KW_IMPORT", + "KW_IN", "KW_INCLUDE", "KW_INDEX", "KW_INDEXES", "KW_INNER", "KW_INPATH", + "KW_INPUTFORMAT", "KW_INSERT", "KW_INTERSECT", "KW_INTERVAL", "KW_INT", + "KW_INTEGER", "KW_INTO", "KW_IS", "KW_ITEMS", "KW_JOIN", "KW_KEYS", + "KW_LAST", "KW_LATERAL", "KW_LAZY", "KW_LEADING", "KW_LEFT", "KW_LIFECYCLE", + "KW_LIKE", "KW_ILIKE", "KW_LIMIT", "KW_LINES", "KW_LIST", "KW_LOAD", + "KW_LOCAL", "KW_LOCATION", "KW_LOCK", "KW_LOCKS", "KW_LOGICAL", + "KW_LONG", "KW_MACRO", "KW_MAP", "KW_MATCHED", "KW_MERGE", "KW_MICROSECOND", + "KW_MICROSECONDS", "KW_MILLISECOND", "KW_MILLISECONDS", "KW_MINUTE", + "KW_MINUTES", "KW_MONTH", "KW_MONTHS", "KW_MSCK", "KW_NAME", "KW_NAMESPACE", + "KW_NAMESPACES", "KW_NANOSECOND", "KW_NANOSECONDS", "KW_NATURAL", + "KW_NO", "KW_NOSCAN", "KW_NOT", "KW_NULL", "KW_NULLS", "KW_NUMERIC", + "KW_OF", "KW_OFFSET", "KW_ON", "KW_ONLY", "KW_OPTIMIZE", "KW_OPTION", + "KW_OPTIONS", "KW_OR", "KW_ORDER", "KW_OUT", "KW_OUTER", "KW_OUTPUTFORMAT", + "KW_OVER", "KW_OVERLAPS", "KW_OVERLAY", "KW_OVERWRITE", "KW_PARTITION", + "KW_PARTITIONED", "KW_PARTITIONS", "KW_PERCENTILE_CONT", "KW_PERCENTILE_DISC", + "KW_PERCENTLIT", "KW_PIVOT", "KW_PLACING", "KW_POSITION", "KW_PRECEDING", + "KW_PRIMARY", "KW_PRINCIPALS", "KW_PROPERTIES", "KW_PURGE", "KW_QUARTER", + "KW_QUERY", "KW_RANGE", "KW_REAL", "KW_RECORDREADER", "KW_RECORDWRITER", + "KW_RECOVER", "KW_REDUCE", "KW_REFERENCES", "KW_REFRESH", "KW_RENAME", + "KW_REPAIR", "KW_REPEATABLE", "KW_REPLACE", "KW_RESET", "KW_RESPECT", + "KW_RESTRICT", "KW_REWRITE", "KW_REVOKE", "KW_RIGHT", "KW_RLIKE", + "KW_REGEXP", "KW_ROLE", "KW_ROLES", "KW_ROLLBACK", "KW_ROLLUP", + "KW_ROW", "KW_ROWS", "KW_SECOND", "KW_SECONDS", "KW_SCHEMA", "KW_SCHEMAS", + "KW_SELECT", "KW_SEMI", "KW_SEPARATED", "KW_SERDE", "KW_SERDEPROPERTIES", + "KW_SESSION_USER", "KW_SET", "KW_MINUS", "KW_SETS", "KW_SHORT", + "KW_SHOW", "KW_SINGLE", "KW_SKEWED", "KW_SMALLINT", "KW_SOME", "KW_SORT", + "KW_SORTED", "KW_SOURCE", "KW_START", "KW_STATISTICS", "KW_STORED", + "KW_STRATIFY", "KW_STRING", "KW_STRUCT", "KW_SUBSTR", "KW_SUBSTRING", + "KW_SYNC", "KW_SYSTEM", "KW_SYSTEM_TIME", "KW_SYSTEM_VERSION", "KW_TABLE", + "KW_TABLES", "KW_TABLESAMPLE", "KW_TARGET", "KW_TBLPROPERTIES", + "KW_TEMPORARY", "KW_TERMINATED", "KW_THEN", "KW_TIME", "KW_TIMEDIFF", + "KW_TIMESTAMP", "KW_TIMESTAMP_LTZ", "KW_TIMESTAMP_NTZ", "KW_TIMESTAMPADD", + "KW_TIMESTAMPDIFF", "KW_TINYINT", "KW_TO", "KW_TOUCH", "KW_TRAILING", + "KW_TRANSACTION", "KW_TRANSACTIONS", "KW_TRANSFORM", "KW_TRIM", + "KW_TRUE", "KW_TRUNCATE", "KW_TRY_CAST", "KW_TYPE", "KW_UNARCHIVE", + "KW_UNBOUNDED", "KW_UNCACHE", "KW_UNION", "KW_UNIQUE", "KW_UNKNOWN", + "KW_UNLOCK", "KW_UNPIVOT", "KW_UNSET", "KW_UPDATE", "KW_USE", "KW_USER", + "KW_USING", "KW_VALUES", "KW_VARCHAR", "KW_VAR", "KW_VARIABLE", + "KW_VERSION", "KW_VIEW", "KW_VIEWS", "KW_VOID", "KW_WEEK", "KW_WEEKS", + "KW_WHEN", "KW_WHERE", "KW_WINDOW", "KW_WITH", "KW_WITHIN", "KW_YEAR", + "KW_YEARS", "KW_ZONE", "KW_ZORDER", "EQ", "NSEQ", "NEQ", "NEQJ", + "LT", "LTE", "GT", "GTE", "NOT", "PLUS", "MINUS", "ASTERISK", "SLASH", + "PERCENT", "TILDE", "AMPERSAND", "PIPE", "CONCAT_PIPE", "HAT", "COLON", + "ARROW", "FAT_ARROW", "HENT_START", "HENT_END", "QUESTION", "STRING_LITERAL", + "DOUBLEQUOTED_STRING", "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", + "INTEGER_VALUE", "EXPONENT_VALUE", "DECIMAL_VALUE", "FLOAT_LITERAL", + "DOUBLE_LITERAL", "BIGDECIMAL_LITERAL", "IDENTIFIER", "BACKQUOTED_IDENTIFIER", + "SIMPLE_COMMENT", "BRACKETED_COMMENT", "WS", "UNRECOGNIZED" + ]; + public static readonly ruleNames = [ + "program", "singleStatement", "statement", "alterStatement", "createStatement", + "dropStatement", "dmlStatementNoWith", "insertInto", "showStatement", + "unsupportedCommands", "bucketSpec", "skewSpec", "query", "partitionSpecLocation", + "partitionSpec", "partitionVal", "namespace", "describeFuncName", + "describeColName", "ctes", "namedQuery", "tableProvider", "createTableClauses", + "tableLifecycle", "propertyList", "property", "propertyKey", "propertyValue", + "expressionPropertyList", "expressionProperty", "constantList", + "nestedConstantList", "createFileFormat", "fileFormat", "storageHandler", + "namespaceName", "namespaceNameCreate", "tableNameCreate", "tableName", + "viewNameCreate", "viewName", "columnName", "columnNameSeq", "columnNameCreate", + "identifierReference", "queryOrganization", "queryTerm", "queryPrimary", + "sortItem", "fromStatementBody", "querySpecification", "transformClause", + "selectClause", "setClause", "matchedClause", "notMatchedClause", + "notMatchedBySourceClause", "notMatchedAction", "assignmentList", + "assignment", "whereClause", "havingClause", "hint", "hintStatement", + "fromClause", "temporalClause", "aggregationClause", "groupByClause", + "groupingAnalytics", "groupingSet", "pivotClause", "pivotColumn", + "pivotValue", "unpivotClause", "unpivotSingleValueColumnClause", + "unpivotMultiValueColumnClause", "unpivotColumnSet", "unpivotColumnAndAlias", + "ifNotExists", "ifExists", "lateralView", "setQuantifier", "relation", + "joinRelation", "joinType", "joinCriteria", "sample", "sampleMethod", + "identifierList", "identifierSeq", "orderedIdentifierList", "orderedIdentifier", + "identifierCommentList", "identifierComment", "relationPrimary", + "functionTableSubqueryArgument", "tableArgumentPartitioning", "functionTableNamedArgumentExpression", + "functionTableReferenceArgument", "functionTableArgument", "tableAlias", + "rowFormat", "multipartIdentifierList", "multipartIdentifier", "multipartIdentifierPropertyList", + "multipartIdentifierProperty", "tableIdentifier", "viewIdentifier", + "namedExpression", "namedExpressionSeq", "partitionFieldList", "partitionField", + "transform", "transformArgument", "expression", "namedArgumentExpression", + "functionArgument", "expressionSeq", "booleanExpression", "predicate", + "valueExpression", "datetimeUnit", "primaryExpression", "literalType", + "constant", "comparisonOperator", "arithmeticOperator", "predicateOperator", + "booleanValue", "interval", "errorCapturingMultiUnitsInterval", + "errorCapturingUnitToUnitInterval", "multiUnitsInterval", "unitToUnitInterval", + "intervalValue", "unitInMultiUnits", "unitInUnitToUnit", "colPosition", + "type", "dataType", "qualifiedColTypeWithPositionSeqForAdd", "qualifiedColTypeWithPositionForAdd", + "qualifiedColTypeWithPositionSeqForReplace", "qualifiedColTypeWithPositionForReplace", + "colDefinitionDescriptorWithPosition", "variableDefaultExpression", + "colTypeList", "columnType", "createOrReplaceTableColTypeList", + "createOrReplaceTableColType", "colDefinitionOption", "complexColType", + "whenClause", "windowClause", "windowSpec", "windowFrame", "frameBound", + "qualifiedNameList", "functionName", "functionNameCreate", "qualifiedName", + "errorCapturingIdentifier", "errorCapturingIdentifierExtra", "identifier", + "strictIdentifier", "number", "alterColumnAction", "stringLit", + "ansiNonReserved", "strictNonReserved", "nonReserved", + ]; + + public get grammarFileName(): string { return "SqlParser.g4"; } + public get literalNames(): (string | null)[] { return SqlParser.literalNames; } + public get symbolicNames(): (string | null)[] { return SqlParser.symbolicNames; } + public get ruleNames(): string[] { return SqlParser.ruleNames; } + public get serializedATN(): number[] { return SqlParser._serializedATN; } + + protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException { + return new antlr.FailedPredicateException(this, predicate, message); + } + + public constructor(input: antlr.TokenStream) { + super(input); + this.interpreter = new antlr.ParserATNSimulator(this, SqlParser._ATN, SqlParser.decisionsToDFA, new antlr.PredictionContextCache()); + } + public program(): ProgramContext { + let localContext = new ProgramContext(this.context, this.state); + this.enterRule(localContext, 0, SqlParser.RULE_program); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 345; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 10500) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 67896321) !== 0) || ((((_la - 81)) & ~0x1F) === 0 && ((1 << (_la - 81)) & 100696297) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 16842817) !== 0) || ((((_la - 167)) & ~0x1F) === 0 && ((1 << (_la - 167)) & 1051155) !== 0) || _la === 204 || ((((_la - 237)) & ~0x1F) === 0 && ((1 << (_la - 237)) & 2181171413) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & 1048833) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & 536949281) !== 0)) { + { + { + this.state = 342; + this.singleStatement(); + } + } + this.state = 347; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 348; + this.match(SqlParser.EOF); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public singleStatement(): SingleStatementContext { + let localContext = new SingleStatementContext(this.context, this.state); + this.enterRule(localContext, 2, SqlParser.RULE_singleStatement); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 350; + this.statement(); + this.state = 352; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 1) { + { + this.state = 351; + this.match(SqlParser.SEMICOLON); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public statement(): StatementContext { + let localContext = new StatementContext(this.context, this.state); + this.enterRule(localContext, 4, SqlParser.RULE_statement); + let _la: number; + try { + let alternative: number; + this.state = 571; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 40, this.context) ) { + case 1: + localContext = new StatementDefaultContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 354; + this.query(); + } + break; + case 2: + localContext = new DmlStatementContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 356; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 345) { + { + this.state = 355; + this.ctes(); + } + } + + this.state = 358; + this.dmlStatementNoWith(); + } + break; + case 3: + localContext = new UseNamespaceContext(localContext); + this.enterOuterAlt(localContext, 3); + { + this.state = 359; + this.match(SqlParser.KW_USE); + this.state = 361; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) { + case 1: + { + this.state = 360; + this.namespace(); + } + break; + } + this.state = 363; + this.namespaceName(); + } + break; + case 4: + localContext = new AlterContext(localContext); + this.enterOuterAlt(localContext, 4); + { + this.state = 364; + this.alterStatement(); + } + break; + case 5: + localContext = new CreateContext(localContext); + this.enterOuterAlt(localContext, 5); + { + this.state = 365; + this.createStatement(); + } + break; + case 6: + localContext = new DropContext(localContext); + this.enterOuterAlt(localContext, 6); + { + this.state = 366; + this.dropStatement(); + } + break; + case 7: + localContext = new ShowContext(localContext); + this.enterOuterAlt(localContext, 7); + { + this.state = 367; + this.showStatement(); + } + break; + case 8: + localContext = new TruncateTableContext(localContext); + this.enterOuterAlt(localContext, 8); + { + this.state = 368; + this.match(SqlParser.KW_TRUNCATE); + this.state = 369; + this.match(SqlParser.KW_TABLE); + this.state = 370; + this.tableName(); + this.state = 372; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 371; + this.partitionSpec(); + } + } + + } + break; + case 9: + localContext = new AnalyzeContext(localContext); + this.enterOuterAlt(localContext, 9); + { + this.state = 374; + this.match(SqlParser.KW_ANALYZE); + this.state = 375; + this.match(SqlParser.KW_TABLE); + this.state = 376; + this.tableName(); + this.state = 378; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 377; + this.partitionSpec(); + } + } + + this.state = 380; + this.match(SqlParser.KW_COMPUTE); + this.state = 381; + this.match(SqlParser.KW_STATISTICS); + this.state = 389; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 6, this.context) ) { + case 1: + { + this.state = 382; + this.match(SqlParser.KW_NOSCAN); + } + break; + case 2: + { + this.state = 383; + this.match(SqlParser.KW_FOR); + this.state = 384; + this.match(SqlParser.KW_COLUMNS); + this.state = 385; + this.columnNameSeq(); + } + break; + case 3: + { + this.state = 386; + this.match(SqlParser.KW_FOR); + this.state = 387; + this.match(SqlParser.KW_ALL); + this.state = 388; + this.match(SqlParser.KW_COLUMNS); + } + break; + } + } + break; + case 10: + localContext = new AnalyzeTablesContext(localContext); + this.enterOuterAlt(localContext, 10); + { + this.state = 391; + this.match(SqlParser.KW_ANALYZE); + this.state = 392; + this.match(SqlParser.KW_TABLES); + this.state = 395; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 123 || _la === 140) { + { + this.state = 393; + _la = this.tokenStream.LA(1); + if(!(_la === 123 || _la === 140)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 394; + this.namespaceName(); + } + } + + this.state = 397; + this.match(SqlParser.KW_COMPUTE); + this.state = 398; + this.match(SqlParser.KW_STATISTICS); + this.state = 400; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 195) { + { + this.state = 399; + this.match(SqlParser.KW_NOSCAN); + } + } + + } + break; + case 11: + localContext = new DeclareVariableContext(localContext); + this.enterOuterAlt(localContext, 11); + { + this.state = 402; + this.match(SqlParser.KW_DECLARE); + this.state = 405; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 9, this.context) ) { + case 1: + { + this.state = 403; + this.match(SqlParser.KW_OR); + this.state = 404; + this.match(SqlParser.KW_REPLACE); + } + break; + } + this.state = 408; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 10, this.context) ) { + case 1: + { + this.state = 407; + this.match(SqlParser.KW_VARIABLE); + } + break; + } + this.state = 410; + this.functionName(); + this.state = 412; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 11, this.context) ) { + case 1: + { + this.state = 411; + this.dataType(); + } + break; + } + this.state = 415; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 82 || _la === 351) { + { + this.state = 414; + this.variableDefaultExpression(); + } + } + + } + break; + case 12: + localContext = new ExplainStatementContext(localContext); + this.enterOuterAlt(localContext, 12); + { + this.state = 417; + this.match(SqlParser.KW_EXPLAIN); + this.state = 419; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 46 || _la === 58 || _la === 108 || _la === 122 || _la === 173) { + { + this.state = 418; + _la = this.tokenStream.LA(1); + if(!(_la === 46 || _la === 58 || _la === 108 || _la === 122 || _la === 173)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 421; + this.statement(); + } + break; + case 13: + localContext = new DescribeFunctionContext(localContext); + this.enterOuterAlt(localContext, 13); + { + this.state = 422; + _la = this.tokenStream.LA(1); + if(!(_la === 86 || _la === 87)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 423; + this.match(SqlParser.KW_FUNCTION); + this.state = 425; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 14, this.context) ) { + case 1: + { + this.state = 424; + this.match(SqlParser.KW_EXTENDED); + } + break; + } + this.state = 427; + this.describeFuncName(); + } + break; + case 14: + localContext = new DescribeNamespaceContext(localContext); + this.enterOuterAlt(localContext, 14); + { + this.state = 428; + _la = this.tokenStream.LA(1); + if(!(_la === 86 || _la === 87)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 429; + this.match(SqlParser.KW_DATABASE); + this.state = 431; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 15, this.context) ) { + case 1: + { + this.state = 430; + this.match(SqlParser.KW_EXTENDED); + } + break; + } + this.state = 433; + this.namespaceName(); + } + break; + case 15: + localContext = new DescribeQueryContext(localContext); + this.enterOuterAlt(localContext, 15); + { + this.state = 434; + _la = this.tokenStream.LA(1); + if(!(_la === 86 || _la === 87)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 436; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 231) { + { + this.state = 435; + this.match(SqlParser.KW_QUERY); + } + } + + this.state = 438; + this.query(); + } + break; + case 16: + localContext = new DescribeRelationContext(localContext); + this.enterOuterAlt(localContext, 16); + { + this.state = 439; + _la = this.tokenStream.LA(1); + if(!(_la === 86 || _la === 87)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 441; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 292) { + { + this.state = 440; + this.match(SqlParser.KW_TABLE); + } + } + + this.state = 444; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 18, this.context) ) { + case 1: + { + this.state = 443; + (localContext as DescribeRelationContext)._option = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 108 || _la === 122)) { + (localContext as DescribeRelationContext)._option = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + this.state = 446; + this.tableName(); + this.state = 448; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 19, this.context) ) { + case 1: + { + this.state = 447; + this.partitionSpec(); + } + break; + } + this.state = 451; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 20, this.context) ) { + case 1: + { + this.state = 450; + this.describeColName(); + } + break; + } + } + break; + case 17: + localContext = new CommentNamespaceContext(localContext); + this.enterOuterAlt(localContext, 17); + { + this.state = 453; + this.match(SqlParser.KW_COMMENT); + this.state = 454; + this.match(SqlParser.KW_ON); + this.state = 460; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_DATABASE: + case SqlParser.KW_NAMESPACE: + case SqlParser.KW_SCHEMA: + { + { + this.state = 455; + this.namespace(); + this.state = 456; + this.namespaceName(); + } + } + break; + case SqlParser.KW_TABLE: + { + { + this.state = 458; + this.match(SqlParser.KW_TABLE); + this.state = 459; + this.tableName(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 462; + this.match(SqlParser.KW_IS); + this.state = 465; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.STRING_LITERAL: + case SqlParser.DOUBLEQUOTED_STRING: + { + this.state = 463; + this.stringLit(); + } + break; + case SqlParser.KW_NULL: + { + this.state = 464; + this.match(SqlParser.KW_NULL); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case 18: + localContext = new RefreshTableContext(localContext); + this.enterOuterAlt(localContext, 18); + { + this.state = 467; + this.match(SqlParser.KW_REFRESH); + this.state = 468; + this.match(SqlParser.KW_TABLE); + this.state = 469; + this.tableName(); + } + break; + case 19: + localContext = new RefreshFunctionContext(localContext); + this.enterOuterAlt(localContext, 19); + { + this.state = 470; + this.match(SqlParser.KW_REFRESH); + this.state = 471; + this.match(SqlParser.KW_FUNCTION); + this.state = 472; + this.functionName(); + } + break; + case 20: + localContext = new RefreshResourceContext(localContext); + this.enterOuterAlt(localContext, 20); + { + this.state = 473; + this.match(SqlParser.KW_REFRESH); + this.state = 481; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 24, this.context) ) { + case 1: + { + this.state = 474; + this.stringLit(); + } + break; + case 2: + { + this.state = 478; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 23, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 475; + this.matchWildcard(); + } + } + } + this.state = 480; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 23, this.context); + } + } + break; + } + } + break; + case 21: + localContext = new CacheTableContext(localContext); + this.enterOuterAlt(localContext, 21); + { + this.state = 483; + this.match(SqlParser.KW_CACHE); + this.state = 485; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 159) { + { + this.state = 484; + this.match(SqlParser.KW_LAZY); + } + } + + this.state = 487; + this.match(SqlParser.KW_TABLE); + this.state = 488; + this.tableName(); + this.state = 491; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 206) { + { + this.state = 489; + this.match(SqlParser.KW_OPTIONS); + this.state = 490; + (localContext as CacheTableContext)._options = this.propertyList(); + } + } + + this.state = 497; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 28, this.context) ) { + case 1: + { + this.state = 494; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 20) { + { + this.state = 493; + this.match(SqlParser.KW_AS); + } + } + + this.state = 496; + this.query(); + } + break; + } + } + break; + case 22: + localContext = new UnCacheTableContext(localContext); + this.enterOuterAlt(localContext, 22); + { + this.state = 499; + this.match(SqlParser.KW_UNCACHE); + this.state = 500; + this.match(SqlParser.KW_TABLE); + this.state = 502; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 29, this.context) ) { + case 1: + { + this.state = 501; + this.ifExists(); + } + break; + } + this.state = 504; + this.tableName(); + } + break; + case 23: + localContext = new ClearCacheContext(localContext); + this.enterOuterAlt(localContext, 23); + { + this.state = 505; + this.match(SqlParser.KW_CLEAR); + this.state = 506; + this.match(SqlParser.KW_CACHE); + } + break; + case 24: + localContext = new LoadDataContext(localContext); + this.enterOuterAlt(localContext, 24); + { + this.state = 507; + this.match(SqlParser.KW_LOAD); + this.state = 508; + this.match(SqlParser.KW_DATA); + this.state = 510; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 169) { + { + this.state = 509; + this.match(SqlParser.KW_LOCAL); + } + } + + this.state = 512; + this.match(SqlParser.KW_INPATH); + this.state = 513; + (localContext as LoadDataContext)._path = this.stringLit(); + this.state = 515; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 215) { + { + this.state = 514; + this.match(SqlParser.KW_OVERWRITE); + } + } + + this.state = 517; + this.match(SqlParser.KW_INTO); + this.state = 518; + this.match(SqlParser.KW_TABLE); + this.state = 519; + this.tableName(); + this.state = 521; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 520; + this.partitionSpec(); + } + } + + } + break; + case 25: + localContext = new RepairTableContext(localContext); + this.enterOuterAlt(localContext, 25); + { + this.state = 524; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 187) { + { + this.state = 523; + this.match(SqlParser.KW_MSCK); + } + } + + this.state = 526; + this.match(SqlParser.KW_REPAIR); + this.state = 527; + this.match(SqlParser.KW_TABLE); + this.state = 528; + this.tableName(); + this.state = 531; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 34, this.context) ) { + case 1: + { + this.state = 529; + (localContext as RepairTableContext)._option = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 8 || _la === 96 || _la === 288)) { + (localContext as RepairTableContext)._option = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 530; + this.match(SqlParser.KW_PARTITIONS); + } + break; + } + } + break; + case 26: + localContext = new ManageResourceContext(localContext); + this.enterOuterAlt(localContext, 26); + { + this.state = 533; + (localContext as ManageResourceContext)._op = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 8 || _la === 167)) { + (localContext as ManageResourceContext)._op = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 534; + this.identifier(); + this.state = 538; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 35, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 535; + this.matchWildcard(); + } + } + } + this.state = 540; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 35, this.context); + } + } + break; + case 27: + localContext = new SetAnyContext(localContext); + this.enterOuterAlt(localContext, 27); + { + this.state = 541; + this.match(SqlParser.KW_SET); + this.state = 545; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 36, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 542; + this.matchWildcard(); + } + } + } + this.state = 547; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 36, this.context); + } + } + break; + case 28: + localContext = new ResetAnyContext(localContext); + this.enterOuterAlt(localContext, 28); + { + this.state = 548; + this.match(SqlParser.KW_RESET); + this.state = 552; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 37, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 549; + this.matchWildcard(); + } + } + } + this.state = 554; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 37, this.context); + } + } + break; + case 29: + localContext = new OptimizeTableContext(localContext); + this.enterOuterAlt(localContext, 29); + { + this.state = 555; + this.match(SqlParser.KW_OPTIMIZE); + this.state = 556; + this.tableName(); + this.state = 558; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 343) { + { + this.state = 557; + this.whereClause(); + } + } + + this.state = 560; + this.match(SqlParser.KW_ZORDER); + this.state = 561; + this.match(SqlParser.KW_BY); + this.state = 562; + this.columnNameSeq(); + } + break; + case 30: + localContext = new UnsupportHiveCommandsContext(localContext); + this.enterOuterAlt(localContext, 30); + { + this.state = 564; + this.unsupportedCommands(); + this.state = 568; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 39, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 565; + this.matchWildcard(); + } + } + } + this.state = 570; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 39, this.context); + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public alterStatement(): AlterStatementContext { + let localContext = new AlterStatementContext(this.context, this.state); + this.enterRule(localContext, 6, SqlParser.RULE_alterStatement); + let _la: number; + try { + let alternative: number; + this.state = 895; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 96, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 573; + this.match(SqlParser.KW_ALTER); + this.state = 574; + this.namespace(); + this.state = 575; + this.namespaceName(); + this.state = 576; + this.match(SqlParser.KW_SET); + this.state = 581; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_DBPROPERTIES: + case SqlParser.KW_PROPERTIES: + { + { + this.state = 577; + _la = this.tokenStream.LA(1); + if(!(_la === 78 || _la === 228)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 578; + this.propertyList(); + } + } + break; + case SqlParser.KW_LOCATION: + { + this.state = 579; + this.match(SqlParser.KW_LOCATION); + this.state = 580; + this.stringLit(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 583; + this.match(SqlParser.KW_ALTER); + this.state = 584; + this.match(SqlParser.KW_TABLE); + this.state = 585; + this.tableName(); + this.state = 586; + this.match(SqlParser.KW_ADD); + this.state = 587; + _la = this.tokenStream.LA(1); + if(!(_la === 49 || _la === 50)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 589; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 588; + this.match(SqlParser.LEFT_PAREN); + } + } + + this.state = 593; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 43, this.context) ) { + case 1: + { + this.state = 591; + this.qualifiedColTypeWithPositionForAdd(); + } + break; + case 2: + { + this.state = 592; + this.qualifiedColTypeWithPositionSeqForAdd(); + } + break; + } + this.state = 596; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 3) { + { + this.state = 595; + this.match(SqlParser.RIGHT_PAREN); + } + } + + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 598; + this.match(SqlParser.KW_ALTER); + this.state = 599; + this.match(SqlParser.KW_TABLE); + this.state = 600; + this.tableName(); + this.state = 601; + this.match(SqlParser.KW_DROP); + this.state = 602; + _la = this.tokenStream.LA(1); + if(!(_la === 49 || _la === 50)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 604; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 45, this.context) ) { + case 1: + { + this.state = 603; + this.ifExists(); + } + break; + } + this.state = 607; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 46, this.context) ) { + case 1: + { + this.state = 606; + this.match(SqlParser.LEFT_PAREN); + } + break; + } + this.state = 611; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 47, this.context) ) { + case 1: + { + this.state = 609; + this.columnName(); + } + break; + case 2: + { + this.state = 610; + this.columnNameSeq(); + } + break; + } + this.state = 614; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 3) { + { + this.state = 613; + this.match(SqlParser.RIGHT_PAREN); + } + } + + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 616; + this.match(SqlParser.KW_ALTER); + this.state = 621; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_TABLE: + { + this.state = 617; + this.match(SqlParser.KW_TABLE); + this.state = 618; + this.tableName(); + } + break; + case SqlParser.KW_VIEW: + { + this.state = 619; + this.match(SqlParser.KW_VIEW); + this.state = 620; + this.viewName(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 623; + this.match(SqlParser.KW_RENAME); + this.state = 626; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 49) { + { + this.state = 624; + this.match(SqlParser.KW_COLUMN); + this.state = 625; + this.columnName(); + } + } + + this.state = 628; + this.match(SqlParser.KW_TO); + this.state = 631; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 51, this.context) ) { + case 1: + { + this.state = 629; + this.columnNameCreate(); + } + break; + case 2: + { + this.state = 630; + this.multipartIdentifier(); + } + break; + } + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 633; + this.match(SqlParser.KW_ALTER); + this.state = 638; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_TABLE: + { + this.state = 634; + this.match(SqlParser.KW_TABLE); + this.state = 635; + this.tableName(); + } + break; + case SqlParser.KW_VIEW: + { + this.state = 636; + this.match(SqlParser.KW_VIEW); + this.state = 637; + this.viewName(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 640; + _la = this.tokenStream.LA(1); + if(!(_la === 268 || _la === 327)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 641; + this.match(SqlParser.KW_TBLPROPERTIES); + this.state = 643; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 137) { + { + this.state = 642; + this.ifExists(); + } + } + + this.state = 645; + this.propertyList(); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 647; + this.match(SqlParser.KW_ALTER); + this.state = 648; + this.match(SqlParser.KW_TABLE); + this.state = 649; + localContext._table = this.tableName(); + this.state = 650; + _la = this.tokenStream.LA(1); + if(!(_la === 11 || _la === 39)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 652; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 54, this.context) ) { + case 1: + { + this.state = 651; + this.match(SqlParser.KW_COLUMN); + } + break; + } + this.state = 654; + localContext._column = this.columnName(); + this.state = 656; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 55, this.context) ) { + case 1: + { + this.state = 655; + this.alterColumnAction(); + } + break; + } + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 658; + this.match(SqlParser.KW_ALTER); + this.state = 659; + this.match(SqlParser.KW_TABLE); + this.state = 660; + localContext._table = this.tableName(); + this.state = 662; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 661; + this.partitionSpec(); + } + } + + this.state = 670; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_CHANGE: + { + { + this.state = 664; + this.match(SqlParser.KW_CHANGE); + this.state = 666; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 57, this.context) ) { + case 1: + { + this.state = 665; + this.match(SqlParser.KW_COLUMN); + } + break; + } + } + } + break; + case SqlParser.KW_REPLACE: + { + { + this.state = 668; + this.match(SqlParser.KW_REPLACE); + this.state = 669; + this.match(SqlParser.KW_COLUMNS); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 681; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 60, this.context) ) { + case 1: + { + { + this.state = 672; + localContext._colName = this.columnName(); + this.state = 673; + this.columnType(); + this.state = 675; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 9 || _la === 116) { + { + this.state = 674; + this.colPosition(); + } + } + + } + } + break; + case 2: + { + { + this.state = 677; + this.match(SqlParser.LEFT_PAREN); + this.state = 678; + this.qualifiedColTypeWithPositionSeqForReplace(); + this.state = 679; + this.match(SqlParser.RIGHT_PAREN); + } + } + break; + } + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 683; + this.match(SqlParser.KW_ALTER); + this.state = 688; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_TABLE: + { + this.state = 684; + this.match(SqlParser.KW_TABLE); + this.state = 685; + this.tableName(); + } + break; + case SqlParser.KW_VIEW: + { + this.state = 686; + this.match(SqlParser.KW_VIEW); + this.state = 687; + this.viewName(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 690; + _la = this.tokenStream.LA(1); + if(!(_la === 8 || _la === 96)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 693; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 62, this.context) ) { + case 1: + { + this.state = 691; + this.ifNotExists(); + } + break; + case 2: + { + this.state = 692; + this.ifExists(); + } + break; + } + this.state = 701; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 64, this.context) ) { + case 1: + { + this.state = 696; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 695; + this.partitionSpecLocation(); + } + } + this.state = 698; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 216); + } + break; + case 2: + { + this.state = 700; + this.partitionSpec(); + } + break; + } + this.state = 707; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 703; + this.match(SqlParser.COMMA); + this.state = 704; + this.partitionSpec(); + } + } + this.state = 709; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 711; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 229) { + { + this.state = 710; + this.match(SqlParser.KW_PURGE); + } + } + + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 713; + this.match(SqlParser.KW_ALTER); + this.state = 714; + this.match(SqlParser.KW_VIEW); + this.state = 715; + this.viewName(); + this.state = 717; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 20) { + { + this.state = 716; + this.match(SqlParser.KW_AS); + } + } + + this.state = 719; + this.query(); + } + break; + case 10: + this.enterOuterAlt(localContext, 10); + { + this.state = 721; + this.match(SqlParser.KW_ALTER); + this.state = 722; + this.match(SqlParser.KW_TABLE); + this.state = 723; + this.tableName(); + this.state = 725; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 724; + this.partitionSpec(); + } + } + + this.state = 727; + this.match(SqlParser.KW_CHANGE); + this.state = 729; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 69, this.context) ) { + case 1: + { + this.state = 728; + this.match(SqlParser.KW_COLUMN); + } + break; + } + this.state = 731; + this.columnName(); + this.state = 732; + this.columnType(); + this.state = 734; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 9 || _la === 116) { + { + this.state = 733; + this.colPosition(); + } + } + + } + break; + case 11: + this.enterOuterAlt(localContext, 11); + { + this.state = 736; + this.match(SqlParser.KW_ALTER); + this.state = 737; + this.match(SqlParser.KW_TABLE); + this.state = 738; + this.tableName(); + this.state = 740; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 739; + this.partitionSpec(); + } + } + + this.state = 742; + this.match(SqlParser.KW_REPLACE); + this.state = 743; + this.match(SqlParser.KW_COLUMNS); + this.state = 744; + this.match(SqlParser.LEFT_PAREN); + this.state = 745; + this.qualifiedColTypeWithPositionSeqForReplace(); + this.state = 746; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 12: + this.enterOuterAlt(localContext, 12); + { + this.state = 748; + this.match(SqlParser.KW_ALTER); + this.state = 749; + this.match(SqlParser.KW_TABLE); + this.state = 750; + this.tableName(); + this.state = 752; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 751; + this.partitionSpec(); + } + } + + this.state = 754; + this.match(SqlParser.KW_SET); + this.state = 757; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 170) { + { + this.state = 755; + this.match(SqlParser.KW_LOCATION); + this.state = 756; + this.stringLit(); + } + } + + this.state = 760; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 265) { + { + this.state = 759; + this.match(SqlParser.KW_SERDE); + } + } + + this.state = 763; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 376 || _la === 377) { + { + this.state = 762; + this.stringLit(); + } + } + + this.state = 766; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 76, this.context) ) { + case 1: + { + this.state = 765; + this.match(SqlParser.KW_WITH); + } + break; + } + this.state = 769; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 266) { + { + this.state = 768; + this.match(SqlParser.KW_SERDEPROPERTIES); + } + } + + this.state = 772; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 78, this.context) ) { + case 1: + { + this.state = 771; + this.propertyList(); + } + break; + } + } + break; + case 13: + this.enterOuterAlt(localContext, 13); + { + this.state = 774; + this.match(SqlParser.KW_ALTER); + this.state = 775; + this.match(SqlParser.KW_TABLE); + this.state = 776; + this.tableName(); + this.state = 777; + this.partitionSpec(); + this.state = 778; + this.match(SqlParser.KW_RENAME); + this.state = 779; + this.match(SqlParser.KW_TO); + this.state = 780; + this.partitionSpec(); + } + break; + case 14: + this.enterOuterAlt(localContext, 14); + { + this.state = 782; + this.match(SqlParser.KW_ALTER); + this.state = 787; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_TABLE: + { + this.state = 783; + this.match(SqlParser.KW_TABLE); + this.state = 784; + this.tableName(); + } + break; + case SqlParser.KW_VIEW: + { + this.state = 785; + this.match(SqlParser.KW_VIEW); + this.state = 786; + this.viewName(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 789; + this.match(SqlParser.KW_ADD); + this.state = 791; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 137) { + { + this.state = 790; + this.ifNotExists(); + } + } + + this.state = 793; + this.partitionSpecLocation(); + } + break; + case 15: + this.enterOuterAlt(localContext, 15); + { + this.state = 795; + this.match(SqlParser.KW_ALTER); + this.state = 800; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_TABLE: + { + this.state = 796; + this.match(SqlParser.KW_TABLE); + this.state = 797; + this.tableName(); + } + break; + case SqlParser.KW_VIEW: + { + this.state = 798; + this.match(SqlParser.KW_VIEW); + this.state = 799; + this.viewName(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 802; + this.match(SqlParser.KW_DROP); + this.state = 804; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 137) { + { + this.state = 803; + this.ifExists(); + } + } + + this.state = 806; + this.partitionSpec(); + this.state = 811; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 807; + this.match(SqlParser.COMMA); + this.state = 808; + this.partitionSpec(); + } + } + this.state = 813; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 815; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 229) { + { + this.state = 814; + this.match(SqlParser.KW_PURGE); + } + } + + } + break; + case 16: + this.enterOuterAlt(localContext, 16); + { + this.state = 817; + this.match(SqlParser.KW_ALTER); + this.state = 818; + this.match(SqlParser.KW_TABLE); + this.state = 819; + this.tableName(); + this.state = 820; + this.match(SqlParser.KW_RECOVER); + this.state = 821; + this.match(SqlParser.KW_PARTITIONS); + } + break; + case 17: + this.enterOuterAlt(localContext, 17); + { + this.state = 823; + this.match(SqlParser.KW_ALTER); + this.state = 824; + this.match(SqlParser.KW_INDEX); + this.state = 828; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 85, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 825; + this.matchWildcard(); + } + } + } + this.state = 830; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 85, this.context); + } + } + break; + case 18: + this.enterOuterAlt(localContext, 18); + { + this.state = 831; + this.match(SqlParser.KW_ALTER); + this.state = 832; + this.match(SqlParser.KW_TABLE); + this.state = 833; + this.tableName(); + this.state = 834; + _la = this.tokenStream.LA(1); + if(!(_la === 45 || _la === 274 || _la === 309)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 836; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 86, this.context) ) { + case 1: + { + this.state = 835; + this.match(SqlParser.KW_BY); + } + break; + } + this.state = 841; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 87, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 838; + this.matchWildcard(); + } + } + } + this.state = 843; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 87, this.context); + } + } + break; + case 19: + this.enterOuterAlt(localContext, 19); + { + this.state = 844; + this.match(SqlParser.KW_ALTER); + this.state = 845; + this.match(SqlParser.KW_TABLE); + this.state = 846; + this.tableName(); + this.state = 847; + _la = this.tokenStream.LA(1); + if(!(_la === 196 || _la === 268)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 848; + _la = this.tokenStream.LA(1); + if(!(_la === 45 || ((((_la - 274)) & ~0x1F) === 0 && ((1 << (_la - 274)) & 273) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 850; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 88, this.context) ) { + case 1: + { + this.state = 849; + this.match(SqlParser.KW_LOCATION); + } + break; + } + this.state = 853; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 89, this.context) ) { + case 1: + { + this.state = 852; + this.match(SqlParser.KW_AS); + } + break; + } + this.state = 856; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 90, this.context) ) { + case 1: + { + this.state = 855; + this.match(SqlParser.KW_DIRECTORIES); + } + break; + } + this.state = 861; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 91, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 858; + this.matchWildcard(); + } + } + } + this.state = 863; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 91, this.context); + } + } + break; + case 20: + this.enterOuterAlt(localContext, 20); + { + this.state = 864; + this.match(SqlParser.KW_ALTER); + this.state = 865; + this.match(SqlParser.KW_TABLE); + this.state = 866; + this.tableName(); + this.state = 867; + _la = this.tokenStream.LA(1); + if(!(_la === 18 || _la === 103 || _la === 319)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 868; + this.match(SqlParser.KW_PARTITION); + this.state = 872; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 92, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 869; + this.matchWildcard(); + } + } + } + this.state = 874; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 92, this.context); + } + } + break; + case 21: + this.enterOuterAlt(localContext, 21); + { + this.state = 875; + this.match(SqlParser.KW_ALTER); + this.state = 876; + this.match(SqlParser.KW_TABLE); + this.state = 877; + this.tableName(); + this.state = 879; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 878; + this.partitionSpec(); + } + } + + this.state = 887; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_COMPACT: + { + this.state = 881; + this.match(SqlParser.KW_COMPACT); + } + break; + case SqlParser.KW_CONCATENATE: + { + this.state = 882; + this.match(SqlParser.KW_CONCATENATE); + } + break; + case SqlParser.KW_SET: + { + { + this.state = 883; + this.match(SqlParser.KW_SET); + this.state = 884; + this.match(SqlParser.KW_FILEFORMAT); + } + } + break; + case SqlParser.KW_REPLACE: + { + { + this.state = 885; + this.match(SqlParser.KW_REPLACE); + this.state = 886; + this.match(SqlParser.KW_COLUMNS); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 892; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 95, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 889; + this.matchWildcard(); + } + } + } + this.state = 894; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 95, this.context); + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createStatement(): CreateStatementContext { + let localContext = new CreateStatementContext(this.context, this.state); + this.enterRule(localContext, 8, SqlParser.RULE_createStatement); + let _la: number; + try { + let alternative: number; + this.state = 1108; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 137, this.context) ) { + case 1: + localContext = new CreateNamespaceContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 897; + this.match(SqlParser.KW_CREATE); + this.state = 898; + this.namespace(); + this.state = 900; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 97, this.context) ) { + case 1: + { + this.state = 899; + this.ifNotExists(); + } + break; + } + this.state = 902; + this.namespaceNameCreate(); + this.state = 912; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 99, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + this.state = 910; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_COMMENT: + { + { + this.state = 903; + this.match(SqlParser.KW_COMMENT); + this.state = 904; + (localContext as CreateNamespaceContext)._comment = this.stringLit(); + } + } + break; + case SqlParser.KW_LOCATION: + { + { + this.state = 905; + this.match(SqlParser.KW_LOCATION); + this.state = 906; + this.stringLit(); + } + } + break; + case SqlParser.KW_WITH: + { + { + this.state = 907; + this.match(SqlParser.KW_WITH); + this.state = 908; + _la = this.tokenStream.LA(1); + if(!(_la === 78 || _la === 228)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 909; + this.propertyList(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + this.state = 914; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 99, this.context); + } + } + break; + case 2: + localContext = new CreateTableContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 915; + this.match(SqlParser.KW_CREATE); + this.state = 917; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 297) { + { + this.state = 916; + this.match(SqlParser.KW_TEMPORARY); + } + } + + this.state = 920; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 109) { + { + this.state = 919; + this.match(SqlParser.KW_EXTERNAL); + } + } + + this.state = 922; + this.match(SqlParser.KW_TABLE); + this.state = 924; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 102, this.context) ) { + case 1: + { + this.state = 923; + this.ifNotExists(); + } + break; + } + this.state = 926; + this.tableNameCreate(); + this.state = 931; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 103, this.context) ) { + case 1: + { + this.state = 927; + this.match(SqlParser.LEFT_PAREN); + this.state = 928; + this.createOrReplaceTableColTypeList(); + this.state = 929; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + this.state = 934; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 331) { + { + this.state = 933; + this.tableProvider(); + } + } + + this.state = 936; + this.createTableClauses(); + this.state = 941; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 106, this.context) ) { + case 1: + { + this.state = 938; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 20) { + { + this.state = 937; + this.match(SqlParser.KW_AS); + } + } + + this.state = 940; + this.query(); + } + break; + } + } + break; + case 3: + localContext = new ReplaceTableContext(localContext); + this.enterOuterAlt(localContext, 3); + { + this.state = 945; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 59) { + { + this.state = 943; + this.match(SqlParser.KW_CREATE); + this.state = 944; + this.match(SqlParser.KW_OR); + } + } + + this.state = 947; + this.match(SqlParser.KW_REPLACE); + this.state = 948; + this.match(SqlParser.KW_TABLE); + this.state = 949; + this.tableNameCreate(); + this.state = 954; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 108, this.context) ) { + case 1: + { + this.state = 950; + this.match(SqlParser.LEFT_PAREN); + this.state = 951; + this.createOrReplaceTableColTypeList(); + this.state = 952; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + this.state = 957; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 331) { + { + this.state = 956; + this.tableProvider(); + } + } + + this.state = 959; + this.createTableClauses(); + this.state = 964; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 111, this.context) ) { + case 1: + { + this.state = 961; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 20) { + { + this.state = 960; + this.match(SqlParser.KW_AS); + } + } + + this.state = 963; + this.query(); + } + break; + } + } + break; + case 4: + localContext = new CreateTableLikeContext(localContext); + this.enterOuterAlt(localContext, 4); + { + this.state = 966; + this.match(SqlParser.KW_CREATE); + this.state = 967; + this.match(SqlParser.KW_TABLE); + this.state = 969; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 112, this.context) ) { + case 1: + { + this.state = 968; + this.ifNotExists(); + } + break; + } + this.state = 971; + (localContext as CreateTableLikeContext)._target = this.tableNameCreate(); + this.state = 972; + this.match(SqlParser.KW_LIKE); + this.state = 973; + (localContext as CreateTableLikeContext)._source = this.tableName(); + this.state = 984; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 162 || _la === 170 || _la === 256 || _la === 282 || _la === 296 || _la === 331) { + { + this.state = 982; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_USING: + { + this.state = 974; + this.tableProvider(); + } + break; + case SqlParser.KW_ROW: + { + this.state = 975; + this.rowFormat(); + } + break; + case SqlParser.KW_STORED: + { + this.state = 976; + this.createFileFormat(); + } + break; + case SqlParser.KW_LOCATION: + { + { + this.state = 977; + this.match(SqlParser.KW_LOCATION); + this.state = 978; + this.stringLit(); + } + } + break; + case SqlParser.KW_TBLPROPERTIES: + { + { + this.state = 979; + this.match(SqlParser.KW_TBLPROPERTIES); + this.state = 980; + (localContext as CreateTableLikeContext)._tableProps = this.propertyList(); + } + } + break; + case SqlParser.KW_LIFECYCLE: + { + this.state = 981; + this.tableLifecycle(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + this.state = 986; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; + case 5: + localContext = new CreateViewContext(localContext); + this.enterOuterAlt(localContext, 5); + { + this.state = 987; + this.match(SqlParser.KW_CREATE); + this.state = 990; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 207) { + { + this.state = 988; + this.match(SqlParser.KW_OR); + this.state = 989; + this.match(SqlParser.KW_REPLACE); + } + } + + this.state = 996; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 128 || _la === 297) { + { + this.state = 993; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 128) { + { + this.state = 992; + this.match(SqlParser.KW_GLOBAL); + } + } + + this.state = 995; + this.match(SqlParser.KW_TEMPORARY); + } + } + + this.state = 998; + this.match(SqlParser.KW_VIEW); + this.state = 1000; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 118, this.context) ) { + case 1: + { + this.state = 999; + this.ifNotExists(); + } + break; + } + this.state = 1002; + this.viewNameCreate(); + this.state = 1004; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 1003; + this.identifierCommentList(); + } + } + + this.state = 1015; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 51 || _la === 217 || _la === 296) { + { + this.state = 1013; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_COMMENT: + { + { + this.state = 1006; + this.match(SqlParser.KW_COMMENT); + this.state = 1007; + (localContext as CreateViewContext)._comment = this.stringLit(); + } + } + break; + case SqlParser.KW_PARTITIONED: + { + { + this.state = 1008; + this.match(SqlParser.KW_PARTITIONED); + this.state = 1009; + this.match(SqlParser.KW_ON); + this.state = 1010; + this.identifierList(); + } + } + break; + case SqlParser.KW_TBLPROPERTIES: + { + { + this.state = 1011; + this.match(SqlParser.KW_TBLPROPERTIES); + this.state = 1012; + this.propertyList(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + this.state = 1017; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1018; + this.match(SqlParser.KW_AS); + this.state = 1019; + this.query(); + } + break; + case 6: + localContext = new CreateTempViewUsingContext(localContext); + this.enterOuterAlt(localContext, 6); + { + this.state = 1021; + this.match(SqlParser.KW_CREATE); + this.state = 1024; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 207) { + { + this.state = 1022; + this.match(SqlParser.KW_OR); + this.state = 1023; + this.match(SqlParser.KW_REPLACE); + } + } + + this.state = 1027; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 128) { + { + this.state = 1026; + this.match(SqlParser.KW_GLOBAL); + } + } + + this.state = 1029; + this.match(SqlParser.KW_TEMPORARY); + this.state = 1030; + this.match(SqlParser.KW_VIEW); + this.state = 1031; + this.viewNameCreate(); + this.state = 1036; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 1032; + this.match(SqlParser.LEFT_PAREN); + this.state = 1033; + this.colTypeList(); + this.state = 1034; + this.match(SqlParser.RIGHT_PAREN); + } + } + + this.state = 1038; + this.tableProvider(); + this.state = 1041; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 206) { + { + this.state = 1039; + this.match(SqlParser.KW_OPTIONS); + this.state = 1040; + this.propertyList(); + } + } + + } + break; + case 7: + localContext = new CreateFunctionContext(localContext); + this.enterOuterAlt(localContext, 7); + { + this.state = 1043; + this.match(SqlParser.KW_CREATE); + this.state = 1046; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 207) { + { + this.state = 1044; + this.match(SqlParser.KW_OR); + this.state = 1045; + this.match(SqlParser.KW_REPLACE); + } + } + + this.state = 1049; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 297) { + { + this.state = 1048; + this.match(SqlParser.KW_TEMPORARY); + } + } + + this.state = 1051; + this.match(SqlParser.KW_FUNCTION); + this.state = 1053; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 128, this.context) ) { + case 1: + { + this.state = 1052; + this.ifNotExists(); + } + break; + } + this.state = 1055; + this.functionNameCreate(); + this.state = 1056; + this.match(SqlParser.KW_AS); + this.state = 1057; + (localContext as CreateFunctionContext)._className = this.stringLit(); + this.state = 1071; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 331) { + { + this.state = 1058; + this.match(SqlParser.KW_USING); + { + this.state = 1059; + this.identifier(); + this.state = 1060; + this.stringLit(); + } + this.state = 1068; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 1062; + this.match(SqlParser.COMMA); + { + this.state = 1063; + this.identifier(); + this.state = 1064; + this.stringLit(); + } + } + } + this.state = 1070; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + + } + break; + case 8: + localContext = new CreateIndexContext(localContext); + this.enterOuterAlt(localContext, 8); + { + this.state = 1073; + this.match(SqlParser.KW_CREATE); + this.state = 1074; + this.match(SqlParser.KW_INDEX); + this.state = 1076; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 131, this.context) ) { + case 1: + { + this.state = 1075; + this.ifNotExists(); + } + break; + } + this.state = 1078; + this.identifier(); + this.state = 1079; + this.match(SqlParser.KW_ON); + this.state = 1081; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 292) { + { + this.state = 1080; + this.match(SqlParser.KW_TABLE); + } + } + + this.state = 1083; + this.tableName(); + this.state = 1086; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 331) { + { + this.state = 1084; + this.match(SqlParser.KW_USING); + this.state = 1085; + (localContext as CreateIndexContext)._indexType = this.identifier(); + } + } + + this.state = 1088; + this.match(SqlParser.LEFT_PAREN); + this.state = 1089; + this.multipartIdentifierPropertyList(); + this.state = 1090; + this.match(SqlParser.RIGHT_PAREN); + this.state = 1093; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 206) { + { + this.state = 1091; + this.match(SqlParser.KW_OPTIONS); + this.state = 1092; + (localContext as CreateIndexContext)._options = this.propertyList(); + } + } + + } + break; + case 9: + localContext = new CreateRoleContext(localContext); + this.enterOuterAlt(localContext, 9); + { + this.state = 1095; + this.match(SqlParser.KW_CREATE); + this.state = 1100; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_ROLE: + { + this.state = 1096; + this.match(SqlParser.KW_ROLE); + } + break; + case SqlParser.KW_INDEX: + { + this.state = 1097; + this.match(SqlParser.KW_INDEX); + } + break; + case SqlParser.KW_TEMPORARY: + { + { + this.state = 1098; + this.match(SqlParser.KW_TEMPORARY); + this.state = 1099; + this.match(SqlParser.KW_MACRO); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 1105; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 136, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 1102; + this.matchWildcard(); + } + } + } + this.state = 1107; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 136, this.context); + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public dropStatement(): DropStatementContext { + let localContext = new DropStatementContext(this.context, this.state); + this.enterRule(localContext, 10, SqlParser.RULE_dropStatement); + let _la: number; + try { + let alternative: number; + this.state = 1177; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 151, this.context) ) { + case 1: + localContext = new DropNamespaceContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 1110; + this.match(SqlParser.KW_DROP); + this.state = 1111; + this.namespace(); + this.state = 1113; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 138, this.context) ) { + case 1: + { + this.state = 1112; + this.ifExists(); + } + break; + } + this.state = 1115; + this.namespaceName(); + this.state = 1117; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 34 || _la === 246) { + { + this.state = 1116; + _la = this.tokenStream.LA(1); + if(!(_la === 34 || _la === 246)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + } + break; + case 2: + localContext = new DropTableContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 1119; + this.match(SqlParser.KW_DROP); + this.state = 1120; + this.match(SqlParser.KW_TABLE); + this.state = 1122; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 140, this.context) ) { + case 1: + { + this.state = 1121; + this.ifExists(); + } + break; + } + this.state = 1124; + this.tableName(); + this.state = 1126; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 229) { + { + this.state = 1125; + this.match(SqlParser.KW_PURGE); + } + } + + } + break; + case 3: + localContext = new DropViewContext(localContext); + this.enterOuterAlt(localContext, 3); + { + this.state = 1128; + this.match(SqlParser.KW_DROP); + this.state = 1129; + this.match(SqlParser.KW_VIEW); + this.state = 1131; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 142, this.context) ) { + case 1: + { + this.state = 1130; + this.ifExists(); + } + break; + } + this.state = 1133; + this.viewName(); + } + break; + case 4: + localContext = new DropFunctionContext(localContext); + this.enterOuterAlt(localContext, 4); + { + this.state = 1134; + this.match(SqlParser.KW_DROP); + this.state = 1136; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 297) { + { + this.state = 1135; + this.match(SqlParser.KW_TEMPORARY); + } + } + + this.state = 1138; + this.match(SqlParser.KW_FUNCTION); + this.state = 1140; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 144, this.context) ) { + case 1: + { + this.state = 1139; + this.ifExists(); + } + break; + } + this.state = 1142; + this.functionName(); + } + break; + case 5: + localContext = new DropVariableContext(localContext); + this.enterOuterAlt(localContext, 5); + { + this.state = 1143; + this.match(SqlParser.KW_DROP); + this.state = 1144; + this.match(SqlParser.KW_TEMPORARY); + this.state = 1145; + this.match(SqlParser.KW_VARIABLE); + this.state = 1147; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 145, this.context) ) { + case 1: + { + this.state = 1146; + this.ifExists(); + } + break; + } + this.state = 1152; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 146, this.context) ) { + case 1: + { + this.state = 1149; + this.tableName(); + } + break; + case 2: + { + this.state = 1150; + this.viewName(); + } + break; + case 3: + { + this.state = 1151; + this.functionName(); + } + break; + } + } + break; + case 6: + localContext = new DropIndexContext(localContext); + this.enterOuterAlt(localContext, 6); + { + this.state = 1154; + this.match(SqlParser.KW_DROP); + this.state = 1155; + this.match(SqlParser.KW_INDEX); + this.state = 1157; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 147, this.context) ) { + case 1: + { + this.state = 1156; + this.ifExists(); + } + break; + } + this.state = 1159; + this.identifier(); + this.state = 1160; + this.match(SqlParser.KW_ON); + this.state = 1162; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 292) { + { + this.state = 1161; + this.match(SqlParser.KW_TABLE); + } + } + + this.state = 1164; + this.tableName(); + } + break; + case 7: + localContext = new DropRoleContext(localContext); + this.enterOuterAlt(localContext, 7); + { + this.state = 1166; + this.match(SqlParser.KW_DROP); + this.state = 1167; + _la = this.tokenStream.LA(1); + if(!(_la === 142 || _la === 252 || _la === 297)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1169; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 149, this.context) ) { + case 1: + { + this.state = 1168; + this.match(SqlParser.KW_MACRO); + } + break; + } + this.state = 1174; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 150, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 1171; + this.matchWildcard(); + } + } + } + this.state = 1176; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 150, this.context); + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public dmlStatementNoWith(): DmlStatementNoWithContext { + let localContext = new DmlStatementNoWithContext(this.context, this.state); + this.enterRule(localContext, 12, SqlParser.RULE_dmlStatementNoWith); + let _la: number; + try { + let alternative: number; + this.state = 1237; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_INSERT: + localContext = new InsertFromQueryContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 1179; + this.insertInto(); + this.state = 1180; + this.query(); + } + break; + case SqlParser.KW_FROM: + localContext = new MultipleInsertContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 1182; + this.fromClause(); + this.state = 1186; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 1183; + this.insertInto(); + this.state = 1184; + this.fromStatementBody(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 1188; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 152, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } + break; + case SqlParser.KW_DELETE: + localContext = new DeleteFromTableContext(localContext); + this.enterOuterAlt(localContext, 3); + { + this.state = 1190; + this.match(SqlParser.KW_DELETE); + this.state = 1191; + this.match(SqlParser.KW_FROM); + this.state = 1192; + this.tableName(); + this.state = 1193; + this.tableAlias(); + this.state = 1195; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 343) { + { + this.state = 1194; + this.whereClause(); + } + } + + } + break; + case SqlParser.KW_UPDATE: + localContext = new UpdateTableContext(localContext); + this.enterOuterAlt(localContext, 4); + { + this.state = 1197; + this.match(SqlParser.KW_UPDATE); + this.state = 1198; + this.tableName(); + this.state = 1199; + this.tableAlias(); + this.state = 1200; + this.setClause(); + this.state = 1202; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 343) { + { + this.state = 1201; + this.whereClause(); + } + } + + } + break; + case SqlParser.KW_MERGE: + localContext = new MergeIntoTableContext(localContext); + this.enterOuterAlt(localContext, 5); + { + this.state = 1204; + this.match(SqlParser.KW_MERGE); + this.state = 1205; + this.match(SqlParser.KW_INTO); + this.state = 1206; + (localContext as MergeIntoTableContext)._target = this.tableName(); + this.state = 1207; + (localContext as MergeIntoTableContext)._targetAlias = this.tableAlias(); + this.state = 1208; + this.match(SqlParser.KW_USING); + this.state = 1214; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_ADD: + case SqlParser.KW_AFTER: + case SqlParser.KW_ALL: + case SqlParser.KW_ALTER: + case SqlParser.KW_ALWAYS: + case SqlParser.KW_ANALYZE: + case SqlParser.KW_AND: + case SqlParser.KW_ANTI: + case SqlParser.KW_ANY: + case SqlParser.KW_ANY_VALUE: + case SqlParser.KW_ARCHIVE: + case SqlParser.KW_ARRAY: + case SqlParser.KW_AS: + case SqlParser.KW_ASC: + case SqlParser.KW_AT: + case SqlParser.KW_AUTHORIZATION: + case SqlParser.KW_BETWEEN: + case SqlParser.KW_BIGINT: + case SqlParser.KW_BINARY: + case SqlParser.KW_BOOLEAN: + case SqlParser.KW_BOTH: + case SqlParser.KW_BUCKET: + case SqlParser.KW_BUCKETS: + case SqlParser.KW_BY: + case SqlParser.KW_BYTE: + case SqlParser.KW_CACHE: + case SqlParser.KW_CASCADE: + case SqlParser.KW_CASE: + case SqlParser.KW_CAST: + case SqlParser.KW_CATALOG: + case SqlParser.KW_CATALOGS: + case SqlParser.KW_CHANGE: + case SqlParser.KW_CHAR: + case SqlParser.KW_CHARACTER: + case SqlParser.KW_CHECK: + case SqlParser.KW_CLEAR: + case SqlParser.KW_CLUSTER: + case SqlParser.KW_CLUSTERED: + case SqlParser.KW_CODEGEN: + case SqlParser.KW_COLLATE: + case SqlParser.KW_COLLECTION: + case SqlParser.KW_COLUMN: + case SqlParser.KW_COLUMNS: + case SqlParser.KW_COMMENT: + case SqlParser.KW_COMMIT: + case SqlParser.KW_COMPACT: + case SqlParser.KW_COMPACTIONS: + case SqlParser.KW_COMPUTE: + case SqlParser.KW_CONCATENATE: + case SqlParser.KW_CONSTRAINT: + case SqlParser.KW_COST: + case SqlParser.KW_CREATE: + case SqlParser.KW_CROSS: + case SqlParser.KW_CUBE: + case SqlParser.KW_CURRENT: + case SqlParser.KW_CURRENT_DATE: + case SqlParser.KW_CURRENT_TIME: + case SqlParser.KW_CURRENT_TIMESTAMP: + case SqlParser.KW_CURRENT_USER: + case SqlParser.KW_DAY: + case SqlParser.KW_DAYS: + case SqlParser.KW_DAYOFYEAR: + case SqlParser.KW_DATA: + case SqlParser.KW_DATE: + case SqlParser.KW_DATABASE: + case SqlParser.KW_DATABASES: + case SqlParser.KW_DATEADD: + case SqlParser.KW_DATE_ADD: + case SqlParser.KW_DATEDIFF: + case SqlParser.KW_DATE_DIFF: + case SqlParser.KW_DBPROPERTIES: + case SqlParser.KW_DEC: + case SqlParser.KW_DECIMAL: + case SqlParser.KW_DECLARE: + case SqlParser.KW_DEFAULT: + case SqlParser.KW_DEFINED: + case SqlParser.KW_DELETE: + case SqlParser.KW_DELIMITED: + case SqlParser.KW_DESC: + case SqlParser.KW_DESCRIBE: + case SqlParser.KW_DFS: + case SqlParser.KW_DIRECTORIES: + case SqlParser.KW_DIRECTORY: + case SqlParser.KW_DISABLE: + case SqlParser.KW_DISTINCT: + case SqlParser.KW_DISTRIBUTE: + case SqlParser.KW_DIV: + case SqlParser.KW_DOUBLE: + case SqlParser.KW_DROP: + case SqlParser.KW_ELSE: + case SqlParser.KW_ENABLE: + case SqlParser.KW_END: + case SqlParser.KW_ESCAPE: + case SqlParser.KW_ESCAPED: + case SqlParser.KW_EXCEPT: + case SqlParser.KW_EXCHANGE: + case SqlParser.KW_EXCLUDE: + case SqlParser.KW_EXISTS: + case SqlParser.KW_EXPLAIN: + case SqlParser.KW_EXPORT: + case SqlParser.KW_EXTENDED: + case SqlParser.KW_EXTERNAL: + case SqlParser.KW_EXTRACT: + case SqlParser.KW_FALSE: + case SqlParser.KW_FETCH: + case SqlParser.KW_FIELDS: + case SqlParser.KW_FILTER: + case SqlParser.KW_FILEFORMAT: + case SqlParser.KW_FIRST: + case SqlParser.KW_FLOAT: + case SqlParser.KW_FOLLOWING: + case SqlParser.KW_FOR: + case SqlParser.KW_FOREIGN: + case SqlParser.KW_FORMAT: + case SqlParser.KW_FORMATTED: + case SqlParser.KW_FULL: + case SqlParser.KW_FUNCTION: + case SqlParser.KW_FUNCTIONS: + case SqlParser.KW_GENERATED: + case SqlParser.KW_GLOBAL: + case SqlParser.KW_GRANT: + case SqlParser.KW_GROUP: + case SqlParser.KW_GROUPING: + case SqlParser.KW_HAVING: + case SqlParser.KW_BINARY_HEX: + case SqlParser.KW_HOUR: + case SqlParser.KW_HOURS: + case SqlParser.KW_IDENTIFIER: + case SqlParser.KW_IF: + case SqlParser.KW_IGNORE: + case SqlParser.KW_IMPORT: + case SqlParser.KW_IN: + case SqlParser.KW_INCLUDE: + case SqlParser.KW_INDEX: + case SqlParser.KW_INDEXES: + case SqlParser.KW_INNER: + case SqlParser.KW_INPATH: + case SqlParser.KW_INPUTFORMAT: + case SqlParser.KW_INSERT: + case SqlParser.KW_INTERSECT: + case SqlParser.KW_INTERVAL: + case SqlParser.KW_INT: + case SqlParser.KW_INTEGER: + case SqlParser.KW_INTO: + case SqlParser.KW_IS: + case SqlParser.KW_ITEMS: + case SqlParser.KW_JOIN: + case SqlParser.KW_KEYS: + case SqlParser.KW_LAST: + case SqlParser.KW_LATERAL: + case SqlParser.KW_LAZY: + case SqlParser.KW_LEADING: + case SqlParser.KW_LEFT: + case SqlParser.KW_LIFECYCLE: + case SqlParser.KW_LIKE: + case SqlParser.KW_ILIKE: + case SqlParser.KW_LIMIT: + case SqlParser.KW_LINES: + case SqlParser.KW_LIST: + case SqlParser.KW_LOAD: + case SqlParser.KW_LOCAL: + case SqlParser.KW_LOCATION: + case SqlParser.KW_LOCK: + case SqlParser.KW_LOCKS: + case SqlParser.KW_LOGICAL: + case SqlParser.KW_LONG: + case SqlParser.KW_MACRO: + case SqlParser.KW_MAP: + case SqlParser.KW_MATCHED: + case SqlParser.KW_MERGE: + case SqlParser.KW_MICROSECOND: + case SqlParser.KW_MICROSECONDS: + case SqlParser.KW_MILLISECOND: + case SqlParser.KW_MILLISECONDS: + case SqlParser.KW_MINUTE: + case SqlParser.KW_MINUTES: + case SqlParser.KW_MONTH: + case SqlParser.KW_MONTHS: + case SqlParser.KW_MSCK: + case SqlParser.KW_NAME: + case SqlParser.KW_NAMESPACE: + case SqlParser.KW_NAMESPACES: + case SqlParser.KW_NANOSECOND: + case SqlParser.KW_NANOSECONDS: + case SqlParser.KW_NATURAL: + case SqlParser.KW_NO: + case SqlParser.KW_NOT: + case SqlParser.KW_NULL: + case SqlParser.KW_NULLS: + case SqlParser.KW_NUMERIC: + case SqlParser.KW_OF: + case SqlParser.KW_OFFSET: + case SqlParser.KW_ON: + case SqlParser.KW_ONLY: + case SqlParser.KW_OPTIMIZE: + case SqlParser.KW_OPTION: + case SqlParser.KW_OPTIONS: + case SqlParser.KW_OR: + case SqlParser.KW_ORDER: + case SqlParser.KW_OUT: + case SqlParser.KW_OUTER: + case SqlParser.KW_OUTPUTFORMAT: + case SqlParser.KW_OVER: + case SqlParser.KW_OVERLAPS: + case SqlParser.KW_OVERLAY: + case SqlParser.KW_OVERWRITE: + case SqlParser.KW_PARTITION: + case SqlParser.KW_PARTITIONED: + case SqlParser.KW_PARTITIONS: + case SqlParser.KW_PERCENTILE_CONT: + case SqlParser.KW_PERCENTILE_DISC: + case SqlParser.KW_PERCENTLIT: + case SqlParser.KW_PIVOT: + case SqlParser.KW_PLACING: + case SqlParser.KW_POSITION: + case SqlParser.KW_PRECEDING: + case SqlParser.KW_PRIMARY: + case SqlParser.KW_PRINCIPALS: + case SqlParser.KW_PROPERTIES: + case SqlParser.KW_PURGE: + case SqlParser.KW_QUARTER: + case SqlParser.KW_QUERY: + case SqlParser.KW_RANGE: + case SqlParser.KW_REAL: + case SqlParser.KW_RECORDREADER: + case SqlParser.KW_RECORDWRITER: + case SqlParser.KW_RECOVER: + case SqlParser.KW_REDUCE: + case SqlParser.KW_REFERENCES: + case SqlParser.KW_REFRESH: + case SqlParser.KW_RENAME: + case SqlParser.KW_REPAIR: + case SqlParser.KW_REPEATABLE: + case SqlParser.KW_REPLACE: + case SqlParser.KW_RESET: + case SqlParser.KW_RESPECT: + case SqlParser.KW_RESTRICT: + case SqlParser.KW_REWRITE: + case SqlParser.KW_REVOKE: + case SqlParser.KW_RIGHT: + case SqlParser.KW_RLIKE: + case SqlParser.KW_REGEXP: + case SqlParser.KW_ROLE: + case SqlParser.KW_ROLES: + case SqlParser.KW_ROLLBACK: + case SqlParser.KW_ROLLUP: + case SqlParser.KW_ROW: + case SqlParser.KW_ROWS: + case SqlParser.KW_SECOND: + case SqlParser.KW_SECONDS: + case SqlParser.KW_SCHEMA: + case SqlParser.KW_SCHEMAS: + case SqlParser.KW_SEMI: + case SqlParser.KW_SEPARATED: + case SqlParser.KW_SERDE: + case SqlParser.KW_SERDEPROPERTIES: + case SqlParser.KW_SESSION_USER: + case SqlParser.KW_SET: + case SqlParser.KW_MINUS: + case SqlParser.KW_SETS: + case SqlParser.KW_SHORT: + case SqlParser.KW_SHOW: + case SqlParser.KW_SINGLE: + case SqlParser.KW_SKEWED: + case SqlParser.KW_SMALLINT: + case SqlParser.KW_SOME: + case SqlParser.KW_SORT: + case SqlParser.KW_SORTED: + case SqlParser.KW_SOURCE: + case SqlParser.KW_START: + case SqlParser.KW_STATISTICS: + case SqlParser.KW_STORED: + case SqlParser.KW_STRATIFY: + case SqlParser.KW_STRING: + case SqlParser.KW_STRUCT: + case SqlParser.KW_SUBSTR: + case SqlParser.KW_SUBSTRING: + case SqlParser.KW_SYNC: + case SqlParser.KW_SYSTEM: + case SqlParser.KW_SYSTEM_TIME: + case SqlParser.KW_SYSTEM_VERSION: + case SqlParser.KW_TABLES: + case SqlParser.KW_TABLESAMPLE: + case SqlParser.KW_TARGET: + case SqlParser.KW_TBLPROPERTIES: + case SqlParser.KW_TEMPORARY: + case SqlParser.KW_TERMINATED: + case SqlParser.KW_THEN: + case SqlParser.KW_TIME: + case SqlParser.KW_TIMEDIFF: + case SqlParser.KW_TIMESTAMP: + case SqlParser.KW_TIMESTAMP_LTZ: + case SqlParser.KW_TIMESTAMP_NTZ: + case SqlParser.KW_TIMESTAMPADD: + case SqlParser.KW_TIMESTAMPDIFF: + case SqlParser.KW_TINYINT: + case SqlParser.KW_TO: + case SqlParser.KW_TOUCH: + case SqlParser.KW_TRAILING: + case SqlParser.KW_TRANSACTION: + case SqlParser.KW_TRANSACTIONS: + case SqlParser.KW_TRANSFORM: + case SqlParser.KW_TRIM: + case SqlParser.KW_TRUE: + case SqlParser.KW_TRUNCATE: + case SqlParser.KW_TRY_CAST: + case SqlParser.KW_TYPE: + case SqlParser.KW_UNARCHIVE: + case SqlParser.KW_UNBOUNDED: + case SqlParser.KW_UNCACHE: + case SqlParser.KW_UNION: + case SqlParser.KW_UNIQUE: + case SqlParser.KW_UNKNOWN: + case SqlParser.KW_UNLOCK: + case SqlParser.KW_UNPIVOT: + case SqlParser.KW_UNSET: + case SqlParser.KW_UPDATE: + case SqlParser.KW_USE: + case SqlParser.KW_USER: + case SqlParser.KW_USING: + case SqlParser.KW_VALUES: + case SqlParser.KW_VARCHAR: + case SqlParser.KW_VAR: + case SqlParser.KW_VARIABLE: + case SqlParser.KW_VERSION: + case SqlParser.KW_VIEW: + case SqlParser.KW_VIEWS: + case SqlParser.KW_VOID: + case SqlParser.KW_WEEK: + case SqlParser.KW_WEEKS: + case SqlParser.KW_WHEN: + case SqlParser.KW_WHERE: + case SqlParser.KW_WINDOW: + case SqlParser.KW_WITH: + case SqlParser.KW_WITHIN: + case SqlParser.KW_YEAR: + case SqlParser.KW_YEARS: + case SqlParser.KW_ZONE: + case SqlParser.KW_ZORDER: + case SqlParser.DOUBLEQUOTED_STRING: + case SqlParser.IDENTIFIER: + case SqlParser.BACKQUOTED_IDENTIFIER: + { + this.state = 1209; + (localContext as MergeIntoTableContext)._source = this.identifierReference(); + } + break; + case SqlParser.LEFT_PAREN: + { + this.state = 1210; + this.match(SqlParser.LEFT_PAREN); + this.state = 1211; + (localContext as MergeIntoTableContext)._sourceQuery = this.query(); + this.state = 1212; + this.match(SqlParser.RIGHT_PAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 1216; + (localContext as MergeIntoTableContext)._sourceAlias = this.tableAlias(); + this.state = 1217; + this.match(SqlParser.KW_ON); + this.state = 1218; + (localContext as MergeIntoTableContext)._mergeCondition = this.booleanExpression(0); + this.state = 1222; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 156, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1219; + this.matchedClause(); + } + } + } + this.state = 1224; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 156, this.context); + } + this.state = 1228; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 157, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1225; + this.notMatchedClause(); + } + } + } + this.state = 1230; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 157, this.context); + } + this.state = 1234; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 342) { + { + { + this.state = 1231; + this.notMatchedBySourceClause(); + } + } + this.state = 1236; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public insertInto(): InsertIntoContext { + let localContext = new InsertIntoContext(this.context, this.state); + this.enterRule(localContext, 14, SqlParser.RULE_insertInto); + let _la: number; + try { + this.state = 1310; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 175, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1239; + this.match(SqlParser.KW_INSERT); + this.state = 1240; + this.match(SqlParser.KW_INTO); + this.state = 1242; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 292) { + { + this.state = 1241; + this.match(SqlParser.KW_TABLE); + } + } + + this.state = 1244; + this.tableName(); + this.state = 1246; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 1245; + this.partitionSpec(); + } + } + + this.state = 1249; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 137) { + { + this.state = 1248; + this.ifNotExists(); + } + } + + this.state = 1257; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 163, this.context) ) { + case 1: + { + { + this.state = 1251; + this.match(SqlParser.KW_BY); + this.state = 1252; + this.match(SqlParser.KW_NAME); + } + } + break; + case 2: + { + { + this.state = 1253; + this.match(SqlParser.LEFT_PAREN); + this.state = 1254; + this.columnNameSeq(); + this.state = 1255; + this.match(SqlParser.RIGHT_PAREN); + } + } + break; + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1259; + this.match(SqlParser.KW_INSERT); + this.state = 1260; + this.match(SqlParser.KW_INTO); + this.state = 1262; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 292) { + { + this.state = 1261; + this.match(SqlParser.KW_TABLE); + } + } + + this.state = 1264; + this.tableName(); + this.state = 1265; + this.match(SqlParser.KW_REPLACE); + this.state = 1266; + this.whereClause(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1268; + this.match(SqlParser.KW_INSERT); + this.state = 1269; + this.match(SqlParser.KW_OVERWRITE); + this.state = 1271; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 292) { + { + this.state = 1270; + this.match(SqlParser.KW_TABLE); + } + } + + this.state = 1273; + this.tableName(); + this.state = 1278; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 1274; + this.partitionSpec(); + this.state = 1276; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 137) { + { + this.state = 1275; + this.ifNotExists(); + } + } + + } + } + + this.state = 1286; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 168, this.context) ) { + case 1: + { + { + this.state = 1280; + this.match(SqlParser.KW_BY); + this.state = 1281; + this.match(SqlParser.KW_NAME); + } + } + break; + case 2: + { + { + this.state = 1282; + this.match(SqlParser.LEFT_PAREN); + this.state = 1283; + this.columnNameSeq(); + this.state = 1284; + this.match(SqlParser.RIGHT_PAREN); + } + } + break; + } + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1288; + this.match(SqlParser.KW_INSERT); + this.state = 1289; + this.match(SqlParser.KW_OVERWRITE); + this.state = 1291; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 169) { + { + this.state = 1290; + this.match(SqlParser.KW_LOCAL); + } + } + + this.state = 1293; + this.match(SqlParser.KW_DIRECTORY); + this.state = 1295; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 376 || _la === 377) { + { + this.state = 1294; + localContext._path = this.stringLit(); + } + } + + this.state = 1298; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 256) { + { + this.state = 1297; + this.rowFormat(); + } + } + + this.state = 1301; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 282) { + { + this.state = 1300; + this.createFileFormat(); + } + } + + this.state = 1304; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 331) { + { + this.state = 1303; + this.tableProvider(); + } + } + + this.state = 1308; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 206) { + { + this.state = 1306; + this.match(SqlParser.KW_OPTIONS); + this.state = 1307; + localContext._options = this.propertyList(); + } + } + + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public showStatement(): ShowStatementContext { + let localContext = new ShowStatementContext(this.context, this.state); + this.enterRule(localContext, 16, SqlParser.RULE_showStatement); + let _la: number; + try { + let alternative: number; + this.state = 1444; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 201, this.context) ) { + case 1: + localContext = new ShowNamespacesContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 1312; + this.match(SqlParser.KW_SHOW); + this.state = 1313; + _la = this.tokenStream.LA(1); + if(!(_la === 73 || _la === 190 || _la === 261)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1316; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 176, this.context) ) { + case 1: + { + this.state = 1314; + _la = this.tokenStream.LA(1); + if(!(_la === 123 || _la === 140)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1315; + this.multipartIdentifier(); + } + break; + } + this.state = 1322; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 163 || _la === 376 || _la === 377) { + { + this.state = 1319; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 163) { + { + this.state = 1318; + this.match(SqlParser.KW_LIKE); + } + } + + this.state = 1321; + (localContext as ShowNamespacesContext)._pattern = this.stringLit(); + } + } + + } + break; + case 2: + localContext = new ShowTablesContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 1324; + this.match(SqlParser.KW_SHOW); + this.state = 1325; + this.match(SqlParser.KW_TABLES); + this.state = 1328; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 179, this.context) ) { + case 1: + { + this.state = 1326; + _la = this.tokenStream.LA(1); + if(!(_la === 123 || _la === 140)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1327; + this.namespaceName(); + } + break; + } + this.state = 1334; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 163 || _la === 376 || _la === 377) { + { + this.state = 1331; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 163) { + { + this.state = 1330; + this.match(SqlParser.KW_LIKE); + } + } + + this.state = 1333; + (localContext as ShowTablesContext)._pattern = this.stringLit(); + } + } + + } + break; + case 3: + localContext = new ShowTableExtendedContext(localContext); + this.enterOuterAlt(localContext, 3); + { + this.state = 1336; + this.match(SqlParser.KW_SHOW); + this.state = 1337; + this.match(SqlParser.KW_TABLE); + this.state = 1338; + this.match(SqlParser.KW_EXTENDED); + this.state = 1341; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 123 || _la === 140) { + { + this.state = 1339; + _la = this.tokenStream.LA(1); + if(!(_la === 123 || _la === 140)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1340; + (localContext as ShowTableExtendedContext)._ns = this.namespaceName(); + } + } + + this.state = 1343; + this.match(SqlParser.KW_LIKE); + this.state = 1344; + (localContext as ShowTableExtendedContext)._pattern = this.stringLit(); + this.state = 1346; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 1345; + this.partitionSpec(); + } + } + + } + break; + case 4: + localContext = new ShowTblPropertiesContext(localContext); + this.enterOuterAlt(localContext, 4); + { + this.state = 1348; + this.match(SqlParser.KW_SHOW); + this.state = 1349; + this.match(SqlParser.KW_TBLPROPERTIES); + this.state = 1350; + (localContext as ShowTblPropertiesContext)._table = this.tableName(); + this.state = 1355; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 184, this.context) ) { + case 1: + { + this.state = 1351; + this.match(SqlParser.LEFT_PAREN); + this.state = 1352; + (localContext as ShowTblPropertiesContext)._key = this.propertyKey(); + this.state = 1353; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + break; + case 5: + localContext = new ShowColumnsContext(localContext); + this.enterOuterAlt(localContext, 5); + { + this.state = 1357; + this.match(SqlParser.KW_SHOW); + this.state = 1358; + this.match(SqlParser.KW_COLUMNS); + this.state = 1359; + _la = this.tokenStream.LA(1); + if(!(_la === 123 || _la === 140)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1360; + (localContext as ShowColumnsContext)._table = this.tableName(); + this.state = 1363; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 185, this.context) ) { + case 1: + { + this.state = 1361; + _la = this.tokenStream.LA(1); + if(!(_la === 123 || _la === 140)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1362; + this.namespaceName(); + } + break; + } + } + break; + case 6: + localContext = new ShowViewsContext(localContext); + this.enterOuterAlt(localContext, 6); + { + this.state = 1365; + this.match(SqlParser.KW_SHOW); + this.state = 1366; + this.match(SqlParser.KW_VIEWS); + this.state = 1369; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 186, this.context) ) { + case 1: + { + this.state = 1367; + _la = this.tokenStream.LA(1); + if(!(_la === 123 || _la === 140)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1368; + this.namespaceName(); + } + break; + } + this.state = 1375; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 163 || _la === 376 || _la === 377) { + { + this.state = 1372; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 163) { + { + this.state = 1371; + this.match(SqlParser.KW_LIKE); + } + } + + this.state = 1374; + (localContext as ShowViewsContext)._pattern = this.stringLit(); + } + } + + } + break; + case 7: + localContext = new ShowPartitionsContext(localContext); + this.enterOuterAlt(localContext, 7); + { + this.state = 1377; + this.match(SqlParser.KW_SHOW); + this.state = 1378; + this.match(SqlParser.KW_PARTITIONS); + this.state = 1379; + this.tableName(); + this.state = 1381; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 216) { + { + this.state = 1380; + this.partitionSpec(); + } + } + + } + break; + case 8: + localContext = new ShowFunctionsContext(localContext); + this.enterOuterAlt(localContext, 8); + { + this.state = 1383; + this.match(SqlParser.KW_SHOW); + this.state = 1385; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 10 || _la === 289 || _la === 330) { + { + this.state = 1384; + _la = this.tokenStream.LA(1); + if(!(_la === 10 || _la === 289 || _la === 330)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 1387; + this.match(SqlParser.KW_FUNCTIONS); + this.state = 1390; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 191, this.context) ) { + case 1: + { + this.state = 1388; + _la = this.tokenStream.LA(1); + if(!(_la === 123 || _la === 140)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1389; + (localContext as ShowFunctionsContext)._ns = this.namespaceName(); + } + break; + } + this.state = 1399; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 194, this.context) ) { + case 1: + { + this.state = 1393; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 192, this.context) ) { + case 1: + { + this.state = 1392; + this.match(SqlParser.KW_LIKE); + } + break; + } + this.state = 1397; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 193, this.context) ) { + case 1: + { + this.state = 1395; + (localContext as ShowFunctionsContext)._legacy = this.multipartIdentifier(); + } + break; + case 2: + { + this.state = 1396; + (localContext as ShowFunctionsContext)._pattern = this.stringLit(); + } + break; + } + } + break; + } + } + break; + case 9: + localContext = new ShowCreateTableContext(localContext); + this.enterOuterAlt(localContext, 9); + { + this.state = 1401; + this.match(SqlParser.KW_SHOW); + this.state = 1402; + this.match(SqlParser.KW_CREATE); + this.state = 1403; + this.match(SqlParser.KW_TABLE); + this.state = 1404; + this.tableName(); + this.state = 1407; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 20) { + { + this.state = 1405; + this.match(SqlParser.KW_AS); + this.state = 1406; + this.match(SqlParser.KW_SERDE); + } + } + + } + break; + case 10: + localContext = new ShowCurrentNamespaceContext(localContext); + this.enterOuterAlt(localContext, 10); + { + this.state = 1409; + this.match(SqlParser.KW_SHOW); + this.state = 1410; + this.match(SqlParser.KW_CURRENT); + this.state = 1411; + this.namespace(); + } + break; + case 11: + localContext = new ShowCatalogsContext(localContext); + this.enterOuterAlt(localContext, 11); + { + this.state = 1412; + this.match(SqlParser.KW_SHOW); + this.state = 1413; + this.match(SqlParser.KW_CATALOGS); + this.state = 1418; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 163 || _la === 376 || _la === 377) { + { + this.state = 1415; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 163) { + { + this.state = 1414; + this.match(SqlParser.KW_LIKE); + } + } + + this.state = 1417; + (localContext as ShowCatalogsContext)._pattern = this.stringLit(); + } + } + + } + break; + case 12: + localContext = new ShowOtherContext(localContext); + this.enterOuterAlt(localContext, 12); + { + this.state = 1420; + this.match(SqlParser.KW_SHOW); + this.state = 1436; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_GRANT: + { + this.state = 1421; + this.match(SqlParser.KW_GRANT); + } + break; + case SqlParser.KW_PRINCIPALS: + { + this.state = 1422; + this.match(SqlParser.KW_PRINCIPALS); + } + break; + case SqlParser.KW_ROLES: + { + this.state = 1423; + this.match(SqlParser.KW_ROLES); + } + break; + case SqlParser.KW_COMPACTIONS: + { + this.state = 1424; + this.match(SqlParser.KW_COMPACTIONS); + } + break; + case SqlParser.KW_TRANSACTIONS: + { + this.state = 1425; + this.match(SqlParser.KW_TRANSACTIONS); + } + break; + case SqlParser.KW_INDEXES: + { + this.state = 1426; + this.match(SqlParser.KW_INDEXES); + } + break; + case SqlParser.KW_LOCKS: + { + this.state = 1427; + this.match(SqlParser.KW_LOCKS); + } + break; + case SqlParser.KW_ROLE: + { + { + this.state = 1428; + this.match(SqlParser.KW_ROLE); + this.state = 1430; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 198, this.context) ) { + case 1: + { + this.state = 1429; + this.match(SqlParser.KW_GRANT); + } + break; + } + } + } + break; + case SqlParser.KW_CURRENT: + { + { + this.state = 1432; + this.match(SqlParser.KW_CURRENT); + this.state = 1433; + this.match(SqlParser.KW_ROLES); + } + } + break; + case SqlParser.KW_CREATE: + { + { + this.state = 1434; + this.match(SqlParser.KW_CREATE); + this.state = 1435; + this.match(SqlParser.KW_TABLE); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 1441; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 200, this.context); + while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1 + 1) { + { + { + this.state = 1438; + this.matchWildcard(); + } + } + } + this.state = 1443; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 200, this.context); + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public unsupportedCommands(): UnsupportedCommandsContext { + let localContext = new UnsupportedCommandsContext(this.context, this.state); + this.enterRule(localContext, 18, SqlParser.RULE_unsupportedCommands); + let _la: number; + try { + this.state = 1459; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 203, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1446; + _la = this.tokenStream.LA(1); + if(!(_la === 129 || _la === 248)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1448; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 202, this.context) ) { + case 1: + { + this.state = 1447; + this.match(SqlParser.KW_ROLE); + } + break; + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1450; + _la = this.tokenStream.LA(1); + if(!(_la === 107 || _la === 139 || _la === 171 || _la === 325)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1451; + this.match(SqlParser.KW_TABLE); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1452; + _la = this.tokenStream.LA(1); + if(!(_la === 171 || _la === 325)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1453; + this.match(SqlParser.KW_DATABASE); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1454; + this.match(SqlParser.KW_START); + this.state = 1455; + this.match(SqlParser.KW_TRANSACTION); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 1456; + this.match(SqlParser.KW_COMMIT); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 1457; + this.match(SqlParser.KW_ROLLBACK); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 1458; + this.match(SqlParser.KW_DFS); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public bucketSpec(): BucketSpecContext { + let localContext = new BucketSpecContext(this.context, this.state); + this.enterRule(localContext, 20, SqlParser.RULE_bucketSpec); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1461; + this.match(SqlParser.KW_CLUSTERED); + this.state = 1462; + this.match(SqlParser.KW_BY); + this.state = 1463; + this.identifierList(); + this.state = 1467; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 278) { + { + this.state = 1464; + this.match(SqlParser.KW_SORTED); + this.state = 1465; + this.match(SqlParser.KW_BY); + this.state = 1466; + this.orderedIdentifierList(); + } + } + + this.state = 1469; + this.match(SqlParser.KW_INTO); + this.state = 1470; + this.match(SqlParser.INTEGER_VALUE); + this.state = 1471; + this.match(SqlParser.KW_BUCKETS); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public skewSpec(): SkewSpecContext { + let localContext = new SkewSpecContext(this.context, this.state); + this.enterRule(localContext, 22, SqlParser.RULE_skewSpec); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1473; + this.match(SqlParser.KW_SKEWED); + this.state = 1474; + this.match(SqlParser.KW_BY); + this.state = 1475; + this.identifierList(); + this.state = 1476; + this.match(SqlParser.KW_ON); + this.state = 1479; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 205, this.context) ) { + case 1: + { + this.state = 1477; + this.constantList(); + } + break; + case 2: + { + this.state = 1478; + this.nestedConstantList(); + } + break; + } + this.state = 1484; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 206, this.context) ) { + case 1: + { + this.state = 1481; + this.match(SqlParser.KW_STORED); + this.state = 1482; + this.match(SqlParser.KW_AS); + this.state = 1483; + this.match(SqlParser.KW_DIRECTORIES); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public query(): QueryContext { + let localContext = new QueryContext(this.context, this.state); + this.enterRule(localContext, 24, SqlParser.RULE_query); + let _la: number; + try { + localContext = new QueryStatementContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 1487; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 345) { + { + this.state = 1486; + this.ctes(); + } + } + + this.state = 1489; + this.queryTerm(0); + this.state = 1490; + this.queryOrganization(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public partitionSpecLocation(): PartitionSpecLocationContext { + let localContext = new PartitionSpecLocationContext(this.context, this.state); + this.enterRule(localContext, 26, SqlParser.RULE_partitionSpecLocation); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1492; + this.partitionSpec(); + this.state = 1495; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 170) { + { + this.state = 1493; + this.match(SqlParser.KW_LOCATION); + this.state = 1494; + this.stringLit(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public partitionSpec(): PartitionSpecContext { + let localContext = new PartitionSpecContext(this.context, this.state); + this.enterRule(localContext, 28, SqlParser.RULE_partitionSpec); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1497; + this.match(SqlParser.KW_PARTITION); + this.state = 1498; + this.match(SqlParser.LEFT_PAREN); + this.state = 1499; + this.partitionVal(); + this.state = 1504; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 1500; + this.match(SqlParser.COMMA); + this.state = 1501; + this.partitionVal(); + } + } + this.state = 1506; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1507; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public partitionVal(): PartitionValContext { + let localContext = new PartitionValContext(this.context, this.state); + this.enterRule(localContext, 30, SqlParser.RULE_partitionVal); + let _la: number; + try { + this.state = 1518; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 211, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1509; + this.identifier(); + this.state = 1512; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 351) { + { + this.state = 1510; + this.match(SqlParser.EQ); + this.state = 1511; + this.constant(); + } + } + + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1514; + this.identifier(); + this.state = 1515; + this.match(SqlParser.EQ); + this.state = 1516; + this.match(SqlParser.KW_DEFAULT); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public namespace(): NamespaceContext { + let localContext = new NamespaceContext(this.context, this.state); + this.enterRule(localContext, 32, SqlParser.RULE_namespace); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1520; + _la = this.tokenStream.LA(1); + if(!(_la === 72 || _la === 189 || _la === 260)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public describeFuncName(): DescribeFuncNameContext { + let localContext = new DescribeFuncNameContext(this.context, this.state); + this.enterRule(localContext, 34, SqlParser.RULE_describeFuncName); + try { + this.state = 1527; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 212, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1522; + this.identifierReference(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1523; + this.stringLit(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1524; + this.comparisonOperator(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1525; + this.arithmeticOperator(); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 1526; + this.predicateOperator(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public describeColName(): DescribeColNameContext { + let localContext = new DescribeColNameContext(this.context, this.state); + this.enterRule(localContext, 36, SqlParser.RULE_describeColName); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1529; + localContext._identifier = this.identifier(); + localContext._nameParts.push(localContext._identifier); + this.state = 1534; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 5) { + { + { + this.state = 1530; + this.match(SqlParser.DOT); + this.state = 1531; + localContext._identifier = this.identifier(); + localContext._nameParts.push(localContext._identifier); + } + } + this.state = 1536; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public ctes(): CtesContext { + let localContext = new CtesContext(this.context, this.state); + this.enterRule(localContext, 38, SqlParser.RULE_ctes); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1537; + this.match(SqlParser.KW_WITH); + this.state = 1538; + this.namedQuery(); + this.state = 1543; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 1539; + this.match(SqlParser.COMMA); + this.state = 1540; + this.namedQuery(); + } + } + this.state = 1545; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public namedQuery(): NamedQueryContext { + let localContext = new NamedQueryContext(this.context, this.state); + this.enterRule(localContext, 40, SqlParser.RULE_namedQuery); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1546; + localContext._name = this.errorCapturingIdentifier(); + this.state = 1548; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 215, this.context) ) { + case 1: + { + this.state = 1547; + localContext._columnAliases = this.identifierList(); + } + break; + } + this.state = 1551; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 20) { + { + this.state = 1550; + this.match(SqlParser.KW_AS); + } + } + + this.state = 1553; + this.match(SqlParser.LEFT_PAREN); + this.state = 1554; + this.query(); + this.state = 1555; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public tableProvider(): TableProviderContext { + let localContext = new TableProviderContext(this.context, this.state); + this.enterRule(localContext, 42, SqlParser.RULE_tableProvider); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1557; + this.match(SqlParser.KW_USING); + this.state = 1558; + this.multipartIdentifier(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createTableClauses(): CreateTableClausesContext { + let localContext = new CreateTableClausesContext(this.context, this.state); + this.enterRule(localContext, 44, SqlParser.RULE_createTableClauses); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 1578; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 218, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + this.state = 1576; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_OPTIONS: + { + { + this.state = 1560; + this.match(SqlParser.KW_OPTIONS); + this.state = 1561; + localContext._options = this.expressionPropertyList(); + } + } + break; + case SqlParser.KW_PARTITIONED: + { + { + this.state = 1562; + this.match(SqlParser.KW_PARTITIONED); + this.state = 1563; + this.match(SqlParser.KW_BY); + this.state = 1564; + localContext._partitioning = this.partitionFieldList(); + } + } + break; + case SqlParser.KW_SKEWED: + { + this.state = 1565; + this.skewSpec(); + } + break; + case SqlParser.KW_CLUSTERED: + { + this.state = 1566; + this.bucketSpec(); + } + break; + case SqlParser.KW_ROW: + { + this.state = 1567; + this.rowFormat(); + } + break; + case SqlParser.KW_STORED: + { + this.state = 1568; + this.createFileFormat(); + } + break; + case SqlParser.KW_LOCATION: + { + { + this.state = 1569; + this.match(SqlParser.KW_LOCATION); + this.state = 1570; + this.stringLit(); + } + } + break; + case SqlParser.KW_COMMENT: + { + { + this.state = 1571; + this.match(SqlParser.KW_COMMENT); + this.state = 1572; + localContext._comment = this.stringLit(); + } + } + break; + case SqlParser.KW_TBLPROPERTIES: + { + { + this.state = 1573; + this.match(SqlParser.KW_TBLPROPERTIES); + this.state = 1574; + localContext._tableProps = this.propertyList(); + } + } + break; + case SqlParser.KW_LIFECYCLE: + { + this.state = 1575; + this.tableLifecycle(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + this.state = 1580; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 218, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public tableLifecycle(): TableLifecycleContext { + let localContext = new TableLifecycleContext(this.context, this.state); + this.enterRule(localContext, 46, SqlParser.RULE_tableLifecycle); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1581; + this.match(SqlParser.KW_LIFECYCLE); + this.state = 1582; + this.match(SqlParser.INTEGER_VALUE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public propertyList(): PropertyListContext { + let localContext = new PropertyListContext(this.context, this.state); + this.enterRule(localContext, 48, SqlParser.RULE_propertyList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1584; + this.match(SqlParser.LEFT_PAREN); + this.state = 1585; + this.property(); + this.state = 1590; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 1586; + this.match(SqlParser.COMMA); + this.state = 1587; + this.property(); + } + } + this.state = 1592; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1593; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public property(): PropertyContext { + let localContext = new PropertyContext(this.context, this.state); + this.enterRule(localContext, 50, SqlParser.RULE_property); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1595; + localContext._key = this.propertyKey(); + this.state = 1600; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 111 || _la === 315 || ((((_la - 351)) & ~0x1F) === 0 && ((1 << (_la - 351)) & 1174405121) !== 0) || _la === 383) { + { + this.state = 1597; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 351) { + { + this.state = 1596; + this.match(SqlParser.EQ); + } + } + + this.state = 1599; + localContext._value = this.propertyValue(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public propertyKey(): PropertyKeyContext { + let localContext = new PropertyKeyContext(this.context, this.state); + this.enterRule(localContext, 52, SqlParser.RULE_propertyKey); + let _la: number; + try { + this.state = 1611; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 223, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1602; + this.identifier(); + this.state = 1607; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 5) { + { + { + this.state = 1603; + this.match(SqlParser.DOT); + this.state = 1604; + this.identifier(); + } + } + this.state = 1609; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1610; + this.stringLit(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public propertyValue(): PropertyValueContext { + let localContext = new PropertyValueContext(this.context, this.state); + this.enterRule(localContext, 54, SqlParser.RULE_propertyValue); + try { + this.state = 1617; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.INTEGER_VALUE: + this.enterOuterAlt(localContext, 1); + { + this.state = 1613; + this.match(SqlParser.INTEGER_VALUE); + } + break; + case SqlParser.DECIMAL_VALUE: + this.enterOuterAlt(localContext, 2); + { + this.state = 1614; + this.match(SqlParser.DECIMAL_VALUE); + } + break; + case SqlParser.KW_FALSE: + case SqlParser.KW_TRUE: + this.enterOuterAlt(localContext, 3); + { + this.state = 1615; + this.booleanValue(); + } + break; + case SqlParser.STRING_LITERAL: + case SqlParser.DOUBLEQUOTED_STRING: + this.enterOuterAlt(localContext, 4); + { + this.state = 1616; + this.stringLit(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public expressionPropertyList(): ExpressionPropertyListContext { + let localContext = new ExpressionPropertyListContext(this.context, this.state); + this.enterRule(localContext, 56, SqlParser.RULE_expressionPropertyList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1619; + this.match(SqlParser.LEFT_PAREN); + this.state = 1620; + this.expressionProperty(); + this.state = 1625; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 1621; + this.match(SqlParser.COMMA); + this.state = 1622; + this.expressionProperty(); + } + } + this.state = 1627; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1628; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public expressionProperty(): ExpressionPropertyContext { + let localContext = new ExpressionPropertyContext(this.context, this.state); + this.enterRule(localContext, 58, SqlParser.RULE_expressionProperty); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1630; + localContext._key = this.propertyKey(); + this.state = 1635; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 359)) & ~0x1F) === 0 && ((1 << (_la - 359)) & 1073678415) !== 0)) { + { + this.state = 1632; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 351) { + { + this.state = 1631; + this.match(SqlParser.EQ); + } + } + + this.state = 1634; + localContext._value = this.expression(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public constantList(): ConstantListContext { + let localContext = new ConstantListContext(this.context, this.state); + this.enterRule(localContext, 60, SqlParser.RULE_constantList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1637; + this.match(SqlParser.LEFT_PAREN); + this.state = 1638; + this.constant(); + this.state = 1643; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 1639; + this.match(SqlParser.COMMA); + this.state = 1640; + this.constant(); + } + } + this.state = 1645; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1646; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public nestedConstantList(): NestedConstantListContext { + let localContext = new NestedConstantListContext(this.context, this.state); + this.enterRule(localContext, 62, SqlParser.RULE_nestedConstantList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1648; + this.match(SqlParser.LEFT_PAREN); + this.state = 1649; + this.constantList(); + this.state = 1654; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 1650; + this.match(SqlParser.COMMA); + this.state = 1651; + this.constantList(); + } + } + this.state = 1656; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1657; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createFileFormat(): CreateFileFormatContext { + let localContext = new CreateFileFormatContext(this.context, this.state); + this.enterRule(localContext, 64, SqlParser.RULE_createFileFormat); + try { + this.state = 1665; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 230, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1659; + this.match(SqlParser.KW_STORED); + this.state = 1660; + this.match(SqlParser.KW_AS); + this.state = 1661; + this.fileFormat(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1662; + this.match(SqlParser.KW_STORED); + this.state = 1663; + this.match(SqlParser.KW_BY); + this.state = 1664; + this.storageHandler(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fileFormat(): FileFormatContext { + let localContext = new FileFormatContext(this.context, this.state); + this.enterRule(localContext, 66, SqlParser.RULE_fileFormat); + try { + this.state = 1673; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 231, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1667; + this.match(SqlParser.KW_INPUTFORMAT); + this.state = 1668; + localContext._inFmt = this.stringLit(); + this.state = 1669; + this.match(SqlParser.KW_OUTPUTFORMAT); + this.state = 1670; + localContext._outFmt = this.stringLit(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1672; + this.identifier(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public storageHandler(): StorageHandlerContext { + let localContext = new StorageHandlerContext(this.context, this.state); + this.enterRule(localContext, 68, SqlParser.RULE_storageHandler); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1675; + this.stringLit(); + this.state = 1679; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 232, this.context) ) { + case 1: + { + this.state = 1676; + this.match(SqlParser.KW_WITH); + this.state = 1677; + this.match(SqlParser.KW_SERDEPROPERTIES); + this.state = 1678; + this.propertyList(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public namespaceName(): NamespaceNameContext { + let localContext = new NamespaceNameContext(this.context, this.state); + this.enterRule(localContext, 70, SqlParser.RULE_namespaceName); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1681; + this.identifierReference(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public namespaceNameCreate(): NamespaceNameCreateContext { + let localContext = new NamespaceNameCreateContext(this.context, this.state); + this.enterRule(localContext, 72, SqlParser.RULE_namespaceNameCreate); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1683; + this.identifierReference(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public tableNameCreate(): TableNameCreateContext { + let localContext = new TableNameCreateContext(this.context, this.state); + this.enterRule(localContext, 74, SqlParser.RULE_tableNameCreate); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1685; + this.tableIdentifier(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public tableName(): TableNameContext { + let localContext = new TableNameContext(this.context, this.state); + this.enterRule(localContext, 76, SqlParser.RULE_tableName); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1687; + this.tableIdentifier(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public viewNameCreate(): ViewNameCreateContext { + let localContext = new ViewNameCreateContext(this.context, this.state); + this.enterRule(localContext, 78, SqlParser.RULE_viewNameCreate); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1689; + this.viewIdentifier(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public viewName(): ViewNameContext { + let localContext = new ViewNameContext(this.context, this.state); + this.enterRule(localContext, 80, SqlParser.RULE_viewName); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1691; + this.viewIdentifier(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public columnName(): ColumnNameContext { + let localContext = new ColumnNameContext(this.context, this.state); + this.enterRule(localContext, 82, SqlParser.RULE_columnName); + try { + this.state = 1695; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 233, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1693; + this.multipartIdentifier(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1694; + if (!(this.shouldMatchEmpty())) { + throw this.createFailedPredicateException("this.shouldMatchEmpty()"); + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public columnNameSeq(): ColumnNameSeqContext { + let localContext = new ColumnNameSeqContext(this.context, this.state); + this.enterRule(localContext, 84, SqlParser.RULE_columnNameSeq); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1697; + this.columnName(); + this.state = 1702; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 1698; + this.match(SqlParser.COMMA); + this.state = 1699; + this.columnName(); + } + } + this.state = 1704; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public columnNameCreate(): ColumnNameCreateContext { + let localContext = new ColumnNameCreateContext(this.context, this.state); + this.enterRule(localContext, 86, SqlParser.RULE_columnNameCreate); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1705; + this.errorCapturingIdentifier(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public identifierReference(): IdentifierReferenceContext { + let localContext = new IdentifierReferenceContext(this.context, this.state); + this.enterRule(localContext, 88, SqlParser.RULE_identifierReference); + try { + this.state = 1713; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 235, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1707; + this.match(SqlParser.KW_IDENTIFIER); + this.state = 1708; + this.match(SqlParser.LEFT_PAREN); + this.state = 1709; + this.expression(); + this.state = 1710; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1712; + this.multipartIdentifier(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public queryOrganization(): QueryOrganizationContext { + let localContext = new QueryOrganizationContext(this.context, this.state); + this.enterRule(localContext, 90, SqlParser.RULE_queryOrganization); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 1725; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 237, this.context) ) { + case 1: + { + this.state = 1715; + this.match(SqlParser.KW_ORDER); + this.state = 1716; + this.match(SqlParser.KW_BY); + this.state = 1717; + localContext._sortItem = this.sortItem(); + localContext._order.push(localContext._sortItem); + this.state = 1722; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 236, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1718; + this.match(SqlParser.COMMA); + this.state = 1719; + localContext._sortItem = this.sortItem(); + localContext._order.push(localContext._sortItem); + } + } + } + this.state = 1724; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 236, this.context); + } + } + break; + } + this.state = 1737; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 239, this.context) ) { + case 1: + { + this.state = 1727; + this.match(SqlParser.KW_CLUSTER); + this.state = 1728; + this.match(SqlParser.KW_BY); + this.state = 1729; + localContext._expression = this.expression(); + localContext._clusterBy.push(localContext._expression); + this.state = 1734; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 238, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1730; + this.match(SqlParser.COMMA); + this.state = 1731; + localContext._expression = this.expression(); + localContext._clusterBy.push(localContext._expression); + } + } + } + this.state = 1736; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 238, this.context); + } + } + break; + } + this.state = 1749; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 241, this.context) ) { + case 1: + { + this.state = 1739; + this.match(SqlParser.KW_DISTRIBUTE); + this.state = 1740; + this.match(SqlParser.KW_BY); + this.state = 1741; + localContext._expression = this.expression(); + localContext._distributeBy.push(localContext._expression); + this.state = 1746; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 240, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1742; + this.match(SqlParser.COMMA); + this.state = 1743; + localContext._expression = this.expression(); + localContext._distributeBy.push(localContext._expression); + } + } + } + this.state = 1748; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 240, this.context); + } + } + break; + } + this.state = 1761; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 243, this.context) ) { + case 1: + { + this.state = 1751; + this.match(SqlParser.KW_SORT); + this.state = 1752; + this.match(SqlParser.KW_BY); + this.state = 1753; + localContext._sortItem = this.sortItem(); + localContext._sort.push(localContext._sortItem); + this.state = 1758; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 242, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1754; + this.match(SqlParser.COMMA); + this.state = 1755; + localContext._sortItem = this.sortItem(); + localContext._sort.push(localContext._sortItem); + } + } + } + this.state = 1760; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 242, this.context); + } + } + break; + } + this.state = 1764; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 244, this.context) ) { + case 1: + { + this.state = 1763; + this.windowClause(); + } + break; + } + this.state = 1771; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 246, this.context) ) { + case 1: + { + this.state = 1766; + this.match(SqlParser.KW_LIMIT); + this.state = 1769; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 245, this.context) ) { + case 1: + { + this.state = 1767; + this.match(SqlParser.KW_ALL); + } + break; + case 2: + { + this.state = 1768; + localContext._limit = this.expression(); + } + break; + } + } + break; + } + this.state = 1775; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 247, this.context) ) { + case 1: + { + this.state = 1773; + this.match(SqlParser.KW_OFFSET); + this.state = 1774; + localContext._offset = this.expression(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + + public queryTerm(): QueryTermContext; + public queryTerm(_p: number): QueryTermContext; + public queryTerm(_p?: number): QueryTermContext { + if (_p === undefined) { + _p = 0; + } + + let parentContext = this.context; + let parentState = this.state; + let localContext = new QueryTermContext(this.context, parentState); + let previousContext = localContext; + let _startState = 92; + this.enterRecursionRule(localContext, 92, SqlParser.RULE_queryTerm, _p); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + { + this.state = 1778; + this.queryPrimary(); + } + this.context!.stop = this.tokenStream.LT(-1); + this.state = 1800; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 252, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + previousContext = localContext; + { + this.state = 1798; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 251, this.context) ) { + case 1: + { + localContext = new QueryTermContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_queryTerm); + this.state = 1780; + if (!(this.precpred(this.context, 3))) { + throw this.createFailedPredicateException("this.precpred(this.context, 3)"); + } + this.state = 1781; + localContext._operator = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 102 || _la === 148 || _la === 269 || _la === 322)) { + localContext._operator = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1783; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 10 || _la === 92) { + { + this.state = 1782; + this.setQuantifier(); + } + } + + this.state = 1785; + localContext._right = this.queryTerm(4); + } + break; + case 2: + { + localContext = new QueryTermContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_queryTerm); + this.state = 1786; + if (!(this.precpred(this.context, 2))) { + throw this.createFailedPredicateException("this.precpred(this.context, 2)"); + } + this.state = 1787; + localContext._operator = this.match(SqlParser.KW_INTERSECT); + this.state = 1789; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 10 || _la === 92) { + { + this.state = 1788; + this.setQuantifier(); + } + } + + this.state = 1791; + localContext._right = this.queryTerm(3); + } + break; + case 3: + { + localContext = new QueryTermContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_queryTerm); + this.state = 1792; + if (!(this.precpred(this.context, 1))) { + throw this.createFailedPredicateException("this.precpred(this.context, 1)"); + } + this.state = 1793; + localContext._operator = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 102 || _la === 269 || _la === 322)) { + localContext._operator = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1795; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 10 || _la === 92) { + { + this.state = 1794; + this.setQuantifier(); + } + } + + this.state = 1797; + localContext._right = this.queryTerm(2); + } + break; + } + } + } + this.state = 1802; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 252, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(parentContext); + } + return localContext; + } + public queryPrimary(): QueryPrimaryContext { + let localContext = new QueryPrimaryContext(this.context, this.state); + this.enterRule(localContext, 94, SqlParser.RULE_queryPrimary); + try { + let alternative: number; + this.state = 1827; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_MAP: + case SqlParser.KW_REDUCE: + case SqlParser.KW_SELECT: + this.enterOuterAlt(localContext, 1); + { + this.state = 1803; + this.querySpecification(); + } + break; + case SqlParser.KW_FROM: + this.enterOuterAlt(localContext, 2); + { + this.state = 1804; + this.fromClause(); + this.state = 1806; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 1805; + this.fromStatementBody(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 1808; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 253, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } + break; + case SqlParser.KW_TABLE: + this.enterOuterAlt(localContext, 3); + { + this.state = 1810; + this.match(SqlParser.KW_TABLE); + this.state = 1811; + this.tableName(); + } + break; + case SqlParser.KW_VALUES: + this.enterOuterAlt(localContext, 4); + { + this.state = 1812; + this.match(SqlParser.KW_VALUES); + this.state = 1813; + this.expression(); + this.state = 1818; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 254, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1814; + this.match(SqlParser.COMMA); + this.state = 1815; + this.expression(); + } + } + } + this.state = 1820; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 254, this.context); + } + this.state = 1821; + this.tableAlias(); + } + break; + case SqlParser.LEFT_PAREN: + this.enterOuterAlt(localContext, 5); + { + this.state = 1823; + this.match(SqlParser.LEFT_PAREN); + this.state = 1824; + this.query(); + this.state = 1825; + this.match(SqlParser.RIGHT_PAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public sortItem(): SortItemContext { + let localContext = new SortItemContext(this.context, this.state); + this.enterRule(localContext, 96, SqlParser.RULE_sortItem); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1831; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 256, this.context) ) { + case 1: + { + this.state = 1829; + this.columnName(); + } + break; + case 2: + { + this.state = 1830; + this.expression(); + } + break; + } + this.state = 1834; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 257, this.context) ) { + case 1: + { + this.state = 1833; + localContext._ordering = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 21 || _la === 86)) { + localContext._ordering = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + this.state = 1838; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 258, this.context) ) { + case 1: + { + this.state = 1836; + this.match(SqlParser.KW_NULLS); + this.state = 1837; + localContext._nullOrder = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 116 || _la === 157)) { + localContext._nullOrder = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fromStatementBody(): FromStatementBodyContext { + let localContext = new FromStatementBodyContext(this.context, this.state); + this.enterRule(localContext, 98, SqlParser.RULE_fromStatementBody); + try { + let alternative: number; + this.state = 1867; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 265, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1840; + this.transformClause(); + this.state = 1842; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 259, this.context) ) { + case 1: + { + this.state = 1841; + this.whereClause(); + } + break; + } + this.state = 1844; + this.queryOrganization(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1846; + this.selectClause(); + this.state = 1850; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 260, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1847; + this.lateralView(); + } + } + } + this.state = 1852; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 260, this.context); + } + this.state = 1854; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 261, this.context) ) { + case 1: + { + this.state = 1853; + this.whereClause(); + } + break; + } + this.state = 1857; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 262, this.context) ) { + case 1: + { + this.state = 1856; + this.aggregationClause(); + } + break; + } + this.state = 1860; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 263, this.context) ) { + case 1: + { + this.state = 1859; + this.havingClause(); + } + break; + } + this.state = 1863; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 264, this.context) ) { + case 1: + { + this.state = 1862; + this.windowClause(); + } + break; + } + this.state = 1865; + this.queryOrganization(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public querySpecification(): QuerySpecificationContext { + let localContext = new QuerySpecificationContext(this.context, this.state); + this.enterRule(localContext, 100, SqlParser.RULE_querySpecification); + try { + let alternative: number; + this.state = 1913; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 278, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1869; + this.transformClause(); + this.state = 1871; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 266, this.context) ) { + case 1: + { + this.state = 1870; + this.fromClause(); + } + break; + } + this.state = 1876; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 267, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1873; + this.lateralView(); + } + } + } + this.state = 1878; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 267, this.context); + } + this.state = 1880; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 268, this.context) ) { + case 1: + { + this.state = 1879; + this.whereClause(); + } + break; + } + this.state = 1883; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 269, this.context) ) { + case 1: + { + this.state = 1882; + this.aggregationClause(); + } + break; + } + this.state = 1886; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 270, this.context) ) { + case 1: + { + this.state = 1885; + this.havingClause(); + } + break; + } + this.state = 1889; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 271, this.context) ) { + case 1: + { + this.state = 1888; + this.windowClause(); + } + break; + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1891; + this.selectClause(); + this.state = 1893; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 272, this.context) ) { + case 1: + { + this.state = 1892; + this.fromClause(); + } + break; + } + this.state = 1898; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 273, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1895; + this.lateralView(); + } + } + } + this.state = 1900; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 273, this.context); + } + this.state = 1902; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 274, this.context) ) { + case 1: + { + this.state = 1901; + this.whereClause(); + } + break; + } + this.state = 1905; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 275, this.context) ) { + case 1: + { + this.state = 1904; + this.aggregationClause(); + } + break; + } + this.state = 1908; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 276, this.context) ) { + case 1: + { + this.state = 1907; + this.havingClause(); + } + break; + } + this.state = 1911; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 277, this.context) ) { + case 1: + { + this.state = 1910; + this.windowClause(); + } + break; + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public transformClause(): TransformClauseContext { + let localContext = new TransformClauseContext(this.context, this.state); + this.enterRule(localContext, 102, SqlParser.RULE_transformClause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1934; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_SELECT: + { + this.state = 1915; + this.match(SqlParser.KW_SELECT); + this.state = 1916; + localContext._kind = this.match(SqlParser.KW_TRANSFORM); + this.state = 1917; + this.match(SqlParser.LEFT_PAREN); + this.state = 1919; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 279, this.context) ) { + case 1: + { + this.state = 1918; + this.setQuantifier(); + } + break; + } + this.state = 1921; + this.expressionSeq(); + this.state = 1922; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case SqlParser.KW_MAP: + { + this.state = 1924; + localContext._kind = this.match(SqlParser.KW_MAP); + this.state = 1926; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 280, this.context) ) { + case 1: + { + this.state = 1925; + this.setQuantifier(); + } + break; + } + this.state = 1928; + this.expressionSeq(); + } + break; + case SqlParser.KW_REDUCE: + { + this.state = 1929; + localContext._kind = this.match(SqlParser.KW_REDUCE); + this.state = 1931; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 281, this.context) ) { + case 1: + { + this.state = 1930; + this.setQuantifier(); + } + break; + } + this.state = 1933; + this.expressionSeq(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 1937; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 256) { + { + this.state = 1936; + localContext._inRowFormat = this.rowFormat(); + } + } + + this.state = 1941; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 235) { + { + this.state = 1939; + this.match(SqlParser.KW_RECORDWRITER); + this.state = 1940; + localContext._recordWriter = this.stringLit(); + } + } + + this.state = 1943; + this.match(SqlParser.KW_USING); + this.state = 1944; + localContext._script = this.stringLit(); + this.state = 1957; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 287, this.context) ) { + case 1: + { + this.state = 1945; + this.match(SqlParser.KW_AS); + this.state = 1955; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 286, this.context) ) { + case 1: + { + this.state = 1946; + this.identifierSeq(); + } + break; + case 2: + { + this.state = 1947; + this.colTypeList(); + } + break; + case 3: + { + { + this.state = 1948; + this.match(SqlParser.LEFT_PAREN); + this.state = 1951; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 285, this.context) ) { + case 1: + { + this.state = 1949; + this.identifierSeq(); + } + break; + case 2: + { + this.state = 1950; + this.colTypeList(); + } + break; + } + this.state = 1953; + this.match(SqlParser.RIGHT_PAREN); + } + } + break; + } + } + break; + } + this.state = 1960; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 288, this.context) ) { + case 1: + { + this.state = 1959; + localContext._outRowFormat = this.rowFormat(); + } + break; + } + this.state = 1964; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 289, this.context) ) { + case 1: + { + this.state = 1962; + this.match(SqlParser.KW_RECORDREADER); + this.state = 1963; + localContext._recordReader = this.stringLit(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public selectClause(): SelectClauseContext { + let localContext = new SelectClauseContext(this.context, this.state); + this.enterRule(localContext, 104, SqlParser.RULE_selectClause); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 1966; + this.match(SqlParser.KW_SELECT); + this.state = 1970; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 290, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1967; + localContext._hint = this.hint(); + localContext._hints.push(localContext._hint); + } + } + } + this.state = 1972; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 290, this.context); + } + this.state = 1974; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 291, this.context) ) { + case 1: + { + this.state = 1973; + this.setQuantifier(); + } + break; + } + this.state = 1976; + this.namedExpressionSeq(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public setClause(): SetClauseContext { + let localContext = new SetClauseContext(this.context, this.state); + this.enterRule(localContext, 106, SqlParser.RULE_setClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1978; + this.match(SqlParser.KW_SET); + this.state = 1979; + this.assignmentList(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public matchedClause(): MatchedClauseContext { + let localContext = new MatchedClauseContext(this.context, this.state); + this.enterRule(localContext, 108, SqlParser.RULE_matchedClause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1981; + this.match(SqlParser.KW_WHEN); + this.state = 1982; + this.match(SqlParser.KW_MATCHED); + this.state = 1985; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 14) { + { + this.state = 1983; + this.match(SqlParser.KW_AND); + this.state = 1984; + localContext._matchedCond = this.booleanExpression(0); + } + } + + this.state = 1987; + this.match(SqlParser.KW_THEN); + this.state = 1995; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_DELETE: + { + this.state = 1988; + this.match(SqlParser.KW_DELETE); + } + break; + case SqlParser.KW_UPDATE: + { + this.state = 1989; + this.match(SqlParser.KW_UPDATE); + this.state = 1990; + this.match(SqlParser.KW_SET); + this.state = 1993; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.ASTERISK: + { + this.state = 1991; + this.match(SqlParser.ASTERISK); + } + break; + case SqlParser.KW_ADD: + case SqlParser.KW_AFTER: + case SqlParser.KW_ALL: + case SqlParser.KW_ALTER: + case SqlParser.KW_ALWAYS: + case SqlParser.KW_ANALYZE: + case SqlParser.KW_AND: + case SqlParser.KW_ANTI: + case SqlParser.KW_ANY: + case SqlParser.KW_ANY_VALUE: + case SqlParser.KW_ARCHIVE: + case SqlParser.KW_ARRAY: + case SqlParser.KW_AS: + case SqlParser.KW_ASC: + case SqlParser.KW_AT: + case SqlParser.KW_AUTHORIZATION: + case SqlParser.KW_BETWEEN: + case SqlParser.KW_BIGINT: + case SqlParser.KW_BINARY: + case SqlParser.KW_BOOLEAN: + case SqlParser.KW_BOTH: + case SqlParser.KW_BUCKET: + case SqlParser.KW_BUCKETS: + case SqlParser.KW_BY: + case SqlParser.KW_BYTE: + case SqlParser.KW_CACHE: + case SqlParser.KW_CASCADE: + case SqlParser.KW_CASE: + case SqlParser.KW_CAST: + case SqlParser.KW_CATALOG: + case SqlParser.KW_CATALOGS: + case SqlParser.KW_CHANGE: + case SqlParser.KW_CHAR: + case SqlParser.KW_CHARACTER: + case SqlParser.KW_CHECK: + case SqlParser.KW_CLEAR: + case SqlParser.KW_CLUSTER: + case SqlParser.KW_CLUSTERED: + case SqlParser.KW_CODEGEN: + case SqlParser.KW_COLLATE: + case SqlParser.KW_COLLECTION: + case SqlParser.KW_COLUMN: + case SqlParser.KW_COLUMNS: + case SqlParser.KW_COMMENT: + case SqlParser.KW_COMMIT: + case SqlParser.KW_COMPACT: + case SqlParser.KW_COMPACTIONS: + case SqlParser.KW_COMPUTE: + case SqlParser.KW_CONCATENATE: + case SqlParser.KW_CONSTRAINT: + case SqlParser.KW_COST: + case SqlParser.KW_CREATE: + case SqlParser.KW_CROSS: + case SqlParser.KW_CUBE: + case SqlParser.KW_CURRENT: + case SqlParser.KW_CURRENT_DATE: + case SqlParser.KW_CURRENT_TIME: + case SqlParser.KW_CURRENT_TIMESTAMP: + case SqlParser.KW_CURRENT_USER: + case SqlParser.KW_DAY: + case SqlParser.KW_DAYS: + case SqlParser.KW_DAYOFYEAR: + case SqlParser.KW_DATA: + case SqlParser.KW_DATE: + case SqlParser.KW_DATABASE: + case SqlParser.KW_DATABASES: + case SqlParser.KW_DATEADD: + case SqlParser.KW_DATE_ADD: + case SqlParser.KW_DATEDIFF: + case SqlParser.KW_DATE_DIFF: + case SqlParser.KW_DBPROPERTIES: + case SqlParser.KW_DEC: + case SqlParser.KW_DECIMAL: + case SqlParser.KW_DECLARE: + case SqlParser.KW_DEFAULT: + case SqlParser.KW_DEFINED: + case SqlParser.KW_DELETE: + case SqlParser.KW_DELIMITED: + case SqlParser.KW_DESC: + case SqlParser.KW_DESCRIBE: + case SqlParser.KW_DFS: + case SqlParser.KW_DIRECTORIES: + case SqlParser.KW_DIRECTORY: + case SqlParser.KW_DISABLE: + case SqlParser.KW_DISTINCT: + case SqlParser.KW_DISTRIBUTE: + case SqlParser.KW_DIV: + case SqlParser.KW_DOUBLE: + case SqlParser.KW_DROP: + case SqlParser.KW_ELSE: + case SqlParser.KW_ENABLE: + case SqlParser.KW_END: + case SqlParser.KW_ESCAPE: + case SqlParser.KW_ESCAPED: + case SqlParser.KW_EXCEPT: + case SqlParser.KW_EXCHANGE: + case SqlParser.KW_EXCLUDE: + case SqlParser.KW_EXISTS: + case SqlParser.KW_EXPLAIN: + case SqlParser.KW_EXPORT: + case SqlParser.KW_EXTENDED: + case SqlParser.KW_EXTERNAL: + case SqlParser.KW_EXTRACT: + case SqlParser.KW_FALSE: + case SqlParser.KW_FETCH: + case SqlParser.KW_FIELDS: + case SqlParser.KW_FILTER: + case SqlParser.KW_FILEFORMAT: + case SqlParser.KW_FIRST: + case SqlParser.KW_FLOAT: + case SqlParser.KW_FOLLOWING: + case SqlParser.KW_FOR: + case SqlParser.KW_FOREIGN: + case SqlParser.KW_FORMAT: + case SqlParser.KW_FORMATTED: + case SqlParser.KW_FULL: + case SqlParser.KW_FUNCTION: + case SqlParser.KW_FUNCTIONS: + case SqlParser.KW_GENERATED: + case SqlParser.KW_GLOBAL: + case SqlParser.KW_GRANT: + case SqlParser.KW_GROUP: + case SqlParser.KW_GROUPING: + case SqlParser.KW_HAVING: + case SqlParser.KW_BINARY_HEX: + case SqlParser.KW_HOUR: + case SqlParser.KW_HOURS: + case SqlParser.KW_IDENTIFIER: + case SqlParser.KW_IF: + case SqlParser.KW_IGNORE: + case SqlParser.KW_IMPORT: + case SqlParser.KW_IN: + case SqlParser.KW_INCLUDE: + case SqlParser.KW_INDEX: + case SqlParser.KW_INDEXES: + case SqlParser.KW_INNER: + case SqlParser.KW_INPATH: + case SqlParser.KW_INPUTFORMAT: + case SqlParser.KW_INSERT: + case SqlParser.KW_INTERSECT: + case SqlParser.KW_INTERVAL: + case SqlParser.KW_INT: + case SqlParser.KW_INTEGER: + case SqlParser.KW_INTO: + case SqlParser.KW_IS: + case SqlParser.KW_ITEMS: + case SqlParser.KW_JOIN: + case SqlParser.KW_KEYS: + case SqlParser.KW_LAST: + case SqlParser.KW_LATERAL: + case SqlParser.KW_LAZY: + case SqlParser.KW_LEADING: + case SqlParser.KW_LEFT: + case SqlParser.KW_LIFECYCLE: + case SqlParser.KW_LIKE: + case SqlParser.KW_ILIKE: + case SqlParser.KW_LIMIT: + case SqlParser.KW_LINES: + case SqlParser.KW_LIST: + case SqlParser.KW_LOAD: + case SqlParser.KW_LOCAL: + case SqlParser.KW_LOCATION: + case SqlParser.KW_LOCK: + case SqlParser.KW_LOCKS: + case SqlParser.KW_LOGICAL: + case SqlParser.KW_LONG: + case SqlParser.KW_MACRO: + case SqlParser.KW_MAP: + case SqlParser.KW_MATCHED: + case SqlParser.KW_MERGE: + case SqlParser.KW_MICROSECOND: + case SqlParser.KW_MICROSECONDS: + case SqlParser.KW_MILLISECOND: + case SqlParser.KW_MILLISECONDS: + case SqlParser.KW_MINUTE: + case SqlParser.KW_MINUTES: + case SqlParser.KW_MONTH: + case SqlParser.KW_MONTHS: + case SqlParser.KW_MSCK: + case SqlParser.KW_NAME: + case SqlParser.KW_NAMESPACE: + case SqlParser.KW_NAMESPACES: + case SqlParser.KW_NANOSECOND: + case SqlParser.KW_NANOSECONDS: + case SqlParser.KW_NATURAL: + case SqlParser.KW_NO: + case SqlParser.KW_NOT: + case SqlParser.KW_NULL: + case SqlParser.KW_NULLS: + case SqlParser.KW_NUMERIC: + case SqlParser.KW_OF: + case SqlParser.KW_OFFSET: + case SqlParser.KW_ON: + case SqlParser.KW_ONLY: + case SqlParser.KW_OPTIMIZE: + case SqlParser.KW_OPTION: + case SqlParser.KW_OPTIONS: + case SqlParser.KW_OR: + case SqlParser.KW_ORDER: + case SqlParser.KW_OUT: + case SqlParser.KW_OUTER: + case SqlParser.KW_OUTPUTFORMAT: + case SqlParser.KW_OVER: + case SqlParser.KW_OVERLAPS: + case SqlParser.KW_OVERLAY: + case SqlParser.KW_OVERWRITE: + case SqlParser.KW_PARTITION: + case SqlParser.KW_PARTITIONED: + case SqlParser.KW_PARTITIONS: + case SqlParser.KW_PERCENTILE_CONT: + case SqlParser.KW_PERCENTILE_DISC: + case SqlParser.KW_PERCENTLIT: + case SqlParser.KW_PIVOT: + case SqlParser.KW_PLACING: + case SqlParser.KW_POSITION: + case SqlParser.KW_PRECEDING: + case SqlParser.KW_PRIMARY: + case SqlParser.KW_PRINCIPALS: + case SqlParser.KW_PROPERTIES: + case SqlParser.KW_PURGE: + case SqlParser.KW_QUARTER: + case SqlParser.KW_QUERY: + case SqlParser.KW_RANGE: + case SqlParser.KW_REAL: + case SqlParser.KW_RECORDREADER: + case SqlParser.KW_RECORDWRITER: + case SqlParser.KW_RECOVER: + case SqlParser.KW_REDUCE: + case SqlParser.KW_REFERENCES: + case SqlParser.KW_REFRESH: + case SqlParser.KW_RENAME: + case SqlParser.KW_REPAIR: + case SqlParser.KW_REPEATABLE: + case SqlParser.KW_REPLACE: + case SqlParser.KW_RESET: + case SqlParser.KW_RESPECT: + case SqlParser.KW_RESTRICT: + case SqlParser.KW_REWRITE: + case SqlParser.KW_REVOKE: + case SqlParser.KW_RIGHT: + case SqlParser.KW_RLIKE: + case SqlParser.KW_REGEXP: + case SqlParser.KW_ROLE: + case SqlParser.KW_ROLES: + case SqlParser.KW_ROLLBACK: + case SqlParser.KW_ROLLUP: + case SqlParser.KW_ROW: + case SqlParser.KW_ROWS: + case SqlParser.KW_SECOND: + case SqlParser.KW_SECONDS: + case SqlParser.KW_SCHEMA: + case SqlParser.KW_SCHEMAS: + case SqlParser.KW_SEMI: + case SqlParser.KW_SEPARATED: + case SqlParser.KW_SERDE: + case SqlParser.KW_SERDEPROPERTIES: + case SqlParser.KW_SESSION_USER: + case SqlParser.KW_SET: + case SqlParser.KW_MINUS: + case SqlParser.KW_SETS: + case SqlParser.KW_SHORT: + case SqlParser.KW_SHOW: + case SqlParser.KW_SINGLE: + case SqlParser.KW_SKEWED: + case SqlParser.KW_SMALLINT: + case SqlParser.KW_SOME: + case SqlParser.KW_SORT: + case SqlParser.KW_SORTED: + case SqlParser.KW_SOURCE: + case SqlParser.KW_START: + case SqlParser.KW_STATISTICS: + case SqlParser.KW_STORED: + case SqlParser.KW_STRATIFY: + case SqlParser.KW_STRING: + case SqlParser.KW_STRUCT: + case SqlParser.KW_SUBSTR: + case SqlParser.KW_SUBSTRING: + case SqlParser.KW_SYNC: + case SqlParser.KW_SYSTEM: + case SqlParser.KW_SYSTEM_TIME: + case SqlParser.KW_SYSTEM_VERSION: + case SqlParser.KW_TABLES: + case SqlParser.KW_TABLESAMPLE: + case SqlParser.KW_TARGET: + case SqlParser.KW_TBLPROPERTIES: + case SqlParser.KW_TEMPORARY: + case SqlParser.KW_TERMINATED: + case SqlParser.KW_THEN: + case SqlParser.KW_TIME: + case SqlParser.KW_TIMEDIFF: + case SqlParser.KW_TIMESTAMP: + case SqlParser.KW_TIMESTAMP_LTZ: + case SqlParser.KW_TIMESTAMP_NTZ: + case SqlParser.KW_TIMESTAMPADD: + case SqlParser.KW_TIMESTAMPDIFF: + case SqlParser.KW_TINYINT: + case SqlParser.KW_TO: + case SqlParser.KW_TOUCH: + case SqlParser.KW_TRAILING: + case SqlParser.KW_TRANSACTION: + case SqlParser.KW_TRANSACTIONS: + case SqlParser.KW_TRANSFORM: + case SqlParser.KW_TRIM: + case SqlParser.KW_TRUE: + case SqlParser.KW_TRUNCATE: + case SqlParser.KW_TRY_CAST: + case SqlParser.KW_TYPE: + case SqlParser.KW_UNARCHIVE: + case SqlParser.KW_UNBOUNDED: + case SqlParser.KW_UNCACHE: + case SqlParser.KW_UNION: + case SqlParser.KW_UNIQUE: + case SqlParser.KW_UNKNOWN: + case SqlParser.KW_UNLOCK: + case SqlParser.KW_UNPIVOT: + case SqlParser.KW_UNSET: + case SqlParser.KW_UPDATE: + case SqlParser.KW_USE: + case SqlParser.KW_USER: + case SqlParser.KW_USING: + case SqlParser.KW_VALUES: + case SqlParser.KW_VARCHAR: + case SqlParser.KW_VAR: + case SqlParser.KW_VARIABLE: + case SqlParser.KW_VERSION: + case SqlParser.KW_VIEW: + case SqlParser.KW_VIEWS: + case SqlParser.KW_VOID: + case SqlParser.KW_WEEK: + case SqlParser.KW_WEEKS: + case SqlParser.KW_WHEN: + case SqlParser.KW_WHERE: + case SqlParser.KW_WINDOW: + case SqlParser.KW_WITH: + case SqlParser.KW_WITHIN: + case SqlParser.KW_YEAR: + case SqlParser.KW_YEARS: + case SqlParser.KW_ZONE: + case SqlParser.KW_ZORDER: + case SqlParser.DOUBLEQUOTED_STRING: + case SqlParser.IDENTIFIER: + case SqlParser.BACKQUOTED_IDENTIFIER: + { + this.state = 1992; + this.assignmentList(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public notMatchedClause(): NotMatchedClauseContext { + let localContext = new NotMatchedClauseContext(this.context, this.state); + this.enterRule(localContext, 110, SqlParser.RULE_notMatchedClause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1997; + this.match(SqlParser.KW_WHEN); + this.state = 1998; + this.match(SqlParser.KW_NOT); + this.state = 1999; + this.match(SqlParser.KW_MATCHED); + this.state = 2002; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 31) { + { + this.state = 2000; + this.match(SqlParser.KW_BY); + this.state = 2001; + this.match(SqlParser.KW_TARGET); + } + } + + this.state = 2006; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 14) { + { + this.state = 2004; + this.match(SqlParser.KW_AND); + this.state = 2005; + localContext._notMatchedCond = this.booleanExpression(0); + } + } + + this.state = 2008; + this.match(SqlParser.KW_THEN); + this.state = 2009; + this.notMatchedAction(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public notMatchedBySourceClause(): NotMatchedBySourceClauseContext { + let localContext = new NotMatchedBySourceClauseContext(this.context, this.state); + this.enterRule(localContext, 112, SqlParser.RULE_notMatchedBySourceClause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2011; + this.match(SqlParser.KW_WHEN); + this.state = 2012; + this.match(SqlParser.KW_NOT); + this.state = 2013; + this.match(SqlParser.KW_MATCHED); + this.state = 2014; + this.match(SqlParser.KW_BY); + this.state = 2015; + this.match(SqlParser.KW_SOURCE); + this.state = 2018; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 14) { + { + this.state = 2016; + this.match(SqlParser.KW_AND); + this.state = 2017; + localContext._notMatchedBySourceCond = this.booleanExpression(0); + } + } + + this.state = 2020; + this.match(SqlParser.KW_THEN); + this.state = 2025; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_DELETE: + { + this.state = 2021; + this.match(SqlParser.KW_DELETE); + } + break; + case SqlParser.KW_UPDATE: + { + this.state = 2022; + this.match(SqlParser.KW_UPDATE); + this.state = 2023; + this.match(SqlParser.KW_SET); + this.state = 2024; + this.assignmentList(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public notMatchedAction(): NotMatchedActionContext { + let localContext = new NotMatchedActionContext(this.context, this.state); + this.enterRule(localContext, 114, SqlParser.RULE_notMatchedAction); + let _la: number; + try { + this.state = 2045; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 300, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2027; + this.match(SqlParser.KW_INSERT); + this.state = 2028; + this.match(SqlParser.ASTERISK); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2029; + this.match(SqlParser.KW_INSERT); + this.state = 2030; + this.match(SqlParser.LEFT_PAREN); + this.state = 2031; + this.multipartIdentifierList(); + this.state = 2032; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2033; + this.match(SqlParser.KW_VALUES); + this.state = 2034; + this.match(SqlParser.LEFT_PAREN); + this.state = 2035; + this.expression(); + this.state = 2040; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2036; + this.match(SqlParser.COMMA); + this.state = 2037; + this.expression(); + } + } + this.state = 2042; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2043; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public assignmentList(): AssignmentListContext { + let localContext = new AssignmentListContext(this.context, this.state); + this.enterRule(localContext, 116, SqlParser.RULE_assignmentList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2047; + this.assignment(); + this.state = 2052; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2048; + this.match(SqlParser.COMMA); + this.state = 2049; + this.assignment(); + } + } + this.state = 2054; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public assignment(): AssignmentContext { + let localContext = new AssignmentContext(this.context, this.state); + this.enterRule(localContext, 118, SqlParser.RULE_assignment); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2055; + localContext._key = this.multipartIdentifier(); + this.state = 2056; + this.match(SqlParser.EQ); + this.state = 2057; + localContext._value = this.expression(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public whereClause(): WhereClauseContext { + let localContext = new WhereClauseContext(this.context, this.state); + this.enterRule(localContext, 120, SqlParser.RULE_whereClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2059; + this.match(SqlParser.KW_WHERE); + this.state = 2060; + this.booleanExpression(0); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public havingClause(): HavingClauseContext { + let localContext = new HavingClauseContext(this.context, this.state); + this.enterRule(localContext, 122, SqlParser.RULE_havingClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2062; + this.match(SqlParser.KW_HAVING); + this.state = 2063; + this.booleanExpression(0); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public hint(): HintContext { + let localContext = new HintContext(this.context, this.state); + this.enterRule(localContext, 124, SqlParser.RULE_hint); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2065; + this.match(SqlParser.HENT_START); + this.state = 2066; + localContext._hintStatement = this.hintStatement(); + localContext._hintStatements.push(localContext._hintStatement); + this.state = 2073; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967056) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 377)) & ~0x1F) === 0 && ((1 << (_la - 377)) & 3073) !== 0)) { + { + { + this.state = 2068; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 4) { + { + this.state = 2067; + this.match(SqlParser.COMMA); + } + } + + this.state = 2070; + localContext._hintStatement = this.hintStatement(); + localContext._hintStatements.push(localContext._hintStatement); + } + } + this.state = 2075; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2076; + this.match(SqlParser.HENT_END); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public hintStatement(): HintStatementContext { + let localContext = new HintStatementContext(this.context, this.state); + this.enterRule(localContext, 126, SqlParser.RULE_hintStatement); + let _la: number; + try { + this.state = 2091; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 305, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2078; + localContext._hintName = this.identifier(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2079; + localContext._hintName = this.identifier(); + this.state = 2080; + this.match(SqlParser.LEFT_PAREN); + this.state = 2081; + localContext._primaryExpression = this.primaryExpression(0); + localContext._parameters.push(localContext._primaryExpression); + this.state = 2086; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2082; + this.match(SqlParser.COMMA); + this.state = 2083; + localContext._primaryExpression = this.primaryExpression(0); + localContext._parameters.push(localContext._primaryExpression); + } + } + this.state = 2088; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2089; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fromClause(): FromClauseContext { + let localContext = new FromClauseContext(this.context, this.state); + this.enterRule(localContext, 128, SqlParser.RULE_fromClause); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 2093; + this.match(SqlParser.KW_FROM); + this.state = 2094; + this.relation(); + this.state = 2099; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 306, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2095; + this.match(SqlParser.COMMA); + this.state = 2096; + this.relation(); + } + } + } + this.state = 2101; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 306, this.context); + } + this.state = 2105; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 307, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2102; + this.lateralView(); + } + } + } + this.state = 2107; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 307, this.context); + } + this.state = 2109; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 308, this.context) ) { + case 1: + { + this.state = 2108; + this.pivotClause(); + } + break; + } + this.state = 2112; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 309, this.context) ) { + case 1: + { + this.state = 2111; + this.unpivotClause(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public temporalClause(): TemporalClauseContext { + let localContext = new TemporalClauseContext(this.context, this.state); + this.enterRule(localContext, 130, SqlParser.RULE_temporalClause); + let _la: number; + try { + this.state = 2131; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 313, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2115; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 119) { + { + this.state = 2114; + this.match(SqlParser.KW_FOR); + } + } + + this.state = 2117; + _la = this.tokenStream.LA(1); + if(!(_la === 291 || _la === 336)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2118; + this.match(SqlParser.KW_AS); + this.state = 2119; + this.match(SqlParser.KW_OF); + this.state = 2122; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.INTEGER_VALUE: + { + this.state = 2120; + this.match(SqlParser.INTEGER_VALUE); + } + break; + case SqlParser.STRING_LITERAL: + case SqlParser.DOUBLEQUOTED_STRING: + { + this.state = 2121; + this.stringLit(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2125; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 119) { + { + this.state = 2124; + this.match(SqlParser.KW_FOR); + } + } + + this.state = 2127; + _la = this.tokenStream.LA(1); + if(!(_la === 290 || _la === 302)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2128; + this.match(SqlParser.KW_AS); + this.state = 2129; + this.match(SqlParser.KW_OF); + this.state = 2130; + localContext._timestamp = this.valueExpression(0); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public aggregationClause(): AggregationClauseContext { + let localContext = new AggregationClauseContext(this.context, this.state); + this.enterRule(localContext, 132, SqlParser.RULE_aggregationClause); + let _la: number; + try { + let alternative: number; + this.state = 2172; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 318, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2133; + this.match(SqlParser.KW_GROUP); + this.state = 2134; + this.match(SqlParser.KW_BY); + this.state = 2135; + localContext._groupByClause = this.groupByClause(); + localContext._groupingExpressionsWithGroupingAnalytics.push(localContext._groupByClause); + this.state = 2140; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 314, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2136; + this.match(SqlParser.COMMA); + this.state = 2137; + localContext._groupByClause = this.groupByClause(); + localContext._groupingExpressionsWithGroupingAnalytics.push(localContext._groupByClause); + } + } + } + this.state = 2142; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 314, this.context); + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2143; + this.match(SqlParser.KW_GROUP); + this.state = 2144; + this.match(SqlParser.KW_BY); + this.state = 2145; + localContext._expression = this.expression(); + localContext._groupingExpressions.push(localContext._expression); + this.state = 2150; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 315, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2146; + this.match(SqlParser.COMMA); + this.state = 2147; + localContext._expression = this.expression(); + localContext._groupingExpressions.push(localContext._expression); + } + } + } + this.state = 2152; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 315, this.context); + } + this.state = 2170; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 317, this.context) ) { + case 1: + { + this.state = 2153; + this.match(SqlParser.KW_WITH); + this.state = 2154; + localContext._kind = this.match(SqlParser.KW_ROLLUP); + } + break; + case 2: + { + this.state = 2155; + this.match(SqlParser.KW_WITH); + this.state = 2156; + localContext._kind = this.match(SqlParser.KW_CUBE); + } + break; + case 3: + { + this.state = 2157; + localContext._kind = this.match(SqlParser.KW_GROUPING); + this.state = 2158; + this.match(SqlParser.KW_SETS); + this.state = 2159; + this.match(SqlParser.LEFT_PAREN); + this.state = 2160; + this.groupingSet(); + this.state = 2165; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2161; + this.match(SqlParser.COMMA); + this.state = 2162; + this.groupingSet(); + } + } + this.state = 2167; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2168; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public groupByClause(): GroupByClauseContext { + let localContext = new GroupByClauseContext(this.context, this.state); + this.enterRule(localContext, 134, SqlParser.RULE_groupByClause); + try { + this.state = 2177; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 319, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2174; + this.columnName(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2175; + this.groupingAnalytics(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 2176; + this.expression(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public groupingAnalytics(): GroupingAnalyticsContext { + let localContext = new GroupingAnalyticsContext(this.context, this.state); + this.enterRule(localContext, 136, SqlParser.RULE_groupingAnalytics); + let _la: number; + try { + this.state = 2210; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_CUBE: + case SqlParser.KW_ROLLUP: + this.enterOuterAlt(localContext, 1); + { + this.state = 2179; + _la = this.tokenStream.LA(1); + if(!(_la === 61 || _la === 255)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2180; + this.match(SqlParser.LEFT_PAREN); + this.state = 2181; + this.groupingSet(); + this.state = 2186; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2182; + this.match(SqlParser.COMMA); + this.state = 2183; + this.groupingSet(); + } + } + this.state = 2188; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2189; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case SqlParser.KW_GROUPING: + this.enterOuterAlt(localContext, 2); + { + this.state = 2191; + this.match(SqlParser.KW_GROUPING); + this.state = 2192; + this.match(SqlParser.KW_SETS); + this.state = 2193; + this.match(SqlParser.LEFT_PAREN); + this.state = 2196; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 321, this.context) ) { + case 1: + { + this.state = 2194; + this.groupingAnalytics(); + } + break; + case 2: + { + this.state = 2195; + this.groupingSet(); + } + break; + } + this.state = 2205; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2198; + this.match(SqlParser.COMMA); + this.state = 2201; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 322, this.context) ) { + case 1: + { + this.state = 2199; + this.groupingAnalytics(); + } + break; + case 2: + { + this.state = 2200; + this.groupingSet(); + } + break; + } + } + } + this.state = 2207; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2208; + this.match(SqlParser.RIGHT_PAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public groupingSet(): GroupingSetContext { + let localContext = new GroupingSetContext(this.context, this.state); + this.enterRule(localContext, 138, SqlParser.RULE_groupingSet); + let _la: number; + try { + this.state = 2232; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 329, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2212; + this.columnName(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2213; + this.expression(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 2214; + this.match(SqlParser.LEFT_PAREN); + this.state = 2229; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 328, this.context) ) { + case 1: + { + this.state = 2217; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 325, this.context) ) { + case 1: + { + this.state = 2215; + this.columnName(); + } + break; + case 2: + { + this.state = 2216; + this.expression(); + } + break; + } + this.state = 2226; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2219; + this.match(SqlParser.COMMA); + this.state = 2222; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 326, this.context) ) { + case 1: + { + this.state = 2220; + this.columnName(); + } + break; + case 2: + { + this.state = 2221; + this.expression(); + } + break; + } + } + } + this.state = 2228; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; + } + this.state = 2231; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public pivotClause(): PivotClauseContext { + let localContext = new PivotClauseContext(this.context, this.state); + this.enterRule(localContext, 140, SqlParser.RULE_pivotClause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2234; + this.match(SqlParser.KW_PIVOT); + this.state = 2235; + this.match(SqlParser.LEFT_PAREN); + this.state = 2236; + localContext._aggregates = this.namedExpressionSeq(); + this.state = 2237; + this.match(SqlParser.KW_FOR); + this.state = 2238; + this.pivotColumn(); + this.state = 2239; + this.match(SqlParser.KW_IN); + this.state = 2240; + this.match(SqlParser.LEFT_PAREN); + this.state = 2241; + localContext._pivotValue = this.pivotValue(); + localContext._pivotValues.push(localContext._pivotValue); + this.state = 2246; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2242; + this.match(SqlParser.COMMA); + this.state = 2243; + localContext._pivotValue = this.pivotValue(); + localContext._pivotValues.push(localContext._pivotValue); + } + } + this.state = 2248; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2249; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2250; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public pivotColumn(): PivotColumnContext { + let localContext = new PivotColumnContext(this.context, this.state); + this.enterRule(localContext, 142, SqlParser.RULE_pivotColumn); + let _la: number; + try { + this.state = 2264; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_ADD: + case SqlParser.KW_AFTER: + case SqlParser.KW_ALL: + case SqlParser.KW_ALTER: + case SqlParser.KW_ALWAYS: + case SqlParser.KW_ANALYZE: + case SqlParser.KW_AND: + case SqlParser.KW_ANTI: + case SqlParser.KW_ANY: + case SqlParser.KW_ANY_VALUE: + case SqlParser.KW_ARCHIVE: + case SqlParser.KW_ARRAY: + case SqlParser.KW_AS: + case SqlParser.KW_ASC: + case SqlParser.KW_AT: + case SqlParser.KW_AUTHORIZATION: + case SqlParser.KW_BETWEEN: + case SqlParser.KW_BIGINT: + case SqlParser.KW_BINARY: + case SqlParser.KW_BOOLEAN: + case SqlParser.KW_BOTH: + case SqlParser.KW_BUCKET: + case SqlParser.KW_BUCKETS: + case SqlParser.KW_BY: + case SqlParser.KW_BYTE: + case SqlParser.KW_CACHE: + case SqlParser.KW_CASCADE: + case SqlParser.KW_CASE: + case SqlParser.KW_CAST: + case SqlParser.KW_CATALOG: + case SqlParser.KW_CATALOGS: + case SqlParser.KW_CHANGE: + case SqlParser.KW_CHAR: + case SqlParser.KW_CHARACTER: + case SqlParser.KW_CHECK: + case SqlParser.KW_CLEAR: + case SqlParser.KW_CLUSTER: + case SqlParser.KW_CLUSTERED: + case SqlParser.KW_CODEGEN: + case SqlParser.KW_COLLATE: + case SqlParser.KW_COLLECTION: + case SqlParser.KW_COLUMN: + case SqlParser.KW_COLUMNS: + case SqlParser.KW_COMMENT: + case SqlParser.KW_COMMIT: + case SqlParser.KW_COMPACT: + case SqlParser.KW_COMPACTIONS: + case SqlParser.KW_COMPUTE: + case SqlParser.KW_CONCATENATE: + case SqlParser.KW_CONSTRAINT: + case SqlParser.KW_COST: + case SqlParser.KW_CREATE: + case SqlParser.KW_CROSS: + case SqlParser.KW_CUBE: + case SqlParser.KW_CURRENT: + case SqlParser.KW_CURRENT_DATE: + case SqlParser.KW_CURRENT_TIME: + case SqlParser.KW_CURRENT_TIMESTAMP: + case SqlParser.KW_CURRENT_USER: + case SqlParser.KW_DAY: + case SqlParser.KW_DAYS: + case SqlParser.KW_DAYOFYEAR: + case SqlParser.KW_DATA: + case SqlParser.KW_DATE: + case SqlParser.KW_DATABASE: + case SqlParser.KW_DATABASES: + case SqlParser.KW_DATEADD: + case SqlParser.KW_DATE_ADD: + case SqlParser.KW_DATEDIFF: + case SqlParser.KW_DATE_DIFF: + case SqlParser.KW_DBPROPERTIES: + case SqlParser.KW_DEC: + case SqlParser.KW_DECIMAL: + case SqlParser.KW_DECLARE: + case SqlParser.KW_DEFAULT: + case SqlParser.KW_DEFINED: + case SqlParser.KW_DELETE: + case SqlParser.KW_DELIMITED: + case SqlParser.KW_DESC: + case SqlParser.KW_DESCRIBE: + case SqlParser.KW_DFS: + case SqlParser.KW_DIRECTORIES: + case SqlParser.KW_DIRECTORY: + case SqlParser.KW_DISABLE: + case SqlParser.KW_DISTINCT: + case SqlParser.KW_DISTRIBUTE: + case SqlParser.KW_DIV: + case SqlParser.KW_DOUBLE: + case SqlParser.KW_DROP: + case SqlParser.KW_ELSE: + case SqlParser.KW_ENABLE: + case SqlParser.KW_END: + case SqlParser.KW_ESCAPE: + case SqlParser.KW_ESCAPED: + case SqlParser.KW_EXCEPT: + case SqlParser.KW_EXCHANGE: + case SqlParser.KW_EXCLUDE: + case SqlParser.KW_EXISTS: + case SqlParser.KW_EXPLAIN: + case SqlParser.KW_EXPORT: + case SqlParser.KW_EXTENDED: + case SqlParser.KW_EXTERNAL: + case SqlParser.KW_EXTRACT: + case SqlParser.KW_FALSE: + case SqlParser.KW_FETCH: + case SqlParser.KW_FIELDS: + case SqlParser.KW_FILTER: + case SqlParser.KW_FILEFORMAT: + case SqlParser.KW_FIRST: + case SqlParser.KW_FLOAT: + case SqlParser.KW_FOLLOWING: + case SqlParser.KW_FOR: + case SqlParser.KW_FOREIGN: + case SqlParser.KW_FORMAT: + case SqlParser.KW_FORMATTED: + case SqlParser.KW_FULL: + case SqlParser.KW_FUNCTION: + case SqlParser.KW_FUNCTIONS: + case SqlParser.KW_GENERATED: + case SqlParser.KW_GLOBAL: + case SqlParser.KW_GRANT: + case SqlParser.KW_GROUP: + case SqlParser.KW_GROUPING: + case SqlParser.KW_HAVING: + case SqlParser.KW_BINARY_HEX: + case SqlParser.KW_HOUR: + case SqlParser.KW_HOURS: + case SqlParser.KW_IDENTIFIER: + case SqlParser.KW_IF: + case SqlParser.KW_IGNORE: + case SqlParser.KW_IMPORT: + case SqlParser.KW_IN: + case SqlParser.KW_INCLUDE: + case SqlParser.KW_INDEX: + case SqlParser.KW_INDEXES: + case SqlParser.KW_INNER: + case SqlParser.KW_INPATH: + case SqlParser.KW_INPUTFORMAT: + case SqlParser.KW_INSERT: + case SqlParser.KW_INTERSECT: + case SqlParser.KW_INTERVAL: + case SqlParser.KW_INT: + case SqlParser.KW_INTEGER: + case SqlParser.KW_INTO: + case SqlParser.KW_IS: + case SqlParser.KW_ITEMS: + case SqlParser.KW_JOIN: + case SqlParser.KW_KEYS: + case SqlParser.KW_LAST: + case SqlParser.KW_LATERAL: + case SqlParser.KW_LAZY: + case SqlParser.KW_LEADING: + case SqlParser.KW_LEFT: + case SqlParser.KW_LIFECYCLE: + case SqlParser.KW_LIKE: + case SqlParser.KW_ILIKE: + case SqlParser.KW_LIMIT: + case SqlParser.KW_LINES: + case SqlParser.KW_LIST: + case SqlParser.KW_LOAD: + case SqlParser.KW_LOCAL: + case SqlParser.KW_LOCATION: + case SqlParser.KW_LOCK: + case SqlParser.KW_LOCKS: + case SqlParser.KW_LOGICAL: + case SqlParser.KW_LONG: + case SqlParser.KW_MACRO: + case SqlParser.KW_MAP: + case SqlParser.KW_MATCHED: + case SqlParser.KW_MERGE: + case SqlParser.KW_MICROSECOND: + case SqlParser.KW_MICROSECONDS: + case SqlParser.KW_MILLISECOND: + case SqlParser.KW_MILLISECONDS: + case SqlParser.KW_MINUTE: + case SqlParser.KW_MINUTES: + case SqlParser.KW_MONTH: + case SqlParser.KW_MONTHS: + case SqlParser.KW_MSCK: + case SqlParser.KW_NAME: + case SqlParser.KW_NAMESPACE: + case SqlParser.KW_NAMESPACES: + case SqlParser.KW_NANOSECOND: + case SqlParser.KW_NANOSECONDS: + case SqlParser.KW_NATURAL: + case SqlParser.KW_NO: + case SqlParser.KW_NOT: + case SqlParser.KW_NULL: + case SqlParser.KW_NULLS: + case SqlParser.KW_NUMERIC: + case SqlParser.KW_OF: + case SqlParser.KW_OFFSET: + case SqlParser.KW_ON: + case SqlParser.KW_ONLY: + case SqlParser.KW_OPTIMIZE: + case SqlParser.KW_OPTION: + case SqlParser.KW_OPTIONS: + case SqlParser.KW_OR: + case SqlParser.KW_ORDER: + case SqlParser.KW_OUT: + case SqlParser.KW_OUTER: + case SqlParser.KW_OUTPUTFORMAT: + case SqlParser.KW_OVER: + case SqlParser.KW_OVERLAPS: + case SqlParser.KW_OVERLAY: + case SqlParser.KW_OVERWRITE: + case SqlParser.KW_PARTITION: + case SqlParser.KW_PARTITIONED: + case SqlParser.KW_PARTITIONS: + case SqlParser.KW_PERCENTILE_CONT: + case SqlParser.KW_PERCENTILE_DISC: + case SqlParser.KW_PERCENTLIT: + case SqlParser.KW_PIVOT: + case SqlParser.KW_PLACING: + case SqlParser.KW_POSITION: + case SqlParser.KW_PRECEDING: + case SqlParser.KW_PRIMARY: + case SqlParser.KW_PRINCIPALS: + case SqlParser.KW_PROPERTIES: + case SqlParser.KW_PURGE: + case SqlParser.KW_QUARTER: + case SqlParser.KW_QUERY: + case SqlParser.KW_RANGE: + case SqlParser.KW_REAL: + case SqlParser.KW_RECORDREADER: + case SqlParser.KW_RECORDWRITER: + case SqlParser.KW_RECOVER: + case SqlParser.KW_REDUCE: + case SqlParser.KW_REFERENCES: + case SqlParser.KW_REFRESH: + case SqlParser.KW_RENAME: + case SqlParser.KW_REPAIR: + case SqlParser.KW_REPEATABLE: + case SqlParser.KW_REPLACE: + case SqlParser.KW_RESET: + case SqlParser.KW_RESPECT: + case SqlParser.KW_RESTRICT: + case SqlParser.KW_REWRITE: + case SqlParser.KW_REVOKE: + case SqlParser.KW_RIGHT: + case SqlParser.KW_RLIKE: + case SqlParser.KW_REGEXP: + case SqlParser.KW_ROLE: + case SqlParser.KW_ROLES: + case SqlParser.KW_ROLLBACK: + case SqlParser.KW_ROLLUP: + case SqlParser.KW_ROW: + case SqlParser.KW_ROWS: + case SqlParser.KW_SECOND: + case SqlParser.KW_SECONDS: + case SqlParser.KW_SCHEMA: + case SqlParser.KW_SCHEMAS: + case SqlParser.KW_SEMI: + case SqlParser.KW_SEPARATED: + case SqlParser.KW_SERDE: + case SqlParser.KW_SERDEPROPERTIES: + case SqlParser.KW_SESSION_USER: + case SqlParser.KW_SET: + case SqlParser.KW_MINUS: + case SqlParser.KW_SETS: + case SqlParser.KW_SHORT: + case SqlParser.KW_SHOW: + case SqlParser.KW_SINGLE: + case SqlParser.KW_SKEWED: + case SqlParser.KW_SMALLINT: + case SqlParser.KW_SOME: + case SqlParser.KW_SORT: + case SqlParser.KW_SORTED: + case SqlParser.KW_SOURCE: + case SqlParser.KW_START: + case SqlParser.KW_STATISTICS: + case SqlParser.KW_STORED: + case SqlParser.KW_STRATIFY: + case SqlParser.KW_STRING: + case SqlParser.KW_STRUCT: + case SqlParser.KW_SUBSTR: + case SqlParser.KW_SUBSTRING: + case SqlParser.KW_SYNC: + case SqlParser.KW_SYSTEM: + case SqlParser.KW_SYSTEM_TIME: + case SqlParser.KW_SYSTEM_VERSION: + case SqlParser.KW_TABLES: + case SqlParser.KW_TABLESAMPLE: + case SqlParser.KW_TARGET: + case SqlParser.KW_TBLPROPERTIES: + case SqlParser.KW_TEMPORARY: + case SqlParser.KW_TERMINATED: + case SqlParser.KW_THEN: + case SqlParser.KW_TIME: + case SqlParser.KW_TIMEDIFF: + case SqlParser.KW_TIMESTAMP: + case SqlParser.KW_TIMESTAMP_LTZ: + case SqlParser.KW_TIMESTAMP_NTZ: + case SqlParser.KW_TIMESTAMPADD: + case SqlParser.KW_TIMESTAMPDIFF: + case SqlParser.KW_TINYINT: + case SqlParser.KW_TO: + case SqlParser.KW_TOUCH: + case SqlParser.KW_TRAILING: + case SqlParser.KW_TRANSACTION: + case SqlParser.KW_TRANSACTIONS: + case SqlParser.KW_TRANSFORM: + case SqlParser.KW_TRIM: + case SqlParser.KW_TRUE: + case SqlParser.KW_TRUNCATE: + case SqlParser.KW_TRY_CAST: + case SqlParser.KW_TYPE: + case SqlParser.KW_UNARCHIVE: + case SqlParser.KW_UNBOUNDED: + case SqlParser.KW_UNCACHE: + case SqlParser.KW_UNION: + case SqlParser.KW_UNIQUE: + case SqlParser.KW_UNKNOWN: + case SqlParser.KW_UNLOCK: + case SqlParser.KW_UNPIVOT: + case SqlParser.KW_UNSET: + case SqlParser.KW_UPDATE: + case SqlParser.KW_USE: + case SqlParser.KW_USER: + case SqlParser.KW_USING: + case SqlParser.KW_VALUES: + case SqlParser.KW_VARCHAR: + case SqlParser.KW_VAR: + case SqlParser.KW_VARIABLE: + case SqlParser.KW_VERSION: + case SqlParser.KW_VIEW: + case SqlParser.KW_VIEWS: + case SqlParser.KW_VOID: + case SqlParser.KW_WEEK: + case SqlParser.KW_WEEKS: + case SqlParser.KW_WHEN: + case SqlParser.KW_WHERE: + case SqlParser.KW_WINDOW: + case SqlParser.KW_WITH: + case SqlParser.KW_WITHIN: + case SqlParser.KW_YEAR: + case SqlParser.KW_YEARS: + case SqlParser.KW_ZONE: + case SqlParser.KW_ZORDER: + case SqlParser.DOUBLEQUOTED_STRING: + case SqlParser.IDENTIFIER: + case SqlParser.BACKQUOTED_IDENTIFIER: + this.enterOuterAlt(localContext, 1); + { + this.state = 2252; + localContext._identifier = this.identifier(); + localContext._identifiers.push(localContext._identifier); + } + break; + case SqlParser.LEFT_PAREN: + this.enterOuterAlt(localContext, 2); + { + this.state = 2253; + this.match(SqlParser.LEFT_PAREN); + this.state = 2254; + localContext._identifier = this.identifier(); + localContext._identifiers.push(localContext._identifier); + this.state = 2259; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2255; + this.match(SqlParser.COMMA); + this.state = 2256; + localContext._identifier = this.identifier(); + localContext._identifiers.push(localContext._identifier); + } + } + this.state = 2261; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2262; + this.match(SqlParser.RIGHT_PAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public pivotValue(): PivotValueContext { + let localContext = new PivotValueContext(this.context, this.state); + this.enterRule(localContext, 144, SqlParser.RULE_pivotValue); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2266; + this.expression(); + this.state = 2271; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967040) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 377)) & ~0x1F) === 0 && ((1 << (_la - 377)) & 3073) !== 0)) { + { + this.state = 2268; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 333, this.context) ) { + case 1: + { + this.state = 2267; + this.match(SqlParser.KW_AS); + } + break; + } + this.state = 2270; + this.identifier(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public unpivotClause(): UnpivotClauseContext { + let localContext = new UnpivotClauseContext(this.context, this.state); + this.enterRule(localContext, 146, SqlParser.RULE_unpivotClause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2273; + this.match(SqlParser.KW_UNPIVOT); + this.state = 2276; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 104 || _la === 141) { + { + this.state = 2274; + _la = this.tokenStream.LA(1); + if(!(_la === 104 || _la === 141)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2275; + this.match(SqlParser.KW_NULLS); + } + } + + this.state = 2278; + this.match(SqlParser.LEFT_PAREN); + this.state = 2281; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_ADD: + case SqlParser.KW_AFTER: + case SqlParser.KW_ALL: + case SqlParser.KW_ALTER: + case SqlParser.KW_ALWAYS: + case SqlParser.KW_ANALYZE: + case SqlParser.KW_AND: + case SqlParser.KW_ANTI: + case SqlParser.KW_ANY: + case SqlParser.KW_ANY_VALUE: + case SqlParser.KW_ARCHIVE: + case SqlParser.KW_ARRAY: + case SqlParser.KW_AS: + case SqlParser.KW_ASC: + case SqlParser.KW_AT: + case SqlParser.KW_AUTHORIZATION: + case SqlParser.KW_BETWEEN: + case SqlParser.KW_BIGINT: + case SqlParser.KW_BINARY: + case SqlParser.KW_BOOLEAN: + case SqlParser.KW_BOTH: + case SqlParser.KW_BUCKET: + case SqlParser.KW_BUCKETS: + case SqlParser.KW_BY: + case SqlParser.KW_BYTE: + case SqlParser.KW_CACHE: + case SqlParser.KW_CASCADE: + case SqlParser.KW_CASE: + case SqlParser.KW_CAST: + case SqlParser.KW_CATALOG: + case SqlParser.KW_CATALOGS: + case SqlParser.KW_CHANGE: + case SqlParser.KW_CHAR: + case SqlParser.KW_CHARACTER: + case SqlParser.KW_CHECK: + case SqlParser.KW_CLEAR: + case SqlParser.KW_CLUSTER: + case SqlParser.KW_CLUSTERED: + case SqlParser.KW_CODEGEN: + case SqlParser.KW_COLLATE: + case SqlParser.KW_COLLECTION: + case SqlParser.KW_COLUMN: + case SqlParser.KW_COLUMNS: + case SqlParser.KW_COMMENT: + case SqlParser.KW_COMMIT: + case SqlParser.KW_COMPACT: + case SqlParser.KW_COMPACTIONS: + case SqlParser.KW_COMPUTE: + case SqlParser.KW_CONCATENATE: + case SqlParser.KW_CONSTRAINT: + case SqlParser.KW_COST: + case SqlParser.KW_CREATE: + case SqlParser.KW_CROSS: + case SqlParser.KW_CUBE: + case SqlParser.KW_CURRENT: + case SqlParser.KW_CURRENT_DATE: + case SqlParser.KW_CURRENT_TIME: + case SqlParser.KW_CURRENT_TIMESTAMP: + case SqlParser.KW_CURRENT_USER: + case SqlParser.KW_DAY: + case SqlParser.KW_DAYS: + case SqlParser.KW_DAYOFYEAR: + case SqlParser.KW_DATA: + case SqlParser.KW_DATE: + case SqlParser.KW_DATABASE: + case SqlParser.KW_DATABASES: + case SqlParser.KW_DATEADD: + case SqlParser.KW_DATE_ADD: + case SqlParser.KW_DATEDIFF: + case SqlParser.KW_DATE_DIFF: + case SqlParser.KW_DBPROPERTIES: + case SqlParser.KW_DEC: + case SqlParser.KW_DECIMAL: + case SqlParser.KW_DECLARE: + case SqlParser.KW_DEFAULT: + case SqlParser.KW_DEFINED: + case SqlParser.KW_DELETE: + case SqlParser.KW_DELIMITED: + case SqlParser.KW_DESC: + case SqlParser.KW_DESCRIBE: + case SqlParser.KW_DFS: + case SqlParser.KW_DIRECTORIES: + case SqlParser.KW_DIRECTORY: + case SqlParser.KW_DISABLE: + case SqlParser.KW_DISTINCT: + case SqlParser.KW_DISTRIBUTE: + case SqlParser.KW_DIV: + case SqlParser.KW_DOUBLE: + case SqlParser.KW_DROP: + case SqlParser.KW_ELSE: + case SqlParser.KW_ENABLE: + case SqlParser.KW_END: + case SqlParser.KW_ESCAPE: + case SqlParser.KW_ESCAPED: + case SqlParser.KW_EXCEPT: + case SqlParser.KW_EXCHANGE: + case SqlParser.KW_EXCLUDE: + case SqlParser.KW_EXISTS: + case SqlParser.KW_EXPLAIN: + case SqlParser.KW_EXPORT: + case SqlParser.KW_EXTENDED: + case SqlParser.KW_EXTERNAL: + case SqlParser.KW_EXTRACT: + case SqlParser.KW_FALSE: + case SqlParser.KW_FETCH: + case SqlParser.KW_FIELDS: + case SqlParser.KW_FILTER: + case SqlParser.KW_FILEFORMAT: + case SqlParser.KW_FIRST: + case SqlParser.KW_FLOAT: + case SqlParser.KW_FOLLOWING: + case SqlParser.KW_FOR: + case SqlParser.KW_FOREIGN: + case SqlParser.KW_FORMAT: + case SqlParser.KW_FORMATTED: + case SqlParser.KW_FULL: + case SqlParser.KW_FUNCTION: + case SqlParser.KW_FUNCTIONS: + case SqlParser.KW_GENERATED: + case SqlParser.KW_GLOBAL: + case SqlParser.KW_GRANT: + case SqlParser.KW_GROUP: + case SqlParser.KW_GROUPING: + case SqlParser.KW_HAVING: + case SqlParser.KW_BINARY_HEX: + case SqlParser.KW_HOUR: + case SqlParser.KW_HOURS: + case SqlParser.KW_IDENTIFIER: + case SqlParser.KW_IF: + case SqlParser.KW_IGNORE: + case SqlParser.KW_IMPORT: + case SqlParser.KW_IN: + case SqlParser.KW_INCLUDE: + case SqlParser.KW_INDEX: + case SqlParser.KW_INDEXES: + case SqlParser.KW_INNER: + case SqlParser.KW_INPATH: + case SqlParser.KW_INPUTFORMAT: + case SqlParser.KW_INSERT: + case SqlParser.KW_INTERSECT: + case SqlParser.KW_INTERVAL: + case SqlParser.KW_INT: + case SqlParser.KW_INTEGER: + case SqlParser.KW_INTO: + case SqlParser.KW_IS: + case SqlParser.KW_ITEMS: + case SqlParser.KW_JOIN: + case SqlParser.KW_KEYS: + case SqlParser.KW_LAST: + case SqlParser.KW_LATERAL: + case SqlParser.KW_LAZY: + case SqlParser.KW_LEADING: + case SqlParser.KW_LEFT: + case SqlParser.KW_LIFECYCLE: + case SqlParser.KW_LIKE: + case SqlParser.KW_ILIKE: + case SqlParser.KW_LIMIT: + case SqlParser.KW_LINES: + case SqlParser.KW_LIST: + case SqlParser.KW_LOAD: + case SqlParser.KW_LOCAL: + case SqlParser.KW_LOCATION: + case SqlParser.KW_LOCK: + case SqlParser.KW_LOCKS: + case SqlParser.KW_LOGICAL: + case SqlParser.KW_LONG: + case SqlParser.KW_MACRO: + case SqlParser.KW_MAP: + case SqlParser.KW_MATCHED: + case SqlParser.KW_MERGE: + case SqlParser.KW_MICROSECOND: + case SqlParser.KW_MICROSECONDS: + case SqlParser.KW_MILLISECOND: + case SqlParser.KW_MILLISECONDS: + case SqlParser.KW_MINUTE: + case SqlParser.KW_MINUTES: + case SqlParser.KW_MONTH: + case SqlParser.KW_MONTHS: + case SqlParser.KW_MSCK: + case SqlParser.KW_NAME: + case SqlParser.KW_NAMESPACE: + case SqlParser.KW_NAMESPACES: + case SqlParser.KW_NANOSECOND: + case SqlParser.KW_NANOSECONDS: + case SqlParser.KW_NATURAL: + case SqlParser.KW_NO: + case SqlParser.KW_NOT: + case SqlParser.KW_NULL: + case SqlParser.KW_NULLS: + case SqlParser.KW_NUMERIC: + case SqlParser.KW_OF: + case SqlParser.KW_OFFSET: + case SqlParser.KW_ON: + case SqlParser.KW_ONLY: + case SqlParser.KW_OPTIMIZE: + case SqlParser.KW_OPTION: + case SqlParser.KW_OPTIONS: + case SqlParser.KW_OR: + case SqlParser.KW_ORDER: + case SqlParser.KW_OUT: + case SqlParser.KW_OUTER: + case SqlParser.KW_OUTPUTFORMAT: + case SqlParser.KW_OVER: + case SqlParser.KW_OVERLAPS: + case SqlParser.KW_OVERLAY: + case SqlParser.KW_OVERWRITE: + case SqlParser.KW_PARTITION: + case SqlParser.KW_PARTITIONED: + case SqlParser.KW_PARTITIONS: + case SqlParser.KW_PERCENTILE_CONT: + case SqlParser.KW_PERCENTILE_DISC: + case SqlParser.KW_PERCENTLIT: + case SqlParser.KW_PIVOT: + case SqlParser.KW_PLACING: + case SqlParser.KW_POSITION: + case SqlParser.KW_PRECEDING: + case SqlParser.KW_PRIMARY: + case SqlParser.KW_PRINCIPALS: + case SqlParser.KW_PROPERTIES: + case SqlParser.KW_PURGE: + case SqlParser.KW_QUARTER: + case SqlParser.KW_QUERY: + case SqlParser.KW_RANGE: + case SqlParser.KW_REAL: + case SqlParser.KW_RECORDREADER: + case SqlParser.KW_RECORDWRITER: + case SqlParser.KW_RECOVER: + case SqlParser.KW_REDUCE: + case SqlParser.KW_REFERENCES: + case SqlParser.KW_REFRESH: + case SqlParser.KW_RENAME: + case SqlParser.KW_REPAIR: + case SqlParser.KW_REPEATABLE: + case SqlParser.KW_REPLACE: + case SqlParser.KW_RESET: + case SqlParser.KW_RESPECT: + case SqlParser.KW_RESTRICT: + case SqlParser.KW_REWRITE: + case SqlParser.KW_REVOKE: + case SqlParser.KW_RIGHT: + case SqlParser.KW_RLIKE: + case SqlParser.KW_REGEXP: + case SqlParser.KW_ROLE: + case SqlParser.KW_ROLES: + case SqlParser.KW_ROLLBACK: + case SqlParser.KW_ROLLUP: + case SqlParser.KW_ROW: + case SqlParser.KW_ROWS: + case SqlParser.KW_SECOND: + case SqlParser.KW_SECONDS: + case SqlParser.KW_SCHEMA: + case SqlParser.KW_SCHEMAS: + case SqlParser.KW_SEMI: + case SqlParser.KW_SEPARATED: + case SqlParser.KW_SERDE: + case SqlParser.KW_SERDEPROPERTIES: + case SqlParser.KW_SESSION_USER: + case SqlParser.KW_SET: + case SqlParser.KW_MINUS: + case SqlParser.KW_SETS: + case SqlParser.KW_SHORT: + case SqlParser.KW_SHOW: + case SqlParser.KW_SINGLE: + case SqlParser.KW_SKEWED: + case SqlParser.KW_SMALLINT: + case SqlParser.KW_SOME: + case SqlParser.KW_SORT: + case SqlParser.KW_SORTED: + case SqlParser.KW_SOURCE: + case SqlParser.KW_START: + case SqlParser.KW_STATISTICS: + case SqlParser.KW_STORED: + case SqlParser.KW_STRATIFY: + case SqlParser.KW_STRING: + case SqlParser.KW_STRUCT: + case SqlParser.KW_SUBSTR: + case SqlParser.KW_SUBSTRING: + case SqlParser.KW_SYNC: + case SqlParser.KW_SYSTEM: + case SqlParser.KW_SYSTEM_TIME: + case SqlParser.KW_SYSTEM_VERSION: + case SqlParser.KW_TABLES: + case SqlParser.KW_TABLESAMPLE: + case SqlParser.KW_TARGET: + case SqlParser.KW_TBLPROPERTIES: + case SqlParser.KW_TEMPORARY: + case SqlParser.KW_TERMINATED: + case SqlParser.KW_THEN: + case SqlParser.KW_TIME: + case SqlParser.KW_TIMEDIFF: + case SqlParser.KW_TIMESTAMP: + case SqlParser.KW_TIMESTAMP_LTZ: + case SqlParser.KW_TIMESTAMP_NTZ: + case SqlParser.KW_TIMESTAMPADD: + case SqlParser.KW_TIMESTAMPDIFF: + case SqlParser.KW_TINYINT: + case SqlParser.KW_TO: + case SqlParser.KW_TOUCH: + case SqlParser.KW_TRAILING: + case SqlParser.KW_TRANSACTION: + case SqlParser.KW_TRANSACTIONS: + case SqlParser.KW_TRANSFORM: + case SqlParser.KW_TRIM: + case SqlParser.KW_TRUE: + case SqlParser.KW_TRUNCATE: + case SqlParser.KW_TRY_CAST: + case SqlParser.KW_TYPE: + case SqlParser.KW_UNARCHIVE: + case SqlParser.KW_UNBOUNDED: + case SqlParser.KW_UNCACHE: + case SqlParser.KW_UNION: + case SqlParser.KW_UNIQUE: + case SqlParser.KW_UNKNOWN: + case SqlParser.KW_UNLOCK: + case SqlParser.KW_UNPIVOT: + case SqlParser.KW_UNSET: + case SqlParser.KW_UPDATE: + case SqlParser.KW_USE: + case SqlParser.KW_USER: + case SqlParser.KW_USING: + case SqlParser.KW_VALUES: + case SqlParser.KW_VARCHAR: + case SqlParser.KW_VAR: + case SqlParser.KW_VARIABLE: + case SqlParser.KW_VERSION: + case SqlParser.KW_VIEW: + case SqlParser.KW_VIEWS: + case SqlParser.KW_VOID: + case SqlParser.KW_WEEK: + case SqlParser.KW_WEEKS: + case SqlParser.KW_WHEN: + case SqlParser.KW_WHERE: + case SqlParser.KW_WINDOW: + case SqlParser.KW_WITH: + case SqlParser.KW_WITHIN: + case SqlParser.KW_YEAR: + case SqlParser.KW_YEARS: + case SqlParser.KW_ZONE: + case SqlParser.KW_ZORDER: + case SqlParser.DOUBLEQUOTED_STRING: + case SqlParser.IDENTIFIER: + case SqlParser.BACKQUOTED_IDENTIFIER: + { + this.state = 2279; + this.unpivotSingleValueColumnClause(); + } + break; + case SqlParser.LEFT_PAREN: + { + this.state = 2280; + this.unpivotMultiValueColumnClause(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 2283; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2288; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 338, this.context) ) { + case 1: + { + this.state = 2285; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 337, this.context) ) { + case 1: + { + this.state = 2284; + this.match(SqlParser.KW_AS); + } + break; + } + this.state = 2287; + this.identifier(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public unpivotSingleValueColumnClause(): UnpivotSingleValueColumnClauseContext { + let localContext = new UnpivotSingleValueColumnClauseContext(this.context, this.state); + this.enterRule(localContext, 148, SqlParser.RULE_unpivotSingleValueColumnClause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2290; + this.identifier(); + this.state = 2291; + this.match(SqlParser.KW_FOR); + this.state = 2292; + this.identifier(); + this.state = 2293; + this.match(SqlParser.KW_IN); + this.state = 2294; + this.match(SqlParser.LEFT_PAREN); + this.state = 2295; + localContext._unpivotColumnAndAlias = this.unpivotColumnAndAlias(); + localContext._unpivotColumns.push(localContext._unpivotColumnAndAlias); + this.state = 2300; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2296; + this.match(SqlParser.COMMA); + this.state = 2297; + localContext._unpivotColumnAndAlias = this.unpivotColumnAndAlias(); + localContext._unpivotColumns.push(localContext._unpivotColumnAndAlias); + } + } + this.state = 2302; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2303; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public unpivotMultiValueColumnClause(): UnpivotMultiValueColumnClauseContext { + let localContext = new UnpivotMultiValueColumnClauseContext(this.context, this.state); + this.enterRule(localContext, 150, SqlParser.RULE_unpivotMultiValueColumnClause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2305; + this.match(SqlParser.LEFT_PAREN); + this.state = 2306; + localContext._identifier = this.identifier(); + localContext._unpivotValueColumns.push(localContext._identifier); + this.state = 2311; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2307; + this.match(SqlParser.COMMA); + this.state = 2308; + localContext._identifier = this.identifier(); + localContext._unpivotValueColumns.push(localContext._identifier); + } + } + this.state = 2313; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2314; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2315; + this.match(SqlParser.KW_FOR); + this.state = 2316; + this.identifier(); + this.state = 2317; + this.match(SqlParser.KW_IN); + this.state = 2318; + this.match(SqlParser.LEFT_PAREN); + this.state = 2319; + localContext._unpivotColumnSet = this.unpivotColumnSet(); + localContext._unpivotColumnSets.push(localContext._unpivotColumnSet); + this.state = 2324; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2320; + this.match(SqlParser.COMMA); + this.state = 2321; + localContext._unpivotColumnSet = this.unpivotColumnSet(); + localContext._unpivotColumnSets.push(localContext._unpivotColumnSet); + } + } + this.state = 2326; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2327; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public unpivotColumnSet(): UnpivotColumnSetContext { + let localContext = new UnpivotColumnSetContext(this.context, this.state); + this.enterRule(localContext, 152, SqlParser.RULE_unpivotColumnSet); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2329; + this.match(SqlParser.LEFT_PAREN); + this.state = 2330; + localContext._multipartIdentifier = this.multipartIdentifier(); + localContext._unpivotColumns.push(localContext._multipartIdentifier); + this.state = 2335; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2331; + this.match(SqlParser.COMMA); + this.state = 2332; + localContext._multipartIdentifier = this.multipartIdentifier(); + localContext._unpivotColumns.push(localContext._multipartIdentifier); + } + } + this.state = 2337; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2338; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2343; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967040) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 377)) & ~0x1F) === 0 && ((1 << (_la - 377)) & 3073) !== 0)) { + { + this.state = 2340; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 343, this.context) ) { + case 1: + { + this.state = 2339; + this.match(SqlParser.KW_AS); + } + break; + } + this.state = 2342; + this.identifier(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public unpivotColumnAndAlias(): UnpivotColumnAndAliasContext { + let localContext = new UnpivotColumnAndAliasContext(this.context, this.state); + this.enterRule(localContext, 154, SqlParser.RULE_unpivotColumnAndAlias); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2345; + this.multipartIdentifier(); + this.state = 2350; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967040) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 377)) & ~0x1F) === 0 && ((1 << (_la - 377)) & 3073) !== 0)) { + { + this.state = 2347; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 345, this.context) ) { + case 1: + { + this.state = 2346; + this.match(SqlParser.KW_AS); + } + break; + } + this.state = 2349; + this.identifier(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public ifNotExists(): IfNotExistsContext { + let localContext = new IfNotExistsContext(this.context, this.state); + this.enterRule(localContext, 156, SqlParser.RULE_ifNotExists); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2352; + this.match(SqlParser.KW_IF); + this.state = 2353; + this.match(SqlParser.KW_NOT); + this.state = 2354; + this.match(SqlParser.KW_EXISTS); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public ifExists(): IfExistsContext { + let localContext = new IfExistsContext(this.context, this.state); + this.enterRule(localContext, 158, SqlParser.RULE_ifExists); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2356; + this.match(SqlParser.KW_IF); + this.state = 2357; + this.match(SqlParser.KW_EXISTS); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public lateralView(): LateralViewContext { + let localContext = new LateralViewContext(this.context, this.state); + this.enterRule(localContext, 160, SqlParser.RULE_lateralView); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 2359; + this.match(SqlParser.KW_LATERAL); + this.state = 2360; + this.match(SqlParser.KW_VIEW); + this.state = 2362; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 347, this.context) ) { + case 1: + { + this.state = 2361; + this.match(SqlParser.KW_OUTER); + } + break; + } + this.state = 2364; + this.viewName(); + this.state = 2365; + this.match(SqlParser.LEFT_PAREN); + this.state = 2374; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 359)) & ~0x1F) === 0 && ((1 << (_la - 359)) & 1073678415) !== 0)) { + { + this.state = 2366; + this.expression(); + this.state = 2371; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2367; + this.match(SqlParser.COMMA); + this.state = 2368; + this.expression(); + } + } + this.state = 2373; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + + this.state = 2376; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2377; + this.tableAlias(); + this.state = 2389; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 352, this.context) ) { + case 1: + { + this.state = 2379; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 350, this.context) ) { + case 1: + { + this.state = 2378; + this.match(SqlParser.KW_AS); + } + break; + } + this.state = 2381; + localContext._identifier = this.identifier(); + localContext._colName.push(localContext._identifier); + this.state = 2386; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 351, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2382; + this.match(SqlParser.COMMA); + this.state = 2383; + localContext._identifier = this.identifier(); + localContext._colName.push(localContext._identifier); + } + } + } + this.state = 2388; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 351, this.context); + } + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public setQuantifier(): SetQuantifierContext { + let localContext = new SetQuantifierContext(this.context, this.state); + this.enterRule(localContext, 162, SqlParser.RULE_setQuantifier); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2391; + _la = this.tokenStream.LA(1); + if(!(_la === 10 || _la === 92)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public relation(): RelationContext { + let localContext = new RelationContext(this.context, this.state); + this.enterRule(localContext, 164, SqlParser.RULE_relation); + try { + let alternative: number; + this.state = 2406; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 356, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2393; + this.tableName(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2395; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 353, this.context) ) { + case 1: + { + this.state = 2394; + this.match(SqlParser.KW_LATERAL); + } + break; + } + this.state = 2397; + this.relationPrimary(); + this.state = 2403; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 355, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + this.state = 2401; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_ANTI: + case SqlParser.KW_CROSS: + case SqlParser.KW_FULL: + case SqlParser.KW_INNER: + case SqlParser.KW_JOIN: + case SqlParser.KW_LEFT: + case SqlParser.KW_NATURAL: + case SqlParser.KW_RIGHT: + case SqlParser.KW_SEMI: + { + this.state = 2398; + this.joinRelation(); + } + break; + case SqlParser.KW_PIVOT: + { + this.state = 2399; + this.pivotClause(); + } + break; + case SqlParser.KW_UNPIVOT: + { + this.state = 2400; + this.unpivotClause(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + this.state = 2405; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 355, this.context); + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public joinRelation(): JoinRelationContext { + let localContext = new JoinRelationContext(this.context, this.state); + this.enterRule(localContext, 166, SqlParser.RULE_joinRelation); + try { + this.state = 2425; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_ANTI: + case SqlParser.KW_CROSS: + case SqlParser.KW_FULL: + case SqlParser.KW_INNER: + case SqlParser.KW_JOIN: + case SqlParser.KW_LEFT: + case SqlParser.KW_RIGHT: + case SqlParser.KW_SEMI: + this.enterOuterAlt(localContext, 1); + { + { + this.state = 2408; + this.joinType(); + } + this.state = 2409; + this.match(SqlParser.KW_JOIN); + this.state = 2411; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 357, this.context) ) { + case 1: + { + this.state = 2410; + this.match(SqlParser.KW_LATERAL); + } + break; + } + this.state = 2413; + localContext._right = this.relationPrimary(); + this.state = 2415; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 358, this.context) ) { + case 1: + { + this.state = 2414; + this.joinCriteria(); + } + break; + } + } + break; + case SqlParser.KW_NATURAL: + this.enterOuterAlt(localContext, 2); + { + this.state = 2417; + this.match(SqlParser.KW_NATURAL); + this.state = 2418; + this.joinType(); + this.state = 2419; + this.match(SqlParser.KW_JOIN); + this.state = 2421; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 359, this.context) ) { + case 1: + { + this.state = 2420; + this.match(SqlParser.KW_LATERAL); + } + break; + } + this.state = 2423; + localContext._right = this.relationPrimary(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public joinType(): JoinTypeContext { + let localContext = new JoinTypeContext(this.context, this.state); + this.enterRule(localContext, 168, SqlParser.RULE_joinType); + let _la: number; + try { + this.state = 2443; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 365, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2428; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 144) { + { + this.state = 2427; + this.match(SqlParser.KW_INNER); + } + } + + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2430; + this.match(SqlParser.KW_CROSS); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 2431; + this.match(SqlParser.KW_LEFT); + this.state = 2433; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 210) { + { + this.state = 2432; + this.match(SqlParser.KW_OUTER); + } + } + + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 2436; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 161) { + { + this.state = 2435; + this.match(SqlParser.KW_LEFT); + } + } + + this.state = 2438; + _la = this.tokenStream.LA(1); + if(!(_la === 15 || _la === 263)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 2439; + _la = this.tokenStream.LA(1); + if(!(_la === 124 || _la === 249)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2441; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 210) { + { + this.state = 2440; + this.match(SqlParser.KW_OUTER); + } + } + + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public joinCriteria(): JoinCriteriaContext { + let localContext = new JoinCriteriaContext(this.context, this.state); + this.enterRule(localContext, 170, SqlParser.RULE_joinCriteria); + try { + this.state = 2449; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_ON: + this.enterOuterAlt(localContext, 1); + { + this.state = 2445; + this.match(SqlParser.KW_ON); + this.state = 2446; + this.booleanExpression(0); + } + break; + case SqlParser.KW_USING: + this.enterOuterAlt(localContext, 2); + { + this.state = 2447; + this.match(SqlParser.KW_USING); + this.state = 2448; + this.identifierList(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public sample(): SampleContext { + let localContext = new SampleContext(this.context, this.state); + this.enterRule(localContext, 172, SqlParser.RULE_sample); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2451; + this.match(SqlParser.KW_TABLESAMPLE); + this.state = 2452; + this.match(SqlParser.LEFT_PAREN); + this.state = 2454; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 359)) & ~0x1F) === 0 && ((1 << (_la - 359)) & 1073678415) !== 0)) { + { + this.state = 2453; + this.sampleMethod(); + } + } + + this.state = 2456; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2461; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 368, this.context) ) { + case 1: + { + this.state = 2457; + this.match(SqlParser.KW_REPEATABLE); + this.state = 2458; + this.match(SqlParser.LEFT_PAREN); + this.state = 2459; + localContext._seed = this.match(SqlParser.INTEGER_VALUE); + this.state = 2460; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public sampleMethod(): SampleMethodContext { + let localContext = new SampleMethodContext(this.context, this.state); + this.enterRule(localContext, 174, SqlParser.RULE_sampleMethod); + let _la: number; + try { + this.state = 2487; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 372, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2464; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 361) { + { + this.state = 2463; + localContext._negativeSign = this.match(SqlParser.MINUS); + } + } + + this.state = 2466; + localContext._percentage = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 381 || _la === 383)) { + localContext._percentage = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2467; + this.match(SqlParser.KW_PERCENTLIT); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2468; + this.expression(); + this.state = 2469; + this.match(SqlParser.KW_ROWS); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 2471; + localContext._sampleType = this.match(SqlParser.KW_BUCKET); + this.state = 2472; + localContext._numerator = this.match(SqlParser.INTEGER_VALUE); + this.state = 2473; + this.match(SqlParser.KW_OUT); + this.state = 2474; + this.match(SqlParser.KW_OF); + this.state = 2475; + localContext._denominator = this.match(SqlParser.INTEGER_VALUE); + this.state = 2484; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 202) { + { + this.state = 2476; + this.match(SqlParser.KW_ON); + this.state = 2482; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 370, this.context) ) { + case 1: + { + this.state = 2477; + this.identifier(); + } + break; + case 2: + { + this.state = 2478; + this.qualifiedName(); + this.state = 2479; + this.match(SqlParser.LEFT_PAREN); + this.state = 2480; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + } + + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 2486; + localContext._bytes = this.expression(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public identifierList(): IdentifierListContext { + let localContext = new IdentifierListContext(this.context, this.state); + this.enterRule(localContext, 176, SqlParser.RULE_identifierList); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2489; + this.match(SqlParser.LEFT_PAREN); + this.state = 2490; + this.identifierSeq(); + this.state = 2491; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public identifierSeq(): IdentifierSeqContext { + let localContext = new IdentifierSeqContext(this.context, this.state); + this.enterRule(localContext, 178, SqlParser.RULE_identifierSeq); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 2493; + localContext._errorCapturingIdentifier = this.errorCapturingIdentifier(); + localContext._ident.push(localContext._errorCapturingIdentifier); + this.state = 2498; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 373, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2494; + this.match(SqlParser.COMMA); + this.state = 2495; + localContext._errorCapturingIdentifier = this.errorCapturingIdentifier(); + localContext._ident.push(localContext._errorCapturingIdentifier); + } + } + } + this.state = 2500; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 373, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public orderedIdentifierList(): OrderedIdentifierListContext { + let localContext = new OrderedIdentifierListContext(this.context, this.state); + this.enterRule(localContext, 180, SqlParser.RULE_orderedIdentifierList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2501; + this.match(SqlParser.LEFT_PAREN); + this.state = 2502; + this.orderedIdentifier(); + this.state = 2507; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2503; + this.match(SqlParser.COMMA); + this.state = 2504; + this.orderedIdentifier(); + } + } + this.state = 2509; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2510; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public orderedIdentifier(): OrderedIdentifierContext { + let localContext = new OrderedIdentifierContext(this.context, this.state); + this.enterRule(localContext, 182, SqlParser.RULE_orderedIdentifier); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2512; + localContext._ident = this.errorCapturingIdentifier(); + this.state = 2514; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 21 || _la === 86) { + { + this.state = 2513; + localContext._ordering = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 21 || _la === 86)) { + localContext._ordering = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public identifierCommentList(): IdentifierCommentListContext { + let localContext = new IdentifierCommentListContext(this.context, this.state); + this.enterRule(localContext, 184, SqlParser.RULE_identifierCommentList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2516; + this.match(SqlParser.LEFT_PAREN); + this.state = 2517; + this.identifierComment(); + this.state = 2522; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2518; + this.match(SqlParser.COMMA); + this.state = 2519; + this.identifierComment(); + } + } + this.state = 2524; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2525; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public identifierComment(): IdentifierCommentContext { + let localContext = new IdentifierCommentContext(this.context, this.state); + this.enterRule(localContext, 186, SqlParser.RULE_identifierComment); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2527; + this.columnNameCreate(); + this.state = 2530; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 51) { + { + this.state = 2528; + this.match(SqlParser.KW_COMMENT); + this.state = 2529; + localContext._comment = this.stringLit(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public relationPrimary(): RelationPrimaryContext { + let localContext = new RelationPrimaryContext(this.context, this.state); + this.enterRule(localContext, 188, SqlParser.RULE_relationPrimary); + let _la: number; + try { + let alternative: number; + this.state = 2587; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 386, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2535; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 378, this.context) ) { + case 1: + { + this.state = 2532; + this.tableName(); + } + break; + case 2: + { + this.state = 2533; + this.viewName(); + } + break; + case 3: + { + this.state = 2534; + this.identifierReference(); + } + break; + } + this.state = 2538; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 379, this.context) ) { + case 1: + { + this.state = 2537; + this.temporalClause(); + } + break; + } + this.state = 2541; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 380, this.context) ) { + case 1: + { + this.state = 2540; + this.sample(); + } + break; + } + this.state = 2543; + this.tableAlias(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2545; + this.match(SqlParser.LEFT_PAREN); + this.state = 2546; + this.query(); + this.state = 2547; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2549; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 381, this.context) ) { + case 1: + { + this.state = 2548; + this.sample(); + } + break; + } + this.state = 2551; + this.tableAlias(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 2553; + this.match(SqlParser.LEFT_PAREN); + this.state = 2554; + this.relation(); + this.state = 2555; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2557; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 382, this.context) ) { + case 1: + { + this.state = 2556; + this.sample(); + } + break; + } + this.state = 2559; + this.tableAlias(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 2561; + this.match(SqlParser.KW_VALUES); + this.state = 2562; + this.expression(); + this.state = 2567; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 383, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2563; + this.match(SqlParser.COMMA); + this.state = 2564; + this.expression(); + } + } + } + this.state = 2569; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 383, this.context); + } + this.state = 2570; + this.tableAlias(); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 2572; + this.functionName(); + this.state = 2573; + this.match(SqlParser.LEFT_PAREN); + this.state = 2582; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967295) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 359)) & ~0x1F) === 0 && ((1 << (_la - 359)) & 1073678415) !== 0)) { + { + this.state = 2574; + this.functionTableArgument(); + this.state = 2579; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2575; + this.match(SqlParser.COMMA); + this.state = 2576; + this.functionTableArgument(); + } + } + this.state = 2581; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + + this.state = 2584; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2585; + this.tableAlias(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext { + let localContext = new FunctionTableSubqueryArgumentContext(this.context, this.state); + this.enterRule(localContext, 190, SqlParser.RULE_functionTableSubqueryArgument); + let _la: number; + try { + this.state = 2608; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 390, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2589; + this.match(SqlParser.KW_TABLE); + this.state = 2590; + this.tableName(); + this.state = 2592; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 93 || _la === 216 || _la === 345) { + { + this.state = 2591; + this.tableArgumentPartitioning(); + } + } + + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2594; + this.match(SqlParser.KW_TABLE); + this.state = 2595; + this.match(SqlParser.LEFT_PAREN); + this.state = 2596; + this.tableName(); + this.state = 2597; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2599; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 93 || _la === 216 || _la === 345) { + { + this.state = 2598; + this.tableArgumentPartitioning(); + } + } + + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 2601; + this.match(SqlParser.KW_TABLE); + this.state = 2602; + this.match(SqlParser.LEFT_PAREN); + this.state = 2603; + this.query(); + this.state = 2604; + this.match(SqlParser.RIGHT_PAREN); + this.state = 2606; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 93 || _la === 216 || _la === 345) { + { + this.state = 2605; + this.tableArgumentPartitioning(); + } + } + + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public tableArgumentPartitioning(): TableArgumentPartitioningContext { + let localContext = new TableArgumentPartitioningContext(this.context, this.state); + this.enterRule(localContext, 192, SqlParser.RULE_tableArgumentPartitioning); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2629; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_WITH: + { + { + this.state = 2610; + this.match(SqlParser.KW_WITH); + this.state = 2611; + this.match(SqlParser.KW_SINGLE); + this.state = 2612; + this.match(SqlParser.KW_PARTITION); + } + } + break; + case SqlParser.KW_DISTRIBUTE: + case SqlParser.KW_PARTITION: + { + { + this.state = 2613; + _la = this.tokenStream.LA(1); + if(!(_la === 93 || _la === 216)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2614; + this.match(SqlParser.KW_BY); + this.state = 2627; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 392, this.context) ) { + case 1: + { + { + { + this.state = 2615; + this.match(SqlParser.LEFT_PAREN); + this.state = 2616; + localContext._expression = this.expression(); + localContext._partition.push(localContext._expression); + this.state = 2621; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2617; + this.match(SqlParser.COMMA); + this.state = 2618; + localContext._expression = this.expression(); + localContext._partition.push(localContext._expression); + } + } + this.state = 2623; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2624; + this.match(SqlParser.RIGHT_PAREN); + } + } + } + break; + case 2: + { + this.state = 2626; + localContext._expression = this.expression(); + localContext._partition.push(localContext._expression); + } + break; + } + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 2647; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 208 || _la === 277) { + { + this.state = 2631; + _la = this.tokenStream.LA(1); + if(!(_la === 208 || _la === 277)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2632; + this.match(SqlParser.KW_BY); + { + this.state = 2645; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 395, this.context) ) { + case 1: + { + { + this.state = 2633; + this.match(SqlParser.LEFT_PAREN); + this.state = 2634; + this.sortItem(); + this.state = 2639; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2635; + this.match(SqlParser.COMMA); + this.state = 2636; + this.sortItem(); + } + } + this.state = 2641; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2642; + this.match(SqlParser.RIGHT_PAREN); + } + } + break; + case 2: + { + this.state = 2644; + this.sortItem(); + } + break; + } + } + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public functionTableNamedArgumentExpression(): FunctionTableNamedArgumentExpressionContext { + let localContext = new FunctionTableNamedArgumentExpressionContext(this.context, this.state); + this.enterRule(localContext, 194, SqlParser.RULE_functionTableNamedArgumentExpression); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2649; + localContext._key = this.identifier(); + this.state = 2650; + this.match(SqlParser.FAT_ARROW); + this.state = 2651; + localContext._table = this.functionTableSubqueryArgument(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public functionTableReferenceArgument(): FunctionTableReferenceArgumentContext { + let localContext = new FunctionTableReferenceArgumentContext(this.context, this.state); + this.enterRule(localContext, 196, SqlParser.RULE_functionTableReferenceArgument); + try { + this.state = 2655; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_TABLE: + this.enterOuterAlt(localContext, 1); + { + this.state = 2653; + this.functionTableSubqueryArgument(); + } + break; + case SqlParser.KW_ADD: + case SqlParser.KW_AFTER: + case SqlParser.KW_ALL: + case SqlParser.KW_ALTER: + case SqlParser.KW_ALWAYS: + case SqlParser.KW_ANALYZE: + case SqlParser.KW_AND: + case SqlParser.KW_ANTI: + case SqlParser.KW_ANY: + case SqlParser.KW_ANY_VALUE: + case SqlParser.KW_ARCHIVE: + case SqlParser.KW_ARRAY: + case SqlParser.KW_AS: + case SqlParser.KW_ASC: + case SqlParser.KW_AT: + case SqlParser.KW_AUTHORIZATION: + case SqlParser.KW_BETWEEN: + case SqlParser.KW_BIGINT: + case SqlParser.KW_BINARY: + case SqlParser.KW_BOOLEAN: + case SqlParser.KW_BOTH: + case SqlParser.KW_BUCKET: + case SqlParser.KW_BUCKETS: + case SqlParser.KW_BY: + case SqlParser.KW_BYTE: + case SqlParser.KW_CACHE: + case SqlParser.KW_CASCADE: + case SqlParser.KW_CASE: + case SqlParser.KW_CAST: + case SqlParser.KW_CATALOG: + case SqlParser.KW_CATALOGS: + case SqlParser.KW_CHANGE: + case SqlParser.KW_CHAR: + case SqlParser.KW_CHARACTER: + case SqlParser.KW_CHECK: + case SqlParser.KW_CLEAR: + case SqlParser.KW_CLUSTER: + case SqlParser.KW_CLUSTERED: + case SqlParser.KW_CODEGEN: + case SqlParser.KW_COLLATE: + case SqlParser.KW_COLLECTION: + case SqlParser.KW_COLUMN: + case SqlParser.KW_COLUMNS: + case SqlParser.KW_COMMENT: + case SqlParser.KW_COMMIT: + case SqlParser.KW_COMPACT: + case SqlParser.KW_COMPACTIONS: + case SqlParser.KW_COMPUTE: + case SqlParser.KW_CONCATENATE: + case SqlParser.KW_CONSTRAINT: + case SqlParser.KW_COST: + case SqlParser.KW_CREATE: + case SqlParser.KW_CROSS: + case SqlParser.KW_CUBE: + case SqlParser.KW_CURRENT: + case SqlParser.KW_CURRENT_DATE: + case SqlParser.KW_CURRENT_TIME: + case SqlParser.KW_CURRENT_TIMESTAMP: + case SqlParser.KW_CURRENT_USER: + case SqlParser.KW_DAY: + case SqlParser.KW_DAYS: + case SqlParser.KW_DAYOFYEAR: + case SqlParser.KW_DATA: + case SqlParser.KW_DATE: + case SqlParser.KW_DATABASE: + case SqlParser.KW_DATABASES: + case SqlParser.KW_DATEADD: + case SqlParser.KW_DATE_ADD: + case SqlParser.KW_DATEDIFF: + case SqlParser.KW_DATE_DIFF: + case SqlParser.KW_DBPROPERTIES: + case SqlParser.KW_DEC: + case SqlParser.KW_DECIMAL: + case SqlParser.KW_DECLARE: + case SqlParser.KW_DEFAULT: + case SqlParser.KW_DEFINED: + case SqlParser.KW_DELETE: + case SqlParser.KW_DELIMITED: + case SqlParser.KW_DESC: + case SqlParser.KW_DESCRIBE: + case SqlParser.KW_DFS: + case SqlParser.KW_DIRECTORIES: + case SqlParser.KW_DIRECTORY: + case SqlParser.KW_DISABLE: + case SqlParser.KW_DISTINCT: + case SqlParser.KW_DISTRIBUTE: + case SqlParser.KW_DIV: + case SqlParser.KW_DOUBLE: + case SqlParser.KW_DROP: + case SqlParser.KW_ELSE: + case SqlParser.KW_ENABLE: + case SqlParser.KW_END: + case SqlParser.KW_ESCAPE: + case SqlParser.KW_ESCAPED: + case SqlParser.KW_EXCEPT: + case SqlParser.KW_EXCHANGE: + case SqlParser.KW_EXCLUDE: + case SqlParser.KW_EXISTS: + case SqlParser.KW_EXPLAIN: + case SqlParser.KW_EXPORT: + case SqlParser.KW_EXTENDED: + case SqlParser.KW_EXTERNAL: + case SqlParser.KW_EXTRACT: + case SqlParser.KW_FALSE: + case SqlParser.KW_FETCH: + case SqlParser.KW_FIELDS: + case SqlParser.KW_FILTER: + case SqlParser.KW_FILEFORMAT: + case SqlParser.KW_FIRST: + case SqlParser.KW_FLOAT: + case SqlParser.KW_FOLLOWING: + case SqlParser.KW_FOR: + case SqlParser.KW_FOREIGN: + case SqlParser.KW_FORMAT: + case SqlParser.KW_FORMATTED: + case SqlParser.KW_FULL: + case SqlParser.KW_FUNCTION: + case SqlParser.KW_FUNCTIONS: + case SqlParser.KW_GENERATED: + case SqlParser.KW_GLOBAL: + case SqlParser.KW_GRANT: + case SqlParser.KW_GROUP: + case SqlParser.KW_GROUPING: + case SqlParser.KW_HAVING: + case SqlParser.KW_BINARY_HEX: + case SqlParser.KW_HOUR: + case SqlParser.KW_HOURS: + case SqlParser.KW_IDENTIFIER: + case SqlParser.KW_IF: + case SqlParser.KW_IGNORE: + case SqlParser.KW_IMPORT: + case SqlParser.KW_IN: + case SqlParser.KW_INCLUDE: + case SqlParser.KW_INDEX: + case SqlParser.KW_INDEXES: + case SqlParser.KW_INNER: + case SqlParser.KW_INPATH: + case SqlParser.KW_INPUTFORMAT: + case SqlParser.KW_INSERT: + case SqlParser.KW_INTERSECT: + case SqlParser.KW_INTERVAL: + case SqlParser.KW_INT: + case SqlParser.KW_INTEGER: + case SqlParser.KW_INTO: + case SqlParser.KW_IS: + case SqlParser.KW_ITEMS: + case SqlParser.KW_JOIN: + case SqlParser.KW_KEYS: + case SqlParser.KW_LAST: + case SqlParser.KW_LATERAL: + case SqlParser.KW_LAZY: + case SqlParser.KW_LEADING: + case SqlParser.KW_LEFT: + case SqlParser.KW_LIFECYCLE: + case SqlParser.KW_LIKE: + case SqlParser.KW_ILIKE: + case SqlParser.KW_LIMIT: + case SqlParser.KW_LINES: + case SqlParser.KW_LIST: + case SqlParser.KW_LOAD: + case SqlParser.KW_LOCAL: + case SqlParser.KW_LOCATION: + case SqlParser.KW_LOCK: + case SqlParser.KW_LOCKS: + case SqlParser.KW_LOGICAL: + case SqlParser.KW_LONG: + case SqlParser.KW_MACRO: + case SqlParser.KW_MAP: + case SqlParser.KW_MATCHED: + case SqlParser.KW_MERGE: + case SqlParser.KW_MICROSECOND: + case SqlParser.KW_MICROSECONDS: + case SqlParser.KW_MILLISECOND: + case SqlParser.KW_MILLISECONDS: + case SqlParser.KW_MINUTE: + case SqlParser.KW_MINUTES: + case SqlParser.KW_MONTH: + case SqlParser.KW_MONTHS: + case SqlParser.KW_MSCK: + case SqlParser.KW_NAME: + case SqlParser.KW_NAMESPACE: + case SqlParser.KW_NAMESPACES: + case SqlParser.KW_NANOSECOND: + case SqlParser.KW_NANOSECONDS: + case SqlParser.KW_NATURAL: + case SqlParser.KW_NO: + case SqlParser.KW_NOT: + case SqlParser.KW_NULL: + case SqlParser.KW_NULLS: + case SqlParser.KW_NUMERIC: + case SqlParser.KW_OF: + case SqlParser.KW_OFFSET: + case SqlParser.KW_ON: + case SqlParser.KW_ONLY: + case SqlParser.KW_OPTIMIZE: + case SqlParser.KW_OPTION: + case SqlParser.KW_OPTIONS: + case SqlParser.KW_OR: + case SqlParser.KW_ORDER: + case SqlParser.KW_OUT: + case SqlParser.KW_OUTER: + case SqlParser.KW_OUTPUTFORMAT: + case SqlParser.KW_OVER: + case SqlParser.KW_OVERLAPS: + case SqlParser.KW_OVERLAY: + case SqlParser.KW_OVERWRITE: + case SqlParser.KW_PARTITION: + case SqlParser.KW_PARTITIONED: + case SqlParser.KW_PARTITIONS: + case SqlParser.KW_PERCENTILE_CONT: + case SqlParser.KW_PERCENTILE_DISC: + case SqlParser.KW_PERCENTLIT: + case SqlParser.KW_PIVOT: + case SqlParser.KW_PLACING: + case SqlParser.KW_POSITION: + case SqlParser.KW_PRECEDING: + case SqlParser.KW_PRIMARY: + case SqlParser.KW_PRINCIPALS: + case SqlParser.KW_PROPERTIES: + case SqlParser.KW_PURGE: + case SqlParser.KW_QUARTER: + case SqlParser.KW_QUERY: + case SqlParser.KW_RANGE: + case SqlParser.KW_REAL: + case SqlParser.KW_RECORDREADER: + case SqlParser.KW_RECORDWRITER: + case SqlParser.KW_RECOVER: + case SqlParser.KW_REDUCE: + case SqlParser.KW_REFERENCES: + case SqlParser.KW_REFRESH: + case SqlParser.KW_RENAME: + case SqlParser.KW_REPAIR: + case SqlParser.KW_REPEATABLE: + case SqlParser.KW_REPLACE: + case SqlParser.KW_RESET: + case SqlParser.KW_RESPECT: + case SqlParser.KW_RESTRICT: + case SqlParser.KW_REWRITE: + case SqlParser.KW_REVOKE: + case SqlParser.KW_RIGHT: + case SqlParser.KW_RLIKE: + case SqlParser.KW_REGEXP: + case SqlParser.KW_ROLE: + case SqlParser.KW_ROLES: + case SqlParser.KW_ROLLBACK: + case SqlParser.KW_ROLLUP: + case SqlParser.KW_ROW: + case SqlParser.KW_ROWS: + case SqlParser.KW_SECOND: + case SqlParser.KW_SECONDS: + case SqlParser.KW_SCHEMA: + case SqlParser.KW_SCHEMAS: + case SqlParser.KW_SEMI: + case SqlParser.KW_SEPARATED: + case SqlParser.KW_SERDE: + case SqlParser.KW_SERDEPROPERTIES: + case SqlParser.KW_SESSION_USER: + case SqlParser.KW_SET: + case SqlParser.KW_MINUS: + case SqlParser.KW_SETS: + case SqlParser.KW_SHORT: + case SqlParser.KW_SHOW: + case SqlParser.KW_SINGLE: + case SqlParser.KW_SKEWED: + case SqlParser.KW_SMALLINT: + case SqlParser.KW_SOME: + case SqlParser.KW_SORT: + case SqlParser.KW_SORTED: + case SqlParser.KW_SOURCE: + case SqlParser.KW_START: + case SqlParser.KW_STATISTICS: + case SqlParser.KW_STORED: + case SqlParser.KW_STRATIFY: + case SqlParser.KW_STRING: + case SqlParser.KW_STRUCT: + case SqlParser.KW_SUBSTR: + case SqlParser.KW_SUBSTRING: + case SqlParser.KW_SYNC: + case SqlParser.KW_SYSTEM: + case SqlParser.KW_SYSTEM_TIME: + case SqlParser.KW_SYSTEM_VERSION: + case SqlParser.KW_TABLES: + case SqlParser.KW_TABLESAMPLE: + case SqlParser.KW_TARGET: + case SqlParser.KW_TBLPROPERTIES: + case SqlParser.KW_TEMPORARY: + case SqlParser.KW_TERMINATED: + case SqlParser.KW_THEN: + case SqlParser.KW_TIME: + case SqlParser.KW_TIMEDIFF: + case SqlParser.KW_TIMESTAMP: + case SqlParser.KW_TIMESTAMP_LTZ: + case SqlParser.KW_TIMESTAMP_NTZ: + case SqlParser.KW_TIMESTAMPADD: + case SqlParser.KW_TIMESTAMPDIFF: + case SqlParser.KW_TINYINT: + case SqlParser.KW_TO: + case SqlParser.KW_TOUCH: + case SqlParser.KW_TRAILING: + case SqlParser.KW_TRANSACTION: + case SqlParser.KW_TRANSACTIONS: + case SqlParser.KW_TRANSFORM: + case SqlParser.KW_TRIM: + case SqlParser.KW_TRUE: + case SqlParser.KW_TRUNCATE: + case SqlParser.KW_TRY_CAST: + case SqlParser.KW_TYPE: + case SqlParser.KW_UNARCHIVE: + case SqlParser.KW_UNBOUNDED: + case SqlParser.KW_UNCACHE: + case SqlParser.KW_UNION: + case SqlParser.KW_UNIQUE: + case SqlParser.KW_UNKNOWN: + case SqlParser.KW_UNLOCK: + case SqlParser.KW_UNPIVOT: + case SqlParser.KW_UNSET: + case SqlParser.KW_UPDATE: + case SqlParser.KW_USE: + case SqlParser.KW_USER: + case SqlParser.KW_USING: + case SqlParser.KW_VALUES: + case SqlParser.KW_VARCHAR: + case SqlParser.KW_VAR: + case SqlParser.KW_VARIABLE: + case SqlParser.KW_VERSION: + case SqlParser.KW_VIEW: + case SqlParser.KW_VIEWS: + case SqlParser.KW_VOID: + case SqlParser.KW_WEEK: + case SqlParser.KW_WEEKS: + case SqlParser.KW_WHEN: + case SqlParser.KW_WHERE: + case SqlParser.KW_WINDOW: + case SqlParser.KW_WITH: + case SqlParser.KW_WITHIN: + case SqlParser.KW_YEAR: + case SqlParser.KW_YEARS: + case SqlParser.KW_ZONE: + case SqlParser.KW_ZORDER: + case SqlParser.DOUBLEQUOTED_STRING: + case SqlParser.IDENTIFIER: + case SqlParser.BACKQUOTED_IDENTIFIER: + this.enterOuterAlt(localContext, 2); + { + this.state = 2654; + this.functionTableNamedArgumentExpression(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public functionTableArgument(): FunctionTableArgumentContext { + let localContext = new FunctionTableArgumentContext(this.context, this.state); + this.enterRule(localContext, 198, SqlParser.RULE_functionTableArgument); + try { + this.state = 2659; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 398, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2657; + this.functionTableReferenceArgument(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2658; + this.functionArgument(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public tableAlias(): TableAliasContext { + let localContext = new TableAliasContext(this.context, this.state); + this.enterRule(localContext, 200, SqlParser.RULE_tableAlias); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2668; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 401, this.context) ) { + case 1: + { + this.state = 2662; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 399, this.context) ) { + case 1: + { + this.state = 2661; + this.match(SqlParser.KW_AS); + } + break; + } + this.state = 2664; + localContext._alias = this.strictIdentifier(); + this.state = 2666; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 400, this.context) ) { + case 1: + { + this.state = 2665; + this.identifierList(); + } + break; + } + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public rowFormat(): RowFormatContext { + let localContext = new RowFormatContext(this.context, this.state); + this.enterRule(localContext, 202, SqlParser.RULE_rowFormat); + try { + this.state = 2719; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 409, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2670; + this.match(SqlParser.KW_ROW); + this.state = 2671; + this.match(SqlParser.KW_FORMAT); + this.state = 2672; + this.match(SqlParser.KW_SERDE); + this.state = 2673; + localContext._name = this.stringLit(); + this.state = 2677; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 402, this.context) ) { + case 1: + { + this.state = 2674; + this.match(SqlParser.KW_WITH); + this.state = 2675; + this.match(SqlParser.KW_SERDEPROPERTIES); + this.state = 2676; + localContext._props = this.propertyList(); + } + break; + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2679; + this.match(SqlParser.KW_ROW); + this.state = 2680; + this.match(SqlParser.KW_FORMAT); + this.state = 2681; + this.match(SqlParser.KW_DELIMITED); + this.state = 2691; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 404, this.context) ) { + case 1: + { + this.state = 2682; + this.match(SqlParser.KW_FIELDS); + this.state = 2683; + this.match(SqlParser.KW_TERMINATED); + this.state = 2684; + this.match(SqlParser.KW_BY); + this.state = 2685; + localContext._fieldsTerminatedBy = this.stringLit(); + this.state = 2689; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 403, this.context) ) { + case 1: + { + this.state = 2686; + this.match(SqlParser.KW_ESCAPED); + this.state = 2687; + this.match(SqlParser.KW_BY); + this.state = 2688; + localContext._escapedBy = this.stringLit(); + } + break; + } + } + break; + } + this.state = 2698; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 405, this.context) ) { + case 1: + { + this.state = 2693; + this.match(SqlParser.KW_COLLECTION); + this.state = 2694; + this.match(SqlParser.KW_ITEMS); + this.state = 2695; + this.match(SqlParser.KW_TERMINATED); + this.state = 2696; + this.match(SqlParser.KW_BY); + this.state = 2697; + localContext._collectionItemsTerminatedBy = this.stringLit(); + } + break; + } + this.state = 2705; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 406, this.context) ) { + case 1: + { + this.state = 2700; + this.match(SqlParser.KW_MAP); + this.state = 2701; + this.match(SqlParser.KW_KEYS); + this.state = 2702; + this.match(SqlParser.KW_TERMINATED); + this.state = 2703; + this.match(SqlParser.KW_BY); + this.state = 2704; + localContext._keysTerminatedBy = this.stringLit(); + } + break; + } + this.state = 2711; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 407, this.context) ) { + case 1: + { + this.state = 2707; + this.match(SqlParser.KW_LINES); + this.state = 2708; + this.match(SqlParser.KW_TERMINATED); + this.state = 2709; + this.match(SqlParser.KW_BY); + this.state = 2710; + localContext._linesSeparatedBy = this.stringLit(); + } + break; + } + this.state = 2717; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 408, this.context) ) { + case 1: + { + this.state = 2713; + this.match(SqlParser.KW_NULL); + this.state = 2714; + this.match(SqlParser.KW_DEFINED); + this.state = 2715; + this.match(SqlParser.KW_AS); + this.state = 2716; + localContext._nullDefinedAs = this.stringLit(); + } + break; + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public multipartIdentifierList(): MultipartIdentifierListContext { + let localContext = new MultipartIdentifierListContext(this.context, this.state); + this.enterRule(localContext, 204, SqlParser.RULE_multipartIdentifierList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2721; + this.multipartIdentifier(); + this.state = 2726; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2722; + this.match(SqlParser.COMMA); + this.state = 2723; + this.multipartIdentifier(); + } + } + this.state = 2728; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public multipartIdentifier(): MultipartIdentifierContext { + let localContext = new MultipartIdentifierContext(this.context, this.state); + this.enterRule(localContext, 206, SqlParser.RULE_multipartIdentifier); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 2729; + localContext._errorCapturingIdentifier = this.errorCapturingIdentifier(); + localContext._parts.push(localContext._errorCapturingIdentifier); + this.state = 2734; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 411, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2730; + this.match(SqlParser.DOT); + this.state = 2731; + localContext._errorCapturingIdentifier = this.errorCapturingIdentifier(); + localContext._parts.push(localContext._errorCapturingIdentifier); + } + } + } + this.state = 2736; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 411, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public multipartIdentifierPropertyList(): MultipartIdentifierPropertyListContext { + let localContext = new MultipartIdentifierPropertyListContext(this.context, this.state); + this.enterRule(localContext, 208, SqlParser.RULE_multipartIdentifierPropertyList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2737; + this.multipartIdentifierProperty(); + this.state = 2742; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2738; + this.match(SqlParser.COMMA); + this.state = 2739; + this.multipartIdentifierProperty(); + } + } + this.state = 2744; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public multipartIdentifierProperty(): MultipartIdentifierPropertyContext { + let localContext = new MultipartIdentifierPropertyContext(this.context, this.state); + this.enterRule(localContext, 210, SqlParser.RULE_multipartIdentifierProperty); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2745; + this.multipartIdentifier(); + this.state = 2748; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 206) { + { + this.state = 2746; + this.match(SqlParser.KW_OPTIONS); + this.state = 2747; + localContext._options = this.propertyList(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public tableIdentifier(): TableIdentifierContext { + let localContext = new TableIdentifierContext(this.context, this.state); + this.enterRule(localContext, 212, SqlParser.RULE_tableIdentifier); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2753; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 414, this.context) ) { + case 1: + { + this.state = 2750; + localContext._db = this.errorCapturingIdentifier(); + this.state = 2751; + this.match(SqlParser.DOT); + } + break; + } + this.state = 2755; + localContext._table = this.errorCapturingIdentifier(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public viewIdentifier(): ViewIdentifierContext { + let localContext = new ViewIdentifierContext(this.context, this.state); + this.enterRule(localContext, 214, SqlParser.RULE_viewIdentifier); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2760; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 415, this.context) ) { + case 1: + { + this.state = 2757; + localContext._db = this.errorCapturingIdentifier(); + this.state = 2758; + this.match(SqlParser.DOT); + } + break; + } + this.state = 2762; + localContext._view = this.errorCapturingIdentifier(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public namedExpression(): NamedExpressionContext { + let localContext = new NamedExpressionContext(this.context, this.state); + this.enterRule(localContext, 216, SqlParser.RULE_namedExpression); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2766; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 416, this.context) ) { + case 1: + { + this.state = 2764; + this.columnName(); + } + break; + case 2: + { + this.state = 2765; + this.expression(); + } + break; + } + this.state = 2775; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 419, this.context) ) { + case 1: + { + this.state = 2769; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 417, this.context) ) { + case 1: + { + this.state = 2768; + this.match(SqlParser.KW_AS); + } + break; + } + this.state = 2773; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_ADD: + case SqlParser.KW_AFTER: + case SqlParser.KW_ALL: + case SqlParser.KW_ALTER: + case SqlParser.KW_ALWAYS: + case SqlParser.KW_ANALYZE: + case SqlParser.KW_AND: + case SqlParser.KW_ANTI: + case SqlParser.KW_ANY: + case SqlParser.KW_ANY_VALUE: + case SqlParser.KW_ARCHIVE: + case SqlParser.KW_ARRAY: + case SqlParser.KW_AS: + case SqlParser.KW_ASC: + case SqlParser.KW_AT: + case SqlParser.KW_AUTHORIZATION: + case SqlParser.KW_BETWEEN: + case SqlParser.KW_BIGINT: + case SqlParser.KW_BINARY: + case SqlParser.KW_BOOLEAN: + case SqlParser.KW_BOTH: + case SqlParser.KW_BUCKET: + case SqlParser.KW_BUCKETS: + case SqlParser.KW_BY: + case SqlParser.KW_BYTE: + case SqlParser.KW_CACHE: + case SqlParser.KW_CASCADE: + case SqlParser.KW_CASE: + case SqlParser.KW_CAST: + case SqlParser.KW_CATALOG: + case SqlParser.KW_CATALOGS: + case SqlParser.KW_CHANGE: + case SqlParser.KW_CHAR: + case SqlParser.KW_CHARACTER: + case SqlParser.KW_CHECK: + case SqlParser.KW_CLEAR: + case SqlParser.KW_CLUSTER: + case SqlParser.KW_CLUSTERED: + case SqlParser.KW_CODEGEN: + case SqlParser.KW_COLLATE: + case SqlParser.KW_COLLECTION: + case SqlParser.KW_COLUMN: + case SqlParser.KW_COLUMNS: + case SqlParser.KW_COMMENT: + case SqlParser.KW_COMMIT: + case SqlParser.KW_COMPACT: + case SqlParser.KW_COMPACTIONS: + case SqlParser.KW_COMPUTE: + case SqlParser.KW_CONCATENATE: + case SqlParser.KW_CONSTRAINT: + case SqlParser.KW_COST: + case SqlParser.KW_CREATE: + case SqlParser.KW_CROSS: + case SqlParser.KW_CUBE: + case SqlParser.KW_CURRENT: + case SqlParser.KW_CURRENT_DATE: + case SqlParser.KW_CURRENT_TIME: + case SqlParser.KW_CURRENT_TIMESTAMP: + case SqlParser.KW_CURRENT_USER: + case SqlParser.KW_DAY: + case SqlParser.KW_DAYS: + case SqlParser.KW_DAYOFYEAR: + case SqlParser.KW_DATA: + case SqlParser.KW_DATE: + case SqlParser.KW_DATABASE: + case SqlParser.KW_DATABASES: + case SqlParser.KW_DATEADD: + case SqlParser.KW_DATE_ADD: + case SqlParser.KW_DATEDIFF: + case SqlParser.KW_DATE_DIFF: + case SqlParser.KW_DBPROPERTIES: + case SqlParser.KW_DEC: + case SqlParser.KW_DECIMAL: + case SqlParser.KW_DECLARE: + case SqlParser.KW_DEFAULT: + case SqlParser.KW_DEFINED: + case SqlParser.KW_DELETE: + case SqlParser.KW_DELIMITED: + case SqlParser.KW_DESC: + case SqlParser.KW_DESCRIBE: + case SqlParser.KW_DFS: + case SqlParser.KW_DIRECTORIES: + case SqlParser.KW_DIRECTORY: + case SqlParser.KW_DISABLE: + case SqlParser.KW_DISTINCT: + case SqlParser.KW_DISTRIBUTE: + case SqlParser.KW_DIV: + case SqlParser.KW_DOUBLE: + case SqlParser.KW_DROP: + case SqlParser.KW_ELSE: + case SqlParser.KW_ENABLE: + case SqlParser.KW_END: + case SqlParser.KW_ESCAPE: + case SqlParser.KW_ESCAPED: + case SqlParser.KW_EXCEPT: + case SqlParser.KW_EXCHANGE: + case SqlParser.KW_EXCLUDE: + case SqlParser.KW_EXISTS: + case SqlParser.KW_EXPLAIN: + case SqlParser.KW_EXPORT: + case SqlParser.KW_EXTENDED: + case SqlParser.KW_EXTERNAL: + case SqlParser.KW_EXTRACT: + case SqlParser.KW_FALSE: + case SqlParser.KW_FETCH: + case SqlParser.KW_FIELDS: + case SqlParser.KW_FILTER: + case SqlParser.KW_FILEFORMAT: + case SqlParser.KW_FIRST: + case SqlParser.KW_FLOAT: + case SqlParser.KW_FOLLOWING: + case SqlParser.KW_FOR: + case SqlParser.KW_FOREIGN: + case SqlParser.KW_FORMAT: + case SqlParser.KW_FORMATTED: + case SqlParser.KW_FULL: + case SqlParser.KW_FUNCTION: + case SqlParser.KW_FUNCTIONS: + case SqlParser.KW_GENERATED: + case SqlParser.KW_GLOBAL: + case SqlParser.KW_GRANT: + case SqlParser.KW_GROUP: + case SqlParser.KW_GROUPING: + case SqlParser.KW_HAVING: + case SqlParser.KW_BINARY_HEX: + case SqlParser.KW_HOUR: + case SqlParser.KW_HOURS: + case SqlParser.KW_IDENTIFIER: + case SqlParser.KW_IF: + case SqlParser.KW_IGNORE: + case SqlParser.KW_IMPORT: + case SqlParser.KW_IN: + case SqlParser.KW_INCLUDE: + case SqlParser.KW_INDEX: + case SqlParser.KW_INDEXES: + case SqlParser.KW_INNER: + case SqlParser.KW_INPATH: + case SqlParser.KW_INPUTFORMAT: + case SqlParser.KW_INSERT: + case SqlParser.KW_INTERSECT: + case SqlParser.KW_INTERVAL: + case SqlParser.KW_INT: + case SqlParser.KW_INTEGER: + case SqlParser.KW_INTO: + case SqlParser.KW_IS: + case SqlParser.KW_ITEMS: + case SqlParser.KW_JOIN: + case SqlParser.KW_KEYS: + case SqlParser.KW_LAST: + case SqlParser.KW_LATERAL: + case SqlParser.KW_LAZY: + case SqlParser.KW_LEADING: + case SqlParser.KW_LEFT: + case SqlParser.KW_LIFECYCLE: + case SqlParser.KW_LIKE: + case SqlParser.KW_ILIKE: + case SqlParser.KW_LIMIT: + case SqlParser.KW_LINES: + case SqlParser.KW_LIST: + case SqlParser.KW_LOAD: + case SqlParser.KW_LOCAL: + case SqlParser.KW_LOCATION: + case SqlParser.KW_LOCK: + case SqlParser.KW_LOCKS: + case SqlParser.KW_LOGICAL: + case SqlParser.KW_LONG: + case SqlParser.KW_MACRO: + case SqlParser.KW_MAP: + case SqlParser.KW_MATCHED: + case SqlParser.KW_MERGE: + case SqlParser.KW_MICROSECOND: + case SqlParser.KW_MICROSECONDS: + case SqlParser.KW_MILLISECOND: + case SqlParser.KW_MILLISECONDS: + case SqlParser.KW_MINUTE: + case SqlParser.KW_MINUTES: + case SqlParser.KW_MONTH: + case SqlParser.KW_MONTHS: + case SqlParser.KW_MSCK: + case SqlParser.KW_NAME: + case SqlParser.KW_NAMESPACE: + case SqlParser.KW_NAMESPACES: + case SqlParser.KW_NANOSECOND: + case SqlParser.KW_NANOSECONDS: + case SqlParser.KW_NATURAL: + case SqlParser.KW_NO: + case SqlParser.KW_NOT: + case SqlParser.KW_NULL: + case SqlParser.KW_NULLS: + case SqlParser.KW_NUMERIC: + case SqlParser.KW_OF: + case SqlParser.KW_OFFSET: + case SqlParser.KW_ON: + case SqlParser.KW_ONLY: + case SqlParser.KW_OPTIMIZE: + case SqlParser.KW_OPTION: + case SqlParser.KW_OPTIONS: + case SqlParser.KW_OR: + case SqlParser.KW_ORDER: + case SqlParser.KW_OUT: + case SqlParser.KW_OUTER: + case SqlParser.KW_OUTPUTFORMAT: + case SqlParser.KW_OVER: + case SqlParser.KW_OVERLAPS: + case SqlParser.KW_OVERLAY: + case SqlParser.KW_OVERWRITE: + case SqlParser.KW_PARTITION: + case SqlParser.KW_PARTITIONED: + case SqlParser.KW_PARTITIONS: + case SqlParser.KW_PERCENTILE_CONT: + case SqlParser.KW_PERCENTILE_DISC: + case SqlParser.KW_PERCENTLIT: + case SqlParser.KW_PIVOT: + case SqlParser.KW_PLACING: + case SqlParser.KW_POSITION: + case SqlParser.KW_PRECEDING: + case SqlParser.KW_PRIMARY: + case SqlParser.KW_PRINCIPALS: + case SqlParser.KW_PROPERTIES: + case SqlParser.KW_PURGE: + case SqlParser.KW_QUARTER: + case SqlParser.KW_QUERY: + case SqlParser.KW_RANGE: + case SqlParser.KW_REAL: + case SqlParser.KW_RECORDREADER: + case SqlParser.KW_RECORDWRITER: + case SqlParser.KW_RECOVER: + case SqlParser.KW_REDUCE: + case SqlParser.KW_REFERENCES: + case SqlParser.KW_REFRESH: + case SqlParser.KW_RENAME: + case SqlParser.KW_REPAIR: + case SqlParser.KW_REPEATABLE: + case SqlParser.KW_REPLACE: + case SqlParser.KW_RESET: + case SqlParser.KW_RESPECT: + case SqlParser.KW_RESTRICT: + case SqlParser.KW_REWRITE: + case SqlParser.KW_REVOKE: + case SqlParser.KW_RIGHT: + case SqlParser.KW_RLIKE: + case SqlParser.KW_REGEXP: + case SqlParser.KW_ROLE: + case SqlParser.KW_ROLES: + case SqlParser.KW_ROLLBACK: + case SqlParser.KW_ROLLUP: + case SqlParser.KW_ROW: + case SqlParser.KW_ROWS: + case SqlParser.KW_SECOND: + case SqlParser.KW_SECONDS: + case SqlParser.KW_SCHEMA: + case SqlParser.KW_SCHEMAS: + case SqlParser.KW_SEMI: + case SqlParser.KW_SEPARATED: + case SqlParser.KW_SERDE: + case SqlParser.KW_SERDEPROPERTIES: + case SqlParser.KW_SESSION_USER: + case SqlParser.KW_SET: + case SqlParser.KW_MINUS: + case SqlParser.KW_SETS: + case SqlParser.KW_SHORT: + case SqlParser.KW_SHOW: + case SqlParser.KW_SINGLE: + case SqlParser.KW_SKEWED: + case SqlParser.KW_SMALLINT: + case SqlParser.KW_SOME: + case SqlParser.KW_SORT: + case SqlParser.KW_SORTED: + case SqlParser.KW_SOURCE: + case SqlParser.KW_START: + case SqlParser.KW_STATISTICS: + case SqlParser.KW_STORED: + case SqlParser.KW_STRATIFY: + case SqlParser.KW_STRING: + case SqlParser.KW_STRUCT: + case SqlParser.KW_SUBSTR: + case SqlParser.KW_SUBSTRING: + case SqlParser.KW_SYNC: + case SqlParser.KW_SYSTEM: + case SqlParser.KW_SYSTEM_TIME: + case SqlParser.KW_SYSTEM_VERSION: + case SqlParser.KW_TABLES: + case SqlParser.KW_TABLESAMPLE: + case SqlParser.KW_TARGET: + case SqlParser.KW_TBLPROPERTIES: + case SqlParser.KW_TEMPORARY: + case SqlParser.KW_TERMINATED: + case SqlParser.KW_THEN: + case SqlParser.KW_TIME: + case SqlParser.KW_TIMEDIFF: + case SqlParser.KW_TIMESTAMP: + case SqlParser.KW_TIMESTAMP_LTZ: + case SqlParser.KW_TIMESTAMP_NTZ: + case SqlParser.KW_TIMESTAMPADD: + case SqlParser.KW_TIMESTAMPDIFF: + case SqlParser.KW_TINYINT: + case SqlParser.KW_TO: + case SqlParser.KW_TOUCH: + case SqlParser.KW_TRAILING: + case SqlParser.KW_TRANSACTION: + case SqlParser.KW_TRANSACTIONS: + case SqlParser.KW_TRANSFORM: + case SqlParser.KW_TRIM: + case SqlParser.KW_TRUE: + case SqlParser.KW_TRUNCATE: + case SqlParser.KW_TRY_CAST: + case SqlParser.KW_TYPE: + case SqlParser.KW_UNARCHIVE: + case SqlParser.KW_UNBOUNDED: + case SqlParser.KW_UNCACHE: + case SqlParser.KW_UNION: + case SqlParser.KW_UNIQUE: + case SqlParser.KW_UNKNOWN: + case SqlParser.KW_UNLOCK: + case SqlParser.KW_UNPIVOT: + case SqlParser.KW_UNSET: + case SqlParser.KW_UPDATE: + case SqlParser.KW_USE: + case SqlParser.KW_USER: + case SqlParser.KW_USING: + case SqlParser.KW_VALUES: + case SqlParser.KW_VARCHAR: + case SqlParser.KW_VAR: + case SqlParser.KW_VARIABLE: + case SqlParser.KW_VERSION: + case SqlParser.KW_VIEW: + case SqlParser.KW_VIEWS: + case SqlParser.KW_VOID: + case SqlParser.KW_WEEK: + case SqlParser.KW_WEEKS: + case SqlParser.KW_WHEN: + case SqlParser.KW_WHERE: + case SqlParser.KW_WINDOW: + case SqlParser.KW_WITH: + case SqlParser.KW_WITHIN: + case SqlParser.KW_YEAR: + case SqlParser.KW_YEARS: + case SqlParser.KW_ZONE: + case SqlParser.KW_ZORDER: + case SqlParser.DOUBLEQUOTED_STRING: + case SqlParser.IDENTIFIER: + case SqlParser.BACKQUOTED_IDENTIFIER: + { + this.state = 2771; + localContext._name = this.errorCapturingIdentifier(); + } + break; + case SqlParser.LEFT_PAREN: + { + this.state = 2772; + this.identifierList(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public namedExpressionSeq(): NamedExpressionSeqContext { + let localContext = new NamedExpressionSeqContext(this.context, this.state); + this.enterRule(localContext, 218, SqlParser.RULE_namedExpressionSeq); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 2777; + this.namedExpression(); + this.state = 2782; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 420, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2778; + this.match(SqlParser.COMMA); + this.state = 2779; + this.namedExpression(); + } + } + } + this.state = 2784; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 420, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public partitionFieldList(): PartitionFieldListContext { + let localContext = new PartitionFieldListContext(this.context, this.state); + this.enterRule(localContext, 220, SqlParser.RULE_partitionFieldList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2785; + this.match(SqlParser.LEFT_PAREN); + this.state = 2786; + localContext._partitionField = this.partitionField(); + localContext._fields.push(localContext._partitionField); + this.state = 2791; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2787; + this.match(SqlParser.COMMA); + this.state = 2788; + localContext._partitionField = this.partitionField(); + localContext._fields.push(localContext._partitionField); + } + } + this.state = 2793; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2794; + this.match(SqlParser.RIGHT_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public partitionField(): PartitionFieldContext { + let localContext = new PartitionFieldContext(this.context, this.state); + this.enterRule(localContext, 222, SqlParser.RULE_partitionField); + try { + this.state = 2798; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 422, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2796; + this.transform(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2797; + this.columnType(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public transform(): TransformContext { + let localContext = new TransformContext(this.context, this.state); + this.enterRule(localContext, 224, SqlParser.RULE_transform); + let _la: number; + try { + this.state = 2813; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 424, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2800; + this.qualifiedName(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2801; + localContext._transformName = this.identifier(); + this.state = 2802; + this.match(SqlParser.LEFT_PAREN); + this.state = 2803; + this.transformArgument(); + this.state = 2808; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2804; + this.match(SqlParser.COMMA); + this.state = 2805; + this.transformArgument(); + } + } + this.state = 2810; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2811; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public transformArgument(): TransformArgumentContext { + let localContext = new TransformArgumentContext(this.context, this.state); + this.enterRule(localContext, 226, SqlParser.RULE_transformArgument); + try { + this.state = 2817; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 425, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2815; + this.qualifiedName(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2816; + this.constant(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public expression(): ExpressionContext { + let localContext = new ExpressionContext(this.context, this.state); + this.enterRule(localContext, 228, SqlParser.RULE_expression); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2819; + this.booleanExpression(0); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public namedArgumentExpression(): NamedArgumentExpressionContext { + let localContext = new NamedArgumentExpressionContext(this.context, this.state); + this.enterRule(localContext, 230, SqlParser.RULE_namedArgumentExpression); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2821; + localContext._key = this.identifier(); + this.state = 2822; + this.match(SqlParser.FAT_ARROW); + this.state = 2823; + localContext._value = this.expression(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public functionArgument(): FunctionArgumentContext { + let localContext = new FunctionArgumentContext(this.context, this.state); + this.enterRule(localContext, 232, SqlParser.RULE_functionArgument); + try { + this.state = 2827; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 426, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2825; + this.expression(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2826; + this.namedArgumentExpression(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public expressionSeq(): ExpressionSeqContext { + let localContext = new ExpressionSeqContext(this.context, this.state); + this.enterRule(localContext, 234, SqlParser.RULE_expressionSeq); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2829; + this.expression(); + this.state = 2834; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2830; + this.match(SqlParser.COMMA); + this.state = 2831; + this.expression(); + } + } + this.state = 2836; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + + public booleanExpression(): BooleanExpressionContext; + public booleanExpression(_p: number): BooleanExpressionContext; + public booleanExpression(_p?: number): BooleanExpressionContext { + if (_p === undefined) { + _p = 0; + } + + let parentContext = this.context; + let parentState = this.state; + let localContext = new BooleanExpressionContext(this.context, parentState); + let previousContext = localContext; + let _startState = 236; + this.enterRecursionRule(localContext, 236, SqlParser.RULE_booleanExpression, _p); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 2849; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 429, this.context) ) { + case 1: + { + this.state = 2838; + _la = this.tokenStream.LA(1); + if(!(_la === 196 || _la === 359)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2839; + this.booleanExpression(5); + } + break; + case 2: + { + this.state = 2840; + this.match(SqlParser.KW_EXISTS); + this.state = 2841; + this.match(SqlParser.LEFT_PAREN); + this.state = 2842; + this.query(); + this.state = 2843; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 3: + { + this.state = 2845; + this.valueExpression(0); + this.state = 2847; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 428, this.context) ) { + case 1: + { + this.state = 2846; + this.predicate(); + } + break; + } + } + break; + } + this.context!.stop = this.tokenStream.LT(-1); + this.state = 2859; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 431, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + previousContext = localContext; + { + this.state = 2857; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 430, this.context) ) { + case 1: + { + localContext = new BooleanExpressionContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_booleanExpression); + this.state = 2851; + if (!(this.precpred(this.context, 2))) { + throw this.createFailedPredicateException("this.precpred(this.context, 2)"); + } + this.state = 2852; + localContext._operator = this.match(SqlParser.KW_AND); + this.state = 2853; + localContext._right = this.booleanExpression(3); + } + break; + case 2: + { + localContext = new BooleanExpressionContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_booleanExpression); + this.state = 2854; + if (!(this.precpred(this.context, 1))) { + throw this.createFailedPredicateException("this.precpred(this.context, 1)"); + } + this.state = 2855; + localContext._operator = this.match(SqlParser.KW_OR); + this.state = 2856; + localContext._right = this.booleanExpression(2); + } + break; + } + } + } + this.state = 2861; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 431, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(parentContext); + } + return localContext; + } + public predicate(): PredicateContext { + let localContext = new PredicateContext(this.context, this.state); + this.enterRule(localContext, 238, SqlParser.RULE_predicate); + let _la: number; + try { + this.state = 2944; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 445, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 2863; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 2862; + this.match(SqlParser.KW_NOT); + } + } + + this.state = 2865; + localContext._kind = this.match(SqlParser.KW_BETWEEN); + this.state = 2866; + localContext._lower = this.valueExpression(0); + this.state = 2867; + this.match(SqlParser.KW_AND); + this.state = 2868; + localContext._upper = this.valueExpression(0); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2871; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 2870; + this.match(SqlParser.KW_NOT); + } + } + + this.state = 2873; + localContext._kind = this.match(SqlParser.KW_IN); + this.state = 2874; + this.match(SqlParser.LEFT_PAREN); + this.state = 2875; + this.expression(); + this.state = 2880; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2876; + this.match(SqlParser.COMMA); + this.state = 2877; + this.expression(); + } + } + this.state = 2882; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2883; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 2886; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 2885; + this.match(SqlParser.KW_NOT); + } + } + + this.state = 2888; + localContext._kind = this.match(SqlParser.KW_IN); + this.state = 2889; + this.match(SqlParser.LEFT_PAREN); + this.state = 2890; + this.query(); + this.state = 2891; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 2894; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 2893; + this.match(SqlParser.KW_NOT); + } + } + + this.state = 2896; + localContext._kind = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 250 || _la === 251)) { + localContext._kind = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2897; + localContext._pattern = this.valueExpression(0); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 2899; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 2898; + this.match(SqlParser.KW_NOT); + } + } + + this.state = 2901; + localContext._kind = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 163 || _la === 164)) { + localContext._kind = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2902; + localContext._quantifier = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 10 || _la === 16 || _la === 276)) { + localContext._quantifier = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2916; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 439, this.context) ) { + case 1: + { + this.state = 2903; + this.match(SqlParser.LEFT_PAREN); + this.state = 2904; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 2: + { + this.state = 2905; + this.match(SqlParser.LEFT_PAREN); + this.state = 2906; + this.expression(); + this.state = 2911; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 2907; + this.match(SqlParser.COMMA); + this.state = 2908; + this.expression(); + } + } + this.state = 2913; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2914; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 2919; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 2918; + this.match(SqlParser.KW_NOT); + } + } + + this.state = 2921; + localContext._kind = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 163 || _la === 164)) { + localContext._kind = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2922; + localContext._pattern = this.valueExpression(0); + this.state = 2925; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 441, this.context) ) { + case 1: + { + this.state = 2923; + this.match(SqlParser.KW_ESCAPE); + this.state = 2924; + localContext._escapeChar = this.stringLit(); + } + break; + } + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 2927; + this.match(SqlParser.KW_IS); + this.state = 2929; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 2928; + this.match(SqlParser.KW_NOT); + } + } + + this.state = 2931; + localContext._kind = this.match(SqlParser.KW_NULL); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 2932; + this.match(SqlParser.KW_IS); + this.state = 2934; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 2933; + this.match(SqlParser.KW_NOT); + } + } + + this.state = 2936; + localContext._kind = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 111 || _la === 315 || _la === 324)) { + localContext._kind = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 2937; + this.match(SqlParser.KW_IS); + this.state = 2939; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 2938; + this.match(SqlParser.KW_NOT); + } + } + + this.state = 2941; + localContext._kind = this.match(SqlParser.KW_DISTINCT); + this.state = 2942; + this.match(SqlParser.KW_FROM); + this.state = 2943; + localContext._right = this.valueExpression(0); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + + public valueExpression(): ValueExpressionContext; + public valueExpression(_p: number): ValueExpressionContext; + public valueExpression(_p?: number): ValueExpressionContext { + if (_p === undefined) { + _p = 0; + } + + let parentContext = this.context; + let parentState = this.state; + let localContext = new ValueExpressionContext(this.context, parentState); + let previousContext = localContext; + let _startState = 240; + this.enterRecursionRule(localContext, 240, SqlParser.RULE_valueExpression, _p); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 2950; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 446, this.context) ) { + case 1: + { + this.state = 2947; + this.primaryExpression(0); + } + break; + case 2: + { + this.state = 2948; + localContext._operator = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(((((_la - 360)) & ~0x1F) === 0 && ((1 << (_la - 360)) & 35) !== 0))) { + localContext._operator = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2949; + this.valueExpression(7); + } + break; + } + this.context!.stop = this.tokenStream.LT(-1); + this.state = 2973; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 448, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + previousContext = localContext; + { + this.state = 2971; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 447, this.context) ) { + case 1: + { + localContext = new ValueExpressionContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_valueExpression); + this.state = 2952; + if (!(this.precpred(this.context, 6))) { + throw this.createFailedPredicateException("this.precpred(this.context, 6)"); + } + this.state = 2953; + localContext._operator = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 94 || ((((_la - 362)) & ~0x1F) === 0 && ((1 << (_la - 362)) & 7) !== 0))) { + localContext._operator = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2954; + localContext._right = this.valueExpression(7); + } + break; + case 2: + { + localContext = new ValueExpressionContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_valueExpression); + this.state = 2955; + if (!(this.precpred(this.context, 5))) { + throw this.createFailedPredicateException("this.precpred(this.context, 5)"); + } + this.state = 2956; + localContext._operator = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(((((_la - 360)) & ~0x1F) === 0 && ((1 << (_la - 360)) & 259) !== 0))) { + localContext._operator = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2957; + localContext._right = this.valueExpression(6); + } + break; + case 3: + { + localContext = new ValueExpressionContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_valueExpression); + this.state = 2958; + if (!(this.precpred(this.context, 4))) { + throw this.createFailedPredicateException("this.precpred(this.context, 4)"); + } + this.state = 2959; + localContext._operator = this.match(SqlParser.AMPERSAND); + this.state = 2960; + localContext._right = this.valueExpression(5); + } + break; + case 4: + { + localContext = new ValueExpressionContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_valueExpression); + this.state = 2961; + if (!(this.precpred(this.context, 3))) { + throw this.createFailedPredicateException("this.precpred(this.context, 3)"); + } + this.state = 2962; + localContext._operator = this.match(SqlParser.HAT); + this.state = 2963; + localContext._right = this.valueExpression(4); + } + break; + case 5: + { + localContext = new ValueExpressionContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_valueExpression); + this.state = 2964; + if (!(this.precpred(this.context, 2))) { + throw this.createFailedPredicateException("this.precpred(this.context, 2)"); + } + this.state = 2965; + localContext._operator = this.match(SqlParser.PIPE); + this.state = 2966; + localContext._right = this.valueExpression(3); + } + break; + case 6: + { + localContext = new ValueExpressionContext(parentContext, parentState); + localContext._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_valueExpression); + this.state = 2967; + if (!(this.precpred(this.context, 1))) { + throw this.createFailedPredicateException("this.precpred(this.context, 1)"); + } + this.state = 2968; + this.comparisonOperator(); + this.state = 2969; + localContext._right = this.valueExpression(2); + } + break; + } + } + } + this.state = 2975; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 448, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(parentContext); + } + return localContext; + } + public datetimeUnit(): DatetimeUnitContext { + let localContext = new DatetimeUnitContext(this.context, this.state); + this.enterRule(localContext, 242, SqlParser.RULE_datetimeUnit); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 2976; + _la = this.tokenStream.LA(1); + if(!(_la === 67 || _la === 69 || _la === 134 || ((((_la - 179)) & ~0x1F) === 0 && ((1 << (_la - 179)) & 85) !== 0) || _la === 230 || _la === 258 || _la === 340 || _la === 347)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + + public primaryExpression(): PrimaryExpressionContext; + public primaryExpression(_p: number): PrimaryExpressionContext; + public primaryExpression(_p?: number): PrimaryExpressionContext { + if (_p === undefined) { + _p = 0; + } + + let parentContext = this.context; + let parentState = this.state; + let localContext = new PrimaryExpressionContext(this.context, parentState); + let previousContext = localContext; + let _startState = 244; + this.enterRecursionRule(localContext, 244, SqlParser.RULE_primaryExpression, _p); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 3227; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 474, this.context) ) { + case 1: + { + this.state = 2979; + localContext._name = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(((((_la - 63)) & ~0x1F) === 0 && ((1 << (_la - 63)) & 13) !== 0) || _la === 267 || _la === 330)) { + localContext._name = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case 2: + { + this.state = 2980; + localContext._name = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 74 || _la === 75 || _la === 305)) { + localContext._name = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2981; + this.match(SqlParser.LEFT_PAREN); + this.state = 2984; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_DAY: + case SqlParser.KW_DAYOFYEAR: + case SqlParser.KW_HOUR: + case SqlParser.KW_MICROSECOND: + case SqlParser.KW_MILLISECOND: + case SqlParser.KW_MINUTE: + case SqlParser.KW_MONTH: + case SqlParser.KW_QUARTER: + case SqlParser.KW_SECOND: + case SqlParser.KW_WEEK: + case SqlParser.KW_YEAR: + { + this.state = 2982; + localContext._unit = this.datetimeUnit(); + } + break; + case SqlParser.STRING_LITERAL: + case SqlParser.DOUBLEQUOTED_STRING: + { + this.state = 2983; + localContext._invalidUnit = this.stringLit(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 2986; + this.match(SqlParser.COMMA); + this.state = 2987; + localContext._unitsAmount = this.valueExpression(0); + this.state = 2988; + this.match(SqlParser.COMMA); + this.state = 2989; + localContext._timestamp = this.valueExpression(0); + this.state = 2990; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 3: + { + this.state = 2992; + localContext._name = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 76 || _la === 77 || _la === 301 || _la === 306)) { + localContext._name = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2993; + this.match(SqlParser.LEFT_PAREN); + this.state = 2996; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_DAY: + case SqlParser.KW_DAYOFYEAR: + case SqlParser.KW_HOUR: + case SqlParser.KW_MICROSECOND: + case SqlParser.KW_MILLISECOND: + case SqlParser.KW_MINUTE: + case SqlParser.KW_MONTH: + case SqlParser.KW_QUARTER: + case SqlParser.KW_SECOND: + case SqlParser.KW_WEEK: + case SqlParser.KW_YEAR: + { + this.state = 2994; + localContext._unit = this.datetimeUnit(); + } + break; + case SqlParser.STRING_LITERAL: + case SqlParser.DOUBLEQUOTED_STRING: + { + this.state = 2995; + localContext._invalidUnit = this.stringLit(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 2998; + this.match(SqlParser.COMMA); + this.state = 2999; + localContext._startTimestamp = this.valueExpression(0); + this.state = 3000; + this.match(SqlParser.COMMA); + this.state = 3001; + localContext._endTimestamp = this.valueExpression(0); + this.state = 3002; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 4: + { + this.state = 3004; + this.match(SqlParser.KW_CASE); + this.state = 3006; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 3005; + this.whenClause(); + } + } + this.state = 3008; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 342); + this.state = 3012; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 97) { + { + this.state = 3010; + this.match(SqlParser.KW_ELSE); + this.state = 3011; + localContext._elseExpression = this.expression(); + } + } + + this.state = 3014; + this.match(SqlParser.KW_END); + } + break; + case 5: + { + this.state = 3016; + this.match(SqlParser.KW_CASE); + this.state = 3017; + this.expression(); + this.state = 3019; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 3018; + this.whenClause(); + } + } + this.state = 3021; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 342); + this.state = 3025; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 97) { + { + this.state = 3023; + this.match(SqlParser.KW_ELSE); + this.state = 3024; + localContext._elseExpression = this.expression(); + } + } + + this.state = 3027; + this.match(SqlParser.KW_END); + } + break; + case 6: + { + this.state = 3029; + localContext._name = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 36 || _la === 317)) { + localContext._name = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3030; + this.match(SqlParser.LEFT_PAREN); + this.state = 3031; + this.expression(); + this.state = 3032; + this.match(SqlParser.KW_AS); + this.state = 3033; + this.dataType(); + this.state = 3034; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 7: + { + this.state = 3036; + this.match(SqlParser.KW_STRUCT); + this.state = 3037; + this.match(SqlParser.LEFT_PAREN); + this.state = 3046; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 456, this.context) ) { + case 1: + { + this.state = 3038; + this.namedExpression(); + this.state = 3043; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3039; + this.match(SqlParser.COMMA); + this.state = 3040; + this.namedExpression(); + } + } + this.state = 3045; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; + } + this.state = 3048; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 8: + { + this.state = 3049; + this.match(SqlParser.KW_FIRST); + this.state = 3050; + this.match(SqlParser.LEFT_PAREN); + this.state = 3051; + this.expression(); + this.state = 3054; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 138) { + { + this.state = 3052; + this.match(SqlParser.KW_IGNORE); + this.state = 3053; + this.match(SqlParser.KW_NULLS); + } + } + + this.state = 3056; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 9: + { + this.state = 3058; + this.match(SqlParser.KW_ANY_VALUE); + this.state = 3059; + this.match(SqlParser.LEFT_PAREN); + this.state = 3060; + this.expression(); + this.state = 3063; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 138) { + { + this.state = 3061; + this.match(SqlParser.KW_IGNORE); + this.state = 3062; + this.match(SqlParser.KW_NULLS); + } + } + + this.state = 3065; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 10: + { + this.state = 3067; + this.match(SqlParser.KW_LAST); + this.state = 3068; + this.match(SqlParser.LEFT_PAREN); + this.state = 3069; + this.expression(); + this.state = 3072; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 138) { + { + this.state = 3070; + this.match(SqlParser.KW_IGNORE); + this.state = 3071; + this.match(SqlParser.KW_NULLS); + } + } + + this.state = 3074; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 11: + { + this.state = 3076; + this.match(SqlParser.KW_POSITION); + this.state = 3077; + this.match(SqlParser.LEFT_PAREN); + this.state = 3078; + localContext._substr = this.valueExpression(0); + this.state = 3079; + this.match(SqlParser.KW_IN); + this.state = 3080; + localContext._str = this.valueExpression(0); + this.state = 3081; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 12: + { + this.state = 3083; + this.constant(); + } + break; + case 13: + { + this.state = 3084; + this.match(SqlParser.ASTERISK); + } + break; + case 14: + { + this.state = 3085; + this.qualifiedName(); + this.state = 3086; + this.match(SqlParser.DOT); + this.state = 3087; + this.match(SqlParser.ASTERISK); + } + break; + case 15: + { + this.state = 3089; + this.match(SqlParser.LEFT_PAREN); + this.state = 3090; + this.namedExpression(); + this.state = 3093; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 3091; + this.match(SqlParser.COMMA); + this.state = 3092; + this.namedExpression(); + } + } + this.state = 3095; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 4); + this.state = 3097; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 16: + { + this.state = 3099; + this.match(SqlParser.LEFT_PAREN); + this.state = 3100; + this.query(); + this.state = 3101; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 17: + { + this.state = 3103; + this.match(SqlParser.KW_IDENTIFIER); + this.state = 3104; + this.match(SqlParser.LEFT_PAREN); + this.state = 3105; + this.expression(); + this.state = 3106; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 18: + { + this.state = 3108; + this.functionName(); + this.state = 3109; + this.match(SqlParser.LEFT_PAREN); + this.state = 3121; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 359)) & ~0x1F) === 0 && ((1 << (_la - 359)) & 1073678415) !== 0)) { + { + this.state = 3111; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 461, this.context) ) { + case 1: + { + this.state = 3110; + this.setQuantifier(); + } + break; + } + this.state = 3113; + this.functionArgument(); + this.state = 3118; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3114; + this.match(SqlParser.COMMA); + this.state = 3115; + this.functionArgument(); + } + } + this.state = 3120; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + + this.state = 3123; + this.match(SqlParser.RIGHT_PAREN); + this.state = 3130; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 464, this.context) ) { + case 1: + { + this.state = 3124; + this.match(SqlParser.KW_FILTER); + this.state = 3125; + this.match(SqlParser.LEFT_PAREN); + this.state = 3126; + this.match(SqlParser.KW_WHERE); + this.state = 3127; + localContext._where = this.booleanExpression(0); + this.state = 3128; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + this.state = 3134; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 465, this.context) ) { + case 1: + { + this.state = 3132; + localContext._nullsOption = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 138 || _la === 245)) { + localContext._nullsOption = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3133; + this.match(SqlParser.KW_NULLS); + } + break; + } + this.state = 3138; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 466, this.context) ) { + case 1: + { + this.state = 3136; + this.match(SqlParser.KW_OVER); + this.state = 3137; + this.windowSpec(); + } + break; + } + } + break; + case 19: + { + this.state = 3140; + this.identifier(); + this.state = 3141; + this.match(SqlParser.ARROW); + this.state = 3142; + this.expression(); + } + break; + case 20: + { + this.state = 3144; + this.match(SqlParser.LEFT_PAREN); + this.state = 3145; + this.identifier(); + this.state = 3148; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 3146; + this.match(SqlParser.COMMA); + this.state = 3147; + this.identifier(); + } + } + this.state = 3150; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 4); + this.state = 3152; + this.match(SqlParser.RIGHT_PAREN); + this.state = 3153; + this.match(SqlParser.ARROW); + this.state = 3154; + this.expression(); + } + break; + case 21: + { + this.state = 3156; + this.identifier(); + } + break; + case 22: + { + this.state = 3157; + this.match(SqlParser.LEFT_PAREN); + this.state = 3158; + this.expression(); + this.state = 3159; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 23: + { + this.state = 3161; + this.match(SqlParser.KW_EXTRACT); + this.state = 3162; + this.match(SqlParser.LEFT_PAREN); + this.state = 3163; + localContext._field = this.identifier(); + this.state = 3164; + this.match(SqlParser.KW_FROM); + this.state = 3165; + localContext._source = this.valueExpression(0); + this.state = 3166; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 24: + { + this.state = 3168; + _la = this.tokenStream.LA(1); + if(!(_la === 286 || _la === 287)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3169; + this.match(SqlParser.LEFT_PAREN); + this.state = 3170; + localContext._str = this.valueExpression(0); + this.state = 3171; + _la = this.tokenStream.LA(1); + if(!(_la === 4 || _la === 123)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3172; + localContext._pos = this.valueExpression(0); + this.state = 3175; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 4 || _la === 119) { + { + this.state = 3173; + _la = this.tokenStream.LA(1); + if(!(_la === 4 || _la === 119)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3174; + localContext._len = this.valueExpression(0); + } + } + + this.state = 3177; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 25: + { + this.state = 3179; + this.match(SqlParser.KW_TRIM); + this.state = 3180; + this.match(SqlParser.LEFT_PAREN); + this.state = 3182; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 469, this.context) ) { + case 1: + { + this.state = 3181; + localContext._trimOption = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 28 || _la === 160 || _la === 310)) { + localContext._trimOption = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + this.state = 3185; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 360)) & ~0x1F) === 0 && ((1 << (_la - 360)) & 536839207) !== 0)) { + { + this.state = 3184; + localContext._trimStr = this.valueExpression(0); + } + } + + this.state = 3187; + this.match(SqlParser.KW_FROM); + this.state = 3188; + localContext._srcStr = this.valueExpression(0); + this.state = 3189; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 26: + { + this.state = 3191; + this.match(SqlParser.KW_OVERLAY); + this.state = 3192; + this.match(SqlParser.LEFT_PAREN); + this.state = 3193; + localContext._input = this.valueExpression(0); + this.state = 3194; + this.match(SqlParser.KW_PLACING); + this.state = 3195; + localContext._replace = this.valueExpression(0); + this.state = 3196; + this.match(SqlParser.KW_FROM); + this.state = 3197; + localContext._position = this.valueExpression(0); + this.state = 3200; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 119) { + { + this.state = 3198; + this.match(SqlParser.KW_FOR); + this.state = 3199; + localContext._length = this.valueExpression(0); + } + } + + this.state = 3202; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 27: + { + this.state = 3204; + localContext._name = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 219 || _la === 220)) { + localContext._name = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3205; + this.match(SqlParser.LEFT_PAREN); + this.state = 3206; + localContext._percentage = this.valueExpression(0); + this.state = 3207; + this.match(SqlParser.RIGHT_PAREN); + this.state = 3208; + this.match(SqlParser.KW_WITHIN); + this.state = 3209; + this.match(SqlParser.KW_GROUP); + this.state = 3210; + this.match(SqlParser.LEFT_PAREN); + this.state = 3211; + this.match(SqlParser.KW_ORDER); + this.state = 3212; + this.match(SqlParser.KW_BY); + this.state = 3213; + this.sortItem(); + this.state = 3214; + this.match(SqlParser.RIGHT_PAREN); + this.state = 3221; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 472, this.context) ) { + case 1: + { + this.state = 3215; + this.match(SqlParser.KW_FILTER); + this.state = 3216; + this.match(SqlParser.LEFT_PAREN); + this.state = 3217; + this.match(SqlParser.KW_WHERE); + this.state = 3218; + localContext._where = this.booleanExpression(0); + this.state = 3219; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + this.state = 3225; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 473, this.context) ) { + case 1: + { + this.state = 3223; + this.match(SqlParser.KW_OVER); + this.state = 3224; + this.windowSpec(); + } + break; + } + } + break; + } + this.context!.stop = this.tokenStream.LT(-1); + this.state = 3239; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 476, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + previousContext = localContext; + { + this.state = 3237; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 475, this.context) ) { + case 1: + { + localContext = new PrimaryExpressionContext(parentContext, parentState); + localContext._value = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_primaryExpression); + this.state = 3229; + if (!(this.precpred(this.context, 9))) { + throw this.createFailedPredicateException("this.precpred(this.context, 9)"); + } + this.state = 3230; + this.match(SqlParser.LEFT_BRACKET); + this.state = 3231; + localContext._index = this.valueExpression(0); + this.state = 3232; + this.match(SqlParser.RIGHT_BRACKET); + } + break; + case 2: + { + localContext = new PrimaryExpressionContext(parentContext, parentState); + localContext._base = previousContext; + this.pushNewRecursionContext(localContext, _startState, SqlParser.RULE_primaryExpression); + this.state = 3234; + if (!(this.precpred(this.context, 7))) { + throw this.createFailedPredicateException("this.precpred(this.context, 7)"); + } + this.state = 3235; + this.match(SqlParser.DOT); + this.state = 3236; + localContext._fieldName = this.identifier(); + } + break; + } + } + } + this.state = 3241; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 476, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(parentContext); + } + return localContext; + } + public literalType(): LiteralTypeContext { + let localContext = new LiteralTypeContext(this.context, this.state); + this.enterRule(localContext, 246, SqlParser.RULE_literalType); + try { + this.state = 3249; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 477, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3242; + this.match(SqlParser.KW_DATE); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3243; + this.match(SqlParser.KW_TIMESTAMP); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3244; + this.match(SqlParser.KW_TIMESTAMP_LTZ); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 3245; + this.match(SqlParser.KW_TIMESTAMP_NTZ); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 3246; + this.match(SqlParser.KW_INTERVAL); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 3247; + this.match(SqlParser.KW_BINARY_HEX); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 3248; + localContext._unsupportedType = this.identifier(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public constant(): ConstantContext { + let localContext = new ConstantContext(this.context, this.state); + this.enterRule(localContext, 248, SqlParser.RULE_constant); + try { + let alternative: number; + this.state = 3266; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 479, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3251; + this.match(SqlParser.KW_NULL); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3252; + this.match(SqlParser.QUESTION); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3253; + this.match(SqlParser.COLON); + this.state = 3254; + this.identifier(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 3255; + this.interval(); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 3256; + this.literalType(); + this.state = 3257; + this.stringLit(); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 3259; + this.number_(); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 3260; + this.booleanValue(); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 3262; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 3261; + this.stringLit(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 3264; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 478, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public comparisonOperator(): ComparisonOperatorContext { + let localContext = new ComparisonOperatorContext(this.context, this.state); + this.enterRule(localContext, 250, SqlParser.RULE_comparisonOperator); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3268; + _la = this.tokenStream.LA(1); + if(!(((((_la - 351)) & ~0x1F) === 0 && ((1 << (_la - 351)) & 255) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public arithmeticOperator(): ArithmeticOperatorContext { + let localContext = new ArithmeticOperatorContext(this.context, this.state); + this.enterRule(localContext, 252, SqlParser.RULE_arithmeticOperator); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3270; + _la = this.tokenStream.LA(1); + if(!(_la === 94 || ((((_la - 360)) & ~0x1F) === 0 && ((1 << (_la - 360)) & 1023) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public predicateOperator(): PredicateOperatorContext { + let localContext = new PredicateOperatorContext(this.context, this.state); + this.enterRule(localContext, 254, SqlParser.RULE_predicateOperator); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3272; + _la = this.tokenStream.LA(1); + if(!(_la === 14 || _la === 140 || _la === 196 || _la === 207)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public booleanValue(): BooleanValueContext { + let localContext = new BooleanValueContext(this.context, this.state); + this.enterRule(localContext, 256, SqlParser.RULE_booleanValue); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3274; + _la = this.tokenStream.LA(1); + if(!(_la === 111 || _la === 315)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public interval(): IntervalContext { + let localContext = new IntervalContext(this.context, this.state); + this.enterRule(localContext, 258, SqlParser.RULE_interval); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3276; + this.match(SqlParser.KW_INTERVAL); + this.state = 3279; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 480, this.context) ) { + case 1: + { + this.state = 3277; + this.errorCapturingMultiUnitsInterval(); + } + break; + case 2: + { + this.state = 3278; + this.errorCapturingUnitToUnitInterval(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext { + let localContext = new ErrorCapturingMultiUnitsIntervalContext(this.context, this.state); + this.enterRule(localContext, 260, SqlParser.RULE_errorCapturingMultiUnitsInterval); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3281; + localContext._body = this.multiUnitsInterval(); + this.state = 3283; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 481, this.context) ) { + case 1: + { + this.state = 3282; + this.unitToUnitInterval(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext { + let localContext = new ErrorCapturingUnitToUnitIntervalContext(this.context, this.state); + this.enterRule(localContext, 262, SqlParser.RULE_errorCapturingUnitToUnitInterval); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3285; + localContext._body = this.unitToUnitInterval(); + this.state = 3288; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 482, this.context) ) { + case 1: + { + this.state = 3286; + localContext._error1 = this.multiUnitsInterval(); + } + break; + case 2: + { + this.state = 3287; + localContext._error2 = this.unitToUnitInterval(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public multiUnitsInterval(): MultiUnitsIntervalContext { + let localContext = new MultiUnitsIntervalContext(this.context, this.state); + this.enterRule(localContext, 264, SqlParser.RULE_multiUnitsInterval); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 3293; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 3290; + this.intervalValue(); + this.state = 3291; + localContext._unitInMultiUnits = this.unitInMultiUnits(); + localContext._unit.push(localContext._unitInMultiUnits); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 3295; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 483, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public unitToUnitInterval(): UnitToUnitIntervalContext { + let localContext = new UnitToUnitIntervalContext(this.context, this.state); + this.enterRule(localContext, 266, SqlParser.RULE_unitToUnitInterval); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3297; + localContext._value = this.intervalValue(); + this.state = 3298; + this.unitInUnitToUnit(); + this.state = 3299; + this.match(SqlParser.KW_TO); + this.state = 3300; + this.unitInUnitToUnit(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public intervalValue(): IntervalValueContext { + let localContext = new IntervalValueContext(this.context, this.state); + this.enterRule(localContext, 268, SqlParser.RULE_intervalValue); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3303; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 360 || _la === 361) { + { + this.state = 3302; + _la = this.tokenStream.LA(1); + if(!(_la === 360 || _la === 361)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 3308; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.INTEGER_VALUE: + { + this.state = 3305; + this.match(SqlParser.INTEGER_VALUE); + } + break; + case SqlParser.DECIMAL_VALUE: + { + this.state = 3306; + this.match(SqlParser.DECIMAL_VALUE); + } + break; + case SqlParser.STRING_LITERAL: + case SqlParser.DOUBLEQUOTED_STRING: + { + this.state = 3307; + this.stringLit(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public unitInMultiUnits(): UnitInMultiUnitsContext { + let localContext = new UnitInMultiUnitsContext(this.context, this.state); + this.enterRule(localContext, 270, SqlParser.RULE_unitInMultiUnits); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3310; + _la = this.tokenStream.LA(1); + if(!(_la === 67 || _la === 68 || _la === 134 || _la === 135 || ((((_la - 179)) & ~0x1F) === 0 && ((1 << (_la - 179)) & 12543) !== 0) || _la === 258 || _la === 259 || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 387) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public unitInUnitToUnit(): UnitInUnitToUnitContext { + let localContext = new UnitInUnitToUnitContext(this.context, this.state); + this.enterRule(localContext, 272, SqlParser.RULE_unitInUnitToUnit); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3312; + _la = this.tokenStream.LA(1); + if(!(_la === 67 || _la === 134 || _la === 183 || _la === 185 || _la === 258 || _la === 347)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public colPosition(): ColPositionContext { + let localContext = new ColPositionContext(this.context, this.state); + this.enterRule(localContext, 274, SqlParser.RULE_colPosition); + try { + this.state = 3317; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_FIRST: + this.enterOuterAlt(localContext, 1); + { + this.state = 3314; + localContext._position = this.match(SqlParser.KW_FIRST); + } + break; + case SqlParser.KW_AFTER: + this.enterOuterAlt(localContext, 2); + { + this.state = 3315; + localContext._position = this.match(SqlParser.KW_AFTER); + this.state = 3316; + localContext._afterCol = this.errorCapturingIdentifier(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public type_(): TypeContext { + let localContext = new TypeContext(this.context, this.state); + this.enterRule(localContext, 276, SqlParser.RULE_type); + try { + this.state = 3349; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 487, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3319; + this.match(SqlParser.KW_BOOLEAN); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3320; + this.match(SqlParser.KW_TINYINT); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3321; + this.match(SqlParser.KW_BYTE); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 3322; + this.match(SqlParser.KW_SMALLINT); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 3323; + this.match(SqlParser.KW_SHORT); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 3324; + this.match(SqlParser.KW_INT); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 3325; + this.match(SqlParser.KW_INTEGER); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 3326; + this.match(SqlParser.KW_BIGINT); + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 3327; + this.match(SqlParser.KW_LONG); + } + break; + case 10: + this.enterOuterAlt(localContext, 10); + { + this.state = 3328; + this.match(SqlParser.KW_FLOAT); + } + break; + case 11: + this.enterOuterAlt(localContext, 11); + { + this.state = 3329; + this.match(SqlParser.KW_REAL); + } + break; + case 12: + this.enterOuterAlt(localContext, 12); + { + this.state = 3330; + this.match(SqlParser.KW_DOUBLE); + } + break; + case 13: + this.enterOuterAlt(localContext, 13); + { + this.state = 3331; + this.match(SqlParser.KW_DATE); + } + break; + case 14: + this.enterOuterAlt(localContext, 14); + { + this.state = 3332; + this.match(SqlParser.KW_TIMESTAMP); + } + break; + case 15: + this.enterOuterAlt(localContext, 15); + { + this.state = 3333; + this.match(SqlParser.KW_TIMESTAMP_NTZ); + } + break; + case 16: + this.enterOuterAlt(localContext, 16); + { + this.state = 3334; + this.match(SqlParser.KW_TIMESTAMP_LTZ); + } + break; + case 17: + this.enterOuterAlt(localContext, 17); + { + this.state = 3335; + this.match(SqlParser.KW_STRING); + } + break; + case 18: + this.enterOuterAlt(localContext, 18); + { + this.state = 3336; + this.match(SqlParser.KW_CHARACTER); + } + break; + case 19: + this.enterOuterAlt(localContext, 19); + { + this.state = 3337; + this.match(SqlParser.KW_CHAR); + } + break; + case 20: + this.enterOuterAlt(localContext, 20); + { + this.state = 3338; + this.match(SqlParser.KW_VARCHAR); + } + break; + case 21: + this.enterOuterAlt(localContext, 21); + { + this.state = 3339; + this.match(SqlParser.KW_BINARY); + } + break; + case 22: + this.enterOuterAlt(localContext, 22); + { + this.state = 3340; + this.match(SqlParser.KW_DECIMAL); + } + break; + case 23: + this.enterOuterAlt(localContext, 23); + { + this.state = 3341; + this.match(SqlParser.KW_DEC); + } + break; + case 24: + this.enterOuterAlt(localContext, 24); + { + this.state = 3342; + this.match(SqlParser.KW_NUMERIC); + } + break; + case 25: + this.enterOuterAlt(localContext, 25); + { + this.state = 3343; + this.match(SqlParser.KW_VOID); + } + break; + case 26: + this.enterOuterAlt(localContext, 26); + { + this.state = 3344; + this.match(SqlParser.KW_INTERVAL); + } + break; + case 27: + this.enterOuterAlt(localContext, 27); + { + this.state = 3345; + this.match(SqlParser.KW_ARRAY); + } + break; + case 28: + this.enterOuterAlt(localContext, 28); + { + this.state = 3346; + this.match(SqlParser.KW_STRUCT); + } + break; + case 29: + this.enterOuterAlt(localContext, 29); + { + this.state = 3347; + this.match(SqlParser.KW_MAP); + } + break; + case 30: + this.enterOuterAlt(localContext, 30); + { + this.state = 3348; + localContext._unsupportedType = this.identifier(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public dataType(): DataTypeContext { + let localContext = new DataTypeContext(this.context, this.state); + this.enterRule(localContext, 278, SqlParser.RULE_dataType); + let _la: number; + try { + this.state = 3404; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 495, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3351; + localContext._complex = this.match(SqlParser.KW_ARRAY); + this.state = 3352; + this.match(SqlParser.LT); + this.state = 3353; + this.dataType(); + this.state = 3354; + this.match(SqlParser.GT); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3356; + localContext._complex = this.match(SqlParser.KW_MAP); + this.state = 3357; + this.match(SqlParser.LT); + this.state = 3358; + this.dataType(); + this.state = 3359; + this.match(SqlParser.COMMA); + this.state = 3360; + this.dataType(); + this.state = 3361; + this.match(SqlParser.GT); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3363; + localContext._complex = this.match(SqlParser.KW_STRUCT); + this.state = 3377; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.LT: + { + this.state = 3364; + this.match(SqlParser.LT); + this.state = 3373; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967040) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967287) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967231) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147483647) !== 0) || ((((_la - 377)) & ~0x1F) === 0 && ((1 << (_la - 377)) & 3073) !== 0)) { + { + this.state = 3365; + this.complexColType(); + this.state = 3370; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3366; + this.match(SqlParser.COMMA); + this.state = 3367; + this.complexColType(); + } + } + this.state = 3372; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + + this.state = 3375; + this.match(SqlParser.GT); + } + break; + case SqlParser.NEQ: + { + this.state = 3376; + this.match(SqlParser.NEQ); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 3379; + this.match(SqlParser.KW_INTERVAL); + this.state = 3380; + _la = this.tokenStream.LA(1); + if(!(_la === 185 || _la === 347)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3383; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 491, this.context) ) { + case 1: + { + this.state = 3381; + this.match(SqlParser.KW_TO); + this.state = 3382; + this.match(SqlParser.KW_MONTH); + } + break; + } + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 3385; + this.match(SqlParser.KW_INTERVAL); + this.state = 3386; + _la = this.tokenStream.LA(1); + if(!(_la === 67 || _la === 134 || _la === 183 || _la === 258)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3389; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 492, this.context) ) { + case 1: + { + this.state = 3387; + this.match(SqlParser.KW_TO); + this.state = 3388; + _la = this.tokenStream.LA(1); + if(!(_la === 134 || _la === 183 || _la === 258)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 3391; + this.type_(); + this.state = 3402; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 494, this.context) ) { + case 1: + { + this.state = 3392; + this.match(SqlParser.LEFT_PAREN); + this.state = 3393; + this.match(SqlParser.INTEGER_VALUE); + this.state = 3398; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3394; + this.match(SqlParser.COMMA); + this.state = 3395; + this.match(SqlParser.INTEGER_VALUE); + } + } + this.state = 3400; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 3401; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public qualifiedColTypeWithPositionSeqForAdd(): QualifiedColTypeWithPositionSeqForAddContext { + let localContext = new QualifiedColTypeWithPositionSeqForAddContext(this.context, this.state); + this.enterRule(localContext, 280, SqlParser.RULE_qualifiedColTypeWithPositionSeqForAdd); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3406; + this.qualifiedColTypeWithPositionForAdd(); + this.state = 3411; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3407; + this.match(SqlParser.COMMA); + this.state = 3408; + this.qualifiedColTypeWithPositionForAdd(); + } + } + this.state = 3413; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public qualifiedColTypeWithPositionForAdd(): QualifiedColTypeWithPositionForAddContext { + let localContext = new QualifiedColTypeWithPositionForAddContext(this.context, this.state); + this.enterRule(localContext, 282, SqlParser.RULE_qualifiedColTypeWithPositionForAdd); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 3414; + localContext._name = this.columnNameCreate(); + this.state = 3415; + this.dataType(); + this.state = 3419; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 497, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 3416; + this.colDefinitionDescriptorWithPosition(); + } + } + } + this.state = 3421; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 497, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public qualifiedColTypeWithPositionSeqForReplace(): QualifiedColTypeWithPositionSeqForReplaceContext { + let localContext = new QualifiedColTypeWithPositionSeqForReplaceContext(this.context, this.state); + this.enterRule(localContext, 284, SqlParser.RULE_qualifiedColTypeWithPositionSeqForReplace); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3422; + this.qualifiedColTypeWithPositionForReplace(); + this.state = 3427; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3423; + this.match(SqlParser.COMMA); + this.state = 3424; + this.qualifiedColTypeWithPositionForReplace(); + } + } + this.state = 3429; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public qualifiedColTypeWithPositionForReplace(): QualifiedColTypeWithPositionForReplaceContext { + let localContext = new QualifiedColTypeWithPositionForReplaceContext(this.context, this.state); + this.enterRule(localContext, 286, SqlParser.RULE_qualifiedColTypeWithPositionForReplace); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3430; + localContext._name = this.columnName(); + this.state = 3431; + this.dataType(); + this.state = 3435; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 9 || _la === 51 || _la === 82 || _la === 116 || _la === 196) { + { + { + this.state = 3432; + this.colDefinitionDescriptorWithPosition(); + } + } + this.state = 3437; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext { + let localContext = new ColDefinitionDescriptorWithPositionContext(this.context, this.state); + this.enterRule(localContext, 288, SqlParser.RULE_colDefinitionDescriptorWithPosition); + try { + this.state = 3445; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_NOT: + this.enterOuterAlt(localContext, 1); + { + this.state = 3438; + this.match(SqlParser.KW_NOT); + this.state = 3439; + this.match(SqlParser.KW_NULL); + } + break; + case SqlParser.KW_DEFAULT: + this.enterOuterAlt(localContext, 2); + { + this.state = 3440; + this.match(SqlParser.KW_DEFAULT); + this.state = 3441; + this.expression(); + } + break; + case SqlParser.KW_COMMENT: + this.enterOuterAlt(localContext, 3); + { + this.state = 3442; + this.match(SqlParser.KW_COMMENT); + this.state = 3443; + localContext._comment = this.stringLit(); + } + break; + case SqlParser.KW_AFTER: + case SqlParser.KW_FIRST: + this.enterOuterAlt(localContext, 4); + { + this.state = 3444; + this.colPosition(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public variableDefaultExpression(): VariableDefaultExpressionContext { + let localContext = new VariableDefaultExpressionContext(this.context, this.state); + this.enterRule(localContext, 290, SqlParser.RULE_variableDefaultExpression); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3447; + _la = this.tokenStream.LA(1); + if(!(_la === 82 || _la === 351)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3448; + this.expression(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public colTypeList(): ColTypeListContext { + let localContext = new ColTypeListContext(this.context, this.state); + this.enterRule(localContext, 292, SqlParser.RULE_colTypeList); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 3450; + this.columnType(); + this.state = 3455; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 501, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 3451; + this.match(SqlParser.COMMA); + this.state = 3452; + this.columnType(); + } + } + } + this.state = 3457; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 501, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public columnType(): ColumnTypeContext { + let localContext = new ColumnTypeContext(this.context, this.state); + this.enterRule(localContext, 294, SqlParser.RULE_columnType); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3458; + localContext._colName = this.errorCapturingIdentifier(); + this.state = 3459; + this.dataType(); + this.state = 3462; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 502, this.context) ) { + case 1: + { + this.state = 3460; + this.match(SqlParser.KW_NOT); + this.state = 3461; + this.match(SqlParser.KW_NULL); + } + break; + } + this.state = 3466; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 503, this.context) ) { + case 1: + { + this.state = 3464; + this.match(SqlParser.KW_COMMENT); + this.state = 3465; + localContext._comment = this.stringLit(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext { + let localContext = new CreateOrReplaceTableColTypeListContext(this.context, this.state); + this.enterRule(localContext, 296, SqlParser.RULE_createOrReplaceTableColTypeList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3468; + this.createOrReplaceTableColType(); + this.state = 3473; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3469; + this.match(SqlParser.COMMA); + this.state = 3470; + this.createOrReplaceTableColType(); + } + } + this.state = 3475; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createOrReplaceTableColType(): CreateOrReplaceTableColTypeContext { + let localContext = new CreateOrReplaceTableColTypeContext(this.context, this.state); + this.enterRule(localContext, 298, SqlParser.RULE_createOrReplaceTableColType); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3476; + localContext._colName = this.columnNameCreate(); + this.state = 3477; + localContext._colType = this.dataType(); + this.state = 3481; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 51 || _la === 82 || _la === 127 || _la === 196) { + { + { + this.state = 3478; + this.colDefinitionOption(); + } + } + this.state = 3483; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public colDefinitionOption(): ColDefinitionOptionContext { + let localContext = new ColDefinitionOptionContext(this.context, this.state); + this.enterRule(localContext, 300, SqlParser.RULE_colDefinitionOption); + try { + this.state = 3497; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_NOT: + this.enterOuterAlt(localContext, 1); + { + this.state = 3484; + this.match(SqlParser.KW_NOT); + this.state = 3485; + this.match(SqlParser.KW_NULL); + } + break; + case SqlParser.KW_DEFAULT: + this.enterOuterAlt(localContext, 2); + { + this.state = 3486; + this.match(SqlParser.KW_DEFAULT); + this.state = 3487; + this.expression(); + } + break; + case SqlParser.KW_GENERATED: + this.enterOuterAlt(localContext, 3); + { + this.state = 3488; + this.match(SqlParser.KW_GENERATED); + this.state = 3489; + this.match(SqlParser.KW_ALWAYS); + this.state = 3490; + this.match(SqlParser.KW_AS); + this.state = 3491; + this.match(SqlParser.LEFT_PAREN); + this.state = 3492; + this.expression(); + this.state = 3493; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case SqlParser.KW_COMMENT: + this.enterOuterAlt(localContext, 4); + { + this.state = 3495; + this.match(SqlParser.KW_COMMENT); + this.state = 3496; + localContext._comment = this.stringLit(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public complexColType(): ComplexColTypeContext { + let localContext = new ComplexColTypeContext(this.context, this.state); + this.enterRule(localContext, 302, SqlParser.RULE_complexColType); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3499; + this.identifier(); + this.state = 3501; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 370) { + { + this.state = 3500; + this.match(SqlParser.COLON); + } + } + + this.state = 3503; + this.dataType(); + this.state = 3506; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 196) { + { + this.state = 3504; + this.match(SqlParser.KW_NOT); + this.state = 3505; + this.match(SqlParser.KW_NULL); + } + } + + this.state = 3510; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 51) { + { + this.state = 3508; + this.match(SqlParser.KW_COMMENT); + this.state = 3509; + localContext._comment = this.stringLit(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public whenClause(): WhenClauseContext { + let localContext = new WhenClauseContext(this.context, this.state); + this.enterRule(localContext, 304, SqlParser.RULE_whenClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3512; + this.match(SqlParser.KW_WHEN); + this.state = 3513; + localContext._condition = this.expression(); + this.state = 3514; + this.match(SqlParser.KW_THEN); + this.state = 3515; + localContext._result = this.expression(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public windowClause(): WindowClauseContext { + let localContext = new WindowClauseContext(this.context, this.state); + this.enterRule(localContext, 306, SqlParser.RULE_windowClause); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 3517; + this.match(SqlParser.KW_WINDOW); + this.state = 3518; + localContext._name = this.errorCapturingIdentifier(); + this.state = 3519; + this.match(SqlParser.KW_AS); + this.state = 3520; + this.windowSpec(); + this.state = 3528; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 510, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 3521; + this.match(SqlParser.COMMA); + this.state = 3522; + localContext._name = this.errorCapturingIdentifier(); + this.state = 3523; + this.match(SqlParser.KW_AS); + this.state = 3524; + this.windowSpec(); + } + } + } + this.state = 3530; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 510, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public windowSpec(): WindowSpecContext { + let localContext = new WindowSpecContext(this.context, this.state); + this.enterRule(localContext, 308, SqlParser.RULE_windowSpec); + let _la: number; + try { + this.state = 3577; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 518, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3531; + localContext._name = this.errorCapturingIdentifier(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3532; + this.match(SqlParser.LEFT_PAREN); + this.state = 3533; + localContext._name = this.errorCapturingIdentifier(); + this.state = 3534; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3536; + this.match(SqlParser.LEFT_PAREN); + this.state = 3571; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case SqlParser.KW_CLUSTER: + { + this.state = 3537; + this.match(SqlParser.KW_CLUSTER); + this.state = 3538; + this.match(SqlParser.KW_BY); + this.state = 3539; + localContext._expression = this.expression(); + localContext._partition.push(localContext._expression); + this.state = 3544; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3540; + this.match(SqlParser.COMMA); + this.state = 3541; + localContext._expression = this.expression(); + localContext._partition.push(localContext._expression); + } + } + this.state = 3546; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; + case SqlParser.RIGHT_PAREN: + case SqlParser.KW_DISTRIBUTE: + case SqlParser.KW_ORDER: + case SqlParser.KW_PARTITION: + case SqlParser.KW_RANGE: + case SqlParser.KW_ROWS: + case SqlParser.KW_SORT: + { + this.state = 3557; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 93 || _la === 216) { + { + this.state = 3547; + _la = this.tokenStream.LA(1); + if(!(_la === 93 || _la === 216)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3548; + this.match(SqlParser.KW_BY); + this.state = 3549; + localContext._expression = this.expression(); + localContext._partition.push(localContext._expression); + this.state = 3554; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3550; + this.match(SqlParser.COMMA); + this.state = 3551; + localContext._expression = this.expression(); + localContext._partition.push(localContext._expression); + } + } + this.state = 3556; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + + this.state = 3569; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 208 || _la === 277) { + { + this.state = 3559; + _la = this.tokenStream.LA(1); + if(!(_la === 208 || _la === 277)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3560; + this.match(SqlParser.KW_BY); + this.state = 3561; + this.sortItem(); + this.state = 3566; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3562; + this.match(SqlParser.COMMA); + this.state = 3563; + this.sortItem(); + } + } + this.state = 3568; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 3574; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 232 || _la === 257) { + { + this.state = 3573; + this.windowFrame(); + } + } + + this.state = 3576; + this.match(SqlParser.RIGHT_PAREN); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public windowFrame(): WindowFrameContext { + let localContext = new WindowFrameContext(this.context, this.state); + this.enterRule(localContext, 310, SqlParser.RULE_windowFrame); + let _la: number; + try { + this.state = 3587; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 519, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3579; + localContext._frameType = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 232 || _la === 257)) { + localContext._frameType = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3580; + localContext._start_ = this.frameBound(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3581; + localContext._frameType = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 232 || _la === 257)) { + localContext._frameType = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3582; + this.match(SqlParser.KW_BETWEEN); + this.state = 3583; + localContext._start_ = this.frameBound(); + this.state = 3584; + this.match(SqlParser.KW_AND); + this.state = 3585; + localContext._end = this.frameBound(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public frameBound(): FrameBoundContext { + let localContext = new FrameBoundContext(this.context, this.state); + this.enterRule(localContext, 312, SqlParser.RULE_frameBound); + let _la: number; + try { + this.state = 3596; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 520, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3589; + this.match(SqlParser.KW_UNBOUNDED); + this.state = 3590; + localContext._boundType = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 118 || _la === 225)) { + localContext._boundType = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3591; + localContext._boundType = this.match(SqlParser.KW_CURRENT); + this.state = 3592; + this.match(SqlParser.KW_ROW); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3593; + this.expression(); + this.state = 3594; + localContext._boundType = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 118 || _la === 225)) { + localContext._boundType = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public qualifiedNameList(): QualifiedNameListContext { + let localContext = new QualifiedNameListContext(this.context, this.state); + this.enterRule(localContext, 314, SqlParser.RULE_qualifiedNameList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3598; + this.qualifiedName(); + this.state = 3603; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 3599; + this.match(SqlParser.COMMA); + this.state = 3600; + this.qualifiedName(); + } + } + this.state = 3605; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public functionName(): FunctionNameContext { + let localContext = new FunctionNameContext(this.context, this.state); + this.enterRule(localContext, 316, SqlParser.RULE_functionName); + try { + this.state = 3615; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 522, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3606; + this.match(SqlParser.KW_IDENTIFIER); + this.state = 3607; + this.match(SqlParser.LEFT_PAREN); + this.state = 3608; + this.expression(); + this.state = 3609; + this.match(SqlParser.RIGHT_PAREN); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3611; + this.qualifiedName(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3612; + this.match(SqlParser.KW_FILTER); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 3613; + this.match(SqlParser.KW_LEFT); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 3614; + this.match(SqlParser.KW_RIGHT); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public functionNameCreate(): FunctionNameCreateContext { + let localContext = new FunctionNameCreateContext(this.context, this.state); + this.enterRule(localContext, 318, SqlParser.RULE_functionNameCreate); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3617; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public qualifiedName(): QualifiedNameContext { + let localContext = new QualifiedNameContext(this.context, this.state); + this.enterRule(localContext, 320, SqlParser.RULE_qualifiedName); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 3619; + this.identifier(); + this.state = 3624; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 523, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 3620; + this.match(SqlParser.DOT); + this.state = 3621; + this.identifier(); + } + } + } + this.state = 3626; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 523, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext { + let localContext = new ErrorCapturingIdentifierContext(this.context, this.state); + this.enterRule(localContext, 322, SqlParser.RULE_errorCapturingIdentifier); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3627; + this.identifier(); + this.state = 3628; + this.errorCapturingIdentifierExtra(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext { + let localContext = new ErrorCapturingIdentifierExtraContext(this.context, this.state); + this.enterRule(localContext, 324, SqlParser.RULE_errorCapturingIdentifierExtra); + try { + let alternative: number; + this.state = 3637; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 525, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3632; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 3630; + this.match(SqlParser.MINUS); + this.state = 3631; + this.identifier(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 3634; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 524, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + // tslint:disable-next-line:no-empty + { + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public identifier(): IdentifierContext { + let localContext = new IdentifierContext(this.context, this.state); + this.enterRule(localContext, 326, SqlParser.RULE_identifier); + try { + this.state = 3641; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 526, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3639; + this.strictIdentifier(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3640; + this.strictNonReserved(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public strictIdentifier(): StrictIdentifierContext { + let localContext = new StrictIdentifierContext(this.context, this.state); + this.enterRule(localContext, 328, SqlParser.RULE_strictIdentifier); + try { + this.state = 3648; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 527, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3643; + this.match(SqlParser.IDENTIFIER); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 3644; + this.match(SqlParser.BACKQUOTED_IDENTIFIER); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3645; + this.match(SqlParser.DOUBLEQUOTED_STRING); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 3646; + this.ansiNonReserved(); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 3647; + this.nonReserved(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public number_(): NumberContext { + let localContext = new NumberContext(this.context, this.state); + this.enterRule(localContext, 330, SqlParser.RULE_number); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3651; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 361) { + { + this.state = 3650; + this.match(SqlParser.MINUS); + } + } + + this.state = 3653; + _la = this.tokenStream.LA(1); + if(!(((((_la - 378)) & ~0x1F) === 0 && ((1 << (_la - 378)) & 511) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public alterColumnAction(): AlterColumnActionContext { + let localContext = new AlterColumnActionContext(this.context, this.state); + this.enterRule(localContext, 332, SqlParser.RULE_alterColumnAction); + let _la: number; + try { + this.state = 3668; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 529, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 3655; + this.match(SqlParser.KW_TYPE); + this.state = 3656; + this.dataType(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + { + this.state = 3657; + this.match(SqlParser.KW_COMMENT); + this.state = 3658; + localContext._comment = this.stringLit(); + } + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3659; + this.colPosition(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 3660; + localContext._setOrDrop = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 96 || _la === 268)) { + localContext._setOrDrop = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3661; + this.match(SqlParser.KW_NOT); + this.state = 3662; + this.match(SqlParser.KW_NULL); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 3663; + this.match(SqlParser.KW_SET); + this.state = 3664; + this.match(SqlParser.KW_DEFAULT); + this.state = 3665; + this.expression(); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 3666; + localContext._dropDefault = this.match(SqlParser.KW_DROP); + this.state = 3667; + this.match(SqlParser.KW_DEFAULT); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public stringLit(): StringLitContext { + let localContext = new StringLitContext(this.context, this.state); + this.enterRule(localContext, 334, SqlParser.RULE_stringLit); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3670; + _la = this.tokenStream.LA(1); + if(!(_la === 376 || _la === 377)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public ansiNonReserved(): AnsiNonReservedContext { + let localContext = new AnsiNonReservedContext(this.context, this.state); + this.enterRule(localContext, 336, SqlParser.RULE_ansiNonReserved); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3672; + _la = this.tokenStream.LA(1); + if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 4017011456) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 1711111143) !== 0) || ((((_la - 67)) & ~0x1F) === 0 && ((1 << (_la - 67)) & 3187671039) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & 1328796669) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & 3316086655) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & 805306367) !== 0) || ((((_la - 198)) & ~0x1F) === 0 && ((1 << (_la - 198)) & 4020201927) !== 0) || ((((_la - 230)) & ~0x1F) === 0 && ((1 << (_la - 230)) & 4294442751) !== 0) || ((((_la - 263)) & ~0x1F) === 0 && ((1 << (_la - 263)) & 3758088175) !== 0) || ((((_la - 295)) & ~0x1F) === 0 && ((1 << (_la - 295)) & 3355402191) !== 0) || ((((_la - 327)) & ~0x1F) === 0 && ((1 << (_la - 327)) & 15892455) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public strictNonReserved(): StrictNonReservedContext { + let localContext = new StrictNonReservedContext(this.context, this.state); + this.enterRule(localContext, 338, SqlParser.RULE_strictNonReserved); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3674; + _la = this.tokenStream.LA(1); + if(!(_la === 15 || _la === 60 || _la === 102 || _la === 124 || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & 149521) !== 0) || _la === 193 || _la === 202 || ((((_la - 249)) & ~0x1F) === 0 && ((1 << (_la - 249)) & 1064961) !== 0) || _la === 322 || _la === 331)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public nonReserved(): NonReservedContext { + let localContext = new NonReservedContext(this.context, this.state); + this.enterRule(localContext, 340, SqlParser.RULE_nonReserved); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 3676; + _la = this.tokenStream.LA(1); + if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294934272) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4026531839) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 3892314047) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 3085893631) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967293) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294966261) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4261412863) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294958911) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967279) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 2147481595) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + + public override sempred(localContext: antlr.RuleContext | null, ruleIndex: number, predIndex: number): boolean { + switch (ruleIndex) { + case 41: + return this.columnName_sempred(localContext as ColumnNameContext, predIndex); + case 46: + return this.queryTerm_sempred(localContext as QueryTermContext, predIndex); + case 118: + return this.booleanExpression_sempred(localContext as BooleanExpressionContext, predIndex); + case 120: + return this.valueExpression_sempred(localContext as ValueExpressionContext, predIndex); + case 122: + return this.primaryExpression_sempred(localContext as PrimaryExpressionContext, predIndex); + } + return true; + } + private columnName_sempred(localContext: ColumnNameContext | null, predIndex: number): boolean { + switch (predIndex) { + case 0: + return this.shouldMatchEmpty(); + } + return true; + } + private queryTerm_sempred(localContext: QueryTermContext | null, predIndex: number): boolean { + switch (predIndex) { + case 1: + return this.precpred(this.context, 3); + case 2: + return this.precpred(this.context, 2); + case 3: + return this.precpred(this.context, 1); + } + return true; + } + private booleanExpression_sempred(localContext: BooleanExpressionContext | null, predIndex: number): boolean { + switch (predIndex) { + case 4: + return this.precpred(this.context, 2); + case 5: + return this.precpred(this.context, 1); + } + return true; + } + private valueExpression_sempred(localContext: ValueExpressionContext | null, predIndex: number): boolean { + switch (predIndex) { + case 6: + return this.precpred(this.context, 6); + case 7: + return this.precpred(this.context, 5); + case 8: + return this.precpred(this.context, 4); + case 9: + return this.precpred(this.context, 3); + case 10: + return this.precpred(this.context, 2); + case 11: + return this.precpred(this.context, 1); + } + return true; + } + private primaryExpression_sempred(localContext: PrimaryExpressionContext | null, predIndex: number): boolean { + switch (predIndex) { + case 12: + return this.precpred(this.context, 9); + case 13: + return this.precpred(this.context, 7); + } + return true; + } + + public static readonly _serializedATN: number[] = [ + 4,1,392,3679,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,5,0,344,8,0,10,0,12,0,347,9,0,1,0,1,0,1,1,1,1,3, + 1,353,8,1,1,2,1,2,3,2,357,8,2,1,2,1,2,1,2,3,2,362,8,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,3,2,373,8,2,1,2,1,2,1,2,1,2,3,2,379,8, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,3,2,390,8,2,1,2,1,2,1,2,1, + 2,3,2,396,8,2,1,2,1,2,1,2,3,2,401,8,2,1,2,1,2,1,2,3,2,406,8,2,1, + 2,3,2,409,8,2,1,2,1,2,3,2,413,8,2,1,2,3,2,416,8,2,1,2,1,2,3,2,420, + 8,2,1,2,1,2,1,2,1,2,3,2,426,8,2,1,2,1,2,1,2,1,2,3,2,432,8,2,1,2, + 1,2,1,2,3,2,437,8,2,1,2,1,2,1,2,3,2,442,8,2,1,2,3,2,445,8,2,1,2, + 1,2,3,2,449,8,2,1,2,3,2,452,8,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,3,2, + 461,8,2,1,2,1,2,1,2,3,2,466,8,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2, + 1,2,5,2,477,8,2,10,2,12,2,480,9,2,3,2,482,8,2,1,2,1,2,3,2,486,8, + 2,1,2,1,2,1,2,1,2,3,2,492,8,2,1,2,3,2,495,8,2,1,2,3,2,498,8,2,1, + 2,1,2,1,2,3,2,503,8,2,1,2,1,2,1,2,1,2,1,2,1,2,3,2,511,8,2,1,2,1, + 2,1,2,3,2,516,8,2,1,2,1,2,1,2,1,2,3,2,522,8,2,1,2,3,2,525,8,2,1, + 2,1,2,1,2,1,2,1,2,3,2,532,8,2,1,2,1,2,1,2,5,2,537,8,2,10,2,12,2, + 540,9,2,1,2,1,2,5,2,544,8,2,10,2,12,2,547,9,2,1,2,1,2,5,2,551,8, + 2,10,2,12,2,554,9,2,1,2,1,2,1,2,3,2,559,8,2,1,2,1,2,1,2,1,2,1,2, + 1,2,5,2,567,8,2,10,2,12,2,570,9,2,3,2,572,8,2,1,3,1,3,1,3,1,3,1, + 3,1,3,1,3,1,3,3,3,582,8,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,590,8,3,1, + 3,1,3,3,3,594,8,3,1,3,3,3,597,8,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,605, + 8,3,1,3,3,3,608,8,3,1,3,1,3,3,3,612,8,3,1,3,3,3,615,8,3,1,3,1,3, + 1,3,1,3,1,3,3,3,622,8,3,1,3,1,3,1,3,3,3,627,8,3,1,3,1,3,1,3,3,3, + 632,8,3,1,3,1,3,1,3,1,3,1,3,3,3,639,8,3,1,3,1,3,1,3,3,3,644,8,3, + 1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,653,8,3,1,3,1,3,3,3,657,8,3,1,3, + 1,3,1,3,1,3,3,3,663,8,3,1,3,1,3,3,3,667,8,3,1,3,1,3,3,3,671,8,3, + 1,3,1,3,1,3,3,3,676,8,3,1,3,1,3,1,3,1,3,3,3,682,8,3,1,3,1,3,1,3, + 1,3,1,3,3,3,689,8,3,1,3,1,3,1,3,3,3,694,8,3,1,3,4,3,697,8,3,11,3, + 12,3,698,1,3,3,3,702,8,3,1,3,1,3,5,3,706,8,3,10,3,12,3,709,9,3,1, + 3,3,3,712,8,3,1,3,1,3,1,3,1,3,3,3,718,8,3,1,3,1,3,1,3,1,3,1,3,1, + 3,3,3,726,8,3,1,3,1,3,3,3,730,8,3,1,3,1,3,1,3,3,3,735,8,3,1,3,1, + 3,1,3,1,3,3,3,741,8,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3, + 3,753,8,3,1,3,1,3,1,3,3,3,758,8,3,1,3,3,3,761,8,3,1,3,3,3,764,8, + 3,1,3,3,3,767,8,3,1,3,3,3,770,8,3,1,3,3,3,773,8,3,1,3,1,3,1,3,1, + 3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,788,8,3,1,3,1,3,3,3,792, + 8,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,801,8,3,1,3,1,3,3,3,805,8,3, + 1,3,1,3,1,3,5,3,810,8,3,10,3,12,3,813,9,3,1,3,3,3,816,8,3,1,3,1, + 3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,5,3,827,8,3,10,3,12,3,830,9,3,1,3, + 1,3,1,3,1,3,1,3,3,3,837,8,3,1,3,5,3,840,8,3,10,3,12,3,843,9,3,1, + 3,1,3,1,3,1,3,1,3,1,3,3,3,851,8,3,1,3,3,3,854,8,3,1,3,3,3,857,8, + 3,1,3,5,3,860,8,3,10,3,12,3,863,9,3,1,3,1,3,1,3,1,3,1,3,1,3,5,3, + 871,8,3,10,3,12,3,874,9,3,1,3,1,3,1,3,1,3,3,3,880,8,3,1,3,1,3,1, + 3,1,3,1,3,1,3,3,3,888,8,3,1,3,5,3,891,8,3,10,3,12,3,894,9,3,3,3, + 896,8,3,1,4,1,4,1,4,3,4,901,8,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4, + 5,4,911,8,4,10,4,12,4,914,9,4,1,4,1,4,3,4,918,8,4,1,4,3,4,921,8, + 4,1,4,1,4,3,4,925,8,4,1,4,1,4,1,4,1,4,1,4,3,4,932,8,4,1,4,3,4,935, + 8,4,1,4,1,4,3,4,939,8,4,1,4,3,4,942,8,4,1,4,1,4,3,4,946,8,4,1,4, + 1,4,1,4,1,4,1,4,1,4,1,4,3,4,955,8,4,1,4,3,4,958,8,4,1,4,1,4,3,4, + 962,8,4,1,4,3,4,965,8,4,1,4,1,4,1,4,3,4,970,8,4,1,4,1,4,1,4,1,4, + 1,4,1,4,1,4,1,4,1,4,1,4,1,4,5,4,983,8,4,10,4,12,4,986,9,4,1,4,1, + 4,1,4,3,4,991,8,4,1,4,3,4,994,8,4,1,4,3,4,997,8,4,1,4,1,4,3,4,1001, + 8,4,1,4,1,4,3,4,1005,8,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,5,4,1014,8, + 4,10,4,12,4,1017,9,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,1025,8,4,1,4,3, + 4,1028,8,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,1037,8,4,1,4,1,4,1,4, + 3,4,1042,8,4,1,4,1,4,1,4,3,4,1047,8,4,1,4,3,4,1050,8,4,1,4,1,4,3, + 4,1054,8,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,5,4,1067, + 8,4,10,4,12,4,1070,9,4,3,4,1072,8,4,1,4,1,4,1,4,3,4,1077,8,4,1,4, + 1,4,1,4,3,4,1082,8,4,1,4,1,4,1,4,3,4,1087,8,4,1,4,1,4,1,4,1,4,1, + 4,3,4,1094,8,4,1,4,1,4,1,4,1,4,1,4,3,4,1101,8,4,1,4,5,4,1104,8,4, + 10,4,12,4,1107,9,4,3,4,1109,8,4,1,5,1,5,1,5,3,5,1114,8,5,1,5,1,5, + 3,5,1118,8,5,1,5,1,5,1,5,3,5,1123,8,5,1,5,1,5,3,5,1127,8,5,1,5,1, + 5,1,5,3,5,1132,8,5,1,5,1,5,1,5,3,5,1137,8,5,1,5,1,5,3,5,1141,8,5, + 1,5,1,5,1,5,1,5,1,5,3,5,1148,8,5,1,5,1,5,1,5,3,5,1153,8,5,1,5,1, + 5,1,5,3,5,1158,8,5,1,5,1,5,1,5,3,5,1163,8,5,1,5,1,5,1,5,1,5,1,5, + 3,5,1170,8,5,1,5,5,5,1173,8,5,10,5,12,5,1176,9,5,3,5,1178,8,5,1, + 6,1,6,1,6,1,6,1,6,1,6,1,6,4,6,1187,8,6,11,6,12,6,1188,1,6,1,6,1, + 6,1,6,1,6,3,6,1196,8,6,1,6,1,6,1,6,1,6,1,6,3,6,1203,8,6,1,6,1,6, + 1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,1215,8,6,1,6,1,6,1,6,1,6,5,6, + 1221,8,6,10,6,12,6,1224,9,6,1,6,5,6,1227,8,6,10,6,12,6,1230,9,6, + 1,6,5,6,1233,8,6,10,6,12,6,1236,9,6,3,6,1238,8,6,1,7,1,7,1,7,3,7, + 1243,8,7,1,7,1,7,3,7,1247,8,7,1,7,3,7,1250,8,7,1,7,1,7,1,7,1,7,1, + 7,1,7,3,7,1258,8,7,1,7,1,7,1,7,3,7,1263,8,7,1,7,1,7,1,7,1,7,1,7, + 1,7,1,7,3,7,1272,8,7,1,7,1,7,1,7,3,7,1277,8,7,3,7,1279,8,7,1,7,1, + 7,1,7,1,7,1,7,1,7,3,7,1287,8,7,1,7,1,7,1,7,3,7,1292,8,7,1,7,1,7, + 3,7,1296,8,7,1,7,3,7,1299,8,7,1,7,3,7,1302,8,7,1,7,3,7,1305,8,7, + 1,7,1,7,3,7,1309,8,7,3,7,1311,8,7,1,8,1,8,1,8,1,8,3,8,1317,8,8,1, + 8,3,8,1320,8,8,1,8,3,8,1323,8,8,1,8,1,8,1,8,1,8,3,8,1329,8,8,1,8, + 3,8,1332,8,8,1,8,3,8,1335,8,8,1,8,1,8,1,8,1,8,1,8,3,8,1342,8,8,1, + 8,1,8,1,8,3,8,1347,8,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,3,8,1356,8,8, + 1,8,1,8,1,8,1,8,1,8,1,8,3,8,1364,8,8,1,8,1,8,1,8,1,8,3,8,1370,8, + 8,1,8,3,8,1373,8,8,1,8,3,8,1376,8,8,1,8,1,8,1,8,1,8,3,8,1382,8,8, + 1,8,1,8,3,8,1386,8,8,1,8,1,8,1,8,3,8,1391,8,8,1,8,3,8,1394,8,8,1, + 8,1,8,3,8,1398,8,8,3,8,1400,8,8,1,8,1,8,1,8,1,8,1,8,1,8,3,8,1408, + 8,8,1,8,1,8,1,8,1,8,1,8,1,8,3,8,1416,8,8,1,8,3,8,1419,8,8,1,8,1, + 8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,3,8,1431,8,8,1,8,1,8,1,8,1,8,3, + 8,1437,8,8,1,8,5,8,1440,8,8,10,8,12,8,1443,9,8,3,8,1445,8,8,1,9, + 1,9,3,9,1449,8,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,3,9,1460,8, + 9,1,10,1,10,1,10,1,10,1,10,1,10,3,10,1468,8,10,1,10,1,10,1,10,1, + 10,1,11,1,11,1,11,1,11,1,11,1,11,3,11,1480,8,11,1,11,1,11,1,11,3, + 11,1485,8,11,1,12,3,12,1488,8,12,1,12,1,12,1,12,1,13,1,13,1,13,3, + 13,1496,8,13,1,14,1,14,1,14,1,14,1,14,5,14,1503,8,14,10,14,12,14, + 1506,9,14,1,14,1,14,1,15,1,15,1,15,3,15,1513,8,15,1,15,1,15,1,15, + 1,15,3,15,1519,8,15,1,16,1,16,1,17,1,17,1,17,1,17,1,17,3,17,1528, + 8,17,1,18,1,18,1,18,5,18,1533,8,18,10,18,12,18,1536,9,18,1,19,1, + 19,1,19,1,19,5,19,1542,8,19,10,19,12,19,1545,9,19,1,20,1,20,3,20, + 1549,8,20,1,20,3,20,1552,8,20,1,20,1,20,1,20,1,20,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,22,1,22,1,22, + 1,22,1,22,1,22,5,22,1577,8,22,10,22,12,22,1580,9,22,1,23,1,23,1, + 23,1,24,1,24,1,24,1,24,5,24,1589,8,24,10,24,12,24,1592,9,24,1,24, + 1,24,1,25,1,25,3,25,1598,8,25,1,25,3,25,1601,8,25,1,26,1,26,1,26, + 5,26,1606,8,26,10,26,12,26,1609,9,26,1,26,3,26,1612,8,26,1,27,1, + 27,1,27,1,27,3,27,1618,8,27,1,28,1,28,1,28,1,28,5,28,1624,8,28,10, + 28,12,28,1627,9,28,1,28,1,28,1,29,1,29,3,29,1633,8,29,1,29,3,29, + 1636,8,29,1,30,1,30,1,30,1,30,5,30,1642,8,30,10,30,12,30,1645,9, + 30,1,30,1,30,1,31,1,31,1,31,1,31,5,31,1653,8,31,10,31,12,31,1656, + 9,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,32,3,32,1666,8,32,1,33, + 1,33,1,33,1,33,1,33,1,33,3,33,1674,8,33,1,34,1,34,1,34,1,34,3,34, + 1680,8,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,3,41,1696,8,41,1,42,1,42,1,42,5,42,1701,8,42,10,42, + 12,42,1704,9,42,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,3,44,1714, + 8,44,1,45,1,45,1,45,1,45,1,45,5,45,1721,8,45,10,45,12,45,1724,9, + 45,3,45,1726,8,45,1,45,1,45,1,45,1,45,1,45,5,45,1733,8,45,10,45, + 12,45,1736,9,45,3,45,1738,8,45,1,45,1,45,1,45,1,45,1,45,5,45,1745, + 8,45,10,45,12,45,1748,9,45,3,45,1750,8,45,1,45,1,45,1,45,1,45,1, + 45,5,45,1757,8,45,10,45,12,45,1760,9,45,3,45,1762,8,45,1,45,3,45, + 1765,8,45,1,45,1,45,1,45,3,45,1770,8,45,3,45,1772,8,45,1,45,1,45, + 3,45,1776,8,45,1,46,1,46,1,46,1,46,1,46,1,46,3,46,1784,8,46,1,46, + 1,46,1,46,1,46,3,46,1790,8,46,1,46,1,46,1,46,1,46,3,46,1796,8,46, + 1,46,5,46,1799,8,46,10,46,12,46,1802,9,46,1,47,1,47,1,47,4,47,1807, + 8,47,11,47,12,47,1808,1,47,1,47,1,47,1,47,1,47,1,47,5,47,1817,8, + 47,10,47,12,47,1820,9,47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,1828, + 8,47,1,48,1,48,3,48,1832,8,48,1,48,3,48,1835,8,48,1,48,1,48,3,48, + 1839,8,48,1,49,1,49,3,49,1843,8,49,1,49,1,49,1,49,1,49,5,49,1849, + 8,49,10,49,12,49,1852,9,49,1,49,3,49,1855,8,49,1,49,3,49,1858,8, + 49,1,49,3,49,1861,8,49,1,49,3,49,1864,8,49,1,49,1,49,3,49,1868,8, + 49,1,50,1,50,3,50,1872,8,50,1,50,5,50,1875,8,50,10,50,12,50,1878, + 9,50,1,50,3,50,1881,8,50,1,50,3,50,1884,8,50,1,50,3,50,1887,8,50, + 1,50,3,50,1890,8,50,1,50,1,50,3,50,1894,8,50,1,50,5,50,1897,8,50, + 10,50,12,50,1900,9,50,1,50,3,50,1903,8,50,1,50,3,50,1906,8,50,1, + 50,3,50,1909,8,50,1,50,3,50,1912,8,50,3,50,1914,8,50,1,51,1,51,1, + 51,1,51,3,51,1920,8,51,1,51,1,51,1,51,1,51,1,51,3,51,1927,8,51,1, + 51,1,51,1,51,3,51,1932,8,51,1,51,3,51,1935,8,51,1,51,3,51,1938,8, + 51,1,51,1,51,3,51,1942,8,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1, + 51,3,51,1952,8,51,1,51,1,51,3,51,1956,8,51,3,51,1958,8,51,1,51,3, + 51,1961,8,51,1,51,1,51,3,51,1965,8,51,1,52,1,52,5,52,1969,8,52,10, + 52,12,52,1972,9,52,1,52,3,52,1975,8,52,1,52,1,52,1,53,1,53,1,53, + 1,54,1,54,1,54,1,54,3,54,1986,8,54,1,54,1,54,1,54,1,54,1,54,1,54, + 3,54,1994,8,54,3,54,1996,8,54,1,55,1,55,1,55,1,55,1,55,3,55,2003, + 8,55,1,55,1,55,3,55,2007,8,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56, + 1,56,1,56,1,56,3,56,2019,8,56,1,56,1,56,1,56,1,56,1,56,3,56,2026, + 8,56,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,5,57, + 2039,8,57,10,57,12,57,2042,9,57,1,57,1,57,3,57,2046,8,57,1,58,1, + 58,1,58,5,58,2051,8,58,10,58,12,58,2054,9,58,1,59,1,59,1,59,1,59, + 1,60,1,60,1,60,1,61,1,61,1,61,1,62,1,62,1,62,3,62,2069,8,62,1,62, + 5,62,2072,8,62,10,62,12,62,2075,9,62,1,62,1,62,1,63,1,63,1,63,1, + 63,1,63,1,63,5,63,2085,8,63,10,63,12,63,2088,9,63,1,63,1,63,3,63, + 2092,8,63,1,64,1,64,1,64,1,64,5,64,2098,8,64,10,64,12,64,2101,9, + 64,1,64,5,64,2104,8,64,10,64,12,64,2107,9,64,1,64,3,64,2110,8,64, + 1,64,3,64,2113,8,64,1,65,3,65,2116,8,65,1,65,1,65,1,65,1,65,1,65, + 3,65,2123,8,65,1,65,3,65,2126,8,65,1,65,1,65,1,65,1,65,3,65,2132, + 8,65,1,66,1,66,1,66,1,66,1,66,5,66,2139,8,66,10,66,12,66,2142,9, + 66,1,66,1,66,1,66,1,66,1,66,5,66,2149,8,66,10,66,12,66,2152,9,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,5,66,2164,8,66, + 10,66,12,66,2167,9,66,1,66,1,66,3,66,2171,8,66,3,66,2173,8,66,1, + 67,1,67,1,67,3,67,2178,8,67,1,68,1,68,1,68,1,68,1,68,5,68,2185,8, + 68,10,68,12,68,2188,9,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68, + 2197,8,68,1,68,1,68,1,68,3,68,2202,8,68,5,68,2204,8,68,10,68,12, + 68,2207,9,68,1,68,1,68,3,68,2211,8,68,1,69,1,69,1,69,1,69,1,69,3, + 69,2218,8,69,1,69,1,69,1,69,3,69,2223,8,69,5,69,2225,8,69,10,69, + 12,69,2228,9,69,3,69,2230,8,69,1,69,3,69,2233,8,69,1,70,1,70,1,70, + 1,70,1,70,1,70,1,70,1,70,1,70,1,70,5,70,2245,8,70,10,70,12,70,2248, + 9,70,1,70,1,70,1,70,1,71,1,71,1,71,1,71,1,71,5,71,2258,8,71,10,71, + 12,71,2261,9,71,1,71,1,71,3,71,2265,8,71,1,72,1,72,3,72,2269,8,72, + 1,72,3,72,2272,8,72,1,73,1,73,1,73,3,73,2277,8,73,1,73,1,73,1,73, + 3,73,2282,8,73,1,73,1,73,3,73,2286,8,73,1,73,3,73,2289,8,73,1,74, + 1,74,1,74,1,74,1,74,1,74,1,74,1,74,5,74,2299,8,74,10,74,12,74,2302, + 9,74,1,74,1,74,1,75,1,75,1,75,1,75,5,75,2310,8,75,10,75,12,75,2313, + 9,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,5,75,2323,8,75,10,75, + 12,75,2326,9,75,1,75,1,75,1,76,1,76,1,76,1,76,5,76,2334,8,76,10, + 76,12,76,2337,9,76,1,76,1,76,3,76,2341,8,76,1,76,3,76,2344,8,76, + 1,77,1,77,3,77,2348,8,77,1,77,3,77,2351,8,77,1,78,1,78,1,78,1,78, + 1,79,1,79,1,79,1,80,1,80,1,80,3,80,2363,8,80,1,80,1,80,1,80,1,80, + 1,80,5,80,2370,8,80,10,80,12,80,2373,9,80,3,80,2375,8,80,1,80,1, + 80,1,80,3,80,2380,8,80,1,80,1,80,1,80,5,80,2385,8,80,10,80,12,80, + 2388,9,80,3,80,2390,8,80,1,81,1,81,1,82,1,82,3,82,2396,8,82,1,82, + 1,82,1,82,1,82,5,82,2402,8,82,10,82,12,82,2405,9,82,3,82,2407,8, + 82,1,83,1,83,1,83,3,83,2412,8,83,1,83,1,83,3,83,2416,8,83,1,83,1, + 83,1,83,1,83,3,83,2422,8,83,1,83,1,83,3,83,2426,8,83,1,84,3,84,2429, + 8,84,1,84,1,84,1,84,3,84,2434,8,84,1,84,3,84,2437,8,84,1,84,1,84, + 1,84,3,84,2442,8,84,3,84,2444,8,84,1,85,1,85,1,85,1,85,3,85,2450, + 8,85,1,86,1,86,1,86,3,86,2455,8,86,1,86,1,86,1,86,1,86,1,86,3,86, + 2462,8,86,1,87,3,87,2465,8,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87, + 1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,3,87,2483,8,87,3,87, + 2485,8,87,1,87,3,87,2488,8,87,1,88,1,88,1,88,1,88,1,89,1,89,1,89, + 5,89,2497,8,89,10,89,12,89,2500,9,89,1,90,1,90,1,90,1,90,5,90,2506, + 8,90,10,90,12,90,2509,9,90,1,90,1,90,1,91,1,91,3,91,2515,8,91,1, + 92,1,92,1,92,1,92,5,92,2521,8,92,10,92,12,92,2524,9,92,1,92,1,92, + 1,93,1,93,1,93,3,93,2531,8,93,1,94,1,94,1,94,3,94,2536,8,94,1,94, + 3,94,2539,8,94,1,94,3,94,2542,8,94,1,94,1,94,1,94,1,94,1,94,1,94, + 3,94,2550,8,94,1,94,1,94,1,94,1,94,1,94,1,94,3,94,2558,8,94,1,94, + 1,94,1,94,1,94,1,94,1,94,5,94,2566,8,94,10,94,12,94,2569,9,94,1, + 94,1,94,1,94,1,94,1,94,1,94,1,94,5,94,2578,8,94,10,94,12,94,2581, + 9,94,3,94,2583,8,94,1,94,1,94,1,94,3,94,2588,8,94,1,95,1,95,1,95, + 3,95,2593,8,95,1,95,1,95,1,95,1,95,1,95,3,95,2600,8,95,1,95,1,95, + 1,95,1,95,1,95,3,95,2607,8,95,3,95,2609,8,95,1,96,1,96,1,96,1,96, + 1,96,1,96,1,96,1,96,1,96,5,96,2620,8,96,10,96,12,96,2623,9,96,1, + 96,1,96,1,96,3,96,2628,8,96,3,96,2630,8,96,1,96,1,96,1,96,1,96,1, + 96,1,96,5,96,2638,8,96,10,96,12,96,2641,9,96,1,96,1,96,1,96,3,96, + 2646,8,96,3,96,2648,8,96,1,97,1,97,1,97,1,97,1,98,1,98,3,98,2656, + 8,98,1,99,1,99,3,99,2660,8,99,1,100,3,100,2663,8,100,1,100,1,100, + 3,100,2667,8,100,3,100,2669,8,100,1,101,1,101,1,101,1,101,1,101, + 1,101,1,101,3,101,2678,8,101,1,101,1,101,1,101,1,101,1,101,1,101, + 1,101,1,101,1,101,1,101,3,101,2690,8,101,3,101,2692,8,101,1,101, + 1,101,1,101,1,101,1,101,3,101,2699,8,101,1,101,1,101,1,101,1,101, + 1,101,3,101,2706,8,101,1,101,1,101,1,101,1,101,3,101,2712,8,101, + 1,101,1,101,1,101,1,101,3,101,2718,8,101,3,101,2720,8,101,1,102, + 1,102,1,102,5,102,2725,8,102,10,102,12,102,2728,9,102,1,103,1,103, + 1,103,5,103,2733,8,103,10,103,12,103,2736,9,103,1,104,1,104,1,104, + 5,104,2741,8,104,10,104,12,104,2744,9,104,1,105,1,105,1,105,3,105, + 2749,8,105,1,106,1,106,1,106,3,106,2754,8,106,1,106,1,106,1,107, + 1,107,1,107,3,107,2761,8,107,1,107,1,107,1,108,1,108,3,108,2767, + 8,108,1,108,3,108,2770,8,108,1,108,1,108,3,108,2774,8,108,3,108, + 2776,8,108,1,109,1,109,1,109,5,109,2781,8,109,10,109,12,109,2784, + 9,109,1,110,1,110,1,110,1,110,5,110,2790,8,110,10,110,12,110,2793, + 9,110,1,110,1,110,1,111,1,111,3,111,2799,8,111,1,112,1,112,1,112, + 1,112,1,112,1,112,5,112,2807,8,112,10,112,12,112,2810,9,112,1,112, + 1,112,3,112,2814,8,112,1,113,1,113,3,113,2818,8,113,1,114,1,114, + 1,115,1,115,1,115,1,115,1,116,1,116,3,116,2828,8,116,1,117,1,117, + 1,117,5,117,2833,8,117,10,117,12,117,2836,9,117,1,118,1,118,1,118, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,3,118,2848,8,118,3,118, + 2850,8,118,1,118,1,118,1,118,1,118,1,118,1,118,5,118,2858,8,118, + 10,118,12,118,2861,9,118,1,119,3,119,2864,8,119,1,119,1,119,1,119, + 1,119,1,119,1,119,3,119,2872,8,119,1,119,1,119,1,119,1,119,1,119, + 5,119,2879,8,119,10,119,12,119,2882,9,119,1,119,1,119,1,119,3,119, + 2887,8,119,1,119,1,119,1,119,1,119,1,119,1,119,3,119,2895,8,119, + 1,119,1,119,1,119,3,119,2900,8,119,1,119,1,119,1,119,1,119,1,119, + 1,119,1,119,1,119,5,119,2910,8,119,10,119,12,119,2913,9,119,1,119, + 1,119,3,119,2917,8,119,1,119,3,119,2920,8,119,1,119,1,119,1,119, + 1,119,3,119,2926,8,119,1,119,1,119,3,119,2930,8,119,1,119,1,119, + 1,119,3,119,2935,8,119,1,119,1,119,1,119,3,119,2940,8,119,1,119, + 1,119,1,119,3,119,2945,8,119,1,120,1,120,1,120,1,120,3,120,2951, + 8,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,5,120,2972, + 8,120,10,120,12,120,2975,9,120,1,121,1,121,1,122,1,122,1,122,1,122, + 1,122,1,122,3,122,2985,8,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,3,122,2997,8,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,4,122,3007,8,122,11,122,12,122,3008,1,122, + 1,122,3,122,3013,8,122,1,122,1,122,1,122,1,122,1,122,4,122,3020, + 8,122,11,122,12,122,3021,1,122,1,122,3,122,3026,8,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,5,122,3042,8,122,10,122,12,122,3045,9,122,3,122,3047,8,122, + 1,122,1,122,1,122,1,122,1,122,1,122,3,122,3055,8,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,3,122,3064,8,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,3,122,3073,8,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,4,122,3094,8,122,11,122,12,122,3095,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,3,122,3112,8,122,1,122,1,122,1,122,5,122,3117,8,122, + 10,122,12,122,3120,9,122,3,122,3122,8,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,3,122,3131,8,122,1,122,1,122,3,122,3135,8,122, + 1,122,1,122,3,122,3139,8,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,4,122,3149,8,122,11,122,12,122,3150,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,3176, + 8,122,1,122,1,122,1,122,1,122,1,122,3,122,3183,8,122,1,122,3,122, + 3186,8,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,3,122,3201,8,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,3,122,3222,8,122,1,122,1,122,3,122,3226, + 8,122,3,122,3228,8,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,5,122,3238,8,122,10,122,12,122,3241,9,122,1,123,1,123,1,123, + 1,123,1,123,1,123,1,123,3,123,3250,8,123,1,124,1,124,1,124,1,124, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,4,124,3263,8,124,11,124, + 12,124,3264,3,124,3267,8,124,1,125,1,125,1,126,1,126,1,127,1,127, + 1,128,1,128,1,129,1,129,1,129,3,129,3280,8,129,1,130,1,130,3,130, + 3284,8,130,1,131,1,131,1,131,3,131,3289,8,131,1,132,1,132,1,132, + 4,132,3294,8,132,11,132,12,132,3295,1,133,1,133,1,133,1,133,1,133, + 1,134,3,134,3304,8,134,1,134,1,134,1,134,3,134,3309,8,134,1,135, + 1,135,1,136,1,136,1,137,1,137,1,137,3,137,3318,8,137,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,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,3350,8,138,1,139,1,139, + 1,139,1,139,1,139,1,139,1,139,1,139,1,139,1,139,1,139,1,139,1,139, + 1,139,1,139,1,139,1,139,5,139,3369,8,139,10,139,12,139,3372,9,139, + 3,139,3374,8,139,1,139,1,139,3,139,3378,8,139,1,139,1,139,1,139, + 1,139,3,139,3384,8,139,1,139,1,139,1,139,1,139,3,139,3390,8,139, + 1,139,1,139,1,139,1,139,1,139,5,139,3397,8,139,10,139,12,139,3400, + 9,139,1,139,3,139,3403,8,139,3,139,3405,8,139,1,140,1,140,1,140, + 5,140,3410,8,140,10,140,12,140,3413,9,140,1,141,1,141,1,141,5,141, + 3418,8,141,10,141,12,141,3421,9,141,1,142,1,142,1,142,5,142,3426, + 8,142,10,142,12,142,3429,9,142,1,143,1,143,1,143,5,143,3434,8,143, + 10,143,12,143,3437,9,143,1,144,1,144,1,144,1,144,1,144,1,144,1,144, + 3,144,3446,8,144,1,145,1,145,1,145,1,146,1,146,1,146,5,146,3454, + 8,146,10,146,12,146,3457,9,146,1,147,1,147,1,147,1,147,3,147,3463, + 8,147,1,147,1,147,3,147,3467,8,147,1,148,1,148,1,148,5,148,3472, + 8,148,10,148,12,148,3475,9,148,1,149,1,149,1,149,5,149,3480,8,149, + 10,149,12,149,3483,9,149,1,150,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,150,1,150,1,150,1,150,1,150,3,150,3498,8,150,1,151,1,151, + 3,151,3502,8,151,1,151,1,151,1,151,3,151,3507,8,151,1,151,1,151, + 3,151,3511,8,151,1,152,1,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,5,153,3527,8,153,10,153,12,153, + 3530,9,153,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,5,154,3543,8,154,10,154,12,154,3546,9,154,1,154,1,154, + 1,154,1,154,1,154,5,154,3553,8,154,10,154,12,154,3556,9,154,3,154, + 3558,8,154,1,154,1,154,1,154,1,154,1,154,5,154,3565,8,154,10,154, + 12,154,3568,9,154,3,154,3570,8,154,3,154,3572,8,154,1,154,3,154, + 3575,8,154,1,154,3,154,3578,8,154,1,155,1,155,1,155,1,155,1,155, + 1,155,1,155,1,155,3,155,3588,8,155,1,156,1,156,1,156,1,156,1,156, + 1,156,1,156,3,156,3597,8,156,1,157,1,157,1,157,5,157,3602,8,157, + 10,157,12,157,3605,9,157,1,158,1,158,1,158,1,158,1,158,1,158,1,158, + 1,158,1,158,3,158,3616,8,158,1,159,1,159,1,160,1,160,1,160,5,160, + 3623,8,160,10,160,12,160,3626,9,160,1,161,1,161,1,161,1,162,1,162, + 4,162,3633,8,162,11,162,12,162,3634,1,162,3,162,3638,8,162,1,163, + 1,163,3,163,3642,8,163,1,164,1,164,1,164,1,164,1,164,3,164,3649, + 8,164,1,165,3,165,3652,8,165,1,165,1,165,1,166,1,166,1,166,1,166, + 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,3,166,3669, + 8,166,1,167,1,167,1,168,1,168,1,169,1,169,1,170,1,170,1,170,13,478, + 538,545,552,568,828,841,861,872,892,1105,1174,1441,4,92,236,240, + 244,171,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,0,75,2,0, + 123,123,140,140,5,0,46,46,58,58,108,108,122,122,173,173,1,0,86,87, + 2,0,108,108,122,122,3,0,8,8,96,96,288,288,2,0,8,8,167,167,2,0,78, + 78,228,228,1,0,49,50,2,0,268,268,327,327,2,0,11,11,39,39,2,0,8,8, + 96,96,3,0,45,45,274,274,309,309,2,0,196,196,268,268,4,0,45,45,274, + 274,278,278,282,282,3,0,18,18,103,103,319,319,2,0,34,34,246,246, + 3,0,142,142,252,252,297,297,3,0,73,73,190,190,261,261,3,0,10,10, + 289,289,330,330,2,0,129,129,248,248,4,0,107,107,139,139,171,171, + 325,325,2,0,171,171,325,325,3,0,72,72,189,189,260,260,4,0,102,102, + 148,148,269,269,322,322,3,0,102,102,269,269,322,322,2,0,21,21,86, + 86,2,0,116,116,157,157,2,0,291,291,336,336,2,0,290,290,302,302,2, + 0,61,61,255,255,2,0,104,104,141,141,2,0,10,10,92,92,2,0,15,15,263, + 263,2,0,124,124,249,249,2,0,381,381,383,383,2,0,93,93,216,216,2, + 0,208,208,277,277,2,0,196,196,359,359,1,0,250,251,1,0,163,164,3, + 0,10,10,16,16,276,276,3,0,111,111,315,315,324,324,2,0,360,361,365, + 365,2,0,94,94,362,364,2,0,360,361,368,368,11,0,67,67,69,69,134,134, + 179,179,181,181,183,183,185,185,230,230,258,258,340,340,347,347, + 4,0,63,63,65,66,267,267,330,330,2,0,74,75,305,305,3,0,76,77,301, + 301,306,306,2,0,36,36,317,317,2,0,138,138,245,245,1,0,286,287,2, + 0,4,4,123,123,2,0,4,4,119,119,3,0,28,28,160,160,310,310,1,0,219, + 220,1,0,351,358,2,0,94,94,360,369,4,0,14,14,140,140,196,196,207, + 207,2,0,111,111,315,315,1,0,360,361,7,0,67,68,134,135,179,186,191, + 192,258,259,340,341,347,348,6,0,67,67,134,134,183,183,185,185,258, + 258,347,347,2,0,185,185,347,347,4,0,67,67,134,134,183,183,258,258, + 3,0,134,134,183,183,258,258,2,0,82,82,351,351,2,0,232,232,257,257, + 2,0,118,118,225,225,1,0,378,386,2,0,96,96,268,268,1,0,376,377,52, + 0,8,9,11,13,15,15,17,19,21,22,24,27,29,34,37,41,43,46,48,48,50,56, + 58,58,61,62,67,91,93,96,98,98,101,101,103,110,113,113,115,118,121, + 122,125,128,131,131,133,139,141,143,145,147,149,151,154,154,156, + 157,159,159,163,192,194,194,198,200,204,206,209,209,211,212,214, + 218,221,225,227,237,239,248,250,261,263,266,268,275,277,291,293, + 298,301,307,309,309,311,321,325,329,332,341,344,344,347,350,16,0, + 15,15,60,60,102,102,124,124,144,144,148,148,155,155,158,158,161, + 161,193,193,202,202,249,249,263,263,269,269,322,322,331,331,19,0, + 8,14,16,59,61,101,103,122,125,143,145,147,149,154,156,157,159,160, + 162,192,194,194,196,201,203,248,250,261,264,268,270,291,293,321, + 323,330,332,350,4271,0,345,1,0,0,0,2,350,1,0,0,0,4,571,1,0,0,0,6, + 895,1,0,0,0,8,1108,1,0,0,0,10,1177,1,0,0,0,12,1237,1,0,0,0,14,1310, + 1,0,0,0,16,1444,1,0,0,0,18,1459,1,0,0,0,20,1461,1,0,0,0,22,1473, + 1,0,0,0,24,1487,1,0,0,0,26,1492,1,0,0,0,28,1497,1,0,0,0,30,1518, + 1,0,0,0,32,1520,1,0,0,0,34,1527,1,0,0,0,36,1529,1,0,0,0,38,1537, + 1,0,0,0,40,1546,1,0,0,0,42,1557,1,0,0,0,44,1578,1,0,0,0,46,1581, + 1,0,0,0,48,1584,1,0,0,0,50,1595,1,0,0,0,52,1611,1,0,0,0,54,1617, + 1,0,0,0,56,1619,1,0,0,0,58,1630,1,0,0,0,60,1637,1,0,0,0,62,1648, + 1,0,0,0,64,1665,1,0,0,0,66,1673,1,0,0,0,68,1675,1,0,0,0,70,1681, + 1,0,0,0,72,1683,1,0,0,0,74,1685,1,0,0,0,76,1687,1,0,0,0,78,1689, + 1,0,0,0,80,1691,1,0,0,0,82,1695,1,0,0,0,84,1697,1,0,0,0,86,1705, + 1,0,0,0,88,1713,1,0,0,0,90,1725,1,0,0,0,92,1777,1,0,0,0,94,1827, + 1,0,0,0,96,1831,1,0,0,0,98,1867,1,0,0,0,100,1913,1,0,0,0,102,1934, + 1,0,0,0,104,1966,1,0,0,0,106,1978,1,0,0,0,108,1981,1,0,0,0,110,1997, + 1,0,0,0,112,2011,1,0,0,0,114,2045,1,0,0,0,116,2047,1,0,0,0,118,2055, + 1,0,0,0,120,2059,1,0,0,0,122,2062,1,0,0,0,124,2065,1,0,0,0,126,2091, + 1,0,0,0,128,2093,1,0,0,0,130,2131,1,0,0,0,132,2172,1,0,0,0,134,2177, + 1,0,0,0,136,2210,1,0,0,0,138,2232,1,0,0,0,140,2234,1,0,0,0,142,2264, + 1,0,0,0,144,2266,1,0,0,0,146,2273,1,0,0,0,148,2290,1,0,0,0,150,2305, + 1,0,0,0,152,2329,1,0,0,0,154,2345,1,0,0,0,156,2352,1,0,0,0,158,2356, + 1,0,0,0,160,2359,1,0,0,0,162,2391,1,0,0,0,164,2406,1,0,0,0,166,2425, + 1,0,0,0,168,2443,1,0,0,0,170,2449,1,0,0,0,172,2451,1,0,0,0,174,2487, + 1,0,0,0,176,2489,1,0,0,0,178,2493,1,0,0,0,180,2501,1,0,0,0,182,2512, + 1,0,0,0,184,2516,1,0,0,0,186,2527,1,0,0,0,188,2587,1,0,0,0,190,2608, + 1,0,0,0,192,2629,1,0,0,0,194,2649,1,0,0,0,196,2655,1,0,0,0,198,2659, + 1,0,0,0,200,2668,1,0,0,0,202,2719,1,0,0,0,204,2721,1,0,0,0,206,2729, + 1,0,0,0,208,2737,1,0,0,0,210,2745,1,0,0,0,212,2753,1,0,0,0,214,2760, + 1,0,0,0,216,2766,1,0,0,0,218,2777,1,0,0,0,220,2785,1,0,0,0,222,2798, + 1,0,0,0,224,2813,1,0,0,0,226,2817,1,0,0,0,228,2819,1,0,0,0,230,2821, + 1,0,0,0,232,2827,1,0,0,0,234,2829,1,0,0,0,236,2849,1,0,0,0,238,2944, + 1,0,0,0,240,2950,1,0,0,0,242,2976,1,0,0,0,244,3227,1,0,0,0,246,3249, + 1,0,0,0,248,3266,1,0,0,0,250,3268,1,0,0,0,252,3270,1,0,0,0,254,3272, + 1,0,0,0,256,3274,1,0,0,0,258,3276,1,0,0,0,260,3281,1,0,0,0,262,3285, + 1,0,0,0,264,3293,1,0,0,0,266,3297,1,0,0,0,268,3303,1,0,0,0,270,3310, + 1,0,0,0,272,3312,1,0,0,0,274,3317,1,0,0,0,276,3349,1,0,0,0,278,3404, + 1,0,0,0,280,3406,1,0,0,0,282,3414,1,0,0,0,284,3422,1,0,0,0,286,3430, + 1,0,0,0,288,3445,1,0,0,0,290,3447,1,0,0,0,292,3450,1,0,0,0,294,3458, + 1,0,0,0,296,3468,1,0,0,0,298,3476,1,0,0,0,300,3497,1,0,0,0,302,3499, + 1,0,0,0,304,3512,1,0,0,0,306,3517,1,0,0,0,308,3577,1,0,0,0,310,3587, + 1,0,0,0,312,3596,1,0,0,0,314,3598,1,0,0,0,316,3615,1,0,0,0,318,3617, + 1,0,0,0,320,3619,1,0,0,0,322,3627,1,0,0,0,324,3637,1,0,0,0,326,3641, + 1,0,0,0,328,3648,1,0,0,0,330,3651,1,0,0,0,332,3668,1,0,0,0,334,3670, + 1,0,0,0,336,3672,1,0,0,0,338,3674,1,0,0,0,340,3676,1,0,0,0,342,344, + 3,2,1,0,343,342,1,0,0,0,344,347,1,0,0,0,345,343,1,0,0,0,345,346, + 1,0,0,0,346,348,1,0,0,0,347,345,1,0,0,0,348,349,5,0,0,1,349,1,1, + 0,0,0,350,352,3,4,2,0,351,353,5,1,0,0,352,351,1,0,0,0,352,353,1, + 0,0,0,353,3,1,0,0,0,354,572,3,24,12,0,355,357,3,38,19,0,356,355, + 1,0,0,0,356,357,1,0,0,0,357,358,1,0,0,0,358,572,3,12,6,0,359,361, + 5,329,0,0,360,362,3,32,16,0,361,360,1,0,0,0,361,362,1,0,0,0,362, + 363,1,0,0,0,363,572,3,70,35,0,364,572,3,6,3,0,365,572,3,8,4,0,366, + 572,3,10,5,0,367,572,3,16,8,0,368,369,5,316,0,0,369,370,5,292,0, + 0,370,372,3,76,38,0,371,373,3,28,14,0,372,371,1,0,0,0,372,373,1, + 0,0,0,373,572,1,0,0,0,374,375,5,13,0,0,375,376,5,292,0,0,376,378, + 3,76,38,0,377,379,3,28,14,0,378,377,1,0,0,0,378,379,1,0,0,0,379, + 380,1,0,0,0,380,381,5,55,0,0,381,389,5,281,0,0,382,390,5,195,0,0, + 383,384,5,119,0,0,384,385,5,50,0,0,385,390,3,84,42,0,386,387,5,119, + 0,0,387,388,5,10,0,0,388,390,5,50,0,0,389,382,1,0,0,0,389,383,1, + 0,0,0,389,386,1,0,0,0,389,390,1,0,0,0,390,572,1,0,0,0,391,392,5, + 13,0,0,392,395,5,293,0,0,393,394,7,0,0,0,394,396,3,70,35,0,395,393, + 1,0,0,0,395,396,1,0,0,0,396,397,1,0,0,0,397,398,5,55,0,0,398,400, + 5,281,0,0,399,401,5,195,0,0,400,399,1,0,0,0,400,401,1,0,0,0,401, + 572,1,0,0,0,402,405,5,81,0,0,403,404,5,207,0,0,404,406,5,243,0,0, + 405,403,1,0,0,0,405,406,1,0,0,0,406,408,1,0,0,0,407,409,5,335,0, + 0,408,407,1,0,0,0,408,409,1,0,0,0,409,410,1,0,0,0,410,412,3,316, + 158,0,411,413,3,278,139,0,412,411,1,0,0,0,412,413,1,0,0,0,413,415, + 1,0,0,0,414,416,3,290,145,0,415,414,1,0,0,0,415,416,1,0,0,0,416, + 572,1,0,0,0,417,419,5,106,0,0,418,420,7,1,0,0,419,418,1,0,0,0,419, + 420,1,0,0,0,420,421,1,0,0,0,421,572,3,4,2,0,422,423,7,2,0,0,423, + 425,5,125,0,0,424,426,5,108,0,0,425,424,1,0,0,0,425,426,1,0,0,0, + 426,427,1,0,0,0,427,572,3,34,17,0,428,429,7,2,0,0,429,431,5,72,0, + 0,430,432,5,108,0,0,431,430,1,0,0,0,431,432,1,0,0,0,432,433,1,0, + 0,0,433,572,3,70,35,0,434,436,7,2,0,0,435,437,5,231,0,0,436,435, + 1,0,0,0,436,437,1,0,0,0,437,438,1,0,0,0,438,572,3,24,12,0,439,441, + 7,2,0,0,440,442,5,292,0,0,441,440,1,0,0,0,441,442,1,0,0,0,442,444, + 1,0,0,0,443,445,7,3,0,0,444,443,1,0,0,0,444,445,1,0,0,0,445,446, + 1,0,0,0,446,448,3,76,38,0,447,449,3,28,14,0,448,447,1,0,0,0,448, + 449,1,0,0,0,449,451,1,0,0,0,450,452,3,36,18,0,451,450,1,0,0,0,451, + 452,1,0,0,0,452,572,1,0,0,0,453,454,5,51,0,0,454,460,5,202,0,0,455, + 456,3,32,16,0,456,457,3,70,35,0,457,461,1,0,0,0,458,459,5,292,0, + 0,459,461,3,76,38,0,460,455,1,0,0,0,460,458,1,0,0,0,461,462,1,0, + 0,0,462,465,5,153,0,0,463,466,3,334,167,0,464,466,5,197,0,0,465, + 463,1,0,0,0,465,464,1,0,0,0,466,572,1,0,0,0,467,468,5,239,0,0,468, + 469,5,292,0,0,469,572,3,76,38,0,470,471,5,239,0,0,471,472,5,125, + 0,0,472,572,3,316,158,0,473,481,5,239,0,0,474,482,3,334,167,0,475, + 477,9,0,0,0,476,475,1,0,0,0,477,480,1,0,0,0,478,479,1,0,0,0,478, + 476,1,0,0,0,479,482,1,0,0,0,480,478,1,0,0,0,481,474,1,0,0,0,481, + 478,1,0,0,0,482,572,1,0,0,0,483,485,5,33,0,0,484,486,5,159,0,0,485, + 484,1,0,0,0,485,486,1,0,0,0,486,487,1,0,0,0,487,488,5,292,0,0,488, + 491,3,76,38,0,489,490,5,206,0,0,490,492,3,48,24,0,491,489,1,0,0, + 0,491,492,1,0,0,0,492,497,1,0,0,0,493,495,5,20,0,0,494,493,1,0,0, + 0,494,495,1,0,0,0,495,496,1,0,0,0,496,498,3,24,12,0,497,494,1,0, + 0,0,497,498,1,0,0,0,498,572,1,0,0,0,499,500,5,321,0,0,500,502,5, + 292,0,0,501,503,3,158,79,0,502,501,1,0,0,0,502,503,1,0,0,0,503,504, + 1,0,0,0,504,572,3,76,38,0,505,506,5,43,0,0,506,572,5,33,0,0,507, + 508,5,168,0,0,508,510,5,70,0,0,509,511,5,169,0,0,510,509,1,0,0,0, + 510,511,1,0,0,0,511,512,1,0,0,0,512,513,5,145,0,0,513,515,3,334, + 167,0,514,516,5,215,0,0,515,514,1,0,0,0,515,516,1,0,0,0,516,517, + 1,0,0,0,517,518,5,152,0,0,518,519,5,292,0,0,519,521,3,76,38,0,520, + 522,3,28,14,0,521,520,1,0,0,0,521,522,1,0,0,0,522,572,1,0,0,0,523, + 525,5,187,0,0,524,523,1,0,0,0,524,525,1,0,0,0,525,526,1,0,0,0,526, + 527,5,241,0,0,527,528,5,292,0,0,528,531,3,76,38,0,529,530,7,4,0, + 0,530,532,5,218,0,0,531,529,1,0,0,0,531,532,1,0,0,0,532,572,1,0, + 0,0,533,534,7,5,0,0,534,538,3,326,163,0,535,537,9,0,0,0,536,535, + 1,0,0,0,537,540,1,0,0,0,538,539,1,0,0,0,538,536,1,0,0,0,539,572, + 1,0,0,0,540,538,1,0,0,0,541,545,5,268,0,0,542,544,9,0,0,0,543,542, + 1,0,0,0,544,547,1,0,0,0,545,546,1,0,0,0,545,543,1,0,0,0,546,572, + 1,0,0,0,547,545,1,0,0,0,548,552,5,244,0,0,549,551,9,0,0,0,550,549, + 1,0,0,0,551,554,1,0,0,0,552,553,1,0,0,0,552,550,1,0,0,0,553,572, + 1,0,0,0,554,552,1,0,0,0,555,556,5,204,0,0,556,558,3,76,38,0,557, + 559,3,120,60,0,558,557,1,0,0,0,558,559,1,0,0,0,559,560,1,0,0,0,560, + 561,5,350,0,0,561,562,5,31,0,0,562,563,3,84,42,0,563,572,1,0,0,0, + 564,568,3,18,9,0,565,567,9,0,0,0,566,565,1,0,0,0,567,570,1,0,0,0, + 568,569,1,0,0,0,568,566,1,0,0,0,569,572,1,0,0,0,570,568,1,0,0,0, + 571,354,1,0,0,0,571,356,1,0,0,0,571,359,1,0,0,0,571,364,1,0,0,0, + 571,365,1,0,0,0,571,366,1,0,0,0,571,367,1,0,0,0,571,368,1,0,0,0, + 571,374,1,0,0,0,571,391,1,0,0,0,571,402,1,0,0,0,571,417,1,0,0,0, + 571,422,1,0,0,0,571,428,1,0,0,0,571,434,1,0,0,0,571,439,1,0,0,0, + 571,453,1,0,0,0,571,467,1,0,0,0,571,470,1,0,0,0,571,473,1,0,0,0, + 571,483,1,0,0,0,571,499,1,0,0,0,571,505,1,0,0,0,571,507,1,0,0,0, + 571,524,1,0,0,0,571,533,1,0,0,0,571,541,1,0,0,0,571,548,1,0,0,0, + 571,555,1,0,0,0,571,564,1,0,0,0,572,5,1,0,0,0,573,574,5,11,0,0,574, + 575,3,32,16,0,575,576,3,70,35,0,576,581,5,268,0,0,577,578,7,6,0, + 0,578,582,3,48,24,0,579,580,5,170,0,0,580,582,3,334,167,0,581,577, + 1,0,0,0,581,579,1,0,0,0,582,896,1,0,0,0,583,584,5,11,0,0,584,585, + 5,292,0,0,585,586,3,76,38,0,586,587,5,8,0,0,587,589,7,7,0,0,588, + 590,5,2,0,0,589,588,1,0,0,0,589,590,1,0,0,0,590,593,1,0,0,0,591, + 594,3,282,141,0,592,594,3,280,140,0,593,591,1,0,0,0,593,592,1,0, + 0,0,594,596,1,0,0,0,595,597,5,3,0,0,596,595,1,0,0,0,596,597,1,0, + 0,0,597,896,1,0,0,0,598,599,5,11,0,0,599,600,5,292,0,0,600,601,3, + 76,38,0,601,602,5,96,0,0,602,604,7,7,0,0,603,605,3,158,79,0,604, + 603,1,0,0,0,604,605,1,0,0,0,605,607,1,0,0,0,606,608,5,2,0,0,607, + 606,1,0,0,0,607,608,1,0,0,0,608,611,1,0,0,0,609,612,3,82,41,0,610, + 612,3,84,42,0,611,609,1,0,0,0,611,610,1,0,0,0,612,614,1,0,0,0,613, + 615,5,3,0,0,614,613,1,0,0,0,614,615,1,0,0,0,615,896,1,0,0,0,616, + 621,5,11,0,0,617,618,5,292,0,0,618,622,3,76,38,0,619,620,5,337,0, + 0,620,622,3,80,40,0,621,617,1,0,0,0,621,619,1,0,0,0,622,623,1,0, + 0,0,623,626,5,240,0,0,624,625,5,49,0,0,625,627,3,82,41,0,626,624, + 1,0,0,0,626,627,1,0,0,0,627,628,1,0,0,0,628,631,5,308,0,0,629,632, + 3,86,43,0,630,632,3,206,103,0,631,629,1,0,0,0,631,630,1,0,0,0,632, + 896,1,0,0,0,633,638,5,11,0,0,634,635,5,292,0,0,635,639,3,76,38,0, + 636,637,5,337,0,0,637,639,3,80,40,0,638,634,1,0,0,0,638,636,1,0, + 0,0,639,640,1,0,0,0,640,641,7,8,0,0,641,643,5,296,0,0,642,644,3, + 158,79,0,643,642,1,0,0,0,643,644,1,0,0,0,644,645,1,0,0,0,645,646, + 3,48,24,0,646,896,1,0,0,0,647,648,5,11,0,0,648,649,5,292,0,0,649, + 650,3,76,38,0,650,652,7,9,0,0,651,653,5,49,0,0,652,651,1,0,0,0,652, + 653,1,0,0,0,653,654,1,0,0,0,654,656,3,82,41,0,655,657,3,332,166, + 0,656,655,1,0,0,0,656,657,1,0,0,0,657,896,1,0,0,0,658,659,5,11,0, + 0,659,660,5,292,0,0,660,662,3,76,38,0,661,663,3,28,14,0,662,661, + 1,0,0,0,662,663,1,0,0,0,663,670,1,0,0,0,664,666,5,39,0,0,665,667, + 5,49,0,0,666,665,1,0,0,0,666,667,1,0,0,0,667,671,1,0,0,0,668,669, + 5,243,0,0,669,671,5,50,0,0,670,664,1,0,0,0,670,668,1,0,0,0,671,681, + 1,0,0,0,672,673,3,82,41,0,673,675,3,294,147,0,674,676,3,274,137, + 0,675,674,1,0,0,0,675,676,1,0,0,0,676,682,1,0,0,0,677,678,5,2,0, + 0,678,679,3,284,142,0,679,680,5,3,0,0,680,682,1,0,0,0,681,672,1, + 0,0,0,681,677,1,0,0,0,682,896,1,0,0,0,683,688,5,11,0,0,684,685,5, + 292,0,0,685,689,3,76,38,0,686,687,5,337,0,0,687,689,3,80,40,0,688, + 684,1,0,0,0,688,686,1,0,0,0,689,690,1,0,0,0,690,693,7,10,0,0,691, + 694,3,156,78,0,692,694,3,158,79,0,693,691,1,0,0,0,693,692,1,0,0, + 0,693,694,1,0,0,0,694,701,1,0,0,0,695,697,3,26,13,0,696,695,1,0, + 0,0,697,698,1,0,0,0,698,696,1,0,0,0,698,699,1,0,0,0,699,702,1,0, + 0,0,700,702,3,28,14,0,701,696,1,0,0,0,701,700,1,0,0,0,702,707,1, + 0,0,0,703,704,5,4,0,0,704,706,3,28,14,0,705,703,1,0,0,0,706,709, + 1,0,0,0,707,705,1,0,0,0,707,708,1,0,0,0,708,711,1,0,0,0,709,707, + 1,0,0,0,710,712,5,229,0,0,711,710,1,0,0,0,711,712,1,0,0,0,712,896, + 1,0,0,0,713,714,5,11,0,0,714,715,5,337,0,0,715,717,3,80,40,0,716, + 718,5,20,0,0,717,716,1,0,0,0,717,718,1,0,0,0,718,719,1,0,0,0,719, + 720,3,24,12,0,720,896,1,0,0,0,721,722,5,11,0,0,722,723,5,292,0,0, + 723,725,3,76,38,0,724,726,3,28,14,0,725,724,1,0,0,0,725,726,1,0, + 0,0,726,727,1,0,0,0,727,729,5,39,0,0,728,730,5,49,0,0,729,728,1, + 0,0,0,729,730,1,0,0,0,730,731,1,0,0,0,731,732,3,82,41,0,732,734, + 3,294,147,0,733,735,3,274,137,0,734,733,1,0,0,0,734,735,1,0,0,0, + 735,896,1,0,0,0,736,737,5,11,0,0,737,738,5,292,0,0,738,740,3,76, + 38,0,739,741,3,28,14,0,740,739,1,0,0,0,740,741,1,0,0,0,741,742,1, + 0,0,0,742,743,5,243,0,0,743,744,5,50,0,0,744,745,5,2,0,0,745,746, + 3,284,142,0,746,747,5,3,0,0,747,896,1,0,0,0,748,749,5,11,0,0,749, + 750,5,292,0,0,750,752,3,76,38,0,751,753,3,28,14,0,752,751,1,0,0, + 0,752,753,1,0,0,0,753,754,1,0,0,0,754,757,5,268,0,0,755,756,5,170, + 0,0,756,758,3,334,167,0,757,755,1,0,0,0,757,758,1,0,0,0,758,760, + 1,0,0,0,759,761,5,265,0,0,760,759,1,0,0,0,760,761,1,0,0,0,761,763, + 1,0,0,0,762,764,3,334,167,0,763,762,1,0,0,0,763,764,1,0,0,0,764, + 766,1,0,0,0,765,767,5,345,0,0,766,765,1,0,0,0,766,767,1,0,0,0,767, + 769,1,0,0,0,768,770,5,266,0,0,769,768,1,0,0,0,769,770,1,0,0,0,770, + 772,1,0,0,0,771,773,3,48,24,0,772,771,1,0,0,0,772,773,1,0,0,0,773, + 896,1,0,0,0,774,775,5,11,0,0,775,776,5,292,0,0,776,777,3,76,38,0, + 777,778,3,28,14,0,778,779,5,240,0,0,779,780,5,308,0,0,780,781,3, + 28,14,0,781,896,1,0,0,0,782,787,5,11,0,0,783,784,5,292,0,0,784,788, + 3,76,38,0,785,786,5,337,0,0,786,788,3,80,40,0,787,783,1,0,0,0,787, + 785,1,0,0,0,788,789,1,0,0,0,789,791,5,8,0,0,790,792,3,156,78,0,791, + 790,1,0,0,0,791,792,1,0,0,0,792,793,1,0,0,0,793,794,3,26,13,0,794, + 896,1,0,0,0,795,800,5,11,0,0,796,797,5,292,0,0,797,801,3,76,38,0, + 798,799,5,337,0,0,799,801,3,80,40,0,800,796,1,0,0,0,800,798,1,0, + 0,0,801,802,1,0,0,0,802,804,5,96,0,0,803,805,3,158,79,0,804,803, + 1,0,0,0,804,805,1,0,0,0,805,806,1,0,0,0,806,811,3,28,14,0,807,808, + 5,4,0,0,808,810,3,28,14,0,809,807,1,0,0,0,810,813,1,0,0,0,811,809, + 1,0,0,0,811,812,1,0,0,0,812,815,1,0,0,0,813,811,1,0,0,0,814,816, + 5,229,0,0,815,814,1,0,0,0,815,816,1,0,0,0,816,896,1,0,0,0,817,818, + 5,11,0,0,818,819,5,292,0,0,819,820,3,76,38,0,820,821,5,236,0,0,821, + 822,5,218,0,0,822,896,1,0,0,0,823,824,5,11,0,0,824,828,5,142,0,0, + 825,827,9,0,0,0,826,825,1,0,0,0,827,830,1,0,0,0,828,829,1,0,0,0, + 828,826,1,0,0,0,829,896,1,0,0,0,830,828,1,0,0,0,831,832,5,11,0,0, + 832,833,5,292,0,0,833,834,3,76,38,0,834,836,7,11,0,0,835,837,5,31, + 0,0,836,835,1,0,0,0,836,837,1,0,0,0,837,841,1,0,0,0,838,840,9,0, + 0,0,839,838,1,0,0,0,840,843,1,0,0,0,841,842,1,0,0,0,841,839,1,0, + 0,0,842,896,1,0,0,0,843,841,1,0,0,0,844,845,5,11,0,0,845,846,5,292, + 0,0,846,847,3,76,38,0,847,848,7,12,0,0,848,850,7,13,0,0,849,851, + 5,170,0,0,850,849,1,0,0,0,850,851,1,0,0,0,851,853,1,0,0,0,852,854, + 5,20,0,0,853,852,1,0,0,0,853,854,1,0,0,0,854,856,1,0,0,0,855,857, + 5,89,0,0,856,855,1,0,0,0,856,857,1,0,0,0,857,861,1,0,0,0,858,860, + 9,0,0,0,859,858,1,0,0,0,860,863,1,0,0,0,861,862,1,0,0,0,861,859, + 1,0,0,0,862,896,1,0,0,0,863,861,1,0,0,0,864,865,5,11,0,0,865,866, + 5,292,0,0,866,867,3,76,38,0,867,868,7,14,0,0,868,872,5,216,0,0,869, + 871,9,0,0,0,870,869,1,0,0,0,871,874,1,0,0,0,872,873,1,0,0,0,872, + 870,1,0,0,0,873,896,1,0,0,0,874,872,1,0,0,0,875,876,5,11,0,0,876, + 877,5,292,0,0,877,879,3,76,38,0,878,880,3,28,14,0,879,878,1,0,0, + 0,879,880,1,0,0,0,880,887,1,0,0,0,881,888,5,53,0,0,882,888,5,56, + 0,0,883,884,5,268,0,0,884,888,5,115,0,0,885,886,5,243,0,0,886,888, + 5,50,0,0,887,881,1,0,0,0,887,882,1,0,0,0,887,883,1,0,0,0,887,885, + 1,0,0,0,888,892,1,0,0,0,889,891,9,0,0,0,890,889,1,0,0,0,891,894, + 1,0,0,0,892,893,1,0,0,0,892,890,1,0,0,0,893,896,1,0,0,0,894,892, + 1,0,0,0,895,573,1,0,0,0,895,583,1,0,0,0,895,598,1,0,0,0,895,616, + 1,0,0,0,895,633,1,0,0,0,895,647,1,0,0,0,895,658,1,0,0,0,895,683, + 1,0,0,0,895,713,1,0,0,0,895,721,1,0,0,0,895,736,1,0,0,0,895,748, + 1,0,0,0,895,774,1,0,0,0,895,782,1,0,0,0,895,795,1,0,0,0,895,817, + 1,0,0,0,895,823,1,0,0,0,895,831,1,0,0,0,895,844,1,0,0,0,895,864, + 1,0,0,0,895,875,1,0,0,0,896,7,1,0,0,0,897,898,5,59,0,0,898,900,3, + 32,16,0,899,901,3,156,78,0,900,899,1,0,0,0,900,901,1,0,0,0,901,902, + 1,0,0,0,902,912,3,72,36,0,903,904,5,51,0,0,904,911,3,334,167,0,905, + 906,5,170,0,0,906,911,3,334,167,0,907,908,5,345,0,0,908,909,7,6, + 0,0,909,911,3,48,24,0,910,903,1,0,0,0,910,905,1,0,0,0,910,907,1, + 0,0,0,911,914,1,0,0,0,912,910,1,0,0,0,912,913,1,0,0,0,913,1109,1, + 0,0,0,914,912,1,0,0,0,915,917,5,59,0,0,916,918,5,297,0,0,917,916, + 1,0,0,0,917,918,1,0,0,0,918,920,1,0,0,0,919,921,5,109,0,0,920,919, + 1,0,0,0,920,921,1,0,0,0,921,922,1,0,0,0,922,924,5,292,0,0,923,925, + 3,156,78,0,924,923,1,0,0,0,924,925,1,0,0,0,925,926,1,0,0,0,926,931, + 3,74,37,0,927,928,5,2,0,0,928,929,3,296,148,0,929,930,5,3,0,0,930, + 932,1,0,0,0,931,927,1,0,0,0,931,932,1,0,0,0,932,934,1,0,0,0,933, + 935,3,42,21,0,934,933,1,0,0,0,934,935,1,0,0,0,935,936,1,0,0,0,936, + 941,3,44,22,0,937,939,5,20,0,0,938,937,1,0,0,0,938,939,1,0,0,0,939, + 940,1,0,0,0,940,942,3,24,12,0,941,938,1,0,0,0,941,942,1,0,0,0,942, + 1109,1,0,0,0,943,944,5,59,0,0,944,946,5,207,0,0,945,943,1,0,0,0, + 945,946,1,0,0,0,946,947,1,0,0,0,947,948,5,243,0,0,948,949,5,292, + 0,0,949,954,3,74,37,0,950,951,5,2,0,0,951,952,3,296,148,0,952,953, + 5,3,0,0,953,955,1,0,0,0,954,950,1,0,0,0,954,955,1,0,0,0,955,957, + 1,0,0,0,956,958,3,42,21,0,957,956,1,0,0,0,957,958,1,0,0,0,958,959, + 1,0,0,0,959,964,3,44,22,0,960,962,5,20,0,0,961,960,1,0,0,0,961,962, + 1,0,0,0,962,963,1,0,0,0,963,965,3,24,12,0,964,961,1,0,0,0,964,965, + 1,0,0,0,965,1109,1,0,0,0,966,967,5,59,0,0,967,969,5,292,0,0,968, + 970,3,156,78,0,969,968,1,0,0,0,969,970,1,0,0,0,970,971,1,0,0,0,971, + 972,3,74,37,0,972,973,5,163,0,0,973,984,3,76,38,0,974,983,3,42,21, + 0,975,983,3,202,101,0,976,983,3,64,32,0,977,978,5,170,0,0,978,983, + 3,334,167,0,979,980,5,296,0,0,980,983,3,48,24,0,981,983,3,46,23, + 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,979,1,0,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,1109,1,0,0,0,986,984,1,0,0,0,987,990,5,59, + 0,0,988,989,5,207,0,0,989,991,5,243,0,0,990,988,1,0,0,0,990,991, + 1,0,0,0,991,996,1,0,0,0,992,994,5,128,0,0,993,992,1,0,0,0,993,994, + 1,0,0,0,994,995,1,0,0,0,995,997,5,297,0,0,996,993,1,0,0,0,996,997, + 1,0,0,0,997,998,1,0,0,0,998,1000,5,337,0,0,999,1001,3,156,78,0,1000, + 999,1,0,0,0,1000,1001,1,0,0,0,1001,1002,1,0,0,0,1002,1004,3,78,39, + 0,1003,1005,3,184,92,0,1004,1003,1,0,0,0,1004,1005,1,0,0,0,1005, + 1015,1,0,0,0,1006,1007,5,51,0,0,1007,1014,3,334,167,0,1008,1009, + 5,217,0,0,1009,1010,5,202,0,0,1010,1014,3,176,88,0,1011,1012,5,296, + 0,0,1012,1014,3,48,24,0,1013,1006,1,0,0,0,1013,1008,1,0,0,0,1013, + 1011,1,0,0,0,1014,1017,1,0,0,0,1015,1013,1,0,0,0,1015,1016,1,0,0, + 0,1016,1018,1,0,0,0,1017,1015,1,0,0,0,1018,1019,5,20,0,0,1019,1020, + 3,24,12,0,1020,1109,1,0,0,0,1021,1024,5,59,0,0,1022,1023,5,207,0, + 0,1023,1025,5,243,0,0,1024,1022,1,0,0,0,1024,1025,1,0,0,0,1025,1027, + 1,0,0,0,1026,1028,5,128,0,0,1027,1026,1,0,0,0,1027,1028,1,0,0,0, + 1028,1029,1,0,0,0,1029,1030,5,297,0,0,1030,1031,5,337,0,0,1031,1036, + 3,78,39,0,1032,1033,5,2,0,0,1033,1034,3,292,146,0,1034,1035,5,3, + 0,0,1035,1037,1,0,0,0,1036,1032,1,0,0,0,1036,1037,1,0,0,0,1037,1038, + 1,0,0,0,1038,1041,3,42,21,0,1039,1040,5,206,0,0,1040,1042,3,48,24, + 0,1041,1039,1,0,0,0,1041,1042,1,0,0,0,1042,1109,1,0,0,0,1043,1046, + 5,59,0,0,1044,1045,5,207,0,0,1045,1047,5,243,0,0,1046,1044,1,0,0, + 0,1046,1047,1,0,0,0,1047,1049,1,0,0,0,1048,1050,5,297,0,0,1049,1048, + 1,0,0,0,1049,1050,1,0,0,0,1050,1051,1,0,0,0,1051,1053,5,125,0,0, + 1052,1054,3,156,78,0,1053,1052,1,0,0,0,1053,1054,1,0,0,0,1054,1055, + 1,0,0,0,1055,1056,3,318,159,0,1056,1057,5,20,0,0,1057,1071,3,334, + 167,0,1058,1059,5,331,0,0,1059,1060,3,326,163,0,1060,1061,3,334, + 167,0,1061,1068,1,0,0,0,1062,1063,5,4,0,0,1063,1064,3,326,163,0, + 1064,1065,3,334,167,0,1065,1067,1,0,0,0,1066,1062,1,0,0,0,1067,1070, + 1,0,0,0,1068,1066,1,0,0,0,1068,1069,1,0,0,0,1069,1072,1,0,0,0,1070, + 1068,1,0,0,0,1071,1058,1,0,0,0,1071,1072,1,0,0,0,1072,1109,1,0,0, + 0,1073,1074,5,59,0,0,1074,1076,5,142,0,0,1075,1077,3,156,78,0,1076, + 1075,1,0,0,0,1076,1077,1,0,0,0,1077,1078,1,0,0,0,1078,1079,3,326, + 163,0,1079,1081,5,202,0,0,1080,1082,5,292,0,0,1081,1080,1,0,0,0, + 1081,1082,1,0,0,0,1082,1083,1,0,0,0,1083,1086,3,76,38,0,1084,1085, + 5,331,0,0,1085,1087,3,326,163,0,1086,1084,1,0,0,0,1086,1087,1,0, + 0,0,1087,1088,1,0,0,0,1088,1089,5,2,0,0,1089,1090,3,208,104,0,1090, + 1093,5,3,0,0,1091,1092,5,206,0,0,1092,1094,3,48,24,0,1093,1091,1, + 0,0,0,1093,1094,1,0,0,0,1094,1109,1,0,0,0,1095,1100,5,59,0,0,1096, + 1101,5,252,0,0,1097,1101,5,142,0,0,1098,1099,5,297,0,0,1099,1101, + 5,175,0,0,1100,1096,1,0,0,0,1100,1097,1,0,0,0,1100,1098,1,0,0,0, + 1101,1105,1,0,0,0,1102,1104,9,0,0,0,1103,1102,1,0,0,0,1104,1107, + 1,0,0,0,1105,1106,1,0,0,0,1105,1103,1,0,0,0,1106,1109,1,0,0,0,1107, + 1105,1,0,0,0,1108,897,1,0,0,0,1108,915,1,0,0,0,1108,945,1,0,0,0, + 1108,966,1,0,0,0,1108,987,1,0,0,0,1108,1021,1,0,0,0,1108,1043,1, + 0,0,0,1108,1073,1,0,0,0,1108,1095,1,0,0,0,1109,9,1,0,0,0,1110,1111, + 5,96,0,0,1111,1113,3,32,16,0,1112,1114,3,158,79,0,1113,1112,1,0, + 0,0,1113,1114,1,0,0,0,1114,1115,1,0,0,0,1115,1117,3,70,35,0,1116, + 1118,7,15,0,0,1117,1116,1,0,0,0,1117,1118,1,0,0,0,1118,1178,1,0, + 0,0,1119,1120,5,96,0,0,1120,1122,5,292,0,0,1121,1123,3,158,79,0, + 1122,1121,1,0,0,0,1122,1123,1,0,0,0,1123,1124,1,0,0,0,1124,1126, + 3,76,38,0,1125,1127,5,229,0,0,1126,1125,1,0,0,0,1126,1127,1,0,0, + 0,1127,1178,1,0,0,0,1128,1129,5,96,0,0,1129,1131,5,337,0,0,1130, + 1132,3,158,79,0,1131,1130,1,0,0,0,1131,1132,1,0,0,0,1132,1133,1, + 0,0,0,1133,1178,3,80,40,0,1134,1136,5,96,0,0,1135,1137,5,297,0,0, + 1136,1135,1,0,0,0,1136,1137,1,0,0,0,1137,1138,1,0,0,0,1138,1140, + 5,125,0,0,1139,1141,3,158,79,0,1140,1139,1,0,0,0,1140,1141,1,0,0, + 0,1141,1142,1,0,0,0,1142,1178,3,316,158,0,1143,1144,5,96,0,0,1144, + 1145,5,297,0,0,1145,1147,5,335,0,0,1146,1148,3,158,79,0,1147,1146, + 1,0,0,0,1147,1148,1,0,0,0,1148,1152,1,0,0,0,1149,1153,3,76,38,0, + 1150,1153,3,80,40,0,1151,1153,3,316,158,0,1152,1149,1,0,0,0,1152, + 1150,1,0,0,0,1152,1151,1,0,0,0,1153,1178,1,0,0,0,1154,1155,5,96, + 0,0,1155,1157,5,142,0,0,1156,1158,3,158,79,0,1157,1156,1,0,0,0,1157, + 1158,1,0,0,0,1158,1159,1,0,0,0,1159,1160,3,326,163,0,1160,1162,5, + 202,0,0,1161,1163,5,292,0,0,1162,1161,1,0,0,0,1162,1163,1,0,0,0, + 1163,1164,1,0,0,0,1164,1165,3,76,38,0,1165,1178,1,0,0,0,1166,1167, + 5,96,0,0,1167,1169,7,16,0,0,1168,1170,5,175,0,0,1169,1168,1,0,0, + 0,1169,1170,1,0,0,0,1170,1174,1,0,0,0,1171,1173,9,0,0,0,1172,1171, + 1,0,0,0,1173,1176,1,0,0,0,1174,1175,1,0,0,0,1174,1172,1,0,0,0,1175, + 1178,1,0,0,0,1176,1174,1,0,0,0,1177,1110,1,0,0,0,1177,1119,1,0,0, + 0,1177,1128,1,0,0,0,1177,1134,1,0,0,0,1177,1143,1,0,0,0,1177,1154, + 1,0,0,0,1177,1166,1,0,0,0,1178,11,1,0,0,0,1179,1180,3,14,7,0,1180, + 1181,3,24,12,0,1181,1238,1,0,0,0,1182,1186,3,128,64,0,1183,1184, + 3,14,7,0,1184,1185,3,98,49,0,1185,1187,1,0,0,0,1186,1183,1,0,0,0, + 1187,1188,1,0,0,0,1188,1186,1,0,0,0,1188,1189,1,0,0,0,1189,1238, + 1,0,0,0,1190,1191,5,84,0,0,1191,1192,5,123,0,0,1192,1193,3,76,38, + 0,1193,1195,3,200,100,0,1194,1196,3,120,60,0,1195,1194,1,0,0,0,1195, + 1196,1,0,0,0,1196,1238,1,0,0,0,1197,1198,5,328,0,0,1198,1199,3,76, + 38,0,1199,1200,3,200,100,0,1200,1202,3,106,53,0,1201,1203,3,120, + 60,0,1202,1201,1,0,0,0,1202,1203,1,0,0,0,1203,1238,1,0,0,0,1204, + 1205,5,178,0,0,1205,1206,5,152,0,0,1206,1207,3,76,38,0,1207,1208, + 3,200,100,0,1208,1214,5,331,0,0,1209,1215,3,88,44,0,1210,1211,5, + 2,0,0,1211,1212,3,24,12,0,1212,1213,5,3,0,0,1213,1215,1,0,0,0,1214, + 1209,1,0,0,0,1214,1210,1,0,0,0,1215,1216,1,0,0,0,1216,1217,3,200, + 100,0,1217,1218,5,202,0,0,1218,1222,3,236,118,0,1219,1221,3,108, + 54,0,1220,1219,1,0,0,0,1221,1224,1,0,0,0,1222,1220,1,0,0,0,1222, + 1223,1,0,0,0,1223,1228,1,0,0,0,1224,1222,1,0,0,0,1225,1227,3,110, + 55,0,1226,1225,1,0,0,0,1227,1230,1,0,0,0,1228,1226,1,0,0,0,1228, + 1229,1,0,0,0,1229,1234,1,0,0,0,1230,1228,1,0,0,0,1231,1233,3,112, + 56,0,1232,1231,1,0,0,0,1233,1236,1,0,0,0,1234,1232,1,0,0,0,1234, + 1235,1,0,0,0,1235,1238,1,0,0,0,1236,1234,1,0,0,0,1237,1179,1,0,0, + 0,1237,1182,1,0,0,0,1237,1190,1,0,0,0,1237,1197,1,0,0,0,1237,1204, + 1,0,0,0,1238,13,1,0,0,0,1239,1240,5,147,0,0,1240,1242,5,152,0,0, + 1241,1243,5,292,0,0,1242,1241,1,0,0,0,1242,1243,1,0,0,0,1243,1244, + 1,0,0,0,1244,1246,3,76,38,0,1245,1247,3,28,14,0,1246,1245,1,0,0, + 0,1246,1247,1,0,0,0,1247,1249,1,0,0,0,1248,1250,3,156,78,0,1249, + 1248,1,0,0,0,1249,1250,1,0,0,0,1250,1257,1,0,0,0,1251,1252,5,31, + 0,0,1252,1258,5,188,0,0,1253,1254,5,2,0,0,1254,1255,3,84,42,0,1255, + 1256,5,3,0,0,1256,1258,1,0,0,0,1257,1251,1,0,0,0,1257,1253,1,0,0, + 0,1257,1258,1,0,0,0,1258,1311,1,0,0,0,1259,1260,5,147,0,0,1260,1262, + 5,152,0,0,1261,1263,5,292,0,0,1262,1261,1,0,0,0,1262,1263,1,0,0, + 0,1263,1264,1,0,0,0,1264,1265,3,76,38,0,1265,1266,5,243,0,0,1266, + 1267,3,120,60,0,1267,1311,1,0,0,0,1268,1269,5,147,0,0,1269,1271, + 5,215,0,0,1270,1272,5,292,0,0,1271,1270,1,0,0,0,1271,1272,1,0,0, + 0,1272,1273,1,0,0,0,1273,1278,3,76,38,0,1274,1276,3,28,14,0,1275, + 1277,3,156,78,0,1276,1275,1,0,0,0,1276,1277,1,0,0,0,1277,1279,1, + 0,0,0,1278,1274,1,0,0,0,1278,1279,1,0,0,0,1279,1286,1,0,0,0,1280, + 1281,5,31,0,0,1281,1287,5,188,0,0,1282,1283,5,2,0,0,1283,1284,3, + 84,42,0,1284,1285,5,3,0,0,1285,1287,1,0,0,0,1286,1280,1,0,0,0,1286, + 1282,1,0,0,0,1286,1287,1,0,0,0,1287,1311,1,0,0,0,1288,1289,5,147, + 0,0,1289,1291,5,215,0,0,1290,1292,5,169,0,0,1291,1290,1,0,0,0,1291, + 1292,1,0,0,0,1292,1293,1,0,0,0,1293,1295,5,90,0,0,1294,1296,3,334, + 167,0,1295,1294,1,0,0,0,1295,1296,1,0,0,0,1296,1298,1,0,0,0,1297, + 1299,3,202,101,0,1298,1297,1,0,0,0,1298,1299,1,0,0,0,1299,1301,1, + 0,0,0,1300,1302,3,64,32,0,1301,1300,1,0,0,0,1301,1302,1,0,0,0,1302, + 1304,1,0,0,0,1303,1305,3,42,21,0,1304,1303,1,0,0,0,1304,1305,1,0, + 0,0,1305,1308,1,0,0,0,1306,1307,5,206,0,0,1307,1309,3,48,24,0,1308, + 1306,1,0,0,0,1308,1309,1,0,0,0,1309,1311,1,0,0,0,1310,1239,1,0,0, + 0,1310,1259,1,0,0,0,1310,1268,1,0,0,0,1310,1288,1,0,0,0,1311,15, + 1,0,0,0,1312,1313,5,272,0,0,1313,1316,7,17,0,0,1314,1315,7,0,0,0, + 1315,1317,3,206,103,0,1316,1314,1,0,0,0,1316,1317,1,0,0,0,1317,1322, + 1,0,0,0,1318,1320,5,163,0,0,1319,1318,1,0,0,0,1319,1320,1,0,0,0, + 1320,1321,1,0,0,0,1321,1323,3,334,167,0,1322,1319,1,0,0,0,1322,1323, + 1,0,0,0,1323,1445,1,0,0,0,1324,1325,5,272,0,0,1325,1328,5,293,0, + 0,1326,1327,7,0,0,0,1327,1329,3,70,35,0,1328,1326,1,0,0,0,1328,1329, + 1,0,0,0,1329,1334,1,0,0,0,1330,1332,5,163,0,0,1331,1330,1,0,0,0, + 1331,1332,1,0,0,0,1332,1333,1,0,0,0,1333,1335,3,334,167,0,1334,1331, + 1,0,0,0,1334,1335,1,0,0,0,1335,1445,1,0,0,0,1336,1337,5,272,0,0, + 1337,1338,5,292,0,0,1338,1341,5,108,0,0,1339,1340,7,0,0,0,1340,1342, + 3,70,35,0,1341,1339,1,0,0,0,1341,1342,1,0,0,0,1342,1343,1,0,0,0, + 1343,1344,5,163,0,0,1344,1346,3,334,167,0,1345,1347,3,28,14,0,1346, + 1345,1,0,0,0,1346,1347,1,0,0,0,1347,1445,1,0,0,0,1348,1349,5,272, + 0,0,1349,1350,5,296,0,0,1350,1355,3,76,38,0,1351,1352,5,2,0,0,1352, + 1353,3,52,26,0,1353,1354,5,3,0,0,1354,1356,1,0,0,0,1355,1351,1,0, + 0,0,1355,1356,1,0,0,0,1356,1445,1,0,0,0,1357,1358,5,272,0,0,1358, + 1359,5,50,0,0,1359,1360,7,0,0,0,1360,1363,3,76,38,0,1361,1362,7, + 0,0,0,1362,1364,3,70,35,0,1363,1361,1,0,0,0,1363,1364,1,0,0,0,1364, + 1445,1,0,0,0,1365,1366,5,272,0,0,1366,1369,5,338,0,0,1367,1368,7, + 0,0,0,1368,1370,3,70,35,0,1369,1367,1,0,0,0,1369,1370,1,0,0,0,1370, + 1375,1,0,0,0,1371,1373,5,163,0,0,1372,1371,1,0,0,0,1372,1373,1,0, + 0,0,1373,1374,1,0,0,0,1374,1376,3,334,167,0,1375,1372,1,0,0,0,1375, + 1376,1,0,0,0,1376,1445,1,0,0,0,1377,1378,5,272,0,0,1378,1379,5,218, + 0,0,1379,1381,3,76,38,0,1380,1382,3,28,14,0,1381,1380,1,0,0,0,1381, + 1382,1,0,0,0,1382,1445,1,0,0,0,1383,1385,5,272,0,0,1384,1386,7,18, + 0,0,1385,1384,1,0,0,0,1385,1386,1,0,0,0,1386,1387,1,0,0,0,1387,1390, + 5,126,0,0,1388,1389,7,0,0,0,1389,1391,3,70,35,0,1390,1388,1,0,0, + 0,1390,1391,1,0,0,0,1391,1399,1,0,0,0,1392,1394,5,163,0,0,1393,1392, + 1,0,0,0,1393,1394,1,0,0,0,1394,1397,1,0,0,0,1395,1398,3,206,103, + 0,1396,1398,3,334,167,0,1397,1395,1,0,0,0,1397,1396,1,0,0,0,1398, + 1400,1,0,0,0,1399,1393,1,0,0,0,1399,1400,1,0,0,0,1400,1445,1,0,0, + 0,1401,1402,5,272,0,0,1402,1403,5,59,0,0,1403,1404,5,292,0,0,1404, + 1407,3,76,38,0,1405,1406,5,20,0,0,1406,1408,5,265,0,0,1407,1405, + 1,0,0,0,1407,1408,1,0,0,0,1408,1445,1,0,0,0,1409,1410,5,272,0,0, + 1410,1411,5,62,0,0,1411,1445,3,32,16,0,1412,1413,5,272,0,0,1413, + 1418,5,38,0,0,1414,1416,5,163,0,0,1415,1414,1,0,0,0,1415,1416,1, + 0,0,0,1416,1417,1,0,0,0,1417,1419,3,334,167,0,1418,1415,1,0,0,0, + 1418,1419,1,0,0,0,1419,1445,1,0,0,0,1420,1436,5,272,0,0,1421,1437, + 5,129,0,0,1422,1437,5,227,0,0,1423,1437,5,253,0,0,1424,1437,5,54, + 0,0,1425,1437,5,312,0,0,1426,1437,5,143,0,0,1427,1437,5,172,0,0, + 1428,1430,5,252,0,0,1429,1431,5,129,0,0,1430,1429,1,0,0,0,1430,1431, + 1,0,0,0,1431,1437,1,0,0,0,1432,1433,5,62,0,0,1433,1437,5,253,0,0, + 1434,1435,5,59,0,0,1435,1437,5,292,0,0,1436,1421,1,0,0,0,1436,1422, + 1,0,0,0,1436,1423,1,0,0,0,1436,1424,1,0,0,0,1436,1425,1,0,0,0,1436, + 1426,1,0,0,0,1436,1427,1,0,0,0,1436,1428,1,0,0,0,1436,1432,1,0,0, + 0,1436,1434,1,0,0,0,1437,1441,1,0,0,0,1438,1440,9,0,0,0,1439,1438, + 1,0,0,0,1440,1443,1,0,0,0,1441,1442,1,0,0,0,1441,1439,1,0,0,0,1442, + 1445,1,0,0,0,1443,1441,1,0,0,0,1444,1312,1,0,0,0,1444,1324,1,0,0, + 0,1444,1336,1,0,0,0,1444,1348,1,0,0,0,1444,1357,1,0,0,0,1444,1365, + 1,0,0,0,1444,1377,1,0,0,0,1444,1383,1,0,0,0,1444,1401,1,0,0,0,1444, + 1409,1,0,0,0,1444,1412,1,0,0,0,1444,1420,1,0,0,0,1445,17,1,0,0,0, + 1446,1448,7,19,0,0,1447,1449,5,252,0,0,1448,1447,1,0,0,0,1448,1449, + 1,0,0,0,1449,1460,1,0,0,0,1450,1451,7,20,0,0,1451,1460,5,292,0,0, + 1452,1453,7,21,0,0,1453,1460,5,72,0,0,1454,1455,5,280,0,0,1455,1460, + 5,311,0,0,1456,1460,5,52,0,0,1457,1460,5,254,0,0,1458,1460,5,88, + 0,0,1459,1446,1,0,0,0,1459,1450,1,0,0,0,1459,1452,1,0,0,0,1459,1454, + 1,0,0,0,1459,1456,1,0,0,0,1459,1457,1,0,0,0,1459,1458,1,0,0,0,1460, + 19,1,0,0,0,1461,1462,5,45,0,0,1462,1463,5,31,0,0,1463,1467,3,176, + 88,0,1464,1465,5,278,0,0,1465,1466,5,31,0,0,1466,1468,3,180,90,0, + 1467,1464,1,0,0,0,1467,1468,1,0,0,0,1468,1469,1,0,0,0,1469,1470, + 5,152,0,0,1470,1471,5,381,0,0,1471,1472,5,30,0,0,1472,21,1,0,0,0, + 1473,1474,5,274,0,0,1474,1475,5,31,0,0,1475,1476,3,176,88,0,1476, + 1479,5,202,0,0,1477,1480,3,60,30,0,1478,1480,3,62,31,0,1479,1477, + 1,0,0,0,1479,1478,1,0,0,0,1480,1484,1,0,0,0,1481,1482,5,282,0,0, + 1482,1483,5,20,0,0,1483,1485,5,89,0,0,1484,1481,1,0,0,0,1484,1485, + 1,0,0,0,1485,23,1,0,0,0,1486,1488,3,38,19,0,1487,1486,1,0,0,0,1487, + 1488,1,0,0,0,1488,1489,1,0,0,0,1489,1490,3,92,46,0,1490,1491,3,90, + 45,0,1491,25,1,0,0,0,1492,1495,3,28,14,0,1493,1494,5,170,0,0,1494, + 1496,3,334,167,0,1495,1493,1,0,0,0,1495,1496,1,0,0,0,1496,27,1,0, + 0,0,1497,1498,5,216,0,0,1498,1499,5,2,0,0,1499,1504,3,30,15,0,1500, + 1501,5,4,0,0,1501,1503,3,30,15,0,1502,1500,1,0,0,0,1503,1506,1,0, + 0,0,1504,1502,1,0,0,0,1504,1505,1,0,0,0,1505,1507,1,0,0,0,1506,1504, + 1,0,0,0,1507,1508,5,3,0,0,1508,29,1,0,0,0,1509,1512,3,326,163,0, + 1510,1511,5,351,0,0,1511,1513,3,248,124,0,1512,1510,1,0,0,0,1512, + 1513,1,0,0,0,1513,1519,1,0,0,0,1514,1515,3,326,163,0,1515,1516,5, + 351,0,0,1516,1517,5,82,0,0,1517,1519,1,0,0,0,1518,1509,1,0,0,0,1518, + 1514,1,0,0,0,1519,31,1,0,0,0,1520,1521,7,22,0,0,1521,33,1,0,0,0, + 1522,1528,3,88,44,0,1523,1528,3,334,167,0,1524,1528,3,250,125,0, + 1525,1528,3,252,126,0,1526,1528,3,254,127,0,1527,1522,1,0,0,0,1527, + 1523,1,0,0,0,1527,1524,1,0,0,0,1527,1525,1,0,0,0,1527,1526,1,0,0, + 0,1528,35,1,0,0,0,1529,1534,3,326,163,0,1530,1531,5,5,0,0,1531,1533, + 3,326,163,0,1532,1530,1,0,0,0,1533,1536,1,0,0,0,1534,1532,1,0,0, + 0,1534,1535,1,0,0,0,1535,37,1,0,0,0,1536,1534,1,0,0,0,1537,1538, + 5,345,0,0,1538,1543,3,40,20,0,1539,1540,5,4,0,0,1540,1542,3,40,20, + 0,1541,1539,1,0,0,0,1542,1545,1,0,0,0,1543,1541,1,0,0,0,1543,1544, + 1,0,0,0,1544,39,1,0,0,0,1545,1543,1,0,0,0,1546,1548,3,322,161,0, + 1547,1549,3,176,88,0,1548,1547,1,0,0,0,1548,1549,1,0,0,0,1549,1551, + 1,0,0,0,1550,1552,5,20,0,0,1551,1550,1,0,0,0,1551,1552,1,0,0,0,1552, + 1553,1,0,0,0,1553,1554,5,2,0,0,1554,1555,3,24,12,0,1555,1556,5,3, + 0,0,1556,41,1,0,0,0,1557,1558,5,331,0,0,1558,1559,3,206,103,0,1559, + 43,1,0,0,0,1560,1561,5,206,0,0,1561,1577,3,56,28,0,1562,1563,5,217, + 0,0,1563,1564,5,31,0,0,1564,1577,3,220,110,0,1565,1577,3,22,11,0, + 1566,1577,3,20,10,0,1567,1577,3,202,101,0,1568,1577,3,64,32,0,1569, + 1570,5,170,0,0,1570,1577,3,334,167,0,1571,1572,5,51,0,0,1572,1577, + 3,334,167,0,1573,1574,5,296,0,0,1574,1577,3,48,24,0,1575,1577,3, + 46,23,0,1576,1560,1,0,0,0,1576,1562,1,0,0,0,1576,1565,1,0,0,0,1576, + 1566,1,0,0,0,1576,1567,1,0,0,0,1576,1568,1,0,0,0,1576,1569,1,0,0, + 0,1576,1571,1,0,0,0,1576,1573,1,0,0,0,1576,1575,1,0,0,0,1577,1580, + 1,0,0,0,1578,1576,1,0,0,0,1578,1579,1,0,0,0,1579,45,1,0,0,0,1580, + 1578,1,0,0,0,1581,1582,5,162,0,0,1582,1583,5,381,0,0,1583,47,1,0, + 0,0,1584,1585,5,2,0,0,1585,1590,3,50,25,0,1586,1587,5,4,0,0,1587, + 1589,3,50,25,0,1588,1586,1,0,0,0,1589,1592,1,0,0,0,1590,1588,1,0, + 0,0,1590,1591,1,0,0,0,1591,1593,1,0,0,0,1592,1590,1,0,0,0,1593,1594, + 5,3,0,0,1594,49,1,0,0,0,1595,1600,3,52,26,0,1596,1598,5,351,0,0, + 1597,1596,1,0,0,0,1597,1598,1,0,0,0,1598,1599,1,0,0,0,1599,1601, + 3,54,27,0,1600,1597,1,0,0,0,1600,1601,1,0,0,0,1601,51,1,0,0,0,1602, + 1607,3,326,163,0,1603,1604,5,5,0,0,1604,1606,3,326,163,0,1605,1603, + 1,0,0,0,1606,1609,1,0,0,0,1607,1605,1,0,0,0,1607,1608,1,0,0,0,1608, + 1612,1,0,0,0,1609,1607,1,0,0,0,1610,1612,3,334,167,0,1611,1602,1, + 0,0,0,1611,1610,1,0,0,0,1612,53,1,0,0,0,1613,1618,5,381,0,0,1614, + 1618,5,383,0,0,1615,1618,3,256,128,0,1616,1618,3,334,167,0,1617, + 1613,1,0,0,0,1617,1614,1,0,0,0,1617,1615,1,0,0,0,1617,1616,1,0,0, + 0,1618,55,1,0,0,0,1619,1620,5,2,0,0,1620,1625,3,58,29,0,1621,1622, + 5,4,0,0,1622,1624,3,58,29,0,1623,1621,1,0,0,0,1624,1627,1,0,0,0, + 1625,1623,1,0,0,0,1625,1626,1,0,0,0,1626,1628,1,0,0,0,1627,1625, + 1,0,0,0,1628,1629,5,3,0,0,1629,57,1,0,0,0,1630,1635,3,52,26,0,1631, + 1633,5,351,0,0,1632,1631,1,0,0,0,1632,1633,1,0,0,0,1633,1634,1,0, + 0,0,1634,1636,3,228,114,0,1635,1632,1,0,0,0,1635,1636,1,0,0,0,1636, + 59,1,0,0,0,1637,1638,5,2,0,0,1638,1643,3,248,124,0,1639,1640,5,4, + 0,0,1640,1642,3,248,124,0,1641,1639,1,0,0,0,1642,1645,1,0,0,0,1643, + 1641,1,0,0,0,1643,1644,1,0,0,0,1644,1646,1,0,0,0,1645,1643,1,0,0, + 0,1646,1647,5,3,0,0,1647,61,1,0,0,0,1648,1649,5,2,0,0,1649,1654, + 3,60,30,0,1650,1651,5,4,0,0,1651,1653,3,60,30,0,1652,1650,1,0,0, + 0,1653,1656,1,0,0,0,1654,1652,1,0,0,0,1654,1655,1,0,0,0,1655,1657, + 1,0,0,0,1656,1654,1,0,0,0,1657,1658,5,3,0,0,1658,63,1,0,0,0,1659, + 1660,5,282,0,0,1660,1661,5,20,0,0,1661,1666,3,66,33,0,1662,1663, + 5,282,0,0,1663,1664,5,31,0,0,1664,1666,3,68,34,0,1665,1659,1,0,0, + 0,1665,1662,1,0,0,0,1666,65,1,0,0,0,1667,1668,5,146,0,0,1668,1669, + 3,334,167,0,1669,1670,5,211,0,0,1670,1671,3,334,167,0,1671,1674, + 1,0,0,0,1672,1674,3,326,163,0,1673,1667,1,0,0,0,1673,1672,1,0,0, + 0,1674,67,1,0,0,0,1675,1679,3,334,167,0,1676,1677,5,345,0,0,1677, + 1678,5,266,0,0,1678,1680,3,48,24,0,1679,1676,1,0,0,0,1679,1680,1, + 0,0,0,1680,69,1,0,0,0,1681,1682,3,88,44,0,1682,71,1,0,0,0,1683,1684, + 3,88,44,0,1684,73,1,0,0,0,1685,1686,3,212,106,0,1686,75,1,0,0,0, + 1687,1688,3,212,106,0,1688,77,1,0,0,0,1689,1690,3,214,107,0,1690, + 79,1,0,0,0,1691,1692,3,214,107,0,1692,81,1,0,0,0,1693,1696,3,206, + 103,0,1694,1696,4,41,0,0,1695,1693,1,0,0,0,1695,1694,1,0,0,0,1696, + 83,1,0,0,0,1697,1702,3,82,41,0,1698,1699,5,4,0,0,1699,1701,3,82, + 41,0,1700,1698,1,0,0,0,1701,1704,1,0,0,0,1702,1700,1,0,0,0,1702, + 1703,1,0,0,0,1703,85,1,0,0,0,1704,1702,1,0,0,0,1705,1706,3,322,161, + 0,1706,87,1,0,0,0,1707,1708,5,136,0,0,1708,1709,5,2,0,0,1709,1710, + 3,228,114,0,1710,1711,5,3,0,0,1711,1714,1,0,0,0,1712,1714,3,206, + 103,0,1713,1707,1,0,0,0,1713,1712,1,0,0,0,1714,89,1,0,0,0,1715,1716, + 5,208,0,0,1716,1717,5,31,0,0,1717,1722,3,96,48,0,1718,1719,5,4,0, + 0,1719,1721,3,96,48,0,1720,1718,1,0,0,0,1721,1724,1,0,0,0,1722,1720, + 1,0,0,0,1722,1723,1,0,0,0,1723,1726,1,0,0,0,1724,1722,1,0,0,0,1725, + 1715,1,0,0,0,1725,1726,1,0,0,0,1726,1737,1,0,0,0,1727,1728,5,44, + 0,0,1728,1729,5,31,0,0,1729,1734,3,228,114,0,1730,1731,5,4,0,0,1731, + 1733,3,228,114,0,1732,1730,1,0,0,0,1733,1736,1,0,0,0,1734,1732,1, + 0,0,0,1734,1735,1,0,0,0,1735,1738,1,0,0,0,1736,1734,1,0,0,0,1737, + 1727,1,0,0,0,1737,1738,1,0,0,0,1738,1749,1,0,0,0,1739,1740,5,93, + 0,0,1740,1741,5,31,0,0,1741,1746,3,228,114,0,1742,1743,5,4,0,0,1743, + 1745,3,228,114,0,1744,1742,1,0,0,0,1745,1748,1,0,0,0,1746,1744,1, + 0,0,0,1746,1747,1,0,0,0,1747,1750,1,0,0,0,1748,1746,1,0,0,0,1749, + 1739,1,0,0,0,1749,1750,1,0,0,0,1750,1761,1,0,0,0,1751,1752,5,277, + 0,0,1752,1753,5,31,0,0,1753,1758,3,96,48,0,1754,1755,5,4,0,0,1755, + 1757,3,96,48,0,1756,1754,1,0,0,0,1757,1760,1,0,0,0,1758,1756,1,0, + 0,0,1758,1759,1,0,0,0,1759,1762,1,0,0,0,1760,1758,1,0,0,0,1761,1751, + 1,0,0,0,1761,1762,1,0,0,0,1762,1764,1,0,0,0,1763,1765,3,306,153, + 0,1764,1763,1,0,0,0,1764,1765,1,0,0,0,1765,1771,1,0,0,0,1766,1769, + 5,165,0,0,1767,1770,5,10,0,0,1768,1770,3,228,114,0,1769,1767,1,0, + 0,0,1769,1768,1,0,0,0,1770,1772,1,0,0,0,1771,1766,1,0,0,0,1771,1772, + 1,0,0,0,1772,1775,1,0,0,0,1773,1774,5,201,0,0,1774,1776,3,228,114, + 0,1775,1773,1,0,0,0,1775,1776,1,0,0,0,1776,91,1,0,0,0,1777,1778, + 6,46,-1,0,1778,1779,3,94,47,0,1779,1800,1,0,0,0,1780,1781,10,3,0, + 0,1781,1783,7,23,0,0,1782,1784,3,162,81,0,1783,1782,1,0,0,0,1783, + 1784,1,0,0,0,1784,1785,1,0,0,0,1785,1799,3,92,46,4,1786,1787,10, + 2,0,0,1787,1789,5,148,0,0,1788,1790,3,162,81,0,1789,1788,1,0,0,0, + 1789,1790,1,0,0,0,1790,1791,1,0,0,0,1791,1799,3,92,46,3,1792,1793, + 10,1,0,0,1793,1795,7,24,0,0,1794,1796,3,162,81,0,1795,1794,1,0,0, + 0,1795,1796,1,0,0,0,1796,1797,1,0,0,0,1797,1799,3,92,46,2,1798,1780, + 1,0,0,0,1798,1786,1,0,0,0,1798,1792,1,0,0,0,1799,1802,1,0,0,0,1800, + 1798,1,0,0,0,1800,1801,1,0,0,0,1801,93,1,0,0,0,1802,1800,1,0,0,0, + 1803,1828,3,100,50,0,1804,1806,3,128,64,0,1805,1807,3,98,49,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,1828,1,0,0,0,1810,1811,5,292,0,0,1811,1828,3,76,38,0,1812, + 1813,5,332,0,0,1813,1818,3,228,114,0,1814,1815,5,4,0,0,1815,1817, + 3,228,114,0,1816,1814,1,0,0,0,1817,1820,1,0,0,0,1818,1816,1,0,0, + 0,1818,1819,1,0,0,0,1819,1821,1,0,0,0,1820,1818,1,0,0,0,1821,1822, + 3,200,100,0,1822,1828,1,0,0,0,1823,1824,5,2,0,0,1824,1825,3,24,12, + 0,1825,1826,5,3,0,0,1826,1828,1,0,0,0,1827,1803,1,0,0,0,1827,1804, + 1,0,0,0,1827,1810,1,0,0,0,1827,1812,1,0,0,0,1827,1823,1,0,0,0,1828, + 95,1,0,0,0,1829,1832,3,82,41,0,1830,1832,3,228,114,0,1831,1829,1, + 0,0,0,1831,1830,1,0,0,0,1832,1834,1,0,0,0,1833,1835,7,25,0,0,1834, + 1833,1,0,0,0,1834,1835,1,0,0,0,1835,1838,1,0,0,0,1836,1837,5,198, + 0,0,1837,1839,7,26,0,0,1838,1836,1,0,0,0,1838,1839,1,0,0,0,1839, + 97,1,0,0,0,1840,1842,3,102,51,0,1841,1843,3,120,60,0,1842,1841,1, + 0,0,0,1842,1843,1,0,0,0,1843,1844,1,0,0,0,1844,1845,3,90,45,0,1845, + 1868,1,0,0,0,1846,1850,3,104,52,0,1847,1849,3,160,80,0,1848,1847, + 1,0,0,0,1849,1852,1,0,0,0,1850,1848,1,0,0,0,1850,1851,1,0,0,0,1851, + 1854,1,0,0,0,1852,1850,1,0,0,0,1853,1855,3,120,60,0,1854,1853,1, + 0,0,0,1854,1855,1,0,0,0,1855,1857,1,0,0,0,1856,1858,3,132,66,0,1857, + 1856,1,0,0,0,1857,1858,1,0,0,0,1858,1860,1,0,0,0,1859,1861,3,122, + 61,0,1860,1859,1,0,0,0,1860,1861,1,0,0,0,1861,1863,1,0,0,0,1862, + 1864,3,306,153,0,1863,1862,1,0,0,0,1863,1864,1,0,0,0,1864,1865,1, + 0,0,0,1865,1866,3,90,45,0,1866,1868,1,0,0,0,1867,1840,1,0,0,0,1867, + 1846,1,0,0,0,1868,99,1,0,0,0,1869,1871,3,102,51,0,1870,1872,3,128, + 64,0,1871,1870,1,0,0,0,1871,1872,1,0,0,0,1872,1876,1,0,0,0,1873, + 1875,3,160,80,0,1874,1873,1,0,0,0,1875,1878,1,0,0,0,1876,1874,1, + 0,0,0,1876,1877,1,0,0,0,1877,1880,1,0,0,0,1878,1876,1,0,0,0,1879, + 1881,3,120,60,0,1880,1879,1,0,0,0,1880,1881,1,0,0,0,1881,1883,1, + 0,0,0,1882,1884,3,132,66,0,1883,1882,1,0,0,0,1883,1884,1,0,0,0,1884, + 1886,1,0,0,0,1885,1887,3,122,61,0,1886,1885,1,0,0,0,1886,1887,1, + 0,0,0,1887,1889,1,0,0,0,1888,1890,3,306,153,0,1889,1888,1,0,0,0, + 1889,1890,1,0,0,0,1890,1914,1,0,0,0,1891,1893,3,104,52,0,1892,1894, + 3,128,64,0,1893,1892,1,0,0,0,1893,1894,1,0,0,0,1894,1898,1,0,0,0, + 1895,1897,3,160,80,0,1896,1895,1,0,0,0,1897,1900,1,0,0,0,1898,1896, + 1,0,0,0,1898,1899,1,0,0,0,1899,1902,1,0,0,0,1900,1898,1,0,0,0,1901, + 1903,3,120,60,0,1902,1901,1,0,0,0,1902,1903,1,0,0,0,1903,1905,1, + 0,0,0,1904,1906,3,132,66,0,1905,1904,1,0,0,0,1905,1906,1,0,0,0,1906, + 1908,1,0,0,0,1907,1909,3,122,61,0,1908,1907,1,0,0,0,1908,1909,1, + 0,0,0,1909,1911,1,0,0,0,1910,1912,3,306,153,0,1911,1910,1,0,0,0, + 1911,1912,1,0,0,0,1912,1914,1,0,0,0,1913,1869,1,0,0,0,1913,1891, + 1,0,0,0,1914,101,1,0,0,0,1915,1916,5,262,0,0,1916,1917,5,313,0,0, + 1917,1919,5,2,0,0,1918,1920,3,162,81,0,1919,1918,1,0,0,0,1919,1920, + 1,0,0,0,1920,1921,1,0,0,0,1921,1922,3,234,117,0,1922,1923,5,3,0, + 0,1923,1935,1,0,0,0,1924,1926,5,176,0,0,1925,1927,3,162,81,0,1926, + 1925,1,0,0,0,1926,1927,1,0,0,0,1927,1928,1,0,0,0,1928,1935,3,234, + 117,0,1929,1931,5,237,0,0,1930,1932,3,162,81,0,1931,1930,1,0,0,0, + 1931,1932,1,0,0,0,1932,1933,1,0,0,0,1933,1935,3,234,117,0,1934,1915, + 1,0,0,0,1934,1924,1,0,0,0,1934,1929,1,0,0,0,1935,1937,1,0,0,0,1936, + 1938,3,202,101,0,1937,1936,1,0,0,0,1937,1938,1,0,0,0,1938,1941,1, + 0,0,0,1939,1940,5,235,0,0,1940,1942,3,334,167,0,1941,1939,1,0,0, + 0,1941,1942,1,0,0,0,1942,1943,1,0,0,0,1943,1944,5,331,0,0,1944,1957, + 3,334,167,0,1945,1955,5,20,0,0,1946,1956,3,178,89,0,1947,1956,3, + 292,146,0,1948,1951,5,2,0,0,1949,1952,3,178,89,0,1950,1952,3,292, + 146,0,1951,1949,1,0,0,0,1951,1950,1,0,0,0,1952,1953,1,0,0,0,1953, + 1954,5,3,0,0,1954,1956,1,0,0,0,1955,1946,1,0,0,0,1955,1947,1,0,0, + 0,1955,1948,1,0,0,0,1956,1958,1,0,0,0,1957,1945,1,0,0,0,1957,1958, + 1,0,0,0,1958,1960,1,0,0,0,1959,1961,3,202,101,0,1960,1959,1,0,0, + 0,1960,1961,1,0,0,0,1961,1964,1,0,0,0,1962,1963,5,234,0,0,1963,1965, + 3,334,167,0,1964,1962,1,0,0,0,1964,1965,1,0,0,0,1965,103,1,0,0,0, + 1966,1970,5,262,0,0,1967,1969,3,124,62,0,1968,1967,1,0,0,0,1969, + 1972,1,0,0,0,1970,1968,1,0,0,0,1970,1971,1,0,0,0,1971,1974,1,0,0, + 0,1972,1970,1,0,0,0,1973,1975,3,162,81,0,1974,1973,1,0,0,0,1974, + 1975,1,0,0,0,1975,1976,1,0,0,0,1976,1977,3,218,109,0,1977,105,1, + 0,0,0,1978,1979,5,268,0,0,1979,1980,3,116,58,0,1980,107,1,0,0,0, + 1981,1982,5,342,0,0,1982,1985,5,177,0,0,1983,1984,5,14,0,0,1984, + 1986,3,236,118,0,1985,1983,1,0,0,0,1985,1986,1,0,0,0,1986,1987,1, + 0,0,0,1987,1995,5,299,0,0,1988,1996,5,84,0,0,1989,1990,5,328,0,0, + 1990,1993,5,268,0,0,1991,1994,5,362,0,0,1992,1994,3,116,58,0,1993, + 1991,1,0,0,0,1993,1992,1,0,0,0,1994,1996,1,0,0,0,1995,1988,1,0,0, + 0,1995,1989,1,0,0,0,1996,109,1,0,0,0,1997,1998,5,342,0,0,1998,1999, + 5,196,0,0,1999,2002,5,177,0,0,2000,2001,5,31,0,0,2001,2003,5,295, + 0,0,2002,2000,1,0,0,0,2002,2003,1,0,0,0,2003,2006,1,0,0,0,2004,2005, + 5,14,0,0,2005,2007,3,236,118,0,2006,2004,1,0,0,0,2006,2007,1,0,0, + 0,2007,2008,1,0,0,0,2008,2009,5,299,0,0,2009,2010,3,114,57,0,2010, + 111,1,0,0,0,2011,2012,5,342,0,0,2012,2013,5,196,0,0,2013,2014,5, + 177,0,0,2014,2015,5,31,0,0,2015,2018,5,279,0,0,2016,2017,5,14,0, + 0,2017,2019,3,236,118,0,2018,2016,1,0,0,0,2018,2019,1,0,0,0,2019, + 2020,1,0,0,0,2020,2025,5,299,0,0,2021,2026,5,84,0,0,2022,2023,5, + 328,0,0,2023,2024,5,268,0,0,2024,2026,3,116,58,0,2025,2021,1,0,0, + 0,2025,2022,1,0,0,0,2026,113,1,0,0,0,2027,2028,5,147,0,0,2028,2046, + 5,362,0,0,2029,2030,5,147,0,0,2030,2031,5,2,0,0,2031,2032,3,204, + 102,0,2032,2033,5,3,0,0,2033,2034,5,332,0,0,2034,2035,5,2,0,0,2035, + 2040,3,228,114,0,2036,2037,5,4,0,0,2037,2039,3,228,114,0,2038,2036, + 1,0,0,0,2039,2042,1,0,0,0,2040,2038,1,0,0,0,2040,2041,1,0,0,0,2041, + 2043,1,0,0,0,2042,2040,1,0,0,0,2043,2044,5,3,0,0,2044,2046,1,0,0, + 0,2045,2027,1,0,0,0,2045,2029,1,0,0,0,2046,115,1,0,0,0,2047,2052, + 3,118,59,0,2048,2049,5,4,0,0,2049,2051,3,118,59,0,2050,2048,1,0, + 0,0,2051,2054,1,0,0,0,2052,2050,1,0,0,0,2052,2053,1,0,0,0,2053,117, + 1,0,0,0,2054,2052,1,0,0,0,2055,2056,3,206,103,0,2056,2057,5,351, + 0,0,2057,2058,3,228,114,0,2058,119,1,0,0,0,2059,2060,5,343,0,0,2060, + 2061,3,236,118,0,2061,121,1,0,0,0,2062,2063,5,132,0,0,2063,2064, + 3,236,118,0,2064,123,1,0,0,0,2065,2066,5,373,0,0,2066,2073,3,126, + 63,0,2067,2069,5,4,0,0,2068,2067,1,0,0,0,2068,2069,1,0,0,0,2069, + 2070,1,0,0,0,2070,2072,3,126,63,0,2071,2068,1,0,0,0,2072,2075,1, + 0,0,0,2073,2071,1,0,0,0,2073,2074,1,0,0,0,2074,2076,1,0,0,0,2075, + 2073,1,0,0,0,2076,2077,5,374,0,0,2077,125,1,0,0,0,2078,2092,3,326, + 163,0,2079,2080,3,326,163,0,2080,2081,5,2,0,0,2081,2086,3,244,122, + 0,2082,2083,5,4,0,0,2083,2085,3,244,122,0,2084,2082,1,0,0,0,2085, + 2088,1,0,0,0,2086,2084,1,0,0,0,2086,2087,1,0,0,0,2087,2089,1,0,0, + 0,2088,2086,1,0,0,0,2089,2090,5,3,0,0,2090,2092,1,0,0,0,2091,2078, + 1,0,0,0,2091,2079,1,0,0,0,2092,127,1,0,0,0,2093,2094,5,123,0,0,2094, + 2099,3,164,82,0,2095,2096,5,4,0,0,2096,2098,3,164,82,0,2097,2095, + 1,0,0,0,2098,2101,1,0,0,0,2099,2097,1,0,0,0,2099,2100,1,0,0,0,2100, + 2105,1,0,0,0,2101,2099,1,0,0,0,2102,2104,3,160,80,0,2103,2102,1, + 0,0,0,2104,2107,1,0,0,0,2105,2103,1,0,0,0,2105,2106,1,0,0,0,2106, + 2109,1,0,0,0,2107,2105,1,0,0,0,2108,2110,3,140,70,0,2109,2108,1, + 0,0,0,2109,2110,1,0,0,0,2110,2112,1,0,0,0,2111,2113,3,146,73,0,2112, + 2111,1,0,0,0,2112,2113,1,0,0,0,2113,129,1,0,0,0,2114,2116,5,119, + 0,0,2115,2114,1,0,0,0,2115,2116,1,0,0,0,2116,2117,1,0,0,0,2117,2118, + 7,27,0,0,2118,2119,5,20,0,0,2119,2122,5,200,0,0,2120,2123,5,381, + 0,0,2121,2123,3,334,167,0,2122,2120,1,0,0,0,2122,2121,1,0,0,0,2123, + 2132,1,0,0,0,2124,2126,5,119,0,0,2125,2124,1,0,0,0,2125,2126,1,0, + 0,0,2126,2127,1,0,0,0,2127,2128,7,28,0,0,2128,2129,5,20,0,0,2129, + 2130,5,200,0,0,2130,2132,3,240,120,0,2131,2115,1,0,0,0,2131,2125, + 1,0,0,0,2132,131,1,0,0,0,2133,2134,5,130,0,0,2134,2135,5,31,0,0, + 2135,2140,3,134,67,0,2136,2137,5,4,0,0,2137,2139,3,134,67,0,2138, + 2136,1,0,0,0,2139,2142,1,0,0,0,2140,2138,1,0,0,0,2140,2141,1,0,0, + 0,2141,2173,1,0,0,0,2142,2140,1,0,0,0,2143,2144,5,130,0,0,2144,2145, + 5,31,0,0,2145,2150,3,228,114,0,2146,2147,5,4,0,0,2147,2149,3,228, + 114,0,2148,2146,1,0,0,0,2149,2152,1,0,0,0,2150,2148,1,0,0,0,2150, + 2151,1,0,0,0,2151,2170,1,0,0,0,2152,2150,1,0,0,0,2153,2154,5,345, + 0,0,2154,2171,5,255,0,0,2155,2156,5,345,0,0,2156,2171,5,61,0,0,2157, + 2158,5,131,0,0,2158,2159,5,270,0,0,2159,2160,5,2,0,0,2160,2165,3, + 138,69,0,2161,2162,5,4,0,0,2162,2164,3,138,69,0,2163,2161,1,0,0, + 0,2164,2167,1,0,0,0,2165,2163,1,0,0,0,2165,2166,1,0,0,0,2166,2168, + 1,0,0,0,2167,2165,1,0,0,0,2168,2169,5,3,0,0,2169,2171,1,0,0,0,2170, + 2153,1,0,0,0,2170,2155,1,0,0,0,2170,2157,1,0,0,0,2170,2171,1,0,0, + 0,2171,2173,1,0,0,0,2172,2133,1,0,0,0,2172,2143,1,0,0,0,2173,133, + 1,0,0,0,2174,2178,3,82,41,0,2175,2178,3,136,68,0,2176,2178,3,228, + 114,0,2177,2174,1,0,0,0,2177,2175,1,0,0,0,2177,2176,1,0,0,0,2178, + 135,1,0,0,0,2179,2180,7,29,0,0,2180,2181,5,2,0,0,2181,2186,3,138, + 69,0,2182,2183,5,4,0,0,2183,2185,3,138,69,0,2184,2182,1,0,0,0,2185, + 2188,1,0,0,0,2186,2184,1,0,0,0,2186,2187,1,0,0,0,2187,2189,1,0,0, + 0,2188,2186,1,0,0,0,2189,2190,5,3,0,0,2190,2211,1,0,0,0,2191,2192, + 5,131,0,0,2192,2193,5,270,0,0,2193,2196,5,2,0,0,2194,2197,3,136, + 68,0,2195,2197,3,138,69,0,2196,2194,1,0,0,0,2196,2195,1,0,0,0,2197, + 2205,1,0,0,0,2198,2201,5,4,0,0,2199,2202,3,136,68,0,2200,2202,3, + 138,69,0,2201,2199,1,0,0,0,2201,2200,1,0,0,0,2202,2204,1,0,0,0,2203, + 2198,1,0,0,0,2204,2207,1,0,0,0,2205,2203,1,0,0,0,2205,2206,1,0,0, + 0,2206,2208,1,0,0,0,2207,2205,1,0,0,0,2208,2209,5,3,0,0,2209,2211, + 1,0,0,0,2210,2179,1,0,0,0,2210,2191,1,0,0,0,2211,137,1,0,0,0,2212, + 2233,3,82,41,0,2213,2233,3,228,114,0,2214,2229,5,2,0,0,2215,2218, + 3,82,41,0,2216,2218,3,228,114,0,2217,2215,1,0,0,0,2217,2216,1,0, + 0,0,2218,2226,1,0,0,0,2219,2222,5,4,0,0,2220,2223,3,82,41,0,2221, + 2223,3,228,114,0,2222,2220,1,0,0,0,2222,2221,1,0,0,0,2223,2225,1, + 0,0,0,2224,2219,1,0,0,0,2225,2228,1,0,0,0,2226,2224,1,0,0,0,2226, + 2227,1,0,0,0,2227,2230,1,0,0,0,2228,2226,1,0,0,0,2229,2217,1,0,0, + 0,2229,2230,1,0,0,0,2230,2231,1,0,0,0,2231,2233,5,3,0,0,2232,2212, + 1,0,0,0,2232,2213,1,0,0,0,2232,2214,1,0,0,0,2233,139,1,0,0,0,2234, + 2235,5,222,0,0,2235,2236,5,2,0,0,2236,2237,3,218,109,0,2237,2238, + 5,119,0,0,2238,2239,3,142,71,0,2239,2240,5,140,0,0,2240,2241,5,2, + 0,0,2241,2246,3,144,72,0,2242,2243,5,4,0,0,2243,2245,3,144,72,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,2249,1,0,0,0,2248,2246,1,0,0,0,2249,2250,5,3,0,0,2250, + 2251,5,3,0,0,2251,141,1,0,0,0,2252,2265,3,326,163,0,2253,2254,5, + 2,0,0,2254,2259,3,326,163,0,2255,2256,5,4,0,0,2256,2258,3,326,163, + 0,2257,2255,1,0,0,0,2258,2261,1,0,0,0,2259,2257,1,0,0,0,2259,2260, + 1,0,0,0,2260,2262,1,0,0,0,2261,2259,1,0,0,0,2262,2263,5,3,0,0,2263, + 2265,1,0,0,0,2264,2252,1,0,0,0,2264,2253,1,0,0,0,2265,143,1,0,0, + 0,2266,2271,3,228,114,0,2267,2269,5,20,0,0,2268,2267,1,0,0,0,2268, + 2269,1,0,0,0,2269,2270,1,0,0,0,2270,2272,3,326,163,0,2271,2268,1, + 0,0,0,2271,2272,1,0,0,0,2272,145,1,0,0,0,2273,2276,5,326,0,0,2274, + 2275,7,30,0,0,2275,2277,5,198,0,0,2276,2274,1,0,0,0,2276,2277,1, + 0,0,0,2277,2278,1,0,0,0,2278,2281,5,2,0,0,2279,2282,3,148,74,0,2280, + 2282,3,150,75,0,2281,2279,1,0,0,0,2281,2280,1,0,0,0,2282,2283,1, + 0,0,0,2283,2288,5,3,0,0,2284,2286,5,20,0,0,2285,2284,1,0,0,0,2285, + 2286,1,0,0,0,2286,2287,1,0,0,0,2287,2289,3,326,163,0,2288,2285,1, + 0,0,0,2288,2289,1,0,0,0,2289,147,1,0,0,0,2290,2291,3,326,163,0,2291, + 2292,5,119,0,0,2292,2293,3,326,163,0,2293,2294,5,140,0,0,2294,2295, + 5,2,0,0,2295,2300,3,154,77,0,2296,2297,5,4,0,0,2297,2299,3,154,77, + 0,2298,2296,1,0,0,0,2299,2302,1,0,0,0,2300,2298,1,0,0,0,2300,2301, + 1,0,0,0,2301,2303,1,0,0,0,2302,2300,1,0,0,0,2303,2304,5,3,0,0,2304, + 149,1,0,0,0,2305,2306,5,2,0,0,2306,2311,3,326,163,0,2307,2308,5, + 4,0,0,2308,2310,3,326,163,0,2309,2307,1,0,0,0,2310,2313,1,0,0,0, + 2311,2309,1,0,0,0,2311,2312,1,0,0,0,2312,2314,1,0,0,0,2313,2311, + 1,0,0,0,2314,2315,5,3,0,0,2315,2316,5,119,0,0,2316,2317,3,326,163, + 0,2317,2318,5,140,0,0,2318,2319,5,2,0,0,2319,2324,3,152,76,0,2320, + 2321,5,4,0,0,2321,2323,3,152,76,0,2322,2320,1,0,0,0,2323,2326,1, + 0,0,0,2324,2322,1,0,0,0,2324,2325,1,0,0,0,2325,2327,1,0,0,0,2326, + 2324,1,0,0,0,2327,2328,5,3,0,0,2328,151,1,0,0,0,2329,2330,5,2,0, + 0,2330,2335,3,206,103,0,2331,2332,5,4,0,0,2332,2334,3,206,103,0, + 2333,2331,1,0,0,0,2334,2337,1,0,0,0,2335,2333,1,0,0,0,2335,2336, + 1,0,0,0,2336,2338,1,0,0,0,2337,2335,1,0,0,0,2338,2343,5,3,0,0,2339, + 2341,5,20,0,0,2340,2339,1,0,0,0,2340,2341,1,0,0,0,2341,2342,1,0, + 0,0,2342,2344,3,326,163,0,2343,2340,1,0,0,0,2343,2344,1,0,0,0,2344, + 153,1,0,0,0,2345,2350,3,206,103,0,2346,2348,5,20,0,0,2347,2346,1, + 0,0,0,2347,2348,1,0,0,0,2348,2349,1,0,0,0,2349,2351,3,326,163,0, + 2350,2347,1,0,0,0,2350,2351,1,0,0,0,2351,155,1,0,0,0,2352,2353,5, + 137,0,0,2353,2354,5,196,0,0,2354,2355,5,105,0,0,2355,157,1,0,0,0, + 2356,2357,5,137,0,0,2357,2358,5,105,0,0,2358,159,1,0,0,0,2359,2360, + 5,158,0,0,2360,2362,5,337,0,0,2361,2363,5,210,0,0,2362,2361,1,0, + 0,0,2362,2363,1,0,0,0,2363,2364,1,0,0,0,2364,2365,3,80,40,0,2365, + 2374,5,2,0,0,2366,2371,3,228,114,0,2367,2368,5,4,0,0,2368,2370,3, + 228,114,0,2369,2367,1,0,0,0,2370,2373,1,0,0,0,2371,2369,1,0,0,0, + 2371,2372,1,0,0,0,2372,2375,1,0,0,0,2373,2371,1,0,0,0,2374,2366, + 1,0,0,0,2374,2375,1,0,0,0,2375,2376,1,0,0,0,2376,2377,5,3,0,0,2377, + 2389,3,200,100,0,2378,2380,5,20,0,0,2379,2378,1,0,0,0,2379,2380, + 1,0,0,0,2380,2381,1,0,0,0,2381,2386,3,326,163,0,2382,2383,5,4,0, + 0,2383,2385,3,326,163,0,2384,2382,1,0,0,0,2385,2388,1,0,0,0,2386, + 2384,1,0,0,0,2386,2387,1,0,0,0,2387,2390,1,0,0,0,2388,2386,1,0,0, + 0,2389,2379,1,0,0,0,2389,2390,1,0,0,0,2390,161,1,0,0,0,2391,2392, + 7,31,0,0,2392,163,1,0,0,0,2393,2407,3,76,38,0,2394,2396,5,158,0, + 0,2395,2394,1,0,0,0,2395,2396,1,0,0,0,2396,2397,1,0,0,0,2397,2403, + 3,188,94,0,2398,2402,3,166,83,0,2399,2402,3,140,70,0,2400,2402,3, + 146,73,0,2401,2398,1,0,0,0,2401,2399,1,0,0,0,2401,2400,1,0,0,0,2402, + 2405,1,0,0,0,2403,2401,1,0,0,0,2403,2404,1,0,0,0,2404,2407,1,0,0, + 0,2405,2403,1,0,0,0,2406,2393,1,0,0,0,2406,2395,1,0,0,0,2407,165, + 1,0,0,0,2408,2409,3,168,84,0,2409,2411,5,155,0,0,2410,2412,5,158, + 0,0,2411,2410,1,0,0,0,2411,2412,1,0,0,0,2412,2413,1,0,0,0,2413,2415, + 3,188,94,0,2414,2416,3,170,85,0,2415,2414,1,0,0,0,2415,2416,1,0, + 0,0,2416,2426,1,0,0,0,2417,2418,5,193,0,0,2418,2419,3,168,84,0,2419, + 2421,5,155,0,0,2420,2422,5,158,0,0,2421,2420,1,0,0,0,2421,2422,1, + 0,0,0,2422,2423,1,0,0,0,2423,2424,3,188,94,0,2424,2426,1,0,0,0,2425, + 2408,1,0,0,0,2425,2417,1,0,0,0,2426,167,1,0,0,0,2427,2429,5,144, + 0,0,2428,2427,1,0,0,0,2428,2429,1,0,0,0,2429,2444,1,0,0,0,2430,2444, + 5,60,0,0,2431,2433,5,161,0,0,2432,2434,5,210,0,0,2433,2432,1,0,0, + 0,2433,2434,1,0,0,0,2434,2444,1,0,0,0,2435,2437,5,161,0,0,2436,2435, + 1,0,0,0,2436,2437,1,0,0,0,2437,2438,1,0,0,0,2438,2444,7,32,0,0,2439, + 2441,7,33,0,0,2440,2442,5,210,0,0,2441,2440,1,0,0,0,2441,2442,1, + 0,0,0,2442,2444,1,0,0,0,2443,2428,1,0,0,0,2443,2430,1,0,0,0,2443, + 2431,1,0,0,0,2443,2436,1,0,0,0,2443,2439,1,0,0,0,2444,169,1,0,0, + 0,2445,2446,5,202,0,0,2446,2450,3,236,118,0,2447,2448,5,331,0,0, + 2448,2450,3,176,88,0,2449,2445,1,0,0,0,2449,2447,1,0,0,0,2450,171, + 1,0,0,0,2451,2452,5,294,0,0,2452,2454,5,2,0,0,2453,2455,3,174,87, + 0,2454,2453,1,0,0,0,2454,2455,1,0,0,0,2455,2456,1,0,0,0,2456,2461, + 5,3,0,0,2457,2458,5,242,0,0,2458,2459,5,2,0,0,2459,2460,5,381,0, + 0,2460,2462,5,3,0,0,2461,2457,1,0,0,0,2461,2462,1,0,0,0,2462,173, + 1,0,0,0,2463,2465,5,361,0,0,2464,2463,1,0,0,0,2464,2465,1,0,0,0, + 2465,2466,1,0,0,0,2466,2467,7,34,0,0,2467,2488,5,221,0,0,2468,2469, + 3,228,114,0,2469,2470,5,257,0,0,2470,2488,1,0,0,0,2471,2472,5,29, + 0,0,2472,2473,5,381,0,0,2473,2474,5,209,0,0,2474,2475,5,200,0,0, + 2475,2484,5,381,0,0,2476,2482,5,202,0,0,2477,2483,3,326,163,0,2478, + 2479,3,320,160,0,2479,2480,5,2,0,0,2480,2481,5,3,0,0,2481,2483,1, + 0,0,0,2482,2477,1,0,0,0,2482,2478,1,0,0,0,2483,2485,1,0,0,0,2484, + 2476,1,0,0,0,2484,2485,1,0,0,0,2485,2488,1,0,0,0,2486,2488,3,228, + 114,0,2487,2464,1,0,0,0,2487,2468,1,0,0,0,2487,2471,1,0,0,0,2487, + 2486,1,0,0,0,2488,175,1,0,0,0,2489,2490,5,2,0,0,2490,2491,3,178, + 89,0,2491,2492,5,3,0,0,2492,177,1,0,0,0,2493,2498,3,322,161,0,2494, + 2495,5,4,0,0,2495,2497,3,322,161,0,2496,2494,1,0,0,0,2497,2500,1, + 0,0,0,2498,2496,1,0,0,0,2498,2499,1,0,0,0,2499,179,1,0,0,0,2500, + 2498,1,0,0,0,2501,2502,5,2,0,0,2502,2507,3,182,91,0,2503,2504,5, + 4,0,0,2504,2506,3,182,91,0,2505,2503,1,0,0,0,2506,2509,1,0,0,0,2507, + 2505,1,0,0,0,2507,2508,1,0,0,0,2508,2510,1,0,0,0,2509,2507,1,0,0, + 0,2510,2511,5,3,0,0,2511,181,1,0,0,0,2512,2514,3,322,161,0,2513, + 2515,7,25,0,0,2514,2513,1,0,0,0,2514,2515,1,0,0,0,2515,183,1,0,0, + 0,2516,2517,5,2,0,0,2517,2522,3,186,93,0,2518,2519,5,4,0,0,2519, + 2521,3,186,93,0,2520,2518,1,0,0,0,2521,2524,1,0,0,0,2522,2520,1, + 0,0,0,2522,2523,1,0,0,0,2523,2525,1,0,0,0,2524,2522,1,0,0,0,2525, + 2526,5,3,0,0,2526,185,1,0,0,0,2527,2530,3,86,43,0,2528,2529,5,51, + 0,0,2529,2531,3,334,167,0,2530,2528,1,0,0,0,2530,2531,1,0,0,0,2531, + 187,1,0,0,0,2532,2536,3,76,38,0,2533,2536,3,80,40,0,2534,2536,3, + 88,44,0,2535,2532,1,0,0,0,2535,2533,1,0,0,0,2535,2534,1,0,0,0,2536, + 2538,1,0,0,0,2537,2539,3,130,65,0,2538,2537,1,0,0,0,2538,2539,1, + 0,0,0,2539,2541,1,0,0,0,2540,2542,3,172,86,0,2541,2540,1,0,0,0,2541, + 2542,1,0,0,0,2542,2543,1,0,0,0,2543,2544,3,200,100,0,2544,2588,1, + 0,0,0,2545,2546,5,2,0,0,2546,2547,3,24,12,0,2547,2549,5,3,0,0,2548, + 2550,3,172,86,0,2549,2548,1,0,0,0,2549,2550,1,0,0,0,2550,2551,1, + 0,0,0,2551,2552,3,200,100,0,2552,2588,1,0,0,0,2553,2554,5,2,0,0, + 2554,2555,3,164,82,0,2555,2557,5,3,0,0,2556,2558,3,172,86,0,2557, + 2556,1,0,0,0,2557,2558,1,0,0,0,2558,2559,1,0,0,0,2559,2560,3,200, + 100,0,2560,2588,1,0,0,0,2561,2562,5,332,0,0,2562,2567,3,228,114, + 0,2563,2564,5,4,0,0,2564,2566,3,228,114,0,2565,2563,1,0,0,0,2566, + 2569,1,0,0,0,2567,2565,1,0,0,0,2567,2568,1,0,0,0,2568,2570,1,0,0, + 0,2569,2567,1,0,0,0,2570,2571,3,200,100,0,2571,2588,1,0,0,0,2572, + 2573,3,316,158,0,2573,2582,5,2,0,0,2574,2579,3,198,99,0,2575,2576, + 5,4,0,0,2576,2578,3,198,99,0,2577,2575,1,0,0,0,2578,2581,1,0,0,0, + 2579,2577,1,0,0,0,2579,2580,1,0,0,0,2580,2583,1,0,0,0,2581,2579, + 1,0,0,0,2582,2574,1,0,0,0,2582,2583,1,0,0,0,2583,2584,1,0,0,0,2584, + 2585,5,3,0,0,2585,2586,3,200,100,0,2586,2588,1,0,0,0,2587,2535,1, + 0,0,0,2587,2545,1,0,0,0,2587,2553,1,0,0,0,2587,2561,1,0,0,0,2587, + 2572,1,0,0,0,2588,189,1,0,0,0,2589,2590,5,292,0,0,2590,2592,3,76, + 38,0,2591,2593,3,192,96,0,2592,2591,1,0,0,0,2592,2593,1,0,0,0,2593, + 2609,1,0,0,0,2594,2595,5,292,0,0,2595,2596,5,2,0,0,2596,2597,3,76, + 38,0,2597,2599,5,3,0,0,2598,2600,3,192,96,0,2599,2598,1,0,0,0,2599, + 2600,1,0,0,0,2600,2609,1,0,0,0,2601,2602,5,292,0,0,2602,2603,5,2, + 0,0,2603,2604,3,24,12,0,2604,2606,5,3,0,0,2605,2607,3,192,96,0,2606, + 2605,1,0,0,0,2606,2607,1,0,0,0,2607,2609,1,0,0,0,2608,2589,1,0,0, + 0,2608,2594,1,0,0,0,2608,2601,1,0,0,0,2609,191,1,0,0,0,2610,2611, + 5,345,0,0,2611,2612,5,273,0,0,2612,2630,5,216,0,0,2613,2614,7,35, + 0,0,2614,2627,5,31,0,0,2615,2616,5,2,0,0,2616,2621,3,228,114,0,2617, + 2618,5,4,0,0,2618,2620,3,228,114,0,2619,2617,1,0,0,0,2620,2623,1, + 0,0,0,2621,2619,1,0,0,0,2621,2622,1,0,0,0,2622,2624,1,0,0,0,2623, + 2621,1,0,0,0,2624,2625,5,3,0,0,2625,2628,1,0,0,0,2626,2628,3,228, + 114,0,2627,2615,1,0,0,0,2627,2626,1,0,0,0,2628,2630,1,0,0,0,2629, + 2610,1,0,0,0,2629,2613,1,0,0,0,2630,2647,1,0,0,0,2631,2632,7,36, + 0,0,2632,2645,5,31,0,0,2633,2634,5,2,0,0,2634,2639,3,96,48,0,2635, + 2636,5,4,0,0,2636,2638,3,96,48,0,2637,2635,1,0,0,0,2638,2641,1,0, + 0,0,2639,2637,1,0,0,0,2639,2640,1,0,0,0,2640,2642,1,0,0,0,2641,2639, + 1,0,0,0,2642,2643,5,3,0,0,2643,2646,1,0,0,0,2644,2646,3,96,48,0, + 2645,2633,1,0,0,0,2645,2644,1,0,0,0,2646,2648,1,0,0,0,2647,2631, + 1,0,0,0,2647,2648,1,0,0,0,2648,193,1,0,0,0,2649,2650,3,326,163,0, + 2650,2651,5,372,0,0,2651,2652,3,190,95,0,2652,195,1,0,0,0,2653,2656, + 3,190,95,0,2654,2656,3,194,97,0,2655,2653,1,0,0,0,2655,2654,1,0, + 0,0,2656,197,1,0,0,0,2657,2660,3,196,98,0,2658,2660,3,232,116,0, + 2659,2657,1,0,0,0,2659,2658,1,0,0,0,2660,199,1,0,0,0,2661,2663,5, + 20,0,0,2662,2661,1,0,0,0,2662,2663,1,0,0,0,2663,2664,1,0,0,0,2664, + 2666,3,328,164,0,2665,2667,3,176,88,0,2666,2665,1,0,0,0,2666,2667, + 1,0,0,0,2667,2669,1,0,0,0,2668,2662,1,0,0,0,2668,2669,1,0,0,0,2669, + 201,1,0,0,0,2670,2671,5,256,0,0,2671,2672,5,121,0,0,2672,2673,5, + 265,0,0,2673,2677,3,334,167,0,2674,2675,5,345,0,0,2675,2676,5,266, + 0,0,2676,2678,3,48,24,0,2677,2674,1,0,0,0,2677,2678,1,0,0,0,2678, + 2720,1,0,0,0,2679,2680,5,256,0,0,2680,2681,5,121,0,0,2681,2691,5, + 85,0,0,2682,2683,5,113,0,0,2683,2684,5,298,0,0,2684,2685,5,31,0, + 0,2685,2689,3,334,167,0,2686,2687,5,101,0,0,2687,2688,5,31,0,0,2688, + 2690,3,334,167,0,2689,2686,1,0,0,0,2689,2690,1,0,0,0,2690,2692,1, + 0,0,0,2691,2682,1,0,0,0,2691,2692,1,0,0,0,2692,2698,1,0,0,0,2693, + 2694,5,48,0,0,2694,2695,5,154,0,0,2695,2696,5,298,0,0,2696,2697, + 5,31,0,0,2697,2699,3,334,167,0,2698,2693,1,0,0,0,2698,2699,1,0,0, + 0,2699,2705,1,0,0,0,2700,2701,5,176,0,0,2701,2702,5,156,0,0,2702, + 2703,5,298,0,0,2703,2704,5,31,0,0,2704,2706,3,334,167,0,2705,2700, + 1,0,0,0,2705,2706,1,0,0,0,2706,2711,1,0,0,0,2707,2708,5,166,0,0, + 2708,2709,5,298,0,0,2709,2710,5,31,0,0,2710,2712,3,334,167,0,2711, + 2707,1,0,0,0,2711,2712,1,0,0,0,2712,2717,1,0,0,0,2713,2714,5,197, + 0,0,2714,2715,5,83,0,0,2715,2716,5,20,0,0,2716,2718,3,334,167,0, + 2717,2713,1,0,0,0,2717,2718,1,0,0,0,2718,2720,1,0,0,0,2719,2670, + 1,0,0,0,2719,2679,1,0,0,0,2720,203,1,0,0,0,2721,2726,3,206,103,0, + 2722,2723,5,4,0,0,2723,2725,3,206,103,0,2724,2722,1,0,0,0,2725,2728, + 1,0,0,0,2726,2724,1,0,0,0,2726,2727,1,0,0,0,2727,205,1,0,0,0,2728, + 2726,1,0,0,0,2729,2734,3,322,161,0,2730,2731,5,5,0,0,2731,2733,3, + 322,161,0,2732,2730,1,0,0,0,2733,2736,1,0,0,0,2734,2732,1,0,0,0, + 2734,2735,1,0,0,0,2735,207,1,0,0,0,2736,2734,1,0,0,0,2737,2742,3, + 210,105,0,2738,2739,5,4,0,0,2739,2741,3,210,105,0,2740,2738,1,0, + 0,0,2741,2744,1,0,0,0,2742,2740,1,0,0,0,2742,2743,1,0,0,0,2743,209, + 1,0,0,0,2744,2742,1,0,0,0,2745,2748,3,206,103,0,2746,2747,5,206, + 0,0,2747,2749,3,48,24,0,2748,2746,1,0,0,0,2748,2749,1,0,0,0,2749, + 211,1,0,0,0,2750,2751,3,322,161,0,2751,2752,5,5,0,0,2752,2754,1, + 0,0,0,2753,2750,1,0,0,0,2753,2754,1,0,0,0,2754,2755,1,0,0,0,2755, + 2756,3,322,161,0,2756,213,1,0,0,0,2757,2758,3,322,161,0,2758,2759, + 5,5,0,0,2759,2761,1,0,0,0,2760,2757,1,0,0,0,2760,2761,1,0,0,0,2761, + 2762,1,0,0,0,2762,2763,3,322,161,0,2763,215,1,0,0,0,2764,2767,3, + 82,41,0,2765,2767,3,228,114,0,2766,2764,1,0,0,0,2766,2765,1,0,0, + 0,2767,2775,1,0,0,0,2768,2770,5,20,0,0,2769,2768,1,0,0,0,2769,2770, + 1,0,0,0,2770,2773,1,0,0,0,2771,2774,3,322,161,0,2772,2774,3,176, + 88,0,2773,2771,1,0,0,0,2773,2772,1,0,0,0,2774,2776,1,0,0,0,2775, + 2769,1,0,0,0,2775,2776,1,0,0,0,2776,217,1,0,0,0,2777,2782,3,216, + 108,0,2778,2779,5,4,0,0,2779,2781,3,216,108,0,2780,2778,1,0,0,0, + 2781,2784,1,0,0,0,2782,2780,1,0,0,0,2782,2783,1,0,0,0,2783,219,1, + 0,0,0,2784,2782,1,0,0,0,2785,2786,5,2,0,0,2786,2791,3,222,111,0, + 2787,2788,5,4,0,0,2788,2790,3,222,111,0,2789,2787,1,0,0,0,2790,2793, + 1,0,0,0,2791,2789,1,0,0,0,2791,2792,1,0,0,0,2792,2794,1,0,0,0,2793, + 2791,1,0,0,0,2794,2795,5,3,0,0,2795,221,1,0,0,0,2796,2799,3,224, + 112,0,2797,2799,3,294,147,0,2798,2796,1,0,0,0,2798,2797,1,0,0,0, + 2799,223,1,0,0,0,2800,2814,3,320,160,0,2801,2802,3,326,163,0,2802, + 2803,5,2,0,0,2803,2808,3,226,113,0,2804,2805,5,4,0,0,2805,2807,3, + 226,113,0,2806,2804,1,0,0,0,2807,2810,1,0,0,0,2808,2806,1,0,0,0, + 2808,2809,1,0,0,0,2809,2811,1,0,0,0,2810,2808,1,0,0,0,2811,2812, + 5,3,0,0,2812,2814,1,0,0,0,2813,2800,1,0,0,0,2813,2801,1,0,0,0,2814, + 225,1,0,0,0,2815,2818,3,320,160,0,2816,2818,3,248,124,0,2817,2815, + 1,0,0,0,2817,2816,1,0,0,0,2818,227,1,0,0,0,2819,2820,3,236,118,0, + 2820,229,1,0,0,0,2821,2822,3,326,163,0,2822,2823,5,372,0,0,2823, + 2824,3,228,114,0,2824,231,1,0,0,0,2825,2828,3,228,114,0,2826,2828, + 3,230,115,0,2827,2825,1,0,0,0,2827,2826,1,0,0,0,2828,233,1,0,0,0, + 2829,2834,3,228,114,0,2830,2831,5,4,0,0,2831,2833,3,228,114,0,2832, + 2830,1,0,0,0,2833,2836,1,0,0,0,2834,2832,1,0,0,0,2834,2835,1,0,0, + 0,2835,235,1,0,0,0,2836,2834,1,0,0,0,2837,2838,6,118,-1,0,2838,2839, + 7,37,0,0,2839,2850,3,236,118,5,2840,2841,5,105,0,0,2841,2842,5,2, + 0,0,2842,2843,3,24,12,0,2843,2844,5,3,0,0,2844,2850,1,0,0,0,2845, + 2847,3,240,120,0,2846,2848,3,238,119,0,2847,2846,1,0,0,0,2847,2848, + 1,0,0,0,2848,2850,1,0,0,0,2849,2837,1,0,0,0,2849,2840,1,0,0,0,2849, + 2845,1,0,0,0,2850,2859,1,0,0,0,2851,2852,10,2,0,0,2852,2853,5,14, + 0,0,2853,2858,3,236,118,3,2854,2855,10,1,0,0,2855,2856,5,207,0,0, + 2856,2858,3,236,118,2,2857,2851,1,0,0,0,2857,2854,1,0,0,0,2858,2861, + 1,0,0,0,2859,2857,1,0,0,0,2859,2860,1,0,0,0,2860,237,1,0,0,0,2861, + 2859,1,0,0,0,2862,2864,5,196,0,0,2863,2862,1,0,0,0,2863,2864,1,0, + 0,0,2864,2865,1,0,0,0,2865,2866,5,24,0,0,2866,2867,3,240,120,0,2867, + 2868,5,14,0,0,2868,2869,3,240,120,0,2869,2945,1,0,0,0,2870,2872, + 5,196,0,0,2871,2870,1,0,0,0,2871,2872,1,0,0,0,2872,2873,1,0,0,0, + 2873,2874,5,140,0,0,2874,2875,5,2,0,0,2875,2880,3,228,114,0,2876, + 2877,5,4,0,0,2877,2879,3,228,114,0,2878,2876,1,0,0,0,2879,2882,1, + 0,0,0,2880,2878,1,0,0,0,2880,2881,1,0,0,0,2881,2883,1,0,0,0,2882, + 2880,1,0,0,0,2883,2884,5,3,0,0,2884,2945,1,0,0,0,2885,2887,5,196, + 0,0,2886,2885,1,0,0,0,2886,2887,1,0,0,0,2887,2888,1,0,0,0,2888,2889, + 5,140,0,0,2889,2890,5,2,0,0,2890,2891,3,24,12,0,2891,2892,5,3,0, + 0,2892,2945,1,0,0,0,2893,2895,5,196,0,0,2894,2893,1,0,0,0,2894,2895, + 1,0,0,0,2895,2896,1,0,0,0,2896,2897,7,38,0,0,2897,2945,3,240,120, + 0,2898,2900,5,196,0,0,2899,2898,1,0,0,0,2899,2900,1,0,0,0,2900,2901, + 1,0,0,0,2901,2902,7,39,0,0,2902,2916,7,40,0,0,2903,2904,5,2,0,0, + 2904,2917,5,3,0,0,2905,2906,5,2,0,0,2906,2911,3,228,114,0,2907,2908, + 5,4,0,0,2908,2910,3,228,114,0,2909,2907,1,0,0,0,2910,2913,1,0,0, + 0,2911,2909,1,0,0,0,2911,2912,1,0,0,0,2912,2914,1,0,0,0,2913,2911, + 1,0,0,0,2914,2915,5,3,0,0,2915,2917,1,0,0,0,2916,2903,1,0,0,0,2916, + 2905,1,0,0,0,2917,2945,1,0,0,0,2918,2920,5,196,0,0,2919,2918,1,0, + 0,0,2919,2920,1,0,0,0,2920,2921,1,0,0,0,2921,2922,7,39,0,0,2922, + 2925,3,240,120,0,2923,2924,5,100,0,0,2924,2926,3,334,167,0,2925, + 2923,1,0,0,0,2925,2926,1,0,0,0,2926,2945,1,0,0,0,2927,2929,5,153, + 0,0,2928,2930,5,196,0,0,2929,2928,1,0,0,0,2929,2930,1,0,0,0,2930, + 2931,1,0,0,0,2931,2945,5,197,0,0,2932,2934,5,153,0,0,2933,2935,5, + 196,0,0,2934,2933,1,0,0,0,2934,2935,1,0,0,0,2935,2936,1,0,0,0,2936, + 2945,7,41,0,0,2937,2939,5,153,0,0,2938,2940,5,196,0,0,2939,2938, + 1,0,0,0,2939,2940,1,0,0,0,2940,2941,1,0,0,0,2941,2942,5,92,0,0,2942, + 2943,5,123,0,0,2943,2945,3,240,120,0,2944,2863,1,0,0,0,2944,2871, + 1,0,0,0,2944,2886,1,0,0,0,2944,2894,1,0,0,0,2944,2899,1,0,0,0,2944, + 2919,1,0,0,0,2944,2927,1,0,0,0,2944,2932,1,0,0,0,2944,2937,1,0,0, + 0,2945,239,1,0,0,0,2946,2947,6,120,-1,0,2947,2951,3,244,122,0,2948, + 2949,7,42,0,0,2949,2951,3,240,120,7,2950,2946,1,0,0,0,2950,2948, + 1,0,0,0,2951,2973,1,0,0,0,2952,2953,10,6,0,0,2953,2954,7,43,0,0, + 2954,2972,3,240,120,7,2955,2956,10,5,0,0,2956,2957,7,44,0,0,2957, + 2972,3,240,120,6,2958,2959,10,4,0,0,2959,2960,5,366,0,0,2960,2972, + 3,240,120,5,2961,2962,10,3,0,0,2962,2963,5,369,0,0,2963,2972,3,240, + 120,4,2964,2965,10,2,0,0,2965,2966,5,367,0,0,2966,2972,3,240,120, + 3,2967,2968,10,1,0,0,2968,2969,3,250,125,0,2969,2970,3,240,120,2, + 2970,2972,1,0,0,0,2971,2952,1,0,0,0,2971,2955,1,0,0,0,2971,2958, + 1,0,0,0,2971,2961,1,0,0,0,2971,2964,1,0,0,0,2971,2967,1,0,0,0,2972, + 2975,1,0,0,0,2973,2971,1,0,0,0,2973,2974,1,0,0,0,2974,241,1,0,0, + 0,2975,2973,1,0,0,0,2976,2977,7,45,0,0,2977,243,1,0,0,0,2978,2979, + 6,122,-1,0,2979,3228,7,46,0,0,2980,2981,7,47,0,0,2981,2984,5,2,0, + 0,2982,2985,3,242,121,0,2983,2985,3,334,167,0,2984,2982,1,0,0,0, + 2984,2983,1,0,0,0,2985,2986,1,0,0,0,2986,2987,5,4,0,0,2987,2988, + 3,240,120,0,2988,2989,5,4,0,0,2989,2990,3,240,120,0,2990,2991,5, + 3,0,0,2991,3228,1,0,0,0,2992,2993,7,48,0,0,2993,2996,5,2,0,0,2994, + 2997,3,242,121,0,2995,2997,3,334,167,0,2996,2994,1,0,0,0,2996,2995, + 1,0,0,0,2997,2998,1,0,0,0,2998,2999,5,4,0,0,2999,3000,3,240,120, + 0,3000,3001,5,4,0,0,3001,3002,3,240,120,0,3002,3003,5,3,0,0,3003, + 3228,1,0,0,0,3004,3006,5,35,0,0,3005,3007,3,304,152,0,3006,3005, + 1,0,0,0,3007,3008,1,0,0,0,3008,3006,1,0,0,0,3008,3009,1,0,0,0,3009, + 3012,1,0,0,0,3010,3011,5,97,0,0,3011,3013,3,228,114,0,3012,3010, + 1,0,0,0,3012,3013,1,0,0,0,3013,3014,1,0,0,0,3014,3015,5,99,0,0,3015, + 3228,1,0,0,0,3016,3017,5,35,0,0,3017,3019,3,228,114,0,3018,3020, + 3,304,152,0,3019,3018,1,0,0,0,3020,3021,1,0,0,0,3021,3019,1,0,0, + 0,3021,3022,1,0,0,0,3022,3025,1,0,0,0,3023,3024,5,97,0,0,3024,3026, + 3,228,114,0,3025,3023,1,0,0,0,3025,3026,1,0,0,0,3026,3027,1,0,0, + 0,3027,3028,5,99,0,0,3028,3228,1,0,0,0,3029,3030,7,49,0,0,3030,3031, + 5,2,0,0,3031,3032,3,228,114,0,3032,3033,5,20,0,0,3033,3034,3,278, + 139,0,3034,3035,5,3,0,0,3035,3228,1,0,0,0,3036,3037,5,285,0,0,3037, + 3046,5,2,0,0,3038,3043,3,216,108,0,3039,3040,5,4,0,0,3040,3042,3, + 216,108,0,3041,3039,1,0,0,0,3042,3045,1,0,0,0,3043,3041,1,0,0,0, + 3043,3044,1,0,0,0,3044,3047,1,0,0,0,3045,3043,1,0,0,0,3046,3038, + 1,0,0,0,3046,3047,1,0,0,0,3047,3048,1,0,0,0,3048,3228,5,3,0,0,3049, + 3050,5,116,0,0,3050,3051,5,2,0,0,3051,3054,3,228,114,0,3052,3053, + 5,138,0,0,3053,3055,5,198,0,0,3054,3052,1,0,0,0,3054,3055,1,0,0, + 0,3055,3056,1,0,0,0,3056,3057,5,3,0,0,3057,3228,1,0,0,0,3058,3059, + 5,17,0,0,3059,3060,5,2,0,0,3060,3063,3,228,114,0,3061,3062,5,138, + 0,0,3062,3064,5,198,0,0,3063,3061,1,0,0,0,3063,3064,1,0,0,0,3064, + 3065,1,0,0,0,3065,3066,5,3,0,0,3066,3228,1,0,0,0,3067,3068,5,157, + 0,0,3068,3069,5,2,0,0,3069,3072,3,228,114,0,3070,3071,5,138,0,0, + 3071,3073,5,198,0,0,3072,3070,1,0,0,0,3072,3073,1,0,0,0,3073,3074, + 1,0,0,0,3074,3075,5,3,0,0,3075,3228,1,0,0,0,3076,3077,5,224,0,0, + 3077,3078,5,2,0,0,3078,3079,3,240,120,0,3079,3080,5,140,0,0,3080, + 3081,3,240,120,0,3081,3082,5,3,0,0,3082,3228,1,0,0,0,3083,3228,3, + 248,124,0,3084,3228,5,362,0,0,3085,3086,3,320,160,0,3086,3087,5, + 5,0,0,3087,3088,5,362,0,0,3088,3228,1,0,0,0,3089,3090,5,2,0,0,3090, + 3093,3,216,108,0,3091,3092,5,4,0,0,3092,3094,3,216,108,0,3093,3091, + 1,0,0,0,3094,3095,1,0,0,0,3095,3093,1,0,0,0,3095,3096,1,0,0,0,3096, + 3097,1,0,0,0,3097,3098,5,3,0,0,3098,3228,1,0,0,0,3099,3100,5,2,0, + 0,3100,3101,3,24,12,0,3101,3102,5,3,0,0,3102,3228,1,0,0,0,3103,3104, + 5,136,0,0,3104,3105,5,2,0,0,3105,3106,3,228,114,0,3106,3107,5,3, + 0,0,3107,3228,1,0,0,0,3108,3109,3,316,158,0,3109,3121,5,2,0,0,3110, + 3112,3,162,81,0,3111,3110,1,0,0,0,3111,3112,1,0,0,0,3112,3113,1, + 0,0,0,3113,3118,3,232,116,0,3114,3115,5,4,0,0,3115,3117,3,232,116, + 0,3116,3114,1,0,0,0,3117,3120,1,0,0,0,3118,3116,1,0,0,0,3118,3119, + 1,0,0,0,3119,3122,1,0,0,0,3120,3118,1,0,0,0,3121,3111,1,0,0,0,3121, + 3122,1,0,0,0,3122,3123,1,0,0,0,3123,3130,5,3,0,0,3124,3125,5,114, + 0,0,3125,3126,5,2,0,0,3126,3127,5,343,0,0,3127,3128,3,236,118,0, + 3128,3129,5,3,0,0,3129,3131,1,0,0,0,3130,3124,1,0,0,0,3130,3131, + 1,0,0,0,3131,3134,1,0,0,0,3132,3133,7,50,0,0,3133,3135,5,198,0,0, + 3134,3132,1,0,0,0,3134,3135,1,0,0,0,3135,3138,1,0,0,0,3136,3137, + 5,212,0,0,3137,3139,3,308,154,0,3138,3136,1,0,0,0,3138,3139,1,0, + 0,0,3139,3228,1,0,0,0,3140,3141,3,326,163,0,3141,3142,5,371,0,0, + 3142,3143,3,228,114,0,3143,3228,1,0,0,0,3144,3145,5,2,0,0,3145,3148, + 3,326,163,0,3146,3147,5,4,0,0,3147,3149,3,326,163,0,3148,3146,1, + 0,0,0,3149,3150,1,0,0,0,3150,3148,1,0,0,0,3150,3151,1,0,0,0,3151, + 3152,1,0,0,0,3152,3153,5,3,0,0,3153,3154,5,371,0,0,3154,3155,3,228, + 114,0,3155,3228,1,0,0,0,3156,3228,3,326,163,0,3157,3158,5,2,0,0, + 3158,3159,3,228,114,0,3159,3160,5,3,0,0,3160,3228,1,0,0,0,3161,3162, + 5,110,0,0,3162,3163,5,2,0,0,3163,3164,3,326,163,0,3164,3165,5,123, + 0,0,3165,3166,3,240,120,0,3166,3167,5,3,0,0,3167,3228,1,0,0,0,3168, + 3169,7,51,0,0,3169,3170,5,2,0,0,3170,3171,3,240,120,0,3171,3172, + 7,52,0,0,3172,3175,3,240,120,0,3173,3174,7,53,0,0,3174,3176,3,240, + 120,0,3175,3173,1,0,0,0,3175,3176,1,0,0,0,3176,3177,1,0,0,0,3177, + 3178,5,3,0,0,3178,3228,1,0,0,0,3179,3180,5,314,0,0,3180,3182,5,2, + 0,0,3181,3183,7,54,0,0,3182,3181,1,0,0,0,3182,3183,1,0,0,0,3183, + 3185,1,0,0,0,3184,3186,3,240,120,0,3185,3184,1,0,0,0,3185,3186,1, + 0,0,0,3186,3187,1,0,0,0,3187,3188,5,123,0,0,3188,3189,3,240,120, + 0,3189,3190,5,3,0,0,3190,3228,1,0,0,0,3191,3192,5,214,0,0,3192,3193, + 5,2,0,0,3193,3194,3,240,120,0,3194,3195,5,223,0,0,3195,3196,3,240, + 120,0,3196,3197,5,123,0,0,3197,3200,3,240,120,0,3198,3199,5,119, + 0,0,3199,3201,3,240,120,0,3200,3198,1,0,0,0,3200,3201,1,0,0,0,3201, + 3202,1,0,0,0,3202,3203,5,3,0,0,3203,3228,1,0,0,0,3204,3205,7,55, + 0,0,3205,3206,5,2,0,0,3206,3207,3,240,120,0,3207,3208,5,3,0,0,3208, + 3209,5,346,0,0,3209,3210,5,130,0,0,3210,3211,5,2,0,0,3211,3212,5, + 208,0,0,3212,3213,5,31,0,0,3213,3214,3,96,48,0,3214,3221,5,3,0,0, + 3215,3216,5,114,0,0,3216,3217,5,2,0,0,3217,3218,5,343,0,0,3218,3219, + 3,236,118,0,3219,3220,5,3,0,0,3220,3222,1,0,0,0,3221,3215,1,0,0, + 0,3221,3222,1,0,0,0,3222,3225,1,0,0,0,3223,3224,5,212,0,0,3224,3226, + 3,308,154,0,3225,3223,1,0,0,0,3225,3226,1,0,0,0,3226,3228,1,0,0, + 0,3227,2978,1,0,0,0,3227,2980,1,0,0,0,3227,2992,1,0,0,0,3227,3004, + 1,0,0,0,3227,3016,1,0,0,0,3227,3029,1,0,0,0,3227,3036,1,0,0,0,3227, + 3049,1,0,0,0,3227,3058,1,0,0,0,3227,3067,1,0,0,0,3227,3076,1,0,0, + 0,3227,3083,1,0,0,0,3227,3084,1,0,0,0,3227,3085,1,0,0,0,3227,3089, + 1,0,0,0,3227,3099,1,0,0,0,3227,3103,1,0,0,0,3227,3108,1,0,0,0,3227, + 3140,1,0,0,0,3227,3144,1,0,0,0,3227,3156,1,0,0,0,3227,3157,1,0,0, + 0,3227,3161,1,0,0,0,3227,3168,1,0,0,0,3227,3179,1,0,0,0,3227,3191, + 1,0,0,0,3227,3204,1,0,0,0,3228,3239,1,0,0,0,3229,3230,10,9,0,0,3230, + 3231,5,6,0,0,3231,3232,3,240,120,0,3232,3233,5,7,0,0,3233,3238,1, + 0,0,0,3234,3235,10,7,0,0,3235,3236,5,5,0,0,3236,3238,3,326,163,0, + 3237,3229,1,0,0,0,3237,3234,1,0,0,0,3238,3241,1,0,0,0,3239,3237, + 1,0,0,0,3239,3240,1,0,0,0,3240,245,1,0,0,0,3241,3239,1,0,0,0,3242, + 3250,5,71,0,0,3243,3250,5,302,0,0,3244,3250,5,303,0,0,3245,3250, + 5,304,0,0,3246,3250,5,149,0,0,3247,3250,5,133,0,0,3248,3250,3,326, + 163,0,3249,3242,1,0,0,0,3249,3243,1,0,0,0,3249,3244,1,0,0,0,3249, + 3245,1,0,0,0,3249,3246,1,0,0,0,3249,3247,1,0,0,0,3249,3248,1,0,0, + 0,3250,247,1,0,0,0,3251,3267,5,197,0,0,3252,3267,5,375,0,0,3253, + 3254,5,370,0,0,3254,3267,3,326,163,0,3255,3267,3,258,129,0,3256, + 3257,3,246,123,0,3257,3258,3,334,167,0,3258,3267,1,0,0,0,3259,3267, + 3,330,165,0,3260,3267,3,256,128,0,3261,3263,3,334,167,0,3262,3261, + 1,0,0,0,3263,3264,1,0,0,0,3264,3262,1,0,0,0,3264,3265,1,0,0,0,3265, + 3267,1,0,0,0,3266,3251,1,0,0,0,3266,3252,1,0,0,0,3266,3253,1,0,0, + 0,3266,3255,1,0,0,0,3266,3256,1,0,0,0,3266,3259,1,0,0,0,3266,3260, + 1,0,0,0,3266,3262,1,0,0,0,3267,249,1,0,0,0,3268,3269,7,56,0,0,3269, + 251,1,0,0,0,3270,3271,7,57,0,0,3271,253,1,0,0,0,3272,3273,7,58,0, + 0,3273,255,1,0,0,0,3274,3275,7,59,0,0,3275,257,1,0,0,0,3276,3279, + 5,149,0,0,3277,3280,3,260,130,0,3278,3280,3,262,131,0,3279,3277, + 1,0,0,0,3279,3278,1,0,0,0,3280,259,1,0,0,0,3281,3283,3,264,132,0, + 3282,3284,3,266,133,0,3283,3282,1,0,0,0,3283,3284,1,0,0,0,3284,261, + 1,0,0,0,3285,3288,3,266,133,0,3286,3289,3,264,132,0,3287,3289,3, + 266,133,0,3288,3286,1,0,0,0,3288,3287,1,0,0,0,3288,3289,1,0,0,0, + 3289,263,1,0,0,0,3290,3291,3,268,134,0,3291,3292,3,270,135,0,3292, + 3294,1,0,0,0,3293,3290,1,0,0,0,3294,3295,1,0,0,0,3295,3293,1,0,0, + 0,3295,3296,1,0,0,0,3296,265,1,0,0,0,3297,3298,3,268,134,0,3298, + 3299,3,272,136,0,3299,3300,5,308,0,0,3300,3301,3,272,136,0,3301, + 267,1,0,0,0,3302,3304,7,60,0,0,3303,3302,1,0,0,0,3303,3304,1,0,0, + 0,3304,3308,1,0,0,0,3305,3309,5,381,0,0,3306,3309,5,383,0,0,3307, + 3309,3,334,167,0,3308,3305,1,0,0,0,3308,3306,1,0,0,0,3308,3307,1, + 0,0,0,3309,269,1,0,0,0,3310,3311,7,61,0,0,3311,271,1,0,0,0,3312, + 3313,7,62,0,0,3313,273,1,0,0,0,3314,3318,5,116,0,0,3315,3316,5,9, + 0,0,3316,3318,3,322,161,0,3317,3314,1,0,0,0,3317,3315,1,0,0,0,3318, + 275,1,0,0,0,3319,3350,5,27,0,0,3320,3350,5,307,0,0,3321,3350,5,32, + 0,0,3322,3350,5,275,0,0,3323,3350,5,271,0,0,3324,3350,5,150,0,0, + 3325,3350,5,151,0,0,3326,3350,5,25,0,0,3327,3350,5,174,0,0,3328, + 3350,5,117,0,0,3329,3350,5,233,0,0,3330,3350,5,95,0,0,3331,3350, + 5,71,0,0,3332,3350,5,302,0,0,3333,3350,5,304,0,0,3334,3350,5,303, + 0,0,3335,3350,5,284,0,0,3336,3350,5,41,0,0,3337,3350,5,40,0,0,3338, + 3350,5,333,0,0,3339,3350,5,26,0,0,3340,3350,5,80,0,0,3341,3350,5, + 79,0,0,3342,3350,5,199,0,0,3343,3350,5,339,0,0,3344,3350,5,149,0, + 0,3345,3350,5,19,0,0,3346,3350,5,285,0,0,3347,3350,5,176,0,0,3348, + 3350,3,326,163,0,3349,3319,1,0,0,0,3349,3320,1,0,0,0,3349,3321,1, + 0,0,0,3349,3322,1,0,0,0,3349,3323,1,0,0,0,3349,3324,1,0,0,0,3349, + 3325,1,0,0,0,3349,3326,1,0,0,0,3349,3327,1,0,0,0,3349,3328,1,0,0, + 0,3349,3329,1,0,0,0,3349,3330,1,0,0,0,3349,3331,1,0,0,0,3349,3332, + 1,0,0,0,3349,3333,1,0,0,0,3349,3334,1,0,0,0,3349,3335,1,0,0,0,3349, + 3336,1,0,0,0,3349,3337,1,0,0,0,3349,3338,1,0,0,0,3349,3339,1,0,0, + 0,3349,3340,1,0,0,0,3349,3341,1,0,0,0,3349,3342,1,0,0,0,3349,3343, + 1,0,0,0,3349,3344,1,0,0,0,3349,3345,1,0,0,0,3349,3346,1,0,0,0,3349, + 3347,1,0,0,0,3349,3348,1,0,0,0,3350,277,1,0,0,0,3351,3352,5,19,0, + 0,3352,3353,5,355,0,0,3353,3354,3,278,139,0,3354,3355,5,357,0,0, + 3355,3405,1,0,0,0,3356,3357,5,176,0,0,3357,3358,5,355,0,0,3358,3359, + 3,278,139,0,3359,3360,5,4,0,0,3360,3361,3,278,139,0,3361,3362,5, + 357,0,0,3362,3405,1,0,0,0,3363,3377,5,285,0,0,3364,3373,5,355,0, + 0,3365,3370,3,302,151,0,3366,3367,5,4,0,0,3367,3369,3,302,151,0, + 3368,3366,1,0,0,0,3369,3372,1,0,0,0,3370,3368,1,0,0,0,3370,3371, + 1,0,0,0,3371,3374,1,0,0,0,3372,3370,1,0,0,0,3373,3365,1,0,0,0,3373, + 3374,1,0,0,0,3374,3375,1,0,0,0,3375,3378,5,357,0,0,3376,3378,5,353, + 0,0,3377,3364,1,0,0,0,3377,3376,1,0,0,0,3378,3405,1,0,0,0,3379,3380, + 5,149,0,0,3380,3383,7,63,0,0,3381,3382,5,308,0,0,3382,3384,5,185, + 0,0,3383,3381,1,0,0,0,3383,3384,1,0,0,0,3384,3405,1,0,0,0,3385,3386, + 5,149,0,0,3386,3389,7,64,0,0,3387,3388,5,308,0,0,3388,3390,7,65, + 0,0,3389,3387,1,0,0,0,3389,3390,1,0,0,0,3390,3405,1,0,0,0,3391,3402, + 3,276,138,0,3392,3393,5,2,0,0,3393,3398,5,381,0,0,3394,3395,5,4, + 0,0,3395,3397,5,381,0,0,3396,3394,1,0,0,0,3397,3400,1,0,0,0,3398, + 3396,1,0,0,0,3398,3399,1,0,0,0,3399,3401,1,0,0,0,3400,3398,1,0,0, + 0,3401,3403,5,3,0,0,3402,3392,1,0,0,0,3402,3403,1,0,0,0,3403,3405, + 1,0,0,0,3404,3351,1,0,0,0,3404,3356,1,0,0,0,3404,3363,1,0,0,0,3404, + 3379,1,0,0,0,3404,3385,1,0,0,0,3404,3391,1,0,0,0,3405,279,1,0,0, + 0,3406,3411,3,282,141,0,3407,3408,5,4,0,0,3408,3410,3,282,141,0, + 3409,3407,1,0,0,0,3410,3413,1,0,0,0,3411,3409,1,0,0,0,3411,3412, + 1,0,0,0,3412,281,1,0,0,0,3413,3411,1,0,0,0,3414,3415,3,86,43,0,3415, + 3419,3,278,139,0,3416,3418,3,288,144,0,3417,3416,1,0,0,0,3418,3421, + 1,0,0,0,3419,3417,1,0,0,0,3419,3420,1,0,0,0,3420,283,1,0,0,0,3421, + 3419,1,0,0,0,3422,3427,3,286,143,0,3423,3424,5,4,0,0,3424,3426,3, + 286,143,0,3425,3423,1,0,0,0,3426,3429,1,0,0,0,3427,3425,1,0,0,0, + 3427,3428,1,0,0,0,3428,285,1,0,0,0,3429,3427,1,0,0,0,3430,3431,3, + 82,41,0,3431,3435,3,278,139,0,3432,3434,3,288,144,0,3433,3432,1, + 0,0,0,3434,3437,1,0,0,0,3435,3433,1,0,0,0,3435,3436,1,0,0,0,3436, + 287,1,0,0,0,3437,3435,1,0,0,0,3438,3439,5,196,0,0,3439,3446,5,197, + 0,0,3440,3441,5,82,0,0,3441,3446,3,228,114,0,3442,3443,5,51,0,0, + 3443,3446,3,334,167,0,3444,3446,3,274,137,0,3445,3438,1,0,0,0,3445, + 3440,1,0,0,0,3445,3442,1,0,0,0,3445,3444,1,0,0,0,3446,289,1,0,0, + 0,3447,3448,7,66,0,0,3448,3449,3,228,114,0,3449,291,1,0,0,0,3450, + 3455,3,294,147,0,3451,3452,5,4,0,0,3452,3454,3,294,147,0,3453,3451, + 1,0,0,0,3454,3457,1,0,0,0,3455,3453,1,0,0,0,3455,3456,1,0,0,0,3456, + 293,1,0,0,0,3457,3455,1,0,0,0,3458,3459,3,322,161,0,3459,3462,3, + 278,139,0,3460,3461,5,196,0,0,3461,3463,5,197,0,0,3462,3460,1,0, + 0,0,3462,3463,1,0,0,0,3463,3466,1,0,0,0,3464,3465,5,51,0,0,3465, + 3467,3,334,167,0,3466,3464,1,0,0,0,3466,3467,1,0,0,0,3467,295,1, + 0,0,0,3468,3473,3,298,149,0,3469,3470,5,4,0,0,3470,3472,3,298,149, + 0,3471,3469,1,0,0,0,3472,3475,1,0,0,0,3473,3471,1,0,0,0,3473,3474, + 1,0,0,0,3474,297,1,0,0,0,3475,3473,1,0,0,0,3476,3477,3,86,43,0,3477, + 3481,3,278,139,0,3478,3480,3,300,150,0,3479,3478,1,0,0,0,3480,3483, + 1,0,0,0,3481,3479,1,0,0,0,3481,3482,1,0,0,0,3482,299,1,0,0,0,3483, + 3481,1,0,0,0,3484,3485,5,196,0,0,3485,3498,5,197,0,0,3486,3487,5, + 82,0,0,3487,3498,3,228,114,0,3488,3489,5,127,0,0,3489,3490,5,12, + 0,0,3490,3491,5,20,0,0,3491,3492,5,2,0,0,3492,3493,3,228,114,0,3493, + 3494,5,3,0,0,3494,3498,1,0,0,0,3495,3496,5,51,0,0,3496,3498,3,334, + 167,0,3497,3484,1,0,0,0,3497,3486,1,0,0,0,3497,3488,1,0,0,0,3497, + 3495,1,0,0,0,3498,301,1,0,0,0,3499,3501,3,326,163,0,3500,3502,5, + 370,0,0,3501,3500,1,0,0,0,3501,3502,1,0,0,0,3502,3503,1,0,0,0,3503, + 3506,3,278,139,0,3504,3505,5,196,0,0,3505,3507,5,197,0,0,3506,3504, + 1,0,0,0,3506,3507,1,0,0,0,3507,3510,1,0,0,0,3508,3509,5,51,0,0,3509, + 3511,3,334,167,0,3510,3508,1,0,0,0,3510,3511,1,0,0,0,3511,303,1, + 0,0,0,3512,3513,5,342,0,0,3513,3514,3,228,114,0,3514,3515,5,299, + 0,0,3515,3516,3,228,114,0,3516,305,1,0,0,0,3517,3518,5,344,0,0,3518, + 3519,3,322,161,0,3519,3520,5,20,0,0,3520,3528,3,308,154,0,3521,3522, + 5,4,0,0,3522,3523,3,322,161,0,3523,3524,5,20,0,0,3524,3525,3,308, + 154,0,3525,3527,1,0,0,0,3526,3521,1,0,0,0,3527,3530,1,0,0,0,3528, + 3526,1,0,0,0,3528,3529,1,0,0,0,3529,307,1,0,0,0,3530,3528,1,0,0, + 0,3531,3578,3,322,161,0,3532,3533,5,2,0,0,3533,3534,3,322,161,0, + 3534,3535,5,3,0,0,3535,3578,1,0,0,0,3536,3571,5,2,0,0,3537,3538, + 5,44,0,0,3538,3539,5,31,0,0,3539,3544,3,228,114,0,3540,3541,5,4, + 0,0,3541,3543,3,228,114,0,3542,3540,1,0,0,0,3543,3546,1,0,0,0,3544, + 3542,1,0,0,0,3544,3545,1,0,0,0,3545,3572,1,0,0,0,3546,3544,1,0,0, + 0,3547,3548,7,35,0,0,3548,3549,5,31,0,0,3549,3554,3,228,114,0,3550, + 3551,5,4,0,0,3551,3553,3,228,114,0,3552,3550,1,0,0,0,3553,3556,1, + 0,0,0,3554,3552,1,0,0,0,3554,3555,1,0,0,0,3555,3558,1,0,0,0,3556, + 3554,1,0,0,0,3557,3547,1,0,0,0,3557,3558,1,0,0,0,3558,3569,1,0,0, + 0,3559,3560,7,36,0,0,3560,3561,5,31,0,0,3561,3566,3,96,48,0,3562, + 3563,5,4,0,0,3563,3565,3,96,48,0,3564,3562,1,0,0,0,3565,3568,1,0, + 0,0,3566,3564,1,0,0,0,3566,3567,1,0,0,0,3567,3570,1,0,0,0,3568,3566, + 1,0,0,0,3569,3559,1,0,0,0,3569,3570,1,0,0,0,3570,3572,1,0,0,0,3571, + 3537,1,0,0,0,3571,3557,1,0,0,0,3572,3574,1,0,0,0,3573,3575,3,310, + 155,0,3574,3573,1,0,0,0,3574,3575,1,0,0,0,3575,3576,1,0,0,0,3576, + 3578,5,3,0,0,3577,3531,1,0,0,0,3577,3532,1,0,0,0,3577,3536,1,0,0, + 0,3578,309,1,0,0,0,3579,3580,7,67,0,0,3580,3588,3,312,156,0,3581, + 3582,7,67,0,0,3582,3583,5,24,0,0,3583,3584,3,312,156,0,3584,3585, + 5,14,0,0,3585,3586,3,312,156,0,3586,3588,1,0,0,0,3587,3579,1,0,0, + 0,3587,3581,1,0,0,0,3588,311,1,0,0,0,3589,3590,5,320,0,0,3590,3597, + 7,68,0,0,3591,3592,5,62,0,0,3592,3597,5,256,0,0,3593,3594,3,228, + 114,0,3594,3595,7,68,0,0,3595,3597,1,0,0,0,3596,3589,1,0,0,0,3596, + 3591,1,0,0,0,3596,3593,1,0,0,0,3597,313,1,0,0,0,3598,3603,3,320, + 160,0,3599,3600,5,4,0,0,3600,3602,3,320,160,0,3601,3599,1,0,0,0, + 3602,3605,1,0,0,0,3603,3601,1,0,0,0,3603,3604,1,0,0,0,3604,315,1, + 0,0,0,3605,3603,1,0,0,0,3606,3607,5,136,0,0,3607,3608,5,2,0,0,3608, + 3609,3,228,114,0,3609,3610,5,3,0,0,3610,3616,1,0,0,0,3611,3616,3, + 320,160,0,3612,3616,5,114,0,0,3613,3616,5,161,0,0,3614,3616,5,249, + 0,0,3615,3606,1,0,0,0,3615,3611,1,0,0,0,3615,3612,1,0,0,0,3615,3613, + 1,0,0,0,3615,3614,1,0,0,0,3616,317,1,0,0,0,3617,3618,3,320,160,0, + 3618,319,1,0,0,0,3619,3624,3,326,163,0,3620,3621,5,5,0,0,3621,3623, + 3,326,163,0,3622,3620,1,0,0,0,3623,3626,1,0,0,0,3624,3622,1,0,0, + 0,3624,3625,1,0,0,0,3625,321,1,0,0,0,3626,3624,1,0,0,0,3627,3628, + 3,326,163,0,3628,3629,3,324,162,0,3629,323,1,0,0,0,3630,3631,5,361, + 0,0,3631,3633,3,326,163,0,3632,3630,1,0,0,0,3633,3634,1,0,0,0,3634, + 3632,1,0,0,0,3634,3635,1,0,0,0,3635,3638,1,0,0,0,3636,3638,1,0,0, + 0,3637,3632,1,0,0,0,3637,3636,1,0,0,0,3638,325,1,0,0,0,3639,3642, + 3,328,164,0,3640,3642,3,338,169,0,3641,3639,1,0,0,0,3641,3640,1, + 0,0,0,3642,327,1,0,0,0,3643,3649,5,387,0,0,3644,3649,5,388,0,0,3645, + 3649,5,377,0,0,3646,3649,3,336,168,0,3647,3649,3,340,170,0,3648, + 3643,1,0,0,0,3648,3644,1,0,0,0,3648,3645,1,0,0,0,3648,3646,1,0,0, + 0,3648,3647,1,0,0,0,3649,329,1,0,0,0,3650,3652,5,361,0,0,3651,3650, + 1,0,0,0,3651,3652,1,0,0,0,3652,3653,1,0,0,0,3653,3654,7,69,0,0,3654, + 331,1,0,0,0,3655,3656,5,318,0,0,3656,3669,3,278,139,0,3657,3658, + 5,51,0,0,3658,3669,3,334,167,0,3659,3669,3,274,137,0,3660,3661,7, + 70,0,0,3661,3662,5,196,0,0,3662,3669,5,197,0,0,3663,3664,5,268,0, + 0,3664,3665,5,82,0,0,3665,3669,3,228,114,0,3666,3667,5,96,0,0,3667, + 3669,5,82,0,0,3668,3655,1,0,0,0,3668,3657,1,0,0,0,3668,3659,1,0, + 0,0,3668,3660,1,0,0,0,3668,3663,1,0,0,0,3668,3666,1,0,0,0,3669,333, + 1,0,0,0,3670,3671,7,71,0,0,3671,335,1,0,0,0,3672,3673,7,72,0,0,3673, + 337,1,0,0,0,3674,3675,7,73,0,0,3675,339,1,0,0,0,3676,3677,7,74,0, + 0,3677,341,1,0,0,0,530,345,352,356,361,372,378,389,395,400,405,408, + 412,415,419,425,431,436,441,444,448,451,460,465,478,481,485,491, + 494,497,502,510,515,521,524,531,538,545,552,558,568,571,581,589, + 593,596,604,607,611,614,621,626,631,638,643,652,656,662,666,670, + 675,681,688,693,698,701,707,711,717,725,729,734,740,752,757,760, + 763,766,769,772,787,791,800,804,811,815,828,836,841,850,853,856, + 861,872,879,887,892,895,900,910,912,917,920,924,931,934,938,941, + 945,954,957,961,964,969,982,984,990,993,996,1000,1004,1013,1015, + 1024,1027,1036,1041,1046,1049,1053,1068,1071,1076,1081,1086,1093, + 1100,1105,1108,1113,1117,1122,1126,1131,1136,1140,1147,1152,1157, + 1162,1169,1174,1177,1188,1195,1202,1214,1222,1228,1234,1237,1242, + 1246,1249,1257,1262,1271,1276,1278,1286,1291,1295,1298,1301,1304, + 1308,1310,1316,1319,1322,1328,1331,1334,1341,1346,1355,1363,1369, + 1372,1375,1381,1385,1390,1393,1397,1399,1407,1415,1418,1430,1436, + 1441,1444,1448,1459,1467,1479,1484,1487,1495,1504,1512,1518,1527, + 1534,1543,1548,1551,1576,1578,1590,1597,1600,1607,1611,1617,1625, + 1632,1635,1643,1654,1665,1673,1679,1695,1702,1713,1722,1725,1734, + 1737,1746,1749,1758,1761,1764,1769,1771,1775,1783,1789,1795,1798, + 1800,1808,1818,1827,1831,1834,1838,1842,1850,1854,1857,1860,1863, + 1867,1871,1876,1880,1883,1886,1889,1893,1898,1902,1905,1908,1911, + 1913,1919,1926,1931,1934,1937,1941,1951,1955,1957,1960,1964,1970, + 1974,1985,1993,1995,2002,2006,2018,2025,2040,2045,2052,2068,2073, + 2086,2091,2099,2105,2109,2112,2115,2122,2125,2131,2140,2150,2165, + 2170,2172,2177,2186,2196,2201,2205,2210,2217,2222,2226,2229,2232, + 2246,2259,2264,2268,2271,2276,2281,2285,2288,2300,2311,2324,2335, + 2340,2343,2347,2350,2362,2371,2374,2379,2386,2389,2395,2401,2403, + 2406,2411,2415,2421,2425,2428,2433,2436,2441,2443,2449,2454,2461, + 2464,2482,2484,2487,2498,2507,2514,2522,2530,2535,2538,2541,2549, + 2557,2567,2579,2582,2587,2592,2599,2606,2608,2621,2627,2629,2639, + 2645,2647,2655,2659,2662,2666,2668,2677,2689,2691,2698,2705,2711, + 2717,2719,2726,2734,2742,2748,2753,2760,2766,2769,2773,2775,2782, + 2791,2798,2808,2813,2817,2827,2834,2847,2849,2857,2859,2863,2871, + 2880,2886,2894,2899,2911,2916,2919,2925,2929,2934,2939,2944,2950, + 2971,2973,2984,2996,3008,3012,3021,3025,3043,3046,3054,3063,3072, + 3095,3111,3118,3121,3130,3134,3138,3150,3175,3182,3185,3200,3221, + 3225,3227,3237,3239,3249,3264,3266,3279,3283,3288,3295,3303,3308, + 3317,3349,3370,3373,3377,3383,3389,3398,3402,3404,3411,3419,3427, + 3435,3445,3455,3462,3466,3473,3481,3497,3501,3506,3510,3528,3544, + 3554,3557,3566,3569,3571,3574,3577,3587,3596,3603,3615,3624,3634, + 3637,3641,3648,3651,3668 + ]; + + private static __ATN: antlr.ATN; + public static get _ATN(): antlr.ATN { + if (!SqlParser.__ATN) { + SqlParser.__ATN = new antlr.ATNDeserializer().deserialize(SqlParser._serializedATN); + } + + return SqlParser.__ATN; + } + + + private static readonly vocabulary = new antlr.Vocabulary(SqlParser.literalNames, SqlParser.symbolicNames, []); + + public override get vocabulary(): antlr.Vocabulary { + return SqlParser.vocabulary; + } + + private static readonly decisionsToDFA = SqlParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) ); +} + +export class ProgramContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public EOF(): antlr.TerminalNode { + return this.getToken(SqlParser.EOF, 0)!; + } + public singleStatement(): SingleStatementContext[]; + public singleStatement(i: number): SingleStatementContext | null; + public singleStatement(i?: number): SingleStatementContext[] | SingleStatementContext | null { + if (i === undefined) { + return this.getRuleContexts(SingleStatementContext); + } + + return this.getRuleContext(i, SingleStatementContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_program; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterProgram) { + listener.enterProgram(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitProgram) { + listener.exitProgram(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitProgram) { + return visitor.visitProgram(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SingleStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public statement(): StatementContext { + return this.getRuleContext(0, StatementContext)!; + } + public SEMICOLON(): antlr.TerminalNode | null { + return this.getToken(SqlParser.SEMICOLON, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_singleStatement; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterSingleStatement) { + listener.enterSingleStatement(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitSingleStatement) { + listener.exitSingleStatement(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitSingleStatement) { + return visitor.visitSingleStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class StatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public override get ruleIndex(): number { + return SqlParser.RULE_statement; + } + public override copyFrom(ctx: StatementContext): void { + super.copyFrom(ctx); + } +} +export class DropContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public dropStatement(): DropStatementContext { + return this.getRuleContext(0, DropStatementContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDrop) { + listener.enterDrop(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDrop) { + listener.exitDrop(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDrop) { + return visitor.visitDrop(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CommentNamespaceContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_COMMENT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_COMMENT, 0)!; + } + public KW_ON(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_ON, 0)!; + } + public KW_IS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_IS, 0)!; + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public namespace(): NamespaceContext | null { + return this.getRuleContext(0, NamespaceContext); + } + public namespaceName(): NamespaceNameContext | null { + return this.getRuleContext(0, NamespaceNameContext); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLE, 0); + } + public tableName(): TableNameContext | null { + return this.getRuleContext(0, TableNameContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCommentNamespace) { + listener.enterCommentNamespace(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCommentNamespace) { + listener.exitCommentNamespace(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCommentNamespace) { + return visitor.visitCommentNamespace(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ResetAnyContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_RESET(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_RESET, 0)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterResetAny) { + listener.enterResetAny(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitResetAny) { + listener.exitResetAny(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitResetAny) { + return visitor.visitResetAny(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DmlStatementContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public dmlStatementNoWith(): DmlStatementNoWithContext { + return this.getRuleContext(0, DmlStatementNoWithContext)!; + } + public ctes(): CtesContext | null { + return this.getRuleContext(0, CtesContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDmlStatement) { + listener.enterDmlStatement(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDmlStatement) { + listener.exitDmlStatement(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDmlStatement) { + return visitor.visitDmlStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public showStatement(): ShowStatementContext { + return this.getRuleContext(0, ShowStatementContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShow) { + listener.enterShow(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShow) { + listener.exitShow(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShow) { + return visitor.visitShow(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DeclareVariableContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DECLARE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DECLARE, 0)!; + } + public functionName(): FunctionNameContext { + return this.getRuleContext(0, FunctionNameContext)!; + } + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OR, 0); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPLACE, 0); + } + public KW_VARIABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VARIABLE, 0); + } + public dataType(): DataTypeContext | null { + return this.getRuleContext(0, DataTypeContext); + } + public variableDefaultExpression(): VariableDefaultExpressionContext | null { + return this.getRuleContext(0, VariableDefaultExpressionContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDeclareVariable) { + listener.enterDeclareVariable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDeclareVariable) { + listener.exitDeclareVariable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDeclareVariable) { + return visitor.visitDeclareVariable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DescribeRelationContext extends StatementContext { + public _option?: Token | null; + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESC, 0); + } + public KW_DESCRIBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESCRIBE, 0); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLE, 0); + } + public partitionSpec(): PartitionSpecContext | null { + return this.getRuleContext(0, PartitionSpecContext); + } + public describeColName(): DescribeColNameContext | null { + return this.getRuleContext(0, DescribeColNameContext); + } + public KW_EXTENDED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTENDED, 0); + } + public KW_FORMATTED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FORMATTED, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDescribeRelation) { + listener.enterDescribeRelation(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDescribeRelation) { + listener.exitDescribeRelation(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDescribeRelation) { + return visitor.visitDescribeRelation(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class LoadDataContext extends StatementContext { + public _path?: StringLitContext; + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_LOAD(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_LOAD, 0)!; + } + public KW_DATA(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DATA, 0)!; + } + public KW_INPATH(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_INPATH, 0)!; + } + public KW_INTO(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_INTO, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public stringLit(): StringLitContext { + return this.getRuleContext(0, StringLitContext)!; + } + public KW_LOCAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCAL, 0); + } + public KW_OVERWRITE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVERWRITE, 0); + } + public partitionSpec(): PartitionSpecContext | null { + return this.getRuleContext(0, PartitionSpecContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterLoadData) { + listener.enterLoadData(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitLoadData) { + listener.exitLoadData(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitLoadData) { + return visitor.visitLoadData(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DescribeFunctionContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_FUNCTION(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FUNCTION, 0)!; + } + public describeFuncName(): DescribeFuncNameContext { + return this.getRuleContext(0, DescribeFuncNameContext)!; + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESC, 0); + } + public KW_DESCRIBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESCRIBE, 0); + } + public KW_EXTENDED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTENDED, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDescribeFunction) { + listener.enterDescribeFunction(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDescribeFunction) { + listener.exitDescribeFunction(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDescribeFunction) { + return visitor.visitDescribeFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ClearCacheContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CLEAR(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CLEAR, 0)!; + } + public KW_CACHE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CACHE, 0)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterClearCache) { + listener.enterClearCache(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitClearCache) { + listener.exitClearCache(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitClearCache) { + return visitor.visitClearCache(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class UnsupportHiveCommandsContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public unsupportedCommands(): UnsupportedCommandsContext { + return this.getRuleContext(0, UnsupportedCommandsContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnsupportHiveCommands) { + listener.enterUnsupportHiveCommands(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnsupportHiveCommands) { + listener.exitUnsupportHiveCommands(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnsupportHiveCommands) { + return visitor.visitUnsupportHiveCommands(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class StatementDefaultContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public query(): QueryContext { + return this.getRuleContext(0, QueryContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterStatementDefault) { + listener.enterStatementDefault(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitStatementDefault) { + listener.exitStatementDefault(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitStatementDefault) { + return visitor.visitStatementDefault(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class RepairTableContext extends StatementContext { + public _option?: Token | null; + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_REPAIR(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_REPAIR, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public KW_MSCK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MSCK, 0); + } + public KW_PARTITIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITIONS, 0); + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ADD, 0); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DROP, 0); + } + public KW_SYNC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYNC, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterRepairTable) { + listener.enterRepairTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitRepairTable) { + listener.exitRepairTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitRepairTable) { + return visitor.visitRepairTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class OptimizeTableContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_OPTIMIZE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_OPTIMIZE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public KW_ZORDER(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_ZORDER, 0)!; + } + public KW_BY(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_BY, 0)!; + } + public columnNameSeq(): ColumnNameSeqContext { + return this.getRuleContext(0, ColumnNameSeqContext)!; + } + public whereClause(): WhereClauseContext | null { + return this.getRuleContext(0, WhereClauseContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterOptimizeTable) { + listener.enterOptimizeTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitOptimizeTable) { + listener.exitOptimizeTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitOptimizeTable) { + return visitor.visitOptimizeTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class RefreshResourceContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_REFRESH(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_REFRESH, 0)!; + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterRefreshResource) { + listener.enterRefreshResource(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitRefreshResource) { + listener.exitRefreshResource(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitRefreshResource) { + return visitor.visitRefreshResource(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CreateContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public createStatement(): CreateStatementContext { + return this.getRuleContext(0, CreateStatementContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreate) { + listener.enterCreate(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreate) { + listener.exitCreate(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreate) { + return visitor.visitCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class TruncateTableContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_TRUNCATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TRUNCATE, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public partitionSpec(): PartitionSpecContext | null { + return this.getRuleContext(0, PartitionSpecContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTruncateTable) { + listener.enterTruncateTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTruncateTable) { + listener.exitTruncateTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTruncateTable) { + return visitor.visitTruncateTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DescribeQueryContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public query(): QueryContext { + return this.getRuleContext(0, QueryContext)!; + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESC, 0); + } + public KW_DESCRIBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESCRIBE, 0); + } + public KW_QUERY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_QUERY, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDescribeQuery) { + listener.enterDescribeQuery(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDescribeQuery) { + listener.exitDescribeQuery(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDescribeQuery) { + return visitor.visitDescribeQuery(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DescribeNamespaceContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DATABASE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DATABASE, 0)!; + } + public namespaceName(): NamespaceNameContext { + return this.getRuleContext(0, NamespaceNameContext)!; + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESC, 0); + } + public KW_DESCRIBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESCRIBE, 0); + } + public KW_EXTENDED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTENDED, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDescribeNamespace) { + listener.enterDescribeNamespace(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDescribeNamespace) { + listener.exitDescribeNamespace(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDescribeNamespace) { + return visitor.visitDescribeNamespace(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class AlterContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public alterStatement(): AlterStatementContext { + return this.getRuleContext(0, AlterStatementContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterAlter) { + listener.enterAlter(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitAlter) { + listener.exitAlter(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitAlter) { + return visitor.visitAlter(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class AnalyzeTablesContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_ANALYZE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_ANALYZE, 0)!; + } + public KW_TABLES(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLES, 0)!; + } + public KW_COMPUTE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_COMPUTE, 0)!; + } + public KW_STATISTICS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_STATISTICS, 0)!; + } + public namespaceName(): NamespaceNameContext | null { + return this.getRuleContext(0, NamespaceNameContext); + } + public KW_NOSCAN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOSCAN, 0); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FROM, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterAnalyzeTables) { + listener.enterAnalyzeTables(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitAnalyzeTables) { + listener.exitAnalyzeTables(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitAnalyzeTables) { + return visitor.visitAnalyzeTables(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class RefreshFunctionContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_REFRESH(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_REFRESH, 0)!; + } + public KW_FUNCTION(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FUNCTION, 0)!; + } + public functionName(): FunctionNameContext { + return this.getRuleContext(0, FunctionNameContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterRefreshFunction) { + listener.enterRefreshFunction(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitRefreshFunction) { + listener.exitRefreshFunction(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitRefreshFunction) { + return visitor.visitRefreshFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class RefreshTableContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_REFRESH(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_REFRESH, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterRefreshTable) { + listener.enterRefreshTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitRefreshTable) { + listener.exitRefreshTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitRefreshTable) { + return visitor.visitRefreshTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SetAnyContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SET(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SET, 0)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterSetAny) { + listener.enterSetAny(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitSetAny) { + listener.exitSetAny(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitSetAny) { + return visitor.visitSetAny(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class UseNamespaceContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_USE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_USE, 0)!; + } + public namespaceName(): NamespaceNameContext { + return this.getRuleContext(0, NamespaceNameContext)!; + } + public namespace(): NamespaceContext | null { + return this.getRuleContext(0, NamespaceContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUseNamespace) { + listener.enterUseNamespace(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUseNamespace) { + listener.exitUseNamespace(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUseNamespace) { + return visitor.visitUseNamespace(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ManageResourceContext extends StatementContext { + public _op?: Token | null; + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext)!; + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ADD, 0); + } + public KW_LIST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIST, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterManageResource) { + listener.enterManageResource(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitManageResource) { + listener.exitManageResource(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitManageResource) { + return visitor.visitManageResource(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ExplainStatementContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_EXPLAIN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_EXPLAIN, 0)!; + } + public statement(): StatementContext { + return this.getRuleContext(0, StatementContext)!; + } + public KW_LOGICAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOGICAL, 0); + } + public KW_FORMATTED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FORMATTED, 0); + } + public KW_EXTENDED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTENDED, 0); + } + public KW_CODEGEN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CODEGEN, 0); + } + public KW_COST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COST, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterExplainStatement) { + listener.enterExplainStatement(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitExplainStatement) { + listener.exitExplainStatement(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitExplainStatement) { + return visitor.visitExplainStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class AnalyzeContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_ANALYZE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_ANALYZE, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public KW_COMPUTE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_COMPUTE, 0)!; + } + public KW_STATISTICS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_STATISTICS, 0)!; + } + public partitionSpec(): PartitionSpecContext | null { + return this.getRuleContext(0, PartitionSpecContext); + } + public KW_NOSCAN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOSCAN, 0); + } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FOR, 0); + } + public KW_COLUMNS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLUMNS, 0); + } + public columnNameSeq(): ColumnNameSeqContext | null { + return this.getRuleContext(0, ColumnNameSeqContext); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALL, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterAnalyze) { + listener.enterAnalyze(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitAnalyze) { + listener.exitAnalyze(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitAnalyze) { + return visitor.visitAnalyze(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class UnCacheTableContext extends StatementContext { + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_UNCACHE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_UNCACHE, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public ifExists(): IfExistsContext | null { + return this.getRuleContext(0, IfExistsContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnCacheTable) { + listener.enterUnCacheTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnCacheTable) { + listener.exitUnCacheTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnCacheTable) { + return visitor.visitUnCacheTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CacheTableContext extends StatementContext { + public _options?: PropertyListContext; + public constructor(ctx: StatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CACHE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CACHE, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public KW_LAZY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LAZY, 0); + } + public KW_OPTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTIONS, 0); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public propertyList(): PropertyListContext | null { + return this.getRuleContext(0, PropertyListContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCacheTable) { + listener.enterCacheTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCacheTable) { + listener.exitCacheTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCacheTable) { + return visitor.visitCacheTable(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterStatementContext extends antlr.ParserRuleContext { + public _table?: TableNameContext; + public _column?: ColumnNameContext; + public _colName?: ColumnNameContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_ALTER(): antlr.TerminalNode[]; + public KW_ALTER(i: number): antlr.TerminalNode | null; + public KW_ALTER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_ALTER); + } else { + return this.getToken(SqlParser.KW_ALTER, i); + } + } + public namespace(): NamespaceContext | null { + return this.getRuleContext(0, NamespaceContext); + } + public namespaceName(): NamespaceNameContext | null { + return this.getRuleContext(0, NamespaceNameContext); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SET, 0); + } + public KW_LOCATION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCATION, 0); + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public propertyList(): PropertyListContext | null { + return this.getRuleContext(0, PropertyListContext); + } + public KW_DBPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DBPROPERTIES, 0); + } + public KW_PROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PROPERTIES, 0); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLE, 0); + } + public tableName(): TableNameContext | null { + return this.getRuleContext(0, TableNameContext); + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ADD, 0); + } + public KW_COLUMN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLUMN, 0); + } + public KW_COLUMNS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLUMNS, 0); + } + public qualifiedColTypeWithPositionForAdd(): QualifiedColTypeWithPositionForAddContext | null { + return this.getRuleContext(0, QualifiedColTypeWithPositionForAddContext); + } + public qualifiedColTypeWithPositionSeqForAdd(): QualifiedColTypeWithPositionSeqForAddContext | null { + return this.getRuleContext(0, QualifiedColTypeWithPositionSeqForAddContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DROP, 0); + } + public columnName(): ColumnNameContext | null { + return this.getRuleContext(0, ColumnNameContext); + } + public columnNameSeq(): ColumnNameSeqContext | null { + return this.getRuleContext(0, ColumnNameSeqContext); + } + public ifExists(): IfExistsContext | null { + return this.getRuleContext(0, IfExistsContext); + } + public KW_RENAME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RENAME, 0); + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TO, 0); + } + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VIEW, 0); + } + public viewName(): ViewNameContext | null { + return this.getRuleContext(0, ViewNameContext); + } + public columnNameCreate(): ColumnNameCreateContext | null { + return this.getRuleContext(0, ColumnNameCreateContext); + } + public multipartIdentifier(): MultipartIdentifierContext | null { + return this.getRuleContext(0, MultipartIdentifierContext); + } + public KW_TBLPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TBLPROPERTIES, 0); + } + public KW_UNSET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNSET, 0); + } + public KW_CHANGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHANGE, 0); + } + public alterColumnAction(): AlterColumnActionContext | null { + return this.getRuleContext(0, AlterColumnActionContext); + } + public partitionSpec(): PartitionSpecContext[]; + public partitionSpec(i: number): PartitionSpecContext | null; + public partitionSpec(i?: number): PartitionSpecContext[] | PartitionSpecContext | null { + if (i === undefined) { + return this.getRuleContexts(PartitionSpecContext); + } + + return this.getRuleContext(i, PartitionSpecContext); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPLACE, 0); + } + public columnType(): ColumnTypeContext | null { + return this.getRuleContext(0, ColumnTypeContext); + } + public qualifiedColTypeWithPositionSeqForReplace(): QualifiedColTypeWithPositionSeqForReplaceContext | null { + return this.getRuleContext(0, QualifiedColTypeWithPositionSeqForReplaceContext); + } + public colPosition(): ColPositionContext | null { + return this.getRuleContext(0, ColPositionContext); + } + public ifNotExists(): IfNotExistsContext | null { + return this.getRuleContext(0, IfNotExistsContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public KW_PURGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PURGE, 0); + } + public partitionSpecLocation(): PartitionSpecLocationContext[]; + public partitionSpecLocation(i: number): PartitionSpecLocationContext | null; + public partitionSpecLocation(i?: number): PartitionSpecLocationContext[] | PartitionSpecLocationContext | null { + if (i === undefined) { + return this.getRuleContexts(PartitionSpecLocationContext); + } + + return this.getRuleContext(i, PartitionSpecLocationContext); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public KW_SERDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDE, 0); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WITH, 0); + } + public KW_SERDEPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDEPROPERTIES, 0); + } + public KW_RECOVER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RECOVER, 0); + } + public KW_PARTITIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITIONS, 0); + } + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INDEX, 0); + } + public KW_CLUSTERED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CLUSTERED, 0); + } + public KW_SKEWED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SKEWED, 0); + } + public KW_TOUCH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TOUCH, 0); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BY, 0); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public KW_SORTED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SORTED, 0); + } + public KW_STORED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STORED, 0); + } + public KW_DIRECTORIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIRECTORIES, 0); + } + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITION, 0); + } + public KW_EXCHANGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXCHANGE, 0); + } + public KW_ARCHIVE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ARCHIVE, 0); + } + public KW_UNARCHIVE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNARCHIVE, 0); + } + public KW_COMPACT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMPACT, 0); + } + public KW_CONCATENATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CONCATENATE, 0); + } + public KW_FILEFORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FILEFORMAT, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_alterStatement; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterAlterStatement) { + listener.enterAlterStatement(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitAlterStatement) { + listener.exitAlterStatement(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitAlterStatement) { + return visitor.visitAlterStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public override get ruleIndex(): number { + return SqlParser.RULE_createStatement; + } + public override copyFrom(ctx: CreateStatementContext): void { + super.copyFrom(ctx); + } +} +export class CreateNamespaceContext extends CreateStatementContext { + public _comment?: StringLitContext; + public constructor(ctx: CreateStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CREATE, 0)!; + } + public namespace(): NamespaceContext { + return this.getRuleContext(0, NamespaceContext)!; + } + public namespaceNameCreate(): NamespaceNameCreateContext { + return this.getRuleContext(0, NamespaceNameCreateContext)!; + } + public ifNotExists(): IfNotExistsContext | null { + return this.getRuleContext(0, IfNotExistsContext); + } + public KW_COMMENT(): antlr.TerminalNode[]; + public KW_COMMENT(i: number): antlr.TerminalNode | null; + public KW_COMMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_COMMENT); + } else { + return this.getToken(SqlParser.KW_COMMENT, i); + } + } + public KW_LOCATION(): antlr.TerminalNode[]; + public KW_LOCATION(i: number): antlr.TerminalNode | null; + public KW_LOCATION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_LOCATION); + } else { + return this.getToken(SqlParser.KW_LOCATION, i); + } + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public KW_WITH(): antlr.TerminalNode[]; + public KW_WITH(i: number): antlr.TerminalNode | null; + public KW_WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_WITH); + } else { + return this.getToken(SqlParser.KW_WITH, i); + } + } + public propertyList(): PropertyListContext[]; + public propertyList(i: number): PropertyListContext | null; + public propertyList(i?: number): PropertyListContext[] | PropertyListContext | null { + if (i === undefined) { + return this.getRuleContexts(PropertyListContext); + } + + return this.getRuleContext(i, PropertyListContext); + } + public KW_DBPROPERTIES(): antlr.TerminalNode[]; + public KW_DBPROPERTIES(i: number): antlr.TerminalNode | null; + public KW_DBPROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_DBPROPERTIES); + } else { + return this.getToken(SqlParser.KW_DBPROPERTIES, i); + } + } + public KW_PROPERTIES(): antlr.TerminalNode[]; + public KW_PROPERTIES(i: number): antlr.TerminalNode | null; + public KW_PROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_PROPERTIES); + } else { + return this.getToken(SqlParser.KW_PROPERTIES, i); + } + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateNamespace) { + listener.enterCreateNamespace(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateNamespace) { + listener.exitCreateNamespace(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateNamespace) { + return visitor.visitCreateNamespace(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CreateTableContext extends CreateStatementContext { + public constructor(ctx: CreateStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CREATE, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableNameCreate(): TableNameCreateContext { + return this.getRuleContext(0, TableNameCreateContext)!; + } + public createTableClauses(): CreateTableClausesContext { + return this.getRuleContext(0, CreateTableClausesContext)!; + } + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TEMPORARY, 0); + } + public KW_EXTERNAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTERNAL, 0); + } + public ifNotExists(): IfNotExistsContext | null { + return this.getRuleContext(0, IfNotExistsContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext | null { + return this.getRuleContext(0, CreateOrReplaceTableColTypeListContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public tableProvider(): TableProviderContext | null { + return this.getRuleContext(0, TableProviderContext); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateTable) { + listener.enterCreateTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateTable) { + listener.exitCreateTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateTable) { + return visitor.visitCreateTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ReplaceTableContext extends CreateStatementContext { + public constructor(ctx: CreateStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_REPLACE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_REPLACE, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableNameCreate(): TableNameCreateContext { + return this.getRuleContext(0, TableNameCreateContext)!; + } + public createTableClauses(): CreateTableClausesContext { + return this.getRuleContext(0, CreateTableClausesContext)!; + } + public KW_CREATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CREATE, 0); + } + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OR, 0); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext | null { + return this.getRuleContext(0, CreateOrReplaceTableColTypeListContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public tableProvider(): TableProviderContext | null { + return this.getRuleContext(0, TableProviderContext); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterReplaceTable) { + listener.enterReplaceTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitReplaceTable) { + listener.exitReplaceTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitReplaceTable) { + return visitor.visitReplaceTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CreateTempViewUsingContext extends CreateStatementContext { + public constructor(ctx: CreateStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CREATE, 0)!; + } + public KW_TEMPORARY(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TEMPORARY, 0)!; + } + public KW_VIEW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_VIEW, 0)!; + } + public viewNameCreate(): ViewNameCreateContext { + return this.getRuleContext(0, ViewNameCreateContext)!; + } + public tableProvider(): TableProviderContext { + return this.getRuleContext(0, TableProviderContext)!; + } + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OR, 0); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPLACE, 0); + } + public KW_GLOBAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GLOBAL, 0); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public colTypeList(): ColTypeListContext | null { + return this.getRuleContext(0, ColTypeListContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public KW_OPTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTIONS, 0); + } + public propertyList(): PropertyListContext | null { + return this.getRuleContext(0, PropertyListContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateTempViewUsing) { + listener.enterCreateTempViewUsing(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateTempViewUsing) { + listener.exitCreateTempViewUsing(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateTempViewUsing) { + return visitor.visitCreateTempViewUsing(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CreateTableLikeContext extends CreateStatementContext { + public _target?: TableNameCreateContext; + public _source?: TableNameContext; + public _tableProps?: PropertyListContext; + public constructor(ctx: CreateStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CREATE, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public KW_LIKE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_LIKE, 0)!; + } + public tableNameCreate(): TableNameCreateContext { + return this.getRuleContext(0, TableNameCreateContext)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public ifNotExists(): IfNotExistsContext | null { + return this.getRuleContext(0, IfNotExistsContext); + } + public tableProvider(): TableProviderContext[]; + public tableProvider(i: number): TableProviderContext | null; + public tableProvider(i?: number): TableProviderContext[] | TableProviderContext | null { + if (i === undefined) { + return this.getRuleContexts(TableProviderContext); + } + + return this.getRuleContext(i, TableProviderContext); + } + public rowFormat(): RowFormatContext[]; + public rowFormat(i: number): RowFormatContext | null; + public rowFormat(i?: number): RowFormatContext[] | RowFormatContext | null { + if (i === undefined) { + return this.getRuleContexts(RowFormatContext); + } + + return this.getRuleContext(i, RowFormatContext); + } + public createFileFormat(): CreateFileFormatContext[]; + public createFileFormat(i: number): CreateFileFormatContext | null; + public createFileFormat(i?: number): CreateFileFormatContext[] | CreateFileFormatContext | null { + if (i === undefined) { + return this.getRuleContexts(CreateFileFormatContext); + } + + return this.getRuleContext(i, CreateFileFormatContext); + } + public tableLifecycle(): TableLifecycleContext[]; + public tableLifecycle(i: number): TableLifecycleContext | null; + public tableLifecycle(i?: number): TableLifecycleContext[] | TableLifecycleContext | null { + if (i === undefined) { + return this.getRuleContexts(TableLifecycleContext); + } + + return this.getRuleContext(i, TableLifecycleContext); + } + public KW_LOCATION(): antlr.TerminalNode[]; + public KW_LOCATION(i: number): antlr.TerminalNode | null; + public KW_LOCATION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_LOCATION); + } else { + return this.getToken(SqlParser.KW_LOCATION, i); + } + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public KW_TBLPROPERTIES(): antlr.TerminalNode[]; + public KW_TBLPROPERTIES(i: number): antlr.TerminalNode | null; + public KW_TBLPROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_TBLPROPERTIES); + } else { + return this.getToken(SqlParser.KW_TBLPROPERTIES, i); + } + } + public propertyList(): PropertyListContext[]; + public propertyList(i: number): PropertyListContext | null; + public propertyList(i?: number): PropertyListContext[] | PropertyListContext | null { + if (i === undefined) { + return this.getRuleContexts(PropertyListContext); + } + + return this.getRuleContext(i, PropertyListContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateTableLike) { + listener.enterCreateTableLike(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateTableLike) { + listener.exitCreateTableLike(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateTableLike) { + return visitor.visitCreateTableLike(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CreateFunctionContext extends CreateStatementContext { + public _className?: StringLitContext; + public constructor(ctx: CreateStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CREATE, 0)!; + } + public KW_FUNCTION(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FUNCTION, 0)!; + } + public functionNameCreate(): FunctionNameCreateContext { + return this.getRuleContext(0, FunctionNameCreateContext)!; + } + public KW_AS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_AS, 0)!; + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OR, 0); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPLACE, 0); + } + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TEMPORARY, 0); + } + public ifNotExists(): IfNotExistsContext | null { + return this.getRuleContext(0, IfNotExistsContext); + } + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_USING, 0); + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateFunction) { + listener.enterCreateFunction(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateFunction) { + listener.exitCreateFunction(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateFunction) { + return visitor.visitCreateFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CreateRoleContext extends CreateStatementContext { + public constructor(ctx: CreateStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CREATE, 0)!; + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLE, 0); + } + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INDEX, 0); + } + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TEMPORARY, 0); + } + public KW_MACRO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MACRO, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateRole) { + listener.enterCreateRole(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateRole) { + listener.exitCreateRole(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateRole) { + return visitor.visitCreateRole(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CreateViewContext extends CreateStatementContext { + public _comment?: StringLitContext; + public constructor(ctx: CreateStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CREATE, 0)!; + } + public KW_VIEW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_VIEW, 0)!; + } + public viewNameCreate(): ViewNameCreateContext { + return this.getRuleContext(0, ViewNameCreateContext)!; + } + public KW_AS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_AS, 0)!; + } + public query(): QueryContext { + return this.getRuleContext(0, QueryContext)!; + } + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OR, 0); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPLACE, 0); + } + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TEMPORARY, 0); + } + public ifNotExists(): IfNotExistsContext | null { + return this.getRuleContext(0, IfNotExistsContext); + } + public identifierCommentList(): IdentifierCommentListContext | null { + return this.getRuleContext(0, IdentifierCommentListContext); + } + public KW_COMMENT(): antlr.TerminalNode[]; + public KW_COMMENT(i: number): antlr.TerminalNode | null; + public KW_COMMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_COMMENT); + } else { + return this.getToken(SqlParser.KW_COMMENT, i); + } + } + public KW_PARTITIONED(): antlr.TerminalNode[]; + public KW_PARTITIONED(i: number): antlr.TerminalNode | null; + public KW_PARTITIONED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_PARTITIONED); + } else { + return this.getToken(SqlParser.KW_PARTITIONED, i); + } + } + public KW_ON(): antlr.TerminalNode[]; + public KW_ON(i: number): antlr.TerminalNode | null; + public KW_ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_ON); + } else { + return this.getToken(SqlParser.KW_ON, i); + } + } + public identifierList(): IdentifierListContext[]; + public identifierList(i: number): IdentifierListContext | null; + public identifierList(i?: number): IdentifierListContext[] | IdentifierListContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierListContext); + } + + return this.getRuleContext(i, IdentifierListContext); + } + public KW_TBLPROPERTIES(): antlr.TerminalNode[]; + public KW_TBLPROPERTIES(i: number): antlr.TerminalNode | null; + public KW_TBLPROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_TBLPROPERTIES); + } else { + return this.getToken(SqlParser.KW_TBLPROPERTIES, i); + } + } + public propertyList(): PropertyListContext[]; + public propertyList(i: number): PropertyListContext | null; + public propertyList(i?: number): PropertyListContext[] | PropertyListContext | null { + if (i === undefined) { + return this.getRuleContexts(PropertyListContext); + } + + return this.getRuleContext(i, PropertyListContext); + } + public KW_GLOBAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GLOBAL, 0); + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateView) { + listener.enterCreateView(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateView) { + listener.exitCreateView(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateView) { + return visitor.visitCreateView(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CreateIndexContext extends CreateStatementContext { + public _indexType?: IdentifierContext; + public _options?: PropertyListContext; + public constructor(ctx: CreateStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CREATE, 0)!; + } + public KW_INDEX(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_INDEX, 0)!; + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public KW_ON(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_ON, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public multipartIdentifierPropertyList(): MultipartIdentifierPropertyListContext { + return this.getRuleContext(0, MultipartIdentifierPropertyListContext)!; + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public ifNotExists(): IfNotExistsContext | null { + return this.getRuleContext(0, IfNotExistsContext); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLE, 0); + } + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_USING, 0); + } + public KW_OPTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTIONS, 0); + } + public propertyList(): PropertyListContext | null { + return this.getRuleContext(0, PropertyListContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateIndex) { + listener.enterCreateIndex(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateIndex) { + listener.exitCreateIndex(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateIndex) { + return visitor.visitCreateIndex(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DropStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public override get ruleIndex(): number { + return SqlParser.RULE_dropStatement; + } + public override copyFrom(ctx: DropStatementContext): void { + super.copyFrom(ctx); + } +} +export class DropRoleContext extends DropStatementContext { + public constructor(ctx: DropStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DROP(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DROP, 0)!; + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLE, 0); + } + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INDEX, 0); + } + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TEMPORARY, 0); + } + public KW_MACRO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MACRO, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDropRole) { + listener.enterDropRole(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDropRole) { + listener.exitDropRole(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDropRole) { + return visitor.visitDropRole(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DropNamespaceContext extends DropStatementContext { + public constructor(ctx: DropStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DROP(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DROP, 0)!; + } + public namespace(): NamespaceContext { + return this.getRuleContext(0, NamespaceContext)!; + } + public namespaceName(): NamespaceNameContext { + return this.getRuleContext(0, NamespaceNameContext)!; + } + public ifExists(): IfExistsContext | null { + return this.getRuleContext(0, IfExistsContext); + } + public KW_RESTRICT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RESTRICT, 0); + } + public KW_CASCADE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CASCADE, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDropNamespace) { + listener.enterDropNamespace(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDropNamespace) { + listener.exitDropNamespace(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDropNamespace) { + return visitor.visitDropNamespace(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DropFunctionContext extends DropStatementContext { + public constructor(ctx: DropStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DROP(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DROP, 0)!; + } + public KW_FUNCTION(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FUNCTION, 0)!; + } + public functionName(): FunctionNameContext { + return this.getRuleContext(0, FunctionNameContext)!; + } + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TEMPORARY, 0); + } + public ifExists(): IfExistsContext | null { + return this.getRuleContext(0, IfExistsContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDropFunction) { + listener.enterDropFunction(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDropFunction) { + listener.exitDropFunction(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDropFunction) { + return visitor.visitDropFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DropViewContext extends DropStatementContext { + public constructor(ctx: DropStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DROP(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DROP, 0)!; + } + public KW_VIEW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_VIEW, 0)!; + } + public viewName(): ViewNameContext { + return this.getRuleContext(0, ViewNameContext)!; + } + public ifExists(): IfExistsContext | null { + return this.getRuleContext(0, IfExistsContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDropView) { + listener.enterDropView(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDropView) { + listener.exitDropView(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDropView) { + return visitor.visitDropView(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DropTableContext extends DropStatementContext { + public constructor(ctx: DropStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DROP(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DROP, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public ifExists(): IfExistsContext | null { + return this.getRuleContext(0, IfExistsContext); + } + public KW_PURGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PURGE, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDropTable) { + listener.enterDropTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDropTable) { + listener.exitDropTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDropTable) { + return visitor.visitDropTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DropVariableContext extends DropStatementContext { + public constructor(ctx: DropStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DROP(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DROP, 0)!; + } + public KW_TEMPORARY(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TEMPORARY, 0)!; + } + public KW_VARIABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_VARIABLE, 0)!; + } + public tableName(): TableNameContext | null { + return this.getRuleContext(0, TableNameContext); + } + public viewName(): ViewNameContext | null { + return this.getRuleContext(0, ViewNameContext); + } + public functionName(): FunctionNameContext | null { + return this.getRuleContext(0, FunctionNameContext); + } + public ifExists(): IfExistsContext | null { + return this.getRuleContext(0, IfExistsContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDropVariable) { + listener.enterDropVariable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDropVariable) { + listener.exitDropVariable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDropVariable) { + return visitor.visitDropVariable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DropIndexContext extends DropStatementContext { + public constructor(ctx: DropStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DROP(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DROP, 0)!; + } + public KW_INDEX(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_INDEX, 0)!; + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext)!; + } + public KW_ON(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_ON, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public ifExists(): IfExistsContext | null { + return this.getRuleContext(0, IfExistsContext); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLE, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDropIndex) { + listener.enterDropIndex(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDropIndex) { + listener.exitDropIndex(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDropIndex) { + return visitor.visitDropIndex(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DmlStatementNoWithContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public override get ruleIndex(): number { + return SqlParser.RULE_dmlStatementNoWith; + } + public override copyFrom(ctx: DmlStatementNoWithContext): void { + super.copyFrom(ctx); + } +} +export class DeleteFromTableContext extends DmlStatementNoWithContext { + public constructor(ctx: DmlStatementNoWithContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_DELETE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_DELETE, 0)!; + } + public KW_FROM(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FROM, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public tableAlias(): TableAliasContext { + return this.getRuleContext(0, TableAliasContext)!; + } + public whereClause(): WhereClauseContext | null { + return this.getRuleContext(0, WhereClauseContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDeleteFromTable) { + listener.enterDeleteFromTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDeleteFromTable) { + listener.exitDeleteFromTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDeleteFromTable) { + return visitor.visitDeleteFromTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class MultipleInsertContext extends DmlStatementNoWithContext { + public constructor(ctx: DmlStatementNoWithContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public fromClause(): FromClauseContext { + return this.getRuleContext(0, FromClauseContext)!; + } + public insertInto(): InsertIntoContext[]; + public insertInto(i: number): InsertIntoContext | null; + public insertInto(i?: number): InsertIntoContext[] | InsertIntoContext | null { + if (i === undefined) { + return this.getRuleContexts(InsertIntoContext); + } + + return this.getRuleContext(i, InsertIntoContext); + } + public fromStatementBody(): FromStatementBodyContext[]; + public fromStatementBody(i: number): FromStatementBodyContext | null; + public fromStatementBody(i?: number): FromStatementBodyContext[] | FromStatementBodyContext | null { + if (i === undefined) { + return this.getRuleContexts(FromStatementBodyContext); + } + + return this.getRuleContext(i, FromStatementBodyContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterMultipleInsert) { + listener.enterMultipleInsert(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitMultipleInsert) { + listener.exitMultipleInsert(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitMultipleInsert) { + return visitor.visitMultipleInsert(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class UpdateTableContext extends DmlStatementNoWithContext { + public constructor(ctx: DmlStatementNoWithContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_UPDATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_UPDATE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public tableAlias(): TableAliasContext { + return this.getRuleContext(0, TableAliasContext)!; + } + public setClause(): SetClauseContext { + return this.getRuleContext(0, SetClauseContext)!; + } + public whereClause(): WhereClauseContext | null { + return this.getRuleContext(0, WhereClauseContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUpdateTable) { + listener.enterUpdateTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUpdateTable) { + listener.exitUpdateTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUpdateTable) { + return visitor.visitUpdateTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class InsertFromQueryContext extends DmlStatementNoWithContext { + public constructor(ctx: DmlStatementNoWithContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public insertInto(): InsertIntoContext { + return this.getRuleContext(0, InsertIntoContext)!; + } + public query(): QueryContext { + return this.getRuleContext(0, QueryContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterInsertFromQuery) { + listener.enterInsertFromQuery(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitInsertFromQuery) { + listener.exitInsertFromQuery(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitInsertFromQuery) { + return visitor.visitInsertFromQuery(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class MergeIntoTableContext extends DmlStatementNoWithContext { + public _target?: TableNameContext; + public _targetAlias?: TableAliasContext; + public _source?: IdentifierReferenceContext; + public _sourceQuery?: QueryContext; + public _sourceAlias?: TableAliasContext; + public _mergeCondition?: BooleanExpressionContext; + public constructor(ctx: DmlStatementNoWithContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_MERGE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_MERGE, 0)!; + } + public KW_INTO(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_INTO, 0)!; + } + public KW_USING(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_USING, 0)!; + } + public KW_ON(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_ON, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public tableAlias(): TableAliasContext[]; + public tableAlias(i: number): TableAliasContext | null; + public tableAlias(i?: number): TableAliasContext[] | TableAliasContext | null { + if (i === undefined) { + return this.getRuleContexts(TableAliasContext); + } + + return this.getRuleContext(i, TableAliasContext); + } + public booleanExpression(): BooleanExpressionContext { + return this.getRuleContext(0, BooleanExpressionContext)!; + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public identifierReference(): IdentifierReferenceContext | null { + return this.getRuleContext(0, IdentifierReferenceContext); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public matchedClause(): MatchedClauseContext[]; + public matchedClause(i: number): MatchedClauseContext | null; + public matchedClause(i?: number): MatchedClauseContext[] | MatchedClauseContext | null { + if (i === undefined) { + return this.getRuleContexts(MatchedClauseContext); + } + + return this.getRuleContext(i, MatchedClauseContext); + } + public notMatchedClause(): NotMatchedClauseContext[]; + public notMatchedClause(i: number): NotMatchedClauseContext | null; + public notMatchedClause(i?: number): NotMatchedClauseContext[] | NotMatchedClauseContext | null { + if (i === undefined) { + return this.getRuleContexts(NotMatchedClauseContext); + } + + return this.getRuleContext(i, NotMatchedClauseContext); + } + public notMatchedBySourceClause(): NotMatchedBySourceClauseContext[]; + public notMatchedBySourceClause(i: number): NotMatchedBySourceClauseContext | null; + public notMatchedBySourceClause(i?: number): NotMatchedBySourceClauseContext[] | NotMatchedBySourceClauseContext | null { + if (i === undefined) { + return this.getRuleContexts(NotMatchedBySourceClauseContext); + } + + return this.getRuleContext(i, NotMatchedBySourceClauseContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterMergeIntoTable) { + listener.enterMergeIntoTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitMergeIntoTable) { + listener.exitMergeIntoTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitMergeIntoTable) { + return visitor.visitMergeIntoTable(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class InsertIntoContext extends antlr.ParserRuleContext { + public _path?: StringLitContext; + public _options?: PropertyListContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_INSERT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_INSERT, 0)!; + } + public KW_INTO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTO, 0); + } + public tableName(): TableNameContext | null { + return this.getRuleContext(0, TableNameContext); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLE, 0); + } + public partitionSpec(): PartitionSpecContext | null { + return this.getRuleContext(0, PartitionSpecContext); + } + public ifNotExists(): IfNotExistsContext | null { + return this.getRuleContext(0, IfNotExistsContext); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BY, 0); + } + public KW_NAME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NAME, 0); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public columnNameSeq(): ColumnNameSeqContext | null { + return this.getRuleContext(0, ColumnNameSeqContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPLACE, 0); + } + public whereClause(): WhereClauseContext | null { + return this.getRuleContext(0, WhereClauseContext); + } + public KW_OVERWRITE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVERWRITE, 0); + } + public KW_DIRECTORY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIRECTORY, 0); + } + public KW_LOCAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCAL, 0); + } + public rowFormat(): RowFormatContext | null { + return this.getRuleContext(0, RowFormatContext); + } + public createFileFormat(): CreateFileFormatContext | null { + return this.getRuleContext(0, CreateFileFormatContext); + } + public tableProvider(): TableProviderContext | null { + return this.getRuleContext(0, TableProviderContext); + } + public KW_OPTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTIONS, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public propertyList(): PropertyListContext | null { + return this.getRuleContext(0, PropertyListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_insertInto; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterInsertInto) { + listener.enterInsertInto(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitInsertInto) { + listener.exitInsertInto(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitInsertInto) { + return visitor.visitInsertInto(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public override get ruleIndex(): number { + return SqlParser.RULE_showStatement; + } + public override copyFrom(ctx: ShowStatementContext): void { + super.copyFrom(ctx); + } +} +export class ShowTblPropertiesContext extends ShowStatementContext { + public _table?: TableNameContext; + public _key?: PropertyKeyContext; + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_TBLPROPERTIES(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TBLPROPERTIES, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public propertyKey(): PropertyKeyContext | null { + return this.getRuleContext(0, PropertyKeyContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowTblProperties) { + listener.enterShowTblProperties(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowTblProperties) { + listener.exitShowTblProperties(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowTblProperties) { + return visitor.visitShowTblProperties(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowCatalogsContext extends ShowStatementContext { + public _pattern?: StringLitContext; + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_CATALOGS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CATALOGS, 0)!; + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIKE, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowCatalogs) { + listener.enterShowCatalogs(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowCatalogs) { + listener.exitShowCatalogs(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowCatalogs) { + return visitor.visitShowCatalogs(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowCurrentNamespaceContext extends ShowStatementContext { + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_CURRENT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CURRENT, 0)!; + } + public namespace(): NamespaceContext { + return this.getRuleContext(0, NamespaceContext)!; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowCurrentNamespace) { + listener.enterShowCurrentNamespace(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowCurrentNamespace) { + listener.exitShowCurrentNamespace(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowCurrentNamespace) { + return visitor.visitShowCurrentNamespace(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowViewsContext extends ShowStatementContext { + public _pattern?: StringLitContext; + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_VIEWS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_VIEWS, 0)!; + } + public namespaceName(): NamespaceNameContext | null { + return this.getRuleContext(0, NamespaceNameContext); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FROM, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIKE, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowViews) { + listener.enterShowViews(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowViews) { + listener.exitShowViews(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowViews) { + return visitor.visitShowViews(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowPartitionsContext extends ShowStatementContext { + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_PARTITIONS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_PARTITIONS, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public partitionSpec(): PartitionSpecContext | null { + return this.getRuleContext(0, PartitionSpecContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowPartitions) { + listener.enterShowPartitions(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowPartitions) { + listener.exitShowPartitions(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowPartitions) { + return visitor.visitShowPartitions(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowFunctionsContext extends ShowStatementContext { + public _ns?: NamespaceNameContext; + public _legacy?: MultipartIdentifierContext; + public _pattern?: StringLitContext; + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_FUNCTIONS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FUNCTIONS, 0)!; + } + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_USER, 0); + } + public KW_SYSTEM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYSTEM, 0); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALL, 0); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FROM, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public namespaceName(): NamespaceNameContext | null { + return this.getRuleContext(0, NamespaceNameContext); + } + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIKE, 0); + } + public multipartIdentifier(): MultipartIdentifierContext | null { + return this.getRuleContext(0, MultipartIdentifierContext); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowFunctions) { + listener.enterShowFunctions(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowFunctions) { + listener.exitShowFunctions(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowFunctions) { + return visitor.visitShowFunctions(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowTablesContext extends ShowStatementContext { + public _pattern?: StringLitContext; + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_TABLES(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLES, 0)!; + } + public namespaceName(): NamespaceNameContext | null { + return this.getRuleContext(0, NamespaceNameContext); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FROM, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIKE, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowTables) { + listener.enterShowTables(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowTables) { + listener.exitShowTables(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowTables) { + return visitor.visitShowTables(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowCreateTableContext extends ShowStatementContext { + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CREATE, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public KW_SERDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDE, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowCreateTable) { + listener.enterShowCreateTable(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowCreateTable) { + listener.exitShowCreateTable(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowCreateTable) { + return visitor.visitShowCreateTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowNamespacesContext extends ShowStatementContext { + public _pattern?: StringLitContext; + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_NAMESPACES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NAMESPACES, 0); + } + public KW_DATABASES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATABASES, 0); + } + public KW_SCHEMAS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SCHEMAS, 0); + } + public multipartIdentifier(): MultipartIdentifierContext | null { + return this.getRuleContext(0, MultipartIdentifierContext); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FROM, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIKE, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowNamespaces) { + listener.enterShowNamespaces(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowNamespaces) { + listener.exitShowNamespaces(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowNamespaces) { + return visitor.visitShowNamespaces(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowTableExtendedContext extends ShowStatementContext { + public _ns?: NamespaceNameContext; + public _pattern?: StringLitContext; + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public KW_EXTENDED(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_EXTENDED, 0)!; + } + public KW_LIKE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_LIKE, 0)!; + } + public stringLit(): StringLitContext { + return this.getRuleContext(0, StringLitContext)!; + } + public partitionSpec(): PartitionSpecContext | null { + return this.getRuleContext(0, PartitionSpecContext); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FROM, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public namespaceName(): NamespaceNameContext | null { + return this.getRuleContext(0, NamespaceNameContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowTableExtended) { + listener.enterShowTableExtended(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowTableExtended) { + listener.exitShowTableExtended(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowTableExtended) { + return visitor.visitShowTableExtended(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowColumnsContext extends ShowStatementContext { + public _table?: TableNameContext; + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_COLUMNS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_COLUMNS, 0)!; + } + public KW_FROM(): antlr.TerminalNode[]; + public KW_FROM(i: number): antlr.TerminalNode | null; + public KW_FROM(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_FROM); + } else { + return this.getToken(SqlParser.KW_FROM, i); + } + } + public KW_IN(): antlr.TerminalNode[]; + public KW_IN(i: number): antlr.TerminalNode | null; + public KW_IN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_IN); + } else { + return this.getToken(SqlParser.KW_IN, i); + } + } + public tableName(): TableNameContext { + return this.getRuleContext(0, TableNameContext)!; + } + public namespaceName(): NamespaceNameContext | null { + return this.getRuleContext(0, NamespaceNameContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowColumns) { + listener.enterShowColumns(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowColumns) { + listener.exitShowColumns(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowColumns) { + return visitor.visitShowColumns(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ShowOtherContext extends ShowStatementContext { + public constructor(ctx: ShowStatementContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SHOW, 0)!; + } + public KW_GRANT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GRANT, 0); + } + public KW_PRINCIPALS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PRINCIPALS, 0); + } + public KW_ROLES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLES, 0); + } + public KW_COMPACTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMPACTIONS, 0); + } + public KW_TRANSACTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRANSACTIONS, 0); + } + public KW_INDEXES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INDEXES, 0); + } + public KW_LOCKS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCKS, 0); + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLE, 0); + } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT, 0); + } + public KW_CREATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CREATE, 0); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLE, 0); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterShowOther) { + listener.enterShowOther(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitShowOther) { + listener.exitShowOther(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitShowOther) { + return visitor.visitShowOther(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnsupportedCommandsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_GRANT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GRANT, 0); + } + public KW_REVOKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REVOKE, 0); + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLE, 0); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLE, 0); + } + public KW_EXPORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXPORT, 0); + } + public KW_IMPORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IMPORT, 0); + } + public KW_LOCK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCK, 0); + } + public KW_UNLOCK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNLOCK, 0); + } + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATABASE, 0); + } + public KW_START(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_START, 0); + } + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRANSACTION, 0); + } + public KW_COMMIT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMIT, 0); + } + public KW_ROLLBACK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLLBACK, 0); + } + public KW_DFS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DFS, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_unsupportedCommands; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnsupportedCommands) { + listener.enterUnsupportedCommands(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnsupportedCommands) { + listener.exitUnsupportedCommands(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnsupportedCommands) { + return visitor.visitUnsupportedCommands(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BucketSpecContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_CLUSTERED(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_CLUSTERED, 0)!; + } + public KW_BY(): antlr.TerminalNode[]; + public KW_BY(i: number): antlr.TerminalNode | null; + public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_BY); + } else { + return this.getToken(SqlParser.KW_BY, i); + } + } + public identifierList(): IdentifierListContext { + return this.getRuleContext(0, IdentifierListContext)!; + } + public KW_INTO(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_INTO, 0)!; + } + public INTEGER_VALUE(): antlr.TerminalNode { + return this.getToken(SqlParser.INTEGER_VALUE, 0)!; + } + public KW_BUCKETS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_BUCKETS, 0)!; + } + public KW_SORTED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SORTED, 0); + } + public orderedIdentifierList(): OrderedIdentifierListContext | null { + return this.getRuleContext(0, OrderedIdentifierListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_bucketSpec; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterBucketSpec) { + listener.enterBucketSpec(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitBucketSpec) { + listener.exitBucketSpec(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitBucketSpec) { + return visitor.visitBucketSpec(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SkewSpecContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_SKEWED(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SKEWED, 0)!; + } + public KW_BY(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_BY, 0)!; + } + public identifierList(): IdentifierListContext { + return this.getRuleContext(0, IdentifierListContext)!; + } + public KW_ON(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_ON, 0)!; + } + public constantList(): ConstantListContext | null { + return this.getRuleContext(0, ConstantListContext); + } + public nestedConstantList(): NestedConstantListContext | null { + return this.getRuleContext(0, NestedConstantListContext); + } + public KW_STORED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STORED, 0); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public KW_DIRECTORIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIRECTORIES, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_skewSpec; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterSkewSpec) { + listener.enterSkewSpec(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitSkewSpec) { + listener.exitSkewSpec(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitSkewSpec) { + return visitor.visitSkewSpec(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QueryContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public override get ruleIndex(): number { + return SqlParser.RULE_query; + } + public override copyFrom(ctx: QueryContext): void { + super.copyFrom(ctx); + } +} +export class QueryStatementContext extends QueryContext { + public constructor(ctx: QueryContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public queryTerm(): QueryTermContext { + return this.getRuleContext(0, QueryTermContext)!; + } + public queryOrganization(): QueryOrganizationContext { + return this.getRuleContext(0, QueryOrganizationContext)!; + } + public ctes(): CtesContext | null { + return this.getRuleContext(0, CtesContext); + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQueryStatement) { + listener.enterQueryStatement(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQueryStatement) { + listener.exitQueryStatement(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQueryStatement) { + return visitor.visitQueryStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PartitionSpecLocationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public partitionSpec(): PartitionSpecContext { + return this.getRuleContext(0, PartitionSpecContext)!; + } + public KW_LOCATION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCATION, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_partitionSpecLocation; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPartitionSpecLocation) { + listener.enterPartitionSpecLocation(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPartitionSpecLocation) { + listener.exitPartitionSpecLocation(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPartitionSpecLocation) { + return visitor.visitPartitionSpecLocation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PartitionSpecContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_PARTITION(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_PARTITION, 0)!; + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public partitionVal(): PartitionValContext[]; + public partitionVal(i: number): PartitionValContext | null; + public partitionVal(i?: number): PartitionValContext[] | PartitionValContext | null { + if (i === undefined) { + return this.getRuleContexts(PartitionValContext); + } + + return this.getRuleContext(i, PartitionValContext); + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_partitionSpec; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPartitionSpec) { + listener.enterPartitionSpec(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPartitionSpec) { + listener.exitPartitionSpec(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPartitionSpec) { + return visitor.visitPartitionSpec(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PartitionValContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext)!; + } + public EQ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.EQ, 0); + } + public constant(): ConstantContext | null { + return this.getRuleContext(0, ConstantContext); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFAULT, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_partitionVal; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPartitionVal) { + listener.enterPartitionVal(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPartitionVal) { + listener.exitPartitionVal(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPartitionVal) { + return visitor.visitPartitionVal(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NamespaceContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_NAMESPACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NAMESPACE, 0); + } + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATABASE, 0); + } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SCHEMA, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_namespace; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNamespace) { + listener.enterNamespace(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNamespace) { + listener.exitNamespace(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNamespace) { + return visitor.visitNamespace(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DescribeFuncNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifierReference(): IdentifierReferenceContext | null { + return this.getRuleContext(0, IdentifierReferenceContext); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public comparisonOperator(): ComparisonOperatorContext | null { + return this.getRuleContext(0, ComparisonOperatorContext); + } + public arithmeticOperator(): ArithmeticOperatorContext | null { + return this.getRuleContext(0, ArithmeticOperatorContext); + } + public predicateOperator(): PredicateOperatorContext | null { + return this.getRuleContext(0, PredicateOperatorContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_describeFuncName; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDescribeFuncName) { + listener.enterDescribeFuncName(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDescribeFuncName) { + listener.exitDescribeFuncName(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDescribeFuncName) { + return visitor.visitDescribeFuncName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DescribeColNameContext extends antlr.ParserRuleContext { + public _identifier?: IdentifierContext; + public _nameParts: IdentifierContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.DOT); + } else { + return this.getToken(SqlParser.DOT, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_describeColName; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDescribeColName) { + listener.enterDescribeColName(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDescribeColName) { + listener.exitDescribeColName(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDescribeColName) { + return visitor.visitDescribeColName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CtesContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_WITH(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_WITH, 0)!; + } + public namedQuery(): NamedQueryContext[]; + public namedQuery(i: number): NamedQueryContext | null; + public namedQuery(i?: number): NamedQueryContext[] | NamedQueryContext | null { + if (i === undefined) { + return this.getRuleContexts(NamedQueryContext); + } + + return this.getRuleContext(i, NamedQueryContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_ctes; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCtes) { + listener.enterCtes(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCtes) { + listener.exitCtes(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCtes) { + return visitor.visitCtes(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NamedQueryContext extends antlr.ParserRuleContext { + public _name?: ErrorCapturingIdentifierContext; + public _columnAliases?: IdentifierListContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public query(): QueryContext { + return this.getRuleContext(0, QueryContext)!; + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext { + return this.getRuleContext(0, ErrorCapturingIdentifierContext)!; + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public identifierList(): IdentifierListContext | null { + return this.getRuleContext(0, IdentifierListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_namedQuery; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNamedQuery) { + listener.enterNamedQuery(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNamedQuery) { + listener.exitNamedQuery(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNamedQuery) { + return visitor.visitNamedQuery(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableProviderContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_USING(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_USING, 0)!; + } + public multipartIdentifier(): MultipartIdentifierContext { + return this.getRuleContext(0, MultipartIdentifierContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_tableProvider; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTableProvider) { + listener.enterTableProvider(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTableProvider) { + listener.exitTableProvider(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTableProvider) { + return visitor.visitTableProvider(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateTableClausesContext extends antlr.ParserRuleContext { + public _options?: ExpressionPropertyListContext; + public _partitioning?: PartitionFieldListContext; + public _comment?: StringLitContext; + public _tableProps?: PropertyListContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public skewSpec(): SkewSpecContext[]; + public skewSpec(i: number): SkewSpecContext | null; + public skewSpec(i?: number): SkewSpecContext[] | SkewSpecContext | null { + if (i === undefined) { + return this.getRuleContexts(SkewSpecContext); + } + + return this.getRuleContext(i, SkewSpecContext); + } + public bucketSpec(): BucketSpecContext[]; + public bucketSpec(i: number): BucketSpecContext | null; + public bucketSpec(i?: number): BucketSpecContext[] | BucketSpecContext | null { + if (i === undefined) { + return this.getRuleContexts(BucketSpecContext); + } + + return this.getRuleContext(i, BucketSpecContext); + } + public rowFormat(): RowFormatContext[]; + public rowFormat(i: number): RowFormatContext | null; + public rowFormat(i?: number): RowFormatContext[] | RowFormatContext | null { + if (i === undefined) { + return this.getRuleContexts(RowFormatContext); + } + + return this.getRuleContext(i, RowFormatContext); + } + public createFileFormat(): CreateFileFormatContext[]; + public createFileFormat(i: number): CreateFileFormatContext | null; + public createFileFormat(i?: number): CreateFileFormatContext[] | CreateFileFormatContext | null { + if (i === undefined) { + return this.getRuleContexts(CreateFileFormatContext); + } + + return this.getRuleContext(i, CreateFileFormatContext); + } + public tableLifecycle(): TableLifecycleContext[]; + public tableLifecycle(i: number): TableLifecycleContext | null; + public tableLifecycle(i?: number): TableLifecycleContext[] | TableLifecycleContext | null { + if (i === undefined) { + return this.getRuleContexts(TableLifecycleContext); + } + + return this.getRuleContext(i, TableLifecycleContext); + } + public KW_OPTIONS(): antlr.TerminalNode[]; + public KW_OPTIONS(i: number): antlr.TerminalNode | null; + public KW_OPTIONS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_OPTIONS); + } else { + return this.getToken(SqlParser.KW_OPTIONS, i); + } + } + public KW_PARTITIONED(): antlr.TerminalNode[]; + public KW_PARTITIONED(i: number): antlr.TerminalNode | null; + public KW_PARTITIONED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_PARTITIONED); + } else { + return this.getToken(SqlParser.KW_PARTITIONED, i); + } + } + public KW_BY(): antlr.TerminalNode[]; + public KW_BY(i: number): antlr.TerminalNode | null; + public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_BY); + } else { + return this.getToken(SqlParser.KW_BY, i); + } + } + public KW_LOCATION(): antlr.TerminalNode[]; + public KW_LOCATION(i: number): antlr.TerminalNode | null; + public KW_LOCATION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_LOCATION); + } else { + return this.getToken(SqlParser.KW_LOCATION, i); + } + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public KW_COMMENT(): antlr.TerminalNode[]; + public KW_COMMENT(i: number): antlr.TerminalNode | null; + public KW_COMMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_COMMENT); + } else { + return this.getToken(SqlParser.KW_COMMENT, i); + } + } + public KW_TBLPROPERTIES(): antlr.TerminalNode[]; + public KW_TBLPROPERTIES(i: number): antlr.TerminalNode | null; + public KW_TBLPROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_TBLPROPERTIES); + } else { + return this.getToken(SqlParser.KW_TBLPROPERTIES, i); + } + } + public expressionPropertyList(): ExpressionPropertyListContext[]; + public expressionPropertyList(i: number): ExpressionPropertyListContext | null; + public expressionPropertyList(i?: number): ExpressionPropertyListContext[] | ExpressionPropertyListContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionPropertyListContext); + } + + return this.getRuleContext(i, ExpressionPropertyListContext); + } + public partitionFieldList(): PartitionFieldListContext[]; + public partitionFieldList(i: number): PartitionFieldListContext | null; + public partitionFieldList(i?: number): PartitionFieldListContext[] | PartitionFieldListContext | null { + if (i === undefined) { + return this.getRuleContexts(PartitionFieldListContext); + } + + return this.getRuleContext(i, PartitionFieldListContext); + } + public propertyList(): PropertyListContext[]; + public propertyList(i: number): PropertyListContext | null; + public propertyList(i?: number): PropertyListContext[] | PropertyListContext | null { + if (i === undefined) { + return this.getRuleContexts(PropertyListContext); + } + + return this.getRuleContext(i, PropertyListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_createTableClauses; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateTableClauses) { + listener.enterCreateTableClauses(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateTableClauses) { + listener.exitCreateTableClauses(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateTableClauses) { + return visitor.visitCreateTableClauses(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableLifecycleContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_LIFECYCLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_LIFECYCLE, 0)!; + } + public INTEGER_VALUE(): antlr.TerminalNode { + return this.getToken(SqlParser.INTEGER_VALUE, 0)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_tableLifecycle; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTableLifecycle) { + listener.enterTableLifecycle(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTableLifecycle) { + listener.exitTableLifecycle(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTableLifecycle) { + return visitor.visitTableLifecycle(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PropertyListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public property(): PropertyContext[]; + public property(i: number): PropertyContext | null; + public property(i?: number): PropertyContext[] | PropertyContext | null { + if (i === undefined) { + return this.getRuleContexts(PropertyContext); + } + + return this.getRuleContext(i, PropertyContext); + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_propertyList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPropertyList) { + listener.enterPropertyList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPropertyList) { + listener.exitPropertyList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPropertyList) { + return visitor.visitPropertyList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PropertyContext extends antlr.ParserRuleContext { + public _key?: PropertyKeyContext; + public _value?: PropertyValueContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public propertyKey(): PropertyKeyContext { + return this.getRuleContext(0, PropertyKeyContext)!; + } + public propertyValue(): PropertyValueContext | null { + return this.getRuleContext(0, PropertyValueContext); + } + public EQ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.EQ, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_property; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterProperty) { + listener.enterProperty(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitProperty) { + listener.exitProperty(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitProperty) { + return visitor.visitProperty(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PropertyKeyContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.DOT); + } else { + return this.getToken(SqlParser.DOT, i); + } + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_propertyKey; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPropertyKey) { + listener.enterPropertyKey(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPropertyKey) { + listener.exitPropertyKey(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPropertyKey) { + return visitor.visitPropertyKey(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PropertyValueContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public INTEGER_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.INTEGER_VALUE, 0); + } + public DECIMAL_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DECIMAL_VALUE, 0); + } + public booleanValue(): BooleanValueContext | null { + return this.getRuleContext(0, BooleanValueContext); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_propertyValue; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPropertyValue) { + listener.enterPropertyValue(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPropertyValue) { + listener.exitPropertyValue(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPropertyValue) { + return visitor.visitPropertyValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ExpressionPropertyListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public expressionProperty(): ExpressionPropertyContext[]; + public expressionProperty(i: number): ExpressionPropertyContext | null; + public expressionProperty(i?: number): ExpressionPropertyContext[] | ExpressionPropertyContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionPropertyContext); + } + + return this.getRuleContext(i, ExpressionPropertyContext); + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_expressionPropertyList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterExpressionPropertyList) { + listener.enterExpressionPropertyList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitExpressionPropertyList) { + listener.exitExpressionPropertyList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitExpressionPropertyList) { + return visitor.visitExpressionPropertyList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ExpressionPropertyContext extends antlr.ParserRuleContext { + public _key?: PropertyKeyContext; + public _value?: ExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public propertyKey(): PropertyKeyContext { + return this.getRuleContext(0, PropertyKeyContext)!; + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public EQ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.EQ, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_expressionProperty; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterExpressionProperty) { + listener.enterExpressionProperty(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitExpressionProperty) { + listener.exitExpressionProperty(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitExpressionProperty) { + return visitor.visitExpressionProperty(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ConstantListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public constant(): ConstantContext[]; + public constant(i: number): ConstantContext | null; + public constant(i?: number): ConstantContext[] | ConstantContext | null { + if (i === undefined) { + return this.getRuleContexts(ConstantContext); + } + + return this.getRuleContext(i, ConstantContext); + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_constantList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterConstantList) { + listener.enterConstantList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitConstantList) { + listener.exitConstantList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitConstantList) { + return visitor.visitConstantList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NestedConstantListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public constantList(): ConstantListContext[]; + public constantList(i: number): ConstantListContext | null; + public constantList(i?: number): ConstantListContext[] | ConstantListContext | null { + if (i === undefined) { + return this.getRuleContexts(ConstantListContext); + } + + return this.getRuleContext(i, ConstantListContext); + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_nestedConstantList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNestedConstantList) { + listener.enterNestedConstantList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNestedConstantList) { + listener.exitNestedConstantList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNestedConstantList) { + return visitor.visitNestedConstantList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateFileFormatContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_STORED(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_STORED, 0)!; + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public fileFormat(): FileFormatContext | null { + return this.getRuleContext(0, FileFormatContext); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BY, 0); + } + public storageHandler(): StorageHandlerContext | null { + return this.getRuleContext(0, StorageHandlerContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_createFileFormat; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateFileFormat) { + listener.enterCreateFileFormat(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateFileFormat) { + listener.exitCreateFileFormat(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateFileFormat) { + return visitor.visitCreateFileFormat(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FileFormatContext extends antlr.ParserRuleContext { + public _inFmt?: StringLitContext; + public _outFmt?: StringLitContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_INPUTFORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INPUTFORMAT, 0); + } + public KW_OUTPUTFORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OUTPUTFORMAT, 0); + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_fileFormat; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFileFormat) { + listener.enterFileFormat(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFileFormat) { + listener.exitFileFormat(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFileFormat) { + return visitor.visitFileFormat(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class StorageHandlerContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public stringLit(): StringLitContext { + return this.getRuleContext(0, StringLitContext)!; + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WITH, 0); + } + public KW_SERDEPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDEPROPERTIES, 0); + } + public propertyList(): PropertyListContext | null { + return this.getRuleContext(0, PropertyListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_storageHandler; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterStorageHandler) { + listener.enterStorageHandler(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitStorageHandler) { + listener.exitStorageHandler(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitStorageHandler) { + return visitor.visitStorageHandler(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NamespaceNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifierReference(): IdentifierReferenceContext { + return this.getRuleContext(0, IdentifierReferenceContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_namespaceName; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNamespaceName) { + listener.enterNamespaceName(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNamespaceName) { + listener.exitNamespaceName(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNamespaceName) { + return visitor.visitNamespaceName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NamespaceNameCreateContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifierReference(): IdentifierReferenceContext { + return this.getRuleContext(0, IdentifierReferenceContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_namespaceNameCreate; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNamespaceNameCreate) { + listener.enterNamespaceNameCreate(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNamespaceNameCreate) { + listener.exitNamespaceNameCreate(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNamespaceNameCreate) { + return visitor.visitNamespaceNameCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableNameCreateContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public tableIdentifier(): TableIdentifierContext { + return this.getRuleContext(0, TableIdentifierContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_tableNameCreate; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTableNameCreate) { + listener.enterTableNameCreate(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTableNameCreate) { + listener.exitTableNameCreate(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTableNameCreate) { + return visitor.visitTableNameCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public tableIdentifier(): TableIdentifierContext { + return this.getRuleContext(0, TableIdentifierContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_tableName; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTableName) { + listener.enterTableName(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTableName) { + listener.exitTableName(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTableName) { + return visitor.visitTableName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ViewNameCreateContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public viewIdentifier(): ViewIdentifierContext { + return this.getRuleContext(0, ViewIdentifierContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_viewNameCreate; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterViewNameCreate) { + listener.enterViewNameCreate(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitViewNameCreate) { + listener.exitViewNameCreate(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitViewNameCreate) { + return visitor.visitViewNameCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ViewNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public viewIdentifier(): ViewIdentifierContext { + return this.getRuleContext(0, ViewIdentifierContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_viewName; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterViewName) { + listener.enterViewName(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitViewName) { + listener.exitViewName(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitViewName) { + return visitor.visitViewName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public multipartIdentifier(): MultipartIdentifierContext | null { + return this.getRuleContext(0, MultipartIdentifierContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_columnName; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterColumnName) { + listener.enterColumnName(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitColumnName) { + listener.exitColumnName(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitColumnName) { + return visitor.visitColumnName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnNameSeqContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public columnName(): ColumnNameContext[]; + public columnName(i: number): ColumnNameContext | null; + public columnName(i?: number): ColumnNameContext[] | ColumnNameContext | null { + if (i === undefined) { + return this.getRuleContexts(ColumnNameContext); + } + + return this.getRuleContext(i, ColumnNameContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_columnNameSeq; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterColumnNameSeq) { + listener.enterColumnNameSeq(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitColumnNameSeq) { + listener.exitColumnNameSeq(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitColumnNameSeq) { + return visitor.visitColumnNameSeq(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnNameCreateContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext { + return this.getRuleContext(0, ErrorCapturingIdentifierContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_columnNameCreate; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterColumnNameCreate) { + listener.enterColumnNameCreate(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitColumnNameCreate) { + listener.exitColumnNameCreate(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitColumnNameCreate) { + return visitor.visitColumnNameCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IdentifierReferenceContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_IDENTIFIER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IDENTIFIER, 0); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public multipartIdentifier(): MultipartIdentifierContext | null { + return this.getRuleContext(0, MultipartIdentifierContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_identifierReference; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterIdentifierReference) { + listener.enterIdentifierReference(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitIdentifierReference) { + listener.exitIdentifierReference(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitIdentifierReference) { + return visitor.visitIdentifierReference(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QueryOrganizationContext extends antlr.ParserRuleContext { + public _sortItem?: SortItemContext; + public _order: SortItemContext[] = []; + public _expression?: ExpressionContext; + public _clusterBy: ExpressionContext[] = []; + public _distributeBy: ExpressionContext[] = []; + public _sort: SortItemContext[] = []; + public _limit?: ExpressionContext; + public _offset?: ExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_ORDER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ORDER, 0); + } + public KW_BY(): antlr.TerminalNode[]; + public KW_BY(i: number): antlr.TerminalNode | null; + public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_BY); + } else { + return this.getToken(SqlParser.KW_BY, i); + } + } + public KW_CLUSTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CLUSTER, 0); + } + public KW_DISTRIBUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISTRIBUTE, 0); + } + public KW_SORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SORT, 0); + } + public windowClause(): WindowClauseContext | null { + return this.getRuleContext(0, WindowClauseContext); + } + public KW_LIMIT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIMIT, 0); + } + public KW_OFFSET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OFFSET, 0); + } + public sortItem(): SortItemContext[]; + public sortItem(i: number): SortItemContext | null; + public sortItem(i?: number): SortItemContext[] | SortItemContext | null { + if (i === undefined) { + return this.getRuleContexts(SortItemContext); + } + + return this.getRuleContext(i, SortItemContext); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALL, 0); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_queryOrganization; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQueryOrganization) { + listener.enterQueryOrganization(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQueryOrganization) { + listener.exitQueryOrganization(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQueryOrganization) { + return visitor.visitQueryOrganization(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QueryTermContext extends antlr.ParserRuleContext { + public _left?: QueryTermContext; + public _operator?: Token | null; + public _right?: QueryTermContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public queryPrimary(): QueryPrimaryContext | null { + return this.getRuleContext(0, QueryPrimaryContext); + } + public queryTerm(): QueryTermContext[]; + public queryTerm(i: number): QueryTermContext | null; + public queryTerm(i?: number): QueryTermContext[] | QueryTermContext | null { + if (i === undefined) { + return this.getRuleContexts(QueryTermContext); + } + + return this.getRuleContext(i, QueryTermContext); + } + public KW_INTERSECT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTERSECT, 0); + } + public KW_UNION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNION, 0); + } + public KW_EXCEPT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXCEPT, 0); + } + public KW_MINUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUS, 0); + } + public setQuantifier(): SetQuantifierContext | null { + return this.getRuleContext(0, SetQuantifierContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_queryTerm; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQueryTerm) { + listener.enterQueryTerm(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQueryTerm) { + listener.exitQueryTerm(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQueryTerm) { + return visitor.visitQueryTerm(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QueryPrimaryContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public querySpecification(): QuerySpecificationContext | null { + return this.getRuleContext(0, QuerySpecificationContext); + } + public fromClause(): FromClauseContext | null { + return this.getRuleContext(0, FromClauseContext); + } + public fromStatementBody(): FromStatementBodyContext[]; + public fromStatementBody(i: number): FromStatementBodyContext | null; + public fromStatementBody(i?: number): FromStatementBodyContext[] | FromStatementBodyContext | null { + if (i === undefined) { + return this.getRuleContexts(FromStatementBodyContext); + } + + return this.getRuleContext(i, FromStatementBodyContext); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLE, 0); + } + public tableName(): TableNameContext | null { + return this.getRuleContext(0, TableNameContext); + } + public KW_VALUES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VALUES, 0); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public tableAlias(): TableAliasContext | null { + return this.getRuleContext(0, TableAliasContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_queryPrimary; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQueryPrimary) { + listener.enterQueryPrimary(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQueryPrimary) { + listener.exitQueryPrimary(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQueryPrimary) { + return visitor.visitQueryPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SortItemContext extends antlr.ParserRuleContext { + public _ordering?: Token | null; + public _nullOrder?: Token | null; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public columnName(): ColumnNameContext | null { + return this.getRuleContext(0, ColumnNameContext); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public KW_NULLS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULLS, 0); + } + public KW_ASC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ASC, 0); + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESC, 0); + } + public KW_LAST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LAST, 0); + } + public KW_FIRST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FIRST, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_sortItem; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterSortItem) { + listener.enterSortItem(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitSortItem) { + listener.exitSortItem(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitSortItem) { + return visitor.visitSortItem(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FromStatementBodyContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public transformClause(): TransformClauseContext | null { + return this.getRuleContext(0, TransformClauseContext); + } + public queryOrganization(): QueryOrganizationContext { + return this.getRuleContext(0, QueryOrganizationContext)!; + } + public whereClause(): WhereClauseContext | null { + return this.getRuleContext(0, WhereClauseContext); + } + public selectClause(): SelectClauseContext | null { + return this.getRuleContext(0, SelectClauseContext); + } + public lateralView(): LateralViewContext[]; + public lateralView(i: number): LateralViewContext | null; + public lateralView(i?: number): LateralViewContext[] | LateralViewContext | null { + if (i === undefined) { + return this.getRuleContexts(LateralViewContext); + } + + return this.getRuleContext(i, LateralViewContext); + } + public aggregationClause(): AggregationClauseContext | null { + return this.getRuleContext(0, AggregationClauseContext); + } + public havingClause(): HavingClauseContext | null { + return this.getRuleContext(0, HavingClauseContext); + } + public windowClause(): WindowClauseContext | null { + return this.getRuleContext(0, WindowClauseContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_fromStatementBody; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFromStatementBody) { + listener.enterFromStatementBody(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFromStatementBody) { + listener.exitFromStatementBody(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFromStatementBody) { + return visitor.visitFromStatementBody(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QuerySpecificationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public transformClause(): TransformClauseContext | null { + return this.getRuleContext(0, TransformClauseContext); + } + public fromClause(): FromClauseContext | null { + return this.getRuleContext(0, FromClauseContext); + } + public lateralView(): LateralViewContext[]; + public lateralView(i: number): LateralViewContext | null; + public lateralView(i?: number): LateralViewContext[] | LateralViewContext | null { + if (i === undefined) { + return this.getRuleContexts(LateralViewContext); + } + + return this.getRuleContext(i, LateralViewContext); + } + public whereClause(): WhereClauseContext | null { + return this.getRuleContext(0, WhereClauseContext); + } + public aggregationClause(): AggregationClauseContext | null { + return this.getRuleContext(0, AggregationClauseContext); + } + public havingClause(): HavingClauseContext | null { + return this.getRuleContext(0, HavingClauseContext); + } + public windowClause(): WindowClauseContext | null { + return this.getRuleContext(0, WindowClauseContext); + } + public selectClause(): SelectClauseContext | null { + return this.getRuleContext(0, SelectClauseContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_querySpecification; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQuerySpecification) { + listener.enterQuerySpecification(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQuerySpecification) { + listener.exitQuerySpecification(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQuerySpecification) { + return visitor.visitQuerySpecification(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TransformClauseContext extends antlr.ParserRuleContext { + public _kind?: Token | null; + public _inRowFormat?: RowFormatContext; + public _recordWriter?: StringLitContext; + public _script?: StringLitContext; + public _outRowFormat?: RowFormatContext; + public _recordReader?: StringLitContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_USING(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_USING, 0)!; + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public KW_SELECT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SELECT, 0); + } + public LEFT_PAREN(): antlr.TerminalNode[]; + public LEFT_PAREN(i: number): antlr.TerminalNode | null; + public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.LEFT_PAREN); + } else { + return this.getToken(SqlParser.LEFT_PAREN, i); + } + } + public expressionSeq(): ExpressionSeqContext | null { + return this.getRuleContext(0, ExpressionSeqContext); + } + public RIGHT_PAREN(): antlr.TerminalNode[]; + public RIGHT_PAREN(i: number): antlr.TerminalNode | null; + public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.RIGHT_PAREN); + } else { + return this.getToken(SqlParser.RIGHT_PAREN, i); + } + } + public KW_TRANSFORM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRANSFORM, 0); + } + public KW_MAP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MAP, 0); + } + public KW_REDUCE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REDUCE, 0); + } + public KW_RECORDWRITER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RECORDWRITER, 0); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public KW_RECORDREADER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RECORDREADER, 0); + } + public rowFormat(): RowFormatContext[]; + public rowFormat(i: number): RowFormatContext | null; + public rowFormat(i?: number): RowFormatContext[] | RowFormatContext | null { + if (i === undefined) { + return this.getRuleContexts(RowFormatContext); + } + + return this.getRuleContext(i, RowFormatContext); + } + public setQuantifier(): SetQuantifierContext | null { + return this.getRuleContext(0, SetQuantifierContext); + } + public identifierSeq(): IdentifierSeqContext | null { + return this.getRuleContext(0, IdentifierSeqContext); + } + public colTypeList(): ColTypeListContext | null { + return this.getRuleContext(0, ColTypeListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_transformClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTransformClause) { + listener.enterTransformClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTransformClause) { + listener.exitTransformClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTransformClause) { + return visitor.visitTransformClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SelectClauseContext extends antlr.ParserRuleContext { + public _hint?: HintContext; + public _hints: HintContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_SELECT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SELECT, 0)!; + } + public namedExpressionSeq(): NamedExpressionSeqContext { + return this.getRuleContext(0, NamedExpressionSeqContext)!; + } + public setQuantifier(): SetQuantifierContext | null { + return this.getRuleContext(0, SetQuantifierContext); + } + public hint(): HintContext[]; + public hint(i: number): HintContext | null; + public hint(i?: number): HintContext[] | HintContext | null { + if (i === undefined) { + return this.getRuleContexts(HintContext); + } + + return this.getRuleContext(i, HintContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_selectClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterSelectClause) { + listener.enterSelectClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitSelectClause) { + listener.exitSelectClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitSelectClause) { + return visitor.visitSelectClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SetClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_SET(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SET, 0)!; + } + public assignmentList(): AssignmentListContext { + return this.getRuleContext(0, AssignmentListContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_setClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterSetClause) { + listener.enterSetClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitSetClause) { + listener.exitSetClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitSetClause) { + return visitor.visitSetClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MatchedClauseContext extends antlr.ParserRuleContext { + public _matchedCond?: BooleanExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_WHEN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_WHEN, 0)!; + } + public KW_MATCHED(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_MATCHED, 0)!; + } + public KW_THEN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_THEN, 0)!; + } + public KW_DELETE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DELETE, 0); + } + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UPDATE, 0); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SET, 0); + } + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AND, 0); + } + public booleanExpression(): BooleanExpressionContext | null { + return this.getRuleContext(0, BooleanExpressionContext); + } + public ASTERISK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.ASTERISK, 0); + } + public assignmentList(): AssignmentListContext | null { + return this.getRuleContext(0, AssignmentListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_matchedClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterMatchedClause) { + listener.enterMatchedClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitMatchedClause) { + listener.exitMatchedClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitMatchedClause) { + return visitor.visitMatchedClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NotMatchedClauseContext extends antlr.ParserRuleContext { + public _notMatchedCond?: BooleanExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_WHEN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_WHEN, 0)!; + } + public KW_NOT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_NOT, 0)!; + } + public KW_MATCHED(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_MATCHED, 0)!; + } + public KW_THEN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_THEN, 0)!; + } + public notMatchedAction(): NotMatchedActionContext { + return this.getRuleContext(0, NotMatchedActionContext)!; + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BY, 0); + } + public KW_TARGET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TARGET, 0); + } + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AND, 0); + } + public booleanExpression(): BooleanExpressionContext | null { + return this.getRuleContext(0, BooleanExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_notMatchedClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNotMatchedClause) { + listener.enterNotMatchedClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNotMatchedClause) { + listener.exitNotMatchedClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNotMatchedClause) { + return visitor.visitNotMatchedClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NotMatchedBySourceClauseContext extends antlr.ParserRuleContext { + public _notMatchedBySourceCond?: BooleanExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_WHEN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_WHEN, 0)!; + } + public KW_NOT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_NOT, 0)!; + } + public KW_MATCHED(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_MATCHED, 0)!; + } + public KW_BY(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_BY, 0)!; + } + public KW_SOURCE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_SOURCE, 0)!; + } + public KW_THEN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_THEN, 0)!; + } + public KW_DELETE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DELETE, 0); + } + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UPDATE, 0); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SET, 0); + } + public assignmentList(): AssignmentListContext | null { + return this.getRuleContext(0, AssignmentListContext); + } + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AND, 0); + } + public booleanExpression(): BooleanExpressionContext | null { + return this.getRuleContext(0, BooleanExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_notMatchedBySourceClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNotMatchedBySourceClause) { + listener.enterNotMatchedBySourceClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNotMatchedBySourceClause) { + listener.exitNotMatchedBySourceClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNotMatchedBySourceClause) { + return visitor.visitNotMatchedBySourceClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NotMatchedActionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_INSERT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_INSERT, 0)!; + } + public ASTERISK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.ASTERISK, 0); + } + public LEFT_PAREN(): antlr.TerminalNode[]; + public LEFT_PAREN(i: number): antlr.TerminalNode | null; + public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.LEFT_PAREN); + } else { + return this.getToken(SqlParser.LEFT_PAREN, i); + } + } + public multipartIdentifierList(): MultipartIdentifierListContext | null { + return this.getRuleContext(0, MultipartIdentifierListContext); + } + public RIGHT_PAREN(): antlr.TerminalNode[]; + public RIGHT_PAREN(i: number): antlr.TerminalNode | null; + public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.RIGHT_PAREN); + } else { + return this.getToken(SqlParser.RIGHT_PAREN, i); + } + } + public KW_VALUES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VALUES, 0); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_notMatchedAction; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNotMatchedAction) { + listener.enterNotMatchedAction(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNotMatchedAction) { + listener.exitNotMatchedAction(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNotMatchedAction) { + return visitor.visitNotMatchedAction(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AssignmentListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public assignment(): AssignmentContext[]; + public assignment(i: number): AssignmentContext | null; + public assignment(i?: number): AssignmentContext[] | AssignmentContext | null { + if (i === undefined) { + return this.getRuleContexts(AssignmentContext); + } + + return this.getRuleContext(i, AssignmentContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_assignmentList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterAssignmentList) { + listener.enterAssignmentList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitAssignmentList) { + listener.exitAssignmentList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitAssignmentList) { + return visitor.visitAssignmentList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AssignmentContext extends antlr.ParserRuleContext { + public _key?: MultipartIdentifierContext; + public _value?: ExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public EQ(): antlr.TerminalNode { + return this.getToken(SqlParser.EQ, 0)!; + } + public multipartIdentifier(): MultipartIdentifierContext { + return this.getRuleContext(0, MultipartIdentifierContext)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_assignment; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterAssignment) { + listener.enterAssignment(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitAssignment) { + listener.exitAssignment(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitAssignment) { + return visitor.visitAssignment(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WhereClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_WHERE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_WHERE, 0)!; + } + public booleanExpression(): BooleanExpressionContext { + return this.getRuleContext(0, BooleanExpressionContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_whereClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterWhereClause) { + listener.enterWhereClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitWhereClause) { + listener.exitWhereClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitWhereClause) { + return visitor.visitWhereClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class HavingClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_HAVING(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_HAVING, 0)!; + } + public booleanExpression(): BooleanExpressionContext { + return this.getRuleContext(0, BooleanExpressionContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_havingClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterHavingClause) { + listener.enterHavingClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitHavingClause) { + listener.exitHavingClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitHavingClause) { + return visitor.visitHavingClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class HintContext extends antlr.ParserRuleContext { + public _hintStatement?: HintStatementContext; + public _hintStatements: HintStatementContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public HENT_START(): antlr.TerminalNode { + return this.getToken(SqlParser.HENT_START, 0)!; + } + public HENT_END(): antlr.TerminalNode { + return this.getToken(SqlParser.HENT_END, 0)!; + } + public hintStatement(): HintStatementContext[]; + public hintStatement(i: number): HintStatementContext | null; + public hintStatement(i?: number): HintStatementContext[] | HintStatementContext | null { + if (i === undefined) { + return this.getRuleContexts(HintStatementContext); + } + + return this.getRuleContext(i, HintStatementContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_hint; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterHint) { + listener.enterHint(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitHint) { + listener.exitHint(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitHint) { + return visitor.visitHint(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class HintStatementContext extends antlr.ParserRuleContext { + public _hintName?: IdentifierContext; + public _primaryExpression?: PrimaryExpressionContext; + public _parameters: PrimaryExpressionContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext)!; + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public primaryExpression(): PrimaryExpressionContext[]; + public primaryExpression(i: number): PrimaryExpressionContext | null; + public primaryExpression(i?: number): PrimaryExpressionContext[] | PrimaryExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(PrimaryExpressionContext); + } + + return this.getRuleContext(i, PrimaryExpressionContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_hintStatement; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterHintStatement) { + listener.enterHintStatement(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitHintStatement) { + listener.exitHintStatement(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitHintStatement) { + return visitor.visitHintStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FromClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_FROM(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FROM, 0)!; + } + public relation(): RelationContext[]; + public relation(i: number): RelationContext | null; + public relation(i?: number): RelationContext[] | RelationContext | null { + if (i === undefined) { + return this.getRuleContexts(RelationContext); + } + + return this.getRuleContext(i, RelationContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public lateralView(): LateralViewContext[]; + public lateralView(i: number): LateralViewContext | null; + public lateralView(i?: number): LateralViewContext[] | LateralViewContext | null { + if (i === undefined) { + return this.getRuleContexts(LateralViewContext); + } + + return this.getRuleContext(i, LateralViewContext); + } + public pivotClause(): PivotClauseContext | null { + return this.getRuleContext(0, PivotClauseContext); + } + public unpivotClause(): UnpivotClauseContext | null { + return this.getRuleContext(0, UnpivotClauseContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_fromClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFromClause) { + listener.enterFromClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFromClause) { + listener.exitFromClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFromClause) { + return visitor.visitFromClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TemporalClauseContext extends antlr.ParserRuleContext { + public _timestamp?: ValueExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_AS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_AS, 0)!; + } + public KW_OF(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_OF, 0)!; + } + public KW_SYSTEM_VERSION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYSTEM_VERSION, 0); + } + public KW_VERSION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VERSION, 0); + } + public INTEGER_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.INTEGER_VALUE, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FOR, 0); + } + public KW_SYSTEM_TIME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYSTEM_TIME, 0); + } + public KW_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP, 0); + } + public valueExpression(): ValueExpressionContext | null { + return this.getRuleContext(0, ValueExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_temporalClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTemporalClause) { + listener.enterTemporalClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTemporalClause) { + listener.exitTemporalClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTemporalClause) { + return visitor.visitTemporalClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AggregationClauseContext extends antlr.ParserRuleContext { + public _groupByClause?: GroupByClauseContext; + public _groupingExpressionsWithGroupingAnalytics: GroupByClauseContext[] = []; + public _expression?: ExpressionContext; + public _groupingExpressions: ExpressionContext[] = []; + public _kind?: Token | null; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_GROUP(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_GROUP, 0)!; + } + public KW_BY(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_BY, 0)!; + } + public groupByClause(): GroupByClauseContext[]; + public groupByClause(i: number): GroupByClauseContext | null; + public groupByClause(i?: number): GroupByClauseContext[] | GroupByClauseContext | null { + if (i === undefined) { + return this.getRuleContexts(GroupByClauseContext); + } + + return this.getRuleContext(i, GroupByClauseContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WITH, 0); + } + public KW_SETS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SETS, 0); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public groupingSet(): GroupingSetContext[]; + public groupingSet(i: number): GroupingSetContext | null; + public groupingSet(i?: number): GroupingSetContext[] | GroupingSetContext | null { + if (i === undefined) { + return this.getRuleContexts(GroupingSetContext); + } + + return this.getRuleContext(i, GroupingSetContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public KW_ROLLUP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLLUP, 0); + } + public KW_CUBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CUBE, 0); + } + public KW_GROUPING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GROUPING, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_aggregationClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterAggregationClause) { + listener.enterAggregationClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitAggregationClause) { + listener.exitAggregationClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitAggregationClause) { + return visitor.visitAggregationClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GroupByClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public columnName(): ColumnNameContext | null { + return this.getRuleContext(0, ColumnNameContext); + } + public groupingAnalytics(): GroupingAnalyticsContext | null { + return this.getRuleContext(0, GroupingAnalyticsContext); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_groupByClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterGroupByClause) { + listener.enterGroupByClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitGroupByClause) { + listener.exitGroupByClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitGroupByClause) { + return visitor.visitGroupByClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GroupingAnalyticsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public groupingSet(): GroupingSetContext[]; + public groupingSet(i: number): GroupingSetContext | null; + public groupingSet(i?: number): GroupingSetContext[] | GroupingSetContext | null { + if (i === undefined) { + return this.getRuleContexts(GroupingSetContext); + } + + return this.getRuleContext(i, GroupingSetContext); + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public KW_ROLLUP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLLUP, 0); + } + public KW_CUBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CUBE, 0); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public KW_GROUPING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GROUPING, 0); + } + public KW_SETS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SETS, 0); + } + public groupingAnalytics(): GroupingAnalyticsContext[]; + public groupingAnalytics(i: number): GroupingAnalyticsContext | null; + public groupingAnalytics(i?: number): GroupingAnalyticsContext[] | GroupingAnalyticsContext | null { + if (i === undefined) { + return this.getRuleContexts(GroupingAnalyticsContext); + } + + return this.getRuleContext(i, GroupingAnalyticsContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_groupingAnalytics; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterGroupingAnalytics) { + listener.enterGroupingAnalytics(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitGroupingAnalytics) { + listener.exitGroupingAnalytics(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitGroupingAnalytics) { + return visitor.visitGroupingAnalytics(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GroupingSetContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public columnName(): ColumnNameContext[]; + public columnName(i: number): ColumnNameContext | null; + public columnName(i?: number): ColumnNameContext[] | ColumnNameContext | null { + if (i === undefined) { + return this.getRuleContexts(ColumnNameContext); + } + + return this.getRuleContext(i, ColumnNameContext); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_groupingSet; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterGroupingSet) { + listener.enterGroupingSet(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitGroupingSet) { + listener.exitGroupingSet(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitGroupingSet) { + return visitor.visitGroupingSet(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PivotClauseContext extends antlr.ParserRuleContext { + public _aggregates?: NamedExpressionSeqContext; + public _pivotValue?: PivotValueContext; + public _pivotValues: PivotValueContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_PIVOT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_PIVOT, 0)!; + } + public LEFT_PAREN(): antlr.TerminalNode[]; + public LEFT_PAREN(i: number): antlr.TerminalNode | null; + public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.LEFT_PAREN); + } else { + return this.getToken(SqlParser.LEFT_PAREN, i); + } + } + public KW_FOR(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FOR, 0)!; + } + public pivotColumn(): PivotColumnContext { + return this.getRuleContext(0, PivotColumnContext)!; + } + public KW_IN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_IN, 0)!; + } + public RIGHT_PAREN(): antlr.TerminalNode[]; + public RIGHT_PAREN(i: number): antlr.TerminalNode | null; + public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.RIGHT_PAREN); + } else { + return this.getToken(SqlParser.RIGHT_PAREN, i); + } + } + public namedExpressionSeq(): NamedExpressionSeqContext { + return this.getRuleContext(0, NamedExpressionSeqContext)!; + } + public pivotValue(): PivotValueContext[]; + public pivotValue(i: number): PivotValueContext | null; + public pivotValue(i?: number): PivotValueContext[] | PivotValueContext | null { + if (i === undefined) { + return this.getRuleContexts(PivotValueContext); + } + + return this.getRuleContext(i, PivotValueContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_pivotClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPivotClause) { + listener.enterPivotClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPivotClause) { + listener.exitPivotClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPivotClause) { + return visitor.visitPivotClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PivotColumnContext extends antlr.ParserRuleContext { + public _identifier?: IdentifierContext; + public _identifiers: IdentifierContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_pivotColumn; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPivotColumn) { + listener.enterPivotColumn(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPivotColumn) { + listener.exitPivotColumn(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPivotColumn) { + return visitor.visitPivotColumn(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PivotValueContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_pivotValue; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPivotValue) { + listener.enterPivotValue(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPivotValue) { + listener.exitPivotValue(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPivotValue) { + return visitor.visitPivotValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnpivotClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_UNPIVOT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_UNPIVOT, 0)!; + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public unpivotSingleValueColumnClause(): UnpivotSingleValueColumnClauseContext | null { + return this.getRuleContext(0, UnpivotSingleValueColumnClauseContext); + } + public unpivotMultiValueColumnClause(): UnpivotMultiValueColumnClauseContext | null { + return this.getRuleContext(0, UnpivotMultiValueColumnClauseContext); + } + public KW_NULLS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULLS, 0); + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public KW_INCLUDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INCLUDE, 0); + } + public KW_EXCLUDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXCLUDE, 0); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_unpivotClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnpivotClause) { + listener.enterUnpivotClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnpivotClause) { + listener.exitUnpivotClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnpivotClause) { + return visitor.visitUnpivotClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnpivotSingleValueColumnClauseContext extends antlr.ParserRuleContext { + public _unpivotColumnAndAlias?: UnpivotColumnAndAliasContext; + public _unpivotColumns: UnpivotColumnAndAliasContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public KW_FOR(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FOR, 0)!; + } + public KW_IN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_IN, 0)!; + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public unpivotColumnAndAlias(): UnpivotColumnAndAliasContext[]; + public unpivotColumnAndAlias(i: number): UnpivotColumnAndAliasContext | null; + public unpivotColumnAndAlias(i?: number): UnpivotColumnAndAliasContext[] | UnpivotColumnAndAliasContext | null { + if (i === undefined) { + return this.getRuleContexts(UnpivotColumnAndAliasContext); + } + + return this.getRuleContext(i, UnpivotColumnAndAliasContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_unpivotSingleValueColumnClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnpivotSingleValueColumnClause) { + listener.enterUnpivotSingleValueColumnClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnpivotSingleValueColumnClause) { + listener.exitUnpivotSingleValueColumnClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnpivotSingleValueColumnClause) { + return visitor.visitUnpivotSingleValueColumnClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnpivotMultiValueColumnClauseContext extends antlr.ParserRuleContext { + public _identifier?: IdentifierContext; + public _unpivotValueColumns: IdentifierContext[] = []; + public _unpivotColumnSet?: UnpivotColumnSetContext; + public _unpivotColumnSets: UnpivotColumnSetContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode[]; + public LEFT_PAREN(i: number): antlr.TerminalNode | null; + public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.LEFT_PAREN); + } else { + return this.getToken(SqlParser.LEFT_PAREN, i); + } + } + public RIGHT_PAREN(): antlr.TerminalNode[]; + public RIGHT_PAREN(i: number): antlr.TerminalNode | null; + public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.RIGHT_PAREN); + } else { + return this.getToken(SqlParser.RIGHT_PAREN, i); + } + } + public KW_FOR(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FOR, 0)!; + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public KW_IN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_IN, 0)!; + } + public unpivotColumnSet(): UnpivotColumnSetContext[]; + public unpivotColumnSet(i: number): UnpivotColumnSetContext | null; + public unpivotColumnSet(i?: number): UnpivotColumnSetContext[] | UnpivotColumnSetContext | null { + if (i === undefined) { + return this.getRuleContexts(UnpivotColumnSetContext); + } + + return this.getRuleContext(i, UnpivotColumnSetContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_unpivotMultiValueColumnClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnpivotMultiValueColumnClause) { + listener.enterUnpivotMultiValueColumnClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnpivotMultiValueColumnClause) { + listener.exitUnpivotMultiValueColumnClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnpivotMultiValueColumnClause) { + return visitor.visitUnpivotMultiValueColumnClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnpivotColumnSetContext extends antlr.ParserRuleContext { + public _multipartIdentifier?: MultipartIdentifierContext; + public _unpivotColumns: MultipartIdentifierContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public multipartIdentifier(): MultipartIdentifierContext[]; + public multipartIdentifier(i: number): MultipartIdentifierContext | null; + public multipartIdentifier(i?: number): MultipartIdentifierContext[] | MultipartIdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(MultipartIdentifierContext); + } + + return this.getRuleContext(i, MultipartIdentifierContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_unpivotColumnSet; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnpivotColumnSet) { + listener.enterUnpivotColumnSet(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnpivotColumnSet) { + listener.exitUnpivotColumnSet(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnpivotColumnSet) { + return visitor.visitUnpivotColumnSet(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnpivotColumnAndAliasContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public multipartIdentifier(): MultipartIdentifierContext { + return this.getRuleContext(0, MultipartIdentifierContext)!; + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_unpivotColumnAndAlias; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnpivotColumnAndAlias) { + listener.enterUnpivotColumnAndAlias(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnpivotColumnAndAlias) { + listener.exitUnpivotColumnAndAlias(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnpivotColumnAndAlias) { + return visitor.visitUnpivotColumnAndAlias(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IfNotExistsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_IF(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_IF, 0)!; + } + public KW_NOT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_NOT, 0)!; + } + public KW_EXISTS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_EXISTS, 0)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_ifNotExists; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterIfNotExists) { + listener.enterIfNotExists(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitIfNotExists) { + listener.exitIfNotExists(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitIfNotExists) { + return visitor.visitIfNotExists(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IfExistsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_IF(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_IF, 0)!; + } + public KW_EXISTS(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_EXISTS, 0)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_ifExists; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterIfExists) { + listener.enterIfExists(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitIfExists) { + listener.exitIfExists(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitIfExists) { + return visitor.visitIfExists(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LateralViewContext extends antlr.ParserRuleContext { + public _identifier?: IdentifierContext; + public _colName: IdentifierContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_LATERAL(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_LATERAL, 0)!; + } + public KW_VIEW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_VIEW, 0)!; + } + public viewName(): ViewNameContext { + return this.getRuleContext(0, ViewNameContext)!; + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public tableAlias(): TableAliasContext { + return this.getRuleContext(0, TableAliasContext)!; + } + public KW_OUTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OUTER, 0); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_lateralView; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterLateralView) { + listener.enterLateralView(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitLateralView) { + listener.exitLateralView(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitLateralView) { + return visitor.visitLateralView(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SetQuantifierContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISTINCT, 0); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALL, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_setQuantifier; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterSetQuantifier) { + listener.enterSetQuantifier(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitSetQuantifier) { + listener.exitSetQuantifier(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitSetQuantifier) { + return visitor.visitSetQuantifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RelationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public tableName(): TableNameContext | null { + return this.getRuleContext(0, TableNameContext); + } + public relationPrimary(): RelationPrimaryContext | null { + return this.getRuleContext(0, RelationPrimaryContext); + } + public KW_LATERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LATERAL, 0); + } + public joinRelation(): JoinRelationContext[]; + public joinRelation(i: number): JoinRelationContext | null; + public joinRelation(i?: number): JoinRelationContext[] | JoinRelationContext | null { + if (i === undefined) { + return this.getRuleContexts(JoinRelationContext); + } + + return this.getRuleContext(i, JoinRelationContext); + } + public pivotClause(): PivotClauseContext[]; + public pivotClause(i: number): PivotClauseContext | null; + public pivotClause(i?: number): PivotClauseContext[] | PivotClauseContext | null { + if (i === undefined) { + return this.getRuleContexts(PivotClauseContext); + } + + return this.getRuleContext(i, PivotClauseContext); + } + public unpivotClause(): UnpivotClauseContext[]; + public unpivotClause(i: number): UnpivotClauseContext | null; + public unpivotClause(i?: number): UnpivotClauseContext[] | UnpivotClauseContext | null { + if (i === undefined) { + return this.getRuleContexts(UnpivotClauseContext); + } + + return this.getRuleContext(i, UnpivotClauseContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_relation; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterRelation) { + listener.enterRelation(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitRelation) { + listener.exitRelation(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitRelation) { + return visitor.visitRelation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class JoinRelationContext extends antlr.ParserRuleContext { + public _right?: RelationPrimaryContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_JOIN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_JOIN, 0)!; + } + public relationPrimary(): RelationPrimaryContext { + return this.getRuleContext(0, RelationPrimaryContext)!; + } + public joinType(): JoinTypeContext | null { + return this.getRuleContext(0, JoinTypeContext); + } + public KW_LATERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LATERAL, 0); + } + public joinCriteria(): JoinCriteriaContext | null { + return this.getRuleContext(0, JoinCriteriaContext); + } + public KW_NATURAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NATURAL, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_joinRelation; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterJoinRelation) { + listener.enterJoinRelation(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitJoinRelation) { + listener.exitJoinRelation(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitJoinRelation) { + return visitor.visitJoinRelation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class JoinTypeContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_INNER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INNER, 0); + } + public KW_CROSS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CROSS, 0); + } + public KW_LEFT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LEFT, 0); + } + public KW_OUTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OUTER, 0); + } + public KW_SEMI(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SEMI, 0); + } + public KW_ANTI(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANTI, 0); + } + public KW_RIGHT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RIGHT, 0); + } + public KW_FULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FULL, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_joinType; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterJoinType) { + listener.enterJoinType(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitJoinType) { + listener.exitJoinType(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitJoinType) { + return visitor.visitJoinType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class JoinCriteriaContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ON, 0); + } + public booleanExpression(): BooleanExpressionContext | null { + return this.getRuleContext(0, BooleanExpressionContext); + } + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_USING, 0); + } + public identifierList(): IdentifierListContext | null { + return this.getRuleContext(0, IdentifierListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_joinCriteria; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterJoinCriteria) { + listener.enterJoinCriteria(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitJoinCriteria) { + listener.exitJoinCriteria(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitJoinCriteria) { + return visitor.visitJoinCriteria(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SampleContext extends antlr.ParserRuleContext { + public _seed?: Token | null; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_TABLESAMPLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLESAMPLE, 0)!; + } + public LEFT_PAREN(): antlr.TerminalNode[]; + public LEFT_PAREN(i: number): antlr.TerminalNode | null; + public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.LEFT_PAREN); + } else { + return this.getToken(SqlParser.LEFT_PAREN, i); + } + } + public RIGHT_PAREN(): antlr.TerminalNode[]; + public RIGHT_PAREN(i: number): antlr.TerminalNode | null; + public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.RIGHT_PAREN); + } else { + return this.getToken(SqlParser.RIGHT_PAREN, i); + } + } + public sampleMethod(): SampleMethodContext | null { + return this.getRuleContext(0, SampleMethodContext); + } + public KW_REPEATABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPEATABLE, 0); + } + public INTEGER_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.INTEGER_VALUE, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_sample; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterSample) { + listener.enterSample(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitSample) { + listener.exitSample(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitSample) { + return visitor.visitSample(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SampleMethodContext extends antlr.ParserRuleContext { + public _negativeSign?: Token | null; + public _percentage?: Token | null; + public _sampleType?: Token | null; + public _numerator?: Token | null; + public _denominator?: Token | null; + public _bytes?: ExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_PERCENTLIT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PERCENTLIT, 0); + } + public INTEGER_VALUE(): antlr.TerminalNode[]; + public INTEGER_VALUE(i: number): antlr.TerminalNode | null; + public INTEGER_VALUE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.INTEGER_VALUE); + } else { + return this.getToken(SqlParser.INTEGER_VALUE, i); + } + } + public DECIMAL_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DECIMAL_VALUE, 0); + } + public MINUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.MINUS, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROWS, 0); + } + public KW_OUT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OUT, 0); + } + public KW_OF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OF, 0); + } + public KW_BUCKET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BUCKET, 0); + } + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ON, 0); + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public qualifiedName(): QualifiedNameContext | null { + return this.getRuleContext(0, QualifiedNameContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_sampleMethod; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterSampleMethod) { + listener.enterSampleMethod(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitSampleMethod) { + listener.exitSampleMethod(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitSampleMethod) { + return visitor.visitSampleMethod(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IdentifierListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public identifierSeq(): IdentifierSeqContext { + return this.getRuleContext(0, IdentifierSeqContext)!; + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_identifierList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterIdentifierList) { + listener.enterIdentifierList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitIdentifierList) { + listener.exitIdentifierList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitIdentifierList) { + return visitor.visitIdentifierList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IdentifierSeqContext extends antlr.ParserRuleContext { + public _errorCapturingIdentifier?: ErrorCapturingIdentifierContext; + public _ident: ErrorCapturingIdentifierContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[]; + public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext | null; + public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext[] | ErrorCapturingIdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ErrorCapturingIdentifierContext); + } + + return this.getRuleContext(i, ErrorCapturingIdentifierContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_identifierSeq; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterIdentifierSeq) { + listener.enterIdentifierSeq(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitIdentifierSeq) { + listener.exitIdentifierSeq(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitIdentifierSeq) { + return visitor.visitIdentifierSeq(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class OrderedIdentifierListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public orderedIdentifier(): OrderedIdentifierContext[]; + public orderedIdentifier(i: number): OrderedIdentifierContext | null; + public orderedIdentifier(i?: number): OrderedIdentifierContext[] | OrderedIdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(OrderedIdentifierContext); + } + + return this.getRuleContext(i, OrderedIdentifierContext); + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_orderedIdentifierList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterOrderedIdentifierList) { + listener.enterOrderedIdentifierList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitOrderedIdentifierList) { + listener.exitOrderedIdentifierList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitOrderedIdentifierList) { + return visitor.visitOrderedIdentifierList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class OrderedIdentifierContext extends antlr.ParserRuleContext { + public _ident?: ErrorCapturingIdentifierContext; + public _ordering?: Token | null; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext { + return this.getRuleContext(0, ErrorCapturingIdentifierContext)!; + } + public KW_ASC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ASC, 0); + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESC, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_orderedIdentifier; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterOrderedIdentifier) { + listener.enterOrderedIdentifier(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitOrderedIdentifier) { + listener.exitOrderedIdentifier(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitOrderedIdentifier) { + return visitor.visitOrderedIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IdentifierCommentListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public identifierComment(): IdentifierCommentContext[]; + public identifierComment(i: number): IdentifierCommentContext | null; + public identifierComment(i?: number): IdentifierCommentContext[] | IdentifierCommentContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierCommentContext); + } + + return this.getRuleContext(i, IdentifierCommentContext); + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_identifierCommentList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterIdentifierCommentList) { + listener.enterIdentifierCommentList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitIdentifierCommentList) { + listener.exitIdentifierCommentList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitIdentifierCommentList) { + return visitor.visitIdentifierCommentList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IdentifierCommentContext extends antlr.ParserRuleContext { + public _comment?: StringLitContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public columnNameCreate(): ColumnNameCreateContext { + return this.getRuleContext(0, ColumnNameCreateContext)!; + } + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMENT, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_identifierComment; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterIdentifierComment) { + listener.enterIdentifierComment(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitIdentifierComment) { + listener.exitIdentifierComment(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitIdentifierComment) { + return visitor.visitIdentifierComment(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RelationPrimaryContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public tableAlias(): TableAliasContext { + return this.getRuleContext(0, TableAliasContext)!; + } + public tableName(): TableNameContext | null { + return this.getRuleContext(0, TableNameContext); + } + public viewName(): ViewNameContext | null { + return this.getRuleContext(0, ViewNameContext); + } + public identifierReference(): IdentifierReferenceContext | null { + return this.getRuleContext(0, IdentifierReferenceContext); + } + public temporalClause(): TemporalClauseContext | null { + return this.getRuleContext(0, TemporalClauseContext); + } + public sample(): SampleContext | null { + return this.getRuleContext(0, SampleContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public relation(): RelationContext | null { + return this.getRuleContext(0, RelationContext); + } + public KW_VALUES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VALUES, 0); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public functionName(): FunctionNameContext | null { + return this.getRuleContext(0, FunctionNameContext); + } + public functionTableArgument(): FunctionTableArgumentContext[]; + public functionTableArgument(i: number): FunctionTableArgumentContext | null; + public functionTableArgument(i?: number): FunctionTableArgumentContext[] | FunctionTableArgumentContext | null { + if (i === undefined) { + return this.getRuleContexts(FunctionTableArgumentContext); + } + + return this.getRuleContext(i, FunctionTableArgumentContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_relationPrimary; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterRelationPrimary) { + listener.enterRelationPrimary(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitRelationPrimary) { + listener.exitRelationPrimary(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitRelationPrimary) { + return visitor.visitRelationPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FunctionTableSubqueryArgumentContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TABLE, 0)!; + } + public tableName(): TableNameContext | null { + return this.getRuleContext(0, TableNameContext); + } + public tableArgumentPartitioning(): TableArgumentPartitioningContext | null { + return this.getRuleContext(0, TableArgumentPartitioningContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_functionTableSubqueryArgument; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFunctionTableSubqueryArgument) { + listener.enterFunctionTableSubqueryArgument(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFunctionTableSubqueryArgument) { + listener.exitFunctionTableSubqueryArgument(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFunctionTableSubqueryArgument) { + return visitor.visitFunctionTableSubqueryArgument(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableArgumentPartitioningContext extends antlr.ParserRuleContext { + public _expression?: ExpressionContext; + public _partition: ExpressionContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_BY(): antlr.TerminalNode[]; + public KW_BY(i: number): antlr.TerminalNode | null; + public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_BY); + } else { + return this.getToken(SqlParser.KW_BY, i); + } + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WITH, 0); + } + public KW_SINGLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SINGLE, 0); + } + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITION, 0); + } + public KW_ORDER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ORDER, 0); + } + public KW_SORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SORT, 0); + } + public KW_DISTRIBUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISTRIBUTE, 0); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public sortItem(): SortItemContext[]; + public sortItem(i: number): SortItemContext | null; + public sortItem(i?: number): SortItemContext[] | SortItemContext | null { + if (i === undefined) { + return this.getRuleContexts(SortItemContext); + } + + return this.getRuleContext(i, SortItemContext); + } + public LEFT_PAREN(): antlr.TerminalNode[]; + public LEFT_PAREN(i: number): antlr.TerminalNode | null; + public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.LEFT_PAREN); + } else { + return this.getToken(SqlParser.LEFT_PAREN, i); + } + } + public RIGHT_PAREN(): antlr.TerminalNode[]; + public RIGHT_PAREN(i: number): antlr.TerminalNode | null; + public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.RIGHT_PAREN); + } else { + return this.getToken(SqlParser.RIGHT_PAREN, i); + } + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_tableArgumentPartitioning; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTableArgumentPartitioning) { + listener.enterTableArgumentPartitioning(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTableArgumentPartitioning) { + listener.exitTableArgumentPartitioning(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTableArgumentPartitioning) { + return visitor.visitTableArgumentPartitioning(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FunctionTableNamedArgumentExpressionContext extends antlr.ParserRuleContext { + public _key?: IdentifierContext; + public _table?: FunctionTableSubqueryArgumentContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public FAT_ARROW(): antlr.TerminalNode { + return this.getToken(SqlParser.FAT_ARROW, 0)!; + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext)!; + } + public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext { + return this.getRuleContext(0, FunctionTableSubqueryArgumentContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_functionTableNamedArgumentExpression; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFunctionTableNamedArgumentExpression) { + listener.enterFunctionTableNamedArgumentExpression(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFunctionTableNamedArgumentExpression) { + listener.exitFunctionTableNamedArgumentExpression(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFunctionTableNamedArgumentExpression) { + return visitor.visitFunctionTableNamedArgumentExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FunctionTableReferenceArgumentContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext | null { + return this.getRuleContext(0, FunctionTableSubqueryArgumentContext); + } + public functionTableNamedArgumentExpression(): FunctionTableNamedArgumentExpressionContext | null { + return this.getRuleContext(0, FunctionTableNamedArgumentExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_functionTableReferenceArgument; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFunctionTableReferenceArgument) { + listener.enterFunctionTableReferenceArgument(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFunctionTableReferenceArgument) { + listener.exitFunctionTableReferenceArgument(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFunctionTableReferenceArgument) { + return visitor.visitFunctionTableReferenceArgument(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FunctionTableArgumentContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public functionTableReferenceArgument(): FunctionTableReferenceArgumentContext | null { + return this.getRuleContext(0, FunctionTableReferenceArgumentContext); + } + public functionArgument(): FunctionArgumentContext | null { + return this.getRuleContext(0, FunctionArgumentContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_functionTableArgument; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFunctionTableArgument) { + listener.enterFunctionTableArgument(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFunctionTableArgument) { + listener.exitFunctionTableArgument(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFunctionTableArgument) { + return visitor.visitFunctionTableArgument(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableAliasContext extends antlr.ParserRuleContext { + public _alias?: StrictIdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public strictIdentifier(): StrictIdentifierContext | null { + return this.getRuleContext(0, StrictIdentifierContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public identifierList(): IdentifierListContext | null { + return this.getRuleContext(0, IdentifierListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_tableAlias; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTableAlias) { + listener.enterTableAlias(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTableAlias) { + listener.exitTableAlias(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTableAlias) { + return visitor.visitTableAlias(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RowFormatContext extends antlr.ParserRuleContext { + public _name?: StringLitContext; + public _props?: PropertyListContext; + public _fieldsTerminatedBy?: StringLitContext; + public _escapedBy?: StringLitContext; + public _collectionItemsTerminatedBy?: StringLitContext; + public _keysTerminatedBy?: StringLitContext; + public _linesSeparatedBy?: StringLitContext; + public _nullDefinedAs?: StringLitContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_ROW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_ROW, 0)!; + } + public KW_FORMAT(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_FORMAT, 0)!; + } + public KW_SERDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDE, 0); + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WITH, 0); + } + public KW_SERDEPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDEPROPERTIES, 0); + } + public propertyList(): PropertyListContext | null { + return this.getRuleContext(0, PropertyListContext); + } + public KW_DELIMITED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DELIMITED, 0); + } + public KW_FIELDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FIELDS, 0); + } + public KW_TERMINATED(): antlr.TerminalNode[]; + public KW_TERMINATED(i: number): antlr.TerminalNode | null; + public KW_TERMINATED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_TERMINATED); + } else { + return this.getToken(SqlParser.KW_TERMINATED, i); + } + } + public KW_BY(): antlr.TerminalNode[]; + public KW_BY(i: number): antlr.TerminalNode | null; + public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_BY); + } else { + return this.getToken(SqlParser.KW_BY, i); + } + } + public KW_COLLECTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLLECTION, 0); + } + public KW_ITEMS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ITEMS, 0); + } + public KW_MAP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MAP, 0); + } + public KW_KEYS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_KEYS, 0); + } + public KW_LINES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LINES, 0); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public KW_DEFINED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFINED, 0); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public KW_ESCAPED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ESCAPED, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_rowFormat; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterRowFormat) { + listener.enterRowFormat(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitRowFormat) { + listener.exitRowFormat(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitRowFormat) { + return visitor.visitRowFormat(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MultipartIdentifierListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public multipartIdentifier(): MultipartIdentifierContext[]; + public multipartIdentifier(i: number): MultipartIdentifierContext | null; + public multipartIdentifier(i?: number): MultipartIdentifierContext[] | MultipartIdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(MultipartIdentifierContext); + } + + return this.getRuleContext(i, MultipartIdentifierContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_multipartIdentifierList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterMultipartIdentifierList) { + listener.enterMultipartIdentifierList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitMultipartIdentifierList) { + listener.exitMultipartIdentifierList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitMultipartIdentifierList) { + return visitor.visitMultipartIdentifierList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MultipartIdentifierContext extends antlr.ParserRuleContext { + public _errorCapturingIdentifier?: ErrorCapturingIdentifierContext; + public _parts: ErrorCapturingIdentifierContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[]; + public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext | null; + public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext[] | ErrorCapturingIdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ErrorCapturingIdentifierContext); + } + + return this.getRuleContext(i, ErrorCapturingIdentifierContext); + } + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.DOT); + } else { + return this.getToken(SqlParser.DOT, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_multipartIdentifier; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterMultipartIdentifier) { + listener.enterMultipartIdentifier(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitMultipartIdentifier) { + listener.exitMultipartIdentifier(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitMultipartIdentifier) { + return visitor.visitMultipartIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MultipartIdentifierPropertyListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public multipartIdentifierProperty(): MultipartIdentifierPropertyContext[]; + public multipartIdentifierProperty(i: number): MultipartIdentifierPropertyContext | null; + public multipartIdentifierProperty(i?: number): MultipartIdentifierPropertyContext[] | MultipartIdentifierPropertyContext | null { + if (i === undefined) { + return this.getRuleContexts(MultipartIdentifierPropertyContext); + } + + return this.getRuleContext(i, MultipartIdentifierPropertyContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_multipartIdentifierPropertyList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterMultipartIdentifierPropertyList) { + listener.enterMultipartIdentifierPropertyList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitMultipartIdentifierPropertyList) { + listener.exitMultipartIdentifierPropertyList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitMultipartIdentifierPropertyList) { + return visitor.visitMultipartIdentifierPropertyList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MultipartIdentifierPropertyContext extends antlr.ParserRuleContext { + public _options?: PropertyListContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public multipartIdentifier(): MultipartIdentifierContext { + return this.getRuleContext(0, MultipartIdentifierContext)!; + } + public KW_OPTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTIONS, 0); + } + public propertyList(): PropertyListContext | null { + return this.getRuleContext(0, PropertyListContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_multipartIdentifierProperty; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterMultipartIdentifierProperty) { + listener.enterMultipartIdentifierProperty(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitMultipartIdentifierProperty) { + listener.exitMultipartIdentifierProperty(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitMultipartIdentifierProperty) { + return visitor.visitMultipartIdentifierProperty(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableIdentifierContext extends antlr.ParserRuleContext { + public _db?: ErrorCapturingIdentifierContext; + public _table?: ErrorCapturingIdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[]; + public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext | null; + public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext[] | ErrorCapturingIdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ErrorCapturingIdentifierContext); + } + + return this.getRuleContext(i, ErrorCapturingIdentifierContext); + } + public DOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DOT, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_tableIdentifier; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTableIdentifier) { + listener.enterTableIdentifier(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTableIdentifier) { + listener.exitTableIdentifier(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTableIdentifier) { + return visitor.visitTableIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ViewIdentifierContext extends antlr.ParserRuleContext { + public _db?: ErrorCapturingIdentifierContext; + public _view?: ErrorCapturingIdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[]; + public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext | null; + public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext[] | ErrorCapturingIdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ErrorCapturingIdentifierContext); + } + + return this.getRuleContext(i, ErrorCapturingIdentifierContext); + } + public DOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DOT, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_viewIdentifier; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterViewIdentifier) { + listener.enterViewIdentifier(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitViewIdentifier) { + listener.exitViewIdentifier(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitViewIdentifier) { + return visitor.visitViewIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NamedExpressionContext extends antlr.ParserRuleContext { + public _name?: ErrorCapturingIdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public columnName(): ColumnNameContext | null { + return this.getRuleContext(0, ColumnNameContext); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public identifierList(): IdentifierListContext | null { + return this.getRuleContext(0, IdentifierListContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | null { + return this.getRuleContext(0, ErrorCapturingIdentifierContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_namedExpression; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNamedExpression) { + listener.enterNamedExpression(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNamedExpression) { + listener.exitNamedExpression(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNamedExpression) { + return visitor.visitNamedExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NamedExpressionSeqContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public namedExpression(): NamedExpressionContext[]; + public namedExpression(i: number): NamedExpressionContext | null; + public namedExpression(i?: number): NamedExpressionContext[] | NamedExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(NamedExpressionContext); + } + + return this.getRuleContext(i, NamedExpressionContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_namedExpressionSeq; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNamedExpressionSeq) { + listener.enterNamedExpressionSeq(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNamedExpressionSeq) { + listener.exitNamedExpressionSeq(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNamedExpressionSeq) { + return visitor.visitNamedExpressionSeq(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PartitionFieldListContext extends antlr.ParserRuleContext { + public _partitionField?: PartitionFieldContext; + public _fields: PartitionFieldContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LEFT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.LEFT_PAREN, 0)!; + } + public RIGHT_PAREN(): antlr.TerminalNode { + return this.getToken(SqlParser.RIGHT_PAREN, 0)!; + } + public partitionField(): PartitionFieldContext[]; + public partitionField(i: number): PartitionFieldContext | null; + public partitionField(i?: number): PartitionFieldContext[] | PartitionFieldContext | null { + if (i === undefined) { + return this.getRuleContexts(PartitionFieldContext); + } + + return this.getRuleContext(i, PartitionFieldContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_partitionFieldList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPartitionFieldList) { + listener.enterPartitionFieldList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPartitionFieldList) { + listener.exitPartitionFieldList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPartitionFieldList) { + return visitor.visitPartitionFieldList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PartitionFieldContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public transform(): TransformContext | null { + return this.getRuleContext(0, TransformContext); + } + public columnType(): ColumnTypeContext | null { + return this.getRuleContext(0, ColumnTypeContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_partitionField; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPartitionField) { + listener.enterPartitionField(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPartitionField) { + listener.exitPartitionField(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPartitionField) { + return visitor.visitPartitionField(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TransformContext extends antlr.ParserRuleContext { + public _transformName?: IdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public qualifiedName(): QualifiedNameContext | null { + return this.getRuleContext(0, QualifiedNameContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public transformArgument(): TransformArgumentContext[]; + public transformArgument(i: number): TransformArgumentContext | null; + public transformArgument(i?: number): TransformArgumentContext[] | TransformArgumentContext | null { + if (i === undefined) { + return this.getRuleContexts(TransformArgumentContext); + } + + return this.getRuleContext(i, TransformArgumentContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_transform; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTransform) { + listener.enterTransform(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTransform) { + listener.exitTransform(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTransform) { + return visitor.visitTransform(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TransformArgumentContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public qualifiedName(): QualifiedNameContext | null { + return this.getRuleContext(0, QualifiedNameContext); + } + public constant(): ConstantContext | null { + return this.getRuleContext(0, ConstantContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_transformArgument; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterTransformArgument) { + listener.enterTransformArgument(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitTransformArgument) { + listener.exitTransformArgument(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitTransformArgument) { + return visitor.visitTransformArgument(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ExpressionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public booleanExpression(): BooleanExpressionContext { + return this.getRuleContext(0, BooleanExpressionContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_expression; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterExpression) { + listener.enterExpression(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitExpression) { + listener.exitExpression(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitExpression) { + return visitor.visitExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NamedArgumentExpressionContext extends antlr.ParserRuleContext { + public _key?: IdentifierContext; + public _value?: ExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public FAT_ARROW(): antlr.TerminalNode { + return this.getToken(SqlParser.FAT_ARROW, 0)!; + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_namedArgumentExpression; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNamedArgumentExpression) { + listener.enterNamedArgumentExpression(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNamedArgumentExpression) { + listener.exitNamedArgumentExpression(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNamedArgumentExpression) { + return visitor.visitNamedArgumentExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FunctionArgumentContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public namedArgumentExpression(): NamedArgumentExpressionContext | null { + return this.getRuleContext(0, NamedArgumentExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_functionArgument; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFunctionArgument) { + listener.enterFunctionArgument(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFunctionArgument) { + listener.exitFunctionArgument(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFunctionArgument) { + return visitor.visitFunctionArgument(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ExpressionSeqContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_expressionSeq; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterExpressionSeq) { + listener.enterExpressionSeq(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitExpressionSeq) { + listener.exitExpressionSeq(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitExpressionSeq) { + return visitor.visitExpressionSeq(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BooleanExpressionContext extends antlr.ParserRuleContext { + public _left?: BooleanExpressionContext; + public _operator?: Token | null; + public _right?: BooleanExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public booleanExpression(): BooleanExpressionContext[]; + public booleanExpression(i: number): BooleanExpressionContext | null; + public booleanExpression(i?: number): BooleanExpressionContext[] | BooleanExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(BooleanExpressionContext); + } + + return this.getRuleContext(i, BooleanExpressionContext); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.NOT, 0); + } + public KW_EXISTS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXISTS, 0); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public valueExpression(): ValueExpressionContext | null { + return this.getRuleContext(0, ValueExpressionContext); + } + public predicate(): PredicateContext | null { + return this.getRuleContext(0, PredicateContext); + } + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AND, 0); + } + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OR, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_booleanExpression; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterBooleanExpression) { + listener.enterBooleanExpression(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitBooleanExpression) { + listener.exitBooleanExpression(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitBooleanExpression) { + return visitor.visitBooleanExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PredicateContext extends antlr.ParserRuleContext { + public _kind?: Token | null; + public _lower?: ValueExpressionContext; + public _upper?: ValueExpressionContext; + public _pattern?: ValueExpressionContext; + public _quantifier?: Token | null; + public _escapeChar?: StringLitContext; + public _right?: ValueExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AND, 0); + } + public KW_BETWEEN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BETWEEN, 0); + } + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext | null; + public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } + + return this.getRuleContext(i, ValueExpressionContext); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public KW_RLIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RLIKE, 0); + } + public KW_REGEXP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REGEXP, 0); + } + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIKE, 0); + } + public KW_ILIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ILIKE, 0); + } + public KW_ANY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANY, 0); + } + public KW_SOME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SOME, 0); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALL, 0); + } + public KW_ESCAPE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ESCAPE, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public KW_IS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IS, 0); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRUE, 0); + } + public KW_FALSE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FALSE, 0); + } + public KW_UNKNOWN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNKNOWN, 0); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FROM, 0); + } + public KW_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISTINCT, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_predicate; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPredicate) { + listener.enterPredicate(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPredicate) { + listener.exitPredicate(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPredicate) { + return visitor.visitPredicate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ValueExpressionContext extends antlr.ParserRuleContext { + public _left?: ValueExpressionContext; + public _operator?: Token | null; + public _right?: ValueExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public primaryExpression(): PrimaryExpressionContext | null { + return this.getRuleContext(0, PrimaryExpressionContext); + } + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext | null; + public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } + + return this.getRuleContext(i, ValueExpressionContext); + } + public MINUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.MINUS, 0); + } + public PLUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.PLUS, 0); + } + public TILDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.TILDE, 0); + } + public ASTERISK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.ASTERISK, 0); + } + public SLASH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.SLASH, 0); + } + public PERCENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.PERCENT, 0); + } + public KW_DIV(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIV, 0); + } + public CONCAT_PIPE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.CONCAT_PIPE, 0); + } + public AMPERSAND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.AMPERSAND, 0); + } + public HAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.HAT, 0); + } + public PIPE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.PIPE, 0); + } + public comparisonOperator(): ComparisonOperatorContext | null { + return this.getRuleContext(0, ComparisonOperatorContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_valueExpression; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterValueExpression) { + listener.enterValueExpression(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitValueExpression) { + listener.exitValueExpression(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitValueExpression) { + return visitor.visitValueExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DatetimeUnitContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_YEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_YEAR, 0); + } + public KW_QUARTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_QUARTER, 0); + } + public KW_MONTH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MONTH, 0); + } + public KW_WEEK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WEEK, 0); + } + public KW_DAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAY, 0); + } + public KW_DAYOFYEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAYOFYEAR, 0); + } + public KW_HOUR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_HOUR, 0); + } + public KW_MINUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUTE, 0); + } + public KW_SECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SECOND, 0); + } + public KW_MILLISECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MILLISECOND, 0); + } + public KW_MICROSECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MICROSECOND, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_datetimeUnit; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDatetimeUnit) { + listener.enterDatetimeUnit(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDatetimeUnit) { + listener.exitDatetimeUnit(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDatetimeUnit) { + return visitor.visitDatetimeUnit(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PrimaryExpressionContext extends antlr.ParserRuleContext { + public _value?: PrimaryExpressionContext; + public _base?: PrimaryExpressionContext; + public _name?: Token | null; + public _unit?: DatetimeUnitContext; + public _invalidUnit?: StringLitContext; + public _unitsAmount?: ValueExpressionContext; + public _timestamp?: ValueExpressionContext; + public _startTimestamp?: ValueExpressionContext; + public _endTimestamp?: ValueExpressionContext; + public _elseExpression?: ExpressionContext; + public _substr?: ValueExpressionContext; + public _str?: ValueExpressionContext; + public _where?: BooleanExpressionContext; + public _nullsOption?: Token | null; + public _field?: IdentifierContext; + public _source?: ValueExpressionContext; + public _pos?: ValueExpressionContext; + public _len?: ValueExpressionContext; + public _trimOption?: Token | null; + public _trimStr?: ValueExpressionContext; + public _srcStr?: ValueExpressionContext; + public _input?: ValueExpressionContext; + public _replace?: ValueExpressionContext; + public _position?: ValueExpressionContext; + public _length?: ValueExpressionContext; + public _percentage?: ValueExpressionContext; + public _index?: ValueExpressionContext; + public _fieldName?: IdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_CURRENT_DATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT_DATE, 0); + } + public KW_CURRENT_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT_TIMESTAMP, 0); + } + public KW_CURRENT_USER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT_USER, 0); + } + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_USER, 0); + } + public KW_SESSION_USER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SESSION_USER, 0); + } + public LEFT_PAREN(): antlr.TerminalNode[]; + public LEFT_PAREN(i: number): antlr.TerminalNode | null; + public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.LEFT_PAREN); + } else { + return this.getToken(SqlParser.LEFT_PAREN, i); + } + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public RIGHT_PAREN(): antlr.TerminalNode[]; + public RIGHT_PAREN(i: number): antlr.TerminalNode | null; + public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.RIGHT_PAREN); + } else { + return this.getToken(SqlParser.RIGHT_PAREN, i); + } + } + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext | null; + public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } + + return this.getRuleContext(i, ValueExpressionContext); + } + public KW_TIMESTAMPADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMPADD, 0); + } + public KW_DATEADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATEADD, 0); + } + public KW_DATE_ADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE_ADD, 0); + } + public datetimeUnit(): DatetimeUnitContext | null { + return this.getRuleContext(0, DatetimeUnitContext); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public KW_TIMESTAMPDIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMPDIFF, 0); + } + public KW_DATEDIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATEDIFF, 0); + } + public KW_DATE_DIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE_DIFF, 0); + } + public KW_TIMEDIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMEDIFF, 0); + } + public KW_CASE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CASE, 0); + } + public KW_END(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_END, 0); + } + public whenClause(): WhenClauseContext[]; + public whenClause(i: number): WhenClauseContext | null; + public whenClause(i?: number): WhenClauseContext[] | WhenClauseContext | null { + if (i === undefined) { + return this.getRuleContexts(WhenClauseContext); + } + + return this.getRuleContext(i, WhenClauseContext); + } + public KW_ELSE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ELSE, 0); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public dataType(): DataTypeContext | null { + return this.getRuleContext(0, DataTypeContext); + } + public KW_CAST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CAST, 0); + } + public KW_TRY_CAST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRY_CAST, 0); + } + public KW_STRUCT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRUCT, 0); + } + public namedExpression(): NamedExpressionContext[]; + public namedExpression(i: number): NamedExpressionContext | null; + public namedExpression(i?: number): NamedExpressionContext[] | NamedExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(NamedExpressionContext); + } + + return this.getRuleContext(i, NamedExpressionContext); + } + public KW_FIRST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FIRST, 0); + } + public KW_IGNORE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IGNORE, 0); + } + public KW_NULLS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULLS, 0); + } + public KW_ANY_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANY_VALUE, 0); + } + public KW_LAST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LAST, 0); + } + public KW_POSITION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_POSITION, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public constant(): ConstantContext | null { + return this.getRuleContext(0, ConstantContext); + } + public ASTERISK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.ASTERISK, 0); + } + public qualifiedName(): QualifiedNameContext | null { + return this.getRuleContext(0, QualifiedNameContext); + } + public DOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DOT, 0); + } + public query(): QueryContext | null { + return this.getRuleContext(0, QueryContext); + } + public KW_IDENTIFIER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IDENTIFIER, 0); + } + public functionName(): FunctionNameContext | null { + return this.getRuleContext(0, FunctionNameContext); + } + public functionArgument(): FunctionArgumentContext[]; + public functionArgument(i: number): FunctionArgumentContext | null; + public functionArgument(i?: number): FunctionArgumentContext[] | FunctionArgumentContext | null { + if (i === undefined) { + return this.getRuleContexts(FunctionArgumentContext); + } + + return this.getRuleContext(i, FunctionArgumentContext); + } + public KW_FILTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FILTER, 0); + } + public KW_WHERE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WHERE, 0); + } + public KW_OVER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVER, 0); + } + public windowSpec(): WindowSpecContext | null { + return this.getRuleContext(0, WindowSpecContext); + } + public booleanExpression(): BooleanExpressionContext | null { + return this.getRuleContext(0, BooleanExpressionContext); + } + public KW_RESPECT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RESPECT, 0); + } + public setQuantifier(): SetQuantifierContext | null { + return this.getRuleContext(0, SetQuantifierContext); + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public ARROW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.ARROW, 0); + } + public KW_EXTRACT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTRACT, 0); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FROM, 0); + } + public KW_SUBSTR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SUBSTR, 0); + } + public KW_SUBSTRING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SUBSTRING, 0); + } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FOR, 0); + } + public KW_TRIM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRIM, 0); + } + public KW_BOTH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BOTH, 0); + } + public KW_LEADING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LEADING, 0); + } + public KW_TRAILING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRAILING, 0); + } + public KW_OVERLAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVERLAY, 0); + } + public KW_PLACING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PLACING, 0); + } + public KW_WITHIN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WITHIN, 0); + } + public KW_GROUP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GROUP, 0); + } + public KW_ORDER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ORDER, 0); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BY, 0); + } + public sortItem(): SortItemContext | null { + return this.getRuleContext(0, SortItemContext); + } + public KW_PERCENTILE_CONT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PERCENTILE_CONT, 0); + } + public KW_PERCENTILE_DISC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PERCENTILE_DISC, 0); + } + public LEFT_BRACKET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_BRACKET, 0); + } + public RIGHT_BRACKET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_BRACKET, 0); + } + public primaryExpression(): PrimaryExpressionContext | null { + return this.getRuleContext(0, PrimaryExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_primaryExpression; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPrimaryExpression) { + listener.enterPrimaryExpression(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPrimaryExpression) { + listener.exitPrimaryExpression(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPrimaryExpression) { + return visitor.visitPrimaryExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LiteralTypeContext extends antlr.ParserRuleContext { + public _unsupportedType?: IdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_DATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE, 0); + } + public KW_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP, 0); + } + public KW_TIMESTAMP_LTZ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP_LTZ, 0); + } + public KW_TIMESTAMP_NTZ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP_NTZ, 0); + } + public KW_INTERVAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTERVAL, 0); + } + public KW_BINARY_HEX(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BINARY_HEX, 0); + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_literalType; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterLiteralType) { + listener.enterLiteralType(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitLiteralType) { + listener.exitLiteralType(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitLiteralType) { + return visitor.visitLiteralType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ConstantContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public QUESTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.QUESTION, 0); + } + public COLON(): antlr.TerminalNode | null { + return this.getToken(SqlParser.COLON, 0); + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public interval(): IntervalContext | null { + return this.getRuleContext(0, IntervalContext); + } + public literalType(): LiteralTypeContext | null { + return this.getRuleContext(0, LiteralTypeContext); + } + public stringLit(): StringLitContext[]; + public stringLit(i: number): StringLitContext | null; + public stringLit(i?: number): StringLitContext[] | StringLitContext | null { + if (i === undefined) { + return this.getRuleContexts(StringLitContext); + } + + return this.getRuleContext(i, StringLitContext); + } + public number(): NumberContext | null { + return this.getRuleContext(0, NumberContext); + } + public booleanValue(): BooleanValueContext | null { + return this.getRuleContext(0, BooleanValueContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_constant; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterConstant) { + listener.enterConstant(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitConstant) { + listener.exitConstant(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitConstant) { + return visitor.visitConstant(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ComparisonOperatorContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public EQ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.EQ, 0); + } + public NEQ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.NEQ, 0); + } + public NEQJ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.NEQJ, 0); + } + public LT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LT, 0); + } + public LTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LTE, 0); + } + public GT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.GT, 0); + } + public GTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.GTE, 0); + } + public NSEQ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.NSEQ, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_comparisonOperator; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterComparisonOperator) { + listener.enterComparisonOperator(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitComparisonOperator) { + listener.exitComparisonOperator(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitComparisonOperator) { + return visitor.visitComparisonOperator(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ArithmeticOperatorContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public PLUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.PLUS, 0); + } + public MINUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.MINUS, 0); + } + public ASTERISK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.ASTERISK, 0); + } + public SLASH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.SLASH, 0); + } + public PERCENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.PERCENT, 0); + } + public KW_DIV(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIV, 0); + } + public TILDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.TILDE, 0); + } + public AMPERSAND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.AMPERSAND, 0); + } + public PIPE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.PIPE, 0); + } + public CONCAT_PIPE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.CONCAT_PIPE, 0); + } + public HAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.HAT, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_arithmeticOperator; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterArithmeticOperator) { + listener.enterArithmeticOperator(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitArithmeticOperator) { + listener.exitArithmeticOperator(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitArithmeticOperator) { + return visitor.visitArithmeticOperator(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PredicateOperatorContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OR, 0); + } + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AND, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_predicateOperator; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterPredicateOperator) { + listener.enterPredicateOperator(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitPredicateOperator) { + listener.exitPredicateOperator(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitPredicateOperator) { + return visitor.visitPredicateOperator(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BooleanValueContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRUE, 0); + } + public KW_FALSE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FALSE, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_booleanValue; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterBooleanValue) { + listener.enterBooleanValue(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitBooleanValue) { + listener.exitBooleanValue(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitBooleanValue) { + return visitor.visitBooleanValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IntervalContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_INTERVAL(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_INTERVAL, 0)!; + } + public errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext | null { + return this.getRuleContext(0, ErrorCapturingMultiUnitsIntervalContext); + } + public errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext | null { + return this.getRuleContext(0, ErrorCapturingUnitToUnitIntervalContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_interval; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterInterval) { + listener.enterInterval(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitInterval) { + listener.exitInterval(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitInterval) { + return visitor.visitInterval(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ErrorCapturingMultiUnitsIntervalContext extends antlr.ParserRuleContext { + public _body?: MultiUnitsIntervalContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public multiUnitsInterval(): MultiUnitsIntervalContext { + return this.getRuleContext(0, MultiUnitsIntervalContext)!; + } + public unitToUnitInterval(): UnitToUnitIntervalContext | null { + return this.getRuleContext(0, UnitToUnitIntervalContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_errorCapturingMultiUnitsInterval; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterErrorCapturingMultiUnitsInterval) { + listener.enterErrorCapturingMultiUnitsInterval(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitErrorCapturingMultiUnitsInterval) { + listener.exitErrorCapturingMultiUnitsInterval(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitErrorCapturingMultiUnitsInterval) { + return visitor.visitErrorCapturingMultiUnitsInterval(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ErrorCapturingUnitToUnitIntervalContext extends antlr.ParserRuleContext { + public _body?: UnitToUnitIntervalContext; + public _error1?: MultiUnitsIntervalContext; + public _error2?: UnitToUnitIntervalContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public unitToUnitInterval(): UnitToUnitIntervalContext[]; + public unitToUnitInterval(i: number): UnitToUnitIntervalContext | null; + public unitToUnitInterval(i?: number): UnitToUnitIntervalContext[] | UnitToUnitIntervalContext | null { + if (i === undefined) { + return this.getRuleContexts(UnitToUnitIntervalContext); + } + + return this.getRuleContext(i, UnitToUnitIntervalContext); + } + public multiUnitsInterval(): MultiUnitsIntervalContext | null { + return this.getRuleContext(0, MultiUnitsIntervalContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_errorCapturingUnitToUnitInterval; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterErrorCapturingUnitToUnitInterval) { + listener.enterErrorCapturingUnitToUnitInterval(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitErrorCapturingUnitToUnitInterval) { + listener.exitErrorCapturingUnitToUnitInterval(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitErrorCapturingUnitToUnitInterval) { + return visitor.visitErrorCapturingUnitToUnitInterval(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MultiUnitsIntervalContext extends antlr.ParserRuleContext { + public _unitInMultiUnits?: UnitInMultiUnitsContext; + public _unit: UnitInMultiUnitsContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public intervalValue(): IntervalValueContext[]; + public intervalValue(i: number): IntervalValueContext | null; + public intervalValue(i?: number): IntervalValueContext[] | IntervalValueContext | null { + if (i === undefined) { + return this.getRuleContexts(IntervalValueContext); + } + + return this.getRuleContext(i, IntervalValueContext); + } + public unitInMultiUnits(): UnitInMultiUnitsContext[]; + public unitInMultiUnits(i: number): UnitInMultiUnitsContext | null; + public unitInMultiUnits(i?: number): UnitInMultiUnitsContext[] | UnitInMultiUnitsContext | null { + if (i === undefined) { + return this.getRuleContexts(UnitInMultiUnitsContext); + } + + return this.getRuleContext(i, UnitInMultiUnitsContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_multiUnitsInterval; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterMultiUnitsInterval) { + listener.enterMultiUnitsInterval(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitMultiUnitsInterval) { + listener.exitMultiUnitsInterval(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitMultiUnitsInterval) { + return visitor.visitMultiUnitsInterval(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnitToUnitIntervalContext extends antlr.ParserRuleContext { + public _value?: IntervalValueContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public unitInUnitToUnit(): UnitInUnitToUnitContext[]; + public unitInUnitToUnit(i: number): UnitInUnitToUnitContext | null; + public unitInUnitToUnit(i?: number): UnitInUnitToUnitContext[] | UnitInUnitToUnitContext | null { + if (i === undefined) { + return this.getRuleContexts(UnitInUnitToUnitContext); + } + + return this.getRuleContext(i, UnitInUnitToUnitContext); + } + public KW_TO(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_TO, 0)!; + } + public intervalValue(): IntervalValueContext { + return this.getRuleContext(0, IntervalValueContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_unitToUnitInterval; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnitToUnitInterval) { + listener.enterUnitToUnitInterval(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnitToUnitInterval) { + listener.exitUnitToUnitInterval(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnitToUnitInterval) { + return visitor.visitUnitToUnitInterval(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IntervalValueContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public INTEGER_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.INTEGER_VALUE, 0); + } + public DECIMAL_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DECIMAL_VALUE, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public PLUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.PLUS, 0); + } + public MINUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.MINUS, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_intervalValue; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterIntervalValue) { + listener.enterIntervalValue(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitIntervalValue) { + listener.exitIntervalValue(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitIntervalValue) { + return visitor.visitIntervalValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnitInMultiUnitsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_NANOSECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NANOSECOND, 0); + } + public KW_NANOSECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NANOSECONDS, 0); + } + public KW_MICROSECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MICROSECOND, 0); + } + public KW_MICROSECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MICROSECONDS, 0); + } + public KW_MILLISECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MILLISECOND, 0); + } + public KW_MILLISECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MILLISECONDS, 0); + } + public KW_SECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SECOND, 0); + } + public KW_SECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SECONDS, 0); + } + public KW_MINUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUTE, 0); + } + public KW_MINUTES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUTES, 0); + } + public KW_HOUR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_HOUR, 0); + } + public KW_HOURS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_HOURS, 0); + } + public KW_DAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAY, 0); + } + public KW_DAYS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAYS, 0); + } + public KW_WEEK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WEEK, 0); + } + public KW_WEEKS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WEEKS, 0); + } + public KW_MONTH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MONTH, 0); + } + public KW_MONTHS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MONTHS, 0); + } + public KW_YEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_YEAR, 0); + } + public KW_YEARS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_YEARS, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_unitInMultiUnits; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnitInMultiUnits) { + listener.enterUnitInMultiUnits(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnitInMultiUnits) { + listener.exitUnitInMultiUnits(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnitInMultiUnits) { + return visitor.visitUnitInMultiUnits(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnitInUnitToUnitContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_SECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SECOND, 0); + } + public KW_MINUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUTE, 0); + } + public KW_HOUR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_HOUR, 0); + } + public KW_DAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAY, 0); + } + public KW_MONTH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MONTH, 0); + } + public KW_YEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_YEAR, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_unitInUnitToUnit; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterUnitInUnitToUnit) { + listener.enterUnitInUnitToUnit(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitUnitInUnitToUnit) { + listener.exitUnitInUnitToUnit(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitUnitInUnitToUnit) { + return visitor.visitUnitInUnitToUnit(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColPositionContext extends antlr.ParserRuleContext { + public _position?: Token | null; + public _afterCol?: ErrorCapturingIdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_FIRST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FIRST, 0); + } + public KW_AFTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AFTER, 0); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | null { + return this.getRuleContext(0, ErrorCapturingIdentifierContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_colPosition; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterColPosition) { + listener.enterColPosition(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitColPosition) { + listener.exitColPosition(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitColPosition) { + return visitor.visitColPosition(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TypeContext extends antlr.ParserRuleContext { + public _unsupportedType?: IdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_BOOLEAN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BOOLEAN, 0); + } + public KW_TINYINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TINYINT, 0); + } + public KW_BYTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BYTE, 0); + } + public KW_SMALLINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SMALLINT, 0); + } + public KW_SHORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SHORT, 0); + } + public KW_INT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INT, 0); + } + public KW_INTEGER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTEGER, 0); + } + public KW_BIGINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BIGINT, 0); + } + public KW_LONG(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LONG, 0); + } + public KW_FLOAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FLOAT, 0); + } + public KW_REAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REAL, 0); + } + public KW_DOUBLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DOUBLE, 0); + } + public KW_DATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE, 0); + } + public KW_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP, 0); + } + public KW_TIMESTAMP_NTZ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP_NTZ, 0); + } + public KW_TIMESTAMP_LTZ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP_LTZ, 0); + } + public KW_STRING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRING, 0); + } + public KW_CHARACTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHARACTER, 0); + } + public KW_CHAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHAR, 0); + } + public KW_VARCHAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VARCHAR, 0); + } + public KW_BINARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BINARY, 0); + } + public KW_DECIMAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DECIMAL, 0); + } + public KW_DEC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEC, 0); + } + public KW_NUMERIC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NUMERIC, 0); + } + public KW_VOID(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VOID, 0); + } + public KW_INTERVAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTERVAL, 0); + } + public KW_ARRAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ARRAY, 0); + } + public KW_STRUCT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRUCT, 0); + } + public KW_MAP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MAP, 0); + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_type; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterType) { + listener.enterType(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitType) { + listener.exitType(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitType) { + return visitor.visitType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DataTypeContext extends antlr.ParserRuleContext { + public _complex?: Token | null; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LT, 0); + } + public dataType(): DataTypeContext[]; + public dataType(i: number): DataTypeContext | null; + public dataType(i?: number): DataTypeContext[] | DataTypeContext | null { + if (i === undefined) { + return this.getRuleContexts(DataTypeContext); + } + + return this.getRuleContext(i, DataTypeContext); + } + public GT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.GT, 0); + } + public KW_ARRAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ARRAY, 0); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public KW_MAP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MAP, 0); + } + public KW_STRUCT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRUCT, 0); + } + public NEQ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.NEQ, 0); + } + public complexColType(): ComplexColTypeContext[]; + public complexColType(i: number): ComplexColTypeContext | null; + public complexColType(i?: number): ComplexColTypeContext[] | ComplexColTypeContext | null { + if (i === undefined) { + return this.getRuleContexts(ComplexColTypeContext); + } + + return this.getRuleContext(i, ComplexColTypeContext); + } + public KW_INTERVAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTERVAL, 0); + } + public KW_YEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_YEAR, 0); + } + public KW_MONTH(): antlr.TerminalNode[]; + public KW_MONTH(i: number): antlr.TerminalNode | null; + public KW_MONTH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_MONTH); + } else { + return this.getToken(SqlParser.KW_MONTH, i); + } + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TO, 0); + } + public KW_DAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAY, 0); + } + public KW_HOUR(): antlr.TerminalNode[]; + public KW_HOUR(i: number): antlr.TerminalNode | null; + public KW_HOUR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_HOUR); + } else { + return this.getToken(SqlParser.KW_HOUR, i); + } + } + public KW_MINUTE(): antlr.TerminalNode[]; + public KW_MINUTE(i: number): antlr.TerminalNode | null; + public KW_MINUTE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_MINUTE); + } else { + return this.getToken(SqlParser.KW_MINUTE, i); + } + } + public KW_SECOND(): antlr.TerminalNode[]; + public KW_SECOND(i: number): antlr.TerminalNode | null; + public KW_SECOND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_SECOND); + } else { + return this.getToken(SqlParser.KW_SECOND, i); + } + } + public type(): TypeContext | null { + return this.getRuleContext(0, TypeContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public INTEGER_VALUE(): antlr.TerminalNode[]; + public INTEGER_VALUE(i: number): antlr.TerminalNode | null; + public INTEGER_VALUE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.INTEGER_VALUE); + } else { + return this.getToken(SqlParser.INTEGER_VALUE, i); + } + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_dataType; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterDataType) { + listener.enterDataType(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitDataType) { + listener.exitDataType(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitDataType) { + return visitor.visitDataType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QualifiedColTypeWithPositionSeqForAddContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public qualifiedColTypeWithPositionForAdd(): QualifiedColTypeWithPositionForAddContext[]; + public qualifiedColTypeWithPositionForAdd(i: number): QualifiedColTypeWithPositionForAddContext | null; + public qualifiedColTypeWithPositionForAdd(i?: number): QualifiedColTypeWithPositionForAddContext[] | QualifiedColTypeWithPositionForAddContext | null { + if (i === undefined) { + return this.getRuleContexts(QualifiedColTypeWithPositionForAddContext); + } + + return this.getRuleContext(i, QualifiedColTypeWithPositionForAddContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_qualifiedColTypeWithPositionSeqForAdd; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQualifiedColTypeWithPositionSeqForAdd) { + listener.enterQualifiedColTypeWithPositionSeqForAdd(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQualifiedColTypeWithPositionSeqForAdd) { + listener.exitQualifiedColTypeWithPositionSeqForAdd(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQualifiedColTypeWithPositionSeqForAdd) { + return visitor.visitQualifiedColTypeWithPositionSeqForAdd(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QualifiedColTypeWithPositionForAddContext extends antlr.ParserRuleContext { + public _name?: ColumnNameCreateContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public dataType(): DataTypeContext { + return this.getRuleContext(0, DataTypeContext)!; + } + public columnNameCreate(): ColumnNameCreateContext { + return this.getRuleContext(0, ColumnNameCreateContext)!; + } + public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext[]; + public colDefinitionDescriptorWithPosition(i: number): ColDefinitionDescriptorWithPositionContext | null; + public colDefinitionDescriptorWithPosition(i?: number): ColDefinitionDescriptorWithPositionContext[] | ColDefinitionDescriptorWithPositionContext | null { + if (i === undefined) { + return this.getRuleContexts(ColDefinitionDescriptorWithPositionContext); + } + + return this.getRuleContext(i, ColDefinitionDescriptorWithPositionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_qualifiedColTypeWithPositionForAdd; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQualifiedColTypeWithPositionForAdd) { + listener.enterQualifiedColTypeWithPositionForAdd(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQualifiedColTypeWithPositionForAdd) { + listener.exitQualifiedColTypeWithPositionForAdd(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQualifiedColTypeWithPositionForAdd) { + return visitor.visitQualifiedColTypeWithPositionForAdd(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QualifiedColTypeWithPositionSeqForReplaceContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public qualifiedColTypeWithPositionForReplace(): QualifiedColTypeWithPositionForReplaceContext[]; + public qualifiedColTypeWithPositionForReplace(i: number): QualifiedColTypeWithPositionForReplaceContext | null; + public qualifiedColTypeWithPositionForReplace(i?: number): QualifiedColTypeWithPositionForReplaceContext[] | QualifiedColTypeWithPositionForReplaceContext | null { + if (i === undefined) { + return this.getRuleContexts(QualifiedColTypeWithPositionForReplaceContext); + } + + return this.getRuleContext(i, QualifiedColTypeWithPositionForReplaceContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_qualifiedColTypeWithPositionSeqForReplace; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQualifiedColTypeWithPositionSeqForReplace) { + listener.enterQualifiedColTypeWithPositionSeqForReplace(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQualifiedColTypeWithPositionSeqForReplace) { + listener.exitQualifiedColTypeWithPositionSeqForReplace(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQualifiedColTypeWithPositionSeqForReplace) { + return visitor.visitQualifiedColTypeWithPositionSeqForReplace(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QualifiedColTypeWithPositionForReplaceContext extends antlr.ParserRuleContext { + public _name?: ColumnNameContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public dataType(): DataTypeContext { + return this.getRuleContext(0, DataTypeContext)!; + } + public columnName(): ColumnNameContext { + return this.getRuleContext(0, ColumnNameContext)!; + } + public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext[]; + public colDefinitionDescriptorWithPosition(i: number): ColDefinitionDescriptorWithPositionContext | null; + public colDefinitionDescriptorWithPosition(i?: number): ColDefinitionDescriptorWithPositionContext[] | ColDefinitionDescriptorWithPositionContext | null { + if (i === undefined) { + return this.getRuleContexts(ColDefinitionDescriptorWithPositionContext); + } + + return this.getRuleContext(i, ColDefinitionDescriptorWithPositionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_qualifiedColTypeWithPositionForReplace; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQualifiedColTypeWithPositionForReplace) { + listener.enterQualifiedColTypeWithPositionForReplace(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQualifiedColTypeWithPositionForReplace) { + listener.exitQualifiedColTypeWithPositionForReplace(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQualifiedColTypeWithPositionForReplace) { + return visitor.visitQualifiedColTypeWithPositionForReplace(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColDefinitionDescriptorWithPositionContext extends antlr.ParserRuleContext { + public _comment?: StringLitContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFAULT, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMENT, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public colPosition(): ColPositionContext | null { + return this.getRuleContext(0, ColPositionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_colDefinitionDescriptorWithPosition; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterColDefinitionDescriptorWithPosition) { + listener.enterColDefinitionDescriptorWithPosition(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitColDefinitionDescriptorWithPosition) { + listener.exitColDefinitionDescriptorWithPosition(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitColDefinitionDescriptorWithPosition) { + return visitor.visitColDefinitionDescriptorWithPosition(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class VariableDefaultExpressionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFAULT, 0); + } + public EQ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.EQ, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_variableDefaultExpression; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterVariableDefaultExpression) { + listener.enterVariableDefaultExpression(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitVariableDefaultExpression) { + listener.exitVariableDefaultExpression(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitVariableDefaultExpression) { + return visitor.visitVariableDefaultExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColTypeListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public columnType(): ColumnTypeContext[]; + public columnType(i: number): ColumnTypeContext | null; + public columnType(i?: number): ColumnTypeContext[] | ColumnTypeContext | null { + if (i === undefined) { + return this.getRuleContexts(ColumnTypeContext); + } + + return this.getRuleContext(i, ColumnTypeContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_colTypeList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterColTypeList) { + listener.enterColTypeList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitColTypeList) { + listener.exitColTypeList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitColTypeList) { + return visitor.visitColTypeList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnTypeContext extends antlr.ParserRuleContext { + public _colName?: ErrorCapturingIdentifierContext; + public _comment?: StringLitContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public dataType(): DataTypeContext { + return this.getRuleContext(0, DataTypeContext)!; + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext { + return this.getRuleContext(0, ErrorCapturingIdentifierContext)!; + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMENT, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_columnType; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterColumnType) { + listener.enterColumnType(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitColumnType) { + listener.exitColumnType(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitColumnType) { + return visitor.visitColumnType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateOrReplaceTableColTypeListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public createOrReplaceTableColType(): CreateOrReplaceTableColTypeContext[]; + public createOrReplaceTableColType(i: number): CreateOrReplaceTableColTypeContext | null; + public createOrReplaceTableColType(i?: number): CreateOrReplaceTableColTypeContext[] | CreateOrReplaceTableColTypeContext | null { + if (i === undefined) { + return this.getRuleContexts(CreateOrReplaceTableColTypeContext); + } + + return this.getRuleContext(i, CreateOrReplaceTableColTypeContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_createOrReplaceTableColTypeList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateOrReplaceTableColTypeList) { + listener.enterCreateOrReplaceTableColTypeList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateOrReplaceTableColTypeList) { + listener.exitCreateOrReplaceTableColTypeList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateOrReplaceTableColTypeList) { + return visitor.visitCreateOrReplaceTableColTypeList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateOrReplaceTableColTypeContext extends antlr.ParserRuleContext { + public _colName?: ColumnNameCreateContext; + public _colType?: DataTypeContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public columnNameCreate(): ColumnNameCreateContext { + return this.getRuleContext(0, ColumnNameCreateContext)!; + } + public dataType(): DataTypeContext { + return this.getRuleContext(0, DataTypeContext)!; + } + public colDefinitionOption(): ColDefinitionOptionContext[]; + public colDefinitionOption(i: number): ColDefinitionOptionContext | null; + public colDefinitionOption(i?: number): ColDefinitionOptionContext[] | ColDefinitionOptionContext | null { + if (i === undefined) { + return this.getRuleContexts(ColDefinitionOptionContext); + } + + return this.getRuleContext(i, ColDefinitionOptionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_createOrReplaceTableColType; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterCreateOrReplaceTableColType) { + listener.enterCreateOrReplaceTableColType(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitCreateOrReplaceTableColType) { + listener.exitCreateOrReplaceTableColType(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitCreateOrReplaceTableColType) { + return visitor.visitCreateOrReplaceTableColType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColDefinitionOptionContext extends antlr.ParserRuleContext { + public _comment?: StringLitContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFAULT, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public KW_GENERATED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GENERATED, 0); + } + public KW_ALWAYS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALWAYS, 0); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMENT, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_colDefinitionOption; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterColDefinitionOption) { + listener.enterColDefinitionOption(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitColDefinitionOption) { + listener.exitColDefinitionOption(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitColDefinitionOption) { + return visitor.visitColDefinitionOption(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ComplexColTypeContext extends antlr.ParserRuleContext { + public _comment?: StringLitContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext)!; + } + public dataType(): DataTypeContext { + return this.getRuleContext(0, DataTypeContext)!; + } + public COLON(): antlr.TerminalNode | null { + return this.getToken(SqlParser.COLON, 0); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMENT, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_complexColType; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterComplexColType) { + listener.enterComplexColType(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitComplexColType) { + listener.exitComplexColType(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitComplexColType) { + return visitor.visitComplexColType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WhenClauseContext extends antlr.ParserRuleContext { + public _condition?: ExpressionContext; + public _result?: ExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_WHEN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_WHEN, 0)!; + } + public KW_THEN(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_THEN, 0)!; + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_whenClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterWhenClause) { + listener.enterWhenClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitWhenClause) { + listener.exitWhenClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitWhenClause) { + return visitor.visitWhenClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WindowClauseContext extends antlr.ParserRuleContext { + public _name?: ErrorCapturingIdentifierContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_WINDOW(): antlr.TerminalNode { + return this.getToken(SqlParser.KW_WINDOW, 0)!; + } + public KW_AS(): antlr.TerminalNode[]; + public KW_AS(i: number): antlr.TerminalNode | null; + public KW_AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_AS); + } else { + return this.getToken(SqlParser.KW_AS, i); + } + } + public windowSpec(): WindowSpecContext[]; + public windowSpec(i: number): WindowSpecContext | null; + public windowSpec(i?: number): WindowSpecContext[] | WindowSpecContext | null { + if (i === undefined) { + return this.getRuleContexts(WindowSpecContext); + } + + return this.getRuleContext(i, WindowSpecContext); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[]; + public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext | null; + public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext[] | ErrorCapturingIdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ErrorCapturingIdentifierContext); + } + + return this.getRuleContext(i, ErrorCapturingIdentifierContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_windowClause; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterWindowClause) { + listener.enterWindowClause(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitWindowClause) { + listener.exitWindowClause(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitWindowClause) { + return visitor.visitWindowClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WindowSpecContext extends antlr.ParserRuleContext { + public _name?: ErrorCapturingIdentifierContext; + public _expression?: ExpressionContext; + public _partition: ExpressionContext[] = []; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | null { + return this.getRuleContext(0, ErrorCapturingIdentifierContext); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public KW_CLUSTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CLUSTER, 0); + } + public KW_BY(): antlr.TerminalNode[]; + public KW_BY(i: number): antlr.TerminalNode | null; + public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.KW_BY); + } else { + return this.getToken(SqlParser.KW_BY, i); + } + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public windowFrame(): WindowFrameContext | null { + return this.getRuleContext(0, WindowFrameContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public sortItem(): SortItemContext[]; + public sortItem(i: number): SortItemContext | null; + public sortItem(i?: number): SortItemContext[] | SortItemContext | null { + if (i === undefined) { + return this.getRuleContexts(SortItemContext); + } + + return this.getRuleContext(i, SortItemContext); + } + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITION, 0); + } + public KW_DISTRIBUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISTRIBUTE, 0); + } + public KW_ORDER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ORDER, 0); + } + public KW_SORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SORT, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_windowSpec; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterWindowSpec) { + listener.enterWindowSpec(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitWindowSpec) { + listener.exitWindowSpec(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitWindowSpec) { + return visitor.visitWindowSpec(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WindowFrameContext extends antlr.ParserRuleContext { + public _frameType?: Token | null; + public _start_?: FrameBoundContext; + public _end?: FrameBoundContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public frameBound(): FrameBoundContext[]; + public frameBound(i: number): FrameBoundContext | null; + public frameBound(i?: number): FrameBoundContext[] | FrameBoundContext | null { + if (i === undefined) { + return this.getRuleContexts(FrameBoundContext); + } + + return this.getRuleContext(i, FrameBoundContext); + } + public KW_RANGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RANGE, 0); + } + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROWS, 0); + } + public KW_BETWEEN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BETWEEN, 0); + } + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AND, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_windowFrame; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterWindowFrame) { + listener.enterWindowFrame(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitWindowFrame) { + listener.exitWindowFrame(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitWindowFrame) { + return visitor.visitWindowFrame(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FrameBoundContext extends antlr.ParserRuleContext { + public _boundType?: Token | null; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_UNBOUNDED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNBOUNDED, 0); + } + public KW_PRECEDING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PRECEDING, 0); + } + public KW_FOLLOWING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FOLLOWING, 0); + } + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROW, 0); + } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_frameBound; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFrameBound) { + listener.enterFrameBound(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFrameBound) { + listener.exitFrameBound(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFrameBound) { + return visitor.visitFrameBound(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QualifiedNameListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public qualifiedName(): QualifiedNameContext[]; + public qualifiedName(i: number): QualifiedNameContext | null; + public qualifiedName(i?: number): QualifiedNameContext[] | QualifiedNameContext | null { + if (i === undefined) { + return this.getRuleContexts(QualifiedNameContext); + } + + return this.getRuleContext(i, QualifiedNameContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.COMMA); + } else { + return this.getToken(SqlParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_qualifiedNameList; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQualifiedNameList) { + listener.enterQualifiedNameList(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQualifiedNameList) { + listener.exitQualifiedNameList(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQualifiedNameList) { + return visitor.visitQualifiedNameList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FunctionNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_IDENTIFIER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IDENTIFIER, 0); + } + public LEFT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.LEFT_PAREN, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public RIGHT_PAREN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.RIGHT_PAREN, 0); + } + public qualifiedName(): QualifiedNameContext | null { + return this.getRuleContext(0, QualifiedNameContext); + } + public KW_FILTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FILTER, 0); + } + public KW_LEFT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LEFT, 0); + } + public KW_RIGHT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RIGHT, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_functionName; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFunctionName) { + listener.enterFunctionName(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFunctionName) { + listener.exitFunctionName(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFunctionName) { + return visitor.visitFunctionName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FunctionNameCreateContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_functionNameCreate; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterFunctionNameCreate) { + listener.enterFunctionNameCreate(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitFunctionNameCreate) { + listener.exitFunctionNameCreate(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitFunctionNameCreate) { + return visitor.visitFunctionNameCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QualifiedNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.DOT); + } else { + return this.getToken(SqlParser.DOT, i); + } + } + public override get ruleIndex(): number { + return SqlParser.RULE_qualifiedName; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterQualifiedName) { + listener.enterQualifiedName(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitQualifiedName) { + listener.exitQualifiedName(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitQualifiedName) { + return visitor.visitQualifiedName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ErrorCapturingIdentifierContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext)!; + } + public errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext { + return this.getRuleContext(0, ErrorCapturingIdentifierExtraContext)!; + } + public override get ruleIndex(): number { + return SqlParser.RULE_errorCapturingIdentifier; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterErrorCapturingIdentifier) { + listener.enterErrorCapturingIdentifier(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitErrorCapturingIdentifier) { + listener.exitErrorCapturingIdentifier(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitErrorCapturingIdentifier) { + return visitor.visitErrorCapturingIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ErrorCapturingIdentifierExtraContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public MINUS(): antlr.TerminalNode[]; + public MINUS(i: number): antlr.TerminalNode | null; + public MINUS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(SqlParser.MINUS); + } else { + return this.getToken(SqlParser.MINUS, i); + } + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_errorCapturingIdentifierExtra; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterErrorCapturingIdentifierExtra) { + listener.enterErrorCapturingIdentifierExtra(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitErrorCapturingIdentifierExtra) { + listener.exitErrorCapturingIdentifierExtra(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitErrorCapturingIdentifierExtra) { + return visitor.visitErrorCapturingIdentifierExtra(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IdentifierContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public strictIdentifier(): StrictIdentifierContext | null { + return this.getRuleContext(0, StrictIdentifierContext); + } + public strictNonReserved(): StrictNonReservedContext | null { + return this.getRuleContext(0, StrictNonReservedContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_identifier; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterIdentifier) { + listener.enterIdentifier(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitIdentifier) { + listener.exitIdentifier(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitIdentifier) { + return visitor.visitIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class StrictIdentifierContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public IDENTIFIER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.IDENTIFIER, 0); + } + public BACKQUOTED_IDENTIFIER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.BACKQUOTED_IDENTIFIER, 0); + } + public DOUBLEQUOTED_STRING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DOUBLEQUOTED_STRING, 0); + } + public ansiNonReserved(): AnsiNonReservedContext | null { + return this.getRuleContext(0, AnsiNonReservedContext); + } + public nonReserved(): NonReservedContext | null { + return this.getRuleContext(0, NonReservedContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_strictIdentifier; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterStrictIdentifier) { + listener.enterStrictIdentifier(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitStrictIdentifier) { + listener.exitStrictIdentifier(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitStrictIdentifier) { + return visitor.visitStrictIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NumberContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public EXPONENT_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.EXPONENT_VALUE, 0); + } + public DECIMAL_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DECIMAL_VALUE, 0); + } + public INTEGER_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.INTEGER_VALUE, 0); + } + public BIGINT_LITERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.BIGINT_LITERAL, 0); + } + public SMALLINT_LITERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.SMALLINT_LITERAL, 0); + } + public TINYINT_LITERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.TINYINT_LITERAL, 0); + } + public DOUBLE_LITERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DOUBLE_LITERAL, 0); + } + public FLOAT_LITERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.FLOAT_LITERAL, 0); + } + public BIGDECIMAL_LITERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.BIGDECIMAL_LITERAL, 0); + } + public MINUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.MINUS, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_number; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNumber) { + listener.enterNumber(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNumber) { + listener.exitNumber(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNumber) { + return visitor.visitNumber(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterColumnActionContext extends antlr.ParserRuleContext { + public _comment?: StringLitContext; + public _setOrDrop?: Token | null; + public _dropDefault?: Token | null; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TYPE, 0); + } + public dataType(): DataTypeContext | null { + return this.getRuleContext(0, DataTypeContext); + } + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMENT, 0); + } + public stringLit(): StringLitContext | null { + return this.getRuleContext(0, StringLitContext); + } + public colPosition(): ColPositionContext | null { + return this.getRuleContext(0, ColPositionContext); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SET, 0); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DROP, 0); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFAULT, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public override get ruleIndex(): number { + return SqlParser.RULE_alterColumnAction; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterAlterColumnAction) { + listener.enterAlterColumnAction(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitAlterColumnAction) { + listener.exitAlterColumnAction(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitAlterColumnAction) { + return visitor.visitAlterColumnAction(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class StringLitContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public STRING_LITERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.STRING_LITERAL, 0); + } + public DOUBLEQUOTED_STRING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.DOUBLEQUOTED_STRING, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_stringLit; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterStringLit) { + listener.enterStringLit(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitStringLit) { + listener.exitStringLit(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitStringLit) { + return visitor.visitStringLit(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AnsiNonReservedContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ADD, 0); + } + public KW_AFTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AFTER, 0); + } + public KW_ALTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALTER, 0); + } + public KW_ALWAYS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALWAYS, 0); + } + public KW_ANALYZE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANALYZE, 0); + } + public KW_ANTI(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANTI, 0); + } + public KW_ANY_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANY_VALUE, 0); + } + public KW_ARCHIVE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ARCHIVE, 0); + } + public KW_ARRAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ARRAY, 0); + } + public KW_ASC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ASC, 0); + } + public KW_AT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AT, 0); + } + public KW_BETWEEN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BETWEEN, 0); + } + public KW_BIGINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BIGINT, 0); + } + public KW_BINARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BINARY, 0); + } + public KW_BINARY_HEX(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BINARY_HEX, 0); + } + public KW_BOOLEAN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BOOLEAN, 0); + } + public KW_BUCKET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BUCKET, 0); + } + public KW_BUCKETS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BUCKETS, 0); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BY, 0); + } + public KW_BYTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BYTE, 0); + } + public KW_CACHE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CACHE, 0); + } + public KW_CASCADE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CASCADE, 0); + } + public KW_CATALOG(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CATALOG, 0); + } + public KW_CATALOGS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CATALOGS, 0); + } + public KW_CHANGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHANGE, 0); + } + public KW_CHAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHAR, 0); + } + public KW_CHARACTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHARACTER, 0); + } + public KW_CLEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CLEAR, 0); + } + public KW_CLUSTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CLUSTER, 0); + } + public KW_CLUSTERED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CLUSTERED, 0); + } + public KW_CODEGEN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CODEGEN, 0); + } + public KW_COLLECTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLLECTION, 0); + } + public KW_COLUMNS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLUMNS, 0); + } + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMENT, 0); + } + public KW_COMMIT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMIT, 0); + } + public KW_COMPACT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMPACT, 0); + } + public KW_COMPACTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMPACTIONS, 0); + } + public KW_COMPUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMPUTE, 0); + } + public KW_CONCATENATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CONCATENATE, 0); + } + public KW_COST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COST, 0); + } + public KW_CUBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CUBE, 0); + } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT, 0); + } + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATA, 0); + } + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATABASE, 0); + } + public KW_DATABASES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATABASES, 0); + } + public KW_DATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE, 0); + } + public KW_DATEADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATEADD, 0); + } + public KW_DATE_ADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE_ADD, 0); + } + public KW_DATEDIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATEDIFF, 0); + } + public KW_DATE_DIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE_DIFF, 0); + } + public KW_DAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAY, 0); + } + public KW_DAYS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAYS, 0); + } + public KW_DAYOFYEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAYOFYEAR, 0); + } + public KW_DBPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DBPROPERTIES, 0); + } + public KW_DEC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEC, 0); + } + public KW_DECIMAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DECIMAL, 0); + } + public KW_DECLARE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DECLARE, 0); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFAULT, 0); + } + public KW_DEFINED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFINED, 0); + } + public KW_DELETE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DELETE, 0); + } + public KW_DELIMITED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DELIMITED, 0); + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESC, 0); + } + public KW_DESCRIBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESCRIBE, 0); + } + public KW_DFS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DFS, 0); + } + public KW_DIRECTORIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIRECTORIES, 0); + } + public KW_DIRECTORY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIRECTORY, 0); + } + public KW_DISABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISABLE, 0); + } + public KW_DISTRIBUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISTRIBUTE, 0); + } + public KW_DIV(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIV, 0); + } + public KW_DOUBLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DOUBLE, 0); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DROP, 0); + } + public KW_ENABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ENABLE, 0); + } + public KW_ESCAPED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ESCAPED, 0); + } + public KW_EXCHANGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXCHANGE, 0); + } + public KW_EXCLUDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXCLUDE, 0); + } + public KW_EXISTS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXISTS, 0); + } + public KW_EXPLAIN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXPLAIN, 0); + } + public KW_EXPORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXPORT, 0); + } + public KW_EXTENDED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTENDED, 0); + } + public KW_EXTERNAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTERNAL, 0); + } + public KW_EXTRACT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTRACT, 0); + } + public KW_FIELDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FIELDS, 0); + } + public KW_FILEFORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FILEFORMAT, 0); + } + public KW_FIRST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FIRST, 0); + } + public KW_FLOAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FLOAT, 0); + } + public KW_FOLLOWING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FOLLOWING, 0); + } + public KW_FORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FORMAT, 0); + } + public KW_FORMATTED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FORMATTED, 0); + } + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FUNCTION, 0); + } + public KW_FUNCTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FUNCTIONS, 0); + } + public KW_GENERATED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GENERATED, 0); + } + public KW_GLOBAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GLOBAL, 0); + } + public KW_GROUPING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GROUPING, 0); + } + public KW_HOUR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_HOUR, 0); + } + public KW_HOURS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_HOURS, 0); + } + public KW_IDENTIFIER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IDENTIFIER, 0); + } + public KW_IF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IF, 0); + } + public KW_IGNORE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IGNORE, 0); + } + public KW_IMPORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IMPORT, 0); + } + public KW_INCLUDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INCLUDE, 0); + } + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INDEX, 0); + } + public KW_INDEXES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INDEXES, 0); + } + public KW_INPATH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INPATH, 0); + } + public KW_INPUTFORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INPUTFORMAT, 0); + } + public KW_INSERT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INSERT, 0); + } + public KW_INT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INT, 0); + } + public KW_INTEGER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTEGER, 0); + } + public KW_INTERVAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTERVAL, 0); + } + public KW_ITEMS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ITEMS, 0); + } + public KW_KEYS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_KEYS, 0); + } + public KW_LAST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LAST, 0); + } + public KW_LAZY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LAZY, 0); + } + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIKE, 0); + } + public KW_ILIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ILIKE, 0); + } + public KW_LIMIT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIMIT, 0); + } + public KW_LINES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LINES, 0); + } + public KW_LIST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIST, 0); + } + public KW_LOAD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOAD, 0); + } + public KW_LOCAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCAL, 0); + } + public KW_LOCATION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCATION, 0); + } + public KW_LOCK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCK, 0); + } + public KW_LOCKS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCKS, 0); + } + public KW_LOGICAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOGICAL, 0); + } + public KW_LONG(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LONG, 0); + } + public KW_MACRO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MACRO, 0); + } + public KW_MAP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MAP, 0); + } + public KW_MATCHED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MATCHED, 0); + } + public KW_MERGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MERGE, 0); + } + public KW_MICROSECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MICROSECOND, 0); + } + public KW_MICROSECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MICROSECONDS, 0); + } + public KW_MILLISECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MILLISECOND, 0); + } + public KW_MILLISECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MILLISECONDS, 0); + } + public KW_MINUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUTE, 0); + } + public KW_MINUTES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUTES, 0); + } + public KW_MONTH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MONTH, 0); + } + public KW_MONTHS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MONTHS, 0); + } + public KW_MSCK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MSCK, 0); + } + public KW_NAME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NAME, 0); + } + public KW_NAMESPACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NAMESPACE, 0); + } + public KW_NAMESPACES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NAMESPACES, 0); + } + public KW_NANOSECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NANOSECOND, 0); + } + public KW_NANOSECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NANOSECONDS, 0); + } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NO, 0); + } + public KW_NULLS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULLS, 0); + } + public KW_NUMERIC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NUMERIC, 0); + } + public KW_OF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OF, 0); + } + public KW_OPTIMIZE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTIMIZE, 0); + } + public KW_OPTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTION, 0); + } + public KW_OPTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTIONS, 0); + } + public KW_OUT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OUT, 0); + } + public KW_OUTPUTFORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OUTPUTFORMAT, 0); + } + public KW_OVER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVER, 0); + } + public KW_OVERLAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVERLAY, 0); + } + public KW_OVERWRITE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVERWRITE, 0); + } + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITION, 0); + } + public KW_PARTITIONED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITIONED, 0); + } + public KW_PARTITIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITIONS, 0); + } + public KW_PERCENTLIT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PERCENTLIT, 0); + } + public KW_PIVOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PIVOT, 0); + } + public KW_PLACING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PLACING, 0); + } + public KW_POSITION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_POSITION, 0); + } + public KW_PRECEDING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PRECEDING, 0); + } + public KW_PRINCIPALS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PRINCIPALS, 0); + } + public KW_PROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PROPERTIES, 0); + } + public KW_PURGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PURGE, 0); + } + public KW_QUARTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_QUARTER, 0); + } + public KW_QUERY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_QUERY, 0); + } + public KW_RANGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RANGE, 0); + } + public KW_REAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REAL, 0); + } + public KW_RECORDREADER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RECORDREADER, 0); + } + public KW_RECORDWRITER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RECORDWRITER, 0); + } + public KW_RECOVER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RECOVER, 0); + } + public KW_REDUCE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REDUCE, 0); + } + public KW_REFRESH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REFRESH, 0); + } + public KW_RENAME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RENAME, 0); + } + public KW_REPAIR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPAIR, 0); + } + public KW_REPEATABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPEATABLE, 0); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPLACE, 0); + } + public KW_RESET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RESET, 0); + } + public KW_RESPECT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RESPECT, 0); + } + public KW_RESTRICT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RESTRICT, 0); + } + public KW_REVOKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REVOKE, 0); + } + public KW_REWRITE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REWRITE, 0); + } + public KW_RLIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RLIKE, 0); + } + public KW_REGEXP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REGEXP, 0); + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLE, 0); + } + public KW_ROLES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLES, 0); + } + public KW_ROLLBACK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLLBACK, 0); + } + public KW_ROLLUP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLLUP, 0); + } + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROW, 0); + } + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROWS, 0); + } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SCHEMA, 0); + } + public KW_SCHEMAS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SCHEMAS, 0); + } + public KW_SECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SECOND, 0); + } + public KW_SECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SECONDS, 0); + } + public KW_SEMI(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SEMI, 0); + } + public KW_SEPARATED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SEPARATED, 0); + } + public KW_SERDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDE, 0); + } + public KW_SERDEPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDEPROPERTIES, 0); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SET, 0); + } + public KW_MINUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUS, 0); + } + public KW_SETS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SETS, 0); + } + public KW_SHORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SHORT, 0); + } + public KW_SHOW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SHOW, 0); + } + public KW_SINGLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SINGLE, 0); + } + public KW_SKEWED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SKEWED, 0); + } + public KW_SMALLINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SMALLINT, 0); + } + public KW_SORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SORT, 0); + } + public KW_SORTED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SORTED, 0); + } + public KW_SOURCE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SOURCE, 0); + } + public KW_START(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_START, 0); + } + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STATISTICS, 0); + } + public KW_STORED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STORED, 0); + } + public KW_STRATIFY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRATIFY, 0); + } + public KW_STRING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRING, 0); + } + public KW_STRUCT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRUCT, 0); + } + public KW_SUBSTR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SUBSTR, 0); + } + public KW_SUBSTRING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SUBSTRING, 0); + } + public KW_SYNC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYNC, 0); + } + public KW_SYSTEM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYSTEM, 0); + } + public KW_SYSTEM_TIME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYSTEM_TIME, 0); + } + public KW_SYSTEM_VERSION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYSTEM_VERSION, 0); + } + public KW_TABLES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLES, 0); + } + public KW_TABLESAMPLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLESAMPLE, 0); + } + public KW_TARGET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TARGET, 0); + } + public KW_TBLPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TBLPROPERTIES, 0); + } + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TEMPORARY, 0); + } + public KW_TERMINATED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TERMINATED, 0); + } + public KW_TIMEDIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMEDIFF, 0); + } + public KW_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP, 0); + } + public KW_TIMESTAMP_LTZ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP_LTZ, 0); + } + public KW_TIMESTAMP_NTZ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP_NTZ, 0); + } + public KW_TIMESTAMPADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMPADD, 0); + } + public KW_TIMESTAMPDIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMPDIFF, 0); + } + public KW_TINYINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TINYINT, 0); + } + public KW_TOUCH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TOUCH, 0); + } + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRANSACTION, 0); + } + public KW_TRANSACTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRANSACTIONS, 0); + } + public KW_TRANSFORM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRANSFORM, 0); + } + public KW_TRIM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRIM, 0); + } + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRUE, 0); + } + public KW_TRUNCATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRUNCATE, 0); + } + public KW_TRY_CAST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRY_CAST, 0); + } + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TYPE, 0); + } + public KW_UNARCHIVE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNARCHIVE, 0); + } + public KW_UNBOUNDED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNBOUNDED, 0); + } + public KW_UNCACHE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNCACHE, 0); + } + public KW_UNLOCK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNLOCK, 0); + } + public KW_UNPIVOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNPIVOT, 0); + } + public KW_UNSET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNSET, 0); + } + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UPDATE, 0); + } + public KW_USE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_USE, 0); + } + public KW_VALUES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VALUES, 0); + } + public KW_VARCHAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VARCHAR, 0); + } + public KW_VAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VAR, 0); + } + public KW_VARIABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VARIABLE, 0); + } + public KW_VERSION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VERSION, 0); + } + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VIEW, 0); + } + public KW_VIEWS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VIEWS, 0); + } + public KW_VOID(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VOID, 0); + } + public KW_WEEK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WEEK, 0); + } + public KW_WEEKS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WEEKS, 0); + } + public KW_WINDOW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WINDOW, 0); + } + public KW_YEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_YEAR, 0); + } + public KW_YEARS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_YEARS, 0); + } + public KW_ZONE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ZONE, 0); + } + public KW_ZORDER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ZORDER, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_ansiNonReserved; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterAnsiNonReserved) { + listener.enterAnsiNonReserved(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitAnsiNonReserved) { + listener.exitAnsiNonReserved(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitAnsiNonReserved) { + return visitor.visitAnsiNonReserved(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class StrictNonReservedContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_ANTI(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANTI, 0); + } + public KW_CROSS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CROSS, 0); + } + public KW_EXCEPT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXCEPT, 0); + } + public KW_FULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FULL, 0); + } + public KW_INNER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INNER, 0); + } + public KW_INTERSECT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTERSECT, 0); + } + public KW_JOIN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_JOIN, 0); + } + public KW_LATERAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LATERAL, 0); + } + public KW_LEFT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LEFT, 0); + } + public KW_NATURAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NATURAL, 0); + } + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ON, 0); + } + public KW_RIGHT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RIGHT, 0); + } + public KW_SEMI(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SEMI, 0); + } + public KW_MINUS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUS, 0); + } + public KW_UNION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNION, 0); + } + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_USING, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_strictNonReserved; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterStrictNonReserved) { + listener.enterStrictNonReserved(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitStrictNonReserved) { + listener.exitStrictNonReserved(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitStrictNonReserved) { + return visitor.visitStrictNonReserved(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NonReservedContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ADD, 0); + } + public KW_AFTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AFTER, 0); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALL, 0); + } + public KW_ALTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALTER, 0); + } + public KW_ALWAYS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ALWAYS, 0); + } + public KW_ANALYZE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANALYZE, 0); + } + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AND, 0); + } + public KW_ANY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANY, 0); + } + public KW_ANY_VALUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ANY_VALUE, 0); + } + public KW_ARCHIVE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ARCHIVE, 0); + } + public KW_ARRAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ARRAY, 0); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AS, 0); + } + public KW_ASC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ASC, 0); + } + public KW_AT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AT, 0); + } + public KW_AUTHORIZATION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_AUTHORIZATION, 0); + } + public KW_BETWEEN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BETWEEN, 0); + } + public KW_BIGINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BIGINT, 0); + } + public KW_BINARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BINARY, 0); + } + public KW_BINARY_HEX(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BINARY_HEX, 0); + } + public KW_BOOLEAN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BOOLEAN, 0); + } + public KW_BOTH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BOTH, 0); + } + public KW_BUCKET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BUCKET, 0); + } + public KW_BUCKETS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BUCKETS, 0); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BY, 0); + } + public KW_BYTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_BYTE, 0); + } + public KW_CACHE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CACHE, 0); + } + public KW_CASCADE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CASCADE, 0); + } + public KW_CASE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CASE, 0); + } + public KW_CAST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CAST, 0); + } + public KW_CATALOG(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CATALOG, 0); + } + public KW_CATALOGS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CATALOGS, 0); + } + public KW_CHANGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHANGE, 0); + } + public KW_CHAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHAR, 0); + } + public KW_CHARACTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHARACTER, 0); + } + public KW_CHECK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CHECK, 0); + } + public KW_CLEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CLEAR, 0); + } + public KW_CLUSTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CLUSTER, 0); + } + public KW_CLUSTERED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CLUSTERED, 0); + } + public KW_CODEGEN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CODEGEN, 0); + } + public KW_COLLATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLLATE, 0); + } + public KW_COLLECTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLLECTION, 0); + } + public KW_COLUMN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLUMN, 0); + } + public KW_COLUMNS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COLUMNS, 0); + } + public KW_COMMENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMENT, 0); + } + public KW_COMMIT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMMIT, 0); + } + public KW_COMPACT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMPACT, 0); + } + public KW_COMPACTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMPACTIONS, 0); + } + public KW_COMPUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COMPUTE, 0); + } + public KW_CONCATENATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CONCATENATE, 0); + } + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CONSTRAINT, 0); + } + public KW_COST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_COST, 0); + } + public KW_CREATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CREATE, 0); + } + public KW_CUBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CUBE, 0); + } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT, 0); + } + public KW_CURRENT_DATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT_DATE, 0); + } + public KW_CURRENT_TIME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT_TIME, 0); + } + public KW_CURRENT_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT_TIMESTAMP, 0); + } + public KW_CURRENT_USER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_CURRENT_USER, 0); + } + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATA, 0); + } + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATABASE, 0); + } + public KW_DATABASES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATABASES, 0); + } + public KW_DATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE, 0); + } + public KW_DATEADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATEADD, 0); + } + public KW_DATE_ADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE_ADD, 0); + } + public KW_DATEDIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATEDIFF, 0); + } + public KW_DATE_DIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DATE_DIFF, 0); + } + public KW_DAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAY, 0); + } + public KW_DAYS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAYS, 0); + } + public KW_DAYOFYEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DAYOFYEAR, 0); + } + public KW_DBPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DBPROPERTIES, 0); + } + public KW_DEC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEC, 0); + } + public KW_DECIMAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DECIMAL, 0); + } + public KW_DECLARE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DECLARE, 0); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFAULT, 0); + } + public KW_DEFINED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DEFINED, 0); + } + public KW_DELETE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DELETE, 0); + } + public KW_DELIMITED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DELIMITED, 0); + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESC, 0); + } + public KW_DESCRIBE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DESCRIBE, 0); + } + public KW_DFS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DFS, 0); + } + public KW_DIRECTORIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIRECTORIES, 0); + } + public KW_DIRECTORY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIRECTORY, 0); + } + public KW_DISABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISABLE, 0); + } + public KW_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISTINCT, 0); + } + public KW_DISTRIBUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DISTRIBUTE, 0); + } + public KW_DIV(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DIV, 0); + } + public KW_DOUBLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DOUBLE, 0); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_DROP, 0); + } + public KW_ELSE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ELSE, 0); + } + public KW_ENABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ENABLE, 0); + } + public KW_END(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_END, 0); + } + public KW_ESCAPE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ESCAPE, 0); + } + public KW_ESCAPED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ESCAPED, 0); + } + public KW_EXCHANGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXCHANGE, 0); + } + public KW_EXCLUDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXCLUDE, 0); + } + public KW_EXISTS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXISTS, 0); + } + public KW_EXPLAIN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXPLAIN, 0); + } + public KW_EXPORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXPORT, 0); + } + public KW_EXTENDED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTENDED, 0); + } + public KW_EXTERNAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTERNAL, 0); + } + public KW_EXTRACT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_EXTRACT, 0); + } + public KW_FALSE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FALSE, 0); + } + public KW_FETCH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FETCH, 0); + } + public KW_FILTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FILTER, 0); + } + public KW_FIELDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FIELDS, 0); + } + public KW_FILEFORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FILEFORMAT, 0); + } + public KW_FIRST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FIRST, 0); + } + public KW_FLOAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FLOAT, 0); + } + public KW_FOLLOWING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FOLLOWING, 0); + } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FOR, 0); + } + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FOREIGN, 0); + } + public KW_FORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FORMAT, 0); + } + public KW_FORMATTED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FORMATTED, 0); + } + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FUNCTION, 0); + } + public KW_FUNCTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_FUNCTIONS, 0); + } + public KW_GENERATED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GENERATED, 0); + } + public KW_GLOBAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GLOBAL, 0); + } + public KW_GRANT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GRANT, 0); + } + public KW_GROUP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GROUP, 0); + } + public KW_GROUPING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_GROUPING, 0); + } + public KW_HAVING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_HAVING, 0); + } + public KW_HOUR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_HOUR, 0); + } + public KW_HOURS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_HOURS, 0); + } + public KW_IDENTIFIER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IDENTIFIER, 0); + } + public KW_IF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IF, 0); + } + public KW_IGNORE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IGNORE, 0); + } + public KW_IMPORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IMPORT, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IN, 0); + } + public KW_INCLUDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INCLUDE, 0); + } + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INDEX, 0); + } + public KW_INDEXES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INDEXES, 0); + } + public KW_INPATH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INPATH, 0); + } + public KW_INPUTFORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INPUTFORMAT, 0); + } + public KW_INSERT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INSERT, 0); + } + public KW_INT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INT, 0); + } + public KW_INTEGER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTEGER, 0); + } + public KW_INTERVAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTERVAL, 0); + } + public KW_INTO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_INTO, 0); + } + public KW_IS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_IS, 0); + } + public KW_ITEMS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ITEMS, 0); + } + public KW_KEYS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_KEYS, 0); + } + public KW_LAST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LAST, 0); + } + public KW_LAZY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LAZY, 0); + } + public KW_LEADING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LEADING, 0); + } + public KW_LIFECYCLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIFECYCLE, 0); + } + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIKE, 0); + } + public KW_LONG(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LONG, 0); + } + public KW_ILIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ILIKE, 0); + } + public KW_LIMIT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIMIT, 0); + } + public KW_LINES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LINES, 0); + } + public KW_LIST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LIST, 0); + } + public KW_LOAD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOAD, 0); + } + public KW_LOCAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCAL, 0); + } + public KW_LOCATION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCATION, 0); + } + public KW_LOCK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCK, 0); + } + public KW_LOCKS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOCKS, 0); + } + public KW_LOGICAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_LOGICAL, 0); + } + public KW_MACRO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MACRO, 0); + } + public KW_MAP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MAP, 0); + } + public KW_MATCHED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MATCHED, 0); + } + public KW_MERGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MERGE, 0); + } + public KW_MICROSECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MICROSECOND, 0); + } + public KW_MICROSECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MICROSECONDS, 0); + } + public KW_MILLISECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MILLISECOND, 0); + } + public KW_MILLISECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MILLISECONDS, 0); + } + public KW_MINUTE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUTE, 0); + } + public KW_MINUTES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MINUTES, 0); + } + public KW_MONTH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MONTH, 0); + } + public KW_MONTHS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MONTHS, 0); + } + public KW_MSCK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_MSCK, 0); + } + public KW_NAME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NAME, 0); + } + public KW_NAMESPACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NAMESPACE, 0); + } + public KW_NAMESPACES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NAMESPACES, 0); + } + public KW_NANOSECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NANOSECOND, 0); + } + public KW_NANOSECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NANOSECONDS, 0); + } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NO, 0); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NOT, 0); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULL, 0); + } + public KW_NULLS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NULLS, 0); + } + public KW_NUMERIC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_NUMERIC, 0); + } + public KW_OF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OF, 0); + } + public KW_OFFSET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OFFSET, 0); + } + public KW_ONLY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ONLY, 0); + } + public KW_OPTIMIZE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTIMIZE, 0); + } + public KW_OPTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTION, 0); + } + public KW_OPTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OPTIONS, 0); + } + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OR, 0); + } + public KW_ORDER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ORDER, 0); + } + public KW_OUT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OUT, 0); + } + public KW_OUTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OUTER, 0); + } + public KW_OUTPUTFORMAT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OUTPUTFORMAT, 0); + } + public KW_OVER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVER, 0); + } + public KW_OVERLAPS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVERLAPS, 0); + } + public KW_OVERLAY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVERLAY, 0); + } + public KW_OVERWRITE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_OVERWRITE, 0); + } + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITION, 0); + } + public KW_PARTITIONED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITIONED, 0); + } + public KW_PARTITIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PARTITIONS, 0); + } + public KW_PERCENTILE_CONT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PERCENTILE_CONT, 0); + } + public KW_PERCENTILE_DISC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PERCENTILE_DISC, 0); + } + public KW_PERCENTLIT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PERCENTLIT, 0); + } + public KW_PIVOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PIVOT, 0); + } + public KW_PLACING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PLACING, 0); + } + public KW_POSITION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_POSITION, 0); + } + public KW_PRECEDING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PRECEDING, 0); + } + public KW_PRIMARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PRIMARY, 0); + } + public KW_PRINCIPALS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PRINCIPALS, 0); + } + public KW_PROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PROPERTIES, 0); + } + public KW_PURGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_PURGE, 0); + } + public KW_QUARTER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_QUARTER, 0); + } + public KW_QUERY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_QUERY, 0); + } + public KW_RANGE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RANGE, 0); + } + public KW_REAL(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REAL, 0); + } + public KW_RECORDREADER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RECORDREADER, 0); + } + public KW_RECORDWRITER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RECORDWRITER, 0); + } + public KW_RECOVER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RECOVER, 0); + } + public KW_REDUCE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REDUCE, 0); + } + public KW_REFERENCES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REFERENCES, 0); + } + public KW_REFRESH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REFRESH, 0); + } + public KW_RENAME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RENAME, 0); + } + public KW_REPAIR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPAIR, 0); + } + public KW_REPEATABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPEATABLE, 0); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REPLACE, 0); + } + public KW_RESET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RESET, 0); + } + public KW_RESPECT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RESPECT, 0); + } + public KW_RESTRICT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RESTRICT, 0); + } + public KW_REVOKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REVOKE, 0); + } + public KW_REWRITE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REWRITE, 0); + } + public KW_RLIKE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_RLIKE, 0); + } + public KW_REGEXP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_REGEXP, 0); + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLE, 0); + } + public KW_ROLES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLES, 0); + } + public KW_ROLLBACK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLLBACK, 0); + } + public KW_ROLLUP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROLLUP, 0); + } + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROW, 0); + } + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ROWS, 0); + } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SCHEMA, 0); + } + public KW_SCHEMAS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SCHEMAS, 0); + } + public KW_SECOND(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SECOND, 0); + } + public KW_SECONDS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SECONDS, 0); + } + public KW_SEPARATED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SEPARATED, 0); + } + public KW_SERDE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDE, 0); + } + public KW_SERDEPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SERDEPROPERTIES, 0); + } + public KW_SESSION_USER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SESSION_USER, 0); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SET, 0); + } + public KW_SETS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SETS, 0); + } + public KW_SHORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SHORT, 0); + } + public KW_SHOW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SHOW, 0); + } + public KW_SINGLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SINGLE, 0); + } + public KW_SKEWED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SKEWED, 0); + } + public KW_SMALLINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SMALLINT, 0); + } + public KW_SOME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SOME, 0); + } + public KW_SORT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SORT, 0); + } + public KW_SORTED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SORTED, 0); + } + public KW_SOURCE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SOURCE, 0); + } + public KW_START(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_START, 0); + } + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STATISTICS, 0); + } + public KW_STORED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STORED, 0); + } + public KW_STRATIFY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRATIFY, 0); + } + public KW_STRING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRING, 0); + } + public KW_STRUCT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_STRUCT, 0); + } + public KW_SUBSTR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SUBSTR, 0); + } + public KW_SUBSTRING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SUBSTRING, 0); + } + public KW_SYNC(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYNC, 0); + } + public KW_SYSTEM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYSTEM, 0); + } + public KW_SYSTEM_TIME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYSTEM_TIME, 0); + } + public KW_SYSTEM_VERSION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_SYSTEM_VERSION, 0); + } + public KW_TABLES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLES, 0); + } + public KW_TABLESAMPLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TABLESAMPLE, 0); + } + public KW_TARGET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TARGET, 0); + } + public KW_TBLPROPERTIES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TBLPROPERTIES, 0); + } + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TEMPORARY, 0); + } + public KW_TERMINATED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TERMINATED, 0); + } + public KW_THEN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_THEN, 0); + } + public KW_TIME(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIME, 0); + } + public KW_TIMEDIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMEDIFF, 0); + } + public KW_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP, 0); + } + public KW_TIMESTAMP_LTZ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP_LTZ, 0); + } + public KW_TIMESTAMP_NTZ(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMP_NTZ, 0); + } + public KW_TIMESTAMPADD(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMPADD, 0); + } + public KW_TIMESTAMPDIFF(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TIMESTAMPDIFF, 0); + } + public KW_TINYINT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TINYINT, 0); + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TO, 0); + } + public KW_TOUCH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TOUCH, 0); + } + public KW_TRAILING(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRAILING, 0); + } + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRANSACTION, 0); + } + public KW_TRANSACTIONS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRANSACTIONS, 0); + } + public KW_TRANSFORM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRANSFORM, 0); + } + public KW_TRIM(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRIM, 0); + } + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRUE, 0); + } + public KW_TRUNCATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRUNCATE, 0); + } + public KW_TRY_CAST(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TRY_CAST, 0); + } + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_TYPE, 0); + } + public KW_UNARCHIVE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNARCHIVE, 0); + } + public KW_UNBOUNDED(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNBOUNDED, 0); + } + public KW_UNCACHE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNCACHE, 0); + } + public KW_UNIQUE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNIQUE, 0); + } + public KW_UNKNOWN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNKNOWN, 0); + } + public KW_UNLOCK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNLOCK, 0); + } + public KW_UNPIVOT(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNPIVOT, 0); + } + public KW_UNSET(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UNSET, 0); + } + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_UPDATE, 0); + } + public KW_USE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_USE, 0); + } + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_USER, 0); + } + public KW_VALUES(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VALUES, 0); + } + public KW_VARCHAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VARCHAR, 0); + } + public KW_VAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VAR, 0); + } + public KW_VARIABLE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VARIABLE, 0); + } + public KW_VERSION(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VERSION, 0); + } + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VIEW, 0); + } + public KW_VIEWS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VIEWS, 0); + } + public KW_VOID(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_VOID, 0); + } + public KW_WEEK(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WEEK, 0); + } + public KW_WEEKS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WEEKS, 0); + } + public KW_WHEN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WHEN, 0); + } + public KW_WHERE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WHERE, 0); + } + public KW_WINDOW(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WINDOW, 0); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WITH, 0); + } + public KW_WITHIN(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_WITHIN, 0); + } + public KW_YEAR(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_YEAR, 0); + } + public KW_YEARS(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_YEARS, 0); + } + public KW_ZONE(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ZONE, 0); + } + public KW_ZORDER(): antlr.TerminalNode | null { + return this.getToken(SqlParser.KW_ZORDER, 0); + } + public override get ruleIndex(): number { + return SqlParser.RULE_nonReserved; + } + public override enterRule(listener: SqlParserListener): void { + if(listener.enterNonReserved) { + listener.enterNonReserved(this); + } + } + public override exitRule(listener: SqlParserListener): void { + if(listener.exitNonReserved) { + listener.exitNonReserved(this); + } + } + public override accept(visitor: SqlParserVisitor): Result | null { + if (visitor.visitNonReserved) { + return visitor.visitNonReserved(this); + } else { + return visitor.visitChildren(this); + } + } +} diff --git a/src/lib/sql/SqlParserListener.ts b/src/lib/sql/SqlParserListener.ts new file mode 100644 index 00000000..34501d53 --- /dev/null +++ b/src/lib/sql/SqlParserListener.ts @@ -0,0 +1,2671 @@ +// Generated from dt-sql-parser/src/grammar/sql/SqlParser.g4 by ANTLR 4.13.1 + +// @ts-nocheck + +import { ErrorNode, ParseTreeListener, ParserRuleContext, TerminalNode } from "antlr4ng"; + + +import { SQLParserBase } from '../SQLParserBase'; + + +import { ProgramContext } from "./SqlParser.js"; +import { SingleStatementContext } from "./SqlParser.js"; +import { StatementDefaultContext } from "./SqlParser.js"; +import { DmlStatementContext } from "./SqlParser.js"; +import { UseNamespaceContext } from "./SqlParser.js"; +import { AlterContext } from "./SqlParser.js"; +import { CreateContext } from "./SqlParser.js"; +import { DropContext } from "./SqlParser.js"; +import { ShowContext } from "./SqlParser.js"; +import { TruncateTableContext } from "./SqlParser.js"; +import { AnalyzeContext } from "./SqlParser.js"; +import { AnalyzeTablesContext } from "./SqlParser.js"; +import { DeclareVariableContext } from "./SqlParser.js"; +import { ExplainStatementContext } from "./SqlParser.js"; +import { DescribeFunctionContext } from "./SqlParser.js"; +import { DescribeNamespaceContext } from "./SqlParser.js"; +import { DescribeQueryContext } from "./SqlParser.js"; +import { DescribeRelationContext } from "./SqlParser.js"; +import { CommentNamespaceContext } from "./SqlParser.js"; +import { RefreshTableContext } from "./SqlParser.js"; +import { RefreshFunctionContext } from "./SqlParser.js"; +import { RefreshResourceContext } from "./SqlParser.js"; +import { CacheTableContext } from "./SqlParser.js"; +import { UnCacheTableContext } from "./SqlParser.js"; +import { ClearCacheContext } from "./SqlParser.js"; +import { LoadDataContext } from "./SqlParser.js"; +import { RepairTableContext } from "./SqlParser.js"; +import { ManageResourceContext } from "./SqlParser.js"; +import { SetAnyContext } from "./SqlParser.js"; +import { ResetAnyContext } from "./SqlParser.js"; +import { OptimizeTableContext } from "./SqlParser.js"; +import { UnsupportHiveCommandsContext } from "./SqlParser.js"; +import { AlterStatementContext } from "./SqlParser.js"; +import { CreateNamespaceContext } from "./SqlParser.js"; +import { CreateTableContext } from "./SqlParser.js"; +import { ReplaceTableContext } from "./SqlParser.js"; +import { CreateTableLikeContext } from "./SqlParser.js"; +import { CreateViewContext } from "./SqlParser.js"; +import { CreateTempViewUsingContext } from "./SqlParser.js"; +import { CreateFunctionContext } from "./SqlParser.js"; +import { CreateIndexContext } from "./SqlParser.js"; +import { CreateRoleContext } from "./SqlParser.js"; +import { DropNamespaceContext } from "./SqlParser.js"; +import { DropTableContext } from "./SqlParser.js"; +import { DropViewContext } from "./SqlParser.js"; +import { DropFunctionContext } from "./SqlParser.js"; +import { DropVariableContext } from "./SqlParser.js"; +import { DropIndexContext } from "./SqlParser.js"; +import { DropRoleContext } from "./SqlParser.js"; +import { InsertFromQueryContext } from "./SqlParser.js"; +import { MultipleInsertContext } from "./SqlParser.js"; +import { DeleteFromTableContext } from "./SqlParser.js"; +import { UpdateTableContext } from "./SqlParser.js"; +import { MergeIntoTableContext } from "./SqlParser.js"; +import { InsertIntoContext } from "./SqlParser.js"; +import { ShowNamespacesContext } from "./SqlParser.js"; +import { ShowTablesContext } from "./SqlParser.js"; +import { ShowTableExtendedContext } from "./SqlParser.js"; +import { ShowTblPropertiesContext } from "./SqlParser.js"; +import { ShowColumnsContext } from "./SqlParser.js"; +import { ShowViewsContext } from "./SqlParser.js"; +import { ShowPartitionsContext } from "./SqlParser.js"; +import { ShowFunctionsContext } from "./SqlParser.js"; +import { ShowCreateTableContext } from "./SqlParser.js"; +import { ShowCurrentNamespaceContext } from "./SqlParser.js"; +import { ShowCatalogsContext } from "./SqlParser.js"; +import { ShowOtherContext } from "./SqlParser.js"; +import { UnsupportedCommandsContext } from "./SqlParser.js"; +import { BucketSpecContext } from "./SqlParser.js"; +import { SkewSpecContext } from "./SqlParser.js"; +import { QueryStatementContext } from "./SqlParser.js"; +import { PartitionSpecLocationContext } from "./SqlParser.js"; +import { PartitionSpecContext } from "./SqlParser.js"; +import { PartitionValContext } from "./SqlParser.js"; +import { NamespaceContext } from "./SqlParser.js"; +import { DescribeFuncNameContext } from "./SqlParser.js"; +import { DescribeColNameContext } from "./SqlParser.js"; +import { CtesContext } from "./SqlParser.js"; +import { NamedQueryContext } from "./SqlParser.js"; +import { TableProviderContext } from "./SqlParser.js"; +import { CreateTableClausesContext } from "./SqlParser.js"; +import { TableLifecycleContext } from "./SqlParser.js"; +import { PropertyListContext } from "./SqlParser.js"; +import { PropertyContext } from "./SqlParser.js"; +import { PropertyKeyContext } from "./SqlParser.js"; +import { PropertyValueContext } from "./SqlParser.js"; +import { ExpressionPropertyListContext } from "./SqlParser.js"; +import { ExpressionPropertyContext } from "./SqlParser.js"; +import { ConstantListContext } from "./SqlParser.js"; +import { NestedConstantListContext } from "./SqlParser.js"; +import { CreateFileFormatContext } from "./SqlParser.js"; +import { FileFormatContext } from "./SqlParser.js"; +import { StorageHandlerContext } from "./SqlParser.js"; +import { NamespaceNameContext } from "./SqlParser.js"; +import { NamespaceNameCreateContext } from "./SqlParser.js"; +import { TableNameCreateContext } from "./SqlParser.js"; +import { TableNameContext } from "./SqlParser.js"; +import { ViewNameCreateContext } from "./SqlParser.js"; +import { ViewNameContext } from "./SqlParser.js"; +import { ColumnNameContext } from "./SqlParser.js"; +import { ColumnNameSeqContext } from "./SqlParser.js"; +import { ColumnNameCreateContext } from "./SqlParser.js"; +import { IdentifierReferenceContext } from "./SqlParser.js"; +import { QueryOrganizationContext } from "./SqlParser.js"; +import { QueryTermContext } from "./SqlParser.js"; +import { QueryPrimaryContext } from "./SqlParser.js"; +import { SortItemContext } from "./SqlParser.js"; +import { FromStatementBodyContext } from "./SqlParser.js"; +import { QuerySpecificationContext } from "./SqlParser.js"; +import { TransformClauseContext } from "./SqlParser.js"; +import { SelectClauseContext } from "./SqlParser.js"; +import { SetClauseContext } from "./SqlParser.js"; +import { MatchedClauseContext } from "./SqlParser.js"; +import { NotMatchedClauseContext } from "./SqlParser.js"; +import { NotMatchedBySourceClauseContext } from "./SqlParser.js"; +import { NotMatchedActionContext } from "./SqlParser.js"; +import { AssignmentListContext } from "./SqlParser.js"; +import { AssignmentContext } from "./SqlParser.js"; +import { WhereClauseContext } from "./SqlParser.js"; +import { HavingClauseContext } from "./SqlParser.js"; +import { HintContext } from "./SqlParser.js"; +import { HintStatementContext } from "./SqlParser.js"; +import { FromClauseContext } from "./SqlParser.js"; +import { TemporalClauseContext } from "./SqlParser.js"; +import { AggregationClauseContext } from "./SqlParser.js"; +import { GroupByClauseContext } from "./SqlParser.js"; +import { GroupingAnalyticsContext } from "./SqlParser.js"; +import { GroupingSetContext } from "./SqlParser.js"; +import { PivotClauseContext } from "./SqlParser.js"; +import { PivotColumnContext } from "./SqlParser.js"; +import { PivotValueContext } from "./SqlParser.js"; +import { UnpivotClauseContext } from "./SqlParser.js"; +import { UnpivotSingleValueColumnClauseContext } from "./SqlParser.js"; +import { UnpivotMultiValueColumnClauseContext } from "./SqlParser.js"; +import { UnpivotColumnSetContext } from "./SqlParser.js"; +import { UnpivotColumnAndAliasContext } from "./SqlParser.js"; +import { IfNotExistsContext } from "./SqlParser.js"; +import { IfExistsContext } from "./SqlParser.js"; +import { LateralViewContext } from "./SqlParser.js"; +import { SetQuantifierContext } from "./SqlParser.js"; +import { RelationContext } from "./SqlParser.js"; +import { JoinRelationContext } from "./SqlParser.js"; +import { JoinTypeContext } from "./SqlParser.js"; +import { JoinCriteriaContext } from "./SqlParser.js"; +import { SampleContext } from "./SqlParser.js"; +import { SampleMethodContext } from "./SqlParser.js"; +import { IdentifierListContext } from "./SqlParser.js"; +import { IdentifierSeqContext } from "./SqlParser.js"; +import { OrderedIdentifierListContext } from "./SqlParser.js"; +import { OrderedIdentifierContext } from "./SqlParser.js"; +import { IdentifierCommentListContext } from "./SqlParser.js"; +import { IdentifierCommentContext } from "./SqlParser.js"; +import { RelationPrimaryContext } from "./SqlParser.js"; +import { FunctionTableSubqueryArgumentContext } from "./SqlParser.js"; +import { TableArgumentPartitioningContext } from "./SqlParser.js"; +import { FunctionTableNamedArgumentExpressionContext } from "./SqlParser.js"; +import { FunctionTableReferenceArgumentContext } from "./SqlParser.js"; +import { FunctionTableArgumentContext } from "./SqlParser.js"; +import { TableAliasContext } from "./SqlParser.js"; +import { RowFormatContext } from "./SqlParser.js"; +import { MultipartIdentifierListContext } from "./SqlParser.js"; +import { MultipartIdentifierContext } from "./SqlParser.js"; +import { MultipartIdentifierPropertyListContext } from "./SqlParser.js"; +import { MultipartIdentifierPropertyContext } from "./SqlParser.js"; +import { TableIdentifierContext } from "./SqlParser.js"; +import { ViewIdentifierContext } from "./SqlParser.js"; +import { NamedExpressionContext } from "./SqlParser.js"; +import { NamedExpressionSeqContext } from "./SqlParser.js"; +import { PartitionFieldListContext } from "./SqlParser.js"; +import { PartitionFieldContext } from "./SqlParser.js"; +import { TransformContext } from "./SqlParser.js"; +import { TransformArgumentContext } from "./SqlParser.js"; +import { ExpressionContext } from "./SqlParser.js"; +import { NamedArgumentExpressionContext } from "./SqlParser.js"; +import { FunctionArgumentContext } from "./SqlParser.js"; +import { ExpressionSeqContext } from "./SqlParser.js"; +import { BooleanExpressionContext } from "./SqlParser.js"; +import { PredicateContext } from "./SqlParser.js"; +import { ValueExpressionContext } from "./SqlParser.js"; +import { DatetimeUnitContext } from "./SqlParser.js"; +import { PrimaryExpressionContext } from "./SqlParser.js"; +import { LiteralTypeContext } from "./SqlParser.js"; +import { ConstantContext } from "./SqlParser.js"; +import { ComparisonOperatorContext } from "./SqlParser.js"; +import { ArithmeticOperatorContext } from "./SqlParser.js"; +import { PredicateOperatorContext } from "./SqlParser.js"; +import { BooleanValueContext } from "./SqlParser.js"; +import { IntervalContext } from "./SqlParser.js"; +import { ErrorCapturingMultiUnitsIntervalContext } from "./SqlParser.js"; +import { ErrorCapturingUnitToUnitIntervalContext } from "./SqlParser.js"; +import { MultiUnitsIntervalContext } from "./SqlParser.js"; +import { UnitToUnitIntervalContext } from "./SqlParser.js"; +import { IntervalValueContext } from "./SqlParser.js"; +import { UnitInMultiUnitsContext } from "./SqlParser.js"; +import { UnitInUnitToUnitContext } from "./SqlParser.js"; +import { ColPositionContext } from "./SqlParser.js"; +import { TypeContext } from "./SqlParser.js"; +import { DataTypeContext } from "./SqlParser.js"; +import { QualifiedColTypeWithPositionSeqForAddContext } from "./SqlParser.js"; +import { QualifiedColTypeWithPositionForAddContext } from "./SqlParser.js"; +import { QualifiedColTypeWithPositionSeqForReplaceContext } from "./SqlParser.js"; +import { QualifiedColTypeWithPositionForReplaceContext } from "./SqlParser.js"; +import { ColDefinitionDescriptorWithPositionContext } from "./SqlParser.js"; +import { VariableDefaultExpressionContext } from "./SqlParser.js"; +import { ColTypeListContext } from "./SqlParser.js"; +import { ColumnTypeContext } from "./SqlParser.js"; +import { CreateOrReplaceTableColTypeListContext } from "./SqlParser.js"; +import { CreateOrReplaceTableColTypeContext } from "./SqlParser.js"; +import { ColDefinitionOptionContext } from "./SqlParser.js"; +import { ComplexColTypeContext } from "./SqlParser.js"; +import { WhenClauseContext } from "./SqlParser.js"; +import { WindowClauseContext } from "./SqlParser.js"; +import { WindowSpecContext } from "./SqlParser.js"; +import { WindowFrameContext } from "./SqlParser.js"; +import { FrameBoundContext } from "./SqlParser.js"; +import { QualifiedNameListContext } from "./SqlParser.js"; +import { FunctionNameContext } from "./SqlParser.js"; +import { FunctionNameCreateContext } from "./SqlParser.js"; +import { QualifiedNameContext } from "./SqlParser.js"; +import { ErrorCapturingIdentifierContext } from "./SqlParser.js"; +import { ErrorCapturingIdentifierExtraContext } from "./SqlParser.js"; +import { IdentifierContext } from "./SqlParser.js"; +import { StrictIdentifierContext } from "./SqlParser.js"; +import { NumberContext } from "./SqlParser.js"; +import { AlterColumnActionContext } from "./SqlParser.js"; +import { StringLitContext } from "./SqlParser.js"; +import { AnsiNonReservedContext } from "./SqlParser.js"; +import { StrictNonReservedContext } from "./SqlParser.js"; +import { NonReservedContext } from "./SqlParser.js"; + + +/** + * This interface defines a complete listener for a parse tree produced by + * `SqlParser`. + */ +export class SqlParserListener implements ParseTreeListener { + /** + * Enter a parse tree produced by `SqlParser.program`. + * @param ctx the parse tree + */ + enterProgram?: (ctx: ProgramContext) => void; + /** + * Exit a parse tree produced by `SqlParser.program`. + * @param ctx the parse tree + */ + exitProgram?: (ctx: ProgramContext) => void; + /** + * Enter a parse tree produced by `SqlParser.singleStatement`. + * @param ctx the parse tree + */ + enterSingleStatement?: (ctx: SingleStatementContext) => void; + /** + * Exit a parse tree produced by `SqlParser.singleStatement`. + * @param ctx the parse tree + */ + exitSingleStatement?: (ctx: SingleStatementContext) => void; + /** + * Enter a parse tree produced by the `statementDefault` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterStatementDefault?: (ctx: StatementDefaultContext) => void; + /** + * Exit a parse tree produced by the `statementDefault` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitStatementDefault?: (ctx: StatementDefaultContext) => void; + /** + * Enter a parse tree produced by the `dmlStatement` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterDmlStatement?: (ctx: DmlStatementContext) => void; + /** + * Exit a parse tree produced by the `dmlStatement` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitDmlStatement?: (ctx: DmlStatementContext) => void; + /** + * Enter a parse tree produced by the `useNamespace` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterUseNamespace?: (ctx: UseNamespaceContext) => void; + /** + * Exit a parse tree produced by the `useNamespace` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitUseNamespace?: (ctx: UseNamespaceContext) => void; + /** + * Enter a parse tree produced by the `alter` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterAlter?: (ctx: AlterContext) => void; + /** + * Exit a parse tree produced by the `alter` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitAlter?: (ctx: AlterContext) => void; + /** + * Enter a parse tree produced by the `create` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterCreate?: (ctx: CreateContext) => void; + /** + * Exit a parse tree produced by the `create` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitCreate?: (ctx: CreateContext) => void; + /** + * Enter a parse tree produced by the `drop` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterDrop?: (ctx: DropContext) => void; + /** + * Exit a parse tree produced by the `drop` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitDrop?: (ctx: DropContext) => void; + /** + * Enter a parse tree produced by the `show` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterShow?: (ctx: ShowContext) => void; + /** + * Exit a parse tree produced by the `show` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitShow?: (ctx: ShowContext) => void; + /** + * Enter a parse tree produced by the `truncateTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterTruncateTable?: (ctx: TruncateTableContext) => void; + /** + * Exit a parse tree produced by the `truncateTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitTruncateTable?: (ctx: TruncateTableContext) => void; + /** + * Enter a parse tree produced by the `analyze` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterAnalyze?: (ctx: AnalyzeContext) => void; + /** + * Exit a parse tree produced by the `analyze` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitAnalyze?: (ctx: AnalyzeContext) => void; + /** + * Enter a parse tree produced by the `analyzeTables` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterAnalyzeTables?: (ctx: AnalyzeTablesContext) => void; + /** + * Exit a parse tree produced by the `analyzeTables` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitAnalyzeTables?: (ctx: AnalyzeTablesContext) => void; + /** + * Enter a parse tree produced by the `declareVariable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterDeclareVariable?: (ctx: DeclareVariableContext) => void; + /** + * Exit a parse tree produced by the `declareVariable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitDeclareVariable?: (ctx: DeclareVariableContext) => void; + /** + * Enter a parse tree produced by the `explainStatement` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterExplainStatement?: (ctx: ExplainStatementContext) => void; + /** + * Exit a parse tree produced by the `explainStatement` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitExplainStatement?: (ctx: ExplainStatementContext) => void; + /** + * Enter a parse tree produced by the `describeFunction` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterDescribeFunction?: (ctx: DescribeFunctionContext) => void; + /** + * Exit a parse tree produced by the `describeFunction` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitDescribeFunction?: (ctx: DescribeFunctionContext) => void; + /** + * Enter a parse tree produced by the `describeNamespace` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterDescribeNamespace?: (ctx: DescribeNamespaceContext) => void; + /** + * Exit a parse tree produced by the `describeNamespace` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitDescribeNamespace?: (ctx: DescribeNamespaceContext) => void; + /** + * Enter a parse tree produced by the `describeQuery` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterDescribeQuery?: (ctx: DescribeQueryContext) => void; + /** + * Exit a parse tree produced by the `describeQuery` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitDescribeQuery?: (ctx: DescribeQueryContext) => void; + /** + * Enter a parse tree produced by the `describeRelation` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterDescribeRelation?: (ctx: DescribeRelationContext) => void; + /** + * Exit a parse tree produced by the `describeRelation` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitDescribeRelation?: (ctx: DescribeRelationContext) => void; + /** + * Enter a parse tree produced by the `commentNamespace` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterCommentNamespace?: (ctx: CommentNamespaceContext) => void; + /** + * Exit a parse tree produced by the `commentNamespace` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitCommentNamespace?: (ctx: CommentNamespaceContext) => void; + /** + * Enter a parse tree produced by the `refreshTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterRefreshTable?: (ctx: RefreshTableContext) => void; + /** + * Exit a parse tree produced by the `refreshTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitRefreshTable?: (ctx: RefreshTableContext) => void; + /** + * Enter a parse tree produced by the `refreshFunction` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterRefreshFunction?: (ctx: RefreshFunctionContext) => void; + /** + * Exit a parse tree produced by the `refreshFunction` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitRefreshFunction?: (ctx: RefreshFunctionContext) => void; + /** + * Enter a parse tree produced by the `refreshResource` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterRefreshResource?: (ctx: RefreshResourceContext) => void; + /** + * Exit a parse tree produced by the `refreshResource` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitRefreshResource?: (ctx: RefreshResourceContext) => void; + /** + * Enter a parse tree produced by the `cacheTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterCacheTable?: (ctx: CacheTableContext) => void; + /** + * Exit a parse tree produced by the `cacheTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitCacheTable?: (ctx: CacheTableContext) => void; + /** + * Enter a parse tree produced by the `unCacheTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterUnCacheTable?: (ctx: UnCacheTableContext) => void; + /** + * Exit a parse tree produced by the `unCacheTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitUnCacheTable?: (ctx: UnCacheTableContext) => void; + /** + * Enter a parse tree produced by the `clearCache` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterClearCache?: (ctx: ClearCacheContext) => void; + /** + * Exit a parse tree produced by the `clearCache` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitClearCache?: (ctx: ClearCacheContext) => void; + /** + * Enter a parse tree produced by the `loadData` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterLoadData?: (ctx: LoadDataContext) => void; + /** + * Exit a parse tree produced by the `loadData` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitLoadData?: (ctx: LoadDataContext) => void; + /** + * Enter a parse tree produced by the `repairTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterRepairTable?: (ctx: RepairTableContext) => void; + /** + * Exit a parse tree produced by the `repairTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitRepairTable?: (ctx: RepairTableContext) => void; + /** + * Enter a parse tree produced by the `manageResource` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterManageResource?: (ctx: ManageResourceContext) => void; + /** + * Exit a parse tree produced by the `manageResource` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitManageResource?: (ctx: ManageResourceContext) => void; + /** + * Enter a parse tree produced by the `setAny` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterSetAny?: (ctx: SetAnyContext) => void; + /** + * Exit a parse tree produced by the `setAny` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitSetAny?: (ctx: SetAnyContext) => void; + /** + * Enter a parse tree produced by the `resetAny` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterResetAny?: (ctx: ResetAnyContext) => void; + /** + * Exit a parse tree produced by the `resetAny` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitResetAny?: (ctx: ResetAnyContext) => void; + /** + * Enter a parse tree produced by the `optimizeTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterOptimizeTable?: (ctx: OptimizeTableContext) => void; + /** + * Exit a parse tree produced by the `optimizeTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitOptimizeTable?: (ctx: OptimizeTableContext) => void; + /** + * Enter a parse tree produced by the `unsupportHiveCommands` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + enterUnsupportHiveCommands?: (ctx: UnsupportHiveCommandsContext) => void; + /** + * Exit a parse tree produced by the `unsupportHiveCommands` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + */ + exitUnsupportHiveCommands?: (ctx: UnsupportHiveCommandsContext) => void; + /** + * Enter a parse tree produced by `SqlParser.alterStatement`. + * @param ctx the parse tree + */ + enterAlterStatement?: (ctx: AlterStatementContext) => void; + /** + * Exit a parse tree produced by `SqlParser.alterStatement`. + * @param ctx the parse tree + */ + exitAlterStatement?: (ctx: AlterStatementContext) => void; + /** + * Enter a parse tree produced by the `createNamespace` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + enterCreateNamespace?: (ctx: CreateNamespaceContext) => void; + /** + * Exit a parse tree produced by the `createNamespace` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + exitCreateNamespace?: (ctx: CreateNamespaceContext) => void; + /** + * Enter a parse tree produced by the `createTable` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + enterCreateTable?: (ctx: CreateTableContext) => void; + /** + * Exit a parse tree produced by the `createTable` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + exitCreateTable?: (ctx: CreateTableContext) => void; + /** + * Enter a parse tree produced by the `replaceTable` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + enterReplaceTable?: (ctx: ReplaceTableContext) => void; + /** + * Exit a parse tree produced by the `replaceTable` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + exitReplaceTable?: (ctx: ReplaceTableContext) => void; + /** + * Enter a parse tree produced by the `createTableLike` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + enterCreateTableLike?: (ctx: CreateTableLikeContext) => void; + /** + * Exit a parse tree produced by the `createTableLike` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + exitCreateTableLike?: (ctx: CreateTableLikeContext) => void; + /** + * Enter a parse tree produced by the `createView` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + enterCreateView?: (ctx: CreateViewContext) => void; + /** + * Exit a parse tree produced by the `createView` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + exitCreateView?: (ctx: CreateViewContext) => void; + /** + * Enter a parse tree produced by the `createTempViewUsing` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + enterCreateTempViewUsing?: (ctx: CreateTempViewUsingContext) => void; + /** + * Exit a parse tree produced by the `createTempViewUsing` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + exitCreateTempViewUsing?: (ctx: CreateTempViewUsingContext) => void; + /** + * Enter a parse tree produced by the `createFunction` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + enterCreateFunction?: (ctx: CreateFunctionContext) => void; + /** + * Exit a parse tree produced by the `createFunction` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + exitCreateFunction?: (ctx: CreateFunctionContext) => void; + /** + * Enter a parse tree produced by the `createIndex` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + enterCreateIndex?: (ctx: CreateIndexContext) => void; + /** + * Exit a parse tree produced by the `createIndex` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + exitCreateIndex?: (ctx: CreateIndexContext) => void; + /** + * Enter a parse tree produced by the `createRole` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + enterCreateRole?: (ctx: CreateRoleContext) => void; + /** + * Exit a parse tree produced by the `createRole` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + */ + exitCreateRole?: (ctx: CreateRoleContext) => void; + /** + * Enter a parse tree produced by the `dropNamespace` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + enterDropNamespace?: (ctx: DropNamespaceContext) => void; + /** + * Exit a parse tree produced by the `dropNamespace` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + exitDropNamespace?: (ctx: DropNamespaceContext) => void; + /** + * Enter a parse tree produced by the `dropTable` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + enterDropTable?: (ctx: DropTableContext) => void; + /** + * Exit a parse tree produced by the `dropTable` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + exitDropTable?: (ctx: DropTableContext) => void; + /** + * Enter a parse tree produced by the `dropView` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + enterDropView?: (ctx: DropViewContext) => void; + /** + * Exit a parse tree produced by the `dropView` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + exitDropView?: (ctx: DropViewContext) => void; + /** + * Enter a parse tree produced by the `dropFunction` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + enterDropFunction?: (ctx: DropFunctionContext) => void; + /** + * Exit a parse tree produced by the `dropFunction` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + exitDropFunction?: (ctx: DropFunctionContext) => void; + /** + * Enter a parse tree produced by the `dropVariable` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + enterDropVariable?: (ctx: DropVariableContext) => void; + /** + * Exit a parse tree produced by the `dropVariable` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + exitDropVariable?: (ctx: DropVariableContext) => void; + /** + * Enter a parse tree produced by the `dropIndex` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + enterDropIndex?: (ctx: DropIndexContext) => void; + /** + * Exit a parse tree produced by the `dropIndex` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + exitDropIndex?: (ctx: DropIndexContext) => void; + /** + * Enter a parse tree produced by the `dropRole` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + enterDropRole?: (ctx: DropRoleContext) => void; + /** + * Exit a parse tree produced by the `dropRole` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + */ + exitDropRole?: (ctx: DropRoleContext) => void; + /** + * Enter a parse tree produced by the `insertFromQuery` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + enterInsertFromQuery?: (ctx: InsertFromQueryContext) => void; + /** + * Exit a parse tree produced by the `insertFromQuery` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + exitInsertFromQuery?: (ctx: InsertFromQueryContext) => void; + /** + * Enter a parse tree produced by the `multipleInsert` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + enterMultipleInsert?: (ctx: MultipleInsertContext) => void; + /** + * Exit a parse tree produced by the `multipleInsert` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + exitMultipleInsert?: (ctx: MultipleInsertContext) => void; + /** + * Enter a parse tree produced by the `deleteFromTable` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + enterDeleteFromTable?: (ctx: DeleteFromTableContext) => void; + /** + * Exit a parse tree produced by the `deleteFromTable` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + exitDeleteFromTable?: (ctx: DeleteFromTableContext) => void; + /** + * Enter a parse tree produced by the `updateTable` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + enterUpdateTable?: (ctx: UpdateTableContext) => void; + /** + * Exit a parse tree produced by the `updateTable` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + exitUpdateTable?: (ctx: UpdateTableContext) => void; + /** + * Enter a parse tree produced by the `mergeIntoTable` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + enterMergeIntoTable?: (ctx: MergeIntoTableContext) => void; + /** + * Exit a parse tree produced by the `mergeIntoTable` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + */ + exitMergeIntoTable?: (ctx: MergeIntoTableContext) => void; + /** + * Enter a parse tree produced by `SqlParser.insertInto`. + * @param ctx the parse tree + */ + enterInsertInto?: (ctx: InsertIntoContext) => void; + /** + * Exit a parse tree produced by `SqlParser.insertInto`. + * @param ctx the parse tree + */ + exitInsertInto?: (ctx: InsertIntoContext) => void; + /** + * Enter a parse tree produced by the `showNamespaces` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowNamespaces?: (ctx: ShowNamespacesContext) => void; + /** + * Exit a parse tree produced by the `showNamespaces` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowNamespaces?: (ctx: ShowNamespacesContext) => void; + /** + * Enter a parse tree produced by the `showTables` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowTables?: (ctx: ShowTablesContext) => void; + /** + * Exit a parse tree produced by the `showTables` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowTables?: (ctx: ShowTablesContext) => void; + /** + * Enter a parse tree produced by the `showTableExtended` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowTableExtended?: (ctx: ShowTableExtendedContext) => void; + /** + * Exit a parse tree produced by the `showTableExtended` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowTableExtended?: (ctx: ShowTableExtendedContext) => void; + /** + * Enter a parse tree produced by the `showTblProperties` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowTblProperties?: (ctx: ShowTblPropertiesContext) => void; + /** + * Exit a parse tree produced by the `showTblProperties` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowTblProperties?: (ctx: ShowTblPropertiesContext) => void; + /** + * Enter a parse tree produced by the `showColumns` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowColumns?: (ctx: ShowColumnsContext) => void; + /** + * Exit a parse tree produced by the `showColumns` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowColumns?: (ctx: ShowColumnsContext) => void; + /** + * Enter a parse tree produced by the `showViews` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowViews?: (ctx: ShowViewsContext) => void; + /** + * Exit a parse tree produced by the `showViews` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowViews?: (ctx: ShowViewsContext) => void; + /** + * Enter a parse tree produced by the `showPartitions` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowPartitions?: (ctx: ShowPartitionsContext) => void; + /** + * Exit a parse tree produced by the `showPartitions` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowPartitions?: (ctx: ShowPartitionsContext) => void; + /** + * Enter a parse tree produced by the `showFunctions` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowFunctions?: (ctx: ShowFunctionsContext) => void; + /** + * Exit a parse tree produced by the `showFunctions` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowFunctions?: (ctx: ShowFunctionsContext) => void; + /** + * Enter a parse tree produced by the `showCreateTable` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowCreateTable?: (ctx: ShowCreateTableContext) => void; + /** + * Exit a parse tree produced by the `showCreateTable` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowCreateTable?: (ctx: ShowCreateTableContext) => void; + /** + * Enter a parse tree produced by the `showCurrentNamespace` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowCurrentNamespace?: (ctx: ShowCurrentNamespaceContext) => void; + /** + * Exit a parse tree produced by the `showCurrentNamespace` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowCurrentNamespace?: (ctx: ShowCurrentNamespaceContext) => void; + /** + * Enter a parse tree produced by the `showCatalogs` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowCatalogs?: (ctx: ShowCatalogsContext) => void; + /** + * Exit a parse tree produced by the `showCatalogs` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowCatalogs?: (ctx: ShowCatalogsContext) => void; + /** + * Enter a parse tree produced by the `showOther` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowOther?: (ctx: ShowOtherContext) => void; + /** + * Exit a parse tree produced by the `showOther` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowOther?: (ctx: ShowOtherContext) => void; + /** + * Enter a parse tree produced by `SqlParser.unsupportedCommands`. + * @param ctx the parse tree + */ + enterUnsupportedCommands?: (ctx: UnsupportedCommandsContext) => void; + /** + * Exit a parse tree produced by `SqlParser.unsupportedCommands`. + * @param ctx the parse tree + */ + exitUnsupportedCommands?: (ctx: UnsupportedCommandsContext) => void; + /** + * Enter a parse tree produced by `SqlParser.bucketSpec`. + * @param ctx the parse tree + */ + enterBucketSpec?: (ctx: BucketSpecContext) => void; + /** + * Exit a parse tree produced by `SqlParser.bucketSpec`. + * @param ctx the parse tree + */ + exitBucketSpec?: (ctx: BucketSpecContext) => void; + /** + * Enter a parse tree produced by `SqlParser.skewSpec`. + * @param ctx the parse tree + */ + enterSkewSpec?: (ctx: SkewSpecContext) => void; + /** + * Exit a parse tree produced by `SqlParser.skewSpec`. + * @param ctx the parse tree + */ + exitSkewSpec?: (ctx: SkewSpecContext) => void; + /** + * Enter a parse tree produced by the `queryStatement` + * labeled alternative in `SqlParser.query`. + * @param ctx the parse tree + */ + enterQueryStatement?: (ctx: QueryStatementContext) => void; + /** + * Exit a parse tree produced by the `queryStatement` + * labeled alternative in `SqlParser.query`. + * @param ctx the parse tree + */ + exitQueryStatement?: (ctx: QueryStatementContext) => void; + /** + * Enter a parse tree produced by `SqlParser.partitionSpecLocation`. + * @param ctx the parse tree + */ + enterPartitionSpecLocation?: (ctx: PartitionSpecLocationContext) => void; + /** + * Exit a parse tree produced by `SqlParser.partitionSpecLocation`. + * @param ctx the parse tree + */ + exitPartitionSpecLocation?: (ctx: PartitionSpecLocationContext) => void; + /** + * Enter a parse tree produced by `SqlParser.partitionSpec`. + * @param ctx the parse tree + */ + enterPartitionSpec?: (ctx: PartitionSpecContext) => void; + /** + * Exit a parse tree produced by `SqlParser.partitionSpec`. + * @param ctx the parse tree + */ + exitPartitionSpec?: (ctx: PartitionSpecContext) => void; + /** + * Enter a parse tree produced by `SqlParser.partitionVal`. + * @param ctx the parse tree + */ + enterPartitionVal?: (ctx: PartitionValContext) => void; + /** + * Exit a parse tree produced by `SqlParser.partitionVal`. + * @param ctx the parse tree + */ + exitPartitionVal?: (ctx: PartitionValContext) => void; + /** + * Enter a parse tree produced by `SqlParser.namespace`. + * @param ctx the parse tree + */ + enterNamespace?: (ctx: NamespaceContext) => void; + /** + * Exit a parse tree produced by `SqlParser.namespace`. + * @param ctx the parse tree + */ + exitNamespace?: (ctx: NamespaceContext) => void; + /** + * Enter a parse tree produced by `SqlParser.describeFuncName`. + * @param ctx the parse tree + */ + enterDescribeFuncName?: (ctx: DescribeFuncNameContext) => void; + /** + * Exit a parse tree produced by `SqlParser.describeFuncName`. + * @param ctx the parse tree + */ + exitDescribeFuncName?: (ctx: DescribeFuncNameContext) => void; + /** + * Enter a parse tree produced by `SqlParser.describeColName`. + * @param ctx the parse tree + */ + enterDescribeColName?: (ctx: DescribeColNameContext) => void; + /** + * Exit a parse tree produced by `SqlParser.describeColName`. + * @param ctx the parse tree + */ + exitDescribeColName?: (ctx: DescribeColNameContext) => void; + /** + * Enter a parse tree produced by `SqlParser.ctes`. + * @param ctx the parse tree + */ + enterCtes?: (ctx: CtesContext) => void; + /** + * Exit a parse tree produced by `SqlParser.ctes`. + * @param ctx the parse tree + */ + exitCtes?: (ctx: CtesContext) => void; + /** + * Enter a parse tree produced by `SqlParser.namedQuery`. + * @param ctx the parse tree + */ + enterNamedQuery?: (ctx: NamedQueryContext) => void; + /** + * Exit a parse tree produced by `SqlParser.namedQuery`. + * @param ctx the parse tree + */ + exitNamedQuery?: (ctx: NamedQueryContext) => void; + /** + * Enter a parse tree produced by `SqlParser.tableProvider`. + * @param ctx the parse tree + */ + enterTableProvider?: (ctx: TableProviderContext) => void; + /** + * Exit a parse tree produced by `SqlParser.tableProvider`. + * @param ctx the parse tree + */ + exitTableProvider?: (ctx: TableProviderContext) => void; + /** + * Enter a parse tree produced by `SqlParser.createTableClauses`. + * @param ctx the parse tree + */ + enterCreateTableClauses?: (ctx: CreateTableClausesContext) => void; + /** + * Exit a parse tree produced by `SqlParser.createTableClauses`. + * @param ctx the parse tree + */ + exitCreateTableClauses?: (ctx: CreateTableClausesContext) => void; + /** + * Enter a parse tree produced by `SqlParser.tableLifecycle`. + * @param ctx the parse tree + */ + enterTableLifecycle?: (ctx: TableLifecycleContext) => void; + /** + * Exit a parse tree produced by `SqlParser.tableLifecycle`. + * @param ctx the parse tree + */ + exitTableLifecycle?: (ctx: TableLifecycleContext) => void; + /** + * Enter a parse tree produced by `SqlParser.propertyList`. + * @param ctx the parse tree + */ + enterPropertyList?: (ctx: PropertyListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.propertyList`. + * @param ctx the parse tree + */ + exitPropertyList?: (ctx: PropertyListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.property`. + * @param ctx the parse tree + */ + enterProperty?: (ctx: PropertyContext) => void; + /** + * Exit a parse tree produced by `SqlParser.property`. + * @param ctx the parse tree + */ + exitProperty?: (ctx: PropertyContext) => void; + /** + * Enter a parse tree produced by `SqlParser.propertyKey`. + * @param ctx the parse tree + */ + enterPropertyKey?: (ctx: PropertyKeyContext) => void; + /** + * Exit a parse tree produced by `SqlParser.propertyKey`. + * @param ctx the parse tree + */ + exitPropertyKey?: (ctx: PropertyKeyContext) => void; + /** + * Enter a parse tree produced by `SqlParser.propertyValue`. + * @param ctx the parse tree + */ + enterPropertyValue?: (ctx: PropertyValueContext) => void; + /** + * Exit a parse tree produced by `SqlParser.propertyValue`. + * @param ctx the parse tree + */ + exitPropertyValue?: (ctx: PropertyValueContext) => void; + /** + * Enter a parse tree produced by `SqlParser.expressionPropertyList`. + * @param ctx the parse tree + */ + enterExpressionPropertyList?: (ctx: ExpressionPropertyListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.expressionPropertyList`. + * @param ctx the parse tree + */ + exitExpressionPropertyList?: (ctx: ExpressionPropertyListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.expressionProperty`. + * @param ctx the parse tree + */ + enterExpressionProperty?: (ctx: ExpressionPropertyContext) => void; + /** + * Exit a parse tree produced by `SqlParser.expressionProperty`. + * @param ctx the parse tree + */ + exitExpressionProperty?: (ctx: ExpressionPropertyContext) => void; + /** + * Enter a parse tree produced by `SqlParser.constantList`. + * @param ctx the parse tree + */ + enterConstantList?: (ctx: ConstantListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.constantList`. + * @param ctx the parse tree + */ + exitConstantList?: (ctx: ConstantListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.nestedConstantList`. + * @param ctx the parse tree + */ + enterNestedConstantList?: (ctx: NestedConstantListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.nestedConstantList`. + * @param ctx the parse tree + */ + exitNestedConstantList?: (ctx: NestedConstantListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.createFileFormat`. + * @param ctx the parse tree + */ + enterCreateFileFormat?: (ctx: CreateFileFormatContext) => void; + /** + * Exit a parse tree produced by `SqlParser.createFileFormat`. + * @param ctx the parse tree + */ + exitCreateFileFormat?: (ctx: CreateFileFormatContext) => void; + /** + * Enter a parse tree produced by `SqlParser.fileFormat`. + * @param ctx the parse tree + */ + enterFileFormat?: (ctx: FileFormatContext) => void; + /** + * Exit a parse tree produced by `SqlParser.fileFormat`. + * @param ctx the parse tree + */ + exitFileFormat?: (ctx: FileFormatContext) => void; + /** + * Enter a parse tree produced by `SqlParser.storageHandler`. + * @param ctx the parse tree + */ + enterStorageHandler?: (ctx: StorageHandlerContext) => void; + /** + * Exit a parse tree produced by `SqlParser.storageHandler`. + * @param ctx the parse tree + */ + exitStorageHandler?: (ctx: StorageHandlerContext) => void; + /** + * Enter a parse tree produced by `SqlParser.namespaceName`. + * @param ctx the parse tree + */ + enterNamespaceName?: (ctx: NamespaceNameContext) => void; + /** + * Exit a parse tree produced by `SqlParser.namespaceName`. + * @param ctx the parse tree + */ + exitNamespaceName?: (ctx: NamespaceNameContext) => void; + /** + * Enter a parse tree produced by `SqlParser.namespaceNameCreate`. + * @param ctx the parse tree + */ + enterNamespaceNameCreate?: (ctx: NamespaceNameCreateContext) => void; + /** + * Exit a parse tree produced by `SqlParser.namespaceNameCreate`. + * @param ctx the parse tree + */ + exitNamespaceNameCreate?: (ctx: NamespaceNameCreateContext) => void; + /** + * Enter a parse tree produced by `SqlParser.tableNameCreate`. + * @param ctx the parse tree + */ + enterTableNameCreate?: (ctx: TableNameCreateContext) => void; + /** + * Exit a parse tree produced by `SqlParser.tableNameCreate`. + * @param ctx the parse tree + */ + exitTableNameCreate?: (ctx: TableNameCreateContext) => void; + /** + * Enter a parse tree produced by `SqlParser.tableName`. + * @param ctx the parse tree + */ + enterTableName?: (ctx: TableNameContext) => void; + /** + * Exit a parse tree produced by `SqlParser.tableName`. + * @param ctx the parse tree + */ + exitTableName?: (ctx: TableNameContext) => void; + /** + * Enter a parse tree produced by `SqlParser.viewNameCreate`. + * @param ctx the parse tree + */ + enterViewNameCreate?: (ctx: ViewNameCreateContext) => void; + /** + * Exit a parse tree produced by `SqlParser.viewNameCreate`. + * @param ctx the parse tree + */ + exitViewNameCreate?: (ctx: ViewNameCreateContext) => void; + /** + * Enter a parse tree produced by `SqlParser.viewName`. + * @param ctx the parse tree + */ + enterViewName?: (ctx: ViewNameContext) => void; + /** + * Exit a parse tree produced by `SqlParser.viewName`. + * @param ctx the parse tree + */ + exitViewName?: (ctx: ViewNameContext) => void; + /** + * Enter a parse tree produced by `SqlParser.columnName`. + * @param ctx the parse tree + */ + enterColumnName?: (ctx: ColumnNameContext) => void; + /** + * Exit a parse tree produced by `SqlParser.columnName`. + * @param ctx the parse tree + */ + exitColumnName?: (ctx: ColumnNameContext) => void; + /** + * Enter a parse tree produced by `SqlParser.columnNameSeq`. + * @param ctx the parse tree + */ + enterColumnNameSeq?: (ctx: ColumnNameSeqContext) => void; + /** + * Exit a parse tree produced by `SqlParser.columnNameSeq`. + * @param ctx the parse tree + */ + exitColumnNameSeq?: (ctx: ColumnNameSeqContext) => void; + /** + * Enter a parse tree produced by `SqlParser.columnNameCreate`. + * @param ctx the parse tree + */ + enterColumnNameCreate?: (ctx: ColumnNameCreateContext) => void; + /** + * Exit a parse tree produced by `SqlParser.columnNameCreate`. + * @param ctx the parse tree + */ + exitColumnNameCreate?: (ctx: ColumnNameCreateContext) => void; + /** + * Enter a parse tree produced by `SqlParser.identifierReference`. + * @param ctx the parse tree + */ + enterIdentifierReference?: (ctx: IdentifierReferenceContext) => void; + /** + * Exit a parse tree produced by `SqlParser.identifierReference`. + * @param ctx the parse tree + */ + exitIdentifierReference?: (ctx: IdentifierReferenceContext) => void; + /** + * Enter a parse tree produced by `SqlParser.queryOrganization`. + * @param ctx the parse tree + */ + enterQueryOrganization?: (ctx: QueryOrganizationContext) => void; + /** + * Exit a parse tree produced by `SqlParser.queryOrganization`. + * @param ctx the parse tree + */ + exitQueryOrganization?: (ctx: QueryOrganizationContext) => void; + /** + * Enter a parse tree produced by `SqlParser.queryTerm`. + * @param ctx the parse tree + */ + enterQueryTerm?: (ctx: QueryTermContext) => void; + /** + * Exit a parse tree produced by `SqlParser.queryTerm`. + * @param ctx the parse tree + */ + exitQueryTerm?: (ctx: QueryTermContext) => void; + /** + * Enter a parse tree produced by `SqlParser.queryPrimary`. + * @param ctx the parse tree + */ + enterQueryPrimary?: (ctx: QueryPrimaryContext) => void; + /** + * Exit a parse tree produced by `SqlParser.queryPrimary`. + * @param ctx the parse tree + */ + exitQueryPrimary?: (ctx: QueryPrimaryContext) => void; + /** + * Enter a parse tree produced by `SqlParser.sortItem`. + * @param ctx the parse tree + */ + enterSortItem?: (ctx: SortItemContext) => void; + /** + * Exit a parse tree produced by `SqlParser.sortItem`. + * @param ctx the parse tree + */ + exitSortItem?: (ctx: SortItemContext) => void; + /** + * Enter a parse tree produced by `SqlParser.fromStatementBody`. + * @param ctx the parse tree + */ + enterFromStatementBody?: (ctx: FromStatementBodyContext) => void; + /** + * Exit a parse tree produced by `SqlParser.fromStatementBody`. + * @param ctx the parse tree + */ + exitFromStatementBody?: (ctx: FromStatementBodyContext) => void; + /** + * Enter a parse tree produced by `SqlParser.querySpecification`. + * @param ctx the parse tree + */ + enterQuerySpecification?: (ctx: QuerySpecificationContext) => void; + /** + * Exit a parse tree produced by `SqlParser.querySpecification`. + * @param ctx the parse tree + */ + exitQuerySpecification?: (ctx: QuerySpecificationContext) => void; + /** + * Enter a parse tree produced by `SqlParser.transformClause`. + * @param ctx the parse tree + */ + enterTransformClause?: (ctx: TransformClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.transformClause`. + * @param ctx the parse tree + */ + exitTransformClause?: (ctx: TransformClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.selectClause`. + * @param ctx the parse tree + */ + enterSelectClause?: (ctx: SelectClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.selectClause`. + * @param ctx the parse tree + */ + exitSelectClause?: (ctx: SelectClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.setClause`. + * @param ctx the parse tree + */ + enterSetClause?: (ctx: SetClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.setClause`. + * @param ctx the parse tree + */ + exitSetClause?: (ctx: SetClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.matchedClause`. + * @param ctx the parse tree + */ + enterMatchedClause?: (ctx: MatchedClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.matchedClause`. + * @param ctx the parse tree + */ + exitMatchedClause?: (ctx: MatchedClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.notMatchedClause`. + * @param ctx the parse tree + */ + enterNotMatchedClause?: (ctx: NotMatchedClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.notMatchedClause`. + * @param ctx the parse tree + */ + exitNotMatchedClause?: (ctx: NotMatchedClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.notMatchedBySourceClause`. + * @param ctx the parse tree + */ + enterNotMatchedBySourceClause?: (ctx: NotMatchedBySourceClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.notMatchedBySourceClause`. + * @param ctx the parse tree + */ + exitNotMatchedBySourceClause?: (ctx: NotMatchedBySourceClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.notMatchedAction`. + * @param ctx the parse tree + */ + enterNotMatchedAction?: (ctx: NotMatchedActionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.notMatchedAction`. + * @param ctx the parse tree + */ + exitNotMatchedAction?: (ctx: NotMatchedActionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.assignmentList`. + * @param ctx the parse tree + */ + enterAssignmentList?: (ctx: AssignmentListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.assignmentList`. + * @param ctx the parse tree + */ + exitAssignmentList?: (ctx: AssignmentListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.assignment`. + * @param ctx the parse tree + */ + enterAssignment?: (ctx: AssignmentContext) => void; + /** + * Exit a parse tree produced by `SqlParser.assignment`. + * @param ctx the parse tree + */ + exitAssignment?: (ctx: AssignmentContext) => void; + /** + * Enter a parse tree produced by `SqlParser.whereClause`. + * @param ctx the parse tree + */ + enterWhereClause?: (ctx: WhereClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.whereClause`. + * @param ctx the parse tree + */ + exitWhereClause?: (ctx: WhereClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.havingClause`. + * @param ctx the parse tree + */ + enterHavingClause?: (ctx: HavingClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.havingClause`. + * @param ctx the parse tree + */ + exitHavingClause?: (ctx: HavingClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.hint`. + * @param ctx the parse tree + */ + enterHint?: (ctx: HintContext) => void; + /** + * Exit a parse tree produced by `SqlParser.hint`. + * @param ctx the parse tree + */ + exitHint?: (ctx: HintContext) => void; + /** + * Enter a parse tree produced by `SqlParser.hintStatement`. + * @param ctx the parse tree + */ + enterHintStatement?: (ctx: HintStatementContext) => void; + /** + * Exit a parse tree produced by `SqlParser.hintStatement`. + * @param ctx the parse tree + */ + exitHintStatement?: (ctx: HintStatementContext) => void; + /** + * Enter a parse tree produced by `SqlParser.fromClause`. + * @param ctx the parse tree + */ + enterFromClause?: (ctx: FromClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.fromClause`. + * @param ctx the parse tree + */ + exitFromClause?: (ctx: FromClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.temporalClause`. + * @param ctx the parse tree + */ + enterTemporalClause?: (ctx: TemporalClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.temporalClause`. + * @param ctx the parse tree + */ + exitTemporalClause?: (ctx: TemporalClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.aggregationClause`. + * @param ctx the parse tree + */ + enterAggregationClause?: (ctx: AggregationClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.aggregationClause`. + * @param ctx the parse tree + */ + exitAggregationClause?: (ctx: AggregationClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.groupByClause`. + * @param ctx the parse tree + */ + enterGroupByClause?: (ctx: GroupByClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.groupByClause`. + * @param ctx the parse tree + */ + exitGroupByClause?: (ctx: GroupByClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.groupingAnalytics`. + * @param ctx the parse tree + */ + enterGroupingAnalytics?: (ctx: GroupingAnalyticsContext) => void; + /** + * Exit a parse tree produced by `SqlParser.groupingAnalytics`. + * @param ctx the parse tree + */ + exitGroupingAnalytics?: (ctx: GroupingAnalyticsContext) => void; + /** + * Enter a parse tree produced by `SqlParser.groupingSet`. + * @param ctx the parse tree + */ + enterGroupingSet?: (ctx: GroupingSetContext) => void; + /** + * Exit a parse tree produced by `SqlParser.groupingSet`. + * @param ctx the parse tree + */ + exitGroupingSet?: (ctx: GroupingSetContext) => void; + /** + * Enter a parse tree produced by `SqlParser.pivotClause`. + * @param ctx the parse tree + */ + enterPivotClause?: (ctx: PivotClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.pivotClause`. + * @param ctx the parse tree + */ + exitPivotClause?: (ctx: PivotClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.pivotColumn`. + * @param ctx the parse tree + */ + enterPivotColumn?: (ctx: PivotColumnContext) => void; + /** + * Exit a parse tree produced by `SqlParser.pivotColumn`. + * @param ctx the parse tree + */ + exitPivotColumn?: (ctx: PivotColumnContext) => void; + /** + * Enter a parse tree produced by `SqlParser.pivotValue`. + * @param ctx the parse tree + */ + enterPivotValue?: (ctx: PivotValueContext) => void; + /** + * Exit a parse tree produced by `SqlParser.pivotValue`. + * @param ctx the parse tree + */ + exitPivotValue?: (ctx: PivotValueContext) => void; + /** + * Enter a parse tree produced by `SqlParser.unpivotClause`. + * @param ctx the parse tree + */ + enterUnpivotClause?: (ctx: UnpivotClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.unpivotClause`. + * @param ctx the parse tree + */ + exitUnpivotClause?: (ctx: UnpivotClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.unpivotSingleValueColumnClause`. + * @param ctx the parse tree + */ + enterUnpivotSingleValueColumnClause?: (ctx: UnpivotSingleValueColumnClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.unpivotSingleValueColumnClause`. + * @param ctx the parse tree + */ + exitUnpivotSingleValueColumnClause?: (ctx: UnpivotSingleValueColumnClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.unpivotMultiValueColumnClause`. + * @param ctx the parse tree + */ + enterUnpivotMultiValueColumnClause?: (ctx: UnpivotMultiValueColumnClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.unpivotMultiValueColumnClause`. + * @param ctx the parse tree + */ + exitUnpivotMultiValueColumnClause?: (ctx: UnpivotMultiValueColumnClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.unpivotColumnSet`. + * @param ctx the parse tree + */ + enterUnpivotColumnSet?: (ctx: UnpivotColumnSetContext) => void; + /** + * Exit a parse tree produced by `SqlParser.unpivotColumnSet`. + * @param ctx the parse tree + */ + exitUnpivotColumnSet?: (ctx: UnpivotColumnSetContext) => void; + /** + * Enter a parse tree produced by `SqlParser.unpivotColumnAndAlias`. + * @param ctx the parse tree + */ + enterUnpivotColumnAndAlias?: (ctx: UnpivotColumnAndAliasContext) => void; + /** + * Exit a parse tree produced by `SqlParser.unpivotColumnAndAlias`. + * @param ctx the parse tree + */ + exitUnpivotColumnAndAlias?: (ctx: UnpivotColumnAndAliasContext) => void; + /** + * Enter a parse tree produced by `SqlParser.ifNotExists`. + * @param ctx the parse tree + */ + enterIfNotExists?: (ctx: IfNotExistsContext) => void; + /** + * Exit a parse tree produced by `SqlParser.ifNotExists`. + * @param ctx the parse tree + */ + exitIfNotExists?: (ctx: IfNotExistsContext) => void; + /** + * Enter a parse tree produced by `SqlParser.ifExists`. + * @param ctx the parse tree + */ + enterIfExists?: (ctx: IfExistsContext) => void; + /** + * Exit a parse tree produced by `SqlParser.ifExists`. + * @param ctx the parse tree + */ + exitIfExists?: (ctx: IfExistsContext) => void; + /** + * Enter a parse tree produced by `SqlParser.lateralView`. + * @param ctx the parse tree + */ + enterLateralView?: (ctx: LateralViewContext) => void; + /** + * Exit a parse tree produced by `SqlParser.lateralView`. + * @param ctx the parse tree + */ + exitLateralView?: (ctx: LateralViewContext) => void; + /** + * Enter a parse tree produced by `SqlParser.setQuantifier`. + * @param ctx the parse tree + */ + enterSetQuantifier?: (ctx: SetQuantifierContext) => void; + /** + * Exit a parse tree produced by `SqlParser.setQuantifier`. + * @param ctx the parse tree + */ + exitSetQuantifier?: (ctx: SetQuantifierContext) => void; + /** + * Enter a parse tree produced by `SqlParser.relation`. + * @param ctx the parse tree + */ + enterRelation?: (ctx: RelationContext) => void; + /** + * Exit a parse tree produced by `SqlParser.relation`. + * @param ctx the parse tree + */ + exitRelation?: (ctx: RelationContext) => void; + /** + * Enter a parse tree produced by `SqlParser.joinRelation`. + * @param ctx the parse tree + */ + enterJoinRelation?: (ctx: JoinRelationContext) => void; + /** + * Exit a parse tree produced by `SqlParser.joinRelation`. + * @param ctx the parse tree + */ + exitJoinRelation?: (ctx: JoinRelationContext) => void; + /** + * Enter a parse tree produced by `SqlParser.joinType`. + * @param ctx the parse tree + */ + enterJoinType?: (ctx: JoinTypeContext) => void; + /** + * Exit a parse tree produced by `SqlParser.joinType`. + * @param ctx the parse tree + */ + exitJoinType?: (ctx: JoinTypeContext) => void; + /** + * Enter a parse tree produced by `SqlParser.joinCriteria`. + * @param ctx the parse tree + */ + enterJoinCriteria?: (ctx: JoinCriteriaContext) => void; + /** + * Exit a parse tree produced by `SqlParser.joinCriteria`. + * @param ctx the parse tree + */ + exitJoinCriteria?: (ctx: JoinCriteriaContext) => void; + /** + * Enter a parse tree produced by `SqlParser.sample`. + * @param ctx the parse tree + */ + enterSample?: (ctx: SampleContext) => void; + /** + * Exit a parse tree produced by `SqlParser.sample`. + * @param ctx the parse tree + */ + exitSample?: (ctx: SampleContext) => void; + /** + * Enter a parse tree produced by `SqlParser.sampleMethod`. + * @param ctx the parse tree + */ + enterSampleMethod?: (ctx: SampleMethodContext) => void; + /** + * Exit a parse tree produced by `SqlParser.sampleMethod`. + * @param ctx the parse tree + */ + exitSampleMethod?: (ctx: SampleMethodContext) => void; + /** + * Enter a parse tree produced by `SqlParser.identifierList`. + * @param ctx the parse tree + */ + enterIdentifierList?: (ctx: IdentifierListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.identifierList`. + * @param ctx the parse tree + */ + exitIdentifierList?: (ctx: IdentifierListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.identifierSeq`. + * @param ctx the parse tree + */ + enterIdentifierSeq?: (ctx: IdentifierSeqContext) => void; + /** + * Exit a parse tree produced by `SqlParser.identifierSeq`. + * @param ctx the parse tree + */ + exitIdentifierSeq?: (ctx: IdentifierSeqContext) => void; + /** + * Enter a parse tree produced by `SqlParser.orderedIdentifierList`. + * @param ctx the parse tree + */ + enterOrderedIdentifierList?: (ctx: OrderedIdentifierListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.orderedIdentifierList`. + * @param ctx the parse tree + */ + exitOrderedIdentifierList?: (ctx: OrderedIdentifierListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.orderedIdentifier`. + * @param ctx the parse tree + */ + enterOrderedIdentifier?: (ctx: OrderedIdentifierContext) => void; + /** + * Exit a parse tree produced by `SqlParser.orderedIdentifier`. + * @param ctx the parse tree + */ + exitOrderedIdentifier?: (ctx: OrderedIdentifierContext) => void; + /** + * Enter a parse tree produced by `SqlParser.identifierCommentList`. + * @param ctx the parse tree + */ + enterIdentifierCommentList?: (ctx: IdentifierCommentListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.identifierCommentList`. + * @param ctx the parse tree + */ + exitIdentifierCommentList?: (ctx: IdentifierCommentListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.identifierComment`. + * @param ctx the parse tree + */ + enterIdentifierComment?: (ctx: IdentifierCommentContext) => void; + /** + * Exit a parse tree produced by `SqlParser.identifierComment`. + * @param ctx the parse tree + */ + exitIdentifierComment?: (ctx: IdentifierCommentContext) => void; + /** + * Enter a parse tree produced by `SqlParser.relationPrimary`. + * @param ctx the parse tree + */ + enterRelationPrimary?: (ctx: RelationPrimaryContext) => void; + /** + * Exit a parse tree produced by `SqlParser.relationPrimary`. + * @param ctx the parse tree + */ + exitRelationPrimary?: (ctx: RelationPrimaryContext) => void; + /** + * Enter a parse tree produced by `SqlParser.functionTableSubqueryArgument`. + * @param ctx the parse tree + */ + enterFunctionTableSubqueryArgument?: (ctx: FunctionTableSubqueryArgumentContext) => void; + /** + * Exit a parse tree produced by `SqlParser.functionTableSubqueryArgument`. + * @param ctx the parse tree + */ + exitFunctionTableSubqueryArgument?: (ctx: FunctionTableSubqueryArgumentContext) => void; + /** + * Enter a parse tree produced by `SqlParser.tableArgumentPartitioning`. + * @param ctx the parse tree + */ + enterTableArgumentPartitioning?: (ctx: TableArgumentPartitioningContext) => void; + /** + * Exit a parse tree produced by `SqlParser.tableArgumentPartitioning`. + * @param ctx the parse tree + */ + exitTableArgumentPartitioning?: (ctx: TableArgumentPartitioningContext) => void; + /** + * Enter a parse tree produced by `SqlParser.functionTableNamedArgumentExpression`. + * @param ctx the parse tree + */ + enterFunctionTableNamedArgumentExpression?: (ctx: FunctionTableNamedArgumentExpressionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.functionTableNamedArgumentExpression`. + * @param ctx the parse tree + */ + exitFunctionTableNamedArgumentExpression?: (ctx: FunctionTableNamedArgumentExpressionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.functionTableReferenceArgument`. + * @param ctx the parse tree + */ + enterFunctionTableReferenceArgument?: (ctx: FunctionTableReferenceArgumentContext) => void; + /** + * Exit a parse tree produced by `SqlParser.functionTableReferenceArgument`. + * @param ctx the parse tree + */ + exitFunctionTableReferenceArgument?: (ctx: FunctionTableReferenceArgumentContext) => void; + /** + * Enter a parse tree produced by `SqlParser.functionTableArgument`. + * @param ctx the parse tree + */ + enterFunctionTableArgument?: (ctx: FunctionTableArgumentContext) => void; + /** + * Exit a parse tree produced by `SqlParser.functionTableArgument`. + * @param ctx the parse tree + */ + exitFunctionTableArgument?: (ctx: FunctionTableArgumentContext) => void; + /** + * Enter a parse tree produced by `SqlParser.tableAlias`. + * @param ctx the parse tree + */ + enterTableAlias?: (ctx: TableAliasContext) => void; + /** + * Exit a parse tree produced by `SqlParser.tableAlias`. + * @param ctx the parse tree + */ + exitTableAlias?: (ctx: TableAliasContext) => void; + /** + * Enter a parse tree produced by `SqlParser.rowFormat`. + * @param ctx the parse tree + */ + enterRowFormat?: (ctx: RowFormatContext) => void; + /** + * Exit a parse tree produced by `SqlParser.rowFormat`. + * @param ctx the parse tree + */ + exitRowFormat?: (ctx: RowFormatContext) => void; + /** + * Enter a parse tree produced by `SqlParser.multipartIdentifierList`. + * @param ctx the parse tree + */ + enterMultipartIdentifierList?: (ctx: MultipartIdentifierListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.multipartIdentifierList`. + * @param ctx the parse tree + */ + exitMultipartIdentifierList?: (ctx: MultipartIdentifierListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.multipartIdentifier`. + * @param ctx the parse tree + */ + enterMultipartIdentifier?: (ctx: MultipartIdentifierContext) => void; + /** + * Exit a parse tree produced by `SqlParser.multipartIdentifier`. + * @param ctx the parse tree + */ + exitMultipartIdentifier?: (ctx: MultipartIdentifierContext) => void; + /** + * Enter a parse tree produced by `SqlParser.multipartIdentifierPropertyList`. + * @param ctx the parse tree + */ + enterMultipartIdentifierPropertyList?: (ctx: MultipartIdentifierPropertyListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.multipartIdentifierPropertyList`. + * @param ctx the parse tree + */ + exitMultipartIdentifierPropertyList?: (ctx: MultipartIdentifierPropertyListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.multipartIdentifierProperty`. + * @param ctx the parse tree + */ + enterMultipartIdentifierProperty?: (ctx: MultipartIdentifierPropertyContext) => void; + /** + * Exit a parse tree produced by `SqlParser.multipartIdentifierProperty`. + * @param ctx the parse tree + */ + exitMultipartIdentifierProperty?: (ctx: MultipartIdentifierPropertyContext) => void; + /** + * Enter a parse tree produced by `SqlParser.tableIdentifier`. + * @param ctx the parse tree + */ + enterTableIdentifier?: (ctx: TableIdentifierContext) => void; + /** + * Exit a parse tree produced by `SqlParser.tableIdentifier`. + * @param ctx the parse tree + */ + exitTableIdentifier?: (ctx: TableIdentifierContext) => void; + /** + * Enter a parse tree produced by `SqlParser.viewIdentifier`. + * @param ctx the parse tree + */ + enterViewIdentifier?: (ctx: ViewIdentifierContext) => void; + /** + * Exit a parse tree produced by `SqlParser.viewIdentifier`. + * @param ctx the parse tree + */ + exitViewIdentifier?: (ctx: ViewIdentifierContext) => void; + /** + * Enter a parse tree produced by `SqlParser.namedExpression`. + * @param ctx the parse tree + */ + enterNamedExpression?: (ctx: NamedExpressionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.namedExpression`. + * @param ctx the parse tree + */ + exitNamedExpression?: (ctx: NamedExpressionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.namedExpressionSeq`. + * @param ctx the parse tree + */ + enterNamedExpressionSeq?: (ctx: NamedExpressionSeqContext) => void; + /** + * Exit a parse tree produced by `SqlParser.namedExpressionSeq`. + * @param ctx the parse tree + */ + exitNamedExpressionSeq?: (ctx: NamedExpressionSeqContext) => void; + /** + * Enter a parse tree produced by `SqlParser.partitionFieldList`. + * @param ctx the parse tree + */ + enterPartitionFieldList?: (ctx: PartitionFieldListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.partitionFieldList`. + * @param ctx the parse tree + */ + exitPartitionFieldList?: (ctx: PartitionFieldListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.partitionField`. + * @param ctx the parse tree + */ + enterPartitionField?: (ctx: PartitionFieldContext) => void; + /** + * Exit a parse tree produced by `SqlParser.partitionField`. + * @param ctx the parse tree + */ + exitPartitionField?: (ctx: PartitionFieldContext) => void; + /** + * Enter a parse tree produced by `SqlParser.transform`. + * @param ctx the parse tree + */ + enterTransform?: (ctx: TransformContext) => void; + /** + * Exit a parse tree produced by `SqlParser.transform`. + * @param ctx the parse tree + */ + exitTransform?: (ctx: TransformContext) => void; + /** + * Enter a parse tree produced by `SqlParser.transformArgument`. + * @param ctx the parse tree + */ + enterTransformArgument?: (ctx: TransformArgumentContext) => void; + /** + * Exit a parse tree produced by `SqlParser.transformArgument`. + * @param ctx the parse tree + */ + exitTransformArgument?: (ctx: TransformArgumentContext) => void; + /** + * Enter a parse tree produced by `SqlParser.expression`. + * @param ctx the parse tree + */ + enterExpression?: (ctx: ExpressionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.expression`. + * @param ctx the parse tree + */ + exitExpression?: (ctx: ExpressionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.namedArgumentExpression`. + * @param ctx the parse tree + */ + enterNamedArgumentExpression?: (ctx: NamedArgumentExpressionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.namedArgumentExpression`. + * @param ctx the parse tree + */ + exitNamedArgumentExpression?: (ctx: NamedArgumentExpressionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.functionArgument`. + * @param ctx the parse tree + */ + enterFunctionArgument?: (ctx: FunctionArgumentContext) => void; + /** + * Exit a parse tree produced by `SqlParser.functionArgument`. + * @param ctx the parse tree + */ + exitFunctionArgument?: (ctx: FunctionArgumentContext) => void; + /** + * Enter a parse tree produced by `SqlParser.expressionSeq`. + * @param ctx the parse tree + */ + enterExpressionSeq?: (ctx: ExpressionSeqContext) => void; + /** + * Exit a parse tree produced by `SqlParser.expressionSeq`. + * @param ctx the parse tree + */ + exitExpressionSeq?: (ctx: ExpressionSeqContext) => void; + /** + * Enter a parse tree produced by `SqlParser.booleanExpression`. + * @param ctx the parse tree + */ + enterBooleanExpression?: (ctx: BooleanExpressionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.booleanExpression`. + * @param ctx the parse tree + */ + exitBooleanExpression?: (ctx: BooleanExpressionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.predicate`. + * @param ctx the parse tree + */ + enterPredicate?: (ctx: PredicateContext) => void; + /** + * Exit a parse tree produced by `SqlParser.predicate`. + * @param ctx the parse tree + */ + exitPredicate?: (ctx: PredicateContext) => void; + /** + * Enter a parse tree produced by `SqlParser.valueExpression`. + * @param ctx the parse tree + */ + enterValueExpression?: (ctx: ValueExpressionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.valueExpression`. + * @param ctx the parse tree + */ + exitValueExpression?: (ctx: ValueExpressionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.datetimeUnit`. + * @param ctx the parse tree + */ + enterDatetimeUnit?: (ctx: DatetimeUnitContext) => void; + /** + * Exit a parse tree produced by `SqlParser.datetimeUnit`. + * @param ctx the parse tree + */ + exitDatetimeUnit?: (ctx: DatetimeUnitContext) => void; + /** + * Enter a parse tree produced by `SqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterPrimaryExpression?: (ctx: PrimaryExpressionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitPrimaryExpression?: (ctx: PrimaryExpressionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.literalType`. + * @param ctx the parse tree + */ + enterLiteralType?: (ctx: LiteralTypeContext) => void; + /** + * Exit a parse tree produced by `SqlParser.literalType`. + * @param ctx the parse tree + */ + exitLiteralType?: (ctx: LiteralTypeContext) => void; + /** + * Enter a parse tree produced by `SqlParser.constant`. + * @param ctx the parse tree + */ + enterConstant?: (ctx: ConstantContext) => void; + /** + * Exit a parse tree produced by `SqlParser.constant`. + * @param ctx the parse tree + */ + exitConstant?: (ctx: ConstantContext) => void; + /** + * Enter a parse tree produced by `SqlParser.comparisonOperator`. + * @param ctx the parse tree + */ + enterComparisonOperator?: (ctx: ComparisonOperatorContext) => void; + /** + * Exit a parse tree produced by `SqlParser.comparisonOperator`. + * @param ctx the parse tree + */ + exitComparisonOperator?: (ctx: ComparisonOperatorContext) => void; + /** + * Enter a parse tree produced by `SqlParser.arithmeticOperator`. + * @param ctx the parse tree + */ + enterArithmeticOperator?: (ctx: ArithmeticOperatorContext) => void; + /** + * Exit a parse tree produced by `SqlParser.arithmeticOperator`. + * @param ctx the parse tree + */ + exitArithmeticOperator?: (ctx: ArithmeticOperatorContext) => void; + /** + * Enter a parse tree produced by `SqlParser.predicateOperator`. + * @param ctx the parse tree + */ + enterPredicateOperator?: (ctx: PredicateOperatorContext) => void; + /** + * Exit a parse tree produced by `SqlParser.predicateOperator`. + * @param ctx the parse tree + */ + exitPredicateOperator?: (ctx: PredicateOperatorContext) => void; + /** + * Enter a parse tree produced by `SqlParser.booleanValue`. + * @param ctx the parse tree + */ + enterBooleanValue?: (ctx: BooleanValueContext) => void; + /** + * Exit a parse tree produced by `SqlParser.booleanValue`. + * @param ctx the parse tree + */ + exitBooleanValue?: (ctx: BooleanValueContext) => void; + /** + * Enter a parse tree produced by `SqlParser.interval`. + * @param ctx the parse tree + */ + enterInterval?: (ctx: IntervalContext) => void; + /** + * Exit a parse tree produced by `SqlParser.interval`. + * @param ctx the parse tree + */ + exitInterval?: (ctx: IntervalContext) => void; + /** + * Enter a parse tree produced by `SqlParser.errorCapturingMultiUnitsInterval`. + * @param ctx the parse tree + */ + enterErrorCapturingMultiUnitsInterval?: (ctx: ErrorCapturingMultiUnitsIntervalContext) => void; + /** + * Exit a parse tree produced by `SqlParser.errorCapturingMultiUnitsInterval`. + * @param ctx the parse tree + */ + exitErrorCapturingMultiUnitsInterval?: (ctx: ErrorCapturingMultiUnitsIntervalContext) => void; + /** + * Enter a parse tree produced by `SqlParser.errorCapturingUnitToUnitInterval`. + * @param ctx the parse tree + */ + enterErrorCapturingUnitToUnitInterval?: (ctx: ErrorCapturingUnitToUnitIntervalContext) => void; + /** + * Exit a parse tree produced by `SqlParser.errorCapturingUnitToUnitInterval`. + * @param ctx the parse tree + */ + exitErrorCapturingUnitToUnitInterval?: (ctx: ErrorCapturingUnitToUnitIntervalContext) => void; + /** + * Enter a parse tree produced by `SqlParser.multiUnitsInterval`. + * @param ctx the parse tree + */ + enterMultiUnitsInterval?: (ctx: MultiUnitsIntervalContext) => void; + /** + * Exit a parse tree produced by `SqlParser.multiUnitsInterval`. + * @param ctx the parse tree + */ + exitMultiUnitsInterval?: (ctx: MultiUnitsIntervalContext) => void; + /** + * Enter a parse tree produced by `SqlParser.unitToUnitInterval`. + * @param ctx the parse tree + */ + enterUnitToUnitInterval?: (ctx: UnitToUnitIntervalContext) => void; + /** + * Exit a parse tree produced by `SqlParser.unitToUnitInterval`. + * @param ctx the parse tree + */ + exitUnitToUnitInterval?: (ctx: UnitToUnitIntervalContext) => void; + /** + * Enter a parse tree produced by `SqlParser.intervalValue`. + * @param ctx the parse tree + */ + enterIntervalValue?: (ctx: IntervalValueContext) => void; + /** + * Exit a parse tree produced by `SqlParser.intervalValue`. + * @param ctx the parse tree + */ + exitIntervalValue?: (ctx: IntervalValueContext) => void; + /** + * Enter a parse tree produced by `SqlParser.unitInMultiUnits`. + * @param ctx the parse tree + */ + enterUnitInMultiUnits?: (ctx: UnitInMultiUnitsContext) => void; + /** + * Exit a parse tree produced by `SqlParser.unitInMultiUnits`. + * @param ctx the parse tree + */ + exitUnitInMultiUnits?: (ctx: UnitInMultiUnitsContext) => void; + /** + * Enter a parse tree produced by `SqlParser.unitInUnitToUnit`. + * @param ctx the parse tree + */ + enterUnitInUnitToUnit?: (ctx: UnitInUnitToUnitContext) => void; + /** + * Exit a parse tree produced by `SqlParser.unitInUnitToUnit`. + * @param ctx the parse tree + */ + exitUnitInUnitToUnit?: (ctx: UnitInUnitToUnitContext) => void; + /** + * Enter a parse tree produced by `SqlParser.colPosition`. + * @param ctx the parse tree + */ + enterColPosition?: (ctx: ColPositionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.colPosition`. + * @param ctx the parse tree + */ + exitColPosition?: (ctx: ColPositionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.type`. + * @param ctx the parse tree + */ + enterType?: (ctx: TypeContext) => void; + /** + * Exit a parse tree produced by `SqlParser.type`. + * @param ctx the parse tree + */ + exitType?: (ctx: TypeContext) => void; + /** + * Enter a parse tree produced by `SqlParser.dataType`. + * @param ctx the parse tree + */ + enterDataType?: (ctx: DataTypeContext) => void; + /** + * Exit a parse tree produced by `SqlParser.dataType`. + * @param ctx the parse tree + */ + exitDataType?: (ctx: DataTypeContext) => void; + /** + * Enter a parse tree produced by `SqlParser.qualifiedColTypeWithPositionSeqForAdd`. + * @param ctx the parse tree + */ + enterQualifiedColTypeWithPositionSeqForAdd?: (ctx: QualifiedColTypeWithPositionSeqForAddContext) => void; + /** + * Exit a parse tree produced by `SqlParser.qualifiedColTypeWithPositionSeqForAdd`. + * @param ctx the parse tree + */ + exitQualifiedColTypeWithPositionSeqForAdd?: (ctx: QualifiedColTypeWithPositionSeqForAddContext) => void; + /** + * Enter a parse tree produced by `SqlParser.qualifiedColTypeWithPositionForAdd`. + * @param ctx the parse tree + */ + enterQualifiedColTypeWithPositionForAdd?: (ctx: QualifiedColTypeWithPositionForAddContext) => void; + /** + * Exit a parse tree produced by `SqlParser.qualifiedColTypeWithPositionForAdd`. + * @param ctx the parse tree + */ + exitQualifiedColTypeWithPositionForAdd?: (ctx: QualifiedColTypeWithPositionForAddContext) => void; + /** + * Enter a parse tree produced by `SqlParser.qualifiedColTypeWithPositionSeqForReplace`. + * @param ctx the parse tree + */ + enterQualifiedColTypeWithPositionSeqForReplace?: (ctx: QualifiedColTypeWithPositionSeqForReplaceContext) => void; + /** + * Exit a parse tree produced by `SqlParser.qualifiedColTypeWithPositionSeqForReplace`. + * @param ctx the parse tree + */ + exitQualifiedColTypeWithPositionSeqForReplace?: (ctx: QualifiedColTypeWithPositionSeqForReplaceContext) => void; + /** + * Enter a parse tree produced by `SqlParser.qualifiedColTypeWithPositionForReplace`. + * @param ctx the parse tree + */ + enterQualifiedColTypeWithPositionForReplace?: (ctx: QualifiedColTypeWithPositionForReplaceContext) => void; + /** + * Exit a parse tree produced by `SqlParser.qualifiedColTypeWithPositionForReplace`. + * @param ctx the parse tree + */ + exitQualifiedColTypeWithPositionForReplace?: (ctx: QualifiedColTypeWithPositionForReplaceContext) => void; + /** + * Enter a parse tree produced by `SqlParser.colDefinitionDescriptorWithPosition`. + * @param ctx the parse tree + */ + enterColDefinitionDescriptorWithPosition?: (ctx: ColDefinitionDescriptorWithPositionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.colDefinitionDescriptorWithPosition`. + * @param ctx the parse tree + */ + exitColDefinitionDescriptorWithPosition?: (ctx: ColDefinitionDescriptorWithPositionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.variableDefaultExpression`. + * @param ctx the parse tree + */ + enterVariableDefaultExpression?: (ctx: VariableDefaultExpressionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.variableDefaultExpression`. + * @param ctx the parse tree + */ + exitVariableDefaultExpression?: (ctx: VariableDefaultExpressionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.colTypeList`. + * @param ctx the parse tree + */ + enterColTypeList?: (ctx: ColTypeListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.colTypeList`. + * @param ctx the parse tree + */ + exitColTypeList?: (ctx: ColTypeListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.columnType`. + * @param ctx the parse tree + */ + enterColumnType?: (ctx: ColumnTypeContext) => void; + /** + * Exit a parse tree produced by `SqlParser.columnType`. + * @param ctx the parse tree + */ + exitColumnType?: (ctx: ColumnTypeContext) => void; + /** + * Enter a parse tree produced by `SqlParser.createOrReplaceTableColTypeList`. + * @param ctx the parse tree + */ + enterCreateOrReplaceTableColTypeList?: (ctx: CreateOrReplaceTableColTypeListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.createOrReplaceTableColTypeList`. + * @param ctx the parse tree + */ + exitCreateOrReplaceTableColTypeList?: (ctx: CreateOrReplaceTableColTypeListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.createOrReplaceTableColType`. + * @param ctx the parse tree + */ + enterCreateOrReplaceTableColType?: (ctx: CreateOrReplaceTableColTypeContext) => void; + /** + * Exit a parse tree produced by `SqlParser.createOrReplaceTableColType`. + * @param ctx the parse tree + */ + exitCreateOrReplaceTableColType?: (ctx: CreateOrReplaceTableColTypeContext) => void; + /** + * Enter a parse tree produced by `SqlParser.colDefinitionOption`. + * @param ctx the parse tree + */ + enterColDefinitionOption?: (ctx: ColDefinitionOptionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.colDefinitionOption`. + * @param ctx the parse tree + */ + exitColDefinitionOption?: (ctx: ColDefinitionOptionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.complexColType`. + * @param ctx the parse tree + */ + enterComplexColType?: (ctx: ComplexColTypeContext) => void; + /** + * Exit a parse tree produced by `SqlParser.complexColType`. + * @param ctx the parse tree + */ + exitComplexColType?: (ctx: ComplexColTypeContext) => void; + /** + * Enter a parse tree produced by `SqlParser.whenClause`. + * @param ctx the parse tree + */ + enterWhenClause?: (ctx: WhenClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.whenClause`. + * @param ctx the parse tree + */ + exitWhenClause?: (ctx: WhenClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.windowClause`. + * @param ctx the parse tree + */ + enterWindowClause?: (ctx: WindowClauseContext) => void; + /** + * Exit a parse tree produced by `SqlParser.windowClause`. + * @param ctx the parse tree + */ + exitWindowClause?: (ctx: WindowClauseContext) => void; + /** + * Enter a parse tree produced by `SqlParser.windowSpec`. + * @param ctx the parse tree + */ + enterWindowSpec?: (ctx: WindowSpecContext) => void; + /** + * Exit a parse tree produced by `SqlParser.windowSpec`. + * @param ctx the parse tree + */ + exitWindowSpec?: (ctx: WindowSpecContext) => void; + /** + * Enter a parse tree produced by `SqlParser.windowFrame`. + * @param ctx the parse tree + */ + enterWindowFrame?: (ctx: WindowFrameContext) => void; + /** + * Exit a parse tree produced by `SqlParser.windowFrame`. + * @param ctx the parse tree + */ + exitWindowFrame?: (ctx: WindowFrameContext) => void; + /** + * Enter a parse tree produced by `SqlParser.frameBound`. + * @param ctx the parse tree + */ + enterFrameBound?: (ctx: FrameBoundContext) => void; + /** + * Exit a parse tree produced by `SqlParser.frameBound`. + * @param ctx the parse tree + */ + exitFrameBound?: (ctx: FrameBoundContext) => void; + /** + * Enter a parse tree produced by `SqlParser.qualifiedNameList`. + * @param ctx the parse tree + */ + enterQualifiedNameList?: (ctx: QualifiedNameListContext) => void; + /** + * Exit a parse tree produced by `SqlParser.qualifiedNameList`. + * @param ctx the parse tree + */ + exitQualifiedNameList?: (ctx: QualifiedNameListContext) => void; + /** + * Enter a parse tree produced by `SqlParser.functionName`. + * @param ctx the parse tree + */ + enterFunctionName?: (ctx: FunctionNameContext) => void; + /** + * Exit a parse tree produced by `SqlParser.functionName`. + * @param ctx the parse tree + */ + exitFunctionName?: (ctx: FunctionNameContext) => void; + /** + * Enter a parse tree produced by `SqlParser.functionNameCreate`. + * @param ctx the parse tree + */ + enterFunctionNameCreate?: (ctx: FunctionNameCreateContext) => void; + /** + * Exit a parse tree produced by `SqlParser.functionNameCreate`. + * @param ctx the parse tree + */ + exitFunctionNameCreate?: (ctx: FunctionNameCreateContext) => void; + /** + * Enter a parse tree produced by `SqlParser.qualifiedName`. + * @param ctx the parse tree + */ + enterQualifiedName?: (ctx: QualifiedNameContext) => void; + /** + * Exit a parse tree produced by `SqlParser.qualifiedName`. + * @param ctx the parse tree + */ + exitQualifiedName?: (ctx: QualifiedNameContext) => void; + /** + * Enter a parse tree produced by `SqlParser.errorCapturingIdentifier`. + * @param ctx the parse tree + */ + enterErrorCapturingIdentifier?: (ctx: ErrorCapturingIdentifierContext) => void; + /** + * Exit a parse tree produced by `SqlParser.errorCapturingIdentifier`. + * @param ctx the parse tree + */ + exitErrorCapturingIdentifier?: (ctx: ErrorCapturingIdentifierContext) => void; + /** + * Enter a parse tree produced by `SqlParser.errorCapturingIdentifierExtra`. + * @param ctx the parse tree + */ + enterErrorCapturingIdentifierExtra?: (ctx: ErrorCapturingIdentifierExtraContext) => void; + /** + * Exit a parse tree produced by `SqlParser.errorCapturingIdentifierExtra`. + * @param ctx the parse tree + */ + exitErrorCapturingIdentifierExtra?: (ctx: ErrorCapturingIdentifierExtraContext) => void; + /** + * Enter a parse tree produced by `SqlParser.identifier`. + * @param ctx the parse tree + */ + enterIdentifier?: (ctx: IdentifierContext) => void; + /** + * Exit a parse tree produced by `SqlParser.identifier`. + * @param ctx the parse tree + */ + exitIdentifier?: (ctx: IdentifierContext) => void; + /** + * Enter a parse tree produced by `SqlParser.strictIdentifier`. + * @param ctx the parse tree + */ + enterStrictIdentifier?: (ctx: StrictIdentifierContext) => void; + /** + * Exit a parse tree produced by `SqlParser.strictIdentifier`. + * @param ctx the parse tree + */ + exitStrictIdentifier?: (ctx: StrictIdentifierContext) => void; + /** + * Enter a parse tree produced by `SqlParser.number`. + * @param ctx the parse tree + */ + enterNumber?: (ctx: NumberContext) => void; + /** + * Exit a parse tree produced by `SqlParser.number`. + * @param ctx the parse tree + */ + exitNumber?: (ctx: NumberContext) => void; + /** + * Enter a parse tree produced by `SqlParser.alterColumnAction`. + * @param ctx the parse tree + */ + enterAlterColumnAction?: (ctx: AlterColumnActionContext) => void; + /** + * Exit a parse tree produced by `SqlParser.alterColumnAction`. + * @param ctx the parse tree + */ + exitAlterColumnAction?: (ctx: AlterColumnActionContext) => void; + /** + * Enter a parse tree produced by `SqlParser.stringLit`. + * @param ctx the parse tree + */ + enterStringLit?: (ctx: StringLitContext) => void; + /** + * Exit a parse tree produced by `SqlParser.stringLit`. + * @param ctx the parse tree + */ + exitStringLit?: (ctx: StringLitContext) => void; + /** + * Enter a parse tree produced by `SqlParser.ansiNonReserved`. + * @param ctx the parse tree + */ + enterAnsiNonReserved?: (ctx: AnsiNonReservedContext) => void; + /** + * Exit a parse tree produced by `SqlParser.ansiNonReserved`. + * @param ctx the parse tree + */ + exitAnsiNonReserved?: (ctx: AnsiNonReservedContext) => void; + /** + * Enter a parse tree produced by `SqlParser.strictNonReserved`. + * @param ctx the parse tree + */ + enterStrictNonReserved?: (ctx: StrictNonReservedContext) => void; + /** + * Exit a parse tree produced by `SqlParser.strictNonReserved`. + * @param ctx the parse tree + */ + exitStrictNonReserved?: (ctx: StrictNonReservedContext) => void; + /** + * Enter a parse tree produced by `SqlParser.nonReserved`. + * @param ctx the parse tree + */ + enterNonReserved?: (ctx: NonReservedContext) => void; + /** + * Exit a parse tree produced by `SqlParser.nonReserved`. + * @param ctx the parse tree + */ + exitNonReserved?: (ctx: NonReservedContext) => void; + + visitTerminal(node: TerminalNode): void {} + visitErrorNode(node: ErrorNode): void {} + enterEveryRule(node: ParserRuleContext): void {} + exitEveryRule(node: ParserRuleContext): void {} +} + diff --git a/src/lib/sql/SqlParserVisitor.ts b/src/lib/sql/SqlParserVisitor.ts new file mode 100644 index 00000000..4055a2ca --- /dev/null +++ b/src/lib/sql/SqlParserVisitor.ts @@ -0,0 +1,1689 @@ +// Generated from dt-sql-parser/src/grammar/sql/SqlParser.g4 by ANTLR 4.13.1 + +// @ts-nocheck + +import { AbstractParseTreeVisitor } from "antlr4ng"; + + +import { SQLParserBase } from '../SQLParserBase'; + + +import { ProgramContext } from "./SqlParser.js"; +import { SingleStatementContext } from "./SqlParser.js"; +import { StatementDefaultContext } from "./SqlParser.js"; +import { DmlStatementContext } from "./SqlParser.js"; +import { UseNamespaceContext } from "./SqlParser.js"; +import { AlterContext } from "./SqlParser.js"; +import { CreateContext } from "./SqlParser.js"; +import { DropContext } from "./SqlParser.js"; +import { ShowContext } from "./SqlParser.js"; +import { TruncateTableContext } from "./SqlParser.js"; +import { AnalyzeContext } from "./SqlParser.js"; +import { AnalyzeTablesContext } from "./SqlParser.js"; +import { DeclareVariableContext } from "./SqlParser.js"; +import { ExplainStatementContext } from "./SqlParser.js"; +import { DescribeFunctionContext } from "./SqlParser.js"; +import { DescribeNamespaceContext } from "./SqlParser.js"; +import { DescribeQueryContext } from "./SqlParser.js"; +import { DescribeRelationContext } from "./SqlParser.js"; +import { CommentNamespaceContext } from "./SqlParser.js"; +import { RefreshTableContext } from "./SqlParser.js"; +import { RefreshFunctionContext } from "./SqlParser.js"; +import { RefreshResourceContext } from "./SqlParser.js"; +import { CacheTableContext } from "./SqlParser.js"; +import { UnCacheTableContext } from "./SqlParser.js"; +import { ClearCacheContext } from "./SqlParser.js"; +import { LoadDataContext } from "./SqlParser.js"; +import { RepairTableContext } from "./SqlParser.js"; +import { ManageResourceContext } from "./SqlParser.js"; +import { SetAnyContext } from "./SqlParser.js"; +import { ResetAnyContext } from "./SqlParser.js"; +import { OptimizeTableContext } from "./SqlParser.js"; +import { UnsupportHiveCommandsContext } from "./SqlParser.js"; +import { AlterStatementContext } from "./SqlParser.js"; +import { CreateNamespaceContext } from "./SqlParser.js"; +import { CreateTableContext } from "./SqlParser.js"; +import { ReplaceTableContext } from "./SqlParser.js"; +import { CreateTableLikeContext } from "./SqlParser.js"; +import { CreateViewContext } from "./SqlParser.js"; +import { CreateTempViewUsingContext } from "./SqlParser.js"; +import { CreateFunctionContext } from "./SqlParser.js"; +import { CreateIndexContext } from "./SqlParser.js"; +import { CreateRoleContext } from "./SqlParser.js"; +import { DropNamespaceContext } from "./SqlParser.js"; +import { DropTableContext } from "./SqlParser.js"; +import { DropViewContext } from "./SqlParser.js"; +import { DropFunctionContext } from "./SqlParser.js"; +import { DropVariableContext } from "./SqlParser.js"; +import { DropIndexContext } from "./SqlParser.js"; +import { DropRoleContext } from "./SqlParser.js"; +import { InsertFromQueryContext } from "./SqlParser.js"; +import { MultipleInsertContext } from "./SqlParser.js"; +import { DeleteFromTableContext } from "./SqlParser.js"; +import { UpdateTableContext } from "./SqlParser.js"; +import { MergeIntoTableContext } from "./SqlParser.js"; +import { InsertIntoContext } from "./SqlParser.js"; +import { ShowNamespacesContext } from "./SqlParser.js"; +import { ShowTablesContext } from "./SqlParser.js"; +import { ShowTableExtendedContext } from "./SqlParser.js"; +import { ShowTblPropertiesContext } from "./SqlParser.js"; +import { ShowColumnsContext } from "./SqlParser.js"; +import { ShowViewsContext } from "./SqlParser.js"; +import { ShowPartitionsContext } from "./SqlParser.js"; +import { ShowFunctionsContext } from "./SqlParser.js"; +import { ShowCreateTableContext } from "./SqlParser.js"; +import { ShowCurrentNamespaceContext } from "./SqlParser.js"; +import { ShowCatalogsContext } from "./SqlParser.js"; +import { ShowOtherContext } from "./SqlParser.js"; +import { UnsupportedCommandsContext } from "./SqlParser.js"; +import { BucketSpecContext } from "./SqlParser.js"; +import { SkewSpecContext } from "./SqlParser.js"; +import { QueryStatementContext } from "./SqlParser.js"; +import { PartitionSpecLocationContext } from "./SqlParser.js"; +import { PartitionSpecContext } from "./SqlParser.js"; +import { PartitionValContext } from "./SqlParser.js"; +import { NamespaceContext } from "./SqlParser.js"; +import { DescribeFuncNameContext } from "./SqlParser.js"; +import { DescribeColNameContext } from "./SqlParser.js"; +import { CtesContext } from "./SqlParser.js"; +import { NamedQueryContext } from "./SqlParser.js"; +import { TableProviderContext } from "./SqlParser.js"; +import { CreateTableClausesContext } from "./SqlParser.js"; +import { TableLifecycleContext } from "./SqlParser.js"; +import { PropertyListContext } from "./SqlParser.js"; +import { PropertyContext } from "./SqlParser.js"; +import { PropertyKeyContext } from "./SqlParser.js"; +import { PropertyValueContext } from "./SqlParser.js"; +import { ExpressionPropertyListContext } from "./SqlParser.js"; +import { ExpressionPropertyContext } from "./SqlParser.js"; +import { ConstantListContext } from "./SqlParser.js"; +import { NestedConstantListContext } from "./SqlParser.js"; +import { CreateFileFormatContext } from "./SqlParser.js"; +import { FileFormatContext } from "./SqlParser.js"; +import { StorageHandlerContext } from "./SqlParser.js"; +import { NamespaceNameContext } from "./SqlParser.js"; +import { NamespaceNameCreateContext } from "./SqlParser.js"; +import { TableNameCreateContext } from "./SqlParser.js"; +import { TableNameContext } from "./SqlParser.js"; +import { ViewNameCreateContext } from "./SqlParser.js"; +import { ViewNameContext } from "./SqlParser.js"; +import { ColumnNameContext } from "./SqlParser.js"; +import { ColumnNameSeqContext } from "./SqlParser.js"; +import { ColumnNameCreateContext } from "./SqlParser.js"; +import { IdentifierReferenceContext } from "./SqlParser.js"; +import { QueryOrganizationContext } from "./SqlParser.js"; +import { QueryTermContext } from "./SqlParser.js"; +import { QueryPrimaryContext } from "./SqlParser.js"; +import { SortItemContext } from "./SqlParser.js"; +import { FromStatementBodyContext } from "./SqlParser.js"; +import { QuerySpecificationContext } from "./SqlParser.js"; +import { TransformClauseContext } from "./SqlParser.js"; +import { SelectClauseContext } from "./SqlParser.js"; +import { SetClauseContext } from "./SqlParser.js"; +import { MatchedClauseContext } from "./SqlParser.js"; +import { NotMatchedClauseContext } from "./SqlParser.js"; +import { NotMatchedBySourceClauseContext } from "./SqlParser.js"; +import { NotMatchedActionContext } from "./SqlParser.js"; +import { AssignmentListContext } from "./SqlParser.js"; +import { AssignmentContext } from "./SqlParser.js"; +import { WhereClauseContext } from "./SqlParser.js"; +import { HavingClauseContext } from "./SqlParser.js"; +import { HintContext } from "./SqlParser.js"; +import { HintStatementContext } from "./SqlParser.js"; +import { FromClauseContext } from "./SqlParser.js"; +import { TemporalClauseContext } from "./SqlParser.js"; +import { AggregationClauseContext } from "./SqlParser.js"; +import { GroupByClauseContext } from "./SqlParser.js"; +import { GroupingAnalyticsContext } from "./SqlParser.js"; +import { GroupingSetContext } from "./SqlParser.js"; +import { PivotClauseContext } from "./SqlParser.js"; +import { PivotColumnContext } from "./SqlParser.js"; +import { PivotValueContext } from "./SqlParser.js"; +import { UnpivotClauseContext } from "./SqlParser.js"; +import { UnpivotSingleValueColumnClauseContext } from "./SqlParser.js"; +import { UnpivotMultiValueColumnClauseContext } from "./SqlParser.js"; +import { UnpivotColumnSetContext } from "./SqlParser.js"; +import { UnpivotColumnAndAliasContext } from "./SqlParser.js"; +import { IfNotExistsContext } from "./SqlParser.js"; +import { IfExistsContext } from "./SqlParser.js"; +import { LateralViewContext } from "./SqlParser.js"; +import { SetQuantifierContext } from "./SqlParser.js"; +import { RelationContext } from "./SqlParser.js"; +import { JoinRelationContext } from "./SqlParser.js"; +import { JoinTypeContext } from "./SqlParser.js"; +import { JoinCriteriaContext } from "./SqlParser.js"; +import { SampleContext } from "./SqlParser.js"; +import { SampleMethodContext } from "./SqlParser.js"; +import { IdentifierListContext } from "./SqlParser.js"; +import { IdentifierSeqContext } from "./SqlParser.js"; +import { OrderedIdentifierListContext } from "./SqlParser.js"; +import { OrderedIdentifierContext } from "./SqlParser.js"; +import { IdentifierCommentListContext } from "./SqlParser.js"; +import { IdentifierCommentContext } from "./SqlParser.js"; +import { RelationPrimaryContext } from "./SqlParser.js"; +import { FunctionTableSubqueryArgumentContext } from "./SqlParser.js"; +import { TableArgumentPartitioningContext } from "./SqlParser.js"; +import { FunctionTableNamedArgumentExpressionContext } from "./SqlParser.js"; +import { FunctionTableReferenceArgumentContext } from "./SqlParser.js"; +import { FunctionTableArgumentContext } from "./SqlParser.js"; +import { TableAliasContext } from "./SqlParser.js"; +import { RowFormatContext } from "./SqlParser.js"; +import { MultipartIdentifierListContext } from "./SqlParser.js"; +import { MultipartIdentifierContext } from "./SqlParser.js"; +import { MultipartIdentifierPropertyListContext } from "./SqlParser.js"; +import { MultipartIdentifierPropertyContext } from "./SqlParser.js"; +import { TableIdentifierContext } from "./SqlParser.js"; +import { ViewIdentifierContext } from "./SqlParser.js"; +import { NamedExpressionContext } from "./SqlParser.js"; +import { NamedExpressionSeqContext } from "./SqlParser.js"; +import { PartitionFieldListContext } from "./SqlParser.js"; +import { PartitionFieldContext } from "./SqlParser.js"; +import { TransformContext } from "./SqlParser.js"; +import { TransformArgumentContext } from "./SqlParser.js"; +import { ExpressionContext } from "./SqlParser.js"; +import { NamedArgumentExpressionContext } from "./SqlParser.js"; +import { FunctionArgumentContext } from "./SqlParser.js"; +import { ExpressionSeqContext } from "./SqlParser.js"; +import { BooleanExpressionContext } from "./SqlParser.js"; +import { PredicateContext } from "./SqlParser.js"; +import { ValueExpressionContext } from "./SqlParser.js"; +import { DatetimeUnitContext } from "./SqlParser.js"; +import { PrimaryExpressionContext } from "./SqlParser.js"; +import { LiteralTypeContext } from "./SqlParser.js"; +import { ConstantContext } from "./SqlParser.js"; +import { ComparisonOperatorContext } from "./SqlParser.js"; +import { ArithmeticOperatorContext } from "./SqlParser.js"; +import { PredicateOperatorContext } from "./SqlParser.js"; +import { BooleanValueContext } from "./SqlParser.js"; +import { IntervalContext } from "./SqlParser.js"; +import { ErrorCapturingMultiUnitsIntervalContext } from "./SqlParser.js"; +import { ErrorCapturingUnitToUnitIntervalContext } from "./SqlParser.js"; +import { MultiUnitsIntervalContext } from "./SqlParser.js"; +import { UnitToUnitIntervalContext } from "./SqlParser.js"; +import { IntervalValueContext } from "./SqlParser.js"; +import { UnitInMultiUnitsContext } from "./SqlParser.js"; +import { UnitInUnitToUnitContext } from "./SqlParser.js"; +import { ColPositionContext } from "./SqlParser.js"; +import { TypeContext } from "./SqlParser.js"; +import { DataTypeContext } from "./SqlParser.js"; +import { QualifiedColTypeWithPositionSeqForAddContext } from "./SqlParser.js"; +import { QualifiedColTypeWithPositionForAddContext } from "./SqlParser.js"; +import { QualifiedColTypeWithPositionSeqForReplaceContext } from "./SqlParser.js"; +import { QualifiedColTypeWithPositionForReplaceContext } from "./SqlParser.js"; +import { ColDefinitionDescriptorWithPositionContext } from "./SqlParser.js"; +import { VariableDefaultExpressionContext } from "./SqlParser.js"; +import { ColTypeListContext } from "./SqlParser.js"; +import { ColumnTypeContext } from "./SqlParser.js"; +import { CreateOrReplaceTableColTypeListContext } from "./SqlParser.js"; +import { CreateOrReplaceTableColTypeContext } from "./SqlParser.js"; +import { ColDefinitionOptionContext } from "./SqlParser.js"; +import { ComplexColTypeContext } from "./SqlParser.js"; +import { WhenClauseContext } from "./SqlParser.js"; +import { WindowClauseContext } from "./SqlParser.js"; +import { WindowSpecContext } from "./SqlParser.js"; +import { WindowFrameContext } from "./SqlParser.js"; +import { FrameBoundContext } from "./SqlParser.js"; +import { QualifiedNameListContext } from "./SqlParser.js"; +import { FunctionNameContext } from "./SqlParser.js"; +import { FunctionNameCreateContext } from "./SqlParser.js"; +import { QualifiedNameContext } from "./SqlParser.js"; +import { ErrorCapturingIdentifierContext } from "./SqlParser.js"; +import { ErrorCapturingIdentifierExtraContext } from "./SqlParser.js"; +import { IdentifierContext } from "./SqlParser.js"; +import { StrictIdentifierContext } from "./SqlParser.js"; +import { NumberContext } from "./SqlParser.js"; +import { AlterColumnActionContext } from "./SqlParser.js"; +import { StringLitContext } from "./SqlParser.js"; +import { AnsiNonReservedContext } from "./SqlParser.js"; +import { StrictNonReservedContext } from "./SqlParser.js"; +import { NonReservedContext } from "./SqlParser.js"; + + +/** + * This interface defines a complete generic visitor for a parse tree produced + * by `SqlParser`. + * + * @param The return type of the visit operation. Use `void` for + * operations with no return type. + */ +export class SqlParserVisitor extends AbstractParseTreeVisitor { + /** + * Visit a parse tree produced by `SqlParser.program`. + * @param ctx the parse tree + * @return the visitor result + */ + visitProgram?: (ctx: ProgramContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.singleStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSingleStatement?: (ctx: SingleStatementContext) => Result; + /** + * Visit a parse tree produced by the `statementDefault` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStatementDefault?: (ctx: StatementDefaultContext) => Result; + /** + * Visit a parse tree produced by the `dmlStatement` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDmlStatement?: (ctx: DmlStatementContext) => Result; + /** + * Visit a parse tree produced by the `useNamespace` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUseNamespace?: (ctx: UseNamespaceContext) => Result; + /** + * Visit a parse tree produced by the `alter` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlter?: (ctx: AlterContext) => Result; + /** + * Visit a parse tree produced by the `create` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreate?: (ctx: CreateContext) => Result; + /** + * Visit a parse tree produced by the `drop` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDrop?: (ctx: DropContext) => Result; + /** + * Visit a parse tree produced by the `show` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShow?: (ctx: ShowContext) => Result; + /** + * Visit a parse tree produced by the `truncateTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTruncateTable?: (ctx: TruncateTableContext) => Result; + /** + * Visit a parse tree produced by the `analyze` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAnalyze?: (ctx: AnalyzeContext) => Result; + /** + * Visit a parse tree produced by the `analyzeTables` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAnalyzeTables?: (ctx: AnalyzeTablesContext) => Result; + /** + * Visit a parse tree produced by the `declareVariable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDeclareVariable?: (ctx: DeclareVariableContext) => Result; + /** + * Visit a parse tree produced by the `explainStatement` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExplainStatement?: (ctx: ExplainStatementContext) => Result; + /** + * Visit a parse tree produced by the `describeFunction` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDescribeFunction?: (ctx: DescribeFunctionContext) => Result; + /** + * Visit a parse tree produced by the `describeNamespace` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDescribeNamespace?: (ctx: DescribeNamespaceContext) => Result; + /** + * Visit a parse tree produced by the `describeQuery` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDescribeQuery?: (ctx: DescribeQueryContext) => Result; + /** + * Visit a parse tree produced by the `describeRelation` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDescribeRelation?: (ctx: DescribeRelationContext) => Result; + /** + * Visit a parse tree produced by the `commentNamespace` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCommentNamespace?: (ctx: CommentNamespaceContext) => Result; + /** + * Visit a parse tree produced by the `refreshTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRefreshTable?: (ctx: RefreshTableContext) => Result; + /** + * Visit a parse tree produced by the `refreshFunction` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRefreshFunction?: (ctx: RefreshFunctionContext) => Result; + /** + * Visit a parse tree produced by the `refreshResource` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRefreshResource?: (ctx: RefreshResourceContext) => Result; + /** + * Visit a parse tree produced by the `cacheTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCacheTable?: (ctx: CacheTableContext) => Result; + /** + * Visit a parse tree produced by the `unCacheTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnCacheTable?: (ctx: UnCacheTableContext) => Result; + /** + * Visit a parse tree produced by the `clearCache` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitClearCache?: (ctx: ClearCacheContext) => Result; + /** + * Visit a parse tree produced by the `loadData` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLoadData?: (ctx: LoadDataContext) => Result; + /** + * Visit a parse tree produced by the `repairTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRepairTable?: (ctx: RepairTableContext) => Result; + /** + * Visit a parse tree produced by the `manageResource` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitManageResource?: (ctx: ManageResourceContext) => Result; + /** + * Visit a parse tree produced by the `setAny` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSetAny?: (ctx: SetAnyContext) => Result; + /** + * Visit a parse tree produced by the `resetAny` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitResetAny?: (ctx: ResetAnyContext) => Result; + /** + * Visit a parse tree produced by the `optimizeTable` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitOptimizeTable?: (ctx: OptimizeTableContext) => Result; + /** + * Visit a parse tree produced by the `unsupportHiveCommands` + * labeled alternative in `SqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnsupportHiveCommands?: (ctx: UnsupportHiveCommandsContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.alterStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterStatement?: (ctx: AlterStatementContext) => Result; + /** + * Visit a parse tree produced by the `createNamespace` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateNamespace?: (ctx: CreateNamespaceContext) => Result; + /** + * Visit a parse tree produced by the `createTable` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateTable?: (ctx: CreateTableContext) => Result; + /** + * Visit a parse tree produced by the `replaceTable` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitReplaceTable?: (ctx: ReplaceTableContext) => Result; + /** + * Visit a parse tree produced by the `createTableLike` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateTableLike?: (ctx: CreateTableLikeContext) => Result; + /** + * Visit a parse tree produced by the `createView` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateView?: (ctx: CreateViewContext) => Result; + /** + * Visit a parse tree produced by the `createTempViewUsing` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateTempViewUsing?: (ctx: CreateTempViewUsingContext) => Result; + /** + * Visit a parse tree produced by the `createFunction` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateFunction?: (ctx: CreateFunctionContext) => Result; + /** + * Visit a parse tree produced by the `createIndex` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateIndex?: (ctx: CreateIndexContext) => Result; + /** + * Visit a parse tree produced by the `createRole` + * labeled alternative in `SqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateRole?: (ctx: CreateRoleContext) => Result; + /** + * Visit a parse tree produced by the `dropNamespace` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropNamespace?: (ctx: DropNamespaceContext) => Result; + /** + * Visit a parse tree produced by the `dropTable` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropTable?: (ctx: DropTableContext) => Result; + /** + * Visit a parse tree produced by the `dropView` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropView?: (ctx: DropViewContext) => Result; + /** + * Visit a parse tree produced by the `dropFunction` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropFunction?: (ctx: DropFunctionContext) => Result; + /** + * Visit a parse tree produced by the `dropVariable` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropVariable?: (ctx: DropVariableContext) => Result; + /** + * Visit a parse tree produced by the `dropIndex` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropIndex?: (ctx: DropIndexContext) => Result; + /** + * Visit a parse tree produced by the `dropRole` + * labeled alternative in `SqlParser.dropStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropRole?: (ctx: DropRoleContext) => Result; + /** + * Visit a parse tree produced by the `insertFromQuery` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInsertFromQuery?: (ctx: InsertFromQueryContext) => Result; + /** + * Visit a parse tree produced by the `multipleInsert` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMultipleInsert?: (ctx: MultipleInsertContext) => Result; + /** + * Visit a parse tree produced by the `deleteFromTable` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDeleteFromTable?: (ctx: DeleteFromTableContext) => Result; + /** + * Visit a parse tree produced by the `updateTable` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUpdateTable?: (ctx: UpdateTableContext) => Result; + /** + * Visit a parse tree produced by the `mergeIntoTable` + * labeled alternative in `SqlParser.dmlStatementNoWith`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMergeIntoTable?: (ctx: MergeIntoTableContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.insertInto`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInsertInto?: (ctx: InsertIntoContext) => Result; + /** + * Visit a parse tree produced by the `showNamespaces` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowNamespaces?: (ctx: ShowNamespacesContext) => Result; + /** + * Visit a parse tree produced by the `showTables` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowTables?: (ctx: ShowTablesContext) => Result; + /** + * Visit a parse tree produced by the `showTableExtended` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowTableExtended?: (ctx: ShowTableExtendedContext) => Result; + /** + * Visit a parse tree produced by the `showTblProperties` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowTblProperties?: (ctx: ShowTblPropertiesContext) => Result; + /** + * Visit a parse tree produced by the `showColumns` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowColumns?: (ctx: ShowColumnsContext) => Result; + /** + * Visit a parse tree produced by the `showViews` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowViews?: (ctx: ShowViewsContext) => Result; + /** + * Visit a parse tree produced by the `showPartitions` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowPartitions?: (ctx: ShowPartitionsContext) => Result; + /** + * Visit a parse tree produced by the `showFunctions` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowFunctions?: (ctx: ShowFunctionsContext) => Result; + /** + * Visit a parse tree produced by the `showCreateTable` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowCreateTable?: (ctx: ShowCreateTableContext) => Result; + /** + * Visit a parse tree produced by the `showCurrentNamespace` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowCurrentNamespace?: (ctx: ShowCurrentNamespaceContext) => Result; + /** + * Visit a parse tree produced by the `showCatalogs` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowCatalogs?: (ctx: ShowCatalogsContext) => Result; + /** + * Visit a parse tree produced by the `showOther` + * labeled alternative in `SqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowOther?: (ctx: ShowOtherContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.unsupportedCommands`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnsupportedCommands?: (ctx: UnsupportedCommandsContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.bucketSpec`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBucketSpec?: (ctx: BucketSpecContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.skewSpec`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSkewSpec?: (ctx: SkewSpecContext) => Result; + /** + * Visit a parse tree produced by the `queryStatement` + * labeled alternative in `SqlParser.query`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryStatement?: (ctx: QueryStatementContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.partitionSpecLocation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPartitionSpecLocation?: (ctx: PartitionSpecLocationContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.partitionSpec`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPartitionSpec?: (ctx: PartitionSpecContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.partitionVal`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPartitionVal?: (ctx: PartitionValContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.namespace`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNamespace?: (ctx: NamespaceContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.describeFuncName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDescribeFuncName?: (ctx: DescribeFuncNameContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.describeColName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDescribeColName?: (ctx: DescribeColNameContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.ctes`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCtes?: (ctx: CtesContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.namedQuery`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNamedQuery?: (ctx: NamedQueryContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.tableProvider`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableProvider?: (ctx: TableProviderContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.createTableClauses`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateTableClauses?: (ctx: CreateTableClausesContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.tableLifecycle`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableLifecycle?: (ctx: TableLifecycleContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.propertyList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPropertyList?: (ctx: PropertyListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.property`. + * @param ctx the parse tree + * @return the visitor result + */ + visitProperty?: (ctx: PropertyContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.propertyKey`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPropertyKey?: (ctx: PropertyKeyContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.propertyValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPropertyValue?: (ctx: PropertyValueContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.expressionPropertyList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExpressionPropertyList?: (ctx: ExpressionPropertyListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.expressionProperty`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExpressionProperty?: (ctx: ExpressionPropertyContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.constantList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitConstantList?: (ctx: ConstantListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.nestedConstantList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNestedConstantList?: (ctx: NestedConstantListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.createFileFormat`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateFileFormat?: (ctx: CreateFileFormatContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.fileFormat`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFileFormat?: (ctx: FileFormatContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.storageHandler`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStorageHandler?: (ctx: StorageHandlerContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.namespaceName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNamespaceName?: (ctx: NamespaceNameContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.namespaceNameCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNamespaceNameCreate?: (ctx: NamespaceNameCreateContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.tableNameCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableNameCreate?: (ctx: TableNameCreateContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.tableName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableName?: (ctx: TableNameContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.viewNameCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitViewNameCreate?: (ctx: ViewNameCreateContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.viewName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitViewName?: (ctx: ViewNameContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.columnName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnName?: (ctx: ColumnNameContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.columnNameSeq`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnNameSeq?: (ctx: ColumnNameSeqContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.columnNameCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnNameCreate?: (ctx: ColumnNameCreateContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.identifierReference`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIdentifierReference?: (ctx: IdentifierReferenceContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.queryOrganization`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryOrganization?: (ctx: QueryOrganizationContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.queryTerm`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryTerm?: (ctx: QueryTermContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.queryPrimary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryPrimary?: (ctx: QueryPrimaryContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.sortItem`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSortItem?: (ctx: SortItemContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.fromStatementBody`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFromStatementBody?: (ctx: FromStatementBodyContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.querySpecification`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQuerySpecification?: (ctx: QuerySpecificationContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.transformClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTransformClause?: (ctx: TransformClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.selectClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSelectClause?: (ctx: SelectClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.setClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSetClause?: (ctx: SetClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.matchedClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMatchedClause?: (ctx: MatchedClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.notMatchedClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNotMatchedClause?: (ctx: NotMatchedClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.notMatchedBySourceClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNotMatchedBySourceClause?: (ctx: NotMatchedBySourceClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.notMatchedAction`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNotMatchedAction?: (ctx: NotMatchedActionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.assignmentList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAssignmentList?: (ctx: AssignmentListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.assignment`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAssignment?: (ctx: AssignmentContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.whereClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWhereClause?: (ctx: WhereClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.havingClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitHavingClause?: (ctx: HavingClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.hint`. + * @param ctx the parse tree + * @return the visitor result + */ + visitHint?: (ctx: HintContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.hintStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitHintStatement?: (ctx: HintStatementContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.fromClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFromClause?: (ctx: FromClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.temporalClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTemporalClause?: (ctx: TemporalClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.aggregationClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAggregationClause?: (ctx: AggregationClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.groupByClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupByClause?: (ctx: GroupByClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.groupingAnalytics`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupingAnalytics?: (ctx: GroupingAnalyticsContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.groupingSet`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupingSet?: (ctx: GroupingSetContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.pivotClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPivotClause?: (ctx: PivotClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.pivotColumn`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPivotColumn?: (ctx: PivotColumnContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.pivotValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPivotValue?: (ctx: PivotValueContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.unpivotClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnpivotClause?: (ctx: UnpivotClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.unpivotSingleValueColumnClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnpivotSingleValueColumnClause?: (ctx: UnpivotSingleValueColumnClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.unpivotMultiValueColumnClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnpivotMultiValueColumnClause?: (ctx: UnpivotMultiValueColumnClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.unpivotColumnSet`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnpivotColumnSet?: (ctx: UnpivotColumnSetContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.unpivotColumnAndAlias`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnpivotColumnAndAlias?: (ctx: UnpivotColumnAndAliasContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.ifNotExists`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIfNotExists?: (ctx: IfNotExistsContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.ifExists`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIfExists?: (ctx: IfExistsContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.lateralView`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLateralView?: (ctx: LateralViewContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.setQuantifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSetQuantifier?: (ctx: SetQuantifierContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.relation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRelation?: (ctx: RelationContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.joinRelation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitJoinRelation?: (ctx: JoinRelationContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.joinType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitJoinType?: (ctx: JoinTypeContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.joinCriteria`. + * @param ctx the parse tree + * @return the visitor result + */ + visitJoinCriteria?: (ctx: JoinCriteriaContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.sample`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSample?: (ctx: SampleContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.sampleMethod`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSampleMethod?: (ctx: SampleMethodContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.identifierList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIdentifierList?: (ctx: IdentifierListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.identifierSeq`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIdentifierSeq?: (ctx: IdentifierSeqContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.orderedIdentifierList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitOrderedIdentifierList?: (ctx: OrderedIdentifierListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.orderedIdentifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitOrderedIdentifier?: (ctx: OrderedIdentifierContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.identifierCommentList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIdentifierCommentList?: (ctx: IdentifierCommentListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.identifierComment`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIdentifierComment?: (ctx: IdentifierCommentContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.relationPrimary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRelationPrimary?: (ctx: RelationPrimaryContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.functionTableSubqueryArgument`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionTableSubqueryArgument?: (ctx: FunctionTableSubqueryArgumentContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.tableArgumentPartitioning`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableArgumentPartitioning?: (ctx: TableArgumentPartitioningContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.functionTableNamedArgumentExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionTableNamedArgumentExpression?: (ctx: FunctionTableNamedArgumentExpressionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.functionTableReferenceArgument`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionTableReferenceArgument?: (ctx: FunctionTableReferenceArgumentContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.functionTableArgument`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionTableArgument?: (ctx: FunctionTableArgumentContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.tableAlias`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableAlias?: (ctx: TableAliasContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.rowFormat`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRowFormat?: (ctx: RowFormatContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.multipartIdentifierList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMultipartIdentifierList?: (ctx: MultipartIdentifierListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.multipartIdentifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMultipartIdentifier?: (ctx: MultipartIdentifierContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.multipartIdentifierPropertyList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMultipartIdentifierPropertyList?: (ctx: MultipartIdentifierPropertyListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.multipartIdentifierProperty`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMultipartIdentifierProperty?: (ctx: MultipartIdentifierPropertyContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.tableIdentifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableIdentifier?: (ctx: TableIdentifierContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.viewIdentifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitViewIdentifier?: (ctx: ViewIdentifierContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.namedExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNamedExpression?: (ctx: NamedExpressionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.namedExpressionSeq`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNamedExpressionSeq?: (ctx: NamedExpressionSeqContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.partitionFieldList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPartitionFieldList?: (ctx: PartitionFieldListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.partitionField`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPartitionField?: (ctx: PartitionFieldContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.transform`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTransform?: (ctx: TransformContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.transformArgument`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTransformArgument?: (ctx: TransformArgumentContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExpression?: (ctx: ExpressionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.namedArgumentExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNamedArgumentExpression?: (ctx: NamedArgumentExpressionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.functionArgument`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionArgument?: (ctx: FunctionArgumentContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.expressionSeq`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExpressionSeq?: (ctx: ExpressionSeqContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.booleanExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBooleanExpression?: (ctx: BooleanExpressionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPredicate?: (ctx: PredicateContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.valueExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitValueExpression?: (ctx: ValueExpressionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.datetimeUnit`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDatetimeUnit?: (ctx: DatetimeUnitContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPrimaryExpression?: (ctx: PrimaryExpressionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.literalType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLiteralType?: (ctx: LiteralTypeContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.constant`. + * @param ctx the parse tree + * @return the visitor result + */ + visitConstant?: (ctx: ConstantContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.comparisonOperator`. + * @param ctx the parse tree + * @return the visitor result + */ + visitComparisonOperator?: (ctx: ComparisonOperatorContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.arithmeticOperator`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArithmeticOperator?: (ctx: ArithmeticOperatorContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.predicateOperator`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPredicateOperator?: (ctx: PredicateOperatorContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.booleanValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBooleanValue?: (ctx: BooleanValueContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.interval`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInterval?: (ctx: IntervalContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.errorCapturingMultiUnitsInterval`. + * @param ctx the parse tree + * @return the visitor result + */ + visitErrorCapturingMultiUnitsInterval?: (ctx: ErrorCapturingMultiUnitsIntervalContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.errorCapturingUnitToUnitInterval`. + * @param ctx the parse tree + * @return the visitor result + */ + visitErrorCapturingUnitToUnitInterval?: (ctx: ErrorCapturingUnitToUnitIntervalContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.multiUnitsInterval`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMultiUnitsInterval?: (ctx: MultiUnitsIntervalContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.unitToUnitInterval`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnitToUnitInterval?: (ctx: UnitToUnitIntervalContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.intervalValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIntervalValue?: (ctx: IntervalValueContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.unitInMultiUnits`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnitInMultiUnits?: (ctx: UnitInMultiUnitsContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.unitInUnitToUnit`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnitInUnitToUnit?: (ctx: UnitInUnitToUnitContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.colPosition`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColPosition?: (ctx: ColPositionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.type`. + * @param ctx the parse tree + * @return the visitor result + */ + visitType?: (ctx: TypeContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.dataType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDataType?: (ctx: DataTypeContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.qualifiedColTypeWithPositionSeqForAdd`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQualifiedColTypeWithPositionSeqForAdd?: (ctx: QualifiedColTypeWithPositionSeqForAddContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.qualifiedColTypeWithPositionForAdd`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQualifiedColTypeWithPositionForAdd?: (ctx: QualifiedColTypeWithPositionForAddContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.qualifiedColTypeWithPositionSeqForReplace`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQualifiedColTypeWithPositionSeqForReplace?: (ctx: QualifiedColTypeWithPositionSeqForReplaceContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.qualifiedColTypeWithPositionForReplace`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQualifiedColTypeWithPositionForReplace?: (ctx: QualifiedColTypeWithPositionForReplaceContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.colDefinitionDescriptorWithPosition`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColDefinitionDescriptorWithPosition?: (ctx: ColDefinitionDescriptorWithPositionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.variableDefaultExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitVariableDefaultExpression?: (ctx: VariableDefaultExpressionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.colTypeList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColTypeList?: (ctx: ColTypeListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.columnType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnType?: (ctx: ColumnTypeContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.createOrReplaceTableColTypeList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateOrReplaceTableColTypeList?: (ctx: CreateOrReplaceTableColTypeListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.createOrReplaceTableColType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateOrReplaceTableColType?: (ctx: CreateOrReplaceTableColTypeContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.colDefinitionOption`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColDefinitionOption?: (ctx: ColDefinitionOptionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.complexColType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitComplexColType?: (ctx: ComplexColTypeContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.whenClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWhenClause?: (ctx: WhenClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.windowClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWindowClause?: (ctx: WindowClauseContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.windowSpec`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWindowSpec?: (ctx: WindowSpecContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.windowFrame`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWindowFrame?: (ctx: WindowFrameContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.frameBound`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFrameBound?: (ctx: FrameBoundContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.qualifiedNameList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQualifiedNameList?: (ctx: QualifiedNameListContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.functionName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionName?: (ctx: FunctionNameContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.functionNameCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionNameCreate?: (ctx: FunctionNameCreateContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.qualifiedName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQualifiedName?: (ctx: QualifiedNameContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.errorCapturingIdentifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitErrorCapturingIdentifier?: (ctx: ErrorCapturingIdentifierContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.errorCapturingIdentifierExtra`. + * @param ctx the parse tree + * @return the visitor result + */ + visitErrorCapturingIdentifierExtra?: (ctx: ErrorCapturingIdentifierExtraContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.identifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIdentifier?: (ctx: IdentifierContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.strictIdentifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStrictIdentifier?: (ctx: StrictIdentifierContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.number`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNumber?: (ctx: NumberContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.alterColumnAction`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterColumnAction?: (ctx: AlterColumnActionContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.stringLit`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStringLit?: (ctx: StringLitContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.ansiNonReserved`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAnsiNonReserved?: (ctx: AnsiNonReservedContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.strictNonReserved`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStrictNonReserved?: (ctx: StrictNonReservedContext) => Result; + /** + * Visit a parse tree produced by `SqlParser.nonReserved`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNonReserved?: (ctx: NonReservedContext) => Result; +} + diff --git a/src/lib/trino/TrinoSqlParser.ts b/src/lib/trino/TrinoSqlParser.ts index bf394649..6c6eeb81 100644 --- a/src/lib/trino/TrinoSqlParser.ts +++ b/src/lib/trino/TrinoSqlParser.ts @@ -1264,7 +1264,7 @@ export class TrinoSqlParser extends SQLParserBase { this.state = 425; this.match(TrinoSqlParser.KW_COMMENT); this.state = 426; - this.string_(); + (localContext as CreateTableAsSelectContext)._comment = this.string_(); } } @@ -1392,7 +1392,7 @@ export class TrinoSqlParser extends SQLParserBase { this.state = 470; this.match(TrinoSqlParser.KW_COMMENT); this.state = 471; - this.string_(); + (localContext as CreateTableContext)._comment = this.string_(); } break; } @@ -2019,7 +2019,7 @@ export class TrinoSqlParser extends SQLParserBase { this.state = 679; this.match(TrinoSqlParser.KW_COMMENT); this.state = 680; - this.string_(); + (localContext as CreateMaterializedViewContext)._comment = this.string_(); } } @@ -2071,7 +2071,7 @@ export class TrinoSqlParser extends SQLParserBase { this.state = 697; this.match(TrinoSqlParser.KW_COMMENT); this.state = 698; - this.string_(); + (localContext as CreateViewContext)._comment = this.string_(); } } @@ -4229,7 +4229,7 @@ export class TrinoSqlParser extends SQLParserBase { this.state = 1270; this.columnNameCreate(); this.state = 1271; - this.type_(0); + localContext._colType = this.type_(0); this.state = 1274; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); @@ -4250,7 +4250,7 @@ export class TrinoSqlParser extends SQLParserBase { this.state = 1276; this.match(TrinoSqlParser.KW_COMMENT); this.state = 1277; - this.string_(); + localContext._comment = this.string_(); } break; } @@ -5718,7 +5718,7 @@ export class TrinoSqlParser extends SQLParserBase { } this.state = 1573; - this.identifier(); + (localContext as SelectSingleContext)._alias = this.identifier(); } break; } @@ -6836,7 +6836,7 @@ export class TrinoSqlParser extends SQLParserBase { } this.state = 1825; - this.identifier(); + localContext._alias = this.identifier(); this.state = 1827; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 223, this.context) ) { @@ -20482,6 +20482,7 @@ export class ShowColumnCommentContext extends StatementContext { } } export class CreateTableContext extends StatementContext { + public _comment?: StringContext; public constructor(ctx: StatementContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); @@ -20522,15 +20523,15 @@ export class CreateTableContext extends StatementContext { public KW_COMMENT(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_COMMENT, 0); } - public string(): StringContext | null { - return this.getRuleContext(0, StringContext); - } public KW_WITH(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_WITH, 0); } public properties(): PropertiesContext | null { return this.getRuleContext(0, PropertiesContext); } + public string(): StringContext | null { + return this.getRuleContext(0, StringContext); + } public override enterRule(listener: TrinoSqlListener): void { if(listener.enterCreateTable) { listener.enterCreateTable(this); @@ -20653,6 +20654,7 @@ export class StartTransactionContext extends StatementContext { } } export class CreateTableAsSelectContext extends StatementContext { + public _comment?: StringContext; public constructor(ctx: StatementContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); @@ -20693,9 +20695,6 @@ export class CreateTableAsSelectContext extends StatementContext { public KW_COMMENT(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_COMMENT, 0); } - public string(): StringContext | null { - return this.getRuleContext(0, StringContext); - } public KW_WITH(): antlr.TerminalNode[]; public KW_WITH(i: number): antlr.TerminalNode | null; public KW_WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { @@ -20711,6 +20710,9 @@ export class CreateTableAsSelectContext extends StatementContext { public KW_DATA(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_DATA, 0); } + public string(): StringContext | null { + return this.getRuleContext(0, StringContext); + } public KW_NO(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_NO, 0); } @@ -21317,6 +21319,7 @@ export class TruncateTableContext extends StatementContext { } } export class CreateMaterializedViewContext extends StatementContext { + public _comment?: StringContext; public constructor(ctx: StatementContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); @@ -21366,15 +21369,15 @@ export class CreateMaterializedViewContext extends StatementContext { public KW_COMMENT(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_COMMENT, 0); } - public string(): StringContext | null { - return this.getRuleContext(0, StringContext); - } public KW_WITH(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_WITH, 0); } public properties(): PropertiesContext | null { return this.getRuleContext(0, PropertiesContext); } + public string(): StringContext | null { + return this.getRuleContext(0, StringContext); + } public override enterRule(listener: TrinoSqlListener): void { if(listener.enterCreateMaterializedView) { listener.enterCreateMaterializedView(this); @@ -21432,6 +21435,7 @@ export class SetSessionContext extends StatementContext { } } export class CreateViewContext extends StatementContext { + public _comment?: StringContext; public constructor(ctx: StatementContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); @@ -21460,9 +21464,6 @@ export class CreateViewContext extends StatementContext { public KW_COMMENT(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_COMMENT, 0); } - public string(): StringContext | null { - return this.getRuleContext(0, StringContext); - } public KW_SECURITY(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_SECURITY, 0); } @@ -21472,6 +21473,9 @@ export class CreateViewContext extends StatementContext { public properties(): PropertiesContext | null { return this.getRuleContext(0, PropertiesContext); } + public string(): StringContext | null { + return this.getRuleContext(0, StringContext); + } public KW_DEFINER(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_DEFINER, 0); } @@ -22445,6 +22449,8 @@ export class TableElementContext extends antlr.ParserRuleContext { export class ColumnDefinitionContext extends antlr.ParserRuleContext { + public _colType?: TypeContext; + public _comment?: StringContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } @@ -22463,15 +22469,15 @@ export class ColumnDefinitionContext extends antlr.ParserRuleContext { public KW_COMMENT(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_COMMENT, 0); } - public string(): StringContext | null { - return this.getRuleContext(0, StringContext); - } public KW_WITH(): antlr.TerminalNode | null { return this.getToken(TrinoSqlParser.KW_WITH, 0); } public properties(): PropertiesContext | null { return this.getRuleContext(0, PropertiesContext); } + public string(): StringContext | null { + return this.getRuleContext(0, StringContext); + } public override get ruleIndex(): number { return TrinoSqlParser.RULE_columnDefinition; } @@ -23711,6 +23717,7 @@ export class SelectAllContext extends SelectItemContext { } } export class SelectSingleContext extends SelectItemContext { + public _alias?: IdentifierContext; public constructor(ctx: SelectItemContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); @@ -24506,6 +24513,7 @@ export class VariableDefinitionContext extends antlr.ParserRuleContext { export class AliasedRelationContext extends antlr.ParserRuleContext { + public _alias?: IdentifierContext; public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } diff --git a/src/locale/locale.ts b/src/locale/locale.ts new file mode 100644 index 00000000..4f993acf --- /dev/null +++ b/src/locale/locale.ts @@ -0,0 +1,46 @@ +const zh_CN = { + stmtInComplete: '语句不完整', + noValidPosition: '在此位置无效', + expecting: '，期望', + unfinishedMultilineComment: '未完成的多行注释', + unfinishedDoubleQuoted: '未完成的双引号字符串字变量', + unfinishedSingleQuoted: '未完成的单引号字符串字变量', + unfinishedTickQuoted: '未完成的反引号引用字符串字变量', + noValidInput: '没有有效的输入', + newObj: '一个新的对象', + existingObj: '一个存在的对象', + new: '一个新的', + existing: '一个存在的', + orKeyword: '或者一个关键字', + keyword: '一个关键字', + missing: '缺少', + at: '在', + or: '或者', +}; + +const en_US: typeof zh_CN = { + stmtInComplete: 'Statement is incomplete', + noValidPosition: 'is not valid at this position', + expecting: ', expecting ', + unfinishedMultilineComment: 'Unfinished multiline comment', + unfinishedDoubleQuoted: 'Unfinished double quoted string literal', + unfinishedSingleQuoted: 'Unfinished single quoted string literal', + unfinishedTickQuoted: 'Unfinished back tick quoted string literal', + noValidInput: 'is no valid input at all', + newObj: 'a new object', + existingObj: 'an existing object', + new: 'a new ', + existing: 'an existing ', + orKeyword: ' or a keyword', + keyword: 'a keyword', + missing: 'missing ', + at: ' at ', + or: ' or ', +}; + +const i18n = { + zh_CN, + en_US, +}; + +export { i18n }; diff --git a/src/parser/common/basicSQL.ts b/src/parser/common/basicSQL.ts index 429078ee..b835979a 100644 --- a/src/parser/common/basicSQL.ts +++ b/src/parser/common/basicSQL.ts @@ -8,13 +8,14 @@ import { ParseTreeWalker, ParseTreeListener, PredictionMode, + ANTLRErrorListener, } from 'antlr4ng'; import { CandidatesCollection, CodeCompletionCore } from 'antlr4-c3'; import { SQLParserBase } from '../../lib/SQLParserBase'; import { findCaretTokenIndex } from './findCaretTokenIndex'; import { ctxToText, tokenToWord, WordRange, TextSlice } from './textAndWord'; -import { CaretPosition, Suggestions, SyntaxSuggestion } from './types'; -import { ParseError, ErrorListener, ParseErrorListener } from './parseErrorListener'; +import { CaretPosition, LOCALE_TYPE, Suggestions, SyntaxSuggestion } from './types'; +import { ParseError, ErrorListener } from './parseErrorListener'; import { ErrorStrategy } from './errorStrategy'; import type { SplitListener } from './splitListener'; import type { EntityCollector } from './entityCollector'; @@ -78,6 +79,11 @@ export abstract class BasicSQL< */ protected abstract get splitListener(): SplitListener; + /** + * Get a new errorListener instance. + */ + protected abstract createErrorListener(errorListener: ErrorListener): ANTLRErrorListener; + /** * Get a new entityCollector instance. */ @@ -86,6 +92,8 @@ export abstract class BasicSQL< caretTokenIndex?: number ): EntityCollector; + public locale: LOCALE_TYPE = 'en_US'; + /** * Create an antlr4 lexer from input. * @param input string @@ -95,7 +103,7 @@ export abstract class BasicSQL< const lexer = this.createLexerFromCharStream(charStreams); if (errorListener) { lexer.removeErrorListeners(); - lexer.addErrorListener(new ParseErrorListener(errorListener)); + lexer.addErrorListener(this.createErrorListener(errorListener)); } return lexer; } @@ -111,7 +119,7 @@ export abstract class BasicSQL< parser.interpreter.predictionMode = PredictionMode.SLL; if (errorListener) { parser.removeErrorListeners(); - parser.addErrorListener(new ParseErrorListener(errorListener)); + parser.addErrorListener(this.createErrorListener(errorListener)); } return parser; @@ -142,7 +150,7 @@ export abstract class BasicSQL< this._lexer = this.createLexerFromCharStream(this._charStreams); this._lexer.removeErrorListeners(); - this._lexer.addErrorListener(new ParseErrorListener(this._errorListener)); + this._lexer.addErrorListener(this.createErrorListener(this._errorListener)); this._tokenStream = new CommonTokenStream(this._lexer); /** @@ -178,7 +186,7 @@ export abstract class BasicSQL< this._parsedInput = input; parser.removeErrorListeners(); - parser.addErrorListener(new ParseErrorListener(this._errorListener)); + parser.addErrorListener(this.createErrorListener(this._errorListener)); this._parseTree = parser.program(); diff --git a/src/parser/common/entityCollector.ts b/src/parser/common/entityCollector.ts index a7579bcc..af394934 100644 --- a/src/parser/common/entityCollector.ts +++ b/src/parser/common/entityCollector.ts @@ -1,8 +1,16 @@ -import { ParserRuleContext } from 'antlr4ng'; -import { EntityContextType } from './types'; -import { WordPosition, TextPosition } from './textAndWord'; -import { ctxToText, ctxToWord } from './textAndWord'; +import { isToken, ParserRuleContext, Token } from 'antlr4ng'; + import { SimpleStack } from './simpleStack'; +import { + ctxToText, + isWordRange, + TextPosition, + TextSlice, + tokenToWord, + WordPosition, + WordRange, +} from './textAndWord'; +import { EntityContextType } from './types'; /** * TODO: more stmt type should be supported. @@ -48,25 +56,80 @@ export function toStmtContext( }; } -export interface BaseAliasContext { - readonly isAlias: boolean; - alias?: string | EntityContext | null; - origin?: string | EntityContext | StmtContext | null; +/** + * entity's attribute + * @key comment: entity's comment attribute + * @key colType: column entity's type attribute + * @key alias: entity's alias attribute + * */ +export enum AttrName { + comment = '_comment', + colType = '_colType', + alias = '_alias', } - -const baseAlias: BaseAliasContext = { - isAlias: false, - origin: null, - alias: null, +/** + * ParserRuleContext with custom attributes + * */ +type ParserRuleContextWithAttr = ParserRuleContext & { + [K in AttrName]?: Token; }; -export interface EntityContext extends BaseAliasContext { +/** + * Function's arguments + * */ +export interface Argument { + argMode?: WordRange; + argName?: WordRange; + argType: WordRange; +} +export interface BaseEntityContext { readonly entityContextType: EntityContextType; readonly text: string; readonly position: WordPosition; readonly belongStmt: StmtContext; - relatedEntities: EntityContext[] | null; - columns: EntityContext[] | null; + reference?: string | EntityContext; // reference entity + [AttrName.comment]: WordRange | null; + [AttrName.alias]?: WordRange | null; // alias token +} + +export interface CommonEntityContext extends BaseEntityContext { + relatedEntities: CommonEntityContext[] | null; + columns?: ColumnEntityContext[]; +} + +export interface ColumnEntityContext extends BaseEntityContext { + [AttrName.colType]: WordRange | null; +} + +export interface FuncEntityContext extends BaseEntityContext { + relatedEntities: CommonEntityContext[] | null; + arguments: Argument[] | null; // function arguments + returns?: Argument; // function return value +} + +export type EntityContext = CommonEntityContext | FuncEntityContext | ColumnEntityContext; + +export function isCommonEntityContext(entity: EntityContext): entity is CommonEntityContext { + if (!entity) return false; + return 'relatedEntities' in entity && !('arguments' in entity); +} + +export function isFuncEntityContext(entity: EntityContext): entity is FuncEntityContext { + if (!entity) return false; + return 'arguments' in entity; +} + +export function isColumnEntityContext(entity: EntityContext): entity is ColumnEntityContext { + if (!entity) return false; + return AttrName.colType in entity; +} + +/** + * what we need when collect attribute information + * */ +interface AttrInfo { + attrName: AttrName; + endContextList: string[]; } export function toEntityContext( @@ -74,23 +137,113 @@ export function toEntityContext( type: EntityContextType, input: string, belongStmt: StmtContext, - alias?: BaseAliasContext + attrInfo?: AttrInfo[] ): EntityContext | null { - const word = ctxToWord(ctx, input); + const word = ctxToText(ctx, input); if (!word) return null; - const { text, ...position } = word; - const finalAlias = Object.assign({}, baseAlias, alias ?? {}); - return { + const { text, startLine, endLine, ...rest } = word; + const position = { + ...rest, + line: startLine, + }; + let entityInfo = { entityContextType: type, text, position, belongStmt, - relatedEntities: null, - columns: null, - ...finalAlias, + [AttrName.comment]: null, }; + switch (entityInfo.entityContextType) { + case EntityContextType.FUNCTION: + case EntityContextType.FUNCTION_CREATE: { + (entityInfo as FuncEntityContext).relatedEntities = null; + (entityInfo as FuncEntityContext).arguments = null; + break; + } + case EntityContextType.COLUMN: + case EntityContextType.COLUMN_CREATE: + (entityInfo as ColumnEntityContext)[AttrName.colType] = null; + break; + default: + (entityInfo as CommonEntityContext).relatedEntities = null; + break; + } + if (attrInfo) { + for (let k = 0; k < attrInfo.length; k++) { + const attributeName: AttrName = attrInfo[k]?.attrName; + const attrToken = findAttribute(ctx, attributeName, attrInfo[k]?.endContextList); + if (attrToken) { + const attrVal: WordRange | TextSlice | null = isToken(attrToken) + ? tokenToWord(attrToken, input) + : ctxToText(attrToken, input); + if (attrVal) { + if (isWordRange(attrVal)) { + entityInfo = Object.assign(entityInfo, { + [attributeName]: attrVal, + }); + } else { + const { startIndex, endIndex, startColumn, endColumn, text, ...rest } = + attrVal; + entityInfo = Object.assign(entityInfo, { + [attributeName]: { + startIndex, + endIndex, + startColumn, + endColumn, + text, + line: rest?.startLine, + }, + }); + } + } + } + } + } + return entityInfo; +} + +export function findAttribute( + ctx: ParserRuleContextWithAttr | null, + keyName: AttrName, + endContextNameList: string[] +): Token | null { + const parent: ParserRuleContextWithAttr | null = ctx?.parent || null; + let attrVal: Token | null = null; + if (parent?.[keyName]) { + attrVal = parent?.[keyName] || null; + return attrVal; + } else { + if (parent?.constructor?.name && !endContextNameList.includes(parent?.constructor?.name)) { + attrVal = findAttribute(parent, keyName, endContextNameList); + } + if (!attrVal) { + if (parent?.children) { + attrVal = findAttributeChildren(parent, keyName); + } + } + } + return attrVal; } +function findAttributeChildren( + ctx: ParserRuleContextWithAttr | null, + keyName: AttrName +): Token | null { + const visitChildren = ctx?.children || []; + let attrVal: Token | null = null; + if (visitChildren.length) { + for (let i = 0; i < visitChildren.length; i++) { + const child = visitChildren[i] || null; + if (child?.[keyName]) { + attrVal = child?.[keyName] || null; + return attrVal; + } else { + attrVal = findAttributeChildren(child, keyName); + } + } + } + return attrVal; +} /** * @todo: Handle alias, includes column alias, table alias, query as alias and so on. * @todo: [may be need] Combine the entities in each clause. @@ -125,8 +278,12 @@ export abstract class EntityCollector { exitEveryRule() {} + getRootStmt() { + return this._rootStmt; + } + getEntities() { - return Array.from(this._entitiesSet); + return Array.from(this._entitiesSet) as EntityContext[]; } enterProgram() { @@ -177,17 +334,13 @@ export abstract class EntityCollector { return stmtContext; } - protected pushEntity( - ctx: ParserRuleContext, - type: EntityContextType, - alias?: BaseAliasContext - ) { + protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, attrInfo?: AttrInfo[]) { const entityContext = toEntityContext( ctx, type, this._input, this._stmtStack.peek(), - alias + attrInfo ); if (entityContext) { if (this._stmtStack.isEmpty()) { @@ -273,13 +426,20 @@ export abstract class EntityCollector { } return result; }, [] as EntityContext[]); - if (mainEntity && columns.length) { - (mainEntity as EntityContext).columns = columns; + if (isCommonEntityContext(mainEntity)) { + mainEntity = Object.assign(mainEntity, { + columns, + }); + } } if (mainEntity && relatedEntities.length) { - (mainEntity as EntityContext).relatedEntities = relatedEntities; + if (isCommonEntityContext(mainEntity) || isFuncEntityContext(mainEntity)) { + mainEntity = Object.assign(mainEntity, { + relatedEntities, + }); + } } return finalEntities; diff --git a/src/parser/common/parseErrorListener.ts b/src/parser/common/parseErrorListener.ts index 0a1295bc..902a36f3 100644 --- a/src/parser/common/parseErrorListener.ts +++ b/src/parser/common/parseErrorListener.ts @@ -4,7 +4,14 @@ import { ANTLRErrorListener, RecognitionException, ATNSimulator, + LexerNoViableAltException, + Lexer, + Parser, + InputMismatchException, + NoViableAltException, } from 'antlr4ng'; +import { LOCALE_TYPE } from './types'; +import { transform } from './transform'; /** * Converted from {@link SyntaxError}. @@ -39,10 +46,12 @@ export interface SyntaxError { */ export type ErrorListener = (parseError: ParseError, originalError: SyntaxError) => void; -export class ParseErrorListener implements ANTLRErrorListener { +export abstract class ParseErrorListener implements ANTLRErrorListener { private _errorListener: ErrorListener; + private locale: LOCALE_TYPE; - constructor(errorListener: ErrorListener) { + constructor(errorListener: ErrorListener, locale: LOCALE_TYPE = 'en_US') { + this.locale = locale; this._errorListener = errorListener; } @@ -52,6 +61,8 @@ export class ParseErrorListener implements ANTLRErrorListener { reportContextSensitivity() {} + protected abstract getExpectedText(parser: Parser, token: Token): string; + syntaxError( recognizer: Recognizer, offendingSymbol: Token | null, @@ -60,6 +71,87 @@ export class ParseErrorListener implements ANTLRErrorListener { msg: string, e: RecognitionException ) { + let message = ''; + // If not undefined then offendingSymbol is of type Token. + if (offendingSymbol) { + let token = offendingSymbol as Token; + const parser = recognizer as Parser; + + // judge token is EOF + const isEof = token.type === Token.EOF; + if (isEof) { + token = parser.tokenStream.get(token.tokenIndex - 1); + } + const wrongText = token.text ?? ''; + + const isInComplete = isEof && wrongText !== ' '; + + const expectedText = isInComplete ? '' : this.getExpectedText(parser, token); + + if (!e) { + // handle missing or unwanted tokens. + message = msg; + if (msg.includes('extraneous')) { + message = `'${wrongText}' {noValidPosition}${ + expectedText.length ? `{expecting}${expectedText}` : '' + }`; + } + if (msg.includes('missing')) { + const regex = /missing\s+'([^']+)'/; + const match = msg.match(regex); + message = `{missing}`; + if (match) { + const missKeyword = match[1]; + message += `'${missKeyword}'`; + } else { + message += `{keyword}`; + } + message += `{at}'${wrongText}'`; + } + } else { + // handle mismatch exception or no viable alt exception + if (e instanceof InputMismatchException || e instanceof NoViableAltException) { + if (isEof) { + message = `{stmtInComplete}`; + } else { + message = `'${wrongText}' {noValidPosition}`; + } + if (expectedText.length > 0) { + message += `{expecting}${expectedText}`; + } + } else { + message = msg; + } + } + } else { + // No offending symbol, which indicates this is a lexer error. + if (e instanceof LexerNoViableAltException) { + const lexer = recognizer as Lexer; + const input = lexer.inputStream; + let text = lexer.getErrorDisplay( + input.getText(lexer._tokenStartCharIndex, input.index) + ); + switch (text[0]) { + case '/': + message = '{unfinishedMultilineComment}'; + break; + case '"': + message = '{unfinishedDoubleQuoted}'; + break; + case "'": + message = '{unfinishedSingleQuoted}'; + break; + case '`': + message = '{unfinishedTickQuoted}'; + break; + + default: + message = '"' + text + '" {noValidInput}'; + break; + } + } + } + message = transform(message, this.locale); let endCol = charPositionInLine + 1; if (offendingSymbol && offendingSymbol.text !== null) { endCol = charPositionInLine + offendingSymbol.text.length; @@ -71,7 +163,7 @@ export class ParseErrorListener implements ANTLRErrorListener { endLine: line, startColumn: charPositionInLine + 1, endColumn: endCol + 1, - message: msg, + message, }, { e, diff --git a/src/parser/common/textAndWord.ts b/src/parser/common/textAndWord.ts index df3066ca..a7217adc 100644 --- a/src/parser/common/textAndWord.ts +++ b/src/parser/common/textAndWord.ts @@ -40,7 +40,7 @@ export interface TextSlice extends TextPosition { /** * Convert Token to Word */ -export function tokenToWord(token: Token, input: string): WordPosition & { text: string } { +export function tokenToWord(token: Token, input: string): WordRange { const startIndex = token.start; const endIndex = token.stop; const text = token.text ?? ''; @@ -54,29 +54,6 @@ export function tokenToWord(token: Token, input: string): WordPosition & { text: }; } -/** - * Convert ParserRuleContext to Word - */ -export function ctxToWord( - ctx: ParserRuleContext, - input: string -): (WordPosition & { text: string }) | null { - if (!ctx.start || !ctx.stop) { - return null; - } - const startIndex = ctx.start.start; - const endIndex = ctx.stop.stop; - const text = input.slice(startIndex, endIndex + 1); - return { - text, - line: ctx.start.line, - startIndex, - endIndex, - startColumn: ctx.start.column + 1, - endColumn: ctx.stop.column + 1 + (ctx.stop.text?.length ?? 0), - }; -} - /** * Convert ParserRuleContext to Text */ @@ -100,3 +77,12 @@ export function ctxToText( endColumn: ctx.stop.column + 1 + (ctx.stop.text?.length ?? 0), }; } + +/** + * judge whether the context is a WordRange + * @param textOrWord TextSlice or WordRange object + * */ +export function isWordRange(textOrWord: TextSlice | WordRange): textOrWord is WordRange { + if (!textOrWord) return false; + return 'line' in textOrWord; +} diff --git a/src/parser/common/transform.ts b/src/parser/common/transform.ts new file mode 100644 index 00000000..f4e52317 --- /dev/null +++ b/src/parser/common/transform.ts @@ -0,0 +1,17 @@ +import { LOCALE_TYPE } from './types'; +import { i18n } from '../../locale/locale'; + +/** + * transform message to locale language + * @param message error msg + * @param locale language setting + */ +function transform(message: string, locale: LOCALE_TYPE) { + const regex = /{([^}]+)}/g; + return message.replace( + regex, + (_, key: keyof (typeof i18n)[typeof locale]) => i18n[locale][key] || '' + ); +} + +export { transform }; diff --git a/src/parser/common/types.ts b/src/parser/common/types.ts index 853673ce..ffb7bdb6 100644 --- a/src/parser/common/types.ts +++ b/src/parser/common/types.ts @@ -67,3 +67,5 @@ export interface Suggestions { */ readonly keywords: string[]; } + +export type LOCALE_TYPE = 'zh_CN' | 'en_US'; diff --git a/src/parser/flink/flinkEntityCollector.ts b/src/parser/flink/flinkEntityCollector.ts index ea401719..7c0d7faf 100644 --- a/src/parser/flink/flinkEntityCollector.ts +++ b/src/parser/flink/flinkEntityCollector.ts @@ -1,4 +1,3 @@ -import { EntityContextType } from '../common/types'; import { CatalogPathContext, CatalogPathCreateContext, @@ -12,15 +11,18 @@ import { DatabasePathCreateContext, FunctionNameCreateContext, InsertStatementContext, + PhysicalColumnDefinitionContext, QueryStatementContext, SqlStatementContext, TablePathContext, TablePathCreateContext, + TableReferenceContext, ViewPathContext, ViewPathCreateContext, } from '../../lib/flink/FlinkSqlParser'; import { FlinkSqlParserListener } from '../../lib/flink/FlinkSqlParserListener'; -import { StmtContextType, EntityCollector } from '../common/entityCollector'; +import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector'; +import { EntityContextType } from '../common/types'; export class FlinkEntityCollector extends EntityCollector implements FlinkSqlParserListener { /** ====== Entity Begin */ @@ -33,7 +35,12 @@ export class FlinkEntityCollector extends EntityCollector implements FlinkSqlPar } exitDatabasePathCreate(ctx: DatabasePathCreateContext) { - this.pushEntity(ctx, EntityContextType.DATABASE_CREATE); + this.pushEntity(ctx, EntityContextType.DATABASE_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateDatabaseContext.name], + }, + ]); } exitDatabasePath(ctx: DatabasePathContext) { @@ -41,11 +48,28 @@ export class FlinkEntityCollector extends EntityCollector implements FlinkSqlPar } exitTablePath(ctx: TablePathContext) { - this.pushEntity(ctx, EntityContextType.TABLE); + const needCollectAttr = this.getRootStmt()?.stmtContextType === StmtContextType.SELECT_STMT; + this.pushEntity( + ctx, + EntityContextType.TABLE, + needCollectAttr + ? [ + { + attrName: AttrName.alias, + endContextList: [TableReferenceContext.name], + }, + ] + : undefined + ); } exitTablePathCreate(ctx: TablePathCreateContext) { - this.pushEntity(ctx, EntityContextType.TABLE_CREATE); + this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateTableContext.name], + }, + ]); } exitViewPath(ctx: ViewPathContext) { @@ -53,11 +77,25 @@ export class FlinkEntityCollector extends EntityCollector implements FlinkSqlPar } exitViewPathCreate(ctx: ViewPathCreateContext) { - this.pushEntity(ctx, EntityContextType.VIEW_CREATE); + this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateViewContext.name], + }, + ]); } exitColumnNameCreate(ctx: ColumnNameCreateContext) { - this.pushEntity(ctx, EntityContextType.COLUMN_CREATE); + this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [PhysicalColumnDefinitionContext.name], + }, + { + attrName: AttrName.colType, + endContextList: [PhysicalColumnDefinitionContext.name], + }, + ]); } exitFunctionNameCreate(ctx: FunctionNameCreateContext) { diff --git a/src/parser/flink/flinkErrorListener.ts b/src/parser/flink/flinkErrorListener.ts new file mode 100644 index 00000000..61a8a157 --- /dev/null +++ b/src/parser/flink/flinkErrorListener.ts @@ -0,0 +1,76 @@ +import { CodeCompletionCore } from 'antlr4-c3'; +import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener'; +import { Parser, Token } from 'antlr4ng'; +import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser'; +import { LOCALE_TYPE } from '../common/types'; + +export class FlinkErrorListener extends ParseErrorListener { + private preferredRules: Set; + + private objectNames: Map = new Map([ + [FlinkSqlParser.RULE_catalogPath, 'catalog'], + [FlinkSqlParser.RULE_catalogPathCreate, 'catalog'], + [FlinkSqlParser.RULE_databasePath, 'database'], + [FlinkSqlParser.RULE_databasePathCreate, 'database'], + [FlinkSqlParser.RULE_tablePath, 'table'], + [FlinkSqlParser.RULE_tablePathCreate, 'table'], + [FlinkSqlParser.RULE_viewPath, 'view'], + [FlinkSqlParser.RULE_viewPathCreate, 'view'], + [FlinkSqlParser.RULE_functionName, 'function'], + [FlinkSqlParser.RULE_functionNameCreate, 'function'], + [FlinkSqlParser.RULE_columnName, 'column'], + [FlinkSqlParser.RULE_columnNameCreate, 'column'], + ]); + + constructor(errorListener: ErrorListener, preferredRules: Set, locale: LOCALE_TYPE) { + super(errorListener, locale); + this.preferredRules = preferredRules; + } + + public getExpectedText(parser: Parser, token: Token) { + let expectedText = ''; + + let currentContext = parser.context ?? undefined; + while (currentContext?.parent) { + currentContext = currentContext.parent; + } + + const core = new CodeCompletionCore(parser); + core.preferredRules = this.preferredRules; + const candidates = core.collectCandidates(token.tokenIndex, currentContext); + + if (candidates.rules.size) { + const result: string[] = []; + // get expectedText as collect rules first + for (const candidate of candidates.rules) { + const [ruleType] = candidate; + const name = this.objectNames.get(ruleType); + switch (ruleType) { + case FlinkSqlParser.RULE_databasePath: + case FlinkSqlParser.RULE_tablePath: + case FlinkSqlParser.RULE_viewPath: + case FlinkSqlParser.RULE_functionName: + case FlinkSqlParser.RULE_columnName: + case FlinkSqlParser.RULE_catalogPath: { + result.push(`{existing}${name}`); + break; + } + case FlinkSqlParser.RULE_databasePathCreate: + case FlinkSqlParser.RULE_tablePathCreate: + case FlinkSqlParser.RULE_functionNameCreate: + case FlinkSqlParser.RULE_viewPathCreate: + case FlinkSqlParser.RULE_columnNameCreate: + case FlinkSqlParser.RULE_catalogPathCreate: { + result.push(`{new}${name}`); + break; + } + } + } + expectedText = result.join('{or}'); + } + if (candidates.tokens.size) { + expectedText += expectedText ? '{orKeyword}' : '{keyword}'; + } + return expectedText; + } +} diff --git a/src/parser/flink/index.ts b/src/parser/flink/index.ts index eb727986..61d19d22 100644 --- a/src/parser/flink/index.ts +++ b/src/parser/flink/index.ts @@ -7,6 +7,8 @@ import { BasicSQL } from '../common/basicSQL'; import { StmtContextType } from '../common/entityCollector'; import { FlinkSqlSplitListener } from './flinkSplitListener'; import { FlinkEntityCollector } from './flinkEntityCollector'; +import { ErrorListener } from '../common/parseErrorListener'; +import { FlinkErrorListener } from './flinkErrorListener'; export { FlinkSqlSplitListener, FlinkEntityCollector }; @@ -37,6 +39,10 @@ export class FlinkSQL extends BasicSQL; + + private objectNames: Map = new Map([ + [HiveSqlParser.RULE_dbSchemaName, 'database'], + [HiveSqlParser.RULE_dbSchemaNameCreate, 'database'], + [HiveSqlParser.RULE_tableName, 'table'], + [HiveSqlParser.RULE_tableNameCreate, 'table'], + [HiveSqlParser.RULE_viewName, 'view'], + [HiveSqlParser.RULE_viewNameCreate, 'view'], + [HiveSqlParser.RULE_functionNameForDDL, 'function'], + [HiveSqlParser.RULE_functionNameForInvoke, 'function'], + [HiveSqlParser.RULE_functionNameCreate, 'function'], + [HiveSqlParser.RULE_columnName, 'column'], + [HiveSqlParser.RULE_columnNameCreate, 'column'], + ]); + + constructor(errorListener: ErrorListener, preferredRules: Set, locale: LOCALE_TYPE) { + super(errorListener, locale); + this.preferredRules = preferredRules; + } + + public getExpectedText(parser: Parser, token: Token) { + let expectedText = ''; + + let currentContext = parser.context ?? undefined; + while (currentContext?.parent) { + currentContext = currentContext.parent; + } + + const core = new CodeCompletionCore(parser); + core.preferredRules = this.preferredRules; + const candidates = core.collectCandidates(token.tokenIndex, currentContext); + + if (candidates.rules.size) { + const result: string[] = []; + // get expectedText as collect rules first + for (const candidate of candidates.rules) { + const [ruleType] = candidate; + const name = this.objectNames.get(ruleType); + switch (ruleType) { + case HiveSqlParser.RULE_dbSchemaName: + case HiveSqlParser.RULE_tableName: + case HiveSqlParser.RULE_viewName: + case HiveSqlParser.RULE_functionNameForDDL: + case HiveSqlParser.RULE_functionNameForInvoke: + case HiveSqlParser.RULE_columnName: { + result.push(`{existing}${name}`); + break; + } + case HiveSqlParser.RULE_dbSchemaNameCreate: + case HiveSqlParser.RULE_tableNameCreate: + case HiveSqlParser.RULE_functionNameCreate: + case HiveSqlParser.RULE_viewNameCreate: + case HiveSqlParser.RULE_columnNameCreate: { + result.push(`{new}${name}`); + break; + } + } + } + expectedText = result.join('{or}'); + } + if (candidates.tokens.size) { + expectedText += expectedText ? '{orKeyword}' : '{keyword}'; + } + return expectedText; + } +} diff --git a/src/parser/hive/index.ts b/src/parser/hive/index.ts index c0c1c8ba..7bac2468 100644 --- a/src/parser/hive/index.ts +++ b/src/parser/hive/index.ts @@ -8,6 +8,8 @@ import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/type import { StmtContextType } from '../common/entityCollector'; import { HiveSqlSplitListener } from './hiveSplitListener'; import { HiveEntityCollector } from './hiveEntityCollector'; +import { ErrorListener } from '../common/parseErrorListener'; +import { HiveErrorListener } from './hiveErrorListener'; export { HiveEntityCollector, HiveSqlSplitListener }; @@ -38,6 +40,10 @@ export class HiveSQL extends BasicSQL; + + private objectNames: Map = new Map([ + [ImpalaSqlParser.RULE_databaseNamePath, 'database'], + [ImpalaSqlParser.RULE_databaseNameCreate, 'database'], + [ImpalaSqlParser.RULE_tableNamePath, 'table'], + [ImpalaSqlParser.RULE_tableNameCreate, 'table'], + [ImpalaSqlParser.RULE_viewNamePath, 'view'], + [ImpalaSqlParser.RULE_viewNameCreate, 'view'], + [ImpalaSqlParser.RULE_functionNamePath, 'function'], + [ImpalaSqlParser.RULE_functionNameCreate, 'function'], + [ImpalaSqlParser.RULE_columnNamePath, 'column'], + [ImpalaSqlParser.RULE_columnNamePathCreate, 'column'], + ]); + + constructor(errorListener: ErrorListener, preferredRules: Set, locale: LOCALE_TYPE) { + super(errorListener, locale); + this.preferredRules = preferredRules; + } + + public getExpectedText(parser: Parser, token: Token) { + let expectedText = ''; + + let currentContext = parser.context ?? undefined; + while (currentContext?.parent) { + currentContext = currentContext.parent; + } + + const core = new CodeCompletionCore(parser); + core.preferredRules = this.preferredRules; + const candidates = core.collectCandidates(token.tokenIndex, currentContext); + + if (candidates.rules.size) { + const result: string[] = []; + // get expectedText as collect rules first + for (const candidate of candidates.rules) { + const [ruleType] = candidate; + const name = this.objectNames.get(ruleType); + switch (ruleType) { + case ImpalaSqlParser.RULE_databaseNamePath: + case ImpalaSqlParser.RULE_tableNamePath: + case ImpalaSqlParser.RULE_functionNamePath: + case ImpalaSqlParser.RULE_viewNamePath: + case ImpalaSqlParser.RULE_columnNamePath: { + result.push(`{existing}${name}`); + break; + } + case ImpalaSqlParser.RULE_databaseNameCreate: + case ImpalaSqlParser.RULE_tableNameCreate: + case ImpalaSqlParser.RULE_functionNameCreate: + case ImpalaSqlParser.RULE_viewNameCreate: + case ImpalaSqlParser.RULE_columnNamePathCreate: { + result.push(`{new}${name}`); + break; + } + } + } + expectedText = result.join(`{or}`); + } + if (candidates.tokens.size) { + expectedText += expectedText ? '{orKeyword}' : '{keyword}'; + } + return expectedText; + } +} diff --git a/src/parser/impala/impalaEntityCollector.ts b/src/parser/impala/impalaEntityCollector.ts index 3644afbc..0bf4cd0b 100644 --- a/src/parser/impala/impalaEntityCollector.ts +++ b/src/parser/impala/impalaEntityCollector.ts @@ -1,5 +1,6 @@ import { ImpalaSqlParserListener } from '../../lib'; import { + ColumnDefinitionContext, ColumnNamePathCreateContext, CreateAggregateFunctionContext, CreateFunctionContext, @@ -12,32 +13,77 @@ import { DatabaseNamePathContext, FunctionNameCreateContext, InsertStatementContext, + KuduTableElementContext, QueryStatementContext, + SampledRelationContext, SingleStatementContext, TableNameCreateContext, TableNamePathContext, + ViewColumnItemContext, ViewNameCreateContext, ViewNamePathContext, } from '../../lib/impala/ImpalaSqlParser'; +import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector'; import { EntityContextType } from '../common/types'; -import { StmtContextType, EntityCollector } from '../common/entityCollector'; export class ImpalaEntityCollector extends EntityCollector implements ImpalaSqlParserListener { /** ===== Entity begin */ exitTableNameCreate(ctx: TableNameCreateContext) { - this.pushEntity(ctx, EntityContextType.TABLE_CREATE); + this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [ + CreateTableSelectContext.name, + CreateKuduTableAsSelectContext.name, + ], + }, + ]); } exitTableNamePath(ctx: TableNamePathContext) { - this.pushEntity(ctx, EntityContextType.TABLE); + const needCollectAttr = this.getRootStmt()?.stmtContextType === StmtContextType.SELECT_STMT; + this.pushEntity( + ctx, + EntityContextType.TABLE, + needCollectAttr + ? [ + { + attrName: AttrName.alias, + endContextList: [SampledRelationContext.name], + }, + ] + : undefined + ); } exitColumnNamePathCreate(ctx: ColumnNamePathCreateContext) { - this.pushEntity(ctx, EntityContextType.COLUMN_CREATE); + this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [ + ColumnDefinitionContext.name, + KuduTableElementContext.name, + ViewColumnItemContext.name, + ], + }, + { + attrName: AttrName.colType, + endContextList: [ + ColumnDefinitionContext.name, + KuduTableElementContext.name, + ViewColumnItemContext.name, + ], + }, + ]); } exitViewNameCreate(ctx: ViewNameCreateContext) { - this.pushEntity(ctx, EntityContextType.VIEW_CREATE); + this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateViewContext.name], + }, + ]); } exitViewNamePath(ctx: ViewNamePathContext) { @@ -49,7 +95,12 @@ export class ImpalaEntityCollector extends EntityCollector implements ImpalaSqlP } exitDatabaseNameCreate(ctx: DatabaseNameCreateContext) { - this.pushEntity(ctx, EntityContextType.DATABASE_CREATE); + this.pushEntity(ctx, EntityContextType.DATABASE_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateSchemaContext.name], + }, + ]); } exitFunctionNameCreate(ctx: FunctionNameCreateContext) { diff --git a/src/parser/impala/index.ts b/src/parser/impala/index.ts index 5afb965a..9902507e 100644 --- a/src/parser/impala/index.ts +++ b/src/parser/impala/index.ts @@ -7,6 +7,8 @@ import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/type import { StmtContextType } from '../common/entityCollector'; import { ImpalaSqlSplitListener } from './impalaSplitListener'; import { ImpalaEntityCollector } from './impalaEntityCollector'; +import { ErrorListener } from '../common/parseErrorListener'; +import { ImpalaErrorListener } from './ImpalaErrorListener'; export { ImpalaEntityCollector, ImpalaSqlSplitListener }; @@ -36,6 +38,10 @@ export class ImpalaSQL extends BasicSQL { return new MysqlSplitListener(); } + protected createErrorListener(_errorListener: ErrorListener) { + return new MysqlErrorListener(_errorListener, this.preferredRules, this.locale); + } + protected createEntityCollector(input: string, caretTokenIndex?: number) { return new MySqlEntityCollector(input, caretTokenIndex); } diff --git a/src/parser/mysql/mysqlEntityCollector.ts b/src/parser/mysql/mysqlEntityCollector.ts index 36ffc9bb..92b5bd0d 100644 --- a/src/parser/mysql/mysqlEntityCollector.ts +++ b/src/parser/mysql/mysqlEntityCollector.ts @@ -1,8 +1,9 @@ -import type { +import { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, + CreateDefinitionContext, CreateFunctionContext, CreateFunctionLoadableContext, CreateViewContext, @@ -15,12 +16,13 @@ import type { SingleStatementContext, TableNameContext, TableNameCreateContext, + TableSourceContext, ViewNameContext, ViewNameCreateContext, } from '../../lib/mysql/MySqlParser'; import type { MySqlParserListener } from '../../lib/mysql/MySqlParserListener'; +import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector'; import { EntityContextType } from '../common/types'; -import { StmtContextType, EntityCollector } from '../common/entityCollector'; export class MySqlEntityCollector extends EntityCollector implements MySqlParserListener { /** ====== Entity Begin */ @@ -33,11 +35,28 @@ export class MySqlEntityCollector extends EntityCollector implements MySqlParser } exitTableName(ctx: TableNameContext) { - this.pushEntity(ctx, EntityContextType.TABLE); + const needCollectAttr = this.getRootStmt()?.stmtContextType === StmtContextType.SELECT_STMT; + this.pushEntity( + ctx, + EntityContextType.TABLE, + needCollectAttr + ? [ + { + attrName: AttrName.alias, + endContextList: [TableSourceContext.name], + }, + ] + : undefined + ); } exitTableNameCreate(ctx: TableNameCreateContext) { - this.pushEntity(ctx, EntityContextType.TABLE_CREATE); + this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [ColumnCreateTableContext.name], + }, + ]); } exitViewName(ctx: ViewNameContext) { @@ -49,11 +68,25 @@ export class MySqlEntityCollector extends EntityCollector implements MySqlParser } exitFunctionNameCreate(ctx: FunctionNameCreateContext) { - this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE); + this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateFunctionContext.name], + }, + ]); } exitColumnNameCreate(ctx: ColumnNameCreateContext) { - this.pushEntity(ctx, EntityContextType.COLUMN_CREATE); + this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateDefinitionContext.name], + }, + { + attrName: AttrName.colType, + endContextList: [CreateDefinitionContext.name], + }, + ]); } /** ===== Statement begin */ diff --git a/src/parser/mysql/mysqlErrorListener.ts b/src/parser/mysql/mysqlErrorListener.ts new file mode 100644 index 00000000..ba6c1440 --- /dev/null +++ b/src/parser/mysql/mysqlErrorListener.ts @@ -0,0 +1,72 @@ +import { CodeCompletionCore } from 'antlr4-c3'; +import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener'; +import { Parser, Token } from 'antlr4ng'; +import { MySqlParser } from '../../lib/mysql/MySqlParser'; +import { LOCALE_TYPE } from '../common/types'; + +export class MysqlErrorListener extends ParseErrorListener { + private preferredRules: Set; + + private objectNames: Map = new Map([ + [MySqlParser.RULE_databaseName, 'database'], + [MySqlParser.RULE_databaseNameCreate, 'database'], + [MySqlParser.RULE_tableName, 'table'], + [MySqlParser.RULE_tableNameCreate, 'table'], + [MySqlParser.RULE_viewName, 'view'], + [MySqlParser.RULE_viewNameCreate, 'view'], + [MySqlParser.RULE_functionName, 'function'], + [MySqlParser.RULE_functionNameCreate, 'function'], + [MySqlParser.RULE_columnName, 'column'], + [MySqlParser.RULE_columnNameCreate, 'column'], + ]); + + constructor(errorListener: ErrorListener, preferredRules: Set, locale: LOCALE_TYPE) { + super(errorListener, locale); + this.preferredRules = preferredRules; + } + + public getExpectedText(parser: Parser, token: Token) { + let expectedText = ''; + + let currentContext = parser.context ?? undefined; + while (currentContext?.parent) { + currentContext = currentContext.parent; + } + + const core = new CodeCompletionCore(parser); + core.preferredRules = this.preferredRules; + const candidates = core.collectCandidates(token.tokenIndex, currentContext); + + if (candidates.rules.size) { + const result: string[] = []; + // get expectedText as collect rules first + for (const candidate of candidates.rules) { + const [ruleType] = candidate; + const name = this.objectNames.get(ruleType); + switch (ruleType) { + case MySqlParser.RULE_databaseName: + case MySqlParser.RULE_tableName: + case MySqlParser.RULE_functionName: + case MySqlParser.RULE_viewName: + case MySqlParser.RULE_columnName: { + result.push(`{existing}${name}`); + break; + } + case MySqlParser.RULE_databaseNameCreate: + case MySqlParser.RULE_tableNameCreate: + case MySqlParser.RULE_functionNameCreate: + case MySqlParser.RULE_viewNameCreate: + case MySqlParser.RULE_columnNameCreate: { + result.push(`{new}${name}`); + break; + } + } + } + expectedText = result.join(`{or}`); + } + if (candidates.tokens.size) { + expectedText += expectedText ? '{orKeyword}' : '{keyword}'; + } + return expectedText; + } +} diff --git a/src/parser/postgresql/index.ts b/src/parser/postgresql/index.ts index 4da31c7b..63820000 100644 --- a/src/parser/postgresql/index.ts +++ b/src/parser/postgresql/index.ts @@ -8,6 +8,8 @@ import { BasicSQL } from '../common/basicSQL'; import { StmtContextType } from '../common/entityCollector'; import { PostgreSqlEntityCollector } from './postgreEntityCollector'; import { PostgreSqlSplitListener } from './postgreSplitListener'; +import { ErrorListener } from '../common/parseErrorListener'; +import { PostgreSqlErrorListener } from './postgreErrorListener'; export { PostgreSqlEntityCollector, PostgreSqlSplitListener }; @@ -41,6 +43,10 @@ export class PostgreSQL extends BasicSQL; + + private objectNames: Map = new Map([ + [PostgreSqlParser.RULE_database_name, 'database'], + [PostgreSqlParser.RULE_database_name_create, 'database'], + [PostgreSqlParser.RULE_table_name, 'table'], + [PostgreSqlParser.RULE_table_name_create, 'table'], + [PostgreSqlParser.RULE_view_name, 'view'], + [PostgreSqlParser.RULE_view_name_create, 'view'], + [PostgreSqlParser.RULE_function_name, 'function'], + [PostgreSqlParser.RULE_function_name_create, 'function'], + [PostgreSqlParser.RULE_column_name, 'column'], + [PostgreSqlParser.RULE_column_name_create, 'column'], + [PostgreSqlParser.RULE_schema_name_create, 'schema'], + [PostgreSqlParser.RULE_schema_name, 'schema'], + [PostgreSqlParser.RULE_procedure_name_create, 'procedure'], + [PostgreSqlParser.RULE_procedure_name, 'procedure'], + ]); + + constructor(errorListener: ErrorListener, preferredRules: Set, locale: LOCALE_TYPE) { + super(errorListener, locale); + this.preferredRules = preferredRules; + } + + public getExpectedText(parser: Parser, token: Token) { + let expectedText = ''; + + let currentContext = parser.context ?? undefined; + while (currentContext?.parent) { + currentContext = currentContext.parent; + } + + const core = new CodeCompletionCore(parser); + core.preferredRules = this.preferredRules; + const candidates = core.collectCandidates(token.tokenIndex, currentContext); + + if (candidates.rules.size) { + const result: string[] = []; + // get expectedText as collect rules first + for (const candidate of candidates.rules) { + const [ruleType] = candidate; + const name = this.objectNames.get(ruleType); + switch (ruleType) { + case PostgreSqlParser.RULE_table_name: + case PostgreSqlParser.RULE_function_name: + case PostgreSqlParser.RULE_schema_name: + case PostgreSqlParser.RULE_view_name: + case PostgreSqlParser.RULE_database_name: + case PostgreSqlParser.RULE_procedure_name: + case PostgreSqlParser.RULE_column_name: { + result.push(`{existing}${name}`); + break; + } + case PostgreSqlParser.RULE_table_name_create: + case PostgreSqlParser.RULE_function_name_create: + case PostgreSqlParser.RULE_schema_name_create: + case PostgreSqlParser.RULE_view_name_create: + case PostgreSqlParser.RULE_database_name_create: + case PostgreSqlParser.RULE_procedure_name_create: + case PostgreSqlParser.RULE_column_name_create: { + result.push(`{new}${name}`); + break; + } + } + } + expectedText = result.join('{or}'); + } + if (candidates.tokens.size) { + expectedText += expectedText ? '{orKeyword}' : '{keyword}'; + } + return expectedText; + } +} diff --git a/src/parser/spark/index.ts b/src/parser/spark/index.ts index afbe5585..1b847fd8 100644 --- a/src/parser/spark/index.ts +++ b/src/parser/spark/index.ts @@ -7,6 +7,8 @@ import { Suggestions, EntityContextType, SyntaxSuggestion } from '../common/type import { StmtContextType } from '../common/entityCollector'; import { SparkSqlSplitListener } from './sparkSplitListener'; import { SparkEntityCollector } from './sparkEntityCollector'; +import { SparkErrorListener } from './sparkErrorListener'; +import { ErrorListener } from '../common/parseErrorListener'; export { SparkSqlSplitListener, SparkEntityCollector }; @@ -36,6 +38,10 @@ export class SparkSQL extends BasicSQL; + + private objectNames: Map = new Map([ + [SparkSqlParser.RULE_namespaceName, 'namespace'], + [SparkSqlParser.RULE_namespaceNameCreate, 'namespace'], + [SparkSqlParser.RULE_tableName, 'table'], + [SparkSqlParser.RULE_tableNameCreate, 'table'], + [SparkSqlParser.RULE_viewName, 'view'], + [SparkSqlParser.RULE_viewNameCreate, 'view'], + [SparkSqlParser.RULE_functionName, 'function'], + [SparkSqlParser.RULE_functionNameCreate, 'function'], + [SparkSqlParser.RULE_columnName, 'column'], + [SparkSqlParser.RULE_columnNameCreate, 'column'], + ]); + + constructor(errorListener: ErrorListener, preferredRules: Set, locale: LOCALE_TYPE) { + super(errorListener, locale); + this.preferredRules = preferredRules; + } + + public getExpectedText(parser: Parser, token: Token) { + let expectedText = ''; + + let currentContext = parser.context ?? undefined; + while (currentContext?.parent) { + currentContext = currentContext.parent; + } + + const core = new CodeCompletionCore(parser); + core.preferredRules = this.preferredRules; + const candidates = core.collectCandidates(token.tokenIndex, currentContext); + + if (candidates.rules.size) { + const result = []; + // get expectedText as collect rules first + for (const candidate of candidates.rules) { + const [ruleType] = candidate; + const name = this.objectNames.get(ruleType); + switch (ruleType) { + case SparkSqlParser.RULE_namespaceName: + case SparkSqlParser.RULE_tableName: + case SparkSqlParser.RULE_viewName: + case SparkSqlParser.RULE_functionName: + case SparkSqlParser.RULE_columnName: { + result.push(`{existing}${name}`); + break; + } + case SparkSqlParser.RULE_namespaceNameCreate: + case SparkSqlParser.RULE_tableNameCreate: + case SparkSqlParser.RULE_functionNameCreate: + case SparkSqlParser.RULE_viewNameCreate: + case SparkSqlParser.RULE_columnNameCreate: { + result.push(`{new}${name}`); + break; + } + } + } + expectedText = result.join('{or}'); + } + if (candidates.tokens.size) { + expectedText += expectedText ? '{orKeyword}' : '{keyword}'; + } + return expectedText; + } +} diff --git a/src/parser/sql/index.ts b/src/parser/sql/index.ts new file mode 100644 index 00000000..4d39560d --- /dev/null +++ b/src/parser/sql/index.ts @@ -0,0 +1,137 @@ +import { CharStream, CommonTokenStream, Token } from 'antlr4ng'; +import { CandidatesCollection } from 'antlr4-c3'; +import { SqlLexer } from '../../lib/sql/SqlLexer'; +import { SqlParser, ProgramContext } from '../../lib/sql/SqlParser'; +import { BasicSQL } from '../common/basicSQL'; +import { Suggestions, EntityContextType, SyntaxSuggestion } from '../common/types'; +import { StmtContextType } from '../common/entityCollector'; +import { SqlSplitListener } from './sqlSplitListener'; +import { SqlEntityCollector } from './sqlEntityCollector'; +import { SqlErrorListener } from './sqlErrorListener'; +import { ErrorListener } from '../common/parseErrorListener'; + +export { SqlSplitListener, SqlEntityCollector }; + +export class Sql extends BasicSQL { + protected createLexerFromCharStream(charStreams: CharStream) { + return new SqlLexer(charStreams); + } + + protected createParserFromTokenStream(tokenStream: CommonTokenStream) { + return new SqlParser(tokenStream); + } + + protected preferredRules: Set = new Set([ + SqlParser.RULE_namespaceName, + SqlParser.RULE_namespaceNameCreate, + SqlParser.RULE_tableName, + SqlParser.RULE_tableNameCreate, + SqlParser.RULE_viewName, + SqlParser.RULE_viewNameCreate, + SqlParser.RULE_functionName, + SqlParser.RULE_functionNameCreate, + SqlParser.RULE_columnName, + SqlParser.RULE_columnNameCreate, + ]); + + protected get splitListener() { + return new SqlSplitListener(); + } + + protected createErrorListener(_errorListener: ErrorListener) { + return new SqlErrorListener(_errorListener, this.preferredRules, this.locale); + } + + protected createEntityCollector(input: string, caretTokenIndex?: number) { + return new SqlEntityCollector(input, caretTokenIndex); + } + + protected processCandidates( + candidates: CandidatesCollection, + allTokens: Token[], + caretTokenIndex: number, + tokenIndexOffset: number + ): Suggestions { + const originalSyntaxSuggestions: SyntaxSuggestion[] = []; + const keywords: string[] = []; + + for (const candidate of candidates.rules) { + const [ruleType, candidateRule] = candidate; + const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset; + const tokenRanges = allTokens.slice( + startTokenIndex, + caretTokenIndex + tokenIndexOffset + 1 + ); + + let syntaxContextType: EntityContextType | StmtContextType | undefined = void 0; + switch (ruleType) { + case SqlParser.RULE_namespaceName: { + syntaxContextType = EntityContextType.DATABASE; + break; + } + case SqlParser.RULE_namespaceNameCreate: { + syntaxContextType = EntityContextType.DATABASE_CREATE; + break; + } + case SqlParser.RULE_tableName: { + syntaxContextType = EntityContextType.TABLE; + break; + } + case SqlParser.RULE_tableNameCreate: { + syntaxContextType = EntityContextType.TABLE_CREATE; + break; + } + case SqlParser.RULE_viewName: { + syntaxContextType = EntityContextType.VIEW; + break; + } + case SqlParser.RULE_viewNameCreate: { + syntaxContextType = EntityContextType.VIEW_CREATE; + break; + } + case SqlParser.RULE_functionName: { + syntaxContextType = EntityContextType.FUNCTION; + break; + } + case SqlParser.RULE_functionNameCreate: { + syntaxContextType = EntityContextType.FUNCTION_CREATE; + break; + } + case SqlParser.RULE_columnName: { + syntaxContextType = EntityContextType.COLUMN; + break; + } + case SqlParser.RULE_columnNameCreate: { + syntaxContextType = EntityContextType.COLUMN_CREATE; + break; + } + default: + break; + } + + if (syntaxContextType) { + originalSyntaxSuggestions.push({ + syntaxContextType, + wordRanges: tokenRanges, + }); + } + } + + for (const candidate of candidates.tokens) { + const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]); + const displayName = this._parser.vocabulary.getDisplayName(candidate[0]); + if (displayName && symbolicName && symbolicName.startsWith('KW_')) { + const keyword = + displayName.startsWith("'") && displayName.endsWith("'") + ? displayName.slice(1, -1) + : displayName; + keywords.push(keyword); + } + } + + return { + syntax: originalSyntaxSuggestions, + keywords, + }; + } +} diff --git a/src/parser/sql/sqlEntityCollector.ts b/src/parser/sql/sqlEntityCollector.ts new file mode 100644 index 00000000..22e17d07 --- /dev/null +++ b/src/parser/sql/sqlEntityCollector.ts @@ -0,0 +1,190 @@ +import { + ColumnNameCreateContext, + CreateFunctionContext, + CreateNamespaceContext, + CreateOrReplaceTableColTypeContext, + CreateTableContext, + CreateTableLikeContext, + CreateTempViewUsingContext, + CreateViewContext, + FunctionNameCreateContext, + IdentifierCommentContext, + InsertFromQueryContext, + MultipleInsertContext, + NamespaceNameContext, + NamespaceNameCreateContext, + QueryStatementContext, + RelationPrimaryContext, + ReplaceTableContext, + SingleStatementContext, + TableNameContext, + TableNameCreateContext, + ViewNameContext, + ViewNameCreateContext, +} from '../../lib/sql/SqlParser'; +import type { SqlParserListener } from '../../lib/sql/SqlParserListener'; +import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector'; +import { EntityContextType } from '../common/types'; + +export class SqlEntityCollector extends EntityCollector implements SqlParserListener { + /** ====== Entity Begin */ + exitNamespaceName(ctx: NamespaceNameContext) { + this.pushEntity(ctx, EntityContextType.DATABASE); + } + + exitNamespaceNameCreate(ctx: NamespaceNameCreateContext) { + this.pushEntity(ctx, EntityContextType.DATABASE_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateNamespaceContext.name], + }, + ]); + } + + exitTableName(ctx: TableNameContext) { + const needCollectAttr = this.getRootStmt()?.stmtContextType === StmtContextType.SELECT_STMT; + this.pushEntity( + ctx, + EntityContextType.TABLE, + needCollectAttr + ? [ + { + attrName: AttrName.alias, + endContextList: [RelationPrimaryContext.name], + }, + ] + : undefined + ); + } + + exitTableNameCreate(ctx: TableNameCreateContext) { + this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateTableContext.name], + }, + ]); + } + + exitViewName(ctx: ViewNameContext) { + this.pushEntity(ctx, EntityContextType.VIEW); + } + + exitViewNameCreate(ctx: ViewNameCreateContext) { + this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [CreateViewContext.name], + }, + ]); + } + + exitFunctionNameCreate(ctx: FunctionNameCreateContext) { + this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE); + } + + exitColumnNameCreate(ctx: ColumnNameCreateContext) { + this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [ + { + attrName: AttrName.comment, + endContextList: [ + CreateOrReplaceTableColTypeContext.name, + IdentifierCommentContext.name, + ], + }, + { + attrName: AttrName.colType, + endContextList: [CreateOrReplaceTableColTypeContext.name], + }, + ]); + } + + /** ===== Statement begin */ + enterSingleStatement(ctx: SingleStatementContext) { + this.pushStmt(ctx, StmtContextType.COMMON_STMT); + } + + exitSingleStatement(ctx: SingleStatementContext) { + this.popStmt(); + } + + enterCreateTable(ctx: CreateTableContext) { + this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT); + } + + exitCreateTable(ctx: CreateTableContext) { + this.popStmt(); + } + + enterCreateTableLike(ctx: CreateTableLikeContext) { + this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT); + } + + exitCreateTableLike(ctx: CreateTableLikeContext) { + this.popStmt(); + } + + enterReplaceTable(ctx: ReplaceTableContext) { + this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT); + } + + exitReplaceTable(ctx: ReplaceTableContext) { + this.popStmt(); + } + + enterCreateView(ctx: CreateViewContext) { + this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT); + } + + exitCreateView(ctx: CreateViewContext) { + this.popStmt(); + } + + enterCreateTempViewUsing(ctx: CreateTempViewUsingContext) { + this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT); + } + + exitCreateTempViewUsing(ctx: CreateTempViewUsingContext) { + this.popStmt(); + } + + enterQueryStatement(ctx: QueryStatementContext) { + this.pushStmt(ctx, StmtContextType.SELECT_STMT); + } + + exitQueryStatement(ctx: QueryStatementContext) { + this.popStmt(); + } + + enterInsertFromQuery(ctx: InsertFromQueryContext) { + this.pushStmt(ctx, StmtContextType.INSERT_STMT); + } + + exitInsertFromQuery(ctx: InsertFromQueryContext) { + this.popStmt(); + } + + enterMultipleInsert(ctx: MultipleInsertContext) { + this.pushStmt(ctx, StmtContextType.INSERT_STMT); + } + + exitMultipleInsert(ctx: MultipleInsertContext) { + this.popStmt(); + } + + enterCreateNamespace(ctx: CreateNamespaceContext) { + this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT); + } + + exitCreateNamespace(ctx: CreateNamespaceContext) { + this.popStmt(); + } + + enterCreateFunction(ctx: CreateFunctionContext) { + this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT); + } + + exitCreateFunction(ctx: CreateFunctionContext) { + this.popStmt(); + } +} diff --git a/src/parser/sql/sqlErrorListener.ts b/src/parser/sql/sqlErrorListener.ts new file mode 100644 index 00000000..95825e97 --- /dev/null +++ b/src/parser/sql/sqlErrorListener.ts @@ -0,0 +1,72 @@ +import { CodeCompletionCore } from 'antlr4-c3'; +import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener'; +import { Parser, Token } from 'antlr4ng'; +import { SqlParser } from '../../lib/sql/SqlParser'; +import { LOCALE_TYPE } from '../common/types'; + +export class SqlErrorListener extends ParseErrorListener { + private preferredRules: Set; + + private objectNames: Map = new Map([ + [SqlParser.RULE_namespaceName, 'namespace'], + [SqlParser.RULE_namespaceNameCreate, 'namespace'], + [SqlParser.RULE_tableName, 'table'], + [SqlParser.RULE_tableNameCreate, 'table'], + [SqlParser.RULE_viewName, 'view'], + [SqlParser.RULE_viewNameCreate, 'view'], + [SqlParser.RULE_functionName, 'function'], + [SqlParser.RULE_functionNameCreate, 'function'], + [SqlParser.RULE_columnName, 'column'], + [SqlParser.RULE_columnNameCreate, 'column'], + ]); + + constructor(errorListener: ErrorListener, preferredRules: Set, locale: LOCALE_TYPE) { + super(errorListener, locale); + this.preferredRules = preferredRules; + } + + public getExpectedText(parser: Parser, token: Token) { + let expectedText = ''; + + let currentContext = parser.context ?? undefined; + while (currentContext?.parent) { + currentContext = currentContext.parent; + } + + const core = new CodeCompletionCore(parser); + core.preferredRules = this.preferredRules; + const candidates = core.collectCandidates(token.tokenIndex, currentContext); + + if (candidates.rules.size) { + const result = []; + // get expectedText as collect rules first + for (const candidate of candidates.rules) { + const [ruleType] = candidate; + const name = this.objectNames.get(ruleType); + switch (ruleType) { + case SqlParser.RULE_namespaceName: + case SqlParser.RULE_tableName: + case SqlParser.RULE_viewName: + case SqlParser.RULE_functionName: + case SqlParser.RULE_columnName: { + result.push(`{existing}${name}`); + break; + } + case SqlParser.RULE_namespaceNameCreate: + case SqlParser.RULE_tableNameCreate: + case SqlParser.RULE_functionNameCreate: + case SqlParser.RULE_viewNameCreate: + case SqlParser.RULE_columnNameCreate: { + result.push(`{new}${name}`); + break; + } + } + } + expectedText = result.join('{or}'); + } + if (candidates.tokens.size) { + expectedText += expectedText ? '{orKeyword}' : '{keyword}'; + } + return expectedText; + } +} diff --git a/src/parser/sql/sqlSplitListener.ts b/src/parser/sql/sqlSplitListener.ts new file mode 100644 index 00000000..ac05209e --- /dev/null +++ b/src/parser/sql/sqlSplitListener.ts @@ -0,0 +1,13 @@ +import { SingleStatementContext } from '../../lib/sql/SqlParser'; + +import { SqlParserListener } from '../../lib/sql/SqlParserListener'; +import { SplitListener } from '../common/splitListener'; + +export class SqlSplitListener + extends SplitListener + implements SqlParserListener +{ + exitSingleStatement(ctx: SingleStatementContext) { + this._statementsContext.push(ctx); + } +} diff --git a/src/parser/trino/index.ts b/src/parser/trino/index.ts index a57958a2..cf1f9db4 100644 --- a/src/parser/trino/index.ts +++ b/src/parser/trino/index.ts @@ -7,6 +7,8 @@ import { Suggestions, EntityContextType, SyntaxSuggestion } from '../common/type import { StmtContextType } from '../common/entityCollector'; import { TrinoSqlSplitListener } from './trinoSplitListener'; import { TrinoEntityCollector } from './trinoEntityCollector'; +import { ErrorListener } from '../common/parseErrorListener'; +import { TrinoErrorListener } from './trinoErrorListener'; export { TrinoSqlSplitListener, TrinoEntityCollector }; @@ -23,6 +25,10 @@ export class TrinoSQL extends BasicSQL; + + private objectNames: Map = new Map([ + [TrinoSqlParser.RULE_catalogRef, 'catalog'], + [TrinoSqlParser.RULE_catalogNameCreate, 'catalog'], + [TrinoSqlParser.RULE_tableRef, 'table'], + [TrinoSqlParser.RULE_tableNameCreate, 'table'], + [TrinoSqlParser.RULE_viewRef, 'view'], + [TrinoSqlParser.RULE_viewNameCreate, 'view'], + [TrinoSqlParser.RULE_schemaRef, 'schema'], + [TrinoSqlParser.RULE_schemaNameCreate, 'schema'], + [TrinoSqlParser.RULE_functionName, 'function'], + [TrinoSqlParser.RULE_columnRef, 'column'], + [TrinoSqlParser.RULE_columnNameCreate, 'column'], + ]); + + constructor(errorListener: ErrorListener, preferredRules: Set, locale: LOCALE_TYPE) { + super(errorListener, locale); + this.preferredRules = preferredRules; + } + + public getExpectedText(parser: Parser, token: Token) { + let expectedText = ''; + + let currentContext = parser.context ?? undefined; + while (currentContext?.parent) { + currentContext = currentContext.parent; + } + + const core = new CodeCompletionCore(parser); + core.preferredRules = this.preferredRules; + const candidates = core.collectCandidates(token.tokenIndex, currentContext); + + if (candidates.rules.size) { + const result: string[] = []; + // get expectedText as collect rules first + for (const candidate of candidates.rules) { + const [ruleType] = candidate; + const name = this.objectNames.get(ruleType); + switch (ruleType) { + case TrinoSqlParser.RULE_catalogRef: + case TrinoSqlParser.RULE_schemaRef: + case TrinoSqlParser.RULE_tableRef: + case TrinoSqlParser.RULE_viewRef: + case TrinoSqlParser.RULE_functionName: + case TrinoSqlParser.RULE_columnRef: { + result.push(`{existing}${name}`); + break; + } + case TrinoSqlParser.RULE_catalogNameCreate: + case TrinoSqlParser.RULE_tableNameCreate: + case TrinoSqlParser.RULE_schemaNameCreate: + case TrinoSqlParser.RULE_viewNameCreate: + case TrinoSqlParser.RULE_tableNameCreate: { + result.push(`{new}${name}`); + break; + } + } + } + expectedText = result.join('{or}'); + } + if (candidates.tokens.size) { + expectedText += expectedText ? '{orKeyword}' : '{keyword}'; + } + return expectedText; + } +} diff --git a/test/jest.d.ts b/test/jest.d.ts index 56a6dcae..ee98c31d 100644 --- a/test/jest.d.ts +++ b/test/jest.d.ts @@ -9,9 +9,9 @@ namespace jest { * Every item must be primitive type, like string, number, etc. * * @example - * expect(['a', 'b']).toMatchUnorderedArrary(['b', 'a']) // pass - * expect(['b', 'a']).toMatchUnorderedArrary(['c', 'b', 'a']) // not pass, missing item 'c' + * expect(['a', 'b']).toMatchUnorderedArray(['b', 'a']) // pass + * expect(['b', 'a']).toMatchUnorderedArray(['c', 'b', 'a']) // not pass, missing item 'c' */ - toMatchUnorderedArrary(expected: unknown[]): R; + toMatchUnorderedArray(expected: unknown[]): R; } } diff --git a/test/matchers.ts b/test/matchers.ts index 66cb5d81..c37ade47 100644 --- a/test/matchers.ts +++ b/test/matchers.ts @@ -1,4 +1,4 @@ -export const toMatchUnorderedArrary: jest.CustomMatcher = function ( +export const toMatchUnorderedArray: jest.CustomMatcher = function ( actual: Array, expected: Array ) { diff --git a/test/parser/flink/contextCollect/entityCollector.test.ts b/test/parser/flink/contextCollect/entityCollector.test.ts index 8f412c9f..622565a3 100644 --- a/test/parser/flink/contextCollect/entityCollector.test.ts +++ b/test/parser/flink/contextCollect/entityCollector.test.ts @@ -1,10 +1,15 @@ +import { ParseTreeListener } from 'antlr4ng'; import fs from 'fs'; import path from 'path'; -import { ParseTreeListener } from 'antlr4ng'; -import { FlinkSQL, FlinkEntityCollector, FlinkSqlSplitListener } from 'src/parser/flink'; import { FlinkSqlParserListener } from 'src/lib/flink/FlinkSqlParserListener'; +import { + AttrName, + isCommonEntityContext, + isFuncEntityContext, + StmtContextType, +} from 'src/parser/common/entityCollector'; import { EntityContextType } from 'src/parser/common/types'; -import { StmtContextType } from 'src/parser/common/entityCollector'; +import { FlinkEntityCollector, FlinkSQL, FlinkSqlSplitListener } from 'src/parser/flink'; const commonSql = fs.readFileSync(path.join(__dirname, 'fixtures', 'common.sql'), 'utf-8'); @@ -49,23 +54,60 @@ describe('Flink entity collector tests', () => { ); expect(tableCreateEntity.belongStmt.position).toEqual({ startIndex: 0, - endIndex: 85, + endIndex: 180, startLine: 1, endLine: 1, startColumn: 1, - endColumn: 87, + endColumn: 182, }); - expect(tableCreateEntity.relatedEntities).toBeNull(); - - expect(tableCreateEntity.columns.length).toBe(2); - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'test table comment ABC.'", + startIndex: 78, + endIndex: 102, + line: 1, + startColumn: 79, + endColumn: 104, }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).toBeNull(); + + expect(tableCreateEntity.columns?.length).toBe(2); + tableCreateEntity.columns?.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.columns[0][AttrName.comment]).toEqual({ + text: "'col1'", + startIndex: 47, + endIndex: 52, + line: 1, + startColumn: 48, + endColumn: 54, + }); + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'BIGINT', + startIndex: 32, + endIndex: 37, + line: 1, + startColumn: 33, + endColumn: 39, + }); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'STRING', + startIndex: 62, + endIndex: 67, + line: 1, + startColumn: 63, + endColumn: 69, + }); + } }); test('create table as select', () => { @@ -83,8 +125,8 @@ describe('Flink entity collector tests', () => { expect(tableCreateEntity.entityContextType).toBe(EntityContextType.TABLE_CREATE); expect(tableCreateEntity.text).toBe('my_ctas_table'); expect(tableCreateEntity.position).toEqual({ - startIndex: 102, - endIndex: 114, + startIndex: 197, + endIndex: 209, line: 3, startColumn: 14, endColumn: 27, @@ -94,27 +136,26 @@ describe('Flink entity collector tests', () => { StmtContextType.CREATE_TABLE_STMT ); expect(tableCreateEntity.belongStmt.position).toEqual({ - startIndex: 89, - endIndex: 228, + startIndex: 184, + endIndex: 323, startLine: 3, endLine: 11, startColumn: 1, endColumn: 20, }); - - expect(tableCreateEntity.columns).toBeNull(); - - expect(tableCreateEntity.relatedEntities.length).toBe(1); - tableCreateEntity.relatedEntities.forEach((relatedEntity) => { - expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); - expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); - }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities.length).toBe(1); + tableCreateEntity.relatedEntities.forEach((relatedEntity) => { + expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); + }); + } expect(allEntities[1].text).toBe('source_table'); expect(allEntities[1].belongStmt.rootStmt).toBe(allEntities[0].belongStmt); expect(allEntities[1].position).toEqual({ - startIndex: 191, - endIndex: 202, + startIndex: 286, + endIndex: 297, line: 9, startColumn: 5, endColumn: 17, @@ -140,14 +181,15 @@ describe('Flink entity collector tests', () => { StmtContextType.CREATE_TABLE_STMT ); - expect(tableCreateEntity.columns.length).toBe(1); - expect(tableCreateEntity.columns[0].text).toBe('id'); - expect(tableCreateEntity.columns[0].entityContextType).toBe( - EntityContextType.COLUMN_CREATE - ); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); - + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns.length).toBe(1); + expect(tableCreateEntity.columns[0].text).toBe('id'); + expect(tableCreateEntity.columns[0].entityContextType).toBe( + EntityContextType.COLUMN_CREATE + ); + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); + } expect(originTableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(originTableEntity.text).toBe('Orders_in_file'); expect(originTableEntity.belongStmt).toBe(tableCreateEntity.belongStmt); @@ -160,16 +202,41 @@ describe('Flink entity collector tests', () => { const allEntities = collectListener.getEntities(); - expect(allEntities.length).toBe(1); + expect(allEntities.length).toBe(2); const tableEntity = allEntities[0]; - + const tableEntity1 = allEntities[1]; expect(tableEntity.entityContextType).toBe(EntityContextType.TABLE); - expect(tableEntity.text).toBe('Orders'); - expect(tableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(tableEntity.text).toBe('Order1'); + expect(tableEntity[AttrName.alias]).toEqual({ + text: 'o1', + startIndex: 616, + endIndex: 617, + line: 23, + startColumn: 54, + endColumn: 56, + }); - expect(tableEntity.columns).toBeNull(); - expect(tableEntity.relatedEntities).toBeNull(); + expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + if (isCommonEntityContext(tableEntity1)) { + expect(tableEntity1.columns).toBeUndefined(); + expect(tableEntity1.relatedEntities).toBeNull(); + } + expect(tableEntity1.entityContextType).toBe(EntityContextType.TABLE); + expect(tableEntity1.text).toBe('Order2'); + expect(tableEntity1[AttrName.alias]).toEqual({ + text: 't2', + startIndex: 634, + endIndex: 635, + line: 23, + startColumn: 72, + endColumn: 74, + }); + expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + if (isCommonEntityContext(tableEntity1)) { + expect(tableEntity1.columns).toBeUndefined(); + expect(tableEntity1.relatedEntities).toBeNull(); + } }); test('select from table join', () => { @@ -187,16 +254,18 @@ describe('Flink entity collector tests', () => { expect(tableEntity1.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity1.text).toBe('Orders'); expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - - expect(tableEntity1.columns).toBeNull(); - expect(tableEntity1.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity1)) { + expect(tableEntity1.columns).toBeUndefined(); + expect(tableEntity1.relatedEntities).toBeNull(); + } expect(tableEntity2.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity2.text).toBe('Product'); expect(tableEntity2.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - - expect(tableEntity2.columns).toBeNull(); - expect(tableEntity2.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity2)) { + expect(tableEntity2.columns).toBeUndefined(); + expect(tableEntity2.relatedEntities).toBeNull(); + } expect(tableEntity1.belongStmt).toBe(tableEntity2.belongStmt); }); @@ -216,16 +285,17 @@ describe('Flink entity collector tests', () => { expect(tableEntity1.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity1.text).toBe('t1'); expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - - expect(tableEntity1.columns).toBeNull(); - expect(tableEntity1.relatedEntities).toBeNull(); - + if (isCommonEntityContext(tableEntity1)) { + expect(tableEntity1.columns).toBeUndefined(); + expect(tableEntity1.relatedEntities).toBeNull(); + } expect(tableEntity2.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity2.text).toBe('t2'); expect(tableEntity2.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - - expect(tableEntity2.columns).toBeNull(); - expect(tableEntity2.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity2)) { + expect(tableEntity2.columns).toBeUndefined(); + expect(tableEntity2.relatedEntities).toBeNull(); + } expect(tableEntity1.belongStmt.rootStmt).toBe(tableEntity2.belongStmt.rootStmt); }); @@ -244,9 +314,10 @@ describe('Flink entity collector tests', () => { expect(tableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity.text).toBe('country_page_view'); expect(tableEntity.belongStmt.stmtContextType).toBe(StmtContextType.INSERT_STMT); - - expect(tableEntity.columns).toBeNull(); - expect(tableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity)) { + expect(tableEntity.columns).toBeUndefined(); + expect(tableEntity.relatedEntities).toBeNull(); + } }); test('insert into table select', () => { @@ -307,11 +378,18 @@ describe('Flink entity collector tests', () => { flink.listen(collectListener as ParseTreeListener, insertTableContext); const allEntities = collectListener.getEntities(); - expect(allEntities.length).toBe(2); expect(allEntities[0].entityContextType).toBe(EntityContextType.VIEW_CREATE); expect(allEntities[0].text).toBe('view1'); + expect(allEntities[0][AttrName.comment]).toEqual({ + text: "'this is a view'", + startIndex: 1254, + endIndex: 1269, + line: 42, + startColumn: 39, + endColumn: 55, + }); expect(allEntities[0].belongStmt.stmtContextType).toBe(StmtContextType.CREATE_VIEW_STMT); expect(allEntities[1].entityContextType).toBe(EntityContextType.TABLE); @@ -333,26 +411,35 @@ describe('Flink entity collector tests', () => { expect(dbEntity.entityContextType).toBe(EntityContextType.DATABASE_CREATE); expect(dbEntity.text).toBe('db1'); + expect(dbEntity[AttrName.comment]).toEqual({ + text: "'this is a created database'", + startIndex: 1345, + endIndex: 1372, + line: 44, + startColumn: 43, + endColumn: 71, + }); expect(dbEntity.position).toEqual({ endColumn: 34, - endIndex: 1160, + endIndex: 1335, line: 44, startColumn: 31, - startIndex: 1158, + startIndex: 1333, }); expect(dbEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_DATABASE_STMT); expect(dbEntity.belongStmt.position).toEqual({ - endColumn: 82, - endIndex: 1208, + endColumn: 119, + endIndex: 1420, endLine: 44, startColumn: 1, - startIndex: 1128, + startIndex: 1303, startLine: 44, }); - - expect(dbEntity.columns).toBeNull(); - expect(dbEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } }); test('create function', () => { @@ -371,10 +458,10 @@ describe('Flink entity collector tests', () => { expect(functionEntity.text).toBe('tempFunction'); expect(functionEntity.position).toEqual({ endColumn: 43, - endIndex: 1253, + endIndex: 1465, line: 46, startColumn: 31, - startIndex: 1242, + startIndex: 1454, }); expect(functionEntity.belongStmt.stmtContextType).toBe( @@ -382,14 +469,15 @@ describe('Flink entity collector tests', () => { ); expect(functionEntity.belongStmt.position).toEqual({ endColumn: 58, - endIndex: 1268, + endIndex: 1480, endLine: 46, startColumn: 1, - startIndex: 1212, + startIndex: 1424, startLine: 46, }); - - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity?.arguments)?.toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } }); }); diff --git a/test/parser/flink/contextCollect/fixtures/common.sql b/test/parser/flink/contextCollect/fixtures/common.sql index db3f9ccf..3dc20d59 100644 --- a/test/parser/flink/contextCollect/fixtures/common.sql +++ b/test/parser/flink/contextCollect/fixtures/common.sql @@ -1,4 +1,4 @@ -CREATE TABLE MyTable ('user_id' BIGINT, 'name' STRING) WITH ('connector' = 'oracle-x'); +CREATE TABLE MyTable ('user_id' BIGINT COMMENT 'col1', 'name' STRING) COMMENT 'test table comment ABC.' PARTITIONED BY (a, h) WITH ('connector' = 'kafka','kafka.topic' = 'log.test'); CREATE TABLE my_ctas_table WITH ('connector' = 'kafka') AS SELECT @@ -20,7 +20,7 @@ CREATE TABLE Orders_with_watermark ( INCLUDING GENERATED ); -SELECT order_id, price + tax FROM Orders; +SELECT order_id, price + tax AS total FROM Order1 AS o1 JOIN Order2 AS t2 ON t1.id = t2.user_id; SELECT * FROM Orders LEFT JOIN Product ON Orders.product_id = Product.id; @@ -39,8 +39,8 @@ EXECUTE STATEMENT SET BEGIN ('Amercian', 'georage', 22); END; -CREATE VIEW view1(col1, col2) AS SELECT col3, col4 FROM tbl; +CREATE VIEW view1(col1, col2) COMMENT 'this is a view' AS SELECT col3, col4 FROM tbl; -CREATE DATABASE IF NOT EXISTS db1 WITH ('key1' = 'value1', 'key2.a' = 'value2.a'); +CREATE DATABASE IF NOT EXISTS db1 COMMENT 'this is a created database' WITH ('key1' = 'value1', 'key2.a' = 'value2.a'); CREATE FUNCTION IF NOT EXISTS tempFunction AS 'SimpleUdf'; \ No newline at end of file diff --git a/test/parser/flink/errorListener.test.ts b/test/parser/flink/errorListener.test.ts new file mode 100644 index 00000000..1a82a9b3 --- /dev/null +++ b/test/parser/flink/errorListener.test.ts @@ -0,0 +1,100 @@ +import { FlinkSQL } from 'src/parser/flink'; + +const randomText = `dhsdansdnkla ndjnsla ndnalks`; +const sql1 = `SHOW CREATE TABLE`; +const sql2 = `SELECT * FROM `; +const sql3 = `DROP VIEW IF EXIsST aaa aaa`; +const sql4 = `SELECT * froma aaa`; +const sql5 = `CREATE VIEW `; +const sql6 = `DROP CATALOG `; + +describe('FlinkSQL validate invalid sql and test msg', () => { + const flink = new FlinkSQL(); + + test('validate random text', () => { + const errors = flink.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'dhsdansdnkla' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql1', () => { + const errors = flink.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete'); + }); + + test('validate unComplete sql2', () => { + const errors = flink.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + 'Statement is incomplete, expecting an existing table or an existing view or a keyword' + ); + }); + + test('validate unComplete sql3', () => { + const errors = flink.validate(sql3); + expect(errors.length).toBe(2); + expect(errors[0].message).toBe(`missing 'EXISTS' at 'EXIsST'`); + expect(errors[1].message).toBe(`'aaa' is not valid at this position`); + }); + + test('validate unComplete sql4', () => { + const errors = flink.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'aaa' is not valid at this position, expecting an existing column or a keyword` + ); + }); + + test('validate unComplete sql5', () => { + const errors = flink.validate(sql5); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `Statement is incomplete, expecting a new view or a keyword` + ); + }); + + test('validate unComplete sql6', () => { + const errors = flink.validate(sql6); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `Statement is incomplete, expecting an existing catalog or a keyword` + ); + }); + + test('validate random text cn', () => { + flink.locale = 'zh_CN'; + const errors = flink.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'dhsdansdnkla' 在此位置无效，期望一个关键字`); + }); + + test('validate unComplete sql1 cn', () => { + const errors = flink.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('语句不完整'); + }); + + test('validate unComplete sql2 cn', () => { + const errors = flink.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + '语句不完整，期望一个存在的table或者一个存在的view或者一个关键字' + ); + }); + + test('validate unComplete sql3 cn', () => { + const errors = flink.validate(sql3); + expect(errors.length).toBe(2); + expect(errors[0].message).toBe(`缺少'EXISTS'在'EXIsST'`); + expect(errors[1].message).toBe(`'aaa' 在此位置无效`); + }); + + test('validate unComplete sql4 cn', () => { + const errors = flink.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'aaa' 在此位置无效，期望一个存在的column或者一个关键字`); + }); +}); diff --git a/test/parser/flink/suggestion/tokenSuggestion.test.ts b/test/parser/flink/suggestion/tokenSuggestion.test.ts index e527d6b8..6663d174 100644 --- a/test/parser/flink/suggestion/tokenSuggestion.test.ts +++ b/test/parser/flink/suggestion/tokenSuggestion.test.ts @@ -19,7 +19,7 @@ describe('Flink SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['MODULES', 'CATALOG']); + expect(suggestion).toMatchUnorderedArray(['MODULES', 'CATALOG']); }); test('Create Statement ', () => { @@ -32,7 +32,7 @@ describe('Flink SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'CATALOG', 'FUNCTION', 'TEMPORARY', @@ -52,7 +52,7 @@ describe('Flink SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'MODULES', 'FULL', 'FUNCTIONS', diff --git a/test/parser/hive/contextCollect/entityCollector.test.ts b/test/parser/hive/contextCollect/entityCollector.test.ts index 3b4785f5..726dd5ec 100644 --- a/test/parser/hive/contextCollect/entityCollector.test.ts +++ b/test/parser/hive/contextCollect/entityCollector.test.ts @@ -2,10 +2,15 @@ import { ParseTreeListener } from 'antlr4ng'; import fs from 'fs'; import path from 'path'; import { HiveSqlParserListener } from 'src/lib/hive/HiveSqlParserListener'; +import { + AttrName, + isCommonEntityContext, + isFuncEntityContext, + StmtContextType, +} from 'src/parser/common/entityCollector'; import { EntityContextType } from 'src/parser/common/types'; -import { HiveSQL, HiveEntityCollector } from 'src/parser/hive'; +import { HiveEntityCollector, HiveSQL } from 'src/parser/hive'; import { HiveSqlSplitListener } from 'src/parser/hive/hiveSplitListener'; -import { StmtContextType } from 'src/parser/common/entityCollector'; const commonSql = fs.readFileSync(path.join(__dirname, 'fixtures', 'common.sql'), 'utf-8'); @@ -20,7 +25,7 @@ describe('Hive entity collector tests', () => { }); test('split results', () => { - expect(splitListener.statementsContext.length).toBe(18); + expect(splitListener.statementsContext.length).toBe(21); }); test('create table by like', () => { @@ -58,9 +63,11 @@ describe('Hive entity collector tests', () => { startColumn: 1, }); - expect(tableCreateEntity.relatedEntities).not.toBeNull(); - expect(tableCreateEntity.relatedEntities[0]).toEqual(tableLikeEntity); - expect(tableCreateEntity.columns).toBeNull(); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).not.toBeNull(); + expect(tableCreateEntity.relatedEntities[0]).toEqual(tableLikeEntity); + expect(tableCreateEntity.columns).toBeUndefined(); + } expect(tableLikeEntity.entityContextType).toBe(EntityContextType.TABLE); expect(tableLikeEntity.text).toBe('origin_table'); @@ -100,17 +107,21 @@ describe('Hive entity collector tests', () => { startIndex: 68, startLine: 3, }); - - expect(tableCreateEntity.relatedEntities).toBeNull(); - expect(tableCreateEntity.columns).not.toBeNull(); - expect(tableCreateEntity.columns.length).toBe(3); - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); - }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).toBeNull(); + expect(tableCreateEntity.columns).not.toBeNull(); + expect(tableCreateEntity.columns.length).toBe(3); + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + } }); test('create table by select', () => { @@ -147,11 +158,11 @@ describe('Hive entity collector tests', () => { startIndex: 202, startLine: 5, }); - - expect(tableCreateEntity.relatedEntities).not.toBeNull(); - expect(tableCreateEntity.relatedEntities[0]).toBe(tableFromEntity); - expect(tableCreateEntity.columns).toBeNull(); - + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).not.toBeNull(); + expect(tableCreateEntity.relatedEntities[0]).toBe(tableFromEntity); + expect(tableCreateEntity.columns).toBeUndefined(); + } expect(tableFromEntity.entityContextType).toBe(EntityContextType.TABLE); expect(tableFromEntity.text).toBe('origin_table'); expect(tableFromEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); @@ -189,11 +200,11 @@ describe('Hive entity collector tests', () => { startIndex: 283, startLine: 11, }); - - expect(viewCreateEntity.relatedEntities).not.toBeNull(); - expect(viewCreateEntity.relatedEntities[0]).toBe(viewSelectEntity); - expect(viewCreateEntity.columns).toBeNull(); - + if (isCommonEntityContext(viewCreateEntity)) { + expect(viewCreateEntity.relatedEntities).not.toBeNull(); + expect(viewCreateEntity.relatedEntities[0]).toBe(viewSelectEntity); + expect(viewCreateEntity.columns).toBeUndefined(); + } expect(viewSelectEntity.entityContextType).toBe(EntityContextType.TABLE); expect(viewSelectEntity.text).toBe('mydb.sale_tbl'); expect(viewSelectEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); @@ -232,17 +243,54 @@ describe('Hive entity collector tests', () => { startLine: 14, }); - expect(viewCreateEntity.relatedEntities).not.toBeNull(); - expect(viewCreateEntity.relatedEntities[0]).toBe(viewSelectEntity); - expect(viewCreateEntity.columns).not.toBeNull(); - expect(viewCreateEntity.columns.length).toBe(3); - viewCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(viewCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); - }); + expect(viewCreateEntity[AttrName.comment]).toEqual({ + text: "'一个任务信息视图'", + endColumn: 19, + line: 19, + startColumn: 9, + startIndex: 470, + endIndex: 479, + }); + if (isCommonEntityContext(viewCreateEntity)) { + expect(viewCreateEntity.relatedEntities).not.toBeNull(); + expect(viewCreateEntity.relatedEntities[0]).toBe(viewSelectEntity); + expect(viewCreateEntity.columns).not.toBeNull(); + expect(viewCreateEntity.columns.length).toBe(3); + viewCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(viewCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(viewCreateEntity.columns[0][AttrName.comment]).toEqual({ + text: "'任务id'", + endColumn: 26, + line: 15, + startColumn: 20, + startIndex: 390, + endIndex: 395, + }); + expect(viewCreateEntity.columns[1][AttrName.comment]).toEqual({ + text: "'任务名称'", + endColumn: 28, + line: 16, + startColumn: 22, + startIndex: 419, + endIndex: 424, + }); + expect(viewCreateEntity.columns[2][AttrName.comment]).toEqual({ + text: "'任务运行时长'", + endColumn: 33, + line: 17, + startColumn: 25, + startIndex: 451, + endIndex: 458, + }); + } expect(viewSelectEntity.entityContextType).toBe(EntityContextType.TABLE); expect(viewSelectEntity.text).toBe('task_tbl'); @@ -281,11 +329,19 @@ describe('Hive entity collector tests', () => { startIndex: 600, startLine: 27, }); - - expect(viewCreateEntity.relatedEntities).not.toBeNull(); - expect(viewCreateEntity.relatedEntities[0]).toBe(viewSelectEntity); - expect(viewCreateEntity.columns).toBeNull(); - + expect(viewCreateEntity[AttrName.comment]).toEqual({ + text: "'一个测试视图'", + endColumn: 17, + line: 29, + startColumn: 9, + startIndex: 677, + endIndex: 684, + }); + if (isCommonEntityContext(viewCreateEntity)) { + expect(viewCreateEntity.relatedEntities).not.toBeNull(); + expect(viewCreateEntity.relatedEntities[0]).toBe(viewSelectEntity); + expect(viewCreateEntity.columns).toBeUndefined(); + } expect(viewSelectEntity.entityContextType).toBe(EntityContextType.TABLE); expect(viewSelectEntity.text).toBe('mydb.sale_tbl'); expect(viewSelectEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); @@ -322,9 +378,10 @@ describe('Hive entity collector tests', () => { startIndex: 719, startLine: 32, }); - - expect(selectTableEntity.columns).toBeNull(); - expect(selectTableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(selectTableEntity)) { + expect(selectTableEntity.columns).toBeUndefined(); + expect(selectTableEntity.relatedEntities).toBeNull(); + } }); test('select table with join', () => { @@ -359,14 +416,17 @@ describe('Hive entity collector tests', () => { startIndex: 757, startLine: 34, }); - - expect(selectTableEntity.columns).toBeNull(); - expect(selectTableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(selectTableEntity)) { + expect(selectTableEntity.columns).toBeUndefined(); + expect(selectTableEntity.relatedEntities).toBeNull(); + } expect(selectTableEntity.belongStmt).toEqual(joinTableEntity.belongStmt); expect(joinTableEntity.text).toBe('b'); - expect(joinTableEntity.columns).toBeNull(); - expect(joinTableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(joinTableEntity)) { + expect(joinTableEntity.columns).toBeUndefined(); + expect(joinTableEntity.relatedEntities).toBeNull(); + } }); test('from select table', () => { @@ -400,9 +460,10 @@ describe('Hive entity collector tests', () => { startIndex: 833, startLine: 36, }); - - expect(selectTableEntity.columns).toBeNull(); - expect(selectTableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(selectTableEntity)) { + expect(selectTableEntity?.columns)?.toBeUndefined(); + expect(selectTableEntity.relatedEntities).toBeNull(); + } }); test('from select table with join', () => { @@ -437,14 +498,16 @@ describe('Hive entity collector tests', () => { startIndex: 871, startLine: 38, }); - - expect(selectTableEntity.columns).toBeNull(); - expect(selectTableEntity.relatedEntities).toBeNull(); - + if (isCommonEntityContext(selectTableEntity)) { + expect(selectTableEntity.columns).toBeUndefined(); + expect(selectTableEntity.relatedEntities).toBeNull(); + } expect(selectTableEntity.belongStmt).toEqual(joinTableEntity.belongStmt); expect(joinTableEntity.text).toBe('b'); - expect(joinTableEntity.columns).toBeNull(); - expect(joinTableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(joinTableEntity)) { + expect(joinTableEntity.columns).toBeUndefined(); + expect(joinTableEntity.relatedEntities).toBeNull(); + } }); test('insert table with values', () => { @@ -478,9 +541,10 @@ describe('Hive entity collector tests', () => { startIndex: 947, startLine: 40, }); - - expect(insertTableEntity.columns).toBeNull(); - expect(insertTableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(insertTableEntity)) { + expect(insertTableEntity.columns).toBeUndefined(); + expect(insertTableEntity.relatedEntities).toBeNull(); + } }); test('insert table use select', () => { @@ -515,9 +579,10 @@ describe('Hive entity collector tests', () => { startIndex: 1049, startLine: 43, }); - - expect(insertTableEntity.columns).toBeNull(); - expect(insertTableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(insertTableEntity)) { + expect(insertTableEntity.columns).toBeUndefined(); + expect(insertTableEntity.relatedEntities).toBeNull(); + } expect(fromTableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); expect(fromTableEntity.text).toBe('source_table'); @@ -557,9 +622,10 @@ describe('Hive entity collector tests', () => { startIndex: 1187, startLine: 48, }); - - expect(insertTableEntity.columns).toBeNull(); - expect(insertTableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(insertTableEntity)) { + expect(insertTableEntity.columns).toBeUndefined(); + expect(insertTableEntity.relatedEntities).toBeNull(); + } expect(fromTableEntity.belongStmt.stmtContextType).toBe(StmtContextType.INSERT_STMT); expect(fromTableEntity.text).toBe('page_view_stg'); @@ -597,9 +663,10 @@ describe('Hive entity collector tests', () => { startIndex: 1374, startLine: 52, }); - - expect(dbEntity.columns).toBeNull(); - expect(dbEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } }); test('create remote db', () => { @@ -634,8 +701,10 @@ describe('Hive entity collector tests', () => { startLine: 54, }); - expect(dbEntity.columns).toBeNull(); - expect(dbEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } }); test('show locks db', () => { @@ -670,8 +739,10 @@ describe('Hive entity collector tests', () => { startLine: 56, }); - expect(dbEntity.columns).toBeNull(); - expect(dbEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } }); test('create function', () => { @@ -708,8 +779,10 @@ describe('Hive entity collector tests', () => { startLine: 58, }); - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } }); test('create temporary function', () => { @@ -745,8 +818,205 @@ describe('Hive entity collector tests', () => { startIndex: 1537, startLine: 60, }); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } + }); + test('create table by columns with attributes', () => { + const columnCreateTableContext = splitListener.statementsContext[18]; + + const collectListener = new HiveEntityCollector(commonSql); + hiveSql.listen(collectListener as ParseTreeListener, columnCreateTableContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(1); + + const tableCreateEntity = allEntities[0]; + + expect(tableCreateEntity.entityContextType).toBe(EntityContextType.TABLE_CREATE); + expect(tableCreateEntity.text).toBe('test_change'); + expect(tableCreateEntity.position).toEqual({ + endColumn: 25, + endIndex: 1604, + line: 62, + startColumn: 14, + startIndex: 1594, + }); + + expect(tableCreateEntity.belongStmt.stmtContextType).toBe( + StmtContextType.CREATE_TABLE_STMT + ); + expect(tableCreateEntity.belongStmt.position).toEqual({ + endColumn: 104, + endIndex: 1683, + endLine: 62, + startColumn: 1, + startIndex: 1581, + startLine: 62, + }); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'table test comment'", + endColumn: 104, + line: 62, + startColumn: 84, + startIndex: 1664, + endIndex: 1683, + }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).toBeNull(); + expect(tableCreateEntity.columns).not.toBeNull(); + expect(tableCreateEntity.columns.length).toBe(3); + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.columns[0].text).toBe('a'); + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'int', + startIndex: 1609, + endIndex: 1611, + line: 62, + startColumn: 29, + endColumn: 32, + }); + expect(tableCreateEntity.columns[1].text).toBe('b'); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'varchar(255)', + startIndex: 1616, + endIndex: 1627, + line: 62, + startColumn: 36, + endColumn: 48, + }); + expect(tableCreateEntity.columns[1][AttrName.comment]).toEqual({ + text: "'column 2'", + startIndex: 1637, + endIndex: 1646, + line: 62, + startColumn: 57, + endColumn: 67, + }); + expect(tableCreateEntity.columns[2].text).toBe('c'); + expect(tableCreateEntity.columns[2][AttrName.colType]).toEqual({ + text: 'int', + startIndex: 1651, + endIndex: 1653, + line: 62, + startColumn: 71, + endColumn: 74, + }); + } + }); + test('create db with comment', () => { + const columnCreateTableContext = splitListener.statementsContext[19]; + + const collectListener = new HiveEntityCollector(commonSql); + hiveSql.listen(collectListener as ParseTreeListener, columnCreateTableContext); - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(1); + + const dbEntity = allEntities[0]; + + expect(dbEntity.entityContextType).toBe(EntityContextType.DATABASE_CREATE); + expect(dbEntity.text).toBe('testdb'); + expect(dbEntity.position).toEqual({ + endColumn: 23, + endIndex: 1708, + line: 64, + startColumn: 17, + startIndex: 1703, + }); + + expect(dbEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_DATABASE_STMT); + expect(dbEntity.belongStmt.position).toEqual({ + endColumn: 69, + endIndex: 1754, + endLine: 64, + startColumn: 1, + startIndex: 1687, + startLine: 64, + }); + expect(dbEntity[AttrName.comment]).toEqual({ + text: "'test database'", + endColumn: 47, + endIndex: 1732, + line: 64, + startColumn: 32, + startIndex: 1718, + }); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } + }); + test('select table with join with alias', () => { + const columnCreateTableContext = splitListener.statementsContext[20]; + + const collectListener = new HiveEntityCollector(commonSql); + hiveSql.listen(collectListener as ParseTreeListener, columnCreateTableContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(2); + + const selectTableEntity = allEntities[0]; + const joinTableEntity = allEntities[1]; + + expect(selectTableEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(selectTableEntity.text).toBe('table_busi'); + expect(selectTableEntity.position).toEqual({ + endColumn: 27, + endIndex: 1783, + line: 66, + startColumn: 17, + startIndex: 1774, + }); + + expect(selectTableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(selectTableEntity.belongStmt.position).toEqual({ + endColumn: 97, + endIndex: 1853, + endLine: 66, + startColumn: 1, + startIndex: 1758, + startLine: 66, + }); + expect(selectTableEntity[AttrName.alias]).toEqual({ + text: 'a', + endColumn: 29, + endIndex: 1785, + line: 66, + startColumn: 28, + startIndex: 1785, + }); + if (isCommonEntityContext(selectTableEntity)) { + expect(selectTableEntity.columns).toBeUndefined(); + expect(selectTableEntity.relatedEntities).toBeNull(); + } + + expect(selectTableEntity.belongStmt).toEqual(joinTableEntity.belongStmt); + expect(joinTableEntity.text).toBe('table_issue'); + expect(joinTableEntity[AttrName.alias]).toEqual({ + text: 'b', + endColumn: 48, + endIndex: 1804, + line: 66, + startColumn: 47, + startIndex: 1804, + }); + if (isCommonEntityContext(joinTableEntity)) { + expect(joinTableEntity.columns).toBeUndefined(); + expect(joinTableEntity.relatedEntities).toBeNull(); + } }); }); diff --git a/test/parser/hive/contextCollect/fixtures/common.sql b/test/parser/hive/contextCollect/fixtures/common.sql index c7c70614..2f779521 100644 --- a/test/parser/hive/contextCollect/fixtures/common.sql +++ b/test/parser/hive/contextCollect/fixtures/common.sql @@ -57,4 +57,10 @@ SHOW LOCKS DATABASE db1; CREATE FUNCTION base_analizer AS 'com.udf.BaseFieldUDF'; -CREATE TEMPORARY FUNCTION flat_analizer AS 'com.udtf.EventJsonUDTF'; \ No newline at end of file +CREATE TEMPORARY FUNCTION flat_analizer AS 'com.udtf.EventJsonUDTF'; + +CREATE TABLE test_change (a int, b varchar(255) COMMENT 'column 2', c int) COMMENT 'table test comment'; + +CREATE DATABASE testdb COMMENT 'test database' LOCATION '/test/path'; + +SELECT a.* FROM table_busi a JOIN table_issue b ON (a.id = b.id AND a.department = b.department); \ No newline at end of file diff --git a/test/parser/hive/errorListener.test.ts b/test/parser/hive/errorListener.test.ts new file mode 100644 index 00000000..1bc9b6a1 --- /dev/null +++ b/test/parser/hive/errorListener.test.ts @@ -0,0 +1,91 @@ +import { HiveSQL } from 'src/parser/hive'; + +const randomText = `dhsdansdnkla ndjnsla ndnalks`; +const sql1 = `SHOW CREATE TABLE`; +const sql2 = `SELECT * FROM `; +const sql3 = `DROP VIEW IF EXIsST aaa aaa`; +const sql4 = `SELECT * froma aaa`; +const sql5 = `CREATE TABLE `; + +describe('HiveSQL validate invalid sql and test msg', () => { + const hive = new HiveSQL(); + + test('validate random text', () => { + const errors = hive.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'dhsdansdnkla' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql1', () => { + const errors = hive.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete'); + }); + + test('validate unComplete sql2', () => { + const errors = hive.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + 'Statement is incomplete, expecting an existing table or an existing view or a keyword' + ); + }); + + test('validate unComplete sql3', () => { + const errors = hive.validate(sql3); + expect(errors.length).toBe(2); + expect(errors[0].message).toBe(`missing 'EXISTS' at 'EXIsST'`); + expect(errors[1].message).toBe(`'aaa' is not valid at this position`); + }); + + test('validate unComplete sql4', () => { + const errors = hive.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'froma' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql5', () => { + const errors = hive.validate(sql5); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `Statement is incomplete, expecting a new table or a keyword` + ); + }); + + test('validate random text cn', () => { + hive.locale = 'zh_CN'; + const errors = hive.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'dhsdansdnkla' 在此位置无效，期望一个关键字`); + }); + + test('validate unComplete sql1 cn', () => { + const errors = hive.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('语句不完整'); + }); + + test('validate unComplete sql2 cn', () => { + const errors = hive.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + '语句不完整，期望一个存在的table或者一个存在的view或者一个关键字' + ); + }); + + test('validate unComplete sql3 cn', () => { + const errors = hive.validate(sql3); + expect(errors.length).toBe(2); + expect(errors[0].message).toBe(`缺少'EXISTS'在'EXIsST'`); + expect(errors[1].message).toBe(`'aaa' 在此位置无效`); + }); + + test('validate unComplete sql4 cn', () => { + const errors = hive.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'froma' 在此位置无效，期望一个关键字`); + }); +}); diff --git a/test/parser/hive/suggestion/tokenSuggestion.test.ts b/test/parser/hive/suggestion/tokenSuggestion.test.ts index 106d3ff9..06c0e3d9 100644 --- a/test/parser/hive/suggestion/tokenSuggestion.test.ts +++ b/test/parser/hive/suggestion/tokenSuggestion.test.ts @@ -18,7 +18,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'APPLICATION', 'GROUP', 'USER', @@ -45,7 +45,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'CONNECTOR', 'APPLICATION', 'GROUP', @@ -80,7 +80,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['FROM']); + expect(suggestion).toMatchUnorderedArray(['FROM']); }); test('After DESCRIBE', () => { @@ -92,7 +92,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'EXTENDED', 'FORMATTED', 'FUNCTION', @@ -111,7 +111,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'CONNECTOR', 'APPLICATION', 'GROUP', @@ -141,7 +141,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['TABLE']); + expect(suggestion).toMatchUnorderedArray(['TABLE']); }); test('After IMPORT', () => { @@ -153,7 +153,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['FROM', 'TABLE', 'EXTERNAL']); + expect(suggestion).toMatchUnorderedArray(['FROM', 'TABLE', 'EXTERNAL']); }); test('After INSERT', () => { @@ -165,7 +165,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['INTO', 'OVERWRITE']); + expect(suggestion).toMatchUnorderedArray(['INTO', 'OVERWRITE']); }); test('After LOAD', () => { @@ -177,7 +177,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['DATA']); + expect(suggestion).toMatchUnorderedArray(['DATA']); }); test('After SHOW', () => { @@ -189,7 +189,7 @@ describe('Hive SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'CURRENT', 'ROLES', 'PRINCIPALS', diff --git a/test/parser/impala/contextCollect/entityCollector.test.ts b/test/parser/impala/contextCollect/entityCollector.test.ts index b7cb6d28..711aa76a 100644 --- a/test/parser/impala/contextCollect/entityCollector.test.ts +++ b/test/parser/impala/contextCollect/entityCollector.test.ts @@ -1,10 +1,15 @@ +import { ParseTreeListener } from 'antlr4ng'; import fs from 'fs'; import path from 'path'; -import { EntityContextType } from 'src/parser/common/types'; -import { StmtContextType } from 'src/parser/common/entityCollector'; -import { ImpalaSQL, ImpalaEntityCollector, ImpalaSqlSplitListener } from 'src/parser/impala'; import { ImpalaSqlParserListener } from 'src/lib/impala/ImpalaSqlParserListener'; -import { ParseTreeListener } from 'antlr4ng'; +import { + AttrName, + isCommonEntityContext, + isFuncEntityContext, + StmtContextType, +} from 'src/parser/common/entityCollector'; +import { EntityContextType } from 'src/parser/common/types'; +import { ImpalaEntityCollector, ImpalaSQL, ImpalaSqlSplitListener } from 'src/parser/impala'; const commonSql = fs.readFileSync(path.join(__dirname, 'fixtures', 'common.sql'), 'utf-8'); @@ -56,11 +61,11 @@ describe('ImpalaSQL entity collector tests', () => { startIndex: 0, startLine: 1, }); - - expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.columns).toBeNull(); - expect(tableCreateEntity.relatedEntities[0]).toBe(likeTableEntity); - + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.columns).toBeUndefined(); + expect(tableCreateEntity.relatedEntities[0]).toBe(likeTableEntity); + } expect(likeTableEntity.text).toBe('old_table'); expect(likeTableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(likeTableEntity.belongStmt).toBe(tableCreateEntity.belongStmt); @@ -92,23 +97,60 @@ describe('ImpalaSQL entity collector tests', () => { StmtContextType.CREATE_TABLE_STMT ); expect(tableCreateEntity.belongStmt.position).toEqual({ - endColumn: 77, - endIndex: 115, + endColumn: 138, + endIndex: 176, endLine: 3, startColumn: 1, startIndex: 40, startLine: 3, }); - - expect(tableCreateEntity.relatedEntities).toBeNull(); - expect(tableCreateEntity.columns.length).toBe(2); - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'common census table comment'", + endColumn: 138, + endIndex: 176, + line: 3, + startColumn: 109, + startIndex: 148, }); + + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).toBeNull(); + expect(tableCreateEntity.columns.length).toBe(2); + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'string', + endColumn: 33, + endIndex: 71, + line: 3, + startColumn: 27, + startIndex: 66, + }); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'int', + endColumn: 50, + endIndex: 88, + line: 3, + startColumn: 47, + startIndex: 86, + }); + expect(tableCreateEntity.columns[1][AttrName.comment]).toEqual({ + text: "'year comment'", + endColumn: 73, + endIndex: 111, + line: 3, + startColumn: 59, + startIndex: 98, + }); + } }); test('create table by select', () => { @@ -128,10 +170,10 @@ describe('ImpalaSQL entity collector tests', () => { expect(tableCreateEntity.text).toBe('sorted_census_data'); expect(tableCreateEntity.position).toEqual({ endColumn: 32, - endIndex: 149, + endIndex: 210, line: 5, startColumn: 14, - startIndex: 132, + startIndex: 193, }); expect(tableCreateEntity.belongStmt.stmtContextType).toBe( @@ -139,19 +181,21 @@ describe('ImpalaSQL entity collector tests', () => { ); expect(tableCreateEntity.belongStmt.position).toEqual({ endColumn: 30, - endIndex: 278, + endIndex: 339, endLine: 9, startColumn: 1, - startIndex: 119, + startIndex: 180, startLine: 5, }); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.columns).toBeNull(); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.columns).toBeUndefined(); - expect(fromCreateEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - expect(fromCreateEntity.text).toBe('unsorted_census_data'); - expect(tableCreateEntity.relatedEntities[0]).toBe(fromCreateEntity); + expect(fromCreateEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(fromCreateEntity.text).toBe('unsorted_census_data'); + expect(tableCreateEntity.relatedEntities[0]).toBe(fromCreateEntity); + } }); test('create kudu table by select', () => { @@ -171,10 +215,10 @@ describe('ImpalaSQL entity collector tests', () => { expect(tableCreateEntity.text).toBe('ctas_t1'); expect(tableCreateEntity.position).toEqual({ endColumn: 21, - endIndex: 301, + endIndex: 362, line: 11, startColumn: 14, - startIndex: 295, + startIndex: 356, }); expect(tableCreateEntity.belongStmt.stmtContextType).toBe( @@ -182,19 +226,21 @@ describe('ImpalaSQL entity collector tests', () => { ); expect(tableCreateEntity.belongStmt.position).toEqual({ endColumn: 31, - endIndex: 405, + endIndex: 466, endLine: 14, startColumn: 1, - startIndex: 282, + startIndex: 343, startLine: 11, }); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.columns).toBeNull(); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.columns).toBeUndefined(); - expect(fromCreateEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - expect(fromCreateEntity.text).toBe('kudu_t1'); - expect(tableCreateEntity.relatedEntities[0]).toBe(fromCreateEntity); + expect(fromCreateEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(fromCreateEntity.text).toBe('kudu_t1'); + expect(tableCreateEntity.relatedEntities[0]).toBe(fromCreateEntity); + } }); test('create kudu table by columns', () => { @@ -213,10 +259,18 @@ describe('ImpalaSQL entity collector tests', () => { expect(tableCreateEntity.text).toBe('kudu_t3'); expect(tableCreateEntity.position).toEqual({ endColumn: 21, - endIndex: 428, + endIndex: 489, line: 16, startColumn: 14, - startIndex: 422, + startIndex: 483, + }); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'kudu table comment'", + endColumn: 31, + endIndex: 840, + line: 23, + startColumn: 11, + startIndex: 821, }); expect(tableCreateEntity.belongStmt.stmtContextType).toBe( @@ -224,22 +278,67 @@ describe('ImpalaSQL entity collector tests', () => { ); expect(tableCreateEntity.belongStmt.position).toEqual({ endColumn: 17, - endIndex: 705, - endLine: 23, + endIndex: 857, + endLine: 24, startColumn: 1, - startIndex: 409, + startIndex: 470, startLine: 16, }); - expect(tableCreateEntity.relatedEntities).toBeNull(); - expect(tableCreateEntity.columns.length).toBe(4); - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); - }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).toBeNull(); + expect(tableCreateEntity.columns.length).toBe(4); + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'BIGINT', + endColumn: 32, + endIndex: 500, + line: 16, + startColumn: 26, + startIndex: 495, + }); + expect(tableCreateEntity.columns[0][AttrName.comment]).toEqual({ + text: "'id column comment'", + endColumn: 60, + endIndex: 528, + line: 16, + startColumn: 41, + startIndex: 510, + }); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'INT', + endColumn: 70, + endIndex: 538, + line: 16, + startColumn: 67, + startIndex: 536, + }); + expect(tableCreateEntity.columns[2][AttrName.colType]).toEqual({ + text: 'STRING', + endColumn: 80, + endIndex: 548, + line: 16, + startColumn: 74, + startIndex: 543, + }); + expect(tableCreateEntity.columns[2][AttrName.comment]).toEqual({ + text: "'string column comment'", + endColumn: 112, + endIndex: 580, + line: 16, + startColumn: 89, + startIndex: 558, + }); + } }); test('create view', () => { @@ -259,31 +358,61 @@ describe('ImpalaSQL entity collector tests', () => { expect(viewCreateEntity.text).toBe('my_view'); expect(viewCreateEntity.position).toEqual({ endColumn: 20, - endIndex: 727, - line: 25, + endIndex: 879, + line: 26, startColumn: 13, - startIndex: 721, + startIndex: 873, + }); + + expect(viewCreateEntity[AttrName.comment]).toEqual({ + text: "'view comment'", + endColumn: 113, + endIndex: 972, + line: 26, + startColumn: 99, + startIndex: 959, }); expect(viewCreateEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_VIEW_STMT); expect(viewCreateEntity.belongStmt.position).toEqual({ - endColumn: 146, - endIndex: 853, - endLine: 25, + endColumn: 169, + endIndex: 1028, + endLine: 26, startColumn: 1, - startIndex: 709, - startLine: 25, + startIndex: 861, + startLine: 26, }); - expect(viewCreateEntity.relatedEntities[0]).toBe(fromCreateEntity); - expect(viewCreateEntity.columns.length).toBe(2); - viewCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(viewCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); - }); + if (isCommonEntityContext(viewCreateEntity)) { + expect(viewCreateEntity.relatedEntities[0]).toBe(fromCreateEntity); + expect(viewCreateEntity.columns.length).toBe(2); + viewCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(viewCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(viewCreateEntity.columns[0][AttrName.comment]).toEqual({ + text: "'this is number col'", + endColumn: 54, + endIndex: 913, + line: 26, + startColumn: 34, + startIndex: 894, + }); + expect(viewCreateEntity.columns[1][AttrName.comment]).toEqual({ + text: "'this is number age'", + endColumn: 89, + endIndex: 948, + line: 26, + startColumn: 69, + startIndex: 929, + }); + } expect(fromCreateEntity.entityContextType).toBe(EntityContextType.TABLE); expect(fromCreateEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); @@ -307,23 +436,24 @@ describe('ImpalaSQL entity collector tests', () => { expect(tableInsertEntity.text).toBe('t2'); expect(tableInsertEntity.position).toEqual({ endColumn: 15, - endIndex: 870, - line: 27, + endIndex: 1045, + line: 28, startColumn: 13, - startIndex: 869, + startIndex: 1044, }); expect(tableInsertEntity.belongStmt.stmtContextType).toBe(StmtContextType.INSERT_STMT); expect(tableInsertEntity.belongStmt.position).toEqual({ endColumn: 40, - endIndex: 895, - endLine: 27, + endIndex: 1070, + endLine: 28, startColumn: 1, - startIndex: 857, - startLine: 27, + startIndex: 1032, + startLine: 28, }); - - expect(tableInsertEntity.columns).toBeNull(); + if (isCommonEntityContext(tableInsertEntity)) { + expect(tableInsertEntity.columns).toBeUndefined(); + } expect(fromTableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(fromTableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); @@ -347,24 +477,25 @@ describe('ImpalaSQL entity collector tests', () => { expect(tableEntity1.text).toBe('a'); expect(tableEntity1.position).toEqual({ endColumn: 16, - endIndex: 913, - line: 29, + endIndex: 1088, + line: 30, startColumn: 15, - startIndex: 913, + startIndex: 1088, }); expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); expect(tableEntity1.belongStmt.position).toEqual({ endColumn: 16, - endIndex: 913, - endLine: 29, + endIndex: 1088, + endLine: 30, startColumn: 1, - startIndex: 899, - startLine: 29, + startIndex: 1074, + startLine: 30, }); - - expect(tableEntity1.columns).toBeNull(); - expect(tableEntity1.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity1)) { + expect(tableEntity1.columns).toBeUndefined(); + expect(tableEntity1.relatedEntities).toBeNull(); + } }); test('select table join', () => { @@ -381,34 +512,54 @@ describe('ImpalaSQL entity collector tests', () => { const tableEntity2 = allEntities[1]; expect(tableEntity1.entityContextType).toBe(EntityContextType.TABLE); - expect(tableEntity1.text).toBe('t1'); + expect(tableEntity1.text).toBe('table1'); expect(tableEntity1.position).toEqual({ - endColumn: 28, - endIndex: 943, - line: 31, + endColumn: 32, + endIndex: 1122, + line: 32, startColumn: 26, - startIndex: 942, + startIndex: 1117, + }); + expect(tableEntity1[AttrName.alias]).toEqual({ + text: 't1', + endColumn: 38, + endIndex: 1128, + line: 32, + startColumn: 36, + startIndex: 1127, }); expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); expect(tableEntity1.belongStmt.position).toEqual({ endColumn: 20, - endIndex: 1022, - endLine: 33, + endIndex: 1217, + endLine: 34, startColumn: 1, - startIndex: 917, - startLine: 31, + startIndex: 1092, + startLine: 32, }); - - expect(tableEntity1.columns).toBeNull(); - expect(tableEntity1.relatedEntities).toBeNull(); - - expect(tableEntity2.entityContextType).toBe(EntityContextType.TABLE); - expect(tableEntity2.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - expect(tableEntity2.text).toBe('t2'); - expect(tableEntity2.columns).toBeNull(); - expect(tableEntity2.relatedEntities).toBeNull(); - expect(tableEntity2.belongStmt).toBe(tableEntity1.belongStmt); + if (isCommonEntityContext(tableEntity1)) { + expect(tableEntity1.columns).toBeUndefined(); + expect(tableEntity1.relatedEntities).toBeNull(); + + expect(tableEntity2.entityContextType).toBe(EntityContextType.TABLE); + expect(tableEntity2.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(tableEntity2.text).toBe('table2'); + expect(tableEntity2[AttrName.alias]).toEqual({ + text: 't2', + endColumn: 56, + endIndex: 1146, + line: 32, + startColumn: 54, + startIndex: 1145, + }); + } + + if (isCommonEntityContext(tableEntity2)) { + expect(tableEntity2.columns).toBeUndefined(); + expect(tableEntity2.relatedEntities).toBeNull(); + expect(tableEntity2.belongStmt).toBe(tableEntity1.belongStmt); + } }); test('create db', () => { @@ -427,24 +578,35 @@ describe('ImpalaSQL entity collector tests', () => { expect(dbEntity.text).toBe('my_db'); expect(dbEntity.position).toEqual({ endColumn: 22, - endIndex: 1046, - line: 35, + endIndex: 1241, + line: 36, startColumn: 17, - startIndex: 1042, + startIndex: 1237, + }); + + expect(dbEntity[AttrName.comment]).toEqual({ + text: "'my first db'", + endColumn: 44, + endIndex: 1263, + line: 36, + startColumn: 31, + startIndex: 1251, }); expect(dbEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_DATABASE_STMT); expect(dbEntity.belongStmt.position).toEqual({ - endColumn: 52, - endIndex: 1076, - endLine: 35, + endColumn: 74, + endIndex: 1293, + endLine: 36, startColumn: 1, - startIndex: 1026, - startLine: 35, + startIndex: 1221, + startLine: 36, }); - expect(dbEntity.columns).toBeNull(); - expect(dbEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } }); test('create schema', () => { @@ -463,24 +625,33 @@ describe('ImpalaSQL entity collector tests', () => { expect(schemaEntity.text).toBe('my_schema'); expect(schemaEntity.position).toEqual({ endColumn: 38, - endIndex: 1116, - line: 37, + endIndex: 1333, + line: 38, startColumn: 29, - startIndex: 1108, + startIndex: 1325, + }); + expect(schemaEntity[AttrName.comment]).toEqual({ + text: "'my first schema'", + endColumn: 64, + endIndex: 1359, + line: 38, + startColumn: 47, + startIndex: 1343, }); expect(schemaEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_DATABASE_STMT); expect(schemaEntity.belongStmt.position).toEqual({ endColumn: 94, - endIndex: 1172, - endLine: 37, + endIndex: 1389, + endLine: 38, startColumn: 1, - startIndex: 1080, - startLine: 37, + startIndex: 1297, + startLine: 38, }); - - expect(schemaEntity.columns).toBeNull(); - expect(schemaEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(schemaEntity)) { + expect(schemaEntity.columns).toBeUndefined(); + expect(schemaEntity.relatedEntities).toBeNull(); + } }); test('comment dbName', () => { @@ -499,25 +670,27 @@ describe('ImpalaSQL entity collector tests', () => { expect(dbEntity.text).toBe('my_database'); expect(dbEntity.position).toEqual({ endColumn: 32, - endIndex: 1206, - line: 39, + endIndex: 1423, + line: 40, startColumn: 21, - startIndex: 1196, + startIndex: 1413, }); // 由于没有处理 comment 语句，所以当前是处于 COMMON_STMT expect(dbEntity.belongStmt.stmtContextType).toBe(StmtContextType.COMMON_STMT); expect(dbEntity.belongStmt.position).toEqual({ endColumn: 59, - endIndex: 1233, - endLine: 39, + endIndex: 1450, + endLine: 40, startColumn: 1, - startIndex: 1176, - startLine: 39, + startIndex: 1393, + startLine: 40, }); - expect(dbEntity.columns).toBeNull(); - expect(dbEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } }); test('create aggregate function', () => { @@ -536,10 +709,10 @@ describe('ImpalaSQL entity collector tests', () => { expect(functionEntity.text).toBe('function_name'); expect(functionEntity.position).toEqual({ endColumn: 40, - endIndex: 1274, - line: 41, + endIndex: 1491, + line: 42, startColumn: 27, - startIndex: 1262, + startIndex: 1479, }); expect(functionEntity.belongStmt.stmtContextType).toBe( @@ -547,15 +720,17 @@ describe('ImpalaSQL entity collector tests', () => { ); expect(functionEntity.belongStmt.position).toEqual({ endColumn: 26, - endIndex: 1391, - endLine: 45, + endIndex: 1608, + endLine: 46, startColumn: 1, - startIndex: 1236, - startLine: 41, + startIndex: 1453, + startLine: 42, }); - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } }); test('create function', () => { @@ -574,10 +749,10 @@ describe('ImpalaSQL entity collector tests', () => { expect(functionEntity.text).toBe('function_name'); expect(functionEntity.position).toEqual({ endColumn: 30, - endIndex: 1423, - line: 47, + endIndex: 1640, + line: 48, startColumn: 17, - startIndex: 1411, + startIndex: 1628, }); expect(functionEntity.belongStmt.stmtContextType).toBe( @@ -585,14 +760,15 @@ describe('ImpalaSQL entity collector tests', () => { ); expect(functionEntity.belongStmt.position).toEqual({ endColumn: 21, - endIndex: 1517, - endLine: 50, + endIndex: 1734, + endLine: 51, startColumn: 1, - startIndex: 1395, - startLine: 47, + startIndex: 1612, + startLine: 48, }); - - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } }); }); diff --git a/test/parser/impala/contextCollect/fixtures/common.sql b/test/parser/impala/contextCollect/fixtures/common.sql index 84f57a70..be084789 100644 --- a/test/parser/impala/contextCollect/fixtures/common.sql +++ b/test/parser/impala/contextCollect/fixtures/common.sql @@ -1,6 +1,6 @@ CREATE TABLE new_Table like old_table; -create table census (name string, census_year int) partitioned by (year int); +create table census (name string, census_year int COMMENT 'year comment') partitioned by (year int) COMMENT 'common census table comment'; CREATE TABLE sorted_census_data SORT BY (last_name, state) @@ -13,26 +13,27 @@ CREATE TABLE ctas_t1 STORED AS KUDU AS SELECT id, s FROM kudu_t1; -CREATE TABLE kudu_t3 (id BIGINT, year INT, s STRING, +CREATE TABLE kudu_t3 (id BIGINT COMMENT 'id column comment', year INT, s STRING COMMENT 'string column comment', b BOOLEAN, PRIMARY KEY (id,year)) PARTITION BY HASH (id) PARTITIONS 20, RANGE (year) (PARTITION 1980 <= VALUES < 1990, PARTITION 1990 <= VALUES < 2000, PARTITION VALUE = 2001, PARTITION 2001 < VALUES < 2003) + COMMENT 'kudu table comment' STORED AS KUDU; -CREATE VIEW my_view (age COMMENT 'this is number col', age1 COMMENT 'this is number col') TBLPROPERTIES ('tblp1' = '1') AS SELECT * FROM my_table; +CREATE VIEW my_view (age COMMENT 'this is number col', age1 COMMENT 'this is number age') COMMENT 'view comment' TBLPROPERTIES ('tblp1' = '1') AS SELECT * FROM my_table; insert into t2 (y, x) select c1 from t1; SELECT * from a; -SELECT t1.c1, t2.c2 FROM t1 JOIN t2 +SELECT t1.c1, t2.c2 FROM table1 AS t1 JOIN table2 AS t2 ON t1.id = t2.id and t1.type_flag = t2.type_flag WHERE t1.c1 > 100; -CREATE DATABASE my_db LOCATION '/path/to/partition'; +CREATE DATABASE my_db COMMENT 'my first db' LOCATION '/path/to/partition'; CREATE SCHEMA IF NOT EXISTS my_schema COMMENT 'my first schema' LOCATION '/path/to/partition'; diff --git a/test/parser/impala/errorListener.test.ts b/test/parser/impala/errorListener.test.ts new file mode 100644 index 00000000..36a91b40 --- /dev/null +++ b/test/parser/impala/errorListener.test.ts @@ -0,0 +1,91 @@ +import { ImpalaSQL } from 'src/parser/impala'; + +const randomText = `dhsdansdnkla ndjnsla ndnalks`; +const sql1 = `SHOW CREATE TABLE`; +const sql2 = `SELECT * FROM `; +const sql3 = `DROP VIEW IF EXIsST aaa aaa`; +const sql4 = `SELECT * froma aaa`; +const sql5 = `CREATE VIEW `; + +describe('ImpalaSQL validate invalid sql and test msg', () => { + const impala = new ImpalaSQL(); + + test('validate random text', () => { + const errors = impala.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'dhsdansdnkla' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql1', () => { + const errors = impala.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete'); + }); + + test('validate unComplete sql2', () => { + const errors = impala.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + 'Statement is incomplete, expecting an existing table or an existing view or a keyword' + ); + }); + + test('validate unComplete sql3', () => { + const errors = impala.validate(sql3); + expect(errors.length).toBe(2); + expect(errors[0].message).toBe(`missing 'EXISTS' at 'EXIsST'`); + expect(errors[1].message).toBe(`'aaa' is not valid at this position`); + }); + + test('validate unComplete sql4', () => { + const errors = impala.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'froma' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql5', () => { + const errors = impala.validate(sql5); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `Statement is incomplete, expecting a new view or a keyword` + ); + }); + + test('validate random text cn', () => { + impala.locale = 'zh_CN'; + const errors = impala.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'dhsdansdnkla' 在此位置无效，期望一个关键字`); + }); + + test('validate unComplete sql1 cn', () => { + const errors = impala.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('语句不完整'); + }); + + test('validate unComplete sql2 cn', () => { + const errors = impala.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + '语句不完整，期望一个存在的table或者一个存在的view或者一个关键字' + ); + }); + + test('validate unComplete sql3 cn', () => { + const errors = impala.validate(sql3); + expect(errors.length).toBe(2); + expect(errors[0].message).toBe(`缺少'EXISTS'在'EXIsST'`); + expect(errors[1].message).toBe(`'aaa' 在此位置无效`); + }); + + test('validate unComplete sql4 cn', () => { + const errors = impala.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'froma' 在此位置无效，期望一个关键字`); + }); +}); diff --git a/test/parser/impala/suggestion/tokenSuggestion.test.ts b/test/parser/impala/suggestion/tokenSuggestion.test.ts index 26d565ce..627d7293 100644 --- a/test/parser/impala/suggestion/tokenSuggestion.test.ts +++ b/test/parser/impala/suggestion/tokenSuggestion.test.ts @@ -19,7 +19,7 @@ describe('Impala SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['TABLE', 'VIEW', 'DATABASE']); + expect(suggestion).toMatchUnorderedArray(['TABLE', 'VIEW', 'DATABASE']); }); test('After CREATE', () => { @@ -32,7 +32,7 @@ describe('Impala SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'TABLE', 'EXTERNAL', 'VIEW', @@ -54,7 +54,7 @@ describe('Impala SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'DATABASE', 'SCHEMA', 'TABLE', @@ -77,7 +77,7 @@ describe('Impala SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['INTO', 'OVERWRITE']); + expect(suggestion).toMatchUnorderedArray(['INTO', 'OVERWRITE']); }); test('After SHOW', () => { @@ -90,7 +90,7 @@ describe('Impala SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'DATABASES', 'SCHEMAS', 'TABLES', diff --git a/test/parser/mysql/contextCollect/entityCollector.test.ts b/test/parser/mysql/contextCollect/entityCollector.test.ts index 78e00046..4d6c5e57 100644 --- a/test/parser/mysql/contextCollect/entityCollector.test.ts +++ b/test/parser/mysql/contextCollect/entityCollector.test.ts @@ -1,11 +1,15 @@ +import { ParseTreeListener } from 'antlr4ng'; import fs from 'fs'; import path from 'path'; -import { MySQL } from 'src/parser/mysql'; -import { MySqlEntityCollector, MysqlSplitListener } from 'src/parser/mysql'; -import { ParseTreeListener } from 'antlr4ng'; import { MySqlParserListener } from 'src/lib/mysql/MySqlParserListener'; +import { + AttrName, + isCommonEntityContext, + isFuncEntityContext, + StmtContextType, +} from 'src/parser/common/entityCollector'; import { EntityContextType } from 'src/parser/common/types'; -import { StmtContextType } from 'src/parser/common/entityCollector'; +import { MySQL, MySqlEntityCollector, MysqlSplitListener } from 'src/parser/mysql'; const commonSql = fs.readFileSync(path.join(__dirname, 'fixtures', 'common.sql'), 'utf-8'); @@ -44,29 +48,67 @@ describe('MySQL entity collector tests', () => { startColumn: 14, endColumn: 29, }); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'new_tb_with_col comment'", + startIndex: 77, + endIndex: 101, + line: 1, + startColumn: 78, + endColumn: 103, + }); expect(tableCreateEntity.belongStmt.stmtContextType).toBe( StmtContextType.CREATE_TABLE_STMT ); expect(tableCreateEntity.belongStmt.position).toEqual({ startIndex: 0, - endIndex: 45, + endIndex: 101, startLine: 1, endLine: 1, startColumn: 1, - endColumn: 47, - }); - - expect(tableCreateEntity.relatedEntities).toBeNull(); - - expect(tableCreateEntity.columns.length).toBe(2); - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); + endColumn: 103, }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).toBeNull(); + + expect(tableCreateEntity.columns.length).toBe(2); + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.columns[0][AttrName.comment]).toEqual({ + text: "'col1'", + startIndex: 45, + endIndex: 50, + line: 1, + startColumn: 46, + endColumn: 52, + }); + + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'int', + startIndex: 33, + endIndex: 35, + line: 1, + startColumn: 34, + endColumn: 37, + }); + expect(tableCreateEntity.columns[1][AttrName.comment]).toBeNull(); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'varchar(3)', + startIndex: 57, + endIndex: 66, + line: 1, + startColumn: 58, + endColumn: 68, + }); + } }); test('create table by select', () => { @@ -84,8 +126,8 @@ describe('MySQL entity collector tests', () => { expect(tableCreateEntity.entityContextType).toBe(EntityContextType.TABLE_CREATE); expect(tableCreateEntity.text).toBe('new_tb_from_old'); expect(tableCreateEntity.position).toEqual({ - startIndex: 62, - endIndex: 76, + startIndex: 118, + endIndex: 132, line: 3, startColumn: 14, endColumn: 29, @@ -95,27 +137,27 @@ describe('MySQL entity collector tests', () => { StmtContextType.CREATE_TABLE_STMT ); expect(tableCreateEntity.belongStmt.position).toEqual({ - startIndex: 49, - endIndex: 265, + startIndex: 105, + endIndex: 321, startLine: 3, endLine: 12, startColumn: 1, endColumn: 34, }); - - expect(tableCreateEntity.columns).toBeNull(); - - expect(tableCreateEntity.relatedEntities.length).toBe(2); - tableCreateEntity.relatedEntities.forEach((relatedEntity) => { - expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); - expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); - }); - + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); + + expect(tableCreateEntity.relatedEntities.length).toBe(2); + tableCreateEntity.relatedEntities.forEach((relatedEntity) => { + expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); + }); + } expect(allEntities[1].text).toBe('old_tb1'); expect(allEntities[1].belongStmt.rootStmt).toBe(allEntities[0].belongStmt); expect(allEntities[1].position).toEqual({ - startIndex: 161, - endIndex: 167, + startIndex: 217, + endIndex: 223, line: 8, startColumn: 9, endColumn: 16, @@ -124,8 +166,8 @@ describe('MySQL entity collector tests', () => { expect(allEntities[2].text).toBe('old_tb2'); expect(allEntities[2].belongStmt.rootStmt).toBe(allEntities[0].belongStmt); expect(allEntities[2].position).toEqual({ - startIndex: 187, - endIndex: 193, + startIndex: 243, + endIndex: 249, line: 10, startColumn: 9, endColumn: 16, @@ -150,11 +192,11 @@ describe('MySQL entity collector tests', () => { expect(tableCreateEntity.belongStmt.stmtContextType).toBe( StmtContextType.CREATE_TABLE_STMT ); - - expect(tableCreateEntity.columns).toBeNull(); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); - + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); + } expect(originTableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(originTableEntity.text).toBe('old_tb'); expect(originTableEntity.belongStmt).toBe(tableCreateEntity.belongStmt); @@ -174,9 +216,10 @@ describe('MySQL entity collector tests', () => { expect(tableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity.text).toBe('select_tb'); expect(tableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - - expect(tableEntity.columns).toBeNull(); - expect(tableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity)) { + expect(tableEntity.columns).toBeUndefined(); + expect(tableEntity.relatedEntities).toBeNull(); + } }); test('select into from table', () => { @@ -193,9 +236,10 @@ describe('MySQL entity collector tests', () => { expect(tableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity.text).toBe('into_select_tb'); expect(tableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - - expect(tableEntity.columns).toBeNull(); - expect(tableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity)) { + expect(tableEntity.columns).toBeUndefined(); + expect(tableEntity.relatedEntities).toBeNull(); + } }); test('select from table join', () => { @@ -213,16 +257,26 @@ describe('MySQL entity collector tests', () => { expect(tableEntity1.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity1.text).toBe('from_tb'); expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - - expect(tableEntity1.columns).toBeNull(); - expect(tableEntity1.relatedEntities).toBeNull(); + expect(tableEntity1[AttrName.alias]).toEqual({ + text: 'tb1', + startIndex: 476, + endIndex: 478, + line: 21, + startColumn: 26, + endColumn: 29, + }); + if (isCommonEntityContext(tableEntity1)) { + expect(tableEntity1.columns).toBeUndefined(); + expect(tableEntity1.relatedEntities).toBeNull(); + } expect(tableEntity2.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity2.text).toBe('join_tb'); expect(tableEntity2.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - - expect(tableEntity2.columns).toBeNull(); - expect(tableEntity2.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity2)) { + expect(tableEntity2.columns).toBeUndefined(); + expect(tableEntity2.relatedEntities).toBeNull(); + } expect(tableEntity1.belongStmt).toBe(tableEntity2.belongStmt); }); @@ -241,9 +295,10 @@ describe('MySQL entity collector tests', () => { expect(tableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity.text).toBe('insert_tb'); expect(tableEntity.belongStmt.stmtContextType).toBe(StmtContextType.INSERT_STMT); - - expect(tableEntity.columns).toBeNull(); - expect(tableEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity)) { + expect(tableEntity.columns).toBeUndefined(); + expect(tableEntity.relatedEntities).toBeNull(); + } }); test('insert into table select', () => { @@ -289,12 +344,15 @@ describe('MySQL entity collector tests', () => { expect(allEntities[0].entityContextType).toBe(EntityContextType.VIEW_CREATE); expect(allEntities[0].text).toBe('new_view'); expect(allEntities[0].belongStmt.stmtContextType).toBe(StmtContextType.CREATE_VIEW_STMT); - - expect(allEntities[0].columns.length).toBe(2); - expect(allEntities[0].columns[0].text).toBe('col1'); - expect(allEntities[0].columns[1].text).toBe('col2'); - expect(allEntities[0].columns[0].entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(allEntities[0].columns[0].belongStmt).toBe(allEntities[0].belongStmt); + if (isCommonEntityContext(allEntities[0])) { + expect(allEntities[0].columns.length).toBe(2); + expect(allEntities[0].columns[0].text).toBe('col1'); + expect(allEntities[0].columns[1].text).toBe('col2'); + expect(allEntities[0].columns[0].entityContextType).toBe( + EntityContextType.COLUMN_CREATE + ); + expect(allEntities[0].columns[0].belongStmt).toBe(allEntities[0].belongStmt); + } }); test('create view as select table', () => { @@ -327,24 +385,25 @@ describe('MySQL entity collector tests', () => { expect(dbEntity.text).toBe('db_name'); expect(dbEntity.position).toEqual({ endColumn: 24, - endIndex: 778, + endIndex: 841, line: 31, startColumn: 17, - startIndex: 772, + startIndex: 835, }); expect(dbEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_DATABASE_STMT); expect(dbEntity.belongStmt.position).toEqual({ endColumn: 47, - endIndex: 801, + endIndex: 864, endLine: 31, startColumn: 1, - startIndex: 756, + startIndex: 819, startLine: 31, }); - - expect(dbEntity.columns).toBeNull(); - expect(dbEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } }); test('create schema', () => { @@ -363,24 +422,25 @@ describe('MySQL entity collector tests', () => { expect(schemaEntity.text).toBe('db_name'); expect(schemaEntity.position).toEqual({ endColumn: 36, - endIndex: 839, + endIndex: 902, line: 33, startColumn: 29, - startIndex: 833, + startIndex: 896, }); expect(schemaEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_DATABASE_STMT); expect(schemaEntity.belongStmt.position).toEqual({ endColumn: 59, - endIndex: 862, + endIndex: 925, endLine: 33, startColumn: 1, - startIndex: 805, + startIndex: 868, startLine: 33, }); - - expect(schemaEntity.columns).toBeNull(); - expect(schemaEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(schemaEntity)) { + expect(schemaEntity.columns).toBeUndefined(); + expect(schemaEntity.relatedEntities).toBeNull(); + } }); test('show create database', () => { @@ -399,24 +459,25 @@ describe('MySQL entity collector tests', () => { expect(dbEntity.text).toBe('db_name'); expect(dbEntity.position).toEqual({ endColumn: 41, - endIndex: 905, + endIndex: 968, line: 35, startColumn: 34, - startIndex: 899, + startIndex: 962, }); expect(dbEntity.belongStmt.stmtContextType).toBe(StmtContextType.COMMON_STMT); expect(dbEntity.belongStmt.position).toEqual({ endColumn: 42, - endIndex: 906, + endIndex: 969, endLine: 35, startColumn: 1, - startIndex: 866, + startIndex: 929, startLine: 35, }); - - expect(dbEntity.columns).toBeNull(); - expect(dbEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } }); test('drop database', () => { @@ -435,24 +496,25 @@ describe('MySQL entity collector tests', () => { expect(dbEntity.text).toBe('db_name'); expect(dbEntity.position).toEqual({ endColumn: 30, - endIndex: 937, + endIndex: 1000, line: 37, startColumn: 23, - startIndex: 931, + startIndex: 994, }); expect(dbEntity.belongStmt.stmtContextType).toBe(StmtContextType.COMMON_STMT); expect(dbEntity.belongStmt.position).toEqual({ endColumn: 31, - endIndex: 938, + endIndex: 1001, endLine: 37, startColumn: 1, - startIndex: 909, + startIndex: 972, startLine: 37, }); - - expect(dbEntity.columns).toBeNull(); - expect(dbEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(dbEntity)) { + expect(dbEntity.columns).toBeUndefined(); + expect(dbEntity.relatedEntities).toBeNull(); + } }); test('create function', () => { @@ -471,26 +533,36 @@ describe('MySQL entity collector tests', () => { expect(functionEntity.text).toBe('hello'); expect(functionEntity.position).toEqual({ endColumn: 39, - endIndex: 978, + endIndex: 1041, line: 39, startColumn: 34, - startIndex: 974, + startIndex: 1037, + }); + + expect(functionEntity[AttrName.comment]).toEqual({ + text: "'this is a defuner user function'", + endColumn: 125, + endIndex: 1127, + line: 39, + startColumn: 92, + startIndex: 1095, }); expect(functionEntity.belongStmt.stmtContextType).toBe( StmtContextType.CREATE_FUNCTION_STMT ); expect(functionEntity.belongStmt.position).toEqual({ - endColumn: 114, - endIndex: 1053, + endColumn: 156, + endIndex: 1158, endLine: 39, startColumn: 1, - startIndex: 941, + startIndex: 1004, startLine: 39, }); - - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } }); test('create function loadable', () => { @@ -509,10 +581,10 @@ describe('MySQL entity collector tests', () => { expect(functionEntity.text).toBe('my_concat_ws'); expect(functionEntity.position).toEqual({ endColumn: 43, - endIndex: 1098, + endIndex: 1203, line: 41, startColumn: 31, - startIndex: 1087, + startIndex: 1192, }); expect(functionEntity.belongStmt.stmtContextType).toBe( @@ -520,14 +592,14 @@ describe('MySQL entity collector tests', () => { ); expect(functionEntity.belongStmt.position).toEqual({ endColumn: 87, - endIndex: 1142, + endIndex: 1247, endLine: 41, startColumn: 1, - startIndex: 1057, + startIndex: 1162, startLine: 41, }); - - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.relatedEntities).toBeNull(); + } }); }); diff --git a/test/parser/mysql/contextCollect/fixtures/common.sql b/test/parser/mysql/contextCollect/fixtures/common.sql index b54b1bfd..8ab93448 100644 --- a/test/parser/mysql/contextCollect/fixtures/common.sql +++ b/test/parser/mysql/contextCollect/fixtures/common.sql @@ -1,4 +1,4 @@ -CREATE TABLE new_tb_with_col (id int, age int); +CREATE TABLE new_tb_with_col (id int COMMENT 'col1', age varchar(3)) COMMENT 'new_tb_with_col comment'; CREATE TABLE new_tb_from_old AS SELECT @@ -18,7 +18,7 @@ SELECT * FROM select_tb LIMIT 5,10; SELECT * INTO @my_var FROM into_select_tb; -SELECT * FROM from_tb LEFT JOIN join_tb ON (t1.a = t2.a); +SELECT * FROM from_tb AS tb1 LEFT JOIN join_tb ON (t1.a = t2.a); INSERT INTO insert_tb (a,b,c) VALUES(1,2,3), (4,5,6), (7,8,9); @@ -36,6 +36,6 @@ SHOW CREATE SCHEMA IF NOT EXISTS db_name; DROP SCHEMA IF EXISTS db_name; -CREATE DEFINER = 'user' FUNCTION hello (s CHAR(20)) RETURNS CHAR(50) DETERMINISTIC RETURN CONCAT('Hello, ',s,'!'); +CREATE DEFINER = 'user' FUNCTION hello (s CHAR(20)) RETURNS CHAR(50) DETERMINISTIC COMMENT 'this is a defuner user function' RETURN CONCAT('Hello, ',s,'!'); CREATE FUNCTION IF NOT EXISTS my_concat_ws RETURNS STRING SONAME 'udf_my_concat_ws.so'; diff --git a/test/parser/mysql/errorListener.test.ts b/test/parser/mysql/errorListener.test.ts new file mode 100644 index 00000000..443666bf --- /dev/null +++ b/test/parser/mysql/errorListener.test.ts @@ -0,0 +1,80 @@ +import { MySQL } from 'src/parser/mysql'; + +const randomText = `dhsdansdnkla ndjnsla ndnalks`; +const sql1 = `SHOW CREATE TABLE`; +const sql2 = `CREATE DATABASE `; +const sql3 = `SHOW CREATE DATABASE IF NOT EXIsST aaa aaa`; +const sql4 = `SELECT * froma aaa`; + +describe('MySQL validate invalid sql and test msg', () => { + const mysql = new MySQL(); + + test('validate random text', () => { + const errors = mysql.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'dhsdansdnkla' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql1', () => { + const errors = mysql.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete'); + }); + + test('validate unComplete sql2', () => { + const errors = mysql.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + 'Statement is incomplete, expecting a new database or a keyword' + ); + }); + + test('validate unComplete sql3', () => { + const errors = mysql.validate(sql3); + expect(errors.length).toBe(2); + expect(errors[0].message).toBe(`missing 'EXISTS' at 'EXIsST'`); + expect(errors[1].message).toBe(`'aaa' is not valid at this position`); + }); + + test('validate unComplete sql4', () => { + const errors = mysql.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'froma' is not valid at this position, expecting an existing column or a keyword` + ); + }); + + test('validate random text cn', () => { + mysql.locale = 'zh_CN'; + const errors = mysql.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'dhsdansdnkla' 在此位置无效，期望一个关键字`); + }); + + test('validate unComplete sql1 cn', () => { + const errors = mysql.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('语句不完整'); + }); + + test('validate unComplete sql2 cn', () => { + const errors = mysql.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toEqual('语句不完整，期望一个新的database或者一个关键字'); + }); + + test('validate unComplete sql3 cn', () => { + const errors = mysql.validate(sql3); + expect(errors.length).toBe(2); + expect(errors[0].message).toBe(`缺少'EXISTS'在'EXIsST'`); + expect(errors[1].message).toBe(`'aaa' 在此位置无效`); + }); + + test('validate unComplete sql4 cn', () => { + const errors = mysql.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'froma' 在此位置无效，期望一个存在的column或者一个关键字`); + }); +}); diff --git a/test/parser/mysql/suggestion/tokenSuggestion.test.ts b/test/parser/mysql/suggestion/tokenSuggestion.test.ts index 38ca340b..2c913cff 100644 --- a/test/parser/mysql/suggestion/tokenSuggestion.test.ts +++ b/test/parser/mysql/suggestion/tokenSuggestion.test.ts @@ -19,7 +19,7 @@ describe('MySQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'RESOURCE', 'USER', 'VIEW', @@ -50,7 +50,7 @@ describe('MySQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'RESOURCE', 'USER', 'ROLE', @@ -92,7 +92,7 @@ describe('MySQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['FROM', 'IGNORE', 'QUICK', 'LOW_PRIORITY']); + expect(suggestion).toMatchUnorderedArray(['FROM', 'IGNORE', 'QUICK', 'LOW_PRIORITY']); }); test('After DESCRIBE', () => { @@ -105,7 +105,7 @@ describe('MySQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'ANALYZE', 'SELECT', 'DELETE', @@ -129,7 +129,7 @@ describe('MySQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'RESOURCE', 'USER', 'PREPARE', @@ -162,7 +162,7 @@ describe('MySQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'INTO', 'IGNORE', 'DELAYED', @@ -181,7 +181,7 @@ describe('MySQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['INDEX', 'XML', 'DATA']); + expect(suggestion).toMatchUnorderedArray(['INDEX', 'XML', 'DATA']); }); test('After SHOW', () => { @@ -194,7 +194,7 @@ describe('MySQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'REPLICAS', 'REPLICA', 'SLAVE', diff --git a/test/parser/postgresql/contextCollect/entityCollector.test.ts b/test/parser/postgresql/contextCollect/entityCollector.test.ts index e0b7b27c..43ced566 100644 --- a/test/parser/postgresql/contextCollect/entityCollector.test.ts +++ b/test/parser/postgresql/contextCollect/entityCollector.test.ts @@ -2,8 +2,13 @@ import { ParseTreeListener } from 'antlr4ng'; import fs from 'fs'; import path from 'path'; import { PostgreSqlParserListener } from 'src/lib/postgresql/PostgreSqlParserListener'; +import { + AttrName, + isCommonEntityContext, + isFuncEntityContext, + StmtContextType, +} from 'src/parser/common/entityCollector'; import { EntityContextType } from 'src/parser/common/types'; -import { StmtContextType } from 'src/parser/common/entityCollector'; import { PostgreSQL, PostgreSqlEntityCollector, @@ -23,7 +28,7 @@ describe('PostgreSql entity collector tests', () => { }); test('split results', () => { - expect(splitListener.statementsContext.length).toBe(10); + expect(splitListener.statementsContext.length).toBe(11); }); test('create database', () => { @@ -76,14 +81,15 @@ describe('PostgreSql entity collector tests', () => { startColumn: 1, endColumn: 122, }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); - expect(tableCreateEntity.columns).toBeNull(); - - expect(tableCreateEntity.relatedEntities.length).toBe(2); - tableCreateEntity.relatedEntities.forEach((relatedEntity) => { - expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); - expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); - }); + expect(tableCreateEntity.relatedEntities.length).toBe(2); + tableCreateEntity.relatedEntities.forEach((relatedEntity) => { + expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); + }); + } expect(allEntities[1].text).toBe('films'); expect(allEntities[1].belongStmt.rootStmt).toBe(allEntities[0].belongStmt); @@ -138,15 +144,35 @@ describe('PostgreSql entity collector tests', () => { startColumn: 1, endColumn: 2, }); - - expect(tableCreateEntity.columns.length).toBe(2); - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); - }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns.length).toBe(2); + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'integer', + startIndex: 290, + endIndex: 296, + line: 10, + startColumn: 13, + endColumn: 20, + }); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'varchar(40)', + startIndex: 311, + endIndex: 321, + line: 11, + startColumn: 13, + endColumn: 24, + }); + } }); test('create foreign table by columns', () => { @@ -181,15 +207,43 @@ describe('PostgreSql entity collector tests', () => { startColumn: 1, endColumn: 19, }); - - expect(tableCreateEntity.columns.length).toBe(6); - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); - }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns.length).toBe(6); + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'char(5)', + startIndex: 426, + endIndex: 432, + line: 16, + startColumn: 17, + endColumn: 24, + }); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'varchar(40)', + startIndex: 460, + endIndex: 470, + line: 17, + startColumn: 17, + endColumn: 28, + }); + expect(tableCreateEntity.columns[3][AttrName.colType]).toEqual({ + text: 'date', + startIndex: 532, + endIndex: 535, + line: 19, + startColumn: 17, + endColumn: 21, + }); + } }); test('create foreign table of partition', () => { @@ -224,15 +278,16 @@ describe('PostgreSql entity collector tests', () => { startColumn: 1, endColumn: 21, }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); - expect(tableCreateEntity.columns).toBeNull(); + expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - - const relatedEntity = tableCreateEntity.relatedEntities[0]; - expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); - expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); - expect(relatedEntity.text).toBe('measurement'); + const relatedEntity = tableCreateEntity.relatedEntities[0]; + expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); + expect(relatedEntity.text).toBe('measurement'); + } }); test('create view by select', () => { @@ -265,15 +320,16 @@ describe('PostgreSql entity collector tests', () => { startColumn: 1, endColumn: 26, }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); - expect(tableCreateEntity.columns).toBeNull(); - - expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.relatedEntities.length).toBe(1); - const relatedEntity = tableCreateEntity.relatedEntities[0]; - expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); - expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); - expect(relatedEntity.text).toBe('films'); + const relatedEntity = tableCreateEntity.relatedEntities[0]; + expect(relatedEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(allEntities.some((en) => relatedEntity === en)).toBeTruthy(); + expect(relatedEntity.text).toBe('films'); + } }); test('create materialized view by columns', () => { @@ -306,16 +362,20 @@ describe('PostgreSql entity collector tests', () => { startColumn: 1, endColumn: 17, }); - - expect(tableCreateEntity.columns.length).toBe(2); - - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); - }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns.length).toBe(2); + + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + } }); test('select with clause', () => { @@ -348,9 +408,10 @@ describe('PostgreSql entity collector tests', () => { startColumn: 36, endColumn: 67, }); - expect(tableEntity1.columns).toBeNull(); - expect(tableEntity1.relatedEntities).toBeNull(); - + if (isCommonEntityContext(tableEntity1)) { + expect(tableEntity1.columns).toBeUndefined(); + expect(tableEntity1.relatedEntities).toBeNull(); + } expect(tableEntity2.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity2.text).toBe('table_expression1'); expect(tableEntity2.position).toEqual({ @@ -370,8 +431,10 @@ describe('PostgreSql entity collector tests', () => { startColumn: 1, endColumn: 111, }); - expect(tableEntity2.columns).toBeNull(); - expect(tableEntity2.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableEntity2)) { + expect(tableEntity2.columns).toBeUndefined(); + expect(tableEntity2.relatedEntities).toBeNull(); + } }); test('insert into table', () => { @@ -404,9 +467,10 @@ describe('PostgreSql entity collector tests', () => { startColumn: 1, endColumn: 55, }); - - expect(tableInsertEntity.columns).toBeNull(); - expect(tableInsertEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableInsertEntity)) { + expect(tableInsertEntity.columns).toBeUndefined(); + expect(tableInsertEntity.relatedEntities).toBeNull(); + } }); test('create function', () => { @@ -441,8 +505,76 @@ describe('PostgreSql entity collector tests', () => { startIndex: 1359, startLine: 47, }); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } + }); + + test('select has table alias with clause', () => { + const testingContext = splitListener.statementsContext[10]; + + const collectListener = new PostgreSqlEntityCollector(commonSql); + postgreSql.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + expect(allEntities.length).toBe(2); + + const tableEntity1 = allEntities[0]; + const tableEntity2 = allEntities[1]; + expect(tableEntity1.entityContextType).toBe(EntityContextType.TABLE); + expect(tableEntity1.text).toBe('table_expression'); + expect(tableEntity1.position).toEqual({ + startIndex: 1531, + endIndex: 1546, + line: 51, + startColumn: 51, + endColumn: 67, + }); - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(tableEntity1.belongStmt.position).toEqual({ + startIndex: 1516, + endIndex: 1546, + startLine: 51, + endLine: 51, + startColumn: 36, + endColumn: 67, + }); + if (isCommonEntityContext(tableEntity1)) { + expect(tableEntity1.columns).toBeUndefined(); + expect(tableEntity1.relatedEntities).toBeNull(); + } + expect(tableEntity2.entityContextType).toBe(EntityContextType.TABLE); + expect(tableEntity2.text).toBe('table_expression1'); + expect(tableEntity2.position).toEqual({ + startIndex: 1604, + endIndex: 1620, + line: 52, + startColumn: 55, + endColumn: 72, + }); + + expect(tableEntity2.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(tableEntity2.belongStmt.position).toEqual({ + startIndex: 1481, + endIndex: 1667, + startLine: 51, + endLine: 52, + startColumn: 1, + endColumn: 119, + }); + expect(tableEntity2[AttrName.alias]).toEqual({ + text: 'tb_1', + startIndex: 1625, + endIndex: 1628, + line: 52, + startColumn: 76, + endColumn: 80, + }); + if (isCommonEntityContext(tableEntity2)) { + expect(tableEntity2.columns).toBeUndefined(); + expect(tableEntity2.relatedEntities).toBeNull(); + } }); }); diff --git a/test/parser/postgresql/contextCollect/fixtures/common.sql b/test/parser/postgresql/contextCollect/fixtures/common.sql index ce34d924..bffb7fa5 100644 --- a/test/parser/postgresql/contextCollect/fixtures/common.sql +++ b/test/parser/postgresql/contextCollect/fixtures/common.sql @@ -46,4 +46,7 @@ INSERT INTO insert_films (code, title, did, date_prod, kind) CREATE FUNCTION get_color_note (rainbow) RETURNS text AS 'SELECT note FROM my_colors WHERE color = $1' - LANGUAGE SQL; \ No newline at end of file + LANGUAGE SQL; + +WITH RECURSIVE query_name (id) AS (SELECT id FROM table_expression) +SELECT DISTINCT ON (col1,col2) random() AS name1 FROM table_expression1 AS tb_1 WHERE name1=name1 GROUP BY DISTINCT id; diff --git a/test/parser/postgresql/errorListener.test.ts b/test/parser/postgresql/errorListener.test.ts new file mode 100644 index 00000000..153f31ab --- /dev/null +++ b/test/parser/postgresql/errorListener.test.ts @@ -0,0 +1,80 @@ +import { PostgreSQL } from 'src/parser/postgresql'; + +const randomText = `dhsdansdnkla ndjnsla ndnalks`; +const sql1 = `ALTER EVENT`; +const sql2 = `CREATE FUNCTION `; +const sql3 = `SELECT name, altitude FROM ONLY cities WHERE `; +const sql4 = `DROP PROCEDURE name1 a`; + +describe('PostgreSQL validate invalid sql and test msg', () => { + const pgSQL = new PostgreSQL(); + + test('validate random text', () => { + const errors = pgSQL.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'dhsdansdnkla' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql1', () => { + const errors = pgSQL.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete'); + }); + + test('validate unComplete sql2', () => { + const errors = pgSQL.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete, expecting a new function'); + }); + + test('validate unComplete sql3', () => { + const errors = pgSQL.validate(sql3); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `Statement is incomplete, expecting an existing function or an existing column or a keyword` + ); + }); + + test('validate unComplete sql4', () => { + const errors = pgSQL.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'a' is not valid at this position, expecting an existing procedure or a keyword` + ); + }); + + test('validate random text cn', () => { + pgSQL.locale = 'zh_CN'; + const errors = pgSQL.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'dhsdansdnkla' 在此位置无效，期望一个关键字`); + }); + + test('validate unComplete sql1 cn', () => { + const errors = pgSQL.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('语句不完整'); + }); + + test('validate unComplete sql2 cn', () => { + const errors = pgSQL.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toEqual('语句不完整，期望一个新的function'); + }); + + test('validate unComplete sql3 cn', () => { + const errors = pgSQL.validate(sql3); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `语句不完整，期望一个存在的function或者一个存在的column或者一个关键字` + ); + }); + + test('validate unComplete sql4 cn', () => { + const errors = pgSQL.validate(sql4); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'a' 在此位置无效，期望一个存在的procedure或者一个关键字`); + }); +}); diff --git a/test/parser/postgresql/suggestion/tokenSuggestion.test.ts b/test/parser/postgresql/suggestion/tokenSuggestion.test.ts index de51ac99..32bd8479 100644 --- a/test/parser/postgresql/suggestion/tokenSuggestion.test.ts +++ b/test/parser/postgresql/suggestion/tokenSuggestion.test.ts @@ -17,7 +17,7 @@ describe('Postgres SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'TYPE', 'TEXT', 'STATISTICS', @@ -66,7 +66,7 @@ describe('Postgres SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'RECURSIVE', 'VIEW', 'TEMPORARY', @@ -126,7 +126,7 @@ describe('Postgres SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['FROM']); + expect(suggestion).toMatchUnorderedArray(['FROM']); }); test('After DROP', () => { @@ -138,7 +138,7 @@ describe('Postgres SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'OPERATOR', 'ROUTINE', 'PROCEDURE', @@ -188,6 +188,6 @@ describe('Postgres SQL Token Suggestion', () => { commentOtherLine(tokenSql, pos.lineNumber), pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['INTO']); + expect(suggestion).toMatchUnorderedArray(['INTO']); }); }); diff --git a/test/parser/spark/contextCollect/entityCollector.test.ts b/test/parser/spark/contextCollect/entityCollector.test.ts index 3bba4858..eabb9095 100644 --- a/test/parser/spark/contextCollect/entityCollector.test.ts +++ b/test/parser/spark/contextCollect/entityCollector.test.ts @@ -1,10 +1,15 @@ +import { ParseTreeListener } from 'antlr4ng'; import fs from 'fs'; import path from 'path'; -import { SparkSQL, SparkSqlSplitListener, SparkEntityCollector } from 'src/parser/spark'; -import { ParseTreeListener } from 'antlr4ng'; import { SparkSqlParserListener } from 'src/lib/spark/SparkSqlParserListener'; +import { + AttrName, + isCommonEntityContext, + isFuncEntityContext, + StmtContextType, +} from 'src/parser/common/entityCollector'; import { EntityContextType } from 'src/parser/common/types'; -import { StmtContextType } from 'src/parser/common/entityCollector'; +import { SparkEntityCollector, SparkSQL, SparkSqlSplitListener } from 'src/parser/spark'; const commonSql = fs.readFileSync(path.join(__dirname, 'fixtures', 'common.sql'), 'utf-8'); @@ -55,15 +60,16 @@ describe('SparkSQL entity collector tests', () => { startColumn: 1, endColumn: 52, }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.relatedEntities.length).toBe(1); + const beLikedEntity = allEntities[1]; - const beLikedEntity = allEntities[1]; - - expect(tableCreateEntity.relatedEntities[0]).toBe(beLikedEntity); - expect(beLikedEntity.text).toBe('like_old_tb'); - expect(beLikedEntity.entityContextType).toBe(EntityContextType.TABLE); - expect(beLikedEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(tableCreateEntity.relatedEntities[0]).toBe(beLikedEntity); + expect(beLikedEntity.text).toBe('like_old_tb'); + expect(beLikedEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(beLikedEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + } }); test('create hive format table', () => { @@ -87,29 +93,65 @@ describe('SparkSQL entity collector tests', () => { startColumn: 14, endColumn: 21, }); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'this is new_tb2 comment'", + startIndex: 283, + endIndex: 307, + line: 9, + startColumn: 13, + endColumn: 38, + }); expect(tableCreateEntity.belongStmt.stmtContextType).toBe( StmtContextType.CREATE_TABLE_STMT ); expect(tableCreateEntity.belongStmt.position).toEqual({ startIndex: 54, - endIndex: 242, + endIndex: 307, startLine: 3, - endLine: 8, + endLine: 9, startColumn: 1, - endColumn: 22, - }); - - expect(tableCreateEntity.relatedEntities).toBeNull(); - expect(tableCreateEntity.columns.length).toBe(2); - - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); + endColumn: 38, }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).toBeNull(); + expect(tableCreateEntity.columns.length).toBe(2); + + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.columns[0][AttrName.comment]).toEqual({ + text: "'this is new col1'", + startIndex: 97, + endIndex: 114, + line: 3, + startColumn: 44, + endColumn: 62, + }); + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'INT', + startIndex: 85, + endIndex: 87, + line: 3, + startColumn: 32, + endColumn: 35, + }); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'STRING', + startIndex: 126, + endIndex: 131, + line: 3, + startColumn: 73, + endColumn: 79, + }); + } }); test('create data source table', () => { @@ -130,11 +172,11 @@ describe('SparkSQL entity collector tests', () => { expect(tableCreateEntity.belongStmt.stmtContextType).toBe( StmtContextType.CREATE_TABLE_STMT ); - - expect(tableCreateEntity.columns).toBeNull(); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); - + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); + } expect(originTableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(originTableEntity.text).toBe('student'); expect(originTableEntity.belongStmt.rootStmt).toBe(tableCreateEntity.belongStmt); @@ -156,15 +198,35 @@ describe('SparkSQL entity collector tests', () => { expect(viewEntity.entityContextType).toBe(EntityContextType.VIEW_CREATE); expect(viewEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_VIEW_STMT); expect(viewEntity.text).toBe('new_view1'); - expect(viewEntity.columns.length).toBe(2); - viewEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(viewEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); + expect(viewEntity[AttrName.comment]).toEqual({ + text: "'View for experienced employees'", + startIndex: 455, + endIndex: 486, + line: 14, + startColumn: 9, + endColumn: 41, }); - + if (isCommonEntityContext(viewEntity)) { + expect(viewEntity.columns.length).toBe(2); + viewEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(viewEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(viewEntity.columns[0][AttrName.comment]).toEqual({ + text: "'Unique identification number'", + startIndex: 408, + endIndex: 437, + line: 13, + startColumn: 35, + endColumn: 65, + }); + } expect(tableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); expect(tableEntity.belongStmt.rootStmt).toBe(viewEntity.belongStmt); @@ -187,10 +249,26 @@ describe('SparkSQL entity collector tests', () => { expect(tableEntity1.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); expect(tableEntity1.text).toBe('employee'); + expect(tableEntity1[AttrName.alias]).toEqual({ + text: 'em', + startIndex: 602, + endIndex: 603, + line: 17, + startColumn: 55, + endColumn: 57, + }); expect(tableEntity2.entityContextType).toBe(EntityContextType.TABLE); expect(tableEntity2.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); expect(tableEntity2.text).toBe('department'); + expect(tableEntity2[AttrName.alias]).toEqual({ + text: 'dept', + startIndex: 630, + endIndex: 633, + line: 17, + startColumn: 83, + endColumn: 87, + }); }); test('insert into table values', () => { @@ -265,6 +343,14 @@ describe('SparkSQL entity collector tests', () => { StmtContextType.CREATE_DATABASE_STMT ); expect(sourceTableEntity.text).toBe('customer_db'); + expect(sourceTableEntity[AttrName.comment]).toEqual({ + text: "'this is database comment'", + startIndex: 928, + endIndex: 953, + line: 25, + startColumn: 51, + endColumn: 77, + }); }); test('use namespace', () => { @@ -299,10 +385,10 @@ describe('SparkSQL entity collector tests', () => { expect(functionEntity.text).toBe('simple_udf'); expect(functionEntity.position).toEqual({ endColumn: 38, - endIndex: 905, - line: 28, + endIndex: 1013, + line: 29, startColumn: 28, - startIndex: 896, + startIndex: 1004, }); expect(functionEntity.belongStmt.stmtContextType).toBe( @@ -310,15 +396,17 @@ describe('SparkSQL entity collector tests', () => { ); expect(functionEntity.belongStmt.position).toEqual({ endColumn: 54, - endIndex: 921, - endLine: 28, + endIndex: 1029, + endLine: 29, startColumn: 1, - startIndex: 869, - startLine: 28, + startIndex: 977, + startLine: 29, }); - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } }); test('create xxx function', () => { @@ -337,10 +425,10 @@ describe('SparkSQL entity collector tests', () => { expect(functionEntity.text).toBe('simple_udf'); expect(functionEntity.position).toEqual({ endColumn: 27, - endIndex: 950, - line: 30, + endIndex: 1058, + line: 31, startColumn: 17, - startIndex: 941, + startIndex: 1049, }); expect(functionEntity.belongStmt.stmtContextType).toBe( @@ -348,14 +436,15 @@ describe('SparkSQL entity collector tests', () => { ); expect(functionEntity.belongStmt.position).toEqual({ endColumn: 43, - endIndex: 966, - endLine: 30, + endIndex: 1074, + endLine: 31, startColumn: 1, - startIndex: 925, - startLine: 30, + startIndex: 1033, + startLine: 31, }); - - expect(functionEntity.columns).toBeNull(); - expect(functionEntity.relatedEntities).toBeNull(); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } }); }); diff --git a/test/parser/spark/contextCollect/fixtures/common.sql b/test/parser/spark/contextCollect/fixtures/common.sql index fc63a477..e3bbd97b 100644 --- a/test/parser/spark/contextCollect/fixtures/common.sql +++ b/test/parser/spark/contextCollect/fixtures/common.sql @@ -1,11 +1,12 @@ CREATE TABLE IF NOT EXISTS new_tb1 like like_old_tb; -CREATE TABLE new_tb2 (new_col1 INT, new_col2 STRING) +CREATE TABLE new_tb2 (new_col1 INT COMMENT 'this is new col1', new_col2 STRING) PARTITIONED BY (YEAR STRING) CLUSTERED BY (new_col1, NAME) SORTED BY (new_col1 ASC) INTO 3 BUCKETS - STORED AS PARQUET; + STORED AS PARQUET + COMMENT 'this is new_tb2 comment'; CREATE TABLE student_copy USING CSV AS SELECT * FROM student; @@ -13,7 +14,7 @@ CREATE VIEW new_view1 (ID COMMENT 'Unique identification number', Name) COMMENT 'View for experienced employees' AS SELECT id, name FROM old_tb_1 WHERE working_years > 5; -SELECT id, name, employee.deptno, deptname FROM employee CROSS JOIN department; +SELECT id, name, em.deptno, deptname FROM employee AS em CROSS JOIN department AS dept; INSERT INTO insert_tb (address, name, student_id) VALUES ('Hangzhou, China', 'Kent Yao', 11215016); @@ -21,7 +22,7 @@ INSERT OVERWRITE target_tb TABLE source_tb; INSERT OVERWRITE DIRECTORY '/path/to/output/directory' SELECT * FROM from_tb WHERE condition; -CREATE DATABASE IF NOT EXISTS customer_db; +CREATE DATABASE IF NOT EXISTS customer_db COMMENT 'this is database comment'; USE NAMESPACE ns1; diff --git a/test/parser/spark/errorListener.test.ts b/test/parser/spark/errorListener.test.ts new file mode 100644 index 00000000..bc356160 --- /dev/null +++ b/test/parser/spark/errorListener.test.ts @@ -0,0 +1,67 @@ +import { SparkSQL } from 'src/parser/spark'; + +const randomText = `dhsdansdnkla ndjnsla ndnalks`; +const sql1 = `ALTER VIEW`; +const sql2 = `SELECT * FROM `; +const sql3 = `DROP SCHEMA aaa aaa`; + +describe('SparkSQL validate invalid sql and test msg', () => { + const spark = new SparkSQL(); + + test('validate random text', () => { + const errors = spark.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'dhsdansdnkla' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql1', () => { + const errors = spark.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete'); + }); + + test('validate unComplete sql2', () => { + const errors = spark.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + 'Statement is incomplete, expecting an existing table or an existing view or an existing function or a keyword' + ); + }); + + test('validate unComplete sql3', () => { + const errors = spark.validate(sql3); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'aaa' is not valid at this position, expecting an existing namespace or a keyword` + ); + }); + + test('validate random text cn', () => { + spark.locale = 'zh_CN'; + const errors = spark.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'dhsdansdnkla' 在此位置无效，期望一个关键字`); + }); + + test('validate unComplete sql1 cn', () => { + const errors = spark.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('语句不完整'); + }); + + test('validate unComplete sql2 cn', () => { + const errors = spark.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + '语句不完整，期望一个存在的table或者一个存在的view或者一个存在的function或者一个关键字' + ); + }); + + test('validate unComplete sql3 cn', () => { + const errors = spark.validate(sql3); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'aaa' 在此位置无效，期望一个存在的namespace或者一个关键字`); + }); +}); diff --git a/test/parser/spark/suggestion/tokenSuggestion.test.ts b/test/parser/spark/suggestion/tokenSuggestion.test.ts index b3648ddc..4cfd9eda 100644 --- a/test/parser/spark/suggestion/tokenSuggestion.test.ts +++ b/test/parser/spark/suggestion/tokenSuggestion.test.ts @@ -19,7 +19,7 @@ describe('Spark SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'TABLE', 'INDEX', 'VIEW', @@ -40,7 +40,7 @@ describe('Spark SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'TEMPORARY', 'INDEX', 'ROLE', @@ -67,7 +67,7 @@ describe('Spark SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['FROM']); + expect(suggestion).toMatchUnorderedArray(['FROM']); }); test('After DESCRIBE', () => { @@ -80,7 +80,7 @@ describe('Spark SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'WITH', 'SELECT', 'MAP', @@ -106,7 +106,7 @@ describe('Spark SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'TEMPORARY', 'INDEX', 'ROLE', @@ -130,7 +130,7 @@ describe('Spark SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['OVERWRITE', 'INTO']); + expect(suggestion).toMatchUnorderedArray(['OVERWRITE', 'INTO']); }); test('After LOAD', () => { @@ -143,7 +143,7 @@ describe('Spark SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['DATA']); + expect(suggestion).toMatchUnorderedArray(['DATA']); }); test('After SHOW', () => { @@ -156,7 +156,7 @@ describe('Spark SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'LOCKS', 'INDEXES', 'TRANSACTIONS', @@ -195,6 +195,6 @@ describe('Spark SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['TABLE']); + expect(suggestion).toMatchUnorderedArray(['TABLE']); }); }); diff --git a/test/parser/sql/contextCollect/entityCollector.test.ts b/test/parser/sql/contextCollect/entityCollector.test.ts new file mode 100644 index 00000000..9ca11d6a --- /dev/null +++ b/test/parser/sql/contextCollect/entityCollector.test.ts @@ -0,0 +1,450 @@ +import { ParseTreeListener } from 'antlr4ng'; +import fs from 'fs'; +import path from 'path'; +import { SqlParserListener } from 'src/lib/sql/SqlParserListener'; +import { + AttrName, + isCommonEntityContext, + isFuncEntityContext, + StmtContextType, +} from 'src/parser/common/entityCollector'; +import { EntityContextType } from 'src/parser/common/types'; +import { SqlEntityCollector, Sql, SqlSplitListener } from 'src/parser/sql'; + +const commonSql = fs.readFileSync(path.join(__dirname, 'fixtures', 'common.sql'), 'utf-8'); + +describe('Sql entity collector tests', () => { + const sql = new Sql(); + const parseTree = sql.parse(commonSql); + const splitListener = new SqlSplitListener(); + sql.listen(splitListener as SqlParserListener, parseTree); + + test('validate common sql', () => { + expect(sql.validate(commonSql).length).toBe(0); + }); + + test('split results', () => { + expect(splitListener.statementsContext.length).toBe(12); + }); + + test('create table like', () => { + const columnCreateTableContext = splitListener.statementsContext[0]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, columnCreateTableContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(2); + + const tableCreateEntity = allEntities[0]; + + expect(tableCreateEntity.entityContextType).toBe(EntityContextType.TABLE_CREATE); + expect(tableCreateEntity.text).toBe('new_tb1'); + expect(tableCreateEntity.position).toEqual({ + startIndex: 27, + endIndex: 33, + line: 1, + startColumn: 28, + endColumn: 35, + }); + + expect(tableCreateEntity.belongStmt.stmtContextType).toBe( + StmtContextType.CREATE_TABLE_STMT + ); + expect(tableCreateEntity.belongStmt.position).toEqual({ + startIndex: 0, + endIndex: 50, + startLine: 1, + endLine: 1, + startColumn: 1, + endColumn: 52, + }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities.length).toBe(1); + + const beLikedEntity = allEntities[1]; + + expect(tableCreateEntity.relatedEntities[0]).toBe(beLikedEntity); + expect(beLikedEntity.text).toBe('like_old_tb'); + expect(beLikedEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(beLikedEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + } + }); + + test('create hive format table', () => { + const columnCreateTableContext = splitListener.statementsContext[1]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, columnCreateTableContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(1); + + const tableCreateEntity = allEntities[0]; + + expect(tableCreateEntity.entityContextType).toBe(EntityContextType.TABLE_CREATE); + expect(tableCreateEntity.text).toBe('new_tb2'); + expect(tableCreateEntity.position).toEqual({ + startIndex: 67, + endIndex: 73, + line: 3, + startColumn: 14, + endColumn: 21, + }); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'this is new_tb2 comment'", + startIndex: 283, + endIndex: 307, + line: 9, + startColumn: 13, + endColumn: 38, + }); + + expect(tableCreateEntity.belongStmt.stmtContextType).toBe( + StmtContextType.CREATE_TABLE_STMT + ); + expect(tableCreateEntity.belongStmt.position).toEqual({ + startIndex: 54, + endIndex: 307, + startLine: 3, + endLine: 9, + startColumn: 1, + endColumn: 38, + }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities).toBeNull(); + expect(tableCreateEntity.columns.length).toBe(2); + + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.columns[0][AttrName.comment]).toEqual({ + text: "'this is new col1'", + startIndex: 97, + endIndex: 114, + line: 3, + startColumn: 44, + endColumn: 62, + }); + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'INT', + startIndex: 85, + endIndex: 87, + line: 3, + startColumn: 32, + endColumn: 35, + }); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'STRING', + startIndex: 126, + endIndex: 131, + line: 3, + startColumn: 73, + endColumn: 79, + }); + } + }); + + test('create data source table', () => { + const testingContext = splitListener.statementsContext[2]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(2); + + const tableCreateEntity = allEntities[0]; + const originTableEntity = allEntities[1]; + + expect(tableCreateEntity.entityContextType).toBe(EntityContextType.TABLE_CREATE); + expect(tableCreateEntity.text).toBe('student_copy'); + expect(tableCreateEntity.belongStmt.stmtContextType).toBe( + StmtContextType.CREATE_TABLE_STMT + ); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); + } + expect(originTableEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(originTableEntity.text).toBe('student'); + expect(originTableEntity.belongStmt.rootStmt).toBe(tableCreateEntity.belongStmt); + }); + + test('create view', () => { + const testingContext = splitListener.statementsContext[3]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(2); + + const viewEntity = allEntities[0]; + const tableEntity = allEntities[1]; + + expect(viewEntity.entityContextType).toBe(EntityContextType.VIEW_CREATE); + expect(viewEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_VIEW_STMT); + expect(viewEntity.text).toBe('new_view1'); + expect(viewEntity[AttrName.comment]).toEqual({ + text: "'View for experienced employees'", + startIndex: 455, + endIndex: 486, + line: 14, + startColumn: 9, + endColumn: 41, + }); + if (isCommonEntityContext(viewEntity)) { + expect(viewEntity.columns.length).toBe(2); + viewEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(viewEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(viewEntity.columns[0][AttrName.comment]).toEqual({ + text: "'Unique identification number'", + startIndex: 408, + endIndex: 437, + line: 13, + startColumn: 35, + endColumn: 65, + }); + } + expect(tableEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(tableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(tableEntity.belongStmt.rootStmt).toBe(viewEntity.belongStmt); + expect(tableEntity.text).toBe('old_tb_1'); + }); + + test('select from table', () => { + const testingContext = splitListener.statementsContext[4]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(2); + + const tableEntity1 = allEntities[0]; + const tableEntity2 = allEntities[1]; + + expect(tableEntity1.entityContextType).toBe(EntityContextType.TABLE); + expect(tableEntity1.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(tableEntity1.text).toBe('employee'); + expect(tableEntity1[AttrName.alias]).toEqual({ + text: 'em', + startIndex: 602, + endIndex: 603, + line: 17, + startColumn: 55, + endColumn: 57, + }); + + expect(tableEntity2.entityContextType).toBe(EntityContextType.TABLE); + expect(tableEntity2.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(tableEntity2.text).toBe('department'); + expect(tableEntity2[AttrName.alias]).toEqual({ + text: 'dept', + startIndex: 630, + endIndex: 633, + line: 17, + startColumn: 83, + endColumn: 87, + }); + }); + + test('insert into table values', () => { + const testingContext = splitListener.statementsContext[5]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(1); + + const tableEntity = allEntities[0]; + + expect(tableEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(tableEntity.belongStmt.stmtContextType).toBe(StmtContextType.INSERT_STMT); + expect(tableEntity.text).toBe('insert_tb'); + }); + + test('insert overwrite table', () => { + const testingContext = splitListener.statementsContext[6]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(2); + + const targetTableEntity = allEntities[0]; + const sourceTableEntity = allEntities[1]; + + expect(targetTableEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(targetTableEntity.belongStmt.stmtContextType).toBe(StmtContextType.INSERT_STMT); + expect(targetTableEntity.text).toBe('target_tb'); + + expect(sourceTableEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(sourceTableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(sourceTableEntity.belongStmt.rootStmt).toBe(targetTableEntity.belongStmt); + expect(sourceTableEntity.text).toBe('source_tb'); + }); + + test('insert overwrite dir', () => { + const testingContext = splitListener.statementsContext[7]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + expect(allEntities.length).toBe(1); + + const sourceTableEntity = allEntities[0]; + + expect(sourceTableEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(sourceTableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(sourceTableEntity.text).toBe('from_tb'); + }); + + test('create database', () => { + const testingContext = splitListener.statementsContext[8]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + expect(allEntities.length).toBe(1); + + const sourceTableEntity = allEntities[0]; + + expect(sourceTableEntity.entityContextType).toBe(EntityContextType.DATABASE_CREATE); + expect(sourceTableEntity.belongStmt.stmtContextType).toBe( + StmtContextType.CREATE_DATABASE_STMT + ); + expect(sourceTableEntity.text).toBe('customer_db'); + expect(sourceTableEntity[AttrName.comment]).toEqual({ + text: "'this is database comment'", + startIndex: 928, + endIndex: 953, + line: 25, + startColumn: 51, + endColumn: 77, + }); + }); + + test('use namespace', () => { + const testingContext = splitListener.statementsContext[9]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + expect(allEntities.length).toBe(1); + + const sourceTableEntity = allEntities[0]; + + expect(sourceTableEntity.entityContextType).toBe(EntityContextType.DATABASE); + expect(sourceTableEntity.belongStmt.stmtContextType).toBe(StmtContextType.COMMON_STMT); + expect(sourceTableEntity.text).toBe('ns1'); + }); + + test('create function', () => { + const functionContext = splitListener.statementsContext[10]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, functionContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(1); + + const functionEntity = allEntities[0]; + + expect(functionEntity.entityContextType).toBe(EntityContextType.FUNCTION_CREATE); + expect(functionEntity.text).toBe('simple_udf'); + expect(functionEntity.position).toEqual({ + endColumn: 38, + endIndex: 1013, + line: 29, + startColumn: 28, + startIndex: 1004, + }); + + expect(functionEntity.belongStmt.stmtContextType).toBe( + StmtContextType.CREATE_FUNCTION_STMT + ); + expect(functionEntity.belongStmt.position).toEqual({ + endColumn: 54, + endIndex: 1029, + endLine: 29, + startColumn: 1, + startIndex: 977, + startLine: 29, + }); + + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } + }); + + test('create xxx function', () => { + const functionContext = splitListener.statementsContext[11]; + + const collectListener = new SqlEntityCollector(commonSql); + sql.listen(collectListener as ParseTreeListener, functionContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(1); + + const functionEntity = allEntities[0]; + + expect(functionEntity.entityContextType).toBe(EntityContextType.FUNCTION_CREATE); + expect(functionEntity.text).toBe('simple_udf'); + expect(functionEntity.position).toEqual({ + endColumn: 27, + endIndex: 1058, + line: 31, + startColumn: 17, + startIndex: 1049, + }); + + expect(functionEntity.belongStmt.stmtContextType).toBe( + StmtContextType.CREATE_FUNCTION_STMT + ); + expect(functionEntity.belongStmt.position).toEqual({ + endColumn: 43, + endIndex: 1074, + endLine: 31, + startColumn: 1, + startIndex: 1033, + startLine: 31, + }); + if (isFuncEntityContext(functionEntity)) { + expect(functionEntity.arguments).toBeNull(); + expect(functionEntity.relatedEntities).toBeNull(); + } + }); +}); diff --git a/test/parser/sql/contextCollect/fixtures/common.sql b/test/parser/sql/contextCollect/fixtures/common.sql new file mode 100644 index 00000000..e3bbd97b --- /dev/null +++ b/test/parser/sql/contextCollect/fixtures/common.sql @@ -0,0 +1,31 @@ +CREATE TABLE IF NOT EXISTS new_tb1 like like_old_tb; + +CREATE TABLE new_tb2 (new_col1 INT COMMENT 'this is new col1', new_col2 STRING) + PARTITIONED BY (YEAR STRING) + CLUSTERED BY (new_col1, NAME) + SORTED BY (new_col1 ASC) + INTO 3 BUCKETS + STORED AS PARQUET + COMMENT 'this is new_tb2 comment'; + +CREATE TABLE student_copy USING CSV AS SELECT * FROM student; + +CREATE VIEW new_view1 (ID COMMENT 'Unique identification number', Name) +COMMENT 'View for experienced employees' +AS SELECT id, name FROM old_tb_1 WHERE working_years > 5; + +SELECT id, name, em.deptno, deptname FROM employee AS em CROSS JOIN department AS dept; + +INSERT INTO insert_tb (address, name, student_id) VALUES ('Hangzhou, China', 'Kent Yao', 11215016); + +INSERT OVERWRITE target_tb TABLE source_tb; + +INSERT OVERWRITE DIRECTORY '/path/to/output/directory' SELECT * FROM from_tb WHERE condition; + +CREATE DATABASE IF NOT EXISTS customer_db COMMENT 'this is database comment'; + +USE NAMESPACE ns1; + +CREATE OR REPLACE FUNCTION simple_udf AS 'SimpleUdfR'; + +CREATE FUNCTION simple_udf AS 'SimpleUdfR'; \ No newline at end of file diff --git a/test/parser/sql/errorListener.test.ts b/test/parser/sql/errorListener.test.ts new file mode 100644 index 00000000..60862059 --- /dev/null +++ b/test/parser/sql/errorListener.test.ts @@ -0,0 +1,67 @@ +import { Sql } from 'src/parser/sql'; + +const randomText = `dhsdansdnkla ndjnsla ndnalks`; +const sql1 = `ALTER VIEW`; +const sql2 = `SELECT * FROM `; +const sql3 = `DROP SCHEMA aaa aaa`; + +describe('Sql validate invalid sql and test msg', () => { + const sql = new Sql(); + + test('validate random text', () => { + const errors = sql.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'dhsdansdnkla' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql1', () => { + const errors = sql.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete'); + }); + + test('validate unComplete sql2', () => { + const errors = sql.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + 'Statement is incomplete, expecting an existing table or an existing view or an existing function or a keyword' + ); + }); + + test('validate unComplete sql3', () => { + const errors = sql.validate(sql3); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'aaa' is not valid at this position, expecting an existing namespace or a keyword` + ); + }); + + test('validate random text cn', () => { + sql.locale = 'zh_CN'; + const errors = sql.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'dhsdansdnkla' 在此位置无效，期望一个关键字`); + }); + + test('validate unComplete sql1 cn', () => { + const errors = sql.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('语句不完整'); + }); + + test('validate unComplete sql2 cn', () => { + const errors = sql.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + '语句不完整，期望一个存在的table或者一个存在的view或者一个存在的function或者一个关键字' + ); + }); + + test('validate unComplete sql3 cn', () => { + const errors = sql.validate(sql3); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'aaa' 在此位置无效，期望一个存在的namespace或者一个关键字`); + }); +}); diff --git a/test/parser/sql/errorStrategy.test.ts b/test/parser/sql/errorStrategy.test.ts new file mode 100644 index 00000000..7ee8f851 --- /dev/null +++ b/test/parser/sql/errorStrategy.test.ts @@ -0,0 +1,64 @@ +import { Sql, SqlSplitListener } from 'src/parser/sql'; +import { SqlParserListener } from 'src/lib/sql/SqlParserListener'; + +const validSQL1 = `INSERT INTO country_page_view +VALUES ('Chinese', 'mumiao', 18), + ('Amercian', 'georage', 22);`; +const validSQL2 = 'SELECT * FROM tb;'; +const inValidSQL = 'CREATE TABLE;'; + +describe('Sql ErrorStrategy test', () => { + const sql = new Sql(); + + // TODO: handle unexpected case + // test('begin inValid', () => { + // const sqlText = [inValidSQL, validSQL1, validSQL2].join('\n'); + // // parse with empty errorListener + // const parseTree = sql.parse(sqlText, () => {}); + // const splitListener = new SqlSplitListener(); + // sql.listen(splitListener as SqlParserListener, parseTree); + + // const statementCount = splitListener.statementsContext.length; + // splitListener.statementsContext.map((item, index) => { + // if (index !== statementCount - 1 && index !== statementCount - 2) { + // expect(item.exception).not.toBe(null); + // } else { + // expect(item.exception).toBe(null); + // } + // }); + // }); + + // TODO: handle unexpected case + // test('middle inValid', () => { + // const sqlText = [validSQL1, inValidSQL, validSQL2].join('\n'); + // // parse with empty errorListener + // const parseTree = sql.parse(sqlText, () => {}); + // const splitListener = new SqlSplitListener(); + // sql.listen(splitListener as SqlParserListener, parseTree); + + // const statementCount = splitListener.statementsContext.length; + // splitListener.statementsContext.map((item, index) => { + // if (index !== statementCount - 1 && index !== 0) { + // expect(item.exception).not.toBe(null); + // } else { + // expect(item.exception).toBe(null); + // } + // }); + // }); + + test('end inValid', () => { + const sqlText = [validSQL1, validSQL2, inValidSQL].join('\n'); + // parse with empty errorListener + const parseTree = sql.parse(sqlText, () => {}); + const splitListener = new SqlSplitListener(); + sql.listen(splitListener as SqlParserListener, parseTree); + + splitListener.statementsContext.map((item, index) => { + if (index !== 0 && index !== 1) { + expect(item.exception).not.toBe(null); + } else { + expect(item.exception).toBe(null); + } + }); + }); +}); diff --git a/test/parser/sql/lexer.test.ts b/test/parser/sql/lexer.test.ts new file mode 100644 index 00000000..fc566a83 --- /dev/null +++ b/test/parser/sql/lexer.test.ts @@ -0,0 +1,17 @@ +import { Sql } from 'src/parser/sql'; + +describe('Sql Lexer tests', () => { + const sql = new Sql(); + + test('select id,name from user1;', () => { + const sqlText = `select id,name from user1;`; + const tokens = sql.getAllTokens(sqlText); + expect(tokens.length).toBe(10); + }); + + test('SELECT * FROM t WHERE x = 1 AND y = 2;', () => { + const sqlText = `SELECT * FROM t WHERE x = 1 AND y = 2;`; + const tokens = sql.getAllTokens(sqlText); + expect(tokens.length).toBe(24); + }); +}); diff --git a/test/parser/sql/listener.test.ts b/test/parser/sql/listener.test.ts new file mode 100644 index 00000000..2da46474 --- /dev/null +++ b/test/parser/sql/listener.test.ts @@ -0,0 +1,63 @@ +import { Sql } from 'src/parser/sql'; +import { SqlParserListener } from 'src/lib/sql/SqlParserListener'; + +describe('Sql Listener Tests', () => { + const expectTableName = 'user1'; + const sqlText = `select id,name,sex from ${expectTableName};`; + const sql = new Sql(); + + const parseTree = sql.parse(sqlText); + + test('Listener exitTableName', () => { + class MyListener extends SqlParserListener { + result = ''; + exitTableName = (ctx): void => { + this.result = ctx.getText().toLowerCase(); + }; + } + const listener = new MyListener(); + + sql.listen(listener, parseTree); + expect(listener.result).toBe(expectTableName); + }); + + test('Split sql listener', async () => { + const singleStatementArr = [ + `SELECT /*+ REPARTITION(zip_code) */ name, age, zip_code FROM person SORT BY name ASC, age DESC;`, + + `INSERT INTO students FROM applicants SELECT name, address, student_id WHERE qualified = true;`, + + `CREATE TABLE student_bucket + USING parquet + CLUSTERED BY (id) INTO 4 buckets ( + WITH tmpTable AS ( + SELECT * FROM student WHERE id > 100 + ) + SELECT * FROM tmpTable + );`, + ]; + + const sqlText = singleStatementArr.join('\n'); + const sqlSlices = sql.splitSQLByStatement(sqlText); + + expect(sqlSlices).not.toBeNull(); + + // check text in result + expect(sqlSlices.map((item) => item.text)).toEqual(singleStatementArr); + + // check startIndex and endIndex in result + sqlSlices.forEach((slice, index) => { + expect(sqlText.slice(slice.startIndex, slice.endIndex + 1)).toBe( + singleStatementArr[index] + ); + }); + + // check lineNumber in result + expect(sqlSlices[0].startLine).toBe(1); + expect(sqlSlices[0].endLine).toBe(1); + expect(sqlSlices[1].startLine).toBe(2); + expect(sqlSlices[1].endLine).toBe(2); + expect(sqlSlices[2].startLine).toBe(3); + expect(sqlSlices[2].endLine).toBe(10); + }); +}); diff --git a/test/parser/sql/suggestion/fixtures/multipleStatement.sql b/test/parser/sql/suggestion/fixtures/multipleStatement.sql new file mode 100644 index 00000000..b794f302 --- /dev/null +++ b/test/parser/sql/suggestion/fixtures/multipleStatement.sql @@ -0,0 +1,21 @@ +CREATE TABLE VALUES -- unfinished + +CREATE TABLE student (id INT, name STRING, age INT) STORED AS ORC; + +CREATE SCHEMA customer_db WITH DBPROPERTIES (ID=001, Name='John'); + +ALTER TABLE StudentInfo ADD COLUMNS (LastName string, DOB timestamp); + +SELECT * FROM db. ; -- unfinished + +INSERT INTO weather (date, city, temp_hi, temp_lo) VALUES ('1994-11-29', 'Hayward', 54, 37); + +DESC EXTENDED students name; + +INSERT INTO weather (date, city, temp_hi, temp_lo) VALUES ('1994-11-29', 'Hayward', 54, 37); -- unfinished + +DROP TABLE IF EXISTS employable; + +DROP TEMPORARY FUNCTION test_avg; + +INSERT INTO products (product_no, name, price) SELECT * FROM db. ; -- unfinished \ No newline at end of file diff --git a/test/parser/sql/suggestion/fixtures/suggestionWithEntity.sql b/test/parser/sql/suggestion/fixtures/suggestionWithEntity.sql new file mode 100644 index 00000000..6bbbf123 --- /dev/null +++ b/test/parser/sql/suggestion/fixtures/suggestionWithEntity.sql @@ -0,0 +1,11 @@ +SELECT FROM my_db.tb; + +SELECT name, calculate_age(birthdate) AS age, FROM students; + +INSERT INTO insert_tb SELECT FROM from_tb; + +INSERT INTO insert_tb SELECT id, age, FROM from_tb; + +CREATE TABLE sorted_census_data AS SELECT FROM unsorted_census_data; + +CREATE TABLE sorted_census_data AS SELECT id, age, FROM unsorted_census_data; \ No newline at end of file diff --git a/test/parser/sql/suggestion/fixtures/syntaxSuggestion.sql b/test/parser/sql/suggestion/fixtures/syntaxSuggestion.sql new file mode 100644 index 00000000..93bcad60 --- /dev/null +++ b/test/parser/sql/suggestion/fixtures/syntaxSuggestion.sql @@ -0,0 +1,55 @@ +INSERT INTO db.tb ; + +SELECT * FROM db.; + +CREATE TABLE db. VALUES; + +DROP TABLE IF EXISTS db.a; + +CREATE OR REPLACE VIEW db.v; + +DROP VIEW db.v ; + +CREATE FUNCTION fn1; + +SELECT name, calculate_age(birthday) AS age FROM students; + +CREATE DATABASE db; + +DROP SCHEMA IF EXISTS sch; + +ANALYZE TABLE students COMPUTE STATISTICS FOR COLUMNS name, co ; + +ALTER TABLE StudentInfo ADD COLUMNS (LastName string, ); + +ALTER TABLE StudentInfo RENAME COLUMN ; + +ALTER TABLE StudentInfo RENAME COLUMN name TO t; + +ALTER TABLE StudentInfo DROP COLUMNS (LastName, ); + +ALTER TABLE StudentInfo CHANGE FirstName; + +INSERT INTO students ( ); + +INSERT INTO students ( id, n ); + +SELECT ; + +SELECT id, n; + +SELECT FROM tbl; + +SELECT id, n FROM tbl; + +SELECT id, n FROM tbl GROUP BY ; + +SELECT id, n FROM tbl ORDER BY name, i ; + +SELECT id FROM tb1 GROUP BY ROLLUP( ); + +OPTIMIZE db.tb; + +OPTIMIZE db.tb ZORDER BY ; + +OPTIMIZE db.tb ZORDER BY name, i; diff --git a/test/parser/sql/suggestion/fixtures/tokenSuggestion.sql b/test/parser/sql/suggestion/fixtures/tokenSuggestion.sql new file mode 100644 index 00000000..64741647 --- /dev/null +++ b/test/parser/sql/suggestion/fixtures/tokenSuggestion.sql @@ -0,0 +1,18 @@ +ALTER +; +CREATE +; +DELETE +; +DESCRIBE +; +DROP +; +INSERT +; +LOAD +; +SHOW +; +EXPORT +; diff --git a/test/parser/sql/suggestion/multipleStatement.test.ts b/test/parser/sql/suggestion/multipleStatement.test.ts new file mode 100644 index 00000000..83e9de75 --- /dev/null +++ b/test/parser/sql/suggestion/multipleStatement.test.ts @@ -0,0 +1,69 @@ +import fs from 'fs'; +import path from 'path'; +import { Sql } from 'src/parser/sql'; +import { CaretPosition, EntityContextType } from 'src/parser/common/types'; + +const syntaxSql = fs.readFileSync( + path.join(__dirname, 'fixtures', 'multipleStatement.sql'), + 'utf-8' +); + +describe('Sql Multiple Statements Syntax Suggestion', () => { + const sql = new Sql(); + + test('Create table ', () => { + const pos: CaretPosition = { + lineNumber: 1, + column: 14, + }; + const syntaxes = sql.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.TABLE_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Select from table', () => { + const pos: CaretPosition = { + lineNumber: 9, + column: 18, + }; + const syntaxes = sql.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.']); + }); + + test('Insert into table ', () => { + const pos: CaretPosition = { + lineNumber: 15, + column: 13, + }; + const syntaxes = sql.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Insert into select from table ', () => { + const pos: CaretPosition = { + lineNumber: 21, + column: 65, + }; + const syntaxes = sql.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.']); + }); +}); diff --git a/test/parser/sql/suggestion/suggestionWithEntity.test.ts b/test/parser/sql/suggestion/suggestionWithEntity.test.ts new file mode 100644 index 00000000..ae1cac49 --- /dev/null +++ b/test/parser/sql/suggestion/suggestionWithEntity.test.ts @@ -0,0 +1,156 @@ +import fs from 'fs'; +import path from 'path'; +import { Sql } from 'src/parser/sql'; +import { CaretPosition, EntityContextType } from 'src/parser/common/types'; +import { commentOtherLine } from 'test/helper'; + +const syntaxSql = fs.readFileSync( + path.join(__dirname, 'fixtures', 'suggestionWithEntity.sql'), + 'utf-8' +); + +describe('Sql Syntax Suggestion with collect entity', () => { + const sql = new Sql(); + + test('select with no column', () => { + const pos: CaretPosition = { + lineNumber: 1, + column: 8, + }; + const sqlText = commentOtherLine(syntaxSql, pos.lineNumber); + + const syntaxes = sql.getSuggestionAtCaretPosition(sqlText, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + + const entities = sql.getAllEntities(sqlText, pos); + expect(entities.length).toBe(1); + expect(entities[0].text).toBe('my_db.tb'); + expect(entities[0].entityContextType).toBe(EntityContextType.TABLE); + expect(entities[0].belongStmt.isContainCaret).toBeTruthy(); + }); + + test('select with columns with trailing comma', () => { + const pos: CaretPosition = { + lineNumber: 3, + column: 47, + }; + const sqlText = commentOtherLine(syntaxSql, pos.lineNumber); + + const syntaxes = sql.getSuggestionAtCaretPosition(sqlText, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + + const entities = sql.getAllEntities(sqlText, pos); + expect(entities.length).toBe(1); + expect(entities[0].text).toBe('students'); + expect(entities[0].entityContextType).toBe(EntityContextType.TABLE); + expect(entities[0].belongStmt.isContainCaret).toBeTruthy(); + }); + + test('insert into table as select with no column', () => { + const pos: CaretPosition = { + lineNumber: 5, + column: 30, + }; + const sqlText = commentOtherLine(syntaxSql, pos.lineNumber); + + const syntaxes = sql.getSuggestionAtCaretPosition(sqlText, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + + const entities = sql.getAllEntities(sqlText, pos); + expect(entities.length).toBe(2); + expect(entities[0].text).toBe('insert_tb'); + expect(entities[0].entityContextType).toBe(EntityContextType.TABLE); + expect(entities[0].belongStmt.isContainCaret).toBeTruthy(); + + expect(entities[1].text).toBe('from_tb'); + expect(entities[1].entityContextType).toBe(EntityContextType.TABLE); + expect(entities[1].belongStmt.isContainCaret).toBeTruthy(); + }); + + test('insert into table as select with trailing comma', () => { + const pos: CaretPosition = { + lineNumber: 7, + column: 39, + }; + const sqlText = commentOtherLine(syntaxSql, pos.lineNumber); + + const syntaxes = sql.getSuggestionAtCaretPosition(sqlText, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + + const entities = sql.getAllEntities(sqlText, pos); + expect(entities.length).toBe(2); + expect(entities[0].text).toBe('insert_tb'); + expect(entities[0].entityContextType).toBe(EntityContextType.TABLE); + expect(entities[0].belongStmt.isContainCaret).toBeTruthy(); + + expect(entities[1].text).toBe('from_tb'); + expect(entities[1].entityContextType).toBe(EntityContextType.TABLE); + expect(entities[1].belongStmt.isContainCaret).toBeTruthy(); + }); + + test('create table as select with no column', () => { + const pos: CaretPosition = { + lineNumber: 9, + column: 43, + }; + const sqlText = commentOtherLine(syntaxSql, pos.lineNumber); + + const syntaxes = sql.getSuggestionAtCaretPosition(sqlText, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + + const entities = sql.getAllEntities(sqlText, pos); + expect(entities.length).toBe(2); + expect(entities[0].text).toBe('sorted_census_data'); + expect(entities[0].entityContextType).toBe(EntityContextType.TABLE_CREATE); + expect(entities[0].belongStmt.isContainCaret).toBeTruthy(); + + expect(entities[1].text).toBe('unsorted_census_data'); + expect(entities[1].entityContextType).toBe(EntityContextType.TABLE); + expect(entities[1].belongStmt.isContainCaret).toBeTruthy(); + }); + + test('create table as select with trailing comma', () => { + const pos: CaretPosition = { + lineNumber: 11, + column: 52, + }; + const sqlText = commentOtherLine(syntaxSql, pos.lineNumber); + + const syntaxes = sql.getSuggestionAtCaretPosition(sqlText, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + + const entities = sql.getAllEntities(sqlText, pos); + expect(entities.length).toBe(2); + expect(entities[0].text).toBe('sorted_census_data'); + expect(entities[0].entityContextType).toBe(EntityContextType.TABLE_CREATE); + expect(entities[0].belongStmt.isContainCaret).toBeTruthy(); + + expect(entities[1].text).toBe('unsorted_census_data'); + expect(entities[1].entityContextType).toBe(EntityContextType.TABLE); + expect(entities[1].belongStmt.isContainCaret).toBeTruthy(); + }); +}); diff --git a/test/parser/sql/suggestion/syntaxSuggestion.test.ts b/test/parser/sql/suggestion/syntaxSuggestion.test.ts new file mode 100644 index 00000000..7ca8f252 --- /dev/null +++ b/test/parser/sql/suggestion/syntaxSuggestion.test.ts @@ -0,0 +1,496 @@ +import fs from 'fs'; +import path from 'path'; +import { Sql } from 'src/parser/sql'; +import { CaretPosition, EntityContextType } from 'src/parser/common/types'; +import { commentOtherLine } from 'test/helper'; + +const syntaxSql = fs.readFileSync( + path.join(__dirname, 'fixtures', 'syntaxSuggestion.sql'), + 'utf-8' +); + +describe('Sql Syntax Suggestion', () => { + const sql = new Sql(); + + test('Validate Syntax SQL', () => { + expect(sql.validate(syntaxSql).length).not.toBe(0); + expect(sql.validate(syntaxSql).length).not.toBe(0); + expect(sql.validate(syntaxSql).length).not.toBe(0); + }); + + test('Insert table ', () => { + const pos: CaretPosition = { + lineNumber: 1, + column: 18, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.', 'tb']); + }); + + test('Select table ', () => { + const pos: CaretPosition = { + lineNumber: 3, + column: 18, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.']); + }); + + test('Create table ', () => { + const pos: CaretPosition = { + lineNumber: 5, + column: 17, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.TABLE_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.']); + }); + + test('DROP table ', () => { + const pos: CaretPosition = { + lineNumber: 7, + column: 26, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.', 'a']); + }); + + test('Create view ', () => { + const pos: CaretPosition = { + lineNumber: 9, + column: 28, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.VIEW_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.', 'v']); + }); + + test('Drop view ', () => { + const pos: CaretPosition = { + lineNumber: 11, + column: 15, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.VIEW + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.', 'v']); + }); + + test('Create function ', () => { + const pos: CaretPosition = { + lineNumber: 13, + column: 20, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.FUNCTION_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['fn1']); + }); + + test('Use function', () => { + const pos: CaretPosition = { + lineNumber: 15, + column: 27, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.FUNCTION + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['calculate_age']); + }); + + test('Create database', () => { + const pos: CaretPosition = { + lineNumber: 17, + column: 19, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.DATABASE_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db']); + }); + + test('Drop database', () => { + const pos: CaretPosition = { + lineNumber: 19, + column: 26, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.DATABASE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['sch']); + }); + + test('ANALYZE table for columns', () => { + const pos: CaretPosition = { + lineNumber: 21, + column: 63, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['co']); + }); + + test('Alter table add columns', () => { + const pos: CaretPosition = { + lineNumber: 23, + column: 55, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Alter table rename columns', () => { + const pos: CaretPosition = { + lineNumber: 25, + column: 39, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Alter table rename columns to', () => { + const pos: CaretPosition = { + lineNumber: 27, + column: 48, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['t']); + }); + + test('Alter table drop columns', () => { + const pos: CaretPosition = { + lineNumber: 29, + column: 49, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Alter table change columns', () => { + const pos: CaretPosition = { + lineNumber: 31, + column: 41, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['FirstName']); + }); + + test('Insert into table spec columns', () => { + const pos: CaretPosition = { + lineNumber: 33, + column: 24, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Insert into table spec columns2', () => { + const pos: CaretPosition = { + lineNumber: 35, + column: 29, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['n']); + }); + + test('Select columns case empty', () => { + const pos: CaretPosition = { + lineNumber: 37, + column: 8, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Select columns case seq', () => { + const pos: CaretPosition = { + lineNumber: 39, + column: 13, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['n']); + }); + + test('Select columns from table case empty', () => { + const pos: CaretPosition = { + lineNumber: 41, + column: 8, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Select columns from table case seq', () => { + const pos: CaretPosition = { + lineNumber: 43, + column: 13, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['n']); + }); + + test('Select group by', () => { + const pos: CaretPosition = { + lineNumber: 45, + column: 32, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Select group by', () => { + const pos: CaretPosition = { + lineNumber: 47, + column: 39, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['i']); + }); + + test('Select group by rollup', () => { + const pos: CaretPosition = { + lineNumber: 49, + column: 37, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Optimize table', () => { + const pos: CaretPosition = { + lineNumber: 51, + column: 15, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.', 'tb']); + }); + + test('Optimize table zorder by empty', () => { + const pos: CaretPosition = { + lineNumber: 53, + column: 26, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([]); + }); + + test('Optimize table zorder by columns', () => { + const pos: CaretPosition = { + lineNumber: 55, + column: 33, + }; + const syntaxes = sql.getSuggestionAtCaretPosition( + commentOtherLine(syntaxSql, pos.lineNumber), + pos + )?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['i']); + }); +}); diff --git a/test/parser/sql/suggestion/tokenSuggestion.test.ts b/test/parser/sql/suggestion/tokenSuggestion.test.ts new file mode 100644 index 00000000..afea67ea --- /dev/null +++ b/test/parser/sql/suggestion/tokenSuggestion.test.ts @@ -0,0 +1,196 @@ +import fs from 'fs'; +import path from 'path'; +import { Sql } from 'src/parser/sql'; +import { CaretPosition } from 'src/parser/common/types'; +import { commentOtherLine } from 'test/helper'; + +const tokenSql = fs.readFileSync(path.join(__dirname, 'fixtures', 'tokenSuggestion.sql'), 'utf-8'); + +describe('Sql Token Suggestion', () => { + const sql = new Sql(); + + test('After ALTER', () => { + const pos: CaretPosition = { + lineNumber: 1, + column: 7, + }; + const suggestion = sql.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toMatchUnorderedArray([ + 'TABLE', + 'INDEX', + 'VIEW', + 'DATABASE', + 'NAMESPACE', + 'SCHEMA', + ]); + }); + + test('After CREATE', () => { + const pos: CaretPosition = { + lineNumber: 3, + column: 8, + }; + const suggestion = sql.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toMatchUnorderedArray([ + 'TEMPORARY', + 'INDEX', + 'ROLE', + 'FUNCTION', + 'OR', + 'GLOBAL', + 'VIEW', + 'TABLE', + 'EXTERNAL', + 'DATABASE', + 'NAMESPACE', + 'SCHEMA', + ]); + }); + + test('After DELETE', () => { + const pos: CaretPosition = { + lineNumber: 5, + column: 8, + }; + const suggestion = sql.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toMatchUnorderedArray(['FROM']); + }); + + test('After DESCRIBE', () => { + const pos: CaretPosition = { + lineNumber: 7, + column: 10, + }; + const suggestion = sql.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toMatchUnorderedArray([ + 'WITH', + 'SELECT', + 'MAP', + 'REDUCE', + 'FROM', + 'TABLE', + 'VALUES', + 'QUERY', + 'EXTENDED', + 'FORMATTED', + 'DATABASE', + 'FUNCTION', + ]); + }); + + test('After DROP', () => { + const pos: CaretPosition = { + lineNumber: 9, + column: 6, + }; + const suggestion = sql.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toMatchUnorderedArray([ + 'TEMPORARY', + 'INDEX', + 'ROLE', + 'FUNCTION', + 'VIEW', + 'TABLE', + 'DATABASE', + 'NAMESPACE', + 'SCHEMA', + ]); + }); + + test('After INSERT', () => { + const pos: CaretPosition = { + lineNumber: 11, + column: 8, + }; + const suggestion = sql.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toMatchUnorderedArray(['OVERWRITE', 'INTO']); + }); + + test('After LOAD', () => { + const pos: CaretPosition = { + lineNumber: 13, + column: 6, + }; + const suggestion = sql.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toMatchUnorderedArray(['DATA']); + }); + + test('After SHOW', () => { + const pos: CaretPosition = { + lineNumber: 15, + column: 6, + }; + const suggestion = sql.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toMatchUnorderedArray([ + 'LOCKS', + 'INDEXES', + 'TRANSACTIONS', + 'CREATE', + 'COMPACTIONS', + 'CURRENT', + 'ROLES', + 'PRINCIPALS', + 'ROLE', + 'GRANT', + 'CATALOGS', + 'FUNCTIONS', + 'ALL', + 'SYSTEM', + 'USER', + 'PARTITIONS', + 'VIEWS', + 'COLUMNS', + 'TBLPROPERTIES', + 'TABLE', + 'TABLES', + 'DATABASES', + 'NAMESPACES', + 'SCHEMAS', + ]); + }); + + test('After EXPORT', () => { + const pos: CaretPosition = { + lineNumber: 17, + column: 8, + }; + const suggestion = sql.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toMatchUnorderedArray(['TABLE']); + }); +}); diff --git a/test/parser/sql/syntax/all.test.ts b/test/parser/sql/syntax/all.test.ts new file mode 100644 index 00000000..07a4fe21 --- /dev/null +++ b/test/parser/sql/syntax/all.test.ts @@ -0,0 +1,72 @@ +import { Sql } from 'src/parser/sql'; +import { readSQL } from 'test/helper'; + +const features = { + alter: readSQL(__dirname, 'alter.sql'), + create: readSQL(__dirname, 'create.sql'), + drop: readSQL(__dirname, 'drop.sql'), + insert: readSQL(__dirname, 'insert.sql'), + select: readSQL(__dirname, 'select.sql'), + show: readSQL(__dirname, 'show.sql'), + truncate: readSQL(__dirname, 'truncate.sql'), + update: readSQL(__dirname, 'update.sql'), + use: readSQL(__dirname, 'use.sql'), +}; + +describe('Generic sql Syntax Tests', () => { + const flink = new Sql(); + + features.alter.forEach((itemSql) => { + it(itemSql, () => { + expect(flink.validate(itemSql).length).toBe(0); + }); + }); + + features.create.forEach((itemSql) => { + it(itemSql, () => { + expect(flink.validate(itemSql).length).toBe(0); + }); + }); + + features.drop.forEach((itemSql) => { + it(itemSql, () => { + expect(flink.validate(itemSql).length).toBe(0); + }); + }); + + features.insert.forEach((itemSql) => { + it(itemSql, () => { + expect(flink.validate(itemSql).length).toBe(0); + }); + }); + + features.select.forEach((itemSql) => { + it(itemSql, () => { + expect(flink.validate(itemSql).length).toBe(0); + }); + }); + + features.show.forEach((itemSql) => { + it(itemSql, () => { + expect(flink.validate(itemSql).length).toBe(0); + }); + }); + + features.truncate.forEach((itemSql) => { + it(itemSql, () => { + expect(flink.validate(itemSql).length).toBe(0); + }); + }); + + features.update.forEach((itemSql) => { + it(itemSql, () => { + expect(flink.validate(itemSql).length).toBe(0); + }); + }); + + features.use.forEach((itemSql) => { + it(itemSql, () => { + expect(flink.validate(itemSql).length).toBe(0); + }); + }); +}); diff --git a/test/parser/sql/syntax/fixtures/alter.sql b/test/parser/sql/syntax/fixtures/alter.sql new file mode 100644 index 00000000..dd5c21c3 --- /dev/null +++ b/test/parser/sql/syntax/fixtures/alter.sql @@ -0,0 +1,73 @@ +-- Syntax ALTER PROPERTIES +-- ALTER { DATABASE | SCHEMA | NAMESPACE } database_name SET { DBPROPERTIES | PROPERTIES } ( property_name = property_value [ , ... ] ) + +ALTER DATABASE inventory SET DBPROPERTIES ('Edited-by' = 'John', 'Edit-date' = '01/01/2001'); +ALTER DATABASE inventory SET PROPERTIES ('Edited-by' = 'John', 'Edit-date' = '01/01/2001'); + + +-- Syntax ALTER LOCATION +-- ALTER { DATABASE | SCHEMA | NAMESPACE } database_name SET LOCATION 'new_location' + +ALTER DATABASE inventory SET LOCATION 'file:/temp/spark-warehouse/new_inventory.db'; +ALTER SCHEMA inventory SET LOCATION 'file:/temp/spark-warehouse/new_inventory.db'; +ALTER NAMESPACE inventory SET LOCATION 'file:/temp/spark-warehouse/new_inventory.db'; + + +-- ============================================ + + +-- Syntax RENAME +ALTER TABLE Student RENAME TO StudentInfo; +ALTER TABLE default.StudentInfo PARTITION (age='10') RENAME TO PARTITION (age='15'); +ALTER TABLE default.StudentInfo PARTITION (age=10) RENAME TO PARTITION (age=12.323); + +-- Syntax ADD COLUMNS +ALTER TABLE StudentInfo ADD COLUMNS (LastName string, DOB timestamp); + +-- Syntax DROP COLUMNS +ALTER TABLE StudentInfo DROP columns (LastName, DOB); + +-- Syntax RENAME COLUMN +ALTER TABLE StudentInfo RENAME COLUMN name TO FirstName; + +-- Syntax ALTER OR CHANGE COLUMN +ALTER TABLE StudentInfo ALTER COLUMN FirstName COMMENT "new comment"; +ALTER TABLE StudentInfo CHANGE COLUMN FirstName COMMENT "new comment"; +ALTER TABLE StudentInfo ALTER FirstName COMMENT "new comment"; +ALTER TABLE StudentInfo CHANGE FirstName COMMENT "new comment"; + +-- Syntax REPLACE COLUMNS +ALTER TABLE StudentInfo REPLACE COLUMNS (name string, ID int COMMENT 'new comment'); +ALTER TABLE StudentInfo REPLACE COLUMNS name string, ID int COMMENT 'new comment'; + +-- Syntax ADD PARTITION +ALTER TABLE StudentInfo ADD IF NOT EXISTS PARTITION (age=18); +ALTER TABLE StudentInfo ADD PARTITION (age=18); +-- Adding multiple partitions to the table +ALTER TABLE StudentInfo ADD IF NOT EXISTS PARTITION (age=18) PARTITION (age=20); +ALTER TABLE StudentInfo ADD PARTITION (age=18) PARTITION (age=20); + +-- Syntax DROP PARTITION +ALTER TABLE StudentInfo DROP IF EXISTS PARTITION (age=18); + +-- Syntax SET SERDE +ALTER TABLE test_tab SET SERDE 'org.apache.hadoop.hive.serde2.columnar.LazyBinaryColumnarSerDe'; +ALTER TABLE dbx.tab1 SET SERDE 'org.apache.hadoop' WITH SERDEPROPERTIES ('k' = 'v', 'kay' = 'vee') + +-- Syntax SET LOCATION And SET FILE FORMAT +ALTER TABLE loc_orc SET FILEFORMAT orc; +ALTER TABLE p1 partition (month=2, day=2) SET FILEFORMAT parquet; +ALTER TABLE dbx.tab1 PARTITION (a='1', b='2') SET LOCATION '/path/to/part/ways' +ALTER TABLE dbx.tab1 SET LOCATION '/path/to/part/ways' + +-- Syntax RECOVER PARTITIONS +ALTER TABLE dbx.tab1 RECOVER PARTITIONS; + + +-- ============================================ + + +-- Syntax RENAME View +ALTER VIEW tempdb1.v1 RENAME TO tempdb1.v2; +-- Syntax ALTER View AS SELECT +ALTER VIEW tempdb1.v2 AS SELECT * FROM tempdb1.v1; diff --git a/test/parser/sql/syntax/fixtures/create.sql b/test/parser/sql/syntax/fixtures/create.sql new file mode 100644 index 00000000..ac631cd0 --- /dev/null +++ b/test/parser/sql/syntax/fixtures/create.sql @@ -0,0 +1,282 @@ +-- Syntax +-- CREATE { DATABASE | SCHEMA } [ IF NOT EXISTS ] database_name [ COMMENT database_comment ] [ LOCATION database_directory ] [ WITH DBPROPERTIES ( property_name = property_value [ , ... ] ) ] + +CREATE DATABASE IF NOT EXISTS customer_db; +CREATE DATABASE customer_db; + +CREATE SCHEMA IF NOT EXISTS customer_db; +CREATE SCHEMA customer_db; + +CREATE DATABASE IF NOT EXISTS customer_db COMMENT 'This is customer database' LOCATION '/user' WITH DBPROPERTIES (ID=001, Name='John'); +CREATE DATABASE IF NOT EXISTS customer_db LOCATION '/user' WITH DBPROPERTIES (ID=001, Name='John'); +CREATE DATABASE IF NOT EXISTS customer_db WITH DBPROPERTIES (ID=001, Name='John'); +CREATE DATABASE customer_db COMMENT 'This is customer database' LOCATION '/user' WITH DBPROPERTIES (ID=001, Name='John'); +CREATE DATABASE customer_db LOCATION '/user' WITH DBPROPERTIES (ID=001, Name='John'); +CREATE DATABASE customer_db WITH DBPROPERTIES (ID=001, Name='John'); + +CREATE SCHEMA IF NOT EXISTS customer_db COMMENT 'This is customer database' LOCATION '/user' WITH DBPROPERTIES (ID=001, Name='John'); +CREATE SCHEMA IF NOT EXISTS customer_db LOCATION '/user' WITH DBPROPERTIES (ID=001, Name='John'); +CREATE SCHEMA IF NOT EXISTS customer_db WITH DBPROPERTIES (ID=001, Name='John'); +CREATE SCHEMA customer_db COMMENT 'This is customer database' LOCATION '/user' WITH DBPROPERTIES (ID=001, Name='John'); +CREATE SCHEMA customer_db LOCATION '/user' WITH DBPROPERTIES (ID=001, Name='John'); +CREATE SCHEMA customer_db WITH DBPROPERTIES (ID=001, Name='John'); + + +-- ============================================ + + +-- Syntax +-- CREATE [ OR REPLACE ] [ TEMPORARY ] FUNCTION [ IF NOT EXISTS ] function_name AS class_name [ resource_locations ] + +CREATE OR REPLACE TEMPORARY FUNCTION IF NOT EXISTS simple_udf AS 'SimpleUdfR' USING JAR '/tmp/SimpleUdfR.jar'; +CREATE OR REPLACE TEMPORARY FUNCTION IF NOT EXISTS simple_udf AS 'SimpleUdfR'; + +CREATE OR REPLACE FUNCTION IF NOT EXISTS simple_udf AS 'SimpleUdfR'; +CREATE TEMPORARY FUNCTION IF NOT EXISTS simple_udf AS 'SimpleUdfR'; +CREATE FUNCTION IF NOT EXISTS simple_udf AS 'SimpleUdfR'; + +CREATE OR REPLACE FUNCTION simple_udf AS 'SimpleUdfR'; +CREATE TEMPORARY FUNCTION simple_udf AS 'SimpleUdfR'; +CREATE FUNCTION simple_udf AS 'SimpleUdfR'; + +CREATE FUNCTION simple_udf AS 'SimpleUdf' USING JAR '/tmp/SimpleUdf.jar'; + +CREATE TEMPORARY FUNCTION simple_temp_udf AS 'SimpleUdf' USING JAR '/tmp/SimpleUdf.jar'; + + +-- ============================================ + + +-- Syntax +-- CREATE TABLE [ IF NOT EXISTS ] table_identifier +-- [ ( col_name1 col_type1 [ COMMENT col_comment1 ], ... ) ] +-- USING data_source +-- [ OPTIONS ( key1=val1, key2=val2, ... ) ] +-- [ PARTITIONED BY ( col_name1, col_name2, ... ) ] +-- [ CLUSTERED BY ( col_name3, col_name4, ... ) +-- [ SORTED BY ( col_name [ ASC | DESC ], ... ) ] +-- INTO num_buckets BUCKETS ] +-- [ LOCATION path ] +-- [ COMMENT table_comment ] +-- [ TBLPROPERTIES ( key1=val1, key2=val2, ... ) ] +-- [ AS select_statement ] + + +--Use data source +CREATE TABLE student (id INT, name STRING, age INT) USING CSV; +CREATE TABLE IF NOT EXISTS student (id INT, name STRING, age INT) USING CSV; + +--Use data from another table +CREATE TABLE student_copy USING CSV AS SELECT * FROM student; + +--Omit the USING clause, which uses the default data source (parquet by default) +CREATE TABLE student (id INT, name STRING, age INT); + +--Use parquet data source with parquet storage options +--The columns 'id' and 'name' enable the bloom filter during writing parquet file, +--column 'age' does not enable +CREATE TABLE student_parquet(id INT, name STRING, age INT) USING PARQUET + OPTIONS ( + 'parquet.bloom.filter.enabled'='true', + 'parquet.bloom.filter.enabled#age'='false' + ); + +--Specify table comment and properties +CREATE TABLE student (id INT, name STRING, age INT) USING CSV + LOCATION 'file:/temp/spark-warehouse/new_inventory.db' + COMMENT 'this is a comment' + TBLPROPERTIES ('foo'='bar'); + +--Specify table comment and properties with different clauses order +CREATE TABLE student (id INT, name STRING, age INT) USING CSV + TBLPROPERTIES ('foo'='bar') + COMMENT 'this is a comment'; + +--Create partitioned and bucketed table +CREATE TABLE student (id INT, name STRING, age INT) + USING CSV + PARTITIONED BY (age) + CLUSTERED BY (Id) + SORTED BY (Id ASC) INTO 4 buckets; + +--Create partitioned and bucketed table through CTAS +CREATE TABLE student_partition_bucket + USING parquet + PARTITIONED BY (age) + CLUSTERED BY (id) INTO 4 buckets + AS SELECT * FROM student; + +--Create bucketed table through CTAS and CTE +CREATE TABLE student_bucket + USING parquet + CLUSTERED BY (id) INTO 4 buckets ( + WITH tmpTable AS ( + SELECT * FROM student WHERE id > 100 + ) + SELECT * FROM tmpTable +); + +-- dtstack SparkSQL/HiveSQL lifecycle +CREATE TABLE IF NOT EXISTS t1 ( + id INT COMMENT '索引', + name STRING COMMENT '姓名', + age SMALLINT COMMENT '年龄' +) COMMENT "t1表" lifecycle 29; + + +-- ============================================ + + +-- Syntax +-- CREATE [ EXTERNAL ] TABLE [ IF NOT EXISTS ] table_identifier +-- [ ( col_name1[:] col_type1 [ COMMENT col_comment1 ], ... ) ] +-- [ COMMENT table_comment ] +-- [ PARTITIONED BY ( col_name2[:] col_type2 [ COMMENT col_comment2 ], ... ) +-- | ( col_name1, col_name2, ... ) ] +-- [ CLUSTERED BY ( col_name1, col_name2, ...) +-- [ SORTED BY ( col_name1 [ ASC | DESC ], col_name2 [ ASC | DESC ], ... ) ] +-- INTO num_buckets BUCKETS ] +-- [ ROW FORMAT row_format ] +-- [ STORED AS file_format ] +-- [ LOCATION path ] +-- [ TBLPROPERTIES ( key1=val1, key2=val2, ... ) ] +-- [ AS select_statement ] + +--Use hive format +CREATE TABLE student (id INT, name STRING, age INT) STORED AS ORC; + +--Use data from another table +CREATE TABLE student_copy STORED AS ORC + AS SELECT * FROM student; + +--Specify table comment and properties +CREATE TABLE student (id INT, name STRING, age INT) + COMMENT 'this is a comment' + STORED AS ORC + TBLPROPERTIES ('foo'='bar'); + +--Specify table comment and properties with different clauses order +CREATE TABLE student (id INT, name STRING, age INT) + STORED AS ORC + TBLPROPERTIES ('foo'='bar') + COMMENT 'this is a comment'; + +--Create partitioned table +CREATE TABLE student (id INT, name STRING) + PARTITIONED BY (age INT) + STORED AS ORC; + +--Create partitioned table with different clauses order +CREATE TABLE student (id INT, name STRING) + STORED AS ORC + PARTITIONED BY (age INT); + +--Use Row Format and file format +CREATE TABLE IF NOT EXISTS student (id INT, name STRING) + ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' + STORED AS TEXTFILE; + +--Use complex datatype +CREATE EXTERNAL TABLE family( + name STRING, + friends ARRAY, + children MAP, + address STRUCT + ) + ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' ESCAPED BY '\\' + COLLECTION ITEMS TERMINATED BY '_' + MAP KEYS TERMINATED BY ':' + LINES TERMINATED BY '\n' + NULL DEFINED AS 'foonull' + STORED AS TEXTFILE + LOCATION '/tmp/family/'; + +--Use predefined custom SerDe +CREATE TABLE avroExample + ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe' + STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.avro.AvroContainerInputFormat' + OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.avro.AvroContainerOutputFormat' + TBLPROPERTIES ('avro.schema.literal'='{ "namespace": "org.apache.hive", + "name": "first_schema", + "type": "record", + "fields": [ + { "name":"string1", "type":"string" }, + { "name":"string2", "type":"string" } + ] }'); + +--Use personalized custom SerDe(we may need to `ADD JAR xxx.jar` first to ensure we can find the serde_class, +--or you may run into `CLASSNOTFOUND` exception) +ADD JAR /tmp/hive_serde_example.jar; + +CREATE EXTERNAL TABLE family (id INT, name STRING) + ROW FORMAT SERDE 'com.ly.spark.serde.SerDeExample' + STORED AS INPUTFORMAT 'com.ly.spark.example.serde.io.SerDeExampleInputFormat' + OUTPUTFORMAT 'com.ly.spark.example.serde.io.SerDeExampleOutputFormat' + LOCATION '/tmp/family/'; + +--Use `CLUSTERED BY` clause to create bucket table without `SORTED BY` +CREATE TABLE clustered_by_test1 (ID INT, AGE STRING) + CLUSTERED BY (ID) + INTO 4 BUCKETS + STORED AS ORC + +--Use `CLUSTERED BY` clause to create bucket table with `SORTED BY` +CREATE TABLE clustered_by_test2 (ID INT, NAME STRING) + PARTITIONED BY (YEAR STRING) + CLUSTERED BY (ID, NAME) + SORTED BY (ID ASC) + INTO 3 BUCKETS + STORED AS PARQUET + + +-- ============================================ + + +-- Syntax +-- CREATE TABLE [IF NOT EXISTS] table_identifier LIKE source_table_identifier +-- USING data_source +-- [ ROW FORMAT row_format ] +-- [ STORED AS file_format ] +-- [ TBLPROPERTIES ( key1=val1, key2=val2, ... ) ] +-- [ LOCATION path ] + +-- Create table using an existing table +CREATE TABLE Student_Duple like Student; +CREATE TABLE IF NOT EXISTS Student_Duple like Student; + +-- Create table like using a data source +CREATE TABLE Student_Duple like Student USING CSV; + +-- Table is created as external table at the location specified +CREATE TABLE Student_Duple like Student location '/root1/home'; + +-- Create table like using a rowformat +CREATE TABLE Student_Duple like Student + ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' + STORED AS TEXTFILE + TBLPROPERTIES ('owner'='xxxx'); + + +-- ============================================ + + +-- dtstack SparkSQL/HiveSQL lifecycle +CREATE TABLE Student_Duple like Student + ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' + STORED AS TEXTFILE + TBLPROPERTIES ('owner'='xxxx') lifecycle 29; + + +-- ============================================ + + +-- Syntax +-- CREATE [ OR REPLACE ] [ [ GLOBAL ] TEMPORARY ] VIEW [ IF NOT EXISTS ] view_identifier create_view_clauses AS query + +CREATE OR REPLACE VIEW experienced_employee (ID COMMENT 'Unique identification number', Name) COMMENT 'View for experienced employees' AS SELECT id, name FROM all_employee WHERE working_years > 5; +CREATE VIEW experienced_employee (ID COMMENT 'Unique identification number', Name) COMMENT 'View for experienced employees' AS SELECT id, name FROM all_employee WHERE working_years > 5; + +CREATE OR REPLACE GLOBAL TEMPORARY VIEW IF NOT EXISTS subscribed_movies AS SELECT mo.member_id, mb.full_name, mo.movie_title FROM movies AS mo INNER JOIN members AS mb ON mo.member_id = mb.id; +CREATE OR REPLACE GLOBAL TEMPORARY VIEW subscribed_movies AS SELECT mo.member_id, mb.full_name, mo.movie_title FROM movies AS mo INNER JOIN members AS mb ON mo.member_id = mb.id; +CREATE GLOBAL TEMPORARY VIEW IF NOT EXISTS subscribed_movies AS SELECT mo.member_id, mb.full_name, mo.movie_title FROM movies AS mo INNER JOIN members AS mb ON mo.member_id = mb.id; +CREATE GLOBAL TEMPORARY VIEW subscribed_movies AS SELECT mo.member_id, mb.full_name, mo.movie_title FROM movies AS mo INNER JOIN members AS mb ON mo.member_id = mb.id; diff --git a/test/parser/sql/syntax/fixtures/drop.sql b/test/parser/sql/syntax/fixtures/drop.sql new file mode 100644 index 00000000..d17bea74 --- /dev/null +++ b/test/parser/sql/syntax/fixtures/drop.sql @@ -0,0 +1,49 @@ +-- Syntax +-- DROP { DATABASE | SCHEMA } [ IF EXISTS ] dbname [ RESTRICT | CASCADE ] + +CREATE DATABASE inventory_db COMMENT 'This database is used to maintain Inventory'; +CREATE SCHEMA inventory_db COMMENT 'This database is used to maintain Inventory'; + +DROP DATABASE inventory_db CASCADE; +DROP SCHEMA inventory_db CASCADE; + +DROP DATABASE IF EXISTS inventory_db CASCADE; +DROP SCHEMA IF EXISTS inventory_db CASCADE; +DROP DATABASE inventory_db RESTRICT; +DROP SCHEMA inventory_db RESTRICT; + + +-- ============================================ + + +-- Syntax +-- DROP [ TEMPORARY ] FUNCTION [ IF EXISTS ] function_name + +DROP FUNCTION test_avg; +DROP TEMPORARY FUNCTION test_avg; +DROP TEMPORARY FUNCTION IF EXISTS test_avg; +DROP TEMPORARY FUNCTION test_avg; + + +-- ============================================ + + +-- Syntax +-- DROP TABLE [ IF EXISTS ] table_identifier [ PURGE ] + +DROP TABLE userDB.employable; +DROP TABLE IF EXISTS employable; +DROP TABLE employable; +DROP TABLE IF EXISTS employable PURGE; +DROP TABLE employable PURGE; + + +-- ============================================ + + +-- Syntax +-- DROP VIEW [ IF EXISTS ] view_identifier + +DROP VIEW employeeView; +DROP VIEW userDB.employeeView; +DROP VIEW IF EXISTS employeeView; diff --git a/test/parser/sql/syntax/fixtures/insert.sql b/test/parser/sql/syntax/fixtures/insert.sql new file mode 100644 index 00000000..30cb3140 --- /dev/null +++ b/test/parser/sql/syntax/fixtures/insert.sql @@ -0,0 +1,80 @@ +-- Syntax +-- INSERT INTO [ TABLE ] table_identifier REPLACE WHERE boolean_expression query + +-- Single Row Insert Using a VALUES Clause +INSERT INTO students VALUES ('Amy Smith', '123 Park Ave, San Jose', 111, 12.34, '-=--@#!$%%'); + +-- Multi-Row Insert Using a VALUES Clause +INSERT INTO students VALUES ('Bob Brown', '456 Taylor St, Cupelation', 222222), ('Cathy Johnson', '789 Race Ave, Pale Alto', 333333); + +-- Insert Using a SELECT Statement +INSERT INTO students PARTITION (student_id = 444444) SELECT name, address FROM persons WHERE name = "Dora Williams"; + +-- Insert Using a REPLACE WHERE Statement +INSERT INTO persons REPLACE WHERE ssn = 123456789 SELECT * FROM persons2; + +-- Insert Using a TABLE Statement +INSERT INTO students TABLE visiting_students; + +-- Insert Using a FROM Statement +INSERT INTO students FROM applicants SELECT name, address, student_id WHERE qualified = true; + +-- Insert Using a Typed Date Literal for a Partition Column Value +INSERT INTO students PARTITION (birthday = date'2019-01-02') VALUES ('Amy Smith', '123 Park Ave, San Jose'); + +-- Insert with a column list +INSERT INTO students (address, name, student_id) VALUES ('Hangzhou, China', 'Kent Yao', 11215016); + +-- Insert with both a partition spec and a column list +INSERT INTO students PARTITION (student_id = 11215017) (address, name) VALUES ('Hangzhou, China', 'Kent Yao Jr.'); + + +-- ============================================ + + +-- Syntax +-- INSERT OVERWRITE [ LOCAL ] DIRECTORY [ directory_path ] +-- { spark_format | hive_format } +-- { VALUES ( { value | NULL } [ , ... ] ) [ , ( ... ) ] | query } +-- USING file_format [ OPTIONS ( key = val [ , ... ] ) ] +-- [ ROW FORMAT row_format ] [ STORED AS hive_serde ] + +INSERT OVERWRITE DIRECTORY '/path/to/output/directory' SELECT * FROM your_table WHERE condition; +INSERT OVERWRITE DIRECTORY '/tmp/destination' + USING parquet + OPTIONS (col1 1, col2 2, col3 'test') + SELECT * FROM test_table; +INSERT OVERWRITE DIRECTORY + USING parquet + OPTIONS ('path' '/tmp/destination', col1 1, col2 2, col3 'test') + SELECT * FROM test_table; +INSERT OVERWRITE LOCAL DIRECTORY '/tmp/destination' + USING parquet + OPTIONS (col1 1, col2 2, col3 'test') + SELECT * FROM test_table; +INSERT OVERWRITE LOCAL DIRECTORY + USING parquet + OPTIONS ('path' '/tmp/destination', col1 1, col2 2, col3 'test') + SELECT * FROM test_table; + + +-- ============================================ + + +-- Syntax +-- INSERT [ INTO | OVERWRITE ] [ TABLE ] table_identifier [ partition_spec ] [ ( column_list ) ] { VALUES ( { value | NULL } [ , ... ] ) [ , ( ... ) ] | query } + +-- Insert Using a VALUES Clause +INSERT OVERWRITE students VALUES ('Ashur Hill', '456 Erica Ct, Cupelation', 111111), ('Brian Reed', '723 Kern Ave, Pale Alto', 222222); +-- Insert Using a SELECT Statement +INSERT OVERWRITE students PARTITION (student_id = 222222) SELECT name, address FROM persons WHERE name = "Dora Williams"; +-- Insert Using a TABLE Statement +INSERT OVERWRITE students TABLE visiting_students; +-- Insert Using a FROM Statement +INSERT OVERWRITE students FROM applicants SELECT name, address, student_id WHERE qualified = true; +-- Insert Using a Typed Date Literal for a Partition Column Value +INSERT OVERWRITE students PARTITION (birthday = date'2019-01-02') VALUES('Jason Wang', '908 Bird St, Saratoga'); +-- Insert with a column list +INSERT OVERWRITE students (address, name, student_id) VALUES ('Hangzhou, China', 'Kent Yao', 11215016); +-- Insert with both a partition spec and a column list +INSERT OVERWRITE students PARTITION (student_id = 11215016) (address, name) VALUES ('Hangzhou, China', 'Kent Yao Jr.'); diff --git a/test/parser/sql/syntax/fixtures/select.sql b/test/parser/sql/syntax/fixtures/select.sql new file mode 100644 index 00000000..cd4f9d92 --- /dev/null +++ b/test/parser/sql/syntax/fixtures/select.sql @@ -0,0 +1,573 @@ +SELECT * FROM table_name WHERE NOT (age > 30); +SELECT * FROM table_name WHERE ! (age > 30); +SELECT * FROM table_name WHERE name RLIKE 'M+'; +SELECT * FROM table_name WHERE name REGEXP 'M+'; + + +-- ============================================ + + +-- aggregate_function(input1 [, input2, ...]) FILTER (WHERE boolean_expression) +-- { PERCENTILE_CONT | PERCENTILE_DISC }(percentile) WITHIN GROUP (ORDER BY { order_by_expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] }) FILTER (WHERE boolean_expression) + +CREATE OR REPLACE TEMPORARY VIEW basic_pays AS SELECT * FROM VALUES +('Diane Murphy','Accounting',8435), +('Mary Patterson','Accounting',9998), +('Barry Jones','SCM',10586) +AS basic_pays(employee_name, department, salary); + +SELECT * FROM basic_pays; +SELECT + department, + percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) AS pc1, + percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pc2, + percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pc3, + percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pc4, + percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) AS pd1, + percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pd2, + percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pd3, + percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pd4 +FROM basic_pays +GROUP BY department +ORDER BY department; + + +-- ============================================ + + +-- CASE [ expression ] { WHEN boolean_expression THEN then_expression } [ ... ] +-- [ ELSE else_expression ] +-- END +SELECT id, CASE WHEN id > 200 THEN 'bigger' ELSE 'small' END FROM person; +SELECT id, CASE id WHEN 100 then 'bigger' WHEN id > 300 THEN '300' ELSE 'small' END FROM person; +SELECT * FROM person WHERE CASE 1 = 1 WHEN 100 THEN 'big' WHEN 200 THEN 'bigger' WHEN 300 THEN 'biggest' ELSE 'small' END = 'small'; + + +-- ============================================ + + +-- WITH common_table_expression [ , ... ] +-- expression_name [ ( column_name [ , ... ] ) ] [ AS ] ( query ) + +-- CTE with multiple column aliases +WITH t(x, y) AS (SELECT 1, 2) +SELECT * FROM t WHERE x = 1 AND y = 2; +-- CTE in CTE definition +WITH t AS (WITH t2 AS (SELECT 1) SELECT * FROM t2) SELECT * FROM t; +-- CTE in subquery expression +SELECT (WITH t AS (SELECT 1) SELECT * FROM t); +-- CTE in CREATE VIEW statement +CREATE VIEW v AS WITH t(a, b, c, d) AS (SELECT 1, 2, 3, 4) SELECT * FROM t; +SELECT * FROM v; + +-- If name conflict is detected in nested CTE, then AnalysisException is thrown by default. +-- SET spark.sql.legacy.ctePrecedencePolicy = CORRECTED (which is recommended), +-- inner CTE definitions take precedence over outer definitions. +SET spark.sql.legacy.ctePrecedencePolicy = CORRECTED; +WITH + t AS (SELECT 1), + t2 AS ( + WITH t AS (SELECT 2) + SELECT * FROM t + ) +SELECT * FROM t2; + + +-- ============================================ + + +-- CLUSTER BY { expression [ , ... ] } +SELECT name, age FROM person; +SELECT age, name FROM person CLUSTER BY age; + + +-- ============================================ + + +-- DISTRIBUTE BY { expression [ , ... ] } +SELECT age, name FROM person DISTRIBUTE BY age; + + +-- ============================================ + + +-- EXPLAIN [ EXTENDED | CODEGEN | COST | FORMATTED ] statement + +-- Default Output +EXPLAIN select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +-- Using Extended +EXPLAIN EXTENDED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; + +-- https://github.com/DTStack/dt-sql-parser/issues/131 +SELECT count(1) FROM tableName; +-- https://github.com/DTStack/dt-sql-parser/issues/131 +DELETE FROM tableName WHERE (SELECT count(1) FROM tableName WHERE pt = '20230601') > 0 AND pt = '20230601'; + + +-- ============================================ + + +-- file_format.`file_path` +SELECT * FROM parquet.`examples/src/main/resources/users.parquet`; +SELECT * FROM orc.`examples/src/main/resources/users.orc`; +SELECT * FROM json.`examples/src/main/resources/people.json`; + + +-- ============================================ + + +-- GROUP BY group_expression [ , group_expression [ , ... ] ] [ WITH { ROLLUP | CUBE } ] +-- GROUP BY { group_expression | { ROLLUP | CUBE | GROUPING SETS } (grouping_set [ , ...]) } [ , ... ] +-- aggregate_name ( [ DISTINCT ] expression [ , ... ] ) [ FILTER ( WHERE boolean_expression ) ] + +-- Sum of quantity per dealership. Group by `id`. +SELECT id, sum(quantity) FROM dealer GROUP BY id ORDER BY id; +-- Use column position in GROUP by clause. +SELECT id, sum(quantity) FROM dealer GROUP BY 1 ORDER BY 1; +-- Multiple aggregations. +-- 1. Sum of quantity per dealership. +-- 2. Max quantity per dealership. +SELECT id, sum(quantity) AS sum, max(quantity) AS max FROM dealer GROUP BY id ORDER BY id; +-- Count the number of distinct dealer cities per car_model. +SELECT car_model, count(DISTINCT city) AS count FROM dealer GROUP BY car_model; +-- Sum of only 'Honda Civic' and 'Honda CRV' quantities per dealership. +SELECT id, sum(quantity) FILTER ( + WHERE car_model IN ('Honda Civic', 'Honda CRV') + ) AS `sum(quantity)` FROM dealer + GROUP BY id ORDER BY id; + +-- Aggregations using multiple sets of grouping columns in a single statement. +-- Following performs aggregations based on four sets of grouping columns. +-- 1. city, car_model +-- 2. city +-- 3. car_model +-- 4. Empty grouping set. Returns quantities for all city and car models. +SELECT city, car_model, sum(quantity) AS sum FROM dealer + GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) + ORDER BY city; + +-- Group by processing with `ROLLUP` clause. +-- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), ()) +SELECT city, car_model, sum(quantity) AS sum FROM dealer + GROUP BY city, car_model WITH ROLLUP + ORDER BY city, car_model; + +-- Group by processing with `CUBE` clause. +-- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) +SELECT city, car_model, sum(quantity) AS sum FROM dealer + GROUP BY city, car_model WITH CUBE + ORDER BY city, car_model; + +--Select the first row in column age +SELECT FIRST(age) FROM person; + +--Get the first row in column `age` ignore nulls,last row in column `id` and sum of column `id`. +SELECT FIRST(age IGNORE NULLS), LAST(id), SUM(id) FROM person; + + +-- ============================================ + + +/*+ hint [ , ... ] */ +SELECT /*+ COALESCE(3) */ * FROM t; +SELECT /*+ REPARTITION(3) */ * FROM t; +SELECT /*+ REPARTITION(c) */ * FROM t; +SELECT /*+ REPARTITION(3, c) */ * FROM t; +SELECT /*+ REPARTITION_BY_RANGE(c) */ * FROM t; +SELECT /*+ REPARTITION_BY_RANGE(3, c) */ * FROM t; +SELECT /*+ REBALANCE */ * FROM t; +SELECT /*+ REBALANCE(3) */ * FROM t; +SELECT /*+ REBALANCE(c) */ * FROM t; +SELECT /*+ REBALANCE(3, c) */ * FROM t; + +-- multiple partitioning hints +EXPLAIN EXTENDED SELECT /*+ REPARTITION(100), COALESCE(500), REPARTITION_BY_RANGE(3, c) */ * FROM t; + +-- Join Hints for broadcast join +SELECT /*+ BROADCAST(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key; +SELECT /*+ BROADCASTJOIN (t1) */ * FROM t1 left JOIN t2 ON t1.key = t2.key; +SELECT /*+ MAPJOIN(t2) */ * FROM t1 right JOIN t2 ON t1.key = t2.key; + +-- Join Hints for shuffle sort merge join +SELECT /*+ SHUFFLE_MERGE(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key; +SELECT /*+ MERGEJOIN(t2) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key; +SELECT /*+ MERGE(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key; + +-- Join Hints for shuffle hash join +SELECT /*+ SHUFFLE_HASH(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key; + +-- Join Hints for shuffle-and-replicate nested loop join +SELECT /*+ SHUFFLE_REPLICATE_NL(t1) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key; + +SELECT /*+ BROADCAST(t1), MERGE(t1, t2) */ * FROM t1 INNER JOIN t2 ON t1.key = t2.key; + + +-- ============================================ + + +-- HAVING boolean_expression + +-- `HAVING` clause referring to column in `GROUP BY`. +SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING city = 'Fremont'; +-- `HAVING` clause referring to aggregate function. +SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum(quantity) > 15; +-- `HAVING` clause referring to aggregate function by its alias. +SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum > 15; +-- `HAVING` clause referring to a different aggregate function than what is present in +-- `SELECT` list. +SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING max(quantity) > 15; +-- `HAVING` clause referring to constant expression. +SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING 1 > 0 ORDER BY city; +-- `HAVING` clause without a `GROUP BY` clause. +SELECT sum(quantity) AS sum FROM dealer HAVING sum(quantity) > 10; + + +-- ============================================ + + +-- VALUES ( expression [ , ... ] ) [ table_alias ] + +-- single row, without a table alias +SELECT * FROM VALUES ("one", 1); +-- three rows with a table alias +SELECT * FROM VALUES ("one", 1), ("two", 2), ("three", null) AS data(a, b); +-- complex types with a table alias +SELECT * FROM VALUES ("one", array(0, 1)), ("two", array(2, 3)) AS data(a, b); + + +-- ============================================ + + +-- relation { [ join_type ] JOIN [ LATERAL ] relation [ join_criteria ] | NATURAL join_type JOIN [ LATERAL ] relation } + +-- Use employee and department tables to demonstrate different type of joins. +SELECT * FROM employee; +SELECT * FROM department; +-- Use employee and department tables to demonstrate inner join. +SELECT id, name, employee.deptno, deptname FROM employee INNER JOIN department ON employee.deptno = department.deptno; +-- Use employee and department tables to demonstrate left join. +SELECT id, name, employee.deptno, deptname FROM employee LEFT JOIN department ON employee.deptno = department.deptno; +-- Use employee and department tables to demonstrate right join. +SELECT id, name, employee.deptno, deptname FROM employee RIGHT JOIN department ON employee.deptno = department.deptno; +-- Use employee and department tables to demonstrate full join. +SELECT id, name, employee.deptno, deptname FROM employee FULL JOIN department ON employee.deptno = department.deptno; +-- Use employee and department tables to demonstrate cross join. +SELECT id, name, employee.deptno, deptname FROM employee CROSS JOIN department; +-- Use employee and department tables to demonstrate semi join. +SELECT * FROM employee SEMI JOIN department ON employee.deptno = department.deptno; +-- Use employee and department tables to demonstrate anti join. +SELECT * FROM employee ANTI JOIN department ON employee.deptno = department.deptno; + + +-- ============================================ + + +-- [ LATERAL ] primary_relation [ join_relation ] +SELECT * FROM t1, + LATERAL (SELECT * FROM t2 WHERE t1.c1 = t2.c1); +SELECT a, b, c FROM t1, + LATERAL (SELECT c1 + c2 AS a), + LATERAL (SELECT c1 - c2 AS b), + LATERAL (SELECT a * b AS c); + + +-- ============================================ + + +-- LATERAL VIEW [ OUTER ] generator_function ( expression [ , ... ] ) [ table_alias ] AS column_alias [ , ... ] + +SELECT * FROM person + LATERAL VIEW EXPLODE(ARRAY(30, 60)) tableName AS c_age + LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age; +SELECT c_age, COUNT(1) FROM person + LATERAL VIEW EXPLODE(ARRAY(30, 60)) AS c_age + LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age +GROUP BY c_age; +SELECT * FROM person LATERAL VIEW EXPLODE(ARRAY()) tableName AS c_age; +SELECT * FROM person LATERAL VIEW OUTER EXPLODE(ARRAY()) tableName AS c_age; + + +-- ============================================ + + +-- [ NOT ] { LIKE search_pattern [ ESCAPE esc_char ] | [ RLIKE | REGEXP ] regex_pattern } +-- [ NOT ] { LIKE quantifiers ( search_pattern [ , ... ]) } +SELECT * FROM person WHERE name LIKE 'M%'; +SELECT * FROM person WHERE name LIKE 'M_ry'; +SELECT * FROM person WHERE name NOT LIKE 'M_ry'; +SELECT * FROM person WHERE name RLIKE 'M+'; +SELECT * FROM person WHERE name REGEXP 'M+'; +SELECT * FROM person WHERE name LIKE '%\_%'; +SELECT * FROM person WHERE name LIKE '%$_%' ESCAPE '$'; +SELECT * FROM person WHERE name LIKE ALL ('%an%', '%an'); +SELECT * FROM person WHERE name LIKE ANY ('%an%', '%an'); +SELECT * FROM person WHERE name LIKE SOME ('%an%', '%an'); +SELECT * FROM person WHERE name NOT LIKE ALL ('%an%', '%an'); +SELECT * FROM person WHERE name NOT LIKE ANY ('%an%', '%an'); +SELECT * FROM person WHERE name NOT LIKE SOME ('%an%', '%an'); + + +-- ============================================ + + +-- LIMIT { ALL | integer_expression } +-- Select the first two rows. +SELECT name, age FROM person ORDER BY name LIMIT 2; +-- Specifying ALL option on LIMIT returns all the rows. +SELECT name, age FROM person ORDER BY name LIMIT ALL; +-- A function expression as an input to LIMIT. +SELECT name, age FROM person ORDER BY name LIMIT length('SPARK'); +-- A non-foldable expression as an input to LIMIT is not allowed. +SELECT name, age FROM person ORDER BY name LIMIT length(name); + + +-- ============================================ + + +-- OFFSET integer_expression + +-- Skip the first two rows. +SELECT name, age FROM person ORDER BY name OFFSET 2; +-- Skip the first two rows and returns the next three rows. +SELECT name, age FROM person ORDER BY name LIMIT 3 OFFSET 2; +-- A function expression as an input to OFFSET. +SELECT name, age FROM person ORDER BY name OFFSET length('SPARK'); +-- A non-foldable expression as an input to OFFSET is not allowed. +SELECT name, age FROM person ORDER BY name OFFSET length(name); + + +-- ============================================ + + +-- ORDER BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] } +-- Sort rows by age. By default rows are sorted in ascending manner with NULL FIRST. +SELECT name, age FROM person ORDER BY age; +-- Sort rows in ascending manner keeping null values to be last. +SELECT name, age FROM person ORDER BY age NULLS LAST; +-- Sort rows by age in descending manner, which defaults to NULL LAST. +SELECT name, age FROM person ORDER BY age DESC; +-- Sort rows in ascending manner keeping null values to be first. +SELECT name, age FROM person ORDER BY age DESC NULLS FIRST; +-- Sort rows based on more than one column with each column having different +-- sort direction. +SELECT * FROM person ORDER BY name ASC, age DESC; + + +-- ============================================ + + +-- PIVOT ( { aggregate_expression [ AS aggregate_expression_alias ] } [ , ... ] +-- FOR column_list IN ( expression_list ) ) +SELECT * FROM person PIVOT (SUM(age) AS a, AVG(class) AS c FOR name IN ('John' AS john, 'Mike' AS mike)); +SELECT * FROM person PIVOT (SUM(age) AS a, AVG(class) AS c FOR (name, age) IN (('John', 30) AS c1, ('Mike', 40) AS c2)); + + +-- ============================================ + + +-- [ ( ] relation [ ) ] EXCEPT | MINUS [ ALL | DISTINCT ] [ ( ] relation [ ) ] +-- Use number1 and number2 tables to demonstrate set operators in this page. +SELECT * FROM number1; +SELECT * FROM number2; +SELECT c FROM number1 EXCEPT SELECT c FROM number2; +SELECT c FROM number1 MINUS SELECT c FROM number2; +SELECT c FROM number1 EXCEPT ALL (SELECT c FROM number2); +SELECT c FROM number1 MINUS ALL (SELECT c FROM number2); + +-- [ ( ] relation [ ) ] INTERSECT [ ALL | DISTINCT ] [ ( ] relation [ ) ] +(SELECT c FROM number1) INTERSECT (SELECT c FROM number2); +(SELECT c FROM number1) INTERSECT DISTINCT (SELECT c FROM number2); +(SELECT c FROM number1) INTERSECT ALL (SELECT c FROM number2); + +-- [ ( ] relation [ ) ] UNION [ ALL | DISTINCT ] [ ( ] relation [ ) ] +(SELECT c FROM number1) UNION (SELECT c FROM number2); +(SELECT c FROM number1) UNION DISTINCT (SELECT c FROM number2); +SELECT c FROM number1 UNION ALL (SELECT c FROM number2); + + +-- ============================================ + + +-- SORT BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] } + +-- Sort rows by `name` within each partition in ascending manner +SELECT /*+ REPARTITION(zip_code) */ name, age, zip_code FROM person SORT BY name; +-- Sort rows within each partition using column position. +SELECT /*+ REPARTITION(zip_code) */ name, age, zip_code FROM person SORT BY 1; +-- Sort rows within partition in ascending manner keeping null values to be last. +SELECT /*+ REPARTITION(zip_code) */ age, name, zip_code FROM person SORT BY age NULLS LAST; +-- Sort rows by age within each partition in descending manner, which defaults to NULL LAST. +SELECT /*+ REPARTITION(zip_code) */ age, name, zip_code FROM person SORT BY age DESC; +-- Sort rows by age within each partition in descending manner keeping null values to be first. +SELECT /*+ REPARTITION(zip_code) */ age, name, zip_code FROM person SORT BY age DESC NULLS FIRST; +-- Sort rows within each partition based on more than one column with each column having +-- different sort direction. +SELECT /*+ REPARTITION(zip_code) */ name, age, zip_code FROM person SORT BY name ASC, age DESC; + + +-- ============================================ + + +-- TABLESAMPLE ({ integer_expression | decimal_expression } PERCENT) +-- | TABLESAMPLE ( integer_expression ROWS ) +-- | TABLESAMPLE ( BUCKET integer_expression OUT OF integer_expression ) + +SELECT * FROM test TABLESAMPLE (50 PERCENT); +SELECT * FROM test TABLESAMPLE (5 ROWS); +SELECT * FROM test TABLESAMPLE (BUCKET 4 OUT OF 10); + + +-- ============================================ + + +-- SELECT TRANSFORM ( expression [ , ... ] ) +-- [ ROW FORMAT row_format ] +-- [ RECORDWRITER record_writer_class ] +-- USING command_or_script [ AS ( [ col_name [ col_type ] ] [ , ... ] ) ] +-- [ ROW FORMAT row_format ] +-- [ RECORDREADER record_reader_class ] + +-- With specified output without data type +SELECT TRANSFORM(zip_code, name, age) + USING 'cat' AS (a, b, c) +FROM person +WHERE zip_code > 94511; + +-- With specified output with data type +SELECT TRANSFORM(zip_code, name, age) + USING 'cat' AS (a STRING, b STRING, c STRING) +FROM person +WHERE zip_code > 94511; + +-- Using ROW FORMAT DELIMITED +SELECT TRANSFORM(name, age) + ROW FORMAT DELIMITED + FIELDS TERMINATED BY ',' + LINES TERMINATED BY '\n' + NULL DEFINED AS 'NULL' + USING 'cat' AS (name_age string) + ROW FORMAT DELIMITED + FIELDS TERMINATED BY '@' + LINES TERMINATED BY '\n' + NULL DEFINED AS 'NULL' +FROM person; + +-- Using Hive Serde +SELECT TRANSFORM(zip_code, name, age) + ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe' + WITH SERDEPROPERTIES ( + 'field.delim' = '\t' + ) + USING 'cat' AS (a STRING, b STRING, c STRING) + ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe' + WITH SERDEPROPERTIES ( + 'field.delim' = '\t' + ) +FROM person +WHERE zip_code > 94511; + +-- Schema-less mode +SELECT TRANSFORM(zip_code, name, age) + USING 'cat' +FROM person +WHERE zip_code > 94500; + + +-- ============================================ + + +-- range call with end +SELECT * FROM range(6 + cos(3)); +-- range call with start and end +SELECT * FROM range(5, 10); +-- range call with numPartitions +SELECT * FROM range(0, 10, 2, 200); +-- range call with a table alias +SELECT * FROM range(5, 8) AS test; +SELECT explode(array(10, 20)); +SELECT inline(array(struct(1, 'a'), struct(2, 'b'))); +SELECT posexplode(array(10,20)); +SELECT stack(2, 1, 2, 3); +SELECT json_tuple('{"a":1, "b":2}', 'a', 'b'); +SELECT parse_url('http://spark.apache.org/path?query=1', 'HOST'); +SELECT * FROM test LATERAL VIEW explode (ARRAY(3,4)) AS c2; + + +-- ============================================ + + +-- UNPIVOT [ { INCLUDE | EXCLUDE } NULLS ] ( +-- { single_value_column_unpivot | multi_value_column_unpivot } +-- ) [[AS] alias] + +-- single_value_column_unpivot: +-- values_column +-- FOR name_column +-- IN (unpivot_column [[AS] alias] [, ...]) + +-- multi_value_column_unpivot: +-- (values_column [, ...]) +-- FOR name_column +-- IN ((unpivot_column [, ...]) [[AS] alias] [, ...]) + +-- column names are used as unpivot columns +SELECT * FROM sales_quarterly + UNPIVOT ( + sales FOR quarter IN (q1, q2, q3, q4) + ); + +-- NULL values are excluded by default, they can be included +-- unpivot columns can be alias +-- unpivot result can be referenced via its alias +SELECT up.* FROM sales_quarterly + UNPIVOT INCLUDE NULLS ( + sales FOR quarter IN (q1 AS Q1, q2 AS Q2, q3 AS Q3, q4 AS Q4) + ) AS up; + +-- multiple value columns can be unpivoted per row +SELECT * FROM sales_quarterly + UNPIVOT EXCLUDE NULLS ( + (first_quarter, second_quarter) + FOR half_of_the_year IN ( + (q1, q2) AS H1, + (q3, q4) AS H2 + ) + ); + + +-- ============================================ + + +-- WHERE boolean_expression + +-- Comparison operator in `WHERE` clause. +SELECT * FROM person WHERE id > 200 ORDER BY id; +-- Comparison and logical operators in `WHERE` clause. +SELECT * FROM person WHERE id = 200 OR id = 300 ORDER BY id; +-- IS NULL expression in `WHERE` clause. +SELECT * FROM person WHERE id > 300 OR age IS NULL ORDER BY id; +-- Function expression in `WHERE` clause. +SELECT * FROM person WHERE length(name) > 3 ORDER BY id; +-- `BETWEEN` expression in `WHERE` clause. +SELECT * FROM person WHERE id BETWEEN 200 AND 300 ORDER BY id; +-- Scalar Subquery in `WHERE` clause. +SELECT * FROM person WHERE age > (SELECT avg(age) FROM person); +-- Correlated Subquery in `WHERE` clause. +SELECT * FROM person AS parent WHERE EXISTS (SELECT 1 FROM person AS child WHERE parent.id = child.id AND child.age IS NULL); + + +-- ============================================ + + +-- window_function [ nulls_option ] OVER +-- ( [ { PARTITION | DISTRIBUTE } BY partition_col_name = partition_col_val ( [ , ... ] ) ] +-- { ORDER | SORT } BY expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] +-- [ window_frame ] ) + +SELECT * FROM employees; +SELECT name, dept, salary, RANK() OVER (PARTITION BY dept ORDER BY salary) AS rank FROM employees; +SELECT name, dept, salary, DENSE_RANK() OVER (PARTITION BY dept ORDER BY salary ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS dense_rank FROM employees; +SELECT name, dept, age, CUME_DIST() OVER (PARTITION BY dept ORDER BY age RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cume_dist FROM employees; +SELECT name, dept, salary, MIN(salary) OVER (PARTITION BY dept ORDER BY salary) AS min FROM employees; +SELECT name, salary, LAG(salary) OVER (PARTITION BY dept ORDER BY salary) AS lag, LEAD(salary, 1, 0) OVER (PARTITION BY dept ORDER BY salary) AS lead FROM employees; +SELECT id, v, LEAD(v, 0) IGNORE NULLS OVER w lead, LAG(v, 0) IGNORE NULLS OVER w lag, NTH_VALUE(v, 2) IGNORE NULLS OVER w nth_value, FIRST_VALUE(v) IGNORE NULLS OVER w first_value, LAST_VALUE(v) IGNORE NULLS OVER w last_value FROM test_ignore_null WINDOW w AS (ORDER BY id) ORDER BY id; diff --git a/test/parser/sql/syntax/fixtures/show.sql b/test/parser/sql/syntax/fixtures/show.sql new file mode 100644 index 00000000..209877f8 --- /dev/null +++ b/test/parser/sql/syntax/fixtures/show.sql @@ -0,0 +1,64 @@ +-- SHOW COLUMNS table_identifier [ database ] +SHOW COLUMNS IN customer; +SHOW COLUMNS IN salesdb.customer; +SHOW COLUMNS IN customer IN salesdb; + + +-- SHOW CREATE TABLE table_identifier [ AS SERDE ] +SHOW CREATE TABLE test; +SHOW CREATE TABLE test AS SERDE; + + +-- SHOW { DATABASES | SCHEMAS } [ LIKE regex_pattern ] +SHOW DATABASES; +SHOW DATABASES LIKE 'pay*'; +SHOW SCHEMAS; + + +-- SHOW [ function_kind ] FUNCTIONS [ { FROM | IN } database_name ] [ LIKE regex_pattern ] +SHOW FUNCTIONS trim; +SHOW SYSTEM FUNCTIONS concat; +SHOW SYSTEM FUNCTIONS FROM salesdb LIKE 'max'; +SHOW FUNCTIONS LIKE 't*'; +SHOW FUNCTIONS LIKE 'yea*|windo*'; +SHOW FUNCTIONS LIKE 't[a-z][a-z][a-z]'; + + +-- SHOW PARTITIONS table_identifier [ partition_spec ] +SHOW PARTITIONS customer; +SHOW PARTITIONS salesdb.customer; +SHOW PARTITIONS customer PARTITION (state = 'CA', city = 'Fremont'); +SHOW PARTITIONS customer PARTITION (state = 'CA'); +SHOW PARTITIONS customer PARTITION (city = 'San Jose'); + + +-- SHOW TABLE EXTENDED [ { IN | FROM } database_name ] LIKE regex_pattern +-- [ partition_spec ] +SHOW TABLE EXTENDED LIKE 'employee'; +SHOW TABLE EXTENDED LIKE 'employe*'; +SHOW TABLE EXTENDED IN default LIKE 'employee' PARTITION (grade=1); +SHOW TABLE EXTENDED IN default LIKE 'empl*' PARTITION (grade=1); + + +-- SHOW TABLES [ { FROM | IN } database_name ] [ LIKE regex_pattern ] +SHOW TABLES; +SHOW TABLES FROM userdb; +SHOW TABLES IN userdb; +SHOW TABLES FROM default LIKE 'sam*'; +SHOW TABLES LIKE 'sam*|suj'; + + +-- SHOW TBLPROPERTIES table_identifier +-- [ ( unquoted_property_key | property_key_as_string_literal ) ] +SHOW TBLPROPERTIES customer; +SHOW TBLPROPERTIES salesdb.customer; +SHOW TBLPROPERTIES customer (created.by.user); +SHOW TBLPROPERTIES customer ('created.date'); + + +-- SHOW VIEWS [ { FROM | IN } database_name ] [ LIKE regex_pattern ] +SHOW VIEWS; +SHOW VIEWS FROM userdb; +SHOW VIEWS IN global_temp; +SHOW VIEWS FROM default LIKE 'sam*'; +SHOW VIEWS LIKE 'sam|suj|temp*'; diff --git a/test/parser/sql/syntax/fixtures/truncate.sql b/test/parser/sql/syntax/fixtures/truncate.sql new file mode 100644 index 00000000..2b68fdac --- /dev/null +++ b/test/parser/sql/syntax/fixtures/truncate.sql @@ -0,0 +1,5 @@ +-- Syntax +-- TRUNCATE TABLE table_identifier [ partition_spec ] + +TRUNCATE TABLE Student partition(age=10); +TRUNCATE TABLE Student; diff --git a/test/parser/sql/syntax/fixtures/update.sql b/test/parser/sql/syntax/fixtures/update.sql new file mode 100644 index 00000000..c13dbddd --- /dev/null +++ b/test/parser/sql/syntax/fixtures/update.sql @@ -0,0 +1,7 @@ +UPDATE t1 SET col1 = col1 + 1; +UPDATE t1 SET col1 = col1 + 1, col2 = col1; +UPDATE t SET id = id + 1; +UPDATE items SET retail = retail * 0.9 WHERE id IN (SELECT id FROM items WHERE retail / wholesale >= 1.3 AND quantity > 100); +UPDATE LOW_PRIORITY t1 SET col1 = col1 + 1 WHERE age = 12; +UPDATE IGNORE t1 SET col1 = col1 + 1 WHERE age = 12; +UPDATE t1 SET col1 = col1 + 1 WHERE age = 12; diff --git a/test/parser/sql/syntax/fixtures/use.sql b/test/parser/sql/syntax/fixtures/use.sql new file mode 100644 index 00000000..7e284a3d --- /dev/null +++ b/test/parser/sql/syntax/fixtures/use.sql @@ -0,0 +1,4 @@ +-- Syntax +-- USE database_name + +USE userDB; diff --git a/test/parser/sql/validateInvalidSql.test.ts b/test/parser/sql/validateInvalidSql.test.ts new file mode 100644 index 00000000..7828e085 --- /dev/null +++ b/test/parser/sql/validateInvalidSql.test.ts @@ -0,0 +1,16 @@ +import { Sql } from 'src/parser/sql'; + +const randomText = `dhsdansdnkla ndjnsla ndnalks`; +const unCompleteSQL = `CREATE TABLE`; + +describe('Sql validate invalid sql', () => { + const sql = new Sql(); + + test('validate random text', () => { + expect(sql.validate(randomText).length).not.toBe(0); + }); + + test('validate unComplete sql', () => { + expect(sql.validate(unCompleteSQL).length).not.toBe(0); + }); +}); diff --git a/test/parser/sql/visitor.test.ts b/test/parser/sql/visitor.test.ts new file mode 100644 index 00000000..b6382f99 --- /dev/null +++ b/test/parser/sql/visitor.test.ts @@ -0,0 +1,33 @@ +import { Sql } from 'src/parser/sql'; +import { SqlParserVisitor } from 'src/lib/sql/SqlParserVisitor'; + +describe('Sql Visitor Tests', () => { + const expectTableName = 'user1'; + const sqlText = `select id,name,sex from ${expectTableName};`; + const sql = new Sql(); + + const parseTree = sql.parse(sqlText, (error) => { + console.error('Parse error:', error); + }); + + test('Visitor visitTableName', () => { + class MyVisitor extends SqlParserVisitor { + defaultResult(): string { + return ''; + } + aggregateResult(aggregate: string, nextResult: string): string { + return aggregate + nextResult; + } + visitProgram = (ctx) => { + return this.visitChildren(ctx); + }; + visitTableName = (ctx) => { + return ctx.getText().toLowerCase(); + }; + } + const visitor = new MyVisitor(); + const result = visitor.visit(parseTree); + + expect(result).toBe(expectTableName); + }); +}); diff --git a/test/parser/trino/contextCollect/entityCollector.test.ts b/test/parser/trino/contextCollect/entityCollector.test.ts index d6471701..61a3defc 100644 --- a/test/parser/trino/contextCollect/entityCollector.test.ts +++ b/test/parser/trino/contextCollect/entityCollector.test.ts @@ -1,10 +1,14 @@ +import { ParseTreeListener } from 'antlr4ng'; import fs from 'fs'; import path from 'path'; -import { TrinoSQL, TrinoSqlSplitListener, TrinoEntityCollector } from 'src/parser/trino'; -import { ParseTreeListener } from 'antlr4ng'; import { TrinoSqlListener } from 'src/lib/trino/TrinoSqlListener'; +import { + AttrName, + isCommonEntityContext, + StmtContextType, +} from 'src/parser/common/entityCollector'; import { EntityContextType } from 'src/parser/common/types'; -import { StmtContextType } from 'src/parser/common/entityCollector'; +import { TrinoEntityCollector, TrinoSQL, TrinoSqlSplitListener } from 'src/parser/trino'; const commonSql = fs.readFileSync(path.join(__dirname, 'fixtures', 'common.sql'), 'utf-8'); @@ -19,7 +23,7 @@ describe('Trino entity collector tests', () => { }); test('split results', () => { - expect(splitListener.statementsContext.length).toBe(9); + expect(splitListener.statementsContext.length).toBe(11); }); test('create table like', () => { @@ -55,15 +59,16 @@ describe('Trino entity collector tests', () => { startColumn: 1, endColumn: 70, }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - - const beLikedEntity = allEntities[1]; + const beLikedEntity = allEntities[1]; - expect(tableCreateEntity.relatedEntities[0]).toBe(beLikedEntity); - expect(beLikedEntity.text).toBe('like_table'); - expect(beLikedEntity.entityContextType).toBe(EntityContextType.TABLE); - expect(beLikedEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(tableCreateEntity.relatedEntities[0]).toBe(beLikedEntity); + expect(beLikedEntity.text).toBe('like_table'); + expect(beLikedEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(beLikedEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + } }); test('create table as select', () => { @@ -84,21 +89,25 @@ describe('Trino entity collector tests', () => { expect(tableCreateEntity.belongStmt.stmtContextType).toBe( StmtContextType.CREATE_TABLE_STMT ); - - expect(tableCreateEntity.columns.length).toBe(2); - tableCreateEntity.columns.forEach((columEntity) => { - expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); - expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); - expect(columEntity.text).toBe( - commonSql.slice(columEntity.position.startIndex, columEntity.position.endIndex + 1) - ); - }); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); - - expect(originTableEntity.entityContextType).toBe(EntityContextType.TABLE); - expect(originTableEntity.text).toBe('t'); - expect(originTableEntity.belongStmt.rootStmt).toBe(tableCreateEntity.belongStmt); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns.length).toBe(2); + tableCreateEntity.columns.forEach((columEntity) => { + expect(columEntity.entityContextType).toBe(EntityContextType.COLUMN_CREATE); + expect(columEntity.belongStmt).toBe(tableCreateEntity.belongStmt); + expect(columEntity.text).toBe( + commonSql.slice( + columEntity.position.startIndex, + columEntity.position.endIndex + 1 + ) + ); + }); + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); + + expect(originTableEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(originTableEntity.text).toBe('t'); + expect(originTableEntity.belongStmt.rootStmt).toBe(tableCreateEntity.belongStmt); + } }); test('create view as select', () => { @@ -117,10 +126,19 @@ describe('Trino entity collector tests', () => { expect(tableCreateEntity.entityContextType).toBe(EntityContextType.VIEW_CREATE); expect(tableCreateEntity.text).toBe('a'); expect(tableCreateEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_VIEW_STMT); - - expect(tableCreateEntity.columns).toBeNull(); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'This is a view comment'", + startIndex: 139, + endIndex: 162, + line: 5, + startColumn: 23, + endColumn: 47, + }); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); + } expect(originTableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(originTableEntity.text).toBe('t'); @@ -143,10 +161,20 @@ describe('Trino entity collector tests', () => { expect(tableCreateEntity.entityContextType).toBe(EntityContextType.VIEW_CREATE); expect(tableCreateEntity.text).toBe('a'); expect(tableCreateEntity.belongStmt.stmtContextType).toBe(StmtContextType.CREATE_VIEW_STMT); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'This is an MATERIALIZED view comment'", + startIndex: 220, + endIndex: 257, + line: 7, + startColumn: 36, + endColumn: 74, + }); - expect(tableCreateEntity.columns).toBeNull(); - expect(tableCreateEntity.relatedEntities.length).toBe(1); - expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); + expect(tableCreateEntity.relatedEntities.length).toBe(1); + expect(tableCreateEntity.relatedEntities[0]).toBe(originTableEntity); + } expect(originTableEntity.entityContextType).toBe(EntityContextType.TABLE); expect(originTableEntity.text).toBe('t'); @@ -169,8 +197,10 @@ describe('Trino entity collector tests', () => { expect(tableCreateEntity.text).toBe('table1'); expect(tableCreateEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); - expect(tableCreateEntity.columns).toBeNull(); - expect(tableCreateEntity.relatedEntities).toBeNull(); + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns).toBeUndefined(); + expect(tableCreateEntity.relatedEntities).toBeNull(); + } }); test('insert into table as select', () => { @@ -246,4 +276,92 @@ describe('Trino entity collector tests', () => { expect(schemaEntity.belongStmt.stmtContextType).toBe(StmtContextType.COMMON_STMT); expect(schemaEntity.text).toBe('information_schema'); }); + + test('select using alias', () => { + const testingContext = splitListener.statementsContext[9]; + + const collectListener = new TrinoEntityCollector(commonSql); + trino.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(1); + + const tableEntity = allEntities[0]; + + expect(tableEntity.entityContextType).toBe(EntityContextType.TABLE); + expect(tableEntity.text).toBe('tb'); + expect(tableEntity.belongStmt.stmtContextType).toBe(StmtContextType.SELECT_STMT); + expect(tableEntity[AttrName.alias]).toEqual({ + text: 'tb_alias', + startIndex: 512, + endIndex: 519, + line: 19, + startColumn: 44, + endColumn: 52, + }); + + if (isCommonEntityContext(tableEntity)) { + expect(tableEntity.columns).toBeUndefined(); + expect(tableEntity.relatedEntities).toBeNull(); + } + }); + + test('create table using alias', () => { + const testingContext = splitListener.statementsContext[10]; + + const collectListener = new TrinoEntityCollector(commonSql); + trino.listen(collectListener as ParseTreeListener, testingContext); + + const allEntities = collectListener.getEntities(); + + expect(allEntities.length).toBe(1); + + const tableCreateEntity = allEntities[0]; + + expect(tableCreateEntity.entityContextType).toBe(EntityContextType.TABLE_CREATE); + expect(tableCreateEntity.text).toBe('orders'); + expect(tableCreateEntity.belongStmt.stmtContextType).toBe( + StmtContextType.CREATE_TABLE_STMT + ); + expect(tableCreateEntity[AttrName.comment]).toEqual({ + text: "'This is the orders table'", + startIndex: 619, + endIndex: 644, + line: 25, + startColumn: 9, + endColumn: 35, + }); + + if (isCommonEntityContext(tableCreateEntity)) { + expect(tableCreateEntity.columns?.length).toBe(2); + expect(tableCreateEntity.relatedEntities).toBeNull(); + expect(tableCreateEntity.columns[0].text).toBe('orderkey'); + expect(tableCreateEntity.columns[1].text).toBe('orderstatus'); + expect(tableCreateEntity.columns[0][AttrName.colType]).toEqual({ + text: 'bigint', + startIndex: 556, + endIndex: 561, + line: 22, + startColumn: 12, + endColumn: 18, + }); + expect(tableCreateEntity.columns[1][AttrName.colType]).toEqual({ + text: 'varchar', + startIndex: 578, + endIndex: 584, + line: 23, + startColumn: 15, + endColumn: 22, + }); + expect(tableCreateEntity.columns[1][AttrName.comment]).toEqual({ + text: "'order status'", + startIndex: 594, + endIndex: 607, + line: 23, + startColumn: 31, + endColumn: 45, + }); + } + }); }); diff --git a/test/parser/trino/contextCollect/fixtures/common.sql b/test/parser/trino/contextCollect/fixtures/common.sql index 60b1e0b9..1da9a96e 100644 --- a/test/parser/trino/contextCollect/fixtures/common.sql +++ b/test/parser/trino/contextCollect/fixtures/common.sql @@ -2,9 +2,9 @@ CREATE TABLE IF NOT EXISTS bar (LIKE like_table INCLUDING PROPERTIES); CREATE TABLE foo(x,y) AS SELECT a,b FROM t; -CREATE VIEW a AS SELECT * FROM t; +CREATE VIEW a COMMENT 'This is a view comment' AS SELECT * FROM t; -CREATE MATERIALIZED VIEW a AS SELECT * FROM t; +CREATE MATERIALIZED VIEW a COMMENT 'This is an MATERIALIZED view comment' AS SELECT * FROM t; SELECT * FROM table1 GROUP BY a; @@ -14,4 +14,13 @@ INSERT INTO cities VALUES (1, 'San Francisco'); CREATE SCHEMA IF NOT EXISTS test; -USE information_schema; \ No newline at end of file +USE information_schema; + +SELECT id AS col1, name AS col2 FROM tb AS tb_alias; + +CREATE TABLE orders ( + orderkey bigint, + orderstatus varchar COMMENT 'order status' +) +COMMENT 'This is the orders table' +WITH (format = 'ORC'); diff --git a/test/parser/trino/errorListener.test.ts b/test/parser/trino/errorListener.test.ts new file mode 100644 index 00000000..c4d174d6 --- /dev/null +++ b/test/parser/trino/errorListener.test.ts @@ -0,0 +1,63 @@ +import { TrinoSQL } from 'src/parser/trino'; + +const randomText = `dhsdansdnkla ndjnsla ndnalks`; +const sql1 = `SHOW CREATE TABLE`; +const sql2 = `CREATE VIEW `; +const sql3 = `SHOW CREATE TABLE aaa aaa`; + +describe('TrinoSQL validate invalid sql and test msg', () => { + const trinoSQL = new TrinoSQL(); + + test('validate random text', () => { + const errors = trinoSQL.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'dhsdansdnkla' is not valid at this position, expecting a keyword` + ); + }); + + test('validate unComplete sql1', () => { + const errors = trinoSQL.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete'); + }); + + test('validate unComplete sql2', () => { + const errors = trinoSQL.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('Statement is incomplete, expecting a new view'); + }); + + test('validate unComplete sql3', () => { + const errors = trinoSQL.validate(sql3); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe( + `'aaa' is not valid at this position, expecting an existing table or a keyword` + ); + }); + + test('validate random text cn', () => { + trinoSQL.locale = 'zh_CN'; + const errors = trinoSQL.validate(randomText); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'dhsdansdnkla' 在此位置无效，期望一个关键字`); + }); + + test('validate unComplete sql1 cn', () => { + const errors = trinoSQL.validate(sql1); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe('语句不完整'); + }); + + test('validate unComplete sql2 cn', () => { + const errors = trinoSQL.validate(sql2); + expect(errors.length).toBe(1); + expect(errors[0].message).toEqual('语句不完整，期望一个新的view'); + }); + + test('validate unComplete sql3 cn', () => { + const errors = trinoSQL.validate(sql3); + expect(errors.length).toBe(1); + expect(errors[0].message).toBe(`'aaa' 在此位置无效，期望一个存在的table或者一个关键字`); + }); +}); diff --git a/test/parser/trino/suggestion/tokenSuggestion.test.ts b/test/parser/trino/suggestion/tokenSuggestion.test.ts index 9c8d7d02..d7398dc2 100644 --- a/test/parser/trino/suggestion/tokenSuggestion.test.ts +++ b/test/parser/trino/suggestion/tokenSuggestion.test.ts @@ -19,7 +19,7 @@ describe('Trino SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['VIEW', 'MATERIALIZED', 'TABLE', 'SCHEMA']); + expect(suggestion).toMatchUnorderedArray(['VIEW', 'MATERIALIZED', 'TABLE', 'SCHEMA']); }); test('After CREATE', () => { @@ -32,7 +32,7 @@ describe('Trino SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'ROLE', 'FUNCTION', 'OR', @@ -54,7 +54,7 @@ describe('Trino SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['PREPARE']); + expect(suggestion).toMatchUnorderedArray(['PREPARE']); }); test('After DELETE', () => { @@ -67,7 +67,7 @@ describe('Trino SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['FROM']); + expect(suggestion).toMatchUnorderedArray(['FROM']); }); test('After DESCRIBE', () => { @@ -101,7 +101,7 @@ describe('Trino SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary([ + expect(suggestion).toMatchUnorderedArray([ 'ROLE', 'FUNCTION', 'VIEW', @@ -122,6 +122,6 @@ describe('Trino SQL Token Suggestion', () => { pos )?.keywords; - expect(suggestion).toMatchUnorderedArrary(['INTO']); + expect(suggestion).toMatchUnorderedArray(['INTO']); }); }); diff --git a/test/setupTests.ts b/test/setupTests.ts index 96a90e5e..30459ab3 100644 --- a/test/setupTests.ts +++ b/test/setupTests.ts @@ -1,3 +1,3 @@ -import { toMatchUnorderedArrary } from './matchers'; +import { toMatchUnorderedArray } from './matchers'; -expect.extend({ toMatchUnorderedArrary }); +expect.extend({ toMatchUnorderedArray }); diff --git a/tsconfig.json b/tsconfig.json index c5e02b39..be809036 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -15,6 +15,8 @@ "noImplicitThis": true, "forceConsistentCasingInFileNames": true, "lib": ["ESNext", "DOM"], + "resolveJsonModule": true, + "allowSyntheticDefaultImports": true, "skipLibCheck": true, "types": ["node", "jest"], "typeRoots": ["node", "node_modules/@types"]