From fe953bde5b0291c49f7b6c58f0f1b63cfb46d21f Mon Sep 17 00:00:00 2001 From: aboyko Date: Thu, 16 May 2024 18:12:46 -0400 Subject: [PATCH] Embedded SQL syntax highlighting and syntax validation --- headless-services/commons/jpql/.gitignore | 4 + .../commons/jpql/generate-parsers.sh | 3 +- .../commons/jpql/grammars/MySqlLexer.g4 | 1354 + .../commons/jpql/grammars/MySqlParser.g4 | 3492 + .../ide/vscode/parser/sql/MySqlLexer.java | 10118 +++ .../ide/vscode/parser/sql/MySqlParser.java | 73382 ++++++++++++++++ .../parser/sql/MySqlParserBaseListener.java | 7468 ++ .../parser/sql/MySqlParserListener.java | 6804 ++ .../app/BootLanguageServerInitializer.java | 4 +- .../ide/vscode/boot/app/JdtConfig.java | 12 +- .../ide/vscode/boot/app/SpringDataConfig.java | 24 + .../java/data/jpa/queries/HqlReconciler.java | 2 +- .../JdtDataQuerySemanticTokensProvider.java | 6 +- ...eryPropertiesLanguageServerComponents.java | 5 +- .../java/data/jpa/queries/JpqlReconciler.java | 2 +- .../NamedQueryPropertiesReconcileEngine.java | 8 +- .../jpa/queries/QueryJdtAstReconciler.java | 18 +- .../java/data/jpa/queries/SqlReconciler.java | 76 + .../data/jpa/queries/SqlSemanticTokens.java | 179 + ...dtDataQuerySemanticTokensProviderTest.java | 42 +- .../data/jpa/queries/QueryReconcilerTest.java | 12 +- 21 files changed, 102990 insertions(+), 25 deletions(-) create mode 100644 headless-services/commons/jpql/grammars/MySqlLexer.g4 create mode 100644 headless-services/commons/jpql/grammars/MySqlParser.g4 create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlLexer.java create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParser.java create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParserBaseListener.java create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParserListener.java create mode 100644 headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlReconciler.java create mode 100644 headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlSemanticTokens.java diff --git a/headless-services/commons/jpql/.gitignore b/headless-services/commons/jpql/.gitignore index 66ffbd68d..54fbda9b6 100644 --- a/headless-services/commons/jpql/.gitignore +++ b/headless-services/commons/jpql/.gitignore @@ -7,4 +7,8 @@ /src/main/java/org/springframework/ide/vscode/parser/hql/Hql.tokens /src/main/java/org/springframework/ide/vscode/parser/hql/HqlLexer.interp /src/main/java/org/springframework/ide/vscode/parser/hql/HqlLexer.tokens +/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParser.interp +/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParser.tokens +/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlLexer.interp +/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlLexer.tokens /target diff --git a/headless-services/commons/jpql/generate-parsers.sh b/headless-services/commons/jpql/generate-parsers.sh index 09656b3ee..0a6d06c24 100755 --- a/headless-services/commons/jpql/generate-parsers.sh +++ b/headless-services/commons/jpql/generate-parsers.sh @@ -7,5 +7,6 @@ fi workdir=$(pwd) cd grammars java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar Jpql.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/jpql -package org.springframework.ide.vscode.parser.jpql -java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar Hql.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode//parser/hql -package org.springframework.ide.vscode.parser.hql +java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar Hql.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/hql -package org.springframework.ide.vscode.parser.hql +java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar MySqlLexer.g4 MySqlParser.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/sql -package org.springframework.ide.vscode.parser.sql diff --git a/headless-services/commons/jpql/grammars/MySqlLexer.g4 b/headless-services/commons/jpql/grammars/MySqlLexer.g4 new file mode 100644 index 000000000..638764c28 --- /dev/null +++ b/headless-services/commons/jpql/grammars/MySqlLexer.g4 @@ -0,0 +1,1354 @@ +/* +MySQL (Positive Technologies) grammar +The MIT License (MIT). +Copyright (c) 2015-2017, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies. +Copyright (c) 2017, Ivan Khudyashev (IHudyashov@ptsecurity.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine +// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true + +lexer grammar MySqlLexer; + +options { + caseInsensitive = true; +} + +channels { + MYSQLCOMMENT, + ERRORCHANNEL +} + +SPEL : ('#')('{')(.)*?('}') ; + +// SKIP + +SPACE : [ \t\r\n]+ -> channel(HIDDEN); +SPEC_MYSQL_COMMENT : '/*!' .+? '*/' -> channel(MYSQLCOMMENT); +COMMENT_INPUT : '/*' .*? '*/' -> channel(HIDDEN); +LINE_COMMENT: + (('--' [ \t]* | '#') ~[\r\n]* ('\r'? '\n' | EOF) | '--' ('\r'? '\n' | EOF)) -> channel(HIDDEN) +; + +// Keywords +// Common Keywords + +ADD : 'ADD'; +ALL : 'ALL'; +ALTER : 'ALTER'; +ALWAYS : 'ALWAYS'; +ANALYZE : 'ANALYZE'; +AND : 'AND'; +ARRAY : 'ARRAY'; +AS : 'AS'; +ASC : 'ASC'; +ATTRIBUTE : 'ATTRIBUTE'; +BEFORE : 'BEFORE'; +BETWEEN : 'BETWEEN'; +BOTH : 'BOTH'; +BUCKETS : 'BUCKETS'; +BY : 'BY'; +CALL : 'CALL'; +CASCADE : 'CASCADE'; +CASE : 'CASE'; +CAST : 'CAST'; +CHANGE : 'CHANGE'; +CHARACTER : 'CHARACTER'; +CHECK : 'CHECK'; +COLLATE : 'COLLATE'; +COLUMN : 'COLUMN'; +CONDITION : 'CONDITION'; +CONSTRAINT : 'CONSTRAINT'; +CONTINUE : 'CONTINUE'; +CONVERT : 'CONVERT'; +CREATE : 'CREATE'; +CROSS : 'CROSS'; +CURRENT : 'CURRENT'; +CURRENT_ROLE : 'CURRENT_ROLE'; +CURRENT_USER : 'CURRENT_USER'; +CURSOR : 'CURSOR'; +DATABASE : 'DATABASE'; +DATABASES : 'DATABASES'; +DECLARE : 'DECLARE'; +DEFAULT : 'DEFAULT'; +DELAYED : 'DELAYED'; +DELETE : 'DELETE'; +DESC : 'DESC'; +DESCRIBE : 'DESCRIBE'; +DETERMINISTIC : 'DETERMINISTIC'; +DIAGNOSTICS : 'DIAGNOSTICS'; +DISTINCT : 'DISTINCT'; +DISTINCTROW : 'DISTINCTROW'; +DROP : 'DROP'; +EACH : 'EACH'; +ELSE : 'ELSE'; +ELSEIF : 'ELSEIF'; +EMPTY : 'EMPTY'; +ENCLOSED : 'ENCLOSED'; +ENFORCED : 'ENFORCED'; +ESCAPED : 'ESCAPED'; +EXCEPT : 'EXCEPT'; +EXISTS : 'EXISTS'; +EXIT : 'EXIT'; +EXPLAIN : 'EXPLAIN'; +FALSE : 'FALSE'; +FETCH : 'FETCH'; +FOR : 'FOR'; +FORCE : 'FORCE'; +FOREIGN : 'FOREIGN'; +FROM : 'FROM'; +FULLTEXT : 'FULLTEXT'; +GENERATED : 'GENERATED'; +GET : 'GET'; +GRANT : 'GRANT'; +GROUP : 'GROUP'; +HAVING : 'HAVING'; +HIGH_PRIORITY : 'HIGH_PRIORITY'; +HISTOGRAM : 'HISTOGRAM'; +IF : 'IF'; +IGNORE : 'IGNORE'; +IGNORED : 'IGNORED'; +IN : 'IN'; +INDEX : 'INDEX'; +INFILE : 'INFILE'; +INNER : 'INNER'; +INOUT : 'INOUT'; +INSERT : 'INSERT'; +INTERVAL : 'INTERVAL'; +INTO : 'INTO'; +IS : 'IS'; +ITERATE : 'ITERATE'; +JOIN : 'JOIN'; +KEY : 'KEY'; +KEYS : 'KEYS'; +KILL : 'KILL'; +LATERAL : 'LATERAL'; +LEADING : 'LEADING'; +LEAVE : 'LEAVE'; +LEFT : 'LEFT'; +LIKE : 'LIKE'; +LIMIT : 'LIMIT'; +LINEAR : 'LINEAR'; +LINES : 'LINES'; +LOAD : 'LOAD'; +LOCK : 'LOCK'; +LOCKED : 'LOCKED'; +LOOP : 'LOOP'; +LOW_PRIORITY : 'LOW_PRIORITY'; +MASTER_BIND : 'MASTER_BIND'; +MASTER_SSL_VERIFY_SERVER_CERT : 'MASTER_SSL_VERIFY_SERVER_CERT'; +MATCH : 'MATCH'; +MAXVALUE : 'MAXVALUE'; +MINVALUE : 'MINVALUE'; +MODIFIES : 'MODIFIES'; +NATURAL : 'NATURAL'; +NOT : 'NOT'; +NO_WRITE_TO_BINLOG : 'NO_WRITE_TO_BINLOG'; +NULL_LITERAL : 'NULL'; +NUMBER : 'NUMBER'; +ON : 'ON'; +OPTIMIZE : 'OPTIMIZE'; +OPTION : 'OPTION'; +OPTIONAL : 'OPTIONAL'; +OPTIONALLY : 'OPTIONALLY'; +OR : 'OR'; +ORDER : 'ORDER'; +OUT : 'OUT'; +OUTER : 'OUTER'; +OUTFILE : 'OUTFILE'; +OVER : 'OVER'; +PARTITION : 'PARTITION'; +PRIMARY : 'PRIMARY'; +PROCEDURE : 'PROCEDURE'; +PURGE : 'PURGE'; +RANGE : 'RANGE'; +READ : 'READ'; +READS : 'READS'; +REFERENCES : 'REFERENCES'; +REGEXP : 'REGEXP'; +RELEASE : 'RELEASE'; +RENAME : 'RENAME'; +REPEAT : 'REPEAT'; +REPLACE : 'REPLACE'; +REQUIRE : 'REQUIRE'; +RESIGNAL : 'RESIGNAL'; +RESTRICT : 'RESTRICT'; +RETAIN : 'RETAIN'; +RETURN : 'RETURN'; +REVOKE : 'REVOKE'; +RIGHT : 'RIGHT'; +RLIKE : 'RLIKE'; +SCHEMA : 'SCHEMA'; +SCHEMAS : 'SCHEMAS'; +SELECT : 'SELECT'; +SET : 'SET'; +SEPARATOR : 'SEPARATOR'; +SHOW : 'SHOW'; +SIGNAL : 'SIGNAL'; +SKIP_ : 'SKIP'; +SKIP_QUERY_REWRITE : 'SKIP_QUERY_REWRITE'; +SPATIAL : 'SPATIAL'; +SQL : 'SQL'; +SQLEXCEPTION : 'SQLEXCEPTION'; +SQLSTATE : 'SQLSTATE'; +SQLWARNING : 'SQLWARNING'; +SQL_BIG_RESULT : 'SQL_BIG_RESULT'; +SQL_CALC_FOUND_ROWS : 'SQL_CALC_FOUND_ROWS'; +SQL_SMALL_RESULT : 'SQL_SMALL_RESULT'; +SSL : 'SSL'; +STACKED : 'STACKED'; +STARTING : 'STARTING'; +STATEMENT : 'STATEMENT'; +STRAIGHT_JOIN : 'STRAIGHT_JOIN'; +TABLE : 'TABLE'; +TERMINATED : 'TERMINATED'; +THEN : 'THEN'; +TO : 'TO'; +TRAILING : 'TRAILING'; +TRIGGER : 'TRIGGER'; +TRUE : 'TRUE'; +UNDO : 'UNDO'; +UNION : 'UNION'; +UNIQUE : 'UNIQUE'; +UNLOCK : 'UNLOCK'; +UNSIGNED : 'UNSIGNED'; +UPDATE : 'UPDATE'; +USAGE : 'USAGE'; +USE : 'USE'; +USING : 'USING'; +VALUES : 'VALUES'; +WHEN : 'WHEN'; +WHERE : 'WHERE'; +WHILE : 'WHILE'; +WITH : 'WITH'; +WRITE : 'WRITE'; +XOR : 'XOR'; +ZEROFILL : 'ZEROFILL'; + +// DATA TYPE Keywords + +TINYINT : 'TINYINT'; +SMALLINT : 'SMALLINT'; +MEDIUMINT : 'MEDIUMINT'; +MIDDLEINT : 'MIDDLEINT'; +INT : 'INT'; +INT1 : 'INT1'; +INT2 : 'INT2'; +INT3 : 'INT3'; +INT4 : 'INT4'; +INT8 : 'INT8'; +INTEGER : 'INTEGER'; +BIGINT : 'BIGINT'; +REAL : 'REAL'; +DOUBLE : 'DOUBLE'; +PRECISION : 'PRECISION'; +FLOAT : 'FLOAT'; +FLOAT4 : 'FLOAT4'; +FLOAT8 : 'FLOAT8'; +DECIMAL : 'DECIMAL'; +DEC : 'DEC'; +NUMERIC : 'NUMERIC'; +DATE : 'DATE'; +TIME : 'TIME'; +TIMESTAMP : 'TIMESTAMP'; +DATETIME : 'DATETIME'; +YEAR : 'YEAR'; +CHAR : 'CHAR'; +VARCHAR : 'VARCHAR'; +NVARCHAR : 'NVARCHAR'; +NATIONAL : 'NATIONAL'; +BINARY : 'BINARY'; +VARBINARY : 'VARBINARY'; +TINYBLOB : 'TINYBLOB'; +BLOB : 'BLOB'; +MEDIUMBLOB : 'MEDIUMBLOB'; +LONG : 'LONG'; +LONGBLOB : 'LONGBLOB'; +TINYTEXT : 'TINYTEXT'; +TEXT : 'TEXT'; +MEDIUMTEXT : 'MEDIUMTEXT'; +LONGTEXT : 'LONGTEXT'; +ENUM : 'ENUM'; +VARYING : 'VARYING'; +SERIAL : 'SERIAL'; + +// Interval type Keywords + +YEAR_MONTH : 'YEAR_MONTH'; +DAY_HOUR : 'DAY_HOUR'; +DAY_MINUTE : 'DAY_MINUTE'; +DAY_SECOND : 'DAY_SECOND'; +HOUR_MINUTE : 'HOUR_MINUTE'; +HOUR_SECOND : 'HOUR_SECOND'; +MINUTE_SECOND : 'MINUTE_SECOND'; +SECOND_MICROSECOND : 'SECOND_MICROSECOND'; +MINUTE_MICROSECOND : 'MINUTE_MICROSECOND'; +HOUR_MICROSECOND : 'HOUR_MICROSECOND'; +DAY_MICROSECOND : 'DAY_MICROSECOND'; + +// JSON keywords +JSON_ARRAY : 'JSON_ARRAY'; +JSON_ARRAYAGG : 'JSON_ARRAYAGG'; +JSON_ARRAY_APPEND : 'JSON_ARRAY_APPEND'; +JSON_ARRAY_INSERT : 'JSON_ARRAY_INSERT'; +JSON_CONTAINS : 'JSON_CONTAINS'; +JSON_CONTAINS_PATH : 'JSON_CONTAINS_PATH'; +JSON_DEPTH : 'JSON_DEPTH'; +JSON_EXTRACT : 'JSON_EXTRACT'; +JSON_INSERT : 'JSON_INSERT'; +JSON_KEYS : 'JSON_KEYS'; +JSON_LENGTH : 'JSON_LENGTH'; +JSON_MERGE : 'JSON_MERGE'; +JSON_MERGE_PATCH : 'JSON_MERGE_PATCH'; +JSON_MERGE_PRESERVE : 'JSON_MERGE_PRESERVE'; +JSON_OBJECT : 'JSON_OBJECT'; +JSON_OBJECTAGG : 'JSON_OBJECTAGG'; +JSON_OVERLAPS : 'JSON_OVERLAPS'; +JSON_PRETTY : 'JSON_PRETTY'; +JSON_QUOTE : 'JSON_QUOTE'; +JSON_REMOVE : 'JSON_REMOVE'; +JSON_REPLACE : 'JSON_REPLACE'; +JSON_SCHEMA_VALID : 'JSON_SCHEMA_VALID'; +JSON_SCHEMA_VALIDATION_REPORT : 'JSON_SCHEMA_VALIDATION_REPORT'; +JSON_SEARCH : 'JSON_SEARCH'; +JSON_SET : 'JSON_SET'; +JSON_STORAGE_FREE : 'JSON_STORAGE_FREE'; +JSON_STORAGE_SIZE : 'JSON_STORAGE_SIZE'; +JSON_TABLE : 'JSON_TABLE'; +JSON_TYPE : 'JSON_TYPE'; +JSON_UNQUOTE : 'JSON_UNQUOTE'; +JSON_VALID : 'JSON_VALID'; +JSON_VALUE : 'JSON_VALUE'; +NESTED : 'NESTED'; +ORDINALITY : 'ORDINALITY'; +PATH : 'PATH'; + +// Group function Keywords + +AVG : 'AVG'; +BIT_AND : 'BIT_AND'; +BIT_OR : 'BIT_OR'; +BIT_XOR : 'BIT_XOR'; +COUNT : 'COUNT'; +CUME_DIST : 'CUME_DIST'; +DENSE_RANK : 'DENSE_RANK'; +FIRST_VALUE : 'FIRST_VALUE'; +GROUP_CONCAT : 'GROUP_CONCAT'; +LAG : 'LAG'; +LAST_VALUE : 'LAST_VALUE'; +LEAD : 'LEAD'; +MAX : 'MAX'; +MIN : 'MIN'; +NTILE : 'NTILE'; +NTH_VALUE : 'NTH_VALUE'; +PERCENT_RANK : 'PERCENT_RANK'; +RANK : 'RANK'; +ROW_NUMBER : 'ROW_NUMBER'; +STD : 'STD'; +STDDEV : 'STDDEV'; +STDDEV_POP : 'STDDEV_POP'; +STDDEV_SAMP : 'STDDEV_SAMP'; +SUM : 'SUM'; +VAR_POP : 'VAR_POP'; +VAR_SAMP : 'VAR_SAMP'; +VARIANCE : 'VARIANCE'; + +// Common function Keywords + +CURRENT_DATE : 'CURRENT_DATE'; +CURRENT_TIME : 'CURRENT_TIME'; +CURRENT_TIMESTAMP : 'CURRENT_TIMESTAMP'; +LOCALTIME : 'LOCALTIME'; +CURDATE : 'CURDATE'; +CURTIME : 'CURTIME'; +DATE_ADD : 'DATE_ADD'; +DATE_SUB : 'DATE_SUB'; +EXTRACT : 'EXTRACT'; +LOCALTIMESTAMP : 'LOCALTIMESTAMP'; +NOW : 'NOW'; +POSITION : 'POSITION'; +SUBSTR : 'SUBSTR'; +SUBSTRING : 'SUBSTRING'; +SYSDATE : 'SYSDATE'; +TRIM : 'TRIM'; +UTC_DATE : 'UTC_DATE'; +UTC_TIME : 'UTC_TIME'; +UTC_TIMESTAMP : 'UTC_TIMESTAMP'; + +// Keywords, but can be ID +// Common Keywords, but can be ID + +ACCOUNT : 'ACCOUNT'; +ACTION : 'ACTION'; +AFTER : 'AFTER'; +AGGREGATE : 'AGGREGATE'; +ALGORITHM : 'ALGORITHM'; +ANY : 'ANY'; +AT : 'AT'; +AUTHORS : 'AUTHORS'; +AUTOCOMMIT : 'AUTOCOMMIT'; +AUTOEXTEND_SIZE : 'AUTOEXTEND_SIZE'; +AUTO_INCREMENT : 'AUTO_INCREMENT'; +AVG_ROW_LENGTH : 'AVG_ROW_LENGTH'; +BEGIN : 'BEGIN'; +BINLOG : 'BINLOG'; +BIT : 'BIT'; +BLOCK : 'BLOCK'; +BOOL : 'BOOL'; +BOOLEAN : 'BOOLEAN'; +BTREE : 'BTREE'; +CACHE : 'CACHE'; +CASCADED : 'CASCADED'; +CHAIN : 'CHAIN'; +CHANGED : 'CHANGED'; +CHANNEL : 'CHANNEL'; +CHECKSUM : 'CHECKSUM'; +PAGE_CHECKSUM : 'PAGE_CHECKSUM'; +CIPHER : 'CIPHER'; +CLASS_ORIGIN : 'CLASS_ORIGIN'; +CLIENT : 'CLIENT'; +CLOSE : 'CLOSE'; +CLUSTERING : 'CLUSTERING'; +COALESCE : 'COALESCE'; +CODE : 'CODE'; +COLUMNS : 'COLUMNS'; +COLUMN_FORMAT : 'COLUMN_FORMAT'; +COLUMN_NAME : 'COLUMN_NAME'; +COMMENT : 'COMMENT'; +COMMIT : 'COMMIT'; +COMPACT : 'COMPACT'; +COMPLETION : 'COMPLETION'; +COMPRESSED : 'COMPRESSED'; +COMPRESSION : 'COMPRESSION'; +CONCURRENT : 'CONCURRENT'; +CONNECT : 'CONNECT'; +CONNECTION : 'CONNECTION'; +CONSISTENT : 'CONSISTENT'; +CONSTRAINT_CATALOG : 'CONSTRAINT_CATALOG'; +CONSTRAINT_SCHEMA : 'CONSTRAINT_SCHEMA'; +CONSTRAINT_NAME : 'CONSTRAINT_NAME'; +CONTAINS : 'CONTAINS'; +CONTEXT : 'CONTEXT'; +CONTRIBUTORS : 'CONTRIBUTORS'; +COPY : 'COPY'; +CPU : 'CPU'; +CYCLE : 'CYCLE'; +CURSOR_NAME : 'CURSOR_NAME'; +DATA : 'DATA'; +DATAFILE : 'DATAFILE'; +DEALLOCATE : 'DEALLOCATE'; +DEFAULT_AUTH : 'DEFAULT_AUTH'; +DEFINER : 'DEFINER'; +DELAY_KEY_WRITE : 'DELAY_KEY_WRITE'; +DES_KEY_FILE : 'DES_KEY_FILE'; +DIRECTORY : 'DIRECTORY'; +DISABLE : 'DISABLE'; +DISCARD : 'DISCARD'; +DISK : 'DISK'; +DO : 'DO'; +DUMPFILE : 'DUMPFILE'; +DUPLICATE : 'DUPLICATE'; +DYNAMIC : 'DYNAMIC'; +ENABLE : 'ENABLE'; +ENCRYPTED : 'ENCRYPTED'; +ENCRYPTION : 'ENCRYPTION'; +ENCRYPTION_KEY_ID : 'ENCRYPTION_KEY_ID'; +END : 'END'; +ENDS : 'ENDS'; +ENGINE : 'ENGINE'; +ENGINES : 'ENGINES'; +ERROR : 'ERROR'; +ERRORS : 'ERRORS'; +ESCAPE : 'ESCAPE'; +EVEN : 'EVEN'; +EVENT : 'EVENT'; +EVENTS : 'EVENTS'; +EVERY : 'EVERY'; +EXCHANGE : 'EXCHANGE'; +EXCLUSIVE : 'EXCLUSIVE'; +EXPIRE : 'EXPIRE'; +EXPORT : 'EXPORT'; +EXTENDED : 'EXTENDED'; +EXTENT_SIZE : 'EXTENT_SIZE'; +FAILED_LOGIN_ATTEMPTS : 'FAILED_LOGIN_ATTEMPTS'; +FAST : 'FAST'; +FAULTS : 'FAULTS'; +FIELDS : 'FIELDS'; +FILE_BLOCK_SIZE : 'FILE_BLOCK_SIZE'; +FILTER : 'FILTER'; +FIRST : 'FIRST'; +FIXED : 'FIXED'; +FLUSH : 'FLUSH'; +FOLLOWING : 'FOLLOWING'; +FOLLOWS : 'FOLLOWS'; +FOUND : 'FOUND'; +FULL : 'FULL'; +FUNCTION : 'FUNCTION'; +GENERAL : 'GENERAL'; +GLOBAL : 'GLOBAL'; +GRANTS : 'GRANTS'; +GROUP_REPLICATION : 'GROUP_REPLICATION'; +HANDLER : 'HANDLER'; +HASH : 'HASH'; +HELP : 'HELP'; +HISTORY : 'HISTORY'; +HOST : 'HOST'; +HOSTS : 'HOSTS'; +IDENTIFIED : 'IDENTIFIED'; +IGNORE_SERVER_IDS : 'IGNORE_SERVER_IDS'; +IMPORT : 'IMPORT'; +INCREMENT : 'INCREMENT'; +INDEXES : 'INDEXES'; +INITIAL_SIZE : 'INITIAL_SIZE'; +INPLACE : 'INPLACE'; +INSERT_METHOD : 'INSERT_METHOD'; +INSTALL : 'INSTALL'; +INSTANCE : 'INSTANCE'; +INSTANT : 'INSTANT'; +INVISIBLE : 'INVISIBLE'; +INVOKER : 'INVOKER'; +IO : 'IO'; +IO_THREAD : 'IO_THREAD'; +IPC : 'IPC'; +ISOLATION : 'ISOLATION'; +ISSUER : 'ISSUER'; +JSON : 'JSON'; +KEY_BLOCK_SIZE : 'KEY_BLOCK_SIZE'; +LANGUAGE : 'LANGUAGE'; +LAST : 'LAST'; +LEAVES : 'LEAVES'; +LESS : 'LESS'; +LEVEL : 'LEVEL'; +LIST : 'LIST'; +LOCAL : 'LOCAL'; +LOGFILE : 'LOGFILE'; +LOGS : 'LOGS'; +MASTER : 'MASTER'; +MASTER_AUTO_POSITION : 'MASTER_AUTO_POSITION'; +MASTER_CONNECT_RETRY : 'MASTER_CONNECT_RETRY'; +MASTER_DELAY : 'MASTER_DELAY'; +MASTER_HEARTBEAT_PERIOD : 'MASTER_HEARTBEAT_PERIOD'; +MASTER_HOST : 'MASTER_HOST'; +MASTER_LOG_FILE : 'MASTER_LOG_FILE'; +MASTER_LOG_POS : 'MASTER_LOG_POS'; +MASTER_PASSWORD : 'MASTER_PASSWORD'; +MASTER_PORT : 'MASTER_PORT'; +MASTER_RETRY_COUNT : 'MASTER_RETRY_COUNT'; +MASTER_SSL : 'MASTER_SSL'; +MASTER_SSL_CA : 'MASTER_SSL_CA'; +MASTER_SSL_CAPATH : 'MASTER_SSL_CAPATH'; +MASTER_SSL_CERT : 'MASTER_SSL_CERT'; +MASTER_SSL_CIPHER : 'MASTER_SSL_CIPHER'; +MASTER_SSL_CRL : 'MASTER_SSL_CRL'; +MASTER_SSL_CRLPATH : 'MASTER_SSL_CRLPATH'; +MASTER_SSL_KEY : 'MASTER_SSL_KEY'; +MASTER_TLS_VERSION : 'MASTER_TLS_VERSION'; +MASTER_USER : 'MASTER_USER'; +MAX_CONNECTIONS_PER_HOUR : 'MAX_CONNECTIONS_PER_HOUR'; +MAX_QUERIES_PER_HOUR : 'MAX_QUERIES_PER_HOUR'; +MAX_ROWS : 'MAX_ROWS'; +MAX_SIZE : 'MAX_SIZE'; +MAX_UPDATES_PER_HOUR : 'MAX_UPDATES_PER_HOUR'; +MAX_USER_CONNECTIONS : 'MAX_USER_CONNECTIONS'; +MEDIUM : 'MEDIUM'; +MEMBER : 'MEMBER'; +MERGE : 'MERGE'; +MESSAGE_TEXT : 'MESSAGE_TEXT'; +MID : 'MID'; +MIGRATE : 'MIGRATE'; +MIN_ROWS : 'MIN_ROWS'; +MODE : 'MODE'; +MODIFY : 'MODIFY'; +MUTEX : 'MUTEX'; +MYSQL : 'MYSQL'; +MYSQL_ERRNO : 'MYSQL_ERRNO'; +NAME : 'NAME'; +NAMES : 'NAMES'; +NCHAR : 'NCHAR'; +NEVER : 'NEVER'; +NEXT : 'NEXT'; +NO : 'NO'; +NOCACHE : 'NOCACHE'; +NOCOPY : 'NOCOPY'; +NOCYCLE : 'NOCYCLE'; +NOMAXVALUE : 'NOMAXVALUE'; +NOMINVALUE : 'NOMINVALUE'; +NOWAIT : 'NOWAIT'; +NODEGROUP : 'NODEGROUP'; +NONE : 'NONE'; +ODBC : 'ODBC'; +OFFLINE : 'OFFLINE'; +OFFSET : 'OFFSET'; +OF : 'OF'; +OJ : 'OJ'; +OLD_PASSWORD : 'OLD_PASSWORD'; +ONE : 'ONE'; +ONLINE : 'ONLINE'; +ONLY : 'ONLY'; +OPEN : 'OPEN'; +OPTIMIZER_COSTS : 'OPTIMIZER_COSTS'; +OPTIONS : 'OPTIONS'; +OWNER : 'OWNER'; +PACK_KEYS : 'PACK_KEYS'; +PAGE : 'PAGE'; +PAGE_COMPRESSED : 'PAGE_COMPRESSED'; +PAGE_COMPRESSION_LEVEL : 'PAGE_COMPRESSION_LEVEL'; +PARSER : 'PARSER'; +PARTIAL : 'PARTIAL'; +PARTITIONING : 'PARTITIONING'; +PARTITIONS : 'PARTITIONS'; +PASSWORD : 'PASSWORD'; +PASSWORD_LOCK_TIME : 'PASSWORD_LOCK_TIME'; +PHASE : 'PHASE'; +PLUGIN : 'PLUGIN'; +PLUGIN_DIR : 'PLUGIN_DIR'; +PLUGINS : 'PLUGINS'; +PORT : 'PORT'; +PRECEDES : 'PRECEDES'; +PRECEDING : 'PRECEDING'; +PREPARE : 'PREPARE'; +PRESERVE : 'PRESERVE'; +PREV : 'PREV'; +PROCESSLIST : 'PROCESSLIST'; +PROFILE : 'PROFILE'; +PROFILES : 'PROFILES'; +PROXY : 'PROXY'; +QUERY : 'QUERY'; +QUICK : 'QUICK'; +REBUILD : 'REBUILD'; +RECOVER : 'RECOVER'; +RECURSIVE : 'RECURSIVE'; +REDO_BUFFER_SIZE : 'REDO_BUFFER_SIZE'; +REDUNDANT : 'REDUNDANT'; +RELAY : 'RELAY'; +RELAY_LOG_FILE : 'RELAY_LOG_FILE'; +RELAY_LOG_POS : 'RELAY_LOG_POS'; +RELAYLOG : 'RELAYLOG'; +REMOVE : 'REMOVE'; +REORGANIZE : 'REORGANIZE'; +REPAIR : 'REPAIR'; +REPLICATE_DO_DB : 'REPLICATE_DO_DB'; +REPLICATE_DO_TABLE : 'REPLICATE_DO_TABLE'; +REPLICATE_IGNORE_DB : 'REPLICATE_IGNORE_DB'; +REPLICATE_IGNORE_TABLE : 'REPLICATE_IGNORE_TABLE'; +REPLICATE_REWRITE_DB : 'REPLICATE_REWRITE_DB'; +REPLICATE_WILD_DO_TABLE : 'REPLICATE_WILD_DO_TABLE'; +REPLICATE_WILD_IGNORE_TABLE : 'REPLICATE_WILD_IGNORE_TABLE'; +REPLICATION : 'REPLICATION'; +RESET : 'RESET'; +RESTART : 'RESTART'; +RESUME : 'RESUME'; +RETURNED_SQLSTATE : 'RETURNED_SQLSTATE'; +RETURNING : 'RETURNING'; +RETURNS : 'RETURNS'; +REUSE : 'REUSE'; +ROLE : 'ROLE'; +ROLLBACK : 'ROLLBACK'; +ROLLUP : 'ROLLUP'; +ROTATE : 'ROTATE'; +ROW : 'ROW'; +ROWS : 'ROWS'; +ROW_FORMAT : 'ROW_FORMAT'; +RTREE : 'RTREE'; +SAVEPOINT : 'SAVEPOINT'; +SCHEDULE : 'SCHEDULE'; +SECURITY : 'SECURITY'; +SEQUENCE : 'SEQUENCE'; +SERVER : 'SERVER'; +SESSION : 'SESSION'; +SHARE : 'SHARE'; +SHARED : 'SHARED'; +SIGNED : 'SIGNED'; +SIMPLE : 'SIMPLE'; +SLAVE : 'SLAVE'; +SLOW : 'SLOW'; +SNAPSHOT : 'SNAPSHOT'; +SOCKET : 'SOCKET'; +SOME : 'SOME'; +SONAME : 'SONAME'; +SOUNDS : 'SOUNDS'; +SOURCE : 'SOURCE'; +SQL_AFTER_GTIDS : 'SQL_AFTER_GTIDS'; +SQL_AFTER_MTS_GAPS : 'SQL_AFTER_MTS_GAPS'; +SQL_BEFORE_GTIDS : 'SQL_BEFORE_GTIDS'; +SQL_BUFFER_RESULT : 'SQL_BUFFER_RESULT'; +SQL_CACHE : 'SQL_CACHE'; +SQL_NO_CACHE : 'SQL_NO_CACHE'; +SQL_THREAD : 'SQL_THREAD'; +START : 'START'; +STARTS : 'STARTS'; +STATS_AUTO_RECALC : 'STATS_AUTO_RECALC'; +STATS_PERSISTENT : 'STATS_PERSISTENT'; +STATS_SAMPLE_PAGES : 'STATS_SAMPLE_PAGES'; +STATUS : 'STATUS'; +STOP : 'STOP'; +STORAGE : 'STORAGE'; +STORED : 'STORED'; +STRING : 'STRING'; +SUBCLASS_ORIGIN : 'SUBCLASS_ORIGIN'; +SUBJECT : 'SUBJECT'; +SUBPARTITION : 'SUBPARTITION'; +SUBPARTITIONS : 'SUBPARTITIONS'; +SUSPEND : 'SUSPEND'; +SWAPS : 'SWAPS'; +SWITCHES : 'SWITCHES'; +TABLE_NAME : 'TABLE_NAME'; +TABLESPACE : 'TABLESPACE'; +TABLE_TYPE : 'TABLE_TYPE'; +TEMPORARY : 'TEMPORARY'; +TEMPTABLE : 'TEMPTABLE'; +THAN : 'THAN'; +TRADITIONAL : 'TRADITIONAL'; +TRANSACTION : 'TRANSACTION'; +TRANSACTIONAL : 'TRANSACTIONAL'; +TRIGGERS : 'TRIGGERS'; +TRUNCATE : 'TRUNCATE'; +UNBOUNDED : 'UNBOUNDED'; +UNDEFINED : 'UNDEFINED'; +UNDOFILE : 'UNDOFILE'; +UNDO_BUFFER_SIZE : 'UNDO_BUFFER_SIZE'; +UNINSTALL : 'UNINSTALL'; +UNKNOWN : 'UNKNOWN'; +UNTIL : 'UNTIL'; +UPGRADE : 'UPGRADE'; +USER : 'USER'; +USE_FRM : 'USE_FRM'; +USER_RESOURCES : 'USER_RESOURCES'; +VALIDATION : 'VALIDATION'; +VALUE : 'VALUE'; +VARIABLES : 'VARIABLES'; +VIEW : 'VIEW'; +VIRTUAL : 'VIRTUAL'; +VISIBLE : 'VISIBLE'; +WAIT : 'WAIT'; +WARNINGS : 'WARNINGS'; +WINDOW : 'WINDOW'; +WITHOUT : 'WITHOUT'; +WORK : 'WORK'; +WRAPPER : 'WRAPPER'; +X509 : 'X509'; +XA : 'XA'; +XML : 'XML'; +YES : 'YES'; + +// Date format Keywords + +EUR : 'EUR'; +USA : 'USA'; +JIS : 'JIS'; +ISO : 'ISO'; +INTERNAL : 'INTERNAL'; + +// Interval type Keywords + +QUARTER : 'QUARTER'; +MONTH : 'MONTH'; +DAY : 'DAY'; +HOUR : 'HOUR'; +MINUTE : 'MINUTE'; +WEEK : 'WEEK'; +SECOND : 'SECOND'; +MICROSECOND : 'MICROSECOND'; + +// PRIVILEGES + +ADMIN : 'ADMIN'; +APPLICATION_PASSWORD_ADMIN : 'APPLICATION_PASSWORD_ADMIN'; +AUDIT_ABORT_EXEMPT : 'AUDIT_ABORT_EXEMPT'; +AUDIT_ADMIN : 'AUDIT_ADMIN'; +AUTHENTICATION_POLICY_ADMIN : 'AUTHENTICATION_POLICY_ADMIN'; +BACKUP_ADMIN : 'BACKUP_ADMIN'; +BINLOG_ADMIN : 'BINLOG_ADMIN'; +BINLOG_ENCRYPTION_ADMIN : 'BINLOG_ENCRYPTION_ADMIN'; +CLONE_ADMIN : 'CLONE_ADMIN'; +CONNECTION_ADMIN : 'CONNECTION_ADMIN'; +ENCRYPTION_KEY_ADMIN : 'ENCRYPTION_KEY_ADMIN'; +EXECUTE : 'EXECUTE'; +FILE : 'FILE'; +FIREWALL_ADMIN : 'FIREWALL_ADMIN'; +FIREWALL_EXEMPT : 'FIREWALL_EXEMPT'; +FIREWALL_USER : 'FIREWALL_USER'; +FLUSH_OPTIMIZER_COSTS : 'FLUSH_OPTIMIZER_COSTS'; +FLUSH_STATUS : 'FLUSH_STATUS'; +FLUSH_TABLES : 'FLUSH_TABLES'; +FLUSH_USER_RESOURCES : 'FLUSH_USER_RESOURCES'; +GROUP_REPLICATION_ADMIN : 'GROUP_REPLICATION_ADMIN'; +INNODB_REDO_LOG_ARCHIVE : 'INNODB_REDO_LOG_ARCHIVE'; +INNODB_REDO_LOG_ENABLE : 'INNODB_REDO_LOG_ENABLE'; +INVOKE : 'INVOKE'; +LAMBDA : 'LAMBDA'; +NDB_STORED_USER : 'NDB_STORED_USER'; +PASSWORDLESS_USER_ADMIN : 'PASSWORDLESS_USER_ADMIN'; +PERSIST_RO_VARIABLES_ADMIN : 'PERSIST_RO_VARIABLES_ADMIN'; +PRIVILEGES : 'PRIVILEGES'; +PROCESS : 'PROCESS'; +RELOAD : 'RELOAD'; +REPLICATION_APPLIER : 'REPLICATION_APPLIER'; +REPLICATION_SLAVE_ADMIN : 'REPLICATION_SLAVE_ADMIN'; +RESOURCE_GROUP_ADMIN : 'RESOURCE_GROUP_ADMIN'; +RESOURCE_GROUP_USER : 'RESOURCE_GROUP_USER'; +ROLE_ADMIN : 'ROLE_ADMIN'; +ROUTINE : 'ROUTINE'; +S3 : 'S3'; +SERVICE_CONNECTION_ADMIN : 'SERVICE_CONNECTION_ADMIN'; +SESSION_VARIABLES_ADMIN : QUOTE_SYMB? 'SESSION_VARIABLES_ADMIN' QUOTE_SYMB?; +SET_USER_ID : 'SET_USER_ID'; +SHOW_ROUTINE : 'SHOW_ROUTINE'; +SHUTDOWN : 'SHUTDOWN'; +SUPER : 'SUPER'; +SYSTEM_VARIABLES_ADMIN : 'SYSTEM_VARIABLES_ADMIN'; +TABLES : 'TABLES'; +TABLE_ENCRYPTION_ADMIN : 'TABLE_ENCRYPTION_ADMIN'; +VERSION_TOKEN_ADMIN : 'VERSION_TOKEN_ADMIN'; +XA_RECOVER_ADMIN : 'XA_RECOVER_ADMIN'; + +// Charsets + +ARMSCII8 : 'ARMSCII8'; +ASCII : 'ASCII'; +BIG5 : 'BIG5'; +CP1250 : 'CP1250'; +CP1251 : 'CP1251'; +CP1256 : 'CP1256'; +CP1257 : 'CP1257'; +CP850 : 'CP850'; +CP852 : 'CP852'; +CP866 : 'CP866'; +CP932 : 'CP932'; +DEC8 : 'DEC8'; +EUCJPMS : 'EUCJPMS'; +EUCKR : 'EUCKR'; +GB18030 : 'GB18030'; +GB2312 : 'GB2312'; +GBK : 'GBK'; +GEOSTD8 : 'GEOSTD8'; +GREEK : 'GREEK'; +HEBREW : 'HEBREW'; +HP8 : 'HP8'; +KEYBCS2 : 'KEYBCS2'; +KOI8R : 'KOI8R'; +KOI8U : 'KOI8U'; +LATIN1 : 'LATIN1'; +LATIN2 : 'LATIN2'; +LATIN5 : 'LATIN5'; +LATIN7 : 'LATIN7'; +MACCE : 'MACCE'; +MACROMAN : 'MACROMAN'; +SJIS : 'SJIS'; +SWE7 : 'SWE7'; +TIS620 : 'TIS620'; +UCS2 : 'UCS2'; +UJIS : 'UJIS'; +UTF16 : 'UTF16'; +UTF16LE : 'UTF16LE'; +UTF32 : 'UTF32'; +UTF8 : 'UTF8'; +UTF8MB3 : 'UTF8MB3'; +UTF8MB4 : 'UTF8MB4'; + +// DB Engines + +ARCHIVE : 'ARCHIVE'; +BLACKHOLE : 'BLACKHOLE'; +CSV : 'CSV'; +FEDERATED : 'FEDERATED'; +INNODB : 'INNODB'; +MEMORY : 'MEMORY'; +MRG_MYISAM : 'MRG_MYISAM'; +MYISAM : 'MYISAM'; +NDB : 'NDB'; +NDBCLUSTER : 'NDBCLUSTER'; +PERFORMANCE_SCHEMA : 'PERFORMANCE_SCHEMA'; +TOKUDB : 'TOKUDB'; + +// Transaction Levels + +REPEATABLE : 'REPEATABLE'; +COMMITTED : 'COMMITTED'; +UNCOMMITTED : 'UNCOMMITTED'; +SERIALIZABLE : 'SERIALIZABLE'; + +// Spatial data types + +GEOMETRYCOLLECTION : 'GEOMETRYCOLLECTION'; +GEOMCOLLECTION : 'GEOMCOLLECTION'; +GEOMETRY : 'GEOMETRY'; +LINESTRING : 'LINESTRING'; +MULTILINESTRING : 'MULTILINESTRING'; +MULTIPOINT : 'MULTIPOINT'; +MULTIPOLYGON : 'MULTIPOLYGON'; +POINT : 'POINT'; +POLYGON : 'POLYGON'; + +// Common function names + +ABS : 'ABS'; +ACOS : 'ACOS'; +ADDDATE : 'ADDDATE'; +ADDTIME : 'ADDTIME'; +AES_DECRYPT : 'AES_DECRYPT'; +AES_ENCRYPT : 'AES_ENCRYPT'; +AREA : 'AREA'; +ASBINARY : 'ASBINARY'; +ASIN : 'ASIN'; +ASTEXT : 'ASTEXT'; +ASWKB : 'ASWKB'; +ASWKT : 'ASWKT'; +ASYMMETRIC_DECRYPT : 'ASYMMETRIC_DECRYPT'; +ASYMMETRIC_DERIVE : 'ASYMMETRIC_DERIVE'; +ASYMMETRIC_ENCRYPT : 'ASYMMETRIC_ENCRYPT'; +ASYMMETRIC_SIGN : 'ASYMMETRIC_SIGN'; +ASYMMETRIC_VERIFY : 'ASYMMETRIC_VERIFY'; +ATAN : 'ATAN'; +ATAN2 : 'ATAN2'; +BENCHMARK : 'BENCHMARK'; +BIN : 'BIN'; +BIT_COUNT : 'BIT_COUNT'; +BIT_LENGTH : 'BIT_LENGTH'; +BUFFER : 'BUFFER'; +CATALOG_NAME : 'CATALOG_NAME'; +CEIL : 'CEIL'; +CEILING : 'CEILING'; +CENTROID : 'CENTROID'; +CHARACTER_LENGTH : 'CHARACTER_LENGTH'; +CHARSET : 'CHARSET'; +CHAR_LENGTH : 'CHAR_LENGTH'; +COERCIBILITY : 'COERCIBILITY'; +COLLATION : 'COLLATION'; +COMPRESS : 'COMPRESS'; +CONCAT : 'CONCAT'; +CONCAT_WS : 'CONCAT_WS'; +CONNECTION_ID : 'CONNECTION_ID'; +CONV : 'CONV'; +CONVERT_TZ : 'CONVERT_TZ'; +COS : 'COS'; +COT : 'COT'; +CRC32 : 'CRC32'; +CREATE_ASYMMETRIC_PRIV_KEY : 'CREATE_ASYMMETRIC_PRIV_KEY'; +CREATE_ASYMMETRIC_PUB_KEY : 'CREATE_ASYMMETRIC_PUB_KEY'; +CREATE_DH_PARAMETERS : 'CREATE_DH_PARAMETERS'; +CREATE_DIGEST : 'CREATE_DIGEST'; +CROSSES : 'CROSSES'; +DATEDIFF : 'DATEDIFF'; +DATE_FORMAT : 'DATE_FORMAT'; +DAYNAME : 'DAYNAME'; +DAYOFMONTH : 'DAYOFMONTH'; +DAYOFWEEK : 'DAYOFWEEK'; +DAYOFYEAR : 'DAYOFYEAR'; +DECODE : 'DECODE'; +DEGREES : 'DEGREES'; +DES_DECRYPT : 'DES_DECRYPT'; +DES_ENCRYPT : 'DES_ENCRYPT'; +DIMENSION : 'DIMENSION'; +DISJOINT : 'DISJOINT'; +ELT : 'ELT'; +ENCODE : 'ENCODE'; +ENCRYPT : 'ENCRYPT'; +ENDPOINT : 'ENDPOINT'; +ENGINE_ATTRIBUTE : 'ENGINE_ATTRIBUTE'; +ENVELOPE : 'ENVELOPE'; +EQUALS : 'EQUALS'; +EXP : 'EXP'; +EXPORT_SET : 'EXPORT_SET'; +EXTERIORRING : 'EXTERIORRING'; +EXTRACTVALUE : 'EXTRACTVALUE'; +FIELD : 'FIELD'; +FIND_IN_SET : 'FIND_IN_SET'; +FLOOR : 'FLOOR'; +FORMAT : 'FORMAT'; +FOUND_ROWS : 'FOUND_ROWS'; +FROM_BASE64 : 'FROM_BASE64'; +FROM_DAYS : 'FROM_DAYS'; +FROM_UNIXTIME : 'FROM_UNIXTIME'; +GEOMCOLLFROMTEXT : 'GEOMCOLLFROMTEXT'; +GEOMCOLLFROMWKB : 'GEOMCOLLFROMWKB'; +GEOMETRYCOLLECTIONFROMTEXT : 'GEOMETRYCOLLECTIONFROMTEXT'; +GEOMETRYCOLLECTIONFROMWKB : 'GEOMETRYCOLLECTIONFROMWKB'; +GEOMETRYFROMTEXT : 'GEOMETRYFROMTEXT'; +GEOMETRYFROMWKB : 'GEOMETRYFROMWKB'; +GEOMETRYN : 'GEOMETRYN'; +GEOMETRYTYPE : 'GEOMETRYTYPE'; +GEOMFROMTEXT : 'GEOMFROMTEXT'; +GEOMFROMWKB : 'GEOMFROMWKB'; +GET_FORMAT : 'GET_FORMAT'; +GET_LOCK : 'GET_LOCK'; +GLENGTH : 'GLENGTH'; +GREATEST : 'GREATEST'; +GTID_SUBSET : 'GTID_SUBSET'; +GTID_SUBTRACT : 'GTID_SUBTRACT'; +HEX : 'HEX'; +IFNULL : 'IFNULL'; +INET6_ATON : 'INET6_ATON'; +INET6_NTOA : 'INET6_NTOA'; +INET_ATON : 'INET_ATON'; +INET_NTOA : 'INET_NTOA'; +INSTR : 'INSTR'; +INTERIORRINGN : 'INTERIORRINGN'; +INTERSECTS : 'INTERSECTS'; +ISCLOSED : 'ISCLOSED'; +ISEMPTY : 'ISEMPTY'; +ISNULL : 'ISNULL'; +ISSIMPLE : 'ISSIMPLE'; +IS_FREE_LOCK : 'IS_FREE_LOCK'; +IS_IPV4 : 'IS_IPV4'; +IS_IPV4_COMPAT : 'IS_IPV4_COMPAT'; +IS_IPV4_MAPPED : 'IS_IPV4_MAPPED'; +IS_IPV6 : 'IS_IPV6'; +IS_USED_LOCK : 'IS_USED_LOCK'; +LAST_INSERT_ID : 'LAST_INSERT_ID'; +LCASE : 'LCASE'; +LEAST : 'LEAST'; +LENGTH : 'LENGTH'; +LINEFROMTEXT : 'LINEFROMTEXT'; +LINEFROMWKB : 'LINEFROMWKB'; +LINESTRINGFROMTEXT : 'LINESTRINGFROMTEXT'; +LINESTRINGFROMWKB : 'LINESTRINGFROMWKB'; +LN : 'LN'; +LOAD_FILE : 'LOAD_FILE'; +LOCATE : 'LOCATE'; +LOG : 'LOG'; +LOG10 : 'LOG10'; +LOG2 : 'LOG2'; +LOWER : 'LOWER'; +LPAD : 'LPAD'; +LTRIM : 'LTRIM'; +MAKEDATE : 'MAKEDATE'; +MAKETIME : 'MAKETIME'; +MAKE_SET : 'MAKE_SET'; +MASTER_POS_WAIT : 'MASTER_POS_WAIT'; +MBRCONTAINS : 'MBRCONTAINS'; +MBRDISJOINT : 'MBRDISJOINT'; +MBREQUAL : 'MBREQUAL'; +MBRINTERSECTS : 'MBRINTERSECTS'; +MBROVERLAPS : 'MBROVERLAPS'; +MBRTOUCHES : 'MBRTOUCHES'; +MBRWITHIN : 'MBRWITHIN'; +MD5 : 'MD5'; +MLINEFROMTEXT : 'MLINEFROMTEXT'; +MLINEFROMWKB : 'MLINEFROMWKB'; +MONTHNAME : 'MONTHNAME'; +MPOINTFROMTEXT : 'MPOINTFROMTEXT'; +MPOINTFROMWKB : 'MPOINTFROMWKB'; +MPOLYFROMTEXT : 'MPOLYFROMTEXT'; +MPOLYFROMWKB : 'MPOLYFROMWKB'; +MULTILINESTRINGFROMTEXT : 'MULTILINESTRINGFROMTEXT'; +MULTILINESTRINGFROMWKB : 'MULTILINESTRINGFROMWKB'; +MULTIPOINTFROMTEXT : 'MULTIPOINTFROMTEXT'; +MULTIPOINTFROMWKB : 'MULTIPOINTFROMWKB'; +MULTIPOLYGONFROMTEXT : 'MULTIPOLYGONFROMTEXT'; +MULTIPOLYGONFROMWKB : 'MULTIPOLYGONFROMWKB'; +NAME_CONST : 'NAME_CONST'; +NULLIF : 'NULLIF'; +NUMGEOMETRIES : 'NUMGEOMETRIES'; +NUMINTERIORRINGS : 'NUMINTERIORRINGS'; +NUMPOINTS : 'NUMPOINTS'; +OCT : 'OCT'; +OCTET_LENGTH : 'OCTET_LENGTH'; +ORD : 'ORD'; +OVERLAPS : 'OVERLAPS'; +PERIOD_ADD : 'PERIOD_ADD'; +PERIOD_DIFF : 'PERIOD_DIFF'; +PI : 'PI'; +POINTFROMTEXT : 'POINTFROMTEXT'; +POINTFROMWKB : 'POINTFROMWKB'; +POINTN : 'POINTN'; +POLYFROMTEXT : 'POLYFROMTEXT'; +POLYFROMWKB : 'POLYFROMWKB'; +POLYGONFROMTEXT : 'POLYGONFROMTEXT'; +POLYGONFROMWKB : 'POLYGONFROMWKB'; +POW : 'POW'; +POWER : 'POWER'; +QUOTE : 'QUOTE'; +RADIANS : 'RADIANS'; +RAND : 'RAND'; +RANDOM : 'RANDOM'; +RANDOM_BYTES : 'RANDOM_BYTES'; +RELEASE_LOCK : 'RELEASE_LOCK'; +REVERSE : 'REVERSE'; +ROUND : 'ROUND'; +ROW_COUNT : 'ROW_COUNT'; +RPAD : 'RPAD'; +RTRIM : 'RTRIM'; +SEC_TO_TIME : 'SEC_TO_TIME'; +SECONDARY_ENGINE_ATTRIBUTE : 'SECONDARY_ENGINE_ATTRIBUTE'; +SESSION_USER : 'SESSION_USER'; +SHA : 'SHA'; +SHA1 : 'SHA1'; +SHA2 : 'SHA2'; +SCHEMA_NAME : 'SCHEMA_NAME'; +SIGN : 'SIGN'; +SIN : 'SIN'; +SLEEP : 'SLEEP'; +SOUNDEX : 'SOUNDEX'; +SQL_THREAD_WAIT_AFTER_GTIDS : 'SQL_THREAD_WAIT_AFTER_GTIDS'; +SQRT : 'SQRT'; +SRID : 'SRID'; +STARTPOINT : 'STARTPOINT'; +STRCMP : 'STRCMP'; +STR_TO_DATE : 'STR_TO_DATE'; +ST_AREA : 'ST_AREA'; +ST_ASBINARY : 'ST_ASBINARY'; +ST_ASTEXT : 'ST_ASTEXT'; +ST_ASWKB : 'ST_ASWKB'; +ST_ASWKT : 'ST_ASWKT'; +ST_BUFFER : 'ST_BUFFER'; +ST_CENTROID : 'ST_CENTROID'; +ST_CONTAINS : 'ST_CONTAINS'; +ST_CROSSES : 'ST_CROSSES'; +ST_DIFFERENCE : 'ST_DIFFERENCE'; +ST_DIMENSION : 'ST_DIMENSION'; +ST_DISJOINT : 'ST_DISJOINT'; +ST_DISTANCE : 'ST_DISTANCE'; +ST_ENDPOINT : 'ST_ENDPOINT'; +ST_ENVELOPE : 'ST_ENVELOPE'; +ST_EQUALS : 'ST_EQUALS'; +ST_EXTERIORRING : 'ST_EXTERIORRING'; +ST_GEOMCOLLFROMTEXT : 'ST_GEOMCOLLFROMTEXT'; +ST_GEOMCOLLFROMTXT : 'ST_GEOMCOLLFROMTXT'; +ST_GEOMCOLLFROMWKB : 'ST_GEOMCOLLFROMWKB'; +ST_GEOMETRYCOLLECTIONFROMTEXT : 'ST_GEOMETRYCOLLECTIONFROMTEXT'; +ST_GEOMETRYCOLLECTIONFROMWKB : 'ST_GEOMETRYCOLLECTIONFROMWKB'; +ST_GEOMETRYFROMTEXT : 'ST_GEOMETRYFROMTEXT'; +ST_GEOMETRYFROMWKB : 'ST_GEOMETRYFROMWKB'; +ST_GEOMETRYN : 'ST_GEOMETRYN'; +ST_GEOMETRYTYPE : 'ST_GEOMETRYTYPE'; +ST_GEOMFROMTEXT : 'ST_GEOMFROMTEXT'; +ST_GEOMFROMWKB : 'ST_GEOMFROMWKB'; +ST_INTERIORRINGN : 'ST_INTERIORRINGN'; +ST_INTERSECTION : 'ST_INTERSECTION'; +ST_INTERSECTS : 'ST_INTERSECTS'; +ST_ISCLOSED : 'ST_ISCLOSED'; +ST_ISEMPTY : 'ST_ISEMPTY'; +ST_ISSIMPLE : 'ST_ISSIMPLE'; +ST_LINEFROMTEXT : 'ST_LINEFROMTEXT'; +ST_LINEFROMWKB : 'ST_LINEFROMWKB'; +ST_LINESTRINGFROMTEXT : 'ST_LINESTRINGFROMTEXT'; +ST_LINESTRINGFROMWKB : 'ST_LINESTRINGFROMWKB'; +ST_NUMGEOMETRIES : 'ST_NUMGEOMETRIES'; +ST_NUMINTERIORRING : 'ST_NUMINTERIORRING'; +ST_NUMINTERIORRINGS : 'ST_NUMINTERIORRINGS'; +ST_NUMPOINTS : 'ST_NUMPOINTS'; +ST_OVERLAPS : 'ST_OVERLAPS'; +ST_POINTFROMTEXT : 'ST_POINTFROMTEXT'; +ST_POINTFROMWKB : 'ST_POINTFROMWKB'; +ST_POINTN : 'ST_POINTN'; +ST_POLYFROMTEXT : 'ST_POLYFROMTEXT'; +ST_POLYFROMWKB : 'ST_POLYFROMWKB'; +ST_POLYGONFROMTEXT : 'ST_POLYGONFROMTEXT'; +ST_POLYGONFROMWKB : 'ST_POLYGONFROMWKB'; +ST_SRID : 'ST_SRID'; +ST_STARTPOINT : 'ST_STARTPOINT'; +ST_SYMDIFFERENCE : 'ST_SYMDIFFERENCE'; +ST_TOUCHES : 'ST_TOUCHES'; +ST_UNION : 'ST_UNION'; +ST_WITHIN : 'ST_WITHIN'; +ST_X : 'ST_X'; +ST_Y : 'ST_Y'; +SUBDATE : 'SUBDATE'; +SUBSTRING_INDEX : 'SUBSTRING_INDEX'; +SUBTIME : 'SUBTIME'; +SYSTEM_USER : 'SYSTEM_USER'; +TAN : 'TAN'; +TIMEDIFF : 'TIMEDIFF'; +TIMESTAMPADD : 'TIMESTAMPADD'; +TIMESTAMPDIFF : 'TIMESTAMPDIFF'; +TIME_FORMAT : 'TIME_FORMAT'; +TIME_TO_SEC : 'TIME_TO_SEC'; +TOUCHES : 'TOUCHES'; +TO_BASE64 : 'TO_BASE64'; +TO_DAYS : 'TO_DAYS'; +TO_SECONDS : 'TO_SECONDS'; +TP_CONNECTION_ADMIN : 'TP_CONNECTION_ADMIN'; +UCASE : 'UCASE'; +UNCOMPRESS : 'UNCOMPRESS'; +UNCOMPRESSED_LENGTH : 'UNCOMPRESSED_LENGTH'; +UNHEX : 'UNHEX'; +UNIX_TIMESTAMP : 'UNIX_TIMESTAMP'; +UPDATEXML : 'UPDATEXML'; +UPPER : 'UPPER'; +UUID : 'UUID'; +UUID_SHORT : 'UUID_SHORT'; +VALIDATE_PASSWORD_STRENGTH : 'VALIDATE_PASSWORD_STRENGTH'; +VERSION : 'VERSION'; +WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS : 'WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS'; +WEEKDAY : 'WEEKDAY'; +WEEKOFYEAR : 'WEEKOFYEAR'; +WEIGHT_STRING : 'WEIGHT_STRING'; +WITHIN : 'WITHIN'; +YEARWEEK : 'YEARWEEK'; +Y_FUNCTION : 'Y'; +X_FUNCTION : 'X'; + +// Operators +// Operators. Assigns + +VAR_ASSIGN : ':='; +PLUS_ASSIGN : '+='; +MINUS_ASSIGN : '-='; +MULT_ASSIGN : '*='; +DIV_ASSIGN : '/='; +MOD_ASSIGN : '%='; +AND_ASSIGN : '&='; +XOR_ASSIGN : '^='; +OR_ASSIGN : '|='; + +// Operators. Arithmetics + +STAR : '*'; +DIVIDE : '/'; +MODULE : '%'; +PLUS : '+'; +MINUS : '-'; +DIV : 'DIV'; +MOD : 'MOD'; + +// Operators. Comparation + +EQUAL_SYMBOL : '='; +GREATER_SYMBOL : '>'; +LESS_SYMBOL : '<'; +EXCLAMATION_SYMBOL : '!'; + +// Operators. Bit + +BIT_NOT_OP : '~'; +BIT_OR_OP : '|'; +BIT_AND_OP : '&'; +BIT_XOR_OP : '^'; + +// Constructors symbols + +DOT : '.'; +LR_BRACKET : '('; +RR_BRACKET : ')'; +COMMA : ','; +SEMI : ';'; +AT_SIGN : '@'; +ZERO_DECIMAL : '0'; +ONE_DECIMAL : '1'; +TWO_DECIMAL : '2'; +SINGLE_QUOTE_SYMB : '\''; +DOUBLE_QUOTE_SYMB : '"'; +REVERSE_QUOTE_SYMB : '`'; +COLON_SYMB : ':'; + +fragment QUOTE_SYMB: SINGLE_QUOTE_SYMB | DOUBLE_QUOTE_SYMB | REVERSE_QUOTE_SYMB; + +// Charsets + +CHARSET_REVERSE_QOUTE_STRING: '`' CHARSET_NAME '`'; + +// File's sizes + +FILESIZE_LITERAL: DEC_DIGIT+ ('K' | 'M' | 'G' | 'T'); + +// Literal Primitives + +START_NATIONAL_STRING_LITERAL : 'N' SQUOTA_STRING; +STRING_LITERAL : DQUOTA_STRING | SQUOTA_STRING | BQUOTA_STRING; +DECIMAL_LITERAL : DEC_DIGIT+; +HEXADECIMAL_LITERAL : 'X' '\'' (HEX_DIGIT HEX_DIGIT)+ '\'' | '0X' HEX_DIGIT+; + +REAL_LITERAL: + DEC_DIGIT* '.' DEC_DIGIT+ + | DEC_DIGIT+ '.' EXPONENT_NUM_PART + | DEC_DIGIT* '.' (DEC_DIGIT+ EXPONENT_NUM_PART) + | DEC_DIGIT+ EXPONENT_NUM_PART +; +NULL_SPEC_LITERAL : '\\' 'N'; +BIT_STRING : BIT_STRING_L; +STRING_CHARSET_NAME : '_' CHARSET_NAME; + +// Hack for dotID +// Prevent recognize string: .123somelatin AS ((.123), FLOAT_LITERAL), ((somelatin), ID) +// it must recoginze: .123somelatin AS ((.), DOT), (123somelatin, ID) + +DOT_ID: '.' ID_LITERAL; + +// Identifiers + +ID: ID_LITERAL; +// DOUBLE_QUOTE_ID: '"' ~'"'+ '"'; +REVERSE_QUOTE_ID : BQUOTA_STRING; +HOST_IP_ADDRESS : (AT_SIGN IP_ADDRESS); +LOCAL_ID : AT_SIGN ( STRING_LITERAL | [A-Z0-9._$\u0080-\uFFFF]+); +GLOBAL_ID : AT_SIGN AT_SIGN ( [A-Z0-9._$\u0080-\uFFFF]+ | BQUOTA_STRING); + +// Fragments for Literal primitives + +fragment CHARSET_NAME: + ARMSCII8 + | ASCII + | BIG5 + | BINARY + | CP1250 + | CP1251 + | CP1256 + | CP1257 + | CP850 + | CP852 + | CP866 + | CP932 + | DEC8 + | EUCJPMS + | EUCKR + | GB2312 + | GBK + | GEOSTD8 + | GREEK + | HEBREW + | HP8 + | KEYBCS2 + | KOI8R + | KOI8U + | LATIN1 + | LATIN2 + | LATIN5 + | LATIN7 + | MACCE + | MACROMAN + | SJIS + | SWE7 + | TIS620 + | UCS2 + | UJIS + | UTF16 + | UTF16LE + | UTF32 + | UTF8 + | UTF8MB3 + | UTF8MB4 +; + +fragment EXPONENT_NUM_PART : 'E' [-+]? DEC_DIGIT+; +fragment ID_LITERAL : [A-Z_$0-9\u0080-\uFFFF]*? [A-Z_$\u0080-\uFFFF]+? [A-Z_$0-9\u0080-\uFFFF]*; +fragment DQUOTA_STRING : '"' ( '\\' . | '""' | ~('"' | '\\'))* '"'; +fragment SQUOTA_STRING : '\'' ('\\' . | '\'\'' | ~('\'' | '\\'))* '\''; +fragment BQUOTA_STRING : '`' ( ~'`' | '``')* '`'; +fragment HEX_DIGIT : [0-9A-F]; +fragment DEC_DIGIT : [0-9]; +fragment BIT_STRING_L : 'B' '\'' [01]+ '\''; +fragment IP_ADDRESS : [0-9]+ '.' [0-9.]+ | [0-9A-F]* ':' [0-9A-F]* ':' [0-9A-F:]+; + +// Last tokens must generate Errors + +ERROR_RECONGNIGION: . -> channel(ERRORCHANNEL); \ No newline at end of file diff --git a/headless-services/commons/jpql/grammars/MySqlParser.g4 b/headless-services/commons/jpql/grammars/MySqlParser.g4 new file mode 100644 index 000000000..8090ec727 --- /dev/null +++ b/headless-services/commons/jpql/grammars/MySqlParser.g4 @@ -0,0 +1,3492 @@ +/* +MySQL (Positive Technologies) grammar +The MIT License (MIT). +Copyright (c) 2015-2017, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies. +Copyright (c) 2017, Ivan Khudyashev (IHudyashov@ptsecurity.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging + +parser grammar MySqlParser; + +options { + tokenVocab = MySqlLexer; +} + +// Top Level Description + +root + : sqlStatements? (MINUS MINUS)? EOF + ; + +sqlStatements + : (sqlStatement (MINUS MINUS)? SEMI? | emptyStatement_)* ( + sqlStatement ((MINUS MINUS)? SEMI)? + | emptyStatement_ + ) + ; + +sqlStatement + : ddlStatement + | dmlStatement + | transactionStatement + | replicationStatement + | preparedStatement + | administrationStatement + | utilityStatement + ; + +emptyStatement_ + : SEMI + ; + +ddlStatement + : createDatabase + | createEvent + | createIndex + | createLogfileGroup + | createProcedure + | createFunction + | createServer + | createTable + | createTablespaceInnodb + | createTablespaceNdb + | createTrigger + | createView + | createRole + | alterDatabase + | alterEvent + | alterFunction + | alterInstance + | alterLogfileGroup + | alterProcedure + | alterServer + | alterTable + | alterTablespace + | alterView + | dropDatabase + | dropEvent + | dropIndex + | dropLogfileGroup + | dropProcedure + | dropFunction + | dropServer + | dropTable + | dropTablespace + | dropTrigger + | dropView + | dropRole + | setRole + | renameTable + | truncateTable + ; + +dmlStatement + : selectStatement + | insertStatement + | updateStatement + | deleteStatement + | replaceStatement + | callStatement + | loadDataStatement + | loadXmlStatement + | doStatement + | handlerStatement + | valuesStatement + | withStatement + | tableStatement + ; + +transactionStatement + : startTransaction + | beginWork + | commitWork + | rollbackWork + | savepointStatement + | rollbackStatement + | releaseStatement + | lockTables + | unlockTables + ; + +replicationStatement + : changeMaster + | changeReplicationFilter + | purgeBinaryLogs + | resetMaster + | resetSlave + | startSlave + | stopSlave + | startGroupReplication + | stopGroupReplication + | xaStartTransaction + | xaEndTransaction + | xaPrepareStatement + | xaCommitWork + | xaRollbackWork + | xaRecoverWork + ; + +preparedStatement + : prepareStatement + | executeStatement + | deallocatePrepare + ; + +// remark: NOT INCLUDED IN sqlStatement, but include in body +// of routine's statements +compoundStatement + : blockStatement + | caseStatement + | ifStatement + | leaveStatement + | loopStatement + | repeatStatement + | whileStatement + | iterateStatement + | returnStatement + | cursorStatement + | withStatement dmlStatement + ; + +administrationStatement + : alterUser + | createUser + | dropUser + | grantStatement + | grantProxy + | renameUser + | revokeStatement + | revokeProxy + | analyzeTable + | checkTable + | checksumTable + | optimizeTable + | repairTable + | createUdfunction + | installPlugin + | uninstallPlugin + | setStatement + | showStatement + | binlogStatement + | cacheIndexStatement + | flushStatement + | killStatement + | loadIndexIntoCache + | resetStatement + | shutdownStatement + ; + +utilityStatement + : simpleDescribeStatement + | fullDescribeStatement + | helpStatement + | useStatement + | signalStatement + | resignalStatement + | diagnosticsStatement + ; + +// Data Definition Language + +// Create statements + +createDatabase + : CREATE dbFormat = (DATABASE | SCHEMA) ifNotExists? uid createDatabaseOption* + ; + +createEvent + : CREATE ownerStatement? EVENT ifNotExists? fullId ON SCHEDULE scheduleExpression ( + ON COMPLETION NOT? PRESERVE + )? enableType? (COMMENT STRING_LITERAL)? DO routineBody + ; + +createIndex + : CREATE intimeAction = (ONLINE | OFFLINE)? indexCategory = (UNIQUE | FULLTEXT | SPATIAL)? INDEX uid indexType? ON tableName indexColumnNames + indexOption* ( + ALGORITHM EQUAL_SYMBOL? algType = (DEFAULT | INPLACE | COPY) + | LOCK EQUAL_SYMBOL? lockType = (DEFAULT | NONE | SHARED | EXCLUSIVE) + )* + ; + +createLogfileGroup + : CREATE LOGFILE GROUP uid ADD UNDOFILE undoFile = STRING_LITERAL ( + INITIAL_SIZE '='? initSize = fileSizeLiteral + )? (UNDO_BUFFER_SIZE '='? undoSize = fileSizeLiteral)? ( + REDO_BUFFER_SIZE '='? redoSize = fileSizeLiteral + )? (NODEGROUP '='? uid)? WAIT? (COMMENT '='? comment = STRING_LITERAL)? ENGINE '='? engineName + ; + +createProcedure + : CREATE ownerStatement? PROCEDURE fullId '(' procedureParameter? (',' procedureParameter)* ')' routineOption* routineBody + ; + +createFunction + : CREATE ownerStatement? AGGREGATE? FUNCTION ifNotExists? fullId '(' functionParameter? ( + ',' functionParameter + )* ')' RETURNS dataType routineOption* (routineBody | returnStatement) + ; + +createRole + : CREATE ROLE ifNotExists? roleName (',' roleName)* + ; + +createServer + : CREATE SERVER uid FOREIGN DATA WRAPPER wrapperName = (MYSQL | STRING_LITERAL) OPTIONS '(' serverOption ( + ',' serverOption + )* ')' + ; + +createTable + : CREATE TEMPORARY? TABLE ifNotExists? tableName ( + LIKE tableName + | '(' LIKE parenthesisTable = tableName ')' + ) # copyCreateTable + | CREATE TEMPORARY? TABLE ifNotExists? tableName createDefinitions? ( + tableOption (','? tableOption)* + )? partitionDefinitions? keyViolate = (IGNORE | REPLACE)? AS? selectStatement # queryCreateTable + | CREATE TEMPORARY? TABLE ifNotExists? tableName createDefinitions ( + tableOption (','? tableOption)* + )? partitionDefinitions? # columnCreateTable + ; + +createTablespaceInnodb + : CREATE TABLESPACE uid ADD DATAFILE datafile = STRING_LITERAL ( + FILE_BLOCK_SIZE '=' fileBlockSize = fileSizeLiteral + )? (ENGINE '='? engineName)? + ; + +createTablespaceNdb + : CREATE TABLESPACE uid ADD DATAFILE datafile = STRING_LITERAL USE LOGFILE GROUP uid ( + EXTENT_SIZE '='? extentSize = fileSizeLiteral + )? (INITIAL_SIZE '='? initialSize = fileSizeLiteral)? ( + AUTOEXTEND_SIZE '='? autoextendSize = fileSizeLiteral + )? (MAX_SIZE '='? maxSize = fileSizeLiteral)? (NODEGROUP '='? uid)? WAIT? ( + COMMENT '='? comment = STRING_LITERAL + )? ENGINE '='? engineName + ; + +createTrigger + : CREATE ownerStatement? TRIGGER thisTrigger = fullId triggerTime = (BEFORE | AFTER) triggerEvent = ( + INSERT + | UPDATE + | DELETE + ) ON tableName FOR EACH ROW (triggerPlace = (FOLLOWS | PRECEDES) otherTrigger = fullId)? routineBody + ; + +withClause + : WITH RECURSIVE? commonTableExpressions + ; + +commonTableExpressions + : cteName ('(' cteColumnName (',' cteColumnName)* ')')? AS '(' dmlStatement ')' ( + ',' commonTableExpressions + )? + ; + +cteName + : uid + ; + +cteColumnName + : uid + ; + +createView + : CREATE orReplace? (ALGORITHM '=' algType = (UNDEFINED | MERGE | TEMPTABLE))? ownerStatement? ( + SQL SECURITY secContext = (DEFINER | INVOKER) + )? VIEW fullId ('(' uidList ')')? AS ( + '(' withClause? selectStatement ')' + | withClause? selectStatement (WITH checkOption = (CASCADED | LOCAL)? CHECK OPTION)? + ) + ; + +// details + +createDatabaseOption + : DEFAULT? charSet '='? (charsetName | DEFAULT) + | DEFAULT? COLLATE '='? collationName + | DEFAULT? ENCRYPTION '='? STRING_LITERAL + | READ ONLY '='? (DEFAULT | ZERO_DECIMAL | ONE_DECIMAL) + ; + +charSet + : CHARACTER SET + | CHARSET + | CHAR SET + ; + +currentUserExpression + : CURRENT_USER ('(' ')')? + ; + +ownerStatement + : DEFINER '=' (userName | currentUserExpression) + ; + +scheduleExpression + : AT timestampValue intervalExpr* # preciseSchedule + | EVERY (decimalLiteral | expression) intervalType ( + STARTS startTimestamp = timestampValue (startIntervals += intervalExpr)* + )? (ENDS endTimestamp = timestampValue (endIntervals += intervalExpr)*)? # intervalSchedule + ; + +timestampValue + : CURRENT_TIMESTAMP + | stringLiteral + | decimalLiteral + | expression + ; + +intervalExpr + : '+' INTERVAL (decimalLiteral | expression) intervalType + ; + +intervalType + : intervalTypeBase + | YEAR + | YEAR_MONTH + | DAY_HOUR + | DAY_MINUTE + | DAY_SECOND + | HOUR_MINUTE + | HOUR_SECOND + | MINUTE_SECOND + | SECOND_MICROSECOND + | MINUTE_MICROSECOND + | HOUR_MICROSECOND + | DAY_MICROSECOND + ; + +enableType + : ENABLE + | DISABLE + | DISABLE ON SLAVE + ; + +indexType + : USING (BTREE | HASH) + ; + +indexOption + : KEY_BLOCK_SIZE EQUAL_SYMBOL? fileSizeLiteral + | indexType + | WITH PARSER uid + | COMMENT STRING_LITERAL + | (VISIBLE | INVISIBLE) + | ENGINE_ATTRIBUTE EQUAL_SYMBOL? STRING_LITERAL + | SECONDARY_ENGINE_ATTRIBUTE EQUAL_SYMBOL? STRING_LITERAL + ; + +procedureParameter + : direction = (IN | OUT | INOUT)? uid dataType + ; + +functionParameter + : uid dataType + ; + +routineOption + : COMMENT STRING_LITERAL # routineComment + | LANGUAGE SQL # routineLanguage + | NOT? DETERMINISTIC # routineBehavior + | ( CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA) # routineData + | SQL SECURITY context = (DEFINER | INVOKER) # routineSecurity + ; + +serverOption + : HOST STRING_LITERAL + | DATABASE STRING_LITERAL + | USER STRING_LITERAL + | PASSWORD STRING_LITERAL + | SOCKET STRING_LITERAL + | OWNER STRING_LITERAL + | PORT decimalLiteral + ; + +createDefinitions + : '(' createDefinition (',' createDefinition)* ')' + ; + +createDefinition + : fullColumnName columnDefinition # columnDeclaration + | tableConstraint NOT? ENFORCED? # constraintDeclaration + | indexColumnDefinition # indexDeclaration + ; + +columnDefinition + : dataType columnConstraint* NOT? ENFORCED? + ; + +columnConstraint + : nullNotnull # nullColumnConstraint + | DEFAULT defaultValue # defaultColumnConstraint + | VISIBLE # visibilityColumnConstraint + | INVISIBLE # invisibilityColumnConstraint + | (AUTO_INCREMENT | ON UPDATE currentTimestamp) # autoIncrementColumnConstraint + | PRIMARY? KEY # primaryKeyColumnConstraint + | UNIQUE KEY? # uniqueKeyColumnConstraint + | COMMENT STRING_LITERAL # commentColumnConstraint + | COLUMN_FORMAT colformat = (FIXED | DYNAMIC | DEFAULT) # formatColumnConstraint + | STORAGE storageval = (DISK | MEMORY | DEFAULT) # storageColumnConstraint + | referenceDefinition # referenceColumnConstraint + | COLLATE collationName # collateColumnConstraint + | (GENERATED ALWAYS)? AS '(' expression ')' (VIRTUAL | STORED)? # generatedColumnConstraint + | SERIAL DEFAULT VALUE # serialDefaultColumnConstraint + | (CONSTRAINT name = uid?)? CHECK '(' expression ')' # checkColumnConstraint + ; + +tableConstraint + : (CONSTRAINT name = uid?)? PRIMARY KEY index = uid? indexType? indexColumnNames indexOption* # primaryKeyTableConstraint + | (CONSTRAINT name = uid?)? UNIQUE indexFormat = (INDEX | KEY)? index = uid? indexType? indexColumnNames indexOption* # uniqueKeyTableConstraint + | (CONSTRAINT name = uid?)? FOREIGN KEY index = uid? indexColumnNames referenceDefinition # foreignKeyTableConstraint + | (CONSTRAINT name = uid?)? CHECK '(' expression ')' # checkTableConstraint + ; + +referenceDefinition + : REFERENCES tableName indexColumnNames? (MATCH matchType = (FULL | PARTIAL | SIMPLE))? referenceAction? + ; + +referenceAction + : ON DELETE onDelete = referenceControlType (ON UPDATE onUpdate = referenceControlType)? + | ON UPDATE onUpdate = referenceControlType (ON DELETE onDelete = referenceControlType)? + ; + +referenceControlType + : RESTRICT + | CASCADE + | SET NULL_LITERAL + | NO ACTION + | SET DEFAULT + ; + +indexColumnDefinition + : indexFormat = (INDEX | KEY) uid? indexType? indexColumnNames indexOption* # simpleIndexDeclaration + | (FULLTEXT | SPATIAL) indexFormat = (INDEX | KEY)? uid? indexColumnNames indexOption* # specialIndexDeclaration + ; + +tableOption + : ENGINE '='? engineName? # tableOptionEngine + | ENGINE_ATTRIBUTE '='? STRING_LITERAL # tableOptionEngineAttribute + | AUTOEXTEND_SIZE '='? decimalLiteral # tableOptionAutoextendSize + | AUTO_INCREMENT '='? decimalLiteral # tableOptionAutoIncrement + | AVG_ROW_LENGTH '='? decimalLiteral # tableOptionAverage + | DEFAULT? charSet '='? (charsetName | DEFAULT) # tableOptionCharset + | (CHECKSUM | PAGE_CHECKSUM) '='? boolValue = ('0' | '1') # tableOptionChecksum + | DEFAULT? COLLATE '='? collationName # tableOptionCollate + | COMMENT '='? STRING_LITERAL # tableOptionComment + | COMPRESSION '='? (STRING_LITERAL | ID) # tableOptionCompression + | CONNECTION '='? STRING_LITERAL # tableOptionConnection + | (DATA | INDEX) DIRECTORY '='? STRING_LITERAL # tableOptionDataDirectory + | DELAY_KEY_WRITE '='? boolValue = ('0' | '1') # tableOptionDelay + | ENCRYPTION '='? STRING_LITERAL # tableOptionEncryption + | (PAGE_COMPRESSED | STRING_LITERAL) '='? ('0' | '1') # tableOptionPageCompressed + | (PAGE_COMPRESSION_LEVEL | STRING_LITERAL) '='? decimalLiteral # tableOptionPageCompressionLevel + | ENCRYPTION_KEY_ID '='? decimalLiteral # tableOptionEncryptionKeyId + | INDEX DIRECTORY '='? STRING_LITERAL # tableOptionIndexDirectory + | INSERT_METHOD '='? insertMethod = (NO | FIRST | LAST) # tableOptionInsertMethod + | KEY_BLOCK_SIZE '='? fileSizeLiteral # tableOptionKeyBlockSize + | MAX_ROWS '='? decimalLiteral # tableOptionMaxRows + | MIN_ROWS '='? decimalLiteral # tableOptionMinRows + | PACK_KEYS '='? extBoolValue = ('0' | '1' | DEFAULT) # tableOptionPackKeys + | PASSWORD '='? STRING_LITERAL # tableOptionPassword + | ROW_FORMAT '='? rowFormat = ( + DEFAULT + | DYNAMIC + | FIXED + | COMPRESSED + | REDUNDANT + | COMPACT + | ID + ) # tableOptionRowFormat + | START TRANSACTION # tableOptionStartTransaction + | SECONDARY_ENGINE_ATTRIBUTE '='? STRING_LITERAL # tableOptionSecondaryEngineAttribute + | STATS_AUTO_RECALC '='? extBoolValue = (DEFAULT | '0' | '1') # tableOptionRecalculation + | STATS_PERSISTENT '='? extBoolValue = (DEFAULT | '0' | '1') # tableOptionPersistent + | STATS_SAMPLE_PAGES '='? (DEFAULT | decimalLiteral) # tableOptionSamplePage + | TABLESPACE uid tablespaceStorage? # tableOptionTablespace + | TABLE_TYPE '=' tableType # tableOptionTableType + | tablespaceStorage # tableOptionTablespace + | TRANSACTIONAL '='? ('0' | '1') # tableOptionTransactional + | UNION '='? '(' tables ')' # tableOptionUnion + ; + +tableType + : MYSQL + | ODBC + ; + +tablespaceStorage + : STORAGE (DISK | MEMORY | DEFAULT) + ; + +partitionDefinitions + : PARTITION BY partitionFunctionDefinition (PARTITIONS count = decimalLiteral)? ( + SUBPARTITION BY subpartitionFunctionDefinition (SUBPARTITIONS subCount = decimalLiteral)? + )? ('(' partitionDefinition (',' partitionDefinition)* ')')? + ; + +partitionFunctionDefinition + : LINEAR? HASH '(' expression ')' # partitionFunctionHash + | LINEAR? KEY (ALGORITHM '=' algType = ('1' | '2'))? '(' uidList? ')' # partitionFunctionKey // Optional uidList for MySQL only + | RANGE ('(' expression ')' | COLUMNS '(' uidList ')') # partitionFunctionRange + | LIST ('(' expression ')' | COLUMNS '(' uidList ')') # partitionFunctionList + ; + +subpartitionFunctionDefinition + : LINEAR? HASH '(' expression ')' # subPartitionFunctionHash + | LINEAR? KEY (ALGORITHM '=' algType = ('1' | '2'))? '(' uidList ')' # subPartitionFunctionKey + ; + +partitionDefinition + : PARTITION uid VALUES LESS THAN '(' partitionDefinerAtom (',' partitionDefinerAtom)* ')' partitionOption* ( + '(' subpartitionDefinition (',' subpartitionDefinition)* ')' + )? # partitionComparison + | PARTITION uid VALUES LESS THAN partitionDefinerAtom partitionOption* ( + '(' subpartitionDefinition (',' subpartitionDefinition)* ')' + )? # partitionComparison + | PARTITION uid VALUES IN '(' partitionDefinerAtom (',' partitionDefinerAtom)* ')' partitionOption* ( + '(' subpartitionDefinition (',' subpartitionDefinition)* ')' + )? # partitionListAtom + | PARTITION uid VALUES IN '(' partitionDefinerVector (',' partitionDefinerVector)* ')' partitionOption* ( + '(' subpartitionDefinition (',' subpartitionDefinition)* ')' + )? # partitionListVector + | PARTITION uid partitionOption* ('(' subpartitionDefinition (',' subpartitionDefinition)* ')')? # partitionSimple + ; + +partitionDefinerAtom + : constant + | expression + | MAXVALUE + ; + +partitionDefinerVector + : '(' partitionDefinerAtom (',' partitionDefinerAtom)+ ')' + ; + +subpartitionDefinition + : SUBPARTITION uid partitionOption* + ; + +partitionOption + : DEFAULT? STORAGE? ENGINE '='? engineName # partitionOptionEngine + | COMMENT '='? comment = STRING_LITERAL # partitionOptionComment + | DATA DIRECTORY '='? dataDirectory = STRING_LITERAL # partitionOptionDataDirectory + | INDEX DIRECTORY '='? indexDirectory = STRING_LITERAL # partitionOptionIndexDirectory + | MAX_ROWS '='? maxRows = decimalLiteral # partitionOptionMaxRows + | MIN_ROWS '='? minRows = decimalLiteral # partitionOptionMinRows + | TABLESPACE '='? tablespace = uid # partitionOptionTablespace + | NODEGROUP '='? nodegroup = uid # partitionOptionNodeGroup + ; + +// Alter statements + +alterDatabase + : ALTER dbFormat = (DATABASE | SCHEMA) uid? createDatabaseOption+ # alterSimpleDatabase + | ALTER dbFormat = (DATABASE | SCHEMA) uid UPGRADE DATA DIRECTORY NAME # alterUpgradeName + ; + +alterEvent + : ALTER ownerStatement? EVENT fullId (ON SCHEDULE scheduleExpression)? ( + ON COMPLETION NOT? PRESERVE + )? (RENAME TO fullId)? enableType? (COMMENT STRING_LITERAL)? (DO routineBody)? + ; + +alterFunction + : ALTER FUNCTION fullId routineOption* + ; + +alterInstance + : ALTER INSTANCE ROTATE INNODB MASTER KEY + ; + +alterLogfileGroup + : ALTER LOGFILE GROUP uid ADD UNDOFILE STRING_LITERAL (INITIAL_SIZE '='? fileSizeLiteral)? WAIT? ENGINE '='? engineName + ; + +alterProcedure + : ALTER PROCEDURE fullId routineOption* + ; + +alterServer + : ALTER SERVER uid OPTIONS '(' serverOption (',' serverOption)* ')' + ; + +alterTable + : ALTER intimeAction = (ONLINE | OFFLINE)? IGNORE? TABLE tableName waitNowaitClause? ( + alterSpecification (',' alterSpecification)* + )? partitionDefinitions? + ; + +alterTablespace + : ALTER TABLESPACE uid objectAction = (ADD | DROP) DATAFILE STRING_LITERAL ( + INITIAL_SIZE '=' fileSizeLiteral + )? WAIT? ENGINE '='? engineName + ; + +alterView + : ALTER (ALGORITHM '=' algType = (UNDEFINED | MERGE | TEMPTABLE))? ownerStatement? ( + SQL SECURITY secContext = (DEFINER | INVOKER) + )? VIEW fullId ('(' uidList ')')? AS selectStatement ( + WITH checkOpt = (CASCADED | LOCAL)? CHECK OPTION + )? + ; + +// details + +alterSpecification + : tableOption (','? tableOption)* # alterByTableOption + | ADD COLUMN? uid columnDefinition (FIRST | AFTER uid)? # alterByAddColumn + | ADD COLUMN? '(' uid columnDefinition (',' uid columnDefinition)* ')' # alterByAddColumns + | ADD indexFormat = (INDEX | KEY) uid? indexType? indexColumnNames indexOption* # alterByAddIndex + | ADD (CONSTRAINT name = uid?)? PRIMARY KEY index = uid? indexType? indexColumnNames indexOption* # alterByAddPrimaryKey + | ADD (CONSTRAINT name = uid?)? UNIQUE indexFormat = (INDEX | KEY)? indexName = uid? indexType? indexColumnNames indexOption* # alterByAddUniqueKey + | ADD keyType = (FULLTEXT | SPATIAL) indexFormat = (INDEX | KEY)? uid? indexColumnNames indexOption* # alterByAddSpecialIndex + | ADD (CONSTRAINT name = uid?)? FOREIGN KEY indexName = uid? indexColumnNames referenceDefinition # alterByAddForeignKey + | ADD (CONSTRAINT name = uid?)? CHECK (uid | stringLiteral | '(' expression ')') NOT? ENFORCED? # alterByAddCheckTableConstraint + | ALTER (CONSTRAINT name = uid?)? CHECK (uid | stringLiteral | '(' expression ')') NOT? ENFORCED? # alterByAlterCheckTableConstraint + | ADD (CONSTRAINT name = uid?)? CHECK '(' expression ')' # alterByAddCheckTableConstraint + | ALGORITHM '='? algType = (DEFAULT | INSTANT | INPLACE | COPY) # alterBySetAlgorithm + | ALTER COLUMN? uid (SET DEFAULT defaultValue | DROP DEFAULT) # alterByChangeDefault + | CHANGE COLUMN? oldColumn = uid newColumn = uid columnDefinition ( + FIRST + | AFTER afterColumn = uid + )? # alterByChangeColumn + | RENAME COLUMN oldColumn = uid TO newColumn = uid # alterByRenameColumn + | LOCK '='? lockType = (DEFAULT | NONE | SHARED | EXCLUSIVE) # alterByLock + | MODIFY COLUMN? uid columnDefinition (FIRST | AFTER uid)? # alterByModifyColumn + | DROP COLUMN? uid RESTRICT? # alterByDropColumn + | DROP (CONSTRAINT | CHECK) uid # alterByDropConstraintCheck + | DROP PRIMARY KEY # alterByDropPrimaryKey + | DROP indexFormat = (INDEX | KEY) uid # alterByDropIndex + | RENAME indexFormat = (INDEX | KEY) uid TO uid # alterByRenameIndex + | ALTER COLUMN? uid ( + SET DEFAULT ( stringLiteral | '(' expression ')') + | SET (VISIBLE | INVISIBLE) + | DROP DEFAULT + ) # alterByAlterColumnDefault + | ALTER INDEX uid (VISIBLE | INVISIBLE) # alterByAlterIndexVisibility + | DROP FOREIGN KEY uid # alterByDropForeignKey + | DISABLE KEYS # alterByDisableKeys + | ENABLE KEYS # alterByEnableKeys + | RENAME renameFormat = (TO | AS)? (uid | fullId) # alterByRename + | ORDER BY uidList # alterByOrder + | CONVERT TO (CHARSET | CHARACTER SET) charsetName (COLLATE collationName)? # alterByConvertCharset + | DEFAULT? CHARACTER SET '=' charsetName (COLLATE '=' collationName)? # alterByDefaultCharset + | DISCARD TABLESPACE # alterByDiscardTablespace + | IMPORT TABLESPACE # alterByImportTablespace + | FORCE # alterByForce + | validationFormat = (WITHOUT | WITH) VALIDATION # alterByValidate + | ADD COLUMN? '(' createDefinition (',' createDefinition)* ')' # alterByAddDefinitions + | alterPartitionSpecification # alterPartition + ; + +alterPartitionSpecification + : ADD PARTITION '(' partitionDefinition (',' partitionDefinition)* ')' # alterByAddPartition + | DROP PARTITION uidList # alterByDropPartition + | DISCARD PARTITION (uidList | ALL) TABLESPACE # alterByDiscardPartition + | IMPORT PARTITION (uidList | ALL) TABLESPACE # alterByImportPartition + | TRUNCATE PARTITION (uidList | ALL) # alterByTruncatePartition + | COALESCE PARTITION decimalLiteral # alterByCoalescePartition + | REORGANIZE PARTITION uidList INTO '(' partitionDefinition (',' partitionDefinition)* ')' # alterByReorganizePartition + | EXCHANGE PARTITION uid WITH TABLE tableName (validationFormat = (WITH | WITHOUT) VALIDATION)? # alterByExchangePartition + | ANALYZE PARTITION (uidList | ALL) # alterByAnalyzePartition + | CHECK PARTITION (uidList | ALL) # alterByCheckPartition + | OPTIMIZE PARTITION (uidList | ALL) # alterByOptimizePartition + | REBUILD PARTITION (uidList | ALL) # alterByRebuildPartition + | REPAIR PARTITION (uidList | ALL) # alterByRepairPartition + | REMOVE PARTITIONING # alterByRemovePartitioning + | UPGRADE PARTITIONING # alterByUpgradePartitioning + ; + +// Drop statements + +dropDatabase + : DROP dbFormat = (DATABASE | SCHEMA) ifExists? uid + ; + +dropEvent + : DROP EVENT ifExists? fullId + ; + +dropIndex + : DROP INDEX intimeAction = (ONLINE | OFFLINE)? uid ON tableName ( + ALGORITHM '='? algType = (DEFAULT | INPLACE | COPY) + | LOCK '='? lockType = (DEFAULT | NONE | SHARED | EXCLUSIVE) + )* + ; + +dropLogfileGroup + : DROP LOGFILE GROUP uid ENGINE '=' engineName + ; + +dropProcedure + : DROP PROCEDURE ifExists? fullId + ; + +dropFunction + : DROP FUNCTION ifExists? fullId + ; + +dropServer + : DROP SERVER ifExists? uid + ; + +dropTable + : DROP TEMPORARY? TABLE ifExists? tables dropType = (RESTRICT | CASCADE)? + ; + +dropTablespace + : DROP TABLESPACE uid (ENGINE '='? engineName)? + ; + +dropTrigger + : DROP TRIGGER ifExists? fullId + ; + +dropView + : DROP VIEW ifExists? fullId (',' fullId)* dropType = (RESTRICT | CASCADE)? + ; + +dropRole + : DROP ROLE ifExists? roleName (',' roleName)* + ; + +setRole + : SET DEFAULT ROLE (NONE | ALL | roleName (',' roleName)*) TO (userName | uid) ( + ',' (userName | uid) + )* + | SET ROLE roleOption + ; + +// Other DDL statements + +renameTable + : RENAME TABLE renameTableClause (',' renameTableClause)* + ; + +renameTableClause + : tableName TO tableName + ; + +truncateTable + : TRUNCATE TABLE? tableName + ; + +// Data Manipulation Language + +// Primary DML Statements + +callStatement + : CALL fullId ('(' (constants | expressions)? ')')? + ; + +deleteStatement + : singleDeleteStatement + | multipleDeleteStatement + ; + +doStatement + : DO expressions + ; + +handlerStatement + : handlerOpenStatement + | handlerReadIndexStatement + | handlerReadStatement + | handlerCloseStatement + ; + +insertStatement + : INSERT priority = (LOW_PRIORITY | DELAYED | HIGH_PRIORITY)? IGNORE? INTO? tableName ( + PARTITION '(' partitions = uidList? ')' + )? ( + ('(' columns = fullColumnNameList? ')')? insertStatementValue (AS? uid)? + | SET setFirst = updatedElement (',' setElements += updatedElement)* + ) ( + ON DUPLICATE KEY UPDATE duplicatedFirst = updatedElement ( + ',' duplicatedElements += updatedElement + )* + )? + ; + +loadDataStatement + : LOAD DATA priority = (LOW_PRIORITY | CONCURRENT)? LOCAL? INFILE filename = STRING_LITERAL violation = ( + REPLACE + | IGNORE + )? INTO TABLE tableName (PARTITION '(' uidList ')')? (CHARACTER SET charset = charsetName)? ( + fieldsFormat = (FIELDS | COLUMNS) selectFieldsInto+ + )? (LINES selectLinesInto+)? (IGNORE decimalLiteral linesFormat = (LINES | ROWS))? ( + '(' assignmentField (',' assignmentField)* ')' + )? (SET updatedElement (',' updatedElement)*)? + ; + +loadXmlStatement + : LOAD XML priority = (LOW_PRIORITY | CONCURRENT)? LOCAL? INFILE filename = STRING_LITERAL violation = ( + REPLACE + | IGNORE + )? INTO TABLE tableName (CHARACTER SET charset = charsetName)? ( + ROWS IDENTIFIED BY '<' tag = STRING_LITERAL '>' + )? (IGNORE decimalLiteral linesFormat = (LINES | ROWS))? ( + '(' assignmentField (',' assignmentField)* ')' + )? (SET updatedElement (',' updatedElement)*)? + ; + +replaceStatement + : REPLACE priority = (LOW_PRIORITY | DELAYED)? INTO? tableName ( + PARTITION '(' partitions = uidList ')' + )? ( + ('(' columns = uidList ')')? insertStatementValue + | SET setFirst = updatedElement (',' setElements += updatedElement)* + ) + ; + +selectStatement + : querySpecification lockClause? # simpleSelect + | queryExpression lockClause? # parenthesisSelect + | (querySpecificationNointo | queryExpressionNointo) unionStatement+ ( + UNION unionType = (ALL | DISTINCT)? (querySpecification | queryExpression) + )? orderByClause? limitClause? lockClause? # unionSelect + | queryExpressionNointo unionParenthesis+ (UNION unionType = (ALL | DISTINCT)? queryExpression)? orderByClause? limitClause? lockClause? # + unionParenthesisSelect + | querySpecificationNointo (',' lateralStatement)+ # withLateralStatement + ; + +updateStatement + : singleUpdateStatement + | multipleUpdateStatement + ; + +// https://dev.mysql.com/doc/refman/8.0/en/values.html +valuesStatement + : VALUES '(' expressionsWithDefaults? ')' (',' '(' expressionsWithDefaults? ')')* + ; + +// details + +insertStatementValue + : selectStatement + | insertFormat = (VALUES | VALUE) '(' expressionsWithDefaults? ')' ( + ',' '(' expressionsWithDefaults? ')' + )* + ; + +updatedElement + : fullColumnName '=' (expression | DEFAULT) + ; + +assignmentField + : uid + | LOCAL_ID + ; + +lockClause + : FOR UPDATE + | LOCK IN SHARE MODE + ; + +// Detailed DML Statements + +singleDeleteStatement + : DELETE priority = LOW_PRIORITY? QUICK? IGNORE? FROM tableName (AS? uid)? ( + PARTITION '(' uidList ')' + )? (WHERE expression)? orderByClause? (LIMIT limitClauseAtom)? + ; + +multipleDeleteStatement + : DELETE priority = LOW_PRIORITY? QUICK? IGNORE? ( + tableName ('.' '*')? ( ',' tableName ('.' '*')?)* FROM tableSources + | FROM tableName ('.' '*')? ( ',' tableName ('.' '*')?)* USING tableSources + ) (WHERE expression)? + ; + +handlerOpenStatement + : HANDLER tableName OPEN (AS? uid)? + ; + +handlerReadIndexStatement + : HANDLER tableName READ index = uid ( + comparisonOperator '(' constants ')' + | moveOrder = (FIRST | NEXT | PREV | LAST) + ) (WHERE expression)? (LIMIT limitClauseAtom)? + ; + +handlerReadStatement + : HANDLER tableName READ moveOrder = (FIRST | NEXT) (WHERE expression)? (LIMIT limitClauseAtom)? + ; + +handlerCloseStatement + : HANDLER tableName CLOSE + ; + +singleUpdateStatement + : UPDATE priority = LOW_PRIORITY? IGNORE? tableName (AS? uid)? SET updatedElement ( + ',' updatedElement + )* (WHERE expression)? orderByClause? limitClause? + ; + +multipleUpdateStatement + : UPDATE priority = LOW_PRIORITY? IGNORE? tableSources SET updatedElement (',' updatedElement)* ( + WHERE expression + )? + ; + +// details + +orderByClause + : ORDER BY orderByExpression (',' orderByExpression)* + ; + +orderByExpression + : expression order = (ASC | DESC)? + ; + +tableSources + : tableSource (',' tableSource)* + ; + +tableSource + : tableSourceItem joinPart* # tableSourceBase + | '(' tableSourceItem joinPart* ')' # tableSourceNested + | jsonTable # tableJson + ; + +tableSourceItem + : tableName (PARTITION '(' uidList ')')? (AS? alias = uid)? (indexHint (',' indexHint)*)? # atomTableItem + | (selectStatement | '(' parenthesisSubquery = selectStatement ')') AS? alias = uid # subqueryTableItem + | '(' tableSources ')' # tableSourcesItem + ; + +indexHint + : indexHintAction = (USE | IGNORE | FORCE) keyFormat = (INDEX | KEY) (FOR indexHintType)? '(' uidList ')' + ; + +indexHintType + : JOIN + | ORDER BY + | GROUP BY + ; + +joinPart + : (INNER | CROSS)? JOIN LATERAL? tableSourceItem joinSpec* # innerJoin + | STRAIGHT_JOIN tableSourceItem (ON expression)* # straightJoin + | (LEFT | RIGHT) OUTER? JOIN LATERAL? tableSourceItem joinSpec* # outerJoin + | NATURAL ((LEFT | RIGHT) OUTER?)? JOIN tableSourceItem # naturalJoin + ; + +joinSpec + : (ON expression) + | USING '(' uidList ')' + ; + +// Select Statement's Details + +queryExpression + : '(' querySpecification ')' + | '(' queryExpression ')' + ; + +queryExpressionNointo + : '(' querySpecificationNointo ')' + | '(' queryExpressionNointo ')' + ; + +querySpecification + : SELECT selectSpec* selectElements selectIntoExpression? fromClause groupByClause? havingClause? windowClause? orderByClause? limitClause? + | SELECT selectSpec* selectElements fromClause groupByClause? havingClause? windowClause? orderByClause? limitClause? selectIntoExpression? + ; + +querySpecificationNointo + : SELECT selectSpec* selectElements fromClause groupByClause? havingClause? windowClause? orderByClause? limitClause? unionStatement? + ; + +unionParenthesis + : UNION unionType = (ALL | DISTINCT)? queryExpressionNointo + ; + +unionStatement + : UNION unionType = (ALL | DISTINCT)? (querySpecificationNointo | queryExpressionNointo) + ; + +lateralStatement + : LATERAL ( + querySpecificationNointo + | queryExpressionNointo + | ('(' (querySpecificationNointo | queryExpressionNointo) ')' (AS? uid)?) + ) + ; + +// JSON + +// https://dev.mysql.com/doc/refman/8.0/en/json-table-functions.html +jsonTable + : JSON_TABLE '(' STRING_LITERAL ',' STRING_LITERAL COLUMNS '(' jsonColumnList ')' ')' (AS? uid)? + ; + +jsonColumnList + : jsonColumn (',' jsonColumn)* + ; + +jsonColumn + : fullColumnName ( + FOR ORDINALITY + | dataType (PATH STRING_LITERAL jsonOnEmpty? jsonOnError? | EXISTS PATH STRING_LITERAL) + ) + | NESTED PATH? STRING_LITERAL COLUMNS '(' jsonColumnList ')' + ; + +jsonOnEmpty + : (NULL_LITERAL | ERROR | DEFAULT defaultValue) ON EMPTY + ; + +jsonOnError + : (NULL_LITERAL | ERROR | DEFAULT defaultValue) ON ERROR + ; + +// details + +selectSpec + : (ALL | DISTINCT | DISTINCTROW) + | HIGH_PRIORITY + | STRAIGHT_JOIN + | SQL_SMALL_RESULT + | SQL_BIG_RESULT + | SQL_BUFFER_RESULT + | (SQL_CACHE | SQL_NO_CACHE) + | SQL_CALC_FOUND_ROWS + ; + +selectElements + : (star = '*' | selectElement) (',' selectElement)* + ; + +selectElement + : fullId '.' '*' # selectStarElement + | fullColumnName (AS? uid)? # selectColumnElement + | functionCall (AS? uid)? # selectFunctionElement + | (LOCAL_ID VAR_ASSIGN)? expression (AS? uid)? # selectExpressionElement + ; + +selectIntoExpression + : INTO assignmentField (',' assignmentField)* # selectIntoVariables + | INTO DUMPFILE STRING_LITERAL # selectIntoDumpFile + | ( + INTO OUTFILE filename = STRING_LITERAL (CHARACTER SET charset = charsetName)? ( + fieldsFormat = (FIELDS | COLUMNS) selectFieldsInto+ + )? (LINES selectLinesInto+)? + ) # selectIntoTextFile + ; + +selectFieldsInto + : TERMINATED BY terminationField = STRING_LITERAL + | OPTIONALLY? ENCLOSED BY enclosion = STRING_LITERAL + | ESCAPED BY escaping = STRING_LITERAL + ; + +selectLinesInto + : STARTING BY starting = STRING_LITERAL + | TERMINATED BY terminationLine = STRING_LITERAL + ; + +fromClause + : (FROM tableSources)? (WHERE whereExpr = expression)? + ; + +groupByClause + : GROUP BY groupByItem (',' groupByItem)* (WITH ROLLUP)? + ; + +havingClause + : HAVING havingExpr = expression + ; + +windowClause + : WINDOW windowName AS '(' windowSpec ')' (',' windowName AS '(' windowSpec ')')* + ; + +groupByItem + : expression order = (ASC | DESC)? + ; + +limitClause + : LIMIT ( + (offset = limitClauseAtom ',')? limit = limitClauseAtom + | limit = limitClauseAtom OFFSET offset = limitClauseAtom + ) + ; + +limitClauseAtom + : decimalLiteral + | mysqlVariable + | simpleId + ; + +// Transaction's Statements + +startTransaction + : START TRANSACTION (transactionMode (',' transactionMode)*)? + ; + +beginWork + : BEGIN WORK? + ; + +commitWork + : COMMIT WORK? (AND nochain = NO? CHAIN)? (norelease = NO? RELEASE)? + ; + +rollbackWork + : ROLLBACK WORK? (AND nochain = NO? CHAIN)? (norelease = NO? RELEASE)? + ; + +savepointStatement + : SAVEPOINT uid + ; + +rollbackStatement + : ROLLBACK WORK? TO SAVEPOINT? uid + ; + +releaseStatement + : RELEASE SAVEPOINT uid + ; + +lockTables + : LOCK (TABLE | TABLES) lockTableElement (',' lockTableElement)* waitNowaitClause? + ; + +unlockTables + : UNLOCK TABLES + ; + +// details + +setAutocommitStatement + : SET AUTOCOMMIT '=' autocommitValue = ('0' | '1') + ; + +setTransactionStatement + : SET transactionContext = (GLOBAL | SESSION)? TRANSACTION transactionOption ( + ',' transactionOption + )* + ; + +transactionMode + : WITH CONSISTENT SNAPSHOT + | READ WRITE + | READ ONLY + ; + +lockTableElement + : tableName (AS? uid)? lockAction + ; + +lockAction + : READ LOCAL? + | LOW_PRIORITY? WRITE + ; + +transactionOption + : ISOLATION LEVEL transactionLevel + | READ WRITE + | READ ONLY + ; + +transactionLevel + : REPEATABLE READ + | READ COMMITTED + | READ UNCOMMITTED + | SERIALIZABLE + ; + +// Replication's Statements + +// Base Replication + +changeMaster + : CHANGE MASTER TO masterOption (',' masterOption)* channelOption? + ; + +changeReplicationFilter + : CHANGE REPLICATION FILTER replicationFilter (',' replicationFilter)* + ; + +purgeBinaryLogs + : PURGE purgeFormat = (BINARY | MASTER) LOGS ( + TO fileName = STRING_LITERAL + | BEFORE timeValue = STRING_LITERAL + ) + ; + +resetMaster + : RESET MASTER + ; + +resetSlave + : RESET SLAVE ALL? channelOption? + ; + +startSlave + : START SLAVE (threadType (',' threadType)*)? (UNTIL untilOption)? connectionOption* channelOption? + ; + +stopSlave + : STOP SLAVE (threadType (',' threadType)*)? + ; + +startGroupReplication + : START GROUP_REPLICATION + ; + +stopGroupReplication + : STOP GROUP_REPLICATION + ; + +// details + +masterOption + : stringMasterOption '=' STRING_LITERAL # masterStringOption + | decimalMasterOption '=' decimalLiteral # masterDecimalOption + | boolMasterOption '=' boolVal = ('0' | '1') # masterBoolOption + | MASTER_HEARTBEAT_PERIOD '=' REAL_LITERAL # masterRealOption + | IGNORE_SERVER_IDS '=' '(' (uid (',' uid)*)? ')' # masterUidListOption + ; + +stringMasterOption + : MASTER_BIND + | MASTER_HOST + | MASTER_USER + | MASTER_PASSWORD + | MASTER_LOG_FILE + | RELAY_LOG_FILE + | MASTER_SSL_CA + | MASTER_SSL_CAPATH + | MASTER_SSL_CERT + | MASTER_SSL_CRL + | MASTER_SSL_CRLPATH + | MASTER_SSL_KEY + | MASTER_SSL_CIPHER + | MASTER_TLS_VERSION + ; + +decimalMasterOption + : MASTER_PORT + | MASTER_CONNECT_RETRY + | MASTER_RETRY_COUNT + | MASTER_DELAY + | MASTER_LOG_POS + | RELAY_LOG_POS + ; + +boolMasterOption + : MASTER_AUTO_POSITION + | MASTER_SSL + | MASTER_SSL_VERIFY_SERVER_CERT + ; + +channelOption + : FOR CHANNEL STRING_LITERAL + ; + +replicationFilter + : REPLICATE_DO_DB '=' '(' uidList ')' # doDbReplication + | REPLICATE_IGNORE_DB '=' '(' uidList ')' # ignoreDbReplication + | REPLICATE_DO_TABLE '=' '(' tables ')' # doTableReplication + | REPLICATE_IGNORE_TABLE '=' '(' tables ')' # ignoreTableReplication + | REPLICATE_WILD_DO_TABLE '=' '(' simpleStrings ')' # wildDoTableReplication + | REPLICATE_WILD_IGNORE_TABLE '=' '(' simpleStrings ')' # wildIgnoreTableReplication + | REPLICATE_REWRITE_DB '=' '(' tablePair (',' tablePair)* ')' # rewriteDbReplication + ; + +tablePair + : '(' firstTable = tableName ',' secondTable = tableName ')' + ; + +threadType + : IO_THREAD + | SQL_THREAD + ; + +untilOption + : gtids = (SQL_BEFORE_GTIDS | SQL_AFTER_GTIDS) '=' gtuidSet # gtidsUntilOption + | MASTER_LOG_FILE '=' STRING_LITERAL ',' MASTER_LOG_POS '=' decimalLiteral # masterLogUntilOption + | RELAY_LOG_FILE '=' STRING_LITERAL ',' RELAY_LOG_POS '=' decimalLiteral # relayLogUntilOption + | SQL_AFTER_MTS_GAPS # sqlGapsUntilOption + ; + +connectionOption + : USER '=' conOptUser = STRING_LITERAL # userConnectionOption + | PASSWORD '=' conOptPassword = STRING_LITERAL # passwordConnectionOption + | DEFAULT_AUTH '=' conOptDefAuth = STRING_LITERAL # defaultAuthConnectionOption + | PLUGIN_DIR '=' conOptPluginDir = STRING_LITERAL # pluginDirConnectionOption + ; + +gtuidSet + : uuidSet (',' uuidSet)* + | STRING_LITERAL + ; + +// XA Transactions + +xaStartTransaction + : XA xaStart = (START | BEGIN) xid xaAction = (JOIN | RESUME)? + ; + +xaEndTransaction + : XA END xid (SUSPEND (FOR MIGRATE)?)? + ; + +xaPrepareStatement + : XA PREPARE xid + ; + +xaCommitWork + : XA COMMIT xid (ONE PHASE)? + ; + +xaRollbackWork + : XA ROLLBACK xid + ; + +xaRecoverWork + : XA RECOVER (CONVERT xid)? + ; + +// Prepared Statements + +prepareStatement + : PREPARE uid FROM (query = STRING_LITERAL | variable = LOCAL_ID) + ; + +executeStatement + : EXECUTE uid (USING userVariables)? + ; + +deallocatePrepare + : dropFormat = (DEALLOCATE | DROP) PREPARE uid + ; + +// Compound Statements + +routineBody + : blockStatement + | sqlStatement + ; + +// details + +blockStatement + : (uid ':')? BEGIN (declareVariable SEMI)* (declareCondition SEMI)* (declareCursor SEMI)* ( + declareHandler SEMI + )* procedureSqlStatement* END uid? + ; + +caseStatement + : CASE (uid | expression)? caseAlternative+ (ELSE procedureSqlStatement+)? END CASE + ; + +ifStatement + : IF expression THEN thenStatements += procedureSqlStatement+ elifAlternative* ( + ELSE elseStatements += procedureSqlStatement+ + )? END IF + ; + +iterateStatement + : ITERATE uid + ; + +leaveStatement + : LEAVE uid + ; + +loopStatement + : (uid ':')? LOOP procedureSqlStatement+ END LOOP uid? + ; + +repeatStatement + : (uid ':')? REPEAT procedureSqlStatement+ UNTIL expression END REPEAT uid? + ; + +returnStatement + : RETURN expression + ; + +whileStatement + : (uid ':')? WHILE expression DO procedureSqlStatement+ END WHILE uid? + ; + +cursorStatement + : CLOSE uid # CloseCursor + | FETCH (NEXT? FROM)? uid INTO uidList # FetchCursor + | OPEN uid # OpenCursor + ; + +// details + +declareVariable + : DECLARE uidList dataType (DEFAULT expression)? + ; + +declareCondition + : DECLARE uid CONDITION FOR (decimalLiteral | SQLSTATE VALUE? STRING_LITERAL) + ; + +declareCursor + : DECLARE uid CURSOR FOR selectStatement + ; + +declareHandler + : DECLARE handlerAction = (CONTINUE | EXIT | UNDO) HANDLER FOR handlerConditionValue ( + ',' handlerConditionValue + )* routineBody + ; + +handlerConditionValue + : decimalLiteral # handlerConditionCode + | SQLSTATE VALUE? STRING_LITERAL # handlerConditionState + | uid # handlerConditionName + | SQLWARNING # handlerConditionWarning + | NOT FOUND # handlerConditionNotfound + | SQLEXCEPTION # handlerConditionException + ; + +procedureSqlStatement + : (compoundStatement | sqlStatement) SEMI + ; + +caseAlternative + : WHEN (constant | expression) THEN procedureSqlStatement+ + ; + +elifAlternative + : ELSEIF expression THEN procedureSqlStatement+ + ; + +// Administration Statements + +// Account management statements + +alterUser + : ALTER USER userSpecification (',' userSpecification)* # alterUserMysqlV56 + | ALTER USER ifExists? userAuthOption (',' userAuthOption)* ( + REQUIRE (tlsNone = NONE | tlsOption (AND? tlsOption)*) + )? (WITH userResourceOption+)? (userPasswordOption | userLockOption)* ( + COMMENT STRING_LITERAL + | ATTRIBUTE STRING_LITERAL + )? # alterUserMysqlV80 + | ALTER USER ifExists? (userName | uid) DEFAULT ROLE roleOption # alterUserMysqlV80 + ; + +createUser + : CREATE USER userAuthOption (',' userAuthOption)* # createUserMysqlV56 + | CREATE USER ifNotExists? userAuthOption (',' userAuthOption)* (DEFAULT ROLE roleOption)? ( + REQUIRE (tlsNone = NONE | tlsOption (AND? tlsOption)*) + )? (WITH userResourceOption+)? (userPasswordOption | userLockOption)* ( + COMMENT STRING_LITERAL + | ATTRIBUTE STRING_LITERAL + )? # createUserMysqlV80 + ; + +dropUser + : DROP USER ifExists? userName (',' userName)* + ; + +grantStatement + : GRANT privelegeClause (',' privelegeClause)* ON privilegeObject = ( + TABLE + | FUNCTION + | PROCEDURE + )? privilegeLevel TO userAuthOption (',' userAuthOption)* ( + REQUIRE (tlsNone = NONE | tlsOption (AND? tlsOption)*) + )? (WITH (GRANT OPTION | userResourceOption)*)? (AS userName WITH ROLE roleOption)? + | GRANT (userName | uid) (',' (userName | uid))* TO (userName | uid) (',' (userName | uid))* ( + WITH ADMIN OPTION + )? + ; + +roleOption + : DEFAULT + | NONE + | ALL (EXCEPT userName (',' userName)*)? + | userName (',' userName)* + ; + +grantProxy + : GRANT PROXY ON fromFirst = userName TO toFirst = userName (',' toOther += userName)* ( + WITH GRANT OPTION + )? + ; + +renameUser + : RENAME USER renameUserClause (',' renameUserClause)* + ; + +revokeStatement + : REVOKE privelegeClause (',' privelegeClause)* ON privilegeObject = ( + TABLE + | FUNCTION + | PROCEDURE + )? privilegeLevel FROM userName (',' userName)* # detailRevoke + | REVOKE ALL PRIVILEGES? ',' GRANT OPTION FROM userName (',' userName)* # shortRevoke + | REVOKE (userName | uid) (',' (userName | uid))* FROM (userName | uid) (',' (userName | uid))* # roleRevoke + ; + +revokeProxy + : REVOKE PROXY ON onUser = userName FROM fromFirst = userName (',' fromOther += userName)* + ; + +setPasswordStatement + : SET PASSWORD (FOR userName)? '=' (passwordFunctionClause | STRING_LITERAL) + ; + +// details + +userSpecification + : userName userPasswordOption + ; + +userAuthOption + : userName IDENTIFIED BY PASSWORD hashed = STRING_LITERAL # hashAuthOption + | userName IDENTIFIED BY RANDOM PASSWORD authOptionClause # randomAuthOption + | userName IDENTIFIED BY STRING_LITERAL authOptionClause # stringAuthOption + | userName IDENTIFIED WITH authenticationRule # moduleAuthOption + | userName # simpleAuthOption + ; + +authOptionClause + : (REPLACE STRING_LITERAL)? (RETAIN CURRENT PASSWORD)? + ; + +authenticationRule + : authPlugin ((BY | USING | AS) (STRING_LITERAL | RANDOM PASSWORD) authOptionClause)? # module + | authPlugin USING passwordFunctionClause # passwordModuleOption + ; + +tlsOption + : SSL + | X509 + | CIPHER STRING_LITERAL + | ISSUER STRING_LITERAL + | SUBJECT STRING_LITERAL + ; + +userResourceOption + : MAX_QUERIES_PER_HOUR decimalLiteral + | MAX_UPDATES_PER_HOUR decimalLiteral + | MAX_CONNECTIONS_PER_HOUR decimalLiteral + | MAX_USER_CONNECTIONS decimalLiteral + ; + +userPasswordOption + : PASSWORD EXPIRE ( + expireType = DEFAULT + | expireType = NEVER + | expireType = INTERVAL decimalLiteral DAY + )? + | PASSWORD HISTORY (DEFAULT | decimalLiteral) + | PASSWORD REUSE INTERVAL (DEFAULT | decimalLiteral DAY) + | PASSWORD REQUIRE CURRENT (OPTIONAL | DEFAULT)? + | FAILED_LOGIN_ATTEMPTS decimalLiteral + | PASSWORD_LOCK_TIME (decimalLiteral | UNBOUNDED) + ; + +userLockOption + : ACCOUNT lockType = (LOCK | UNLOCK) + ; + +privelegeClause + : privilege ('(' uidList ')')? + ; + +privilege + : ALL PRIVILEGES? + | ALTER ROUTINE? + | CREATE (TEMPORARY TABLES | ROUTINE | VIEW | USER | TABLESPACE | ROLE)? + | DELETE + | DROP (ROLE)? + | EVENT + | EXECUTE + | FILE + | GRANT OPTION + | INDEX + | INSERT + | LOCK TABLES + | PROCESS + | PROXY + | REFERENCES + | RELOAD + | REPLICATION (CLIENT | SLAVE) + | SELECT + | SHOW (VIEW | DATABASES) + | SHUTDOWN + | SUPER + | TRIGGER + | UPDATE + | USAGE + | APPLICATION_PASSWORD_ADMIN + | AUDIT_ABORT_EXEMPT + | AUDIT_ADMIN + | AUTHENTICATION_POLICY_ADMIN + | BACKUP_ADMIN + | BINLOG_ADMIN + | BINLOG_ENCRYPTION_ADMIN + | CLONE_ADMIN + | CONNECTION_ADMIN + | ENCRYPTION_KEY_ADMIN + | FIREWALL_ADMIN + | FIREWALL_EXEMPT + | FIREWALL_USER + | FLUSH_OPTIMIZER_COSTS + | FLUSH_STATUS + | FLUSH_TABLES + | FLUSH_USER_RESOURCES + | GROUP_REPLICATION_ADMIN + | INNODB_REDO_LOG_ARCHIVE + | INNODB_REDO_LOG_ENABLE + | NDB_STORED_USER + | PASSWORDLESS_USER_ADMIN + | PERSIST_RO_VARIABLES_ADMIN + | REPLICATION_APPLIER + | REPLICATION_SLAVE_ADMIN + | RESOURCE_GROUP_ADMIN + | RESOURCE_GROUP_USER + | ROLE_ADMIN + | SERVICE_CONNECTION_ADMIN + | SESSION_VARIABLES_ADMIN + | SET_USER_ID + | SKIP_QUERY_REWRITE + | SHOW_ROUTINE + | SYSTEM_USER + | SYSTEM_VARIABLES_ADMIN + | TABLE_ENCRYPTION_ADMIN + | TP_CONNECTION_ADMIN + | VERSION_TOKEN_ADMIN + | XA_RECOVER_ADMIN + // MySQL on Amazon RDS + | LOAD FROM S3 + | SELECT INTO S3 + | INVOKE LAMBDA + ; + +privilegeLevel + : '*' # currentSchemaPriviLevel + | '*' '.' '*' # globalPrivLevel + | uid '.' '*' # definiteSchemaPrivLevel + | uid '.' uid # definiteFullTablePrivLevel + | uid dottedId # definiteFullTablePrivLevel2 + | uid # definiteTablePrivLevel + ; + +renameUserClause + : fromFirst = userName TO toFirst = userName + ; + +// Table maintenance statements + +analyzeTable + : ANALYZE actionOption = (NO_WRITE_TO_BINLOG | LOCAL)? (TABLE | TABLES) tables ( + UPDATE HISTOGRAM ON fullColumnName (',' fullColumnName)* (WITH decimalLiteral BUCKETS)? + )? (DROP HISTOGRAM ON fullColumnName (',' fullColumnName)*)? + ; + +checkTable + : CHECK TABLE tables checkTableOption* + ; + +checksumTable + : CHECKSUM TABLE tables actionOption = (QUICK | EXTENDED)? + ; + +optimizeTable + : OPTIMIZE actionOption = (NO_WRITE_TO_BINLOG | LOCAL)? (TABLE | TABLES) tables + ; + +repairTable + : REPAIR actionOption = (NO_WRITE_TO_BINLOG | LOCAL)? TABLE tables QUICK? EXTENDED? USE_FRM? + ; + +// details + +checkTableOption + : FOR UPGRADE + | QUICK + | FAST + | MEDIUM + | EXTENDED + | CHANGED + ; + +// Plugin and udf statements + +createUdfunction + : CREATE AGGREGATE? FUNCTION ifNotExists? uid RETURNS returnType = ( + STRING + | INTEGER + | REAL + | DECIMAL + ) SONAME STRING_LITERAL + ; + +installPlugin + : INSTALL PLUGIN uid SONAME STRING_LITERAL + ; + +uninstallPlugin + : UNINSTALL PLUGIN uid + ; + +// Set and show statements + +setStatement + : SET variableClause ('=' | ':=') (expression | ON) ( + ',' variableClause ('=' | ':=') (expression | ON) + )* # setVariable + | SET charSet (charsetName | DEFAULT) # setCharset + | SET NAMES (charsetName (COLLATE collationName)? | DEFAULT) # setNames + | setPasswordStatement # setPassword + | setTransactionStatement # setTransaction + | setAutocommitStatement # setAutocommit + | SET fullId ('=' | ':=') expression (',' fullId ('=' | ':=') expression)* # setNewValueInsideTrigger + ; + +showStatement + : SHOW logFormat = (BINARY | MASTER) LOGS # showMasterLogs + | SHOW logFormat = (BINLOG | RELAYLOG) EVENTS (IN filename = STRING_LITERAL)? ( + FROM fromPosition = decimalLiteral + )? (LIMIT (offset = decimalLiteral ',')? rowCount = decimalLiteral)? # showLogEvents + | SHOW showCommonEntity showFilter? # showObjectFilter + | SHOW FULL? columnsFormat = (COLUMNS | FIELDS) tableFormat = (FROM | IN) tableName ( + schemaFormat = (FROM | IN) uid + )? showFilter? # showColumns + | SHOW CREATE schemaFormat = (DATABASE | SCHEMA) ifNotExists? uid # showCreateDb + | SHOW CREATE namedEntity = (EVENT | FUNCTION | PROCEDURE | TABLE | TRIGGER | VIEW) fullId # showCreateFullIdObject + | SHOW CREATE USER userName # showCreateUser + | SHOW ENGINE engineName engineOption = (STATUS | MUTEX) # showEngine + | SHOW showGlobalInfoClause # showGlobalInfo + | SHOW errorFormat = (ERRORS | WARNINGS) ( + LIMIT (offset = decimalLiteral ',')? rowCount = decimalLiteral + )? # showErrors + | SHOW COUNT '(' '*' ')' errorFormat = (ERRORS | WARNINGS) # showCountErrors + | SHOW showSchemaEntity (schemaFormat = (FROM | IN) uid)? showFilter? # showSchemaFilter + | SHOW routine = (FUNCTION | PROCEDURE) CODE fullId # showRoutine + | SHOW GRANTS (FOR userName)? # showGrants + | SHOW indexFormat = (INDEX | INDEXES | KEYS) tableFormat = (FROM | IN) tableName ( + schemaFormat = (FROM | IN) uid + )? (WHERE expression)? # showIndexes + | SHOW OPEN TABLES (schemaFormat = (FROM | IN) uid)? showFilter? # showOpenTables + | SHOW PROFILE showProfileType (',' showProfileType)* (FOR QUERY queryCount = decimalLiteral)? ( + LIMIT (offset = decimalLiteral ',')? rowCount = decimalLiteral + ) # showProfile + | SHOW SLAVE STATUS (FOR CHANNEL STRING_LITERAL)? # showSlaveStatus + ; + +// details + +variableClause + : LOCAL_ID + | GLOBAL_ID + | ( ('@' '@')? (GLOBAL | SESSION | LOCAL))? uid + ; + +showCommonEntity + : CHARACTER SET + | COLLATION + | DATABASES + | SCHEMAS + | FUNCTION STATUS + | PROCEDURE STATUS + | (GLOBAL | SESSION)? (STATUS | VARIABLES) + ; + +showFilter + : LIKE STRING_LITERAL + | WHERE expression + ; + +showGlobalInfoClause + : STORAGE? ENGINES + | MASTER STATUS + | PLUGINS + | PRIVILEGES + | FULL? PROCESSLIST + | PROFILES + | SLAVE HOSTS + | AUTHORS + | CONTRIBUTORS + ; + +showSchemaEntity + : EVENTS + | TABLE STATUS + | FULL? TABLES + | TRIGGERS + ; + +showProfileType + : ALL + | BLOCK IO + | CONTEXT SWITCHES + | CPU + | IPC + | MEMORY + | PAGE FAULTS + | SOURCE + | SWAPS + ; + +// Other administrative statements + +binlogStatement + : BINLOG STRING_LITERAL + ; + +cacheIndexStatement + : CACHE INDEX tableIndexes (',' tableIndexes)* (PARTITION '(' (uidList | ALL) ')')? IN schema = uid + ; + +flushStatement + : FLUSH flushFormat = (NO_WRITE_TO_BINLOG | LOCAL)? flushOption (',' flushOption)* + ; + +killStatement + : KILL connectionFormat = (CONNECTION | QUERY)? expression + ; + +loadIndexIntoCache + : LOAD INDEX INTO CACHE loadedTableIndexes (',' loadedTableIndexes)* + ; + +// remark reset (maser | slave) describe in replication's +// statements section +resetStatement + : RESET QUERY CACHE + ; + +shutdownStatement + : SHUTDOWN + ; + +// details + +tableIndexes + : tableName (indexFormat = (INDEX | KEY)? '(' uidList ')')? + ; + +flushOption + : ( + DES_KEY_FILE + | HOSTS + | ( BINARY | ENGINE | ERROR | GENERAL | RELAY | SLOW)? LOGS + | OPTIMIZER_COSTS + | PRIVILEGES + | QUERY CACHE + | STATUS + | USER_RESOURCES + | TABLES (WITH READ LOCK)? + ) # simpleFlushOption + | RELAY LOGS channelOption? # channelFlushOption + | (TABLE | TABLES) tables? flushTableOption? # tableFlushOption + ; + +flushTableOption + : WITH READ LOCK + | FOR EXPORT + ; + +loadedTableIndexes + : tableName (PARTITION '(' (partitionList = uidList | ALL) ')')? ( + indexFormat = (INDEX | KEY)? '(' indexList = uidList ')' + )? (IGNORE LEAVES)? + ; + +// Utility Statements + +simpleDescribeStatement + : command = (EXPLAIN | DESCRIBE | DESC) tableName (column = uid | pattern = STRING_LITERAL)? + ; + +fullDescribeStatement + : command = (EXPLAIN | DESCRIBE | DESC) ( + formatType = (EXTENDED | PARTITIONS | FORMAT) '=' formatValue = (TRADITIONAL | JSON) + )? describeObjectClause + ; + +helpStatement + : HELP STRING_LITERAL + ; + +useStatement + : USE uid + ; + +signalStatement + : SIGNAL (( SQLSTATE VALUE? stringLiteral) | ID | REVERSE_QUOTE_ID) ( + SET signalConditionInformation ( ',' signalConditionInformation)* + )? + ; + +resignalStatement + : RESIGNAL (( SQLSTATE VALUE? stringLiteral) | ID | REVERSE_QUOTE_ID)? ( + SET signalConditionInformation ( ',' signalConditionInformation)* + )? + ; + +signalConditionInformation + : ( + CLASS_ORIGIN + | SUBCLASS_ORIGIN + | MESSAGE_TEXT + | MYSQL_ERRNO + | CONSTRAINT_CATALOG + | CONSTRAINT_SCHEMA + | CONSTRAINT_NAME + | CATALOG_NAME + | SCHEMA_NAME + | TABLE_NAME + | COLUMN_NAME + | CURSOR_NAME + ) '=' (stringLiteral | DECIMAL_LITERAL | mysqlVariable | simpleId) + ; + +withStatement + : WITH RECURSIVE? commonTableExpressions (',' commonTableExpressions)* + ; + +tableStatement + : TABLE tableName orderByClause? limitClause? + ; + +diagnosticsStatement + : GET (CURRENT | STACKED)? DIAGNOSTICS ( + (variableClause '=' ( NUMBER | ROW_COUNT) ( ',' variableClause '=' ( NUMBER | ROW_COUNT))*) + | ( + CONDITION (decimalLiteral | variableClause) variableClause '=' diagnosticsConditionInformationName ( + ',' variableClause '=' diagnosticsConditionInformationName + )* + ) + ) + ; + +diagnosticsConditionInformationName + : CLASS_ORIGIN + | SUBCLASS_ORIGIN + | RETURNED_SQLSTATE + | MESSAGE_TEXT + | MYSQL_ERRNO + | CONSTRAINT_CATALOG + | CONSTRAINT_SCHEMA + | CONSTRAINT_NAME + | CATALOG_NAME + | SCHEMA_NAME + | TABLE_NAME + | COLUMN_NAME + | CURSOR_NAME + ; + +// details + +describeObjectClause + : (selectStatement | deleteStatement | insertStatement | replaceStatement | updateStatement) # describeStatements + | FOR CONNECTION uid # describeConnection + ; + +// Common Clauses + +// DB Objects + +fullId + : uid (DOT_ID | '.' uid)? + ; + +tableName + : fullId + ; + +roleName + : userName + | uid + ; + +fullColumnName + : uid (dottedId dottedId?)? + | .? dottedId dottedId? + ; + +indexColumnName + : ((uid | STRING_LITERAL) ('(' decimalLiteral ')')? | expression) sortType = (ASC | DESC)? + ; + +simpleUserName + : STRING_LITERAL + | ID + | ADMIN + | keywordsCanBeId + ; + +hostName + : (LOCAL_ID | HOST_IP_ADDRESS | '@') + ; + +userName + : simpleUserName + | simpleUserName hostName + | currentUserExpression + ; + +mysqlVariable + : LOCAL_ID + | GLOBAL_ID + ; + +charsetName + : BINARY + | charsetNameBase + | STRING_LITERAL + | CHARSET_REVERSE_QOUTE_STRING + ; + +collationName + : uid + | STRING_LITERAL + ; + +engineName + : engineNameBase + | ID + | STRING_LITERAL + ; + +engineNameBase + : ARCHIVE + | BLACKHOLE + | CONNECT + | CSV + | FEDERATED + | INNODB + | MEMORY + | MRG_MYISAM + | MYISAM + | NDB + | NDBCLUSTER + | PERFORMANCE_SCHEMA + | TOKUDB + ; + +uuidSet + : decimalLiteral '-' decimalLiteral '-' decimalLiteral '-' decimalLiteral '-' decimalLiteral ( + ':' decimalLiteral '-' decimalLiteral + )+ + ; + +xid + : globalTableUid = xuidStringId (',' qualifier = xuidStringId (',' idFormat = decimalLiteral)?)? + ; + +xuidStringId + : STRING_LITERAL + | BIT_STRING + | HEXADECIMAL_LITERAL+ + ; + +authPlugin + : uid + | STRING_LITERAL + ; + +uid + : simpleId + //| DOUBLE_QUOTE_ID + //| REVERSE_QUOTE_ID + | CHARSET_REVERSE_QOUTE_STRING + | STRING_LITERAL + ; + +simpleId + : ID + | charsetNameBase + | transactionLevelBase + | engineNameBase + | privilegesBase + | intervalTypeBase + | dataTypeBase + | keywordsCanBeId + | scalarFunctionName + ; + +dottedId + : DOT_ID + | '.' uid + ; + +// Literals + +decimalLiteral + : DECIMAL_LITERAL + | ZERO_DECIMAL + | ONE_DECIMAL + | TWO_DECIMAL + | REAL_LITERAL + ; + +fileSizeLiteral + : FILESIZE_LITERAL + | decimalLiteral + ; + +stringLiteral + : (STRING_CHARSET_NAME? STRING_LITERAL | START_NATIONAL_STRING_LITERAL) STRING_LITERAL+ + | (STRING_CHARSET_NAME? STRING_LITERAL | START_NATIONAL_STRING_LITERAL) (COLLATE collationName)? + ; + +booleanLiteral + : TRUE + | FALSE + ; + +hexadecimalLiteral + : STRING_CHARSET_NAME? HEXADECIMAL_LITERAL + ; + +nullNotnull + : NOT? (NULL_LITERAL | NULL_SPEC_LITERAL) + ; + +constant + : stringLiteral + | decimalLiteral + | '-' decimalLiteral + | hexadecimalLiteral + | booleanLiteral + | REAL_LITERAL + | BIT_STRING + | NOT? nullLiteral = (NULL_LITERAL | NULL_SPEC_LITERAL) + ; + +// Data Types + +dataType + : typeName = ( + CHAR + | CHARACTER + | VARCHAR + | TINYTEXT + | TEXT + | MEDIUMTEXT + | LONGTEXT + | NCHAR + | NVARCHAR + | LONG + ) VARYING? lengthOneDimension? BINARY? (charSet charsetName)? (COLLATE collationName | BINARY)? # stringDataType + | NATIONAL typeName = (CHAR | CHARACTER) VARYING lengthOneDimension? BINARY? # nationalVaryingStringDataType + | NATIONAL typeName = (VARCHAR | CHARACTER | CHAR) lengthOneDimension? BINARY? # nationalStringDataType + | NCHAR typeName = VARCHAR lengthOneDimension? BINARY? # nationalStringDataType + | typeName = ( + TINYINT + | SMALLINT + | MEDIUMINT + | INT + | INTEGER + | BIGINT + | MIDDLEINT + | INT1 + | INT2 + | INT3 + | INT4 + | INT8 + ) lengthOneDimension? (SIGNED | UNSIGNED | ZEROFILL)* # dimensionDataType + | typeName = REAL lengthTwoDimension? (SIGNED | UNSIGNED | ZEROFILL)* # dimensionDataType + | typeName = DOUBLE PRECISION? lengthTwoDimension? (SIGNED | UNSIGNED | ZEROFILL)* # dimensionDataType + | typeName = (DECIMAL | DEC | FIXED | NUMERIC | FLOAT | FLOAT4 | FLOAT8) lengthTwoOptionalDimension? ( + SIGNED + | UNSIGNED + | ZEROFILL + )* # dimensionDataType + | typeName = (DATE | TINYBLOB | MEDIUMBLOB | LONGBLOB | BOOL | BOOLEAN | SERIAL) # simpleDataType + | typeName = (BIT | TIME | TIMESTAMP | DATETIME | BINARY | VARBINARY | BLOB | YEAR) lengthOneDimension? # dimensionDataType + | typeName = (ENUM | SET) collectionOptions BINARY? (charSet charsetName)? # collectionDataType + | typeName = ( + GEOMETRYCOLLECTION + | GEOMCOLLECTION + | LINESTRING + | MULTILINESTRING + | MULTIPOINT + | MULTIPOLYGON + | POINT + | POLYGON + | JSON + | GEOMETRY + ) (SRID decimalLiteral)? # spatialDataType + | typeName = LONG VARCHAR? BINARY? (charSet charsetName)? (COLLATE collationName)? # longVarcharDataType // LONG VARCHAR is the same as LONG + | LONG VARBINARY # longVarbinaryDataType + ; + +collectionOptions + : '(' STRING_LITERAL (',' STRING_LITERAL)* ')' + ; + +convertedDataType + : ( + typeName = (BINARY | NCHAR | FLOAT) lengthOneDimension? + | typeName = CHAR lengthOneDimension? (charSet charsetName)? + | typeName = (DATE | DATETIME | TIME | YEAR | JSON | INT | INTEGER | DOUBLE) + | typeName = (DECIMAL | DEC) lengthTwoOptionalDimension? + | (SIGNED | UNSIGNED) (INTEGER | INT)? + ) ARRAY? + ; + +lengthOneDimension + : '(' decimalLiteral ')' + ; + +lengthTwoDimension + : '(' decimalLiteral ',' decimalLiteral ')' + ; + +lengthTwoOptionalDimension + : '(' decimalLiteral (',' decimalLiteral)? ')' + ; + +// Common Lists + +uidList + : uid (',' uid)* + ; + +fullColumnNameList + : fullColumnName (',' fullColumnName)* + ; + +tables + : tableName (',' tableName)* + ; + +indexColumnNames + : '(' indexColumnName (',' indexColumnName)* ')' + ; + +expressions + : expression (',' expression)* + ; + +expressionsWithDefaults + : expressionOrDefault (',' expressionOrDefault)* + ; + +constants + : constant (',' constant)* + ; + +simpleStrings + : STRING_LITERAL (',' STRING_LITERAL)* + ; + +userVariables + : LOCAL_ID (',' LOCAL_ID)* + ; + +// Common Expressons + +defaultValue + : NULL_LITERAL + | CAST '(' expression AS convertedDataType ')' + | unaryOperator? constant + | currentTimestamp (ON UPDATE currentTimestamp)? + | '(' expression ')' + | '(' fullId ')' + ; + +currentTimestamp + : ( + (CURRENT_TIMESTAMP | LOCALTIME | LOCALTIMESTAMP) ('(' decimalLiteral? ')')? + | NOW '(' decimalLiteral? ')' + ) + ; + +expressionOrDefault + : expression + | DEFAULT + ; + +ifExists + : IF EXISTS + ; + +ifNotExists + : IF NOT EXISTS + ; + +orReplace + : OR REPLACE + ; + +waitNowaitClause + : WAIT decimalLiteral + | NOWAIT + ; + +// Functions + +functionCall + : specificFunction # specificFunctionCall + | aggregateWindowedFunction # aggregateFunctionCall + | nonAggregateWindowedFunction # nonAggregateFunctionCall + | scalarFunctionName '(' functionArgs? ')' # scalarFunctionCall + | fullId '(' functionArgs? ')' # udfFunctionCall + | passwordFunctionClause # passwordFunctionCall + ; + +specificFunction + : (CURRENT_DATE | CURRENT_TIME | CURRENT_TIMESTAMP | LOCALTIME | UTC_TIMESTAMP | SCHEMA) ( + '(' ')' + )? # simpleFunctionCall + | currentUserExpression # currentUser + | CONVERT '(' expression separator = ',' convertedDataType ')' # dataTypeFunctionCall + | CONVERT '(' expression USING charsetName ')' # dataTypeFunctionCall + | CAST '(' expression AS convertedDataType ')' # dataTypeFunctionCall + | VALUES '(' fullColumnName ')' # valuesFunctionCall + | CASE expression caseFuncAlternative+ (ELSE elseArg = functionArg)? END # caseExpressionFunctionCall + | CASE caseFuncAlternative+ (ELSE elseArg = functionArg)? END # caseFunctionCall + | CHAR '(' functionArgs (USING charsetName)? ')' # charFunctionCall + | POSITION '(' (positionString = stringLiteral | positionExpression = expression) IN ( + inString = stringLiteral + | inExpression = expression + ) ')' # positionFunctionCall + | (SUBSTR | SUBSTRING) '(' (sourceString = stringLiteral | sourceExpression = expression) FROM ( + fromDecimal = decimalLiteral + | fromExpression = expression + ) (FOR ( forDecimal = decimalLiteral | forExpression = expression))? ')' # substrFunctionCall + | TRIM '(' positioinForm = (BOTH | LEADING | TRAILING) ( + sourceString = stringLiteral + | sourceExpression = expression + )? FROM (fromString = stringLiteral | fromExpression = expression) ')' # trimFunctionCall + | TRIM '(' (sourceString = stringLiteral | sourceExpression = expression) FROM ( + fromString = stringLiteral + | fromExpression = expression + ) ')' # trimFunctionCall + | WEIGHT_STRING '(' (stringLiteral | expression) ( + AS stringFormat = (CHAR | BINARY) '(' decimalLiteral ')' + )? levelsInWeightString? ')' # weightFunctionCall + | EXTRACT '(' intervalType FROM (sourceString = stringLiteral | sourceExpression = expression) ')' # extractFunctionCall + | GET_FORMAT '(' datetimeFormat = (DATE | TIME | DATETIME) ',' stringLiteral ')' # getFormatFunctionCall + | JSON_VALUE '(' expression ',' expression (RETURNING convertedDataType)? jsonOnEmpty? jsonOnError? ')' # jsonValueFunctionCall + ; + +caseFuncAlternative + : WHEN condition = functionArg THEN consequent = functionArg + ; + +levelsInWeightString + : LEVEL levelInWeightListElement (',' levelInWeightListElement)* # levelWeightList + | LEVEL firstLevel = decimalLiteral '-' lastLevel = decimalLiteral # levelWeightRange + ; + +levelInWeightListElement + : decimalLiteral orderType = (ASC | DESC | REVERSE)? + ; + +aggregateWindowedFunction + : (AVG | MAX | MIN | SUM) '(' aggregator = (ALL | DISTINCT)? functionArg ')' overClause? + | COUNT '(' ( + starArg = '*' + | aggregator = ALL? functionArg + | aggregator = DISTINCT functionArgs + ) ')' overClause? + | ( + BIT_AND + | BIT_OR + | BIT_XOR + | STD + | STDDEV + | STDDEV_POP + | STDDEV_SAMP + | VAR_POP + | VAR_SAMP + | VARIANCE + ) '(' aggregator = ALL? functionArg ')' overClause? + | GROUP_CONCAT '(' aggregator = DISTINCT? functionArgs ( + ORDER BY orderByExpression (',' orderByExpression)* + )? (SEPARATOR separator = STRING_LITERAL)? ')' + ; + +nonAggregateWindowedFunction + : (LAG | LEAD) '(' expression (',' decimalLiteral)? (',' decimalLiteral)? ')' overClause + | (FIRST_VALUE | LAST_VALUE) '(' expression ')' overClause + | (CUME_DIST | DENSE_RANK | PERCENT_RANK | RANK | ROW_NUMBER) '(' ')' overClause + | NTH_VALUE '(' expression ',' decimalLiteral ')' overClause + | NTILE '(' decimalLiteral ')' overClause + ; + +overClause + : OVER ('(' windowSpec ')' | windowName) + ; + +windowSpec + : windowName? partitionClause? orderByClause? frameClause? + ; + +windowName + : uid + ; + +frameClause + : frameUnits frameExtent + ; + +frameUnits + : ROWS + | RANGE + ; + +frameExtent + : frameRange + | frameBetween + ; + +frameBetween + : BETWEEN frameRange AND frameRange + ; + +frameRange + : CURRENT ROW + | UNBOUNDED (PRECEDING | FOLLOWING) + | expression (PRECEDING | FOLLOWING) + ; + +partitionClause + : PARTITION BY expression (',' expression)* + ; + +scalarFunctionName + : functionNameBase + | ASCII + | CURDATE + | CURRENT_DATE + | CURRENT_TIME + | CURRENT_TIMESTAMP + | CURTIME + | DATE_ADD + | DATE_SUB + | IF + | INSERT + | LOCALTIME + | LOCALTIMESTAMP + | MID + | NOW + | REPEAT + | REPLACE + | SUBSTR + | SUBSTRING + | SYSDATE + | TRIM + | UTC_DATE + | UTC_TIME + | UTC_TIMESTAMP + ; + +passwordFunctionClause + : functionName = (PASSWORD | OLD_PASSWORD) '(' functionArg ')' + ; + +functionArgs + : (constant | fullColumnName | functionCall | expression) ( + ',' (constant | fullColumnName | functionCall | expression) + )* + ; + +functionArg + : constant + | fullColumnName + | functionCall + | expression + ; + +// Expressions, predicates + +// Simplified approach for expression +expression + : notOperator = (NOT | '!') expression # notExpression + | expression logicalOperator expression # logicalExpression + | predicate IS NOT? testValue = (TRUE | FALSE | UNKNOWN) # isExpression + | predicate # predicateExpression + ; + +predicate + : predicate NOT? IN '(' (selectStatement | expressions) ')' # inPredicate + | predicate IS nullNotnull # isNullPredicate + | left = predicate comparisonOperator right = predicate # binaryComparisonPredicate + | predicate comparisonOperator quantifier = (ALL | ANY | SOME) '(' selectStatement ')' # subqueryComparisonPredicate + | predicate NOT? BETWEEN predicate AND predicate # betweenPredicate + | predicate SOUNDS LIKE predicate # soundsLikePredicate + | predicate NOT? LIKE predicate (ESCAPE STRING_LITERAL)? # likePredicate + | predicate NOT? regex = (REGEXP | RLIKE) predicate # regexpPredicate + | predicate MEMBER OF '(' predicate ')' # jsonMemberOfPredicate + | expressionAtom # expressionAtomPredicate + ; + +// Add in ASTVisitor nullNotnull in constant +expressionAtom + : constant # constantExpressionAtom + | fullColumnName # fullColumnNameExpressionAtom + | functionCall # functionCallExpressionAtom + | expressionAtom COLLATE collationName # collateExpressionAtom + | mysqlVariable # mysqlVariableExpressionAtom + | unaryOperator expressionAtom # unaryExpressionAtom + | BINARY expressionAtom # binaryExpressionAtom + | LOCAL_ID VAR_ASSIGN expressionAtom # variableAssignExpressionAtom + | SPEL # spelExpressionAtom + | '(' expression (',' expression)* ')' # nestedExpressionAtom + | ROW '(' expression (',' expression)+ ')' # nestedRowExpressionAtom + | EXISTS '(' selectStatement ')' # existsExpressionAtom + | '(' selectStatement ')' # subqueryExpressionAtom + | INTERVAL expression intervalType # intervalExpressionAtom + | left = expressionAtom bitOperator right = expressionAtom # bitExpressionAtom + | left = expressionAtom multOperator right = expressionAtom # mathExpressionAtom + | left = expressionAtom addOperator right = expressionAtom # mathExpressionAtom + | left = expressionAtom jsonOperator right = expressionAtom # jsonExpressionAtom + ; + +unaryOperator + : '!' + | '~' + | '+' + | '-' + | NOT + ; + +comparisonOperator + : '=' + | '>' + | '<' + | '<' '=' + | '>' '=' + | '<' '>' + | '!' '=' + | '<' '=' '>' + ; + +logicalOperator + : AND + | '&' '&' + | XOR + | OR + | '|' '|' + ; + +bitOperator + : '<' '<' + | '>' '>' + | '&' + | '^' + | '|' + ; + +multOperator + : '*' + | '/' + | '%' + | DIV + | MOD + ; + +addOperator + : '+' + | '-' + ; + +jsonOperator + : '-' '>' + | '-' '>' '>' + ; + +// Simple id sets +// (that keyword, which can be id) + +charsetNameBase + : ARMSCII8 + | ASCII + | BIG5 + | BINARY + | CP1250 + | CP1251 + | CP1256 + | CP1257 + | CP850 + | CP852 + | CP866 + | CP932 + | DEC8 + | EUCJPMS + | EUCKR + | GB18030 + | GB2312 + | GBK + | GEOSTD8 + | GREEK + | HEBREW + | HP8 + | KEYBCS2 + | KOI8R + | KOI8U + | LATIN1 + | LATIN2 + | LATIN5 + | LATIN7 + | MACCE + | MACROMAN + | SJIS + | SWE7 + | TIS620 + | UCS2 + | UJIS + | UTF16 + | UTF16LE + | UTF32 + | UTF8 + | UTF8MB3 + | UTF8MB4 + ; + +transactionLevelBase + : REPEATABLE + | COMMITTED + | UNCOMMITTED + | SERIALIZABLE + ; + +privilegesBase + : TABLES + | ROUTINE + | EXECUTE + | FILE + | PROCESS + | RELOAD + | SHUTDOWN + | SUPER + | PRIVILEGES + ; + +intervalTypeBase + : QUARTER + | MONTH + | DAY + | HOUR + | MINUTE + | WEEK + | SECOND + | MICROSECOND + ; + +dataTypeBase + : DATE + | TIME + | TIMESTAMP + | DATETIME + | YEAR + | ENUM + | TEXT + ; + +keywordsCanBeId + : ACCOUNT + | ACTION + | ADMIN + | AFTER + | AGGREGATE + | ALGORITHM + | ANY + | ARRAY + | AT + | AUDIT_ADMIN + | AUDIT_ABORT_EXEMPT + | AUTHORS + | AUTOCOMMIT + | AUTOEXTEND_SIZE + | AUTO_INCREMENT + | AUTHENTICATION_POLICY_ADMIN + | AVG + | AVG_ROW_LENGTH + | ATTRIBUTE + | BACKUP_ADMIN + | BEGIN + | BINLOG + | BINLOG_ADMIN + | BINLOG_ENCRYPTION_ADMIN + | BIT + | BIT_AND + | BIT_OR + | BIT_XOR + | BLOCK + | BOOL + | BOOLEAN + | BTREE + | BUCKETS + | CACHE + | CASCADED + | CHAIN + | CHANGED + | CHANNEL + | CHECKSUM + | PAGE_CHECKSUM + | CATALOG_NAME + | CIPHER + | CLASS_ORIGIN + | CLIENT + | CLONE_ADMIN + | CLOSE + | CLUSTERING + | COALESCE + | CODE + | COLUMNS + | COLUMN_FORMAT + | COLUMN_NAME + | COMMENT + | COMMIT + | COMPACT + | COMPLETION + | COMPRESSED + | COMPRESSION + | CONCURRENT + | CONDITION + | CONNECT + | CONNECTION + | CONNECTION_ADMIN + | CONSISTENT + | CONSTRAINT_CATALOG + | CONSTRAINT_NAME + | CONSTRAINT_SCHEMA + | CONTAINS + | CONTEXT + | CONTRIBUTORS + | COPY + | COUNT + | CPU + | CURRENT + | CURRENT_USER + | CURSOR_NAME + | DATA + | DATAFILE + | DEALLOCATE + | DEFAULT + | DEFAULT_AUTH + | DEFINER + | DELAY_KEY_WRITE + | DES_KEY_FILE + | DIAGNOSTICS + | DIRECTORY + | DISABLE + | DISCARD + | DISK + | DO + | DUMPFILE + | DUPLICATE + | DYNAMIC + | EMPTY + | ENABLE + | ENCRYPTION + | ENCRYPTION_KEY_ADMIN + | END + | ENDS + | ENGINE + | ENGINE_ATTRIBUTE + | ENGINES + | ENFORCED + | ERROR + | ERRORS + | ESCAPE + | EUR + | EVEN + | EVENT + | EVENTS + | EVERY + | EXCEPT + | EXCHANGE + | EXCLUSIVE + | EXPIRE + | EXPORT + | EXTENDED + | EXTENT_SIZE + | FAILED_LOGIN_ATTEMPTS + | FAST + | FAULTS + | FIELDS + | FILE_BLOCK_SIZE + | FILTER + | FIREWALL_ADMIN + | FIREWALL_EXEMPT + | FIREWALL_USER + | FIRST + | FIXED + | FLUSH + | FOLLOWS + | FOUND + | FULL + | FUNCTION + | GENERAL + | GLOBAL + | GRANTS + | GROUP + | GROUP_CONCAT + | GROUP_REPLICATION + | GROUP_REPLICATION_ADMIN + | HANDLER + | HASH + | HELP + | HISTORY + | HOST + | HOSTS + | IDENTIFIED + | IGNORED + | IGNORE_SERVER_IDS + | IMPORT + | INDEXES + | INITIAL_SIZE + | INNODB_REDO_LOG_ARCHIVE + | INPLACE + | INSERT_METHOD + | INSTALL + | INSTANCE + | INSTANT + | INTERNAL + | INVOKE + | INVOKER + | IO + | IO_THREAD + | IPC + | ISO + | ISOLATION + | ISSUER + | JIS + | JSON + | KEY_BLOCK_SIZE + | LAMBDA + | LANGUAGE + | LAST + | LATERAL + | LEAVES + | LESS + | LEVEL + | LIST + | LOCAL + | LOGFILE + | LOGS + | MASTER + | MASTER_AUTO_POSITION + | MASTER_CONNECT_RETRY + | MASTER_DELAY + | MASTER_HEARTBEAT_PERIOD + | MASTER_HOST + | MASTER_LOG_FILE + | MASTER_LOG_POS + | MASTER_PASSWORD + | MASTER_PORT + | MASTER_RETRY_COUNT + | MASTER_SSL + | MASTER_SSL_CA + | MASTER_SSL_CAPATH + | MASTER_SSL_CERT + | MASTER_SSL_CIPHER + | MASTER_SSL_CRL + | MASTER_SSL_CRLPATH + | MASTER_SSL_KEY + | MASTER_TLS_VERSION + | MASTER_USER + | MAX_CONNECTIONS_PER_HOUR + | MAX_QUERIES_PER_HOUR + | MAX + | MAX_ROWS + | MAX_SIZE + | MAX_UPDATES_PER_HOUR + | MAX_USER_CONNECTIONS + | MEDIUM + | MEMBER + | MEMORY + | MERGE + | MESSAGE_TEXT + | MID + | MIGRATE + | MIN + | MIN_ROWS + | MODE + | MODIFY + | MUTEX + | MYSQL + | MYSQL_ERRNO + | NAME + | NAMES + | NCHAR + | NDB_STORED_USER + | NESTED + | NEVER + | NEXT + | NO + | NOCOPY + | NODEGROUP + | NONE + | NOWAIT + | NUMBER + | ODBC + | OFFLINE + | OFFSET + | OF + | OJ + | OLD_PASSWORD + | ONE + | ONLINE + | ONLY + | OPEN + | OPTIMIZER_COSTS + | OPTIONAL + | OPTIONS + | ORDER + | ORDINALITY + | OWNER + | PACK_KEYS + | PAGE + | PARSER + | PARTIAL + | PARTITIONING + | PARTITIONS + | PASSWORD + | PASSWORDLESS_USER_ADMIN + | PASSWORD_LOCK_TIME + | PATH + | PERSIST_RO_VARIABLES_ADMIN + | PHASE + | PLUGINS + | PLUGIN_DIR + | PLUGIN + | PORT + | PRECEDES + | PREPARE + | PRESERVE + | PREV + | PRIMARY + | PROCESSLIST + | PROFILE + | PROFILES + | PROXY + | QUERY + | QUICK + | REBUILD + | RECOVER + | RECURSIVE + | REDO_BUFFER_SIZE + | REDUNDANT + | RELAY + | RELAYLOG + | RELAY_LOG_FILE + | RELAY_LOG_POS + | REMOVE + | REORGANIZE + | REPAIR + | REPLICATE_DO_DB + | REPLICATE_DO_TABLE + | REPLICATE_IGNORE_DB + | REPLICATE_IGNORE_TABLE + | REPLICATE_REWRITE_DB + | REPLICATE_WILD_DO_TABLE + | REPLICATE_WILD_IGNORE_TABLE + | REPLICATION + | REPLICATION_APPLIER + | REPLICATION_SLAVE_ADMIN + | RESET + | RESOURCE_GROUP_ADMIN + | RESOURCE_GROUP_USER + | RESUME + | RETURNED_SQLSTATE + | RETURNING + | RETURNS + | REUSE + | ROLE + | ROLE_ADMIN + | ROLLBACK + | ROLLUP + | ROTATE + | ROW + | ROWS + | ROW_FORMAT + | RTREE + | S3 + | SAVEPOINT + | SCHEDULE + | SCHEMA_NAME + | SECURITY + | SECONDARY_ENGINE_ATTRIBUTE + | SERIAL + | SERVER + | SESSION + | SESSION_VARIABLES_ADMIN + | SET_USER_ID + | SHARE + | SHARED + | SHOW_ROUTINE + | SIGNED + | SIMPLE + | SLAVE + | SLOW + | SKIP_QUERY_REWRITE + | SNAPSHOT + | SOCKET + | SOME + | SONAME + | SOUNDS + | SOURCE + | SQL_AFTER_GTIDS + | SQL_AFTER_MTS_GAPS + | SQL_BEFORE_GTIDS + | SQL_BUFFER_RESULT + | SQL_CACHE + | SQL_NO_CACHE + | SQL_THREAD + | STACKED + | START + | STARTS + | STATS_AUTO_RECALC + | STATS_PERSISTENT + | STATS_SAMPLE_PAGES + | STATUS + | STD + | STDDEV + | STDDEV_POP + | STDDEV_SAMP + | STOP + | STORAGE + | STRING + | SUBCLASS_ORIGIN + | SUBJECT + | SUBPARTITION + | SUBPARTITIONS + | SUM + | SUSPEND + | SWAPS + | SWITCHES + | SYSTEM_VARIABLES_ADMIN + | TABLE_NAME + | TABLESPACE + | TABLE_ENCRYPTION_ADMIN + | TABLE_TYPE + | TEMPORARY + | TEMPTABLE + | THAN + | TP_CONNECTION_ADMIN + | TRADITIONAL + | TRANSACTION + | TRANSACTIONAL + | TRIGGERS + | TRUNCATE + | UNBOUNDED + | UNDEFINED + | UNDOFILE + | UNDO_BUFFER_SIZE + | UNINSTALL + | UNKNOWN + | UNTIL + | UPGRADE + | USA + | USER + | USE_FRM + | USER_RESOURCES + | VALIDATION + | VALUE + | VAR_POP + | VAR_SAMP + | VARIABLES + | VARIANCE + | VERSION_TOKEN_ADMIN + | VIEW + | VIRTUAL + | WAIT + | WARNINGS + | WITHOUT + | WORK + | WRAPPER + | X509 + | XA + | XA_RECOVER_ADMIN + | XML + ; + +functionNameBase + : ABS + | ACOS + | ADDDATE + | ADDTIME + | AES_DECRYPT + | AES_ENCRYPT + | AREA + | ASBINARY + | ASIN + | ASTEXT + | ASWKB + | ASWKT + | ASYMMETRIC_DECRYPT + | ASYMMETRIC_DERIVE + | ASYMMETRIC_ENCRYPT + | ASYMMETRIC_SIGN + | ASYMMETRIC_VERIFY + | ATAN + | ATAN2 + | BENCHMARK + | BIN + | BIT_COUNT + | BIT_LENGTH + | BUFFER + | CEIL + | CEILING + | CENTROID + | CHARACTER_LENGTH + | CHARSET + | CHAR_LENGTH + | COERCIBILITY + | COLLATION + | COMPRESS + | CONCAT + | CONCAT_WS + | CONNECTION_ID + | CONV + | CONVERT_TZ + | COS + | COT + | COUNT + | CRC32 + | CREATE_ASYMMETRIC_PRIV_KEY + | CREATE_ASYMMETRIC_PUB_KEY + | CREATE_DH_PARAMETERS + | CREATE_DIGEST + | CROSSES + | CUME_DIST + | DATABASE + | DATE + | DATEDIFF + | DATE_FORMAT + | DAY + | DAYNAME + | DAYOFMONTH + | DAYOFWEEK + | DAYOFYEAR + | DECODE + | DEGREES + | DENSE_RANK + | DES_DECRYPT + | DES_ENCRYPT + | DIMENSION + | DISJOINT + | ELT + | ENCODE + | ENCRYPT + | ENDPOINT + | ENVELOPE + | EQUALS + | EXP + | EXPORT_SET + | EXTERIORRING + | EXTRACTVALUE + | FIELD + | FIND_IN_SET + | FIRST_VALUE + | FLOOR + | FORMAT + | FOUND_ROWS + | FROM_BASE64 + | FROM_DAYS + | FROM_UNIXTIME + | GEOMCOLLFROMTEXT + | GEOMCOLLFROMWKB + | GEOMETRYCOLLECTION + | GEOMETRYCOLLECTIONFROMTEXT + | GEOMETRYCOLLECTIONFROMWKB + | GEOMETRYFROMTEXT + | GEOMETRYFROMWKB + | GEOMETRYN + | GEOMETRYTYPE + | GEOMFROMTEXT + | GEOMFROMWKB + | GET_FORMAT + | GET_LOCK + | GLENGTH + | GREATEST + | GTID_SUBSET + | GTID_SUBTRACT + | HEX + | HOUR + | IFNULL + | INET6_ATON + | INET6_NTOA + | INET_ATON + | INET_NTOA + | INSTR + | INTERIORRINGN + | INTERSECTS + | INVISIBLE + | ISCLOSED + | ISEMPTY + | ISNULL + | ISSIMPLE + | IS_FREE_LOCK + | IS_IPV4 + | IS_IPV4_COMPAT + | IS_IPV4_MAPPED + | IS_IPV6 + | IS_USED_LOCK + | LAG + | LAST_INSERT_ID + | LAST_VALUE + | LCASE + | LEAD + | LEAST + | LEFT + | LENGTH + | LINEFROMTEXT + | LINEFROMWKB + | LINESTRING + | LINESTRINGFROMTEXT + | LINESTRINGFROMWKB + | LN + | LOAD_FILE + | LOCATE + | LOG + | LOG10 + | LOG2 + | LOWER + | LPAD + | LTRIM + | MAKEDATE + | MAKETIME + | MAKE_SET + | MASTER_POS_WAIT + | MBRCONTAINS + | MBRDISJOINT + | MBREQUAL + | MBRINTERSECTS + | MBROVERLAPS + | MBRTOUCHES + | MBRWITHIN + | MD5 + | MICROSECOND + | MINUTE + | MLINEFROMTEXT + | MLINEFROMWKB + | MOD + | MONTH + | MONTHNAME + | MPOINTFROMTEXT + | MPOINTFROMWKB + | MPOLYFROMTEXT + | MPOLYFROMWKB + | MULTILINESTRING + | MULTILINESTRINGFROMTEXT + | MULTILINESTRINGFROMWKB + | MULTIPOINT + | MULTIPOINTFROMTEXT + | MULTIPOINTFROMWKB + | MULTIPOLYGON + | MULTIPOLYGONFROMTEXT + | MULTIPOLYGONFROMWKB + | NAME_CONST + | NTH_VALUE + | NTILE + | NULLIF + | NUMGEOMETRIES + | NUMINTERIORRINGS + | NUMPOINTS + | OCT + | OCTET_LENGTH + | ORD + | OVERLAPS + | PERCENT_RANK + | PERIOD_ADD + | PERIOD_DIFF + | PI + | POINT + | POINTFROMTEXT + | POINTFROMWKB + | POINTN + | POLYFROMTEXT + | POLYFROMWKB + | POLYGON + | POLYGONFROMTEXT + | POLYGONFROMWKB + | POSITION + | POW + | POWER + | QUARTER + | QUOTE + | RADIANS + | RAND + | RANDOM + | RANK + | RANDOM_BYTES + | RELEASE_LOCK + | REVERSE + | RIGHT + | ROUND + | ROW_COUNT + | ROW_NUMBER + | RPAD + | RTRIM + | SCHEMA + | SECOND + | SEC_TO_TIME + | SESSION_USER + | SESSION_VARIABLES_ADMIN + | SHA + | SHA1 + | SHA2 + | SIGN + | SIN + | SLEEP + | SOUNDEX + | SQL_THREAD_WAIT_AFTER_GTIDS + | SQRT + | SRID + | STARTPOINT + | STRCMP + | STR_TO_DATE + | ST_AREA + | ST_ASBINARY + | ST_ASTEXT + | ST_ASWKB + | ST_ASWKT + | ST_BUFFER + | ST_CENTROID + | ST_CONTAINS + | ST_CROSSES + | ST_DIFFERENCE + | ST_DIMENSION + | ST_DISJOINT + | ST_DISTANCE + | ST_ENDPOINT + | ST_ENVELOPE + | ST_EQUALS + | ST_EXTERIORRING + | ST_GEOMCOLLFROMTEXT + | ST_GEOMCOLLFROMTXT + | ST_GEOMCOLLFROMWKB + | ST_GEOMETRYCOLLECTIONFROMTEXT + | ST_GEOMETRYCOLLECTIONFROMWKB + | ST_GEOMETRYFROMTEXT + | ST_GEOMETRYFROMWKB + | ST_GEOMETRYN + | ST_GEOMETRYTYPE + | ST_GEOMFROMTEXT + | ST_GEOMFROMWKB + | ST_INTERIORRINGN + | ST_INTERSECTION + | ST_INTERSECTS + | ST_ISCLOSED + | ST_ISEMPTY + | ST_ISSIMPLE + | ST_LINEFROMTEXT + | ST_LINEFROMWKB + | ST_LINESTRINGFROMTEXT + | ST_LINESTRINGFROMWKB + | ST_NUMGEOMETRIES + | ST_NUMINTERIORRING + | ST_NUMINTERIORRINGS + | ST_NUMPOINTS + | ST_OVERLAPS + | ST_POINTFROMTEXT + | ST_POINTFROMWKB + | ST_POINTN + | ST_POLYFROMTEXT + | ST_POLYFROMWKB + | ST_POLYGONFROMTEXT + | ST_POLYGONFROMWKB + | ST_SRID + | ST_STARTPOINT + | ST_SYMDIFFERENCE + | ST_TOUCHES + | ST_UNION + | ST_WITHIN + | ST_X + | ST_Y + | SUBDATE + | SUBSTRING_INDEX + | SUBTIME + | SYSTEM_USER + | TAN + | TIME + | TIMEDIFF + | TIMESTAMP + | TIMESTAMPADD + | TIMESTAMPDIFF + | TIME_FORMAT + | TIME_TO_SEC + | TOUCHES + | TO_BASE64 + | TO_DAYS + | TO_SECONDS + | UCASE + | UNCOMPRESS + | UNCOMPRESSED_LENGTH + | UNHEX + | UNIX_TIMESTAMP + | UPDATEXML + | UPPER + | UUID + | UUID_SHORT + | VALIDATE_PASSWORD_STRENGTH + | VERSION + | VISIBLE + | WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS + | WEEK + | WEEKDAY + | WEEKOFYEAR + | WEIGHT_STRING + | WITHIN + | YEAR + | YEARWEEK + | Y_FUNCTION + | X_FUNCTION + | JSON_ARRAY + | JSON_OBJECT + | JSON_QUOTE + | JSON_CONTAINS + | JSON_CONTAINS_PATH + | JSON_EXTRACT + | JSON_KEYS + | JSON_OVERLAPS + | JSON_SEARCH + | JSON_VALUE + | JSON_ARRAY_APPEND + | JSON_ARRAY_INSERT + | JSON_INSERT + | JSON_MERGE + | JSON_MERGE_PATCH + | JSON_MERGE_PRESERVE + | JSON_REMOVE + | JSON_REPLACE + | JSON_SET + | JSON_UNQUOTE + | JSON_DEPTH + | JSON_LENGTH + | JSON_TYPE + | JSON_VALID + | JSON_TABLE + | JSON_SCHEMA_VALID + | JSON_SCHEMA_VALIDATION_REPORT + | JSON_PRETTY + | JSON_STORAGE_FREE + | JSON_STORAGE_SIZE + | JSON_ARRAYAGG + | JSON_OBJECTAGG + ; \ No newline at end of file diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlLexer.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlLexer.java new file mode 100644 index 000000000..dc0f1190c --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlLexer.java @@ -0,0 +1,10118 @@ +// Generated from MySqlLexer.g4 by ANTLR 4.13.1 +package org.springframework.ide.vscode.parser.sql; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class MySqlLexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + SPEL=1, SPACE=2, SPEC_MYSQL_COMMENT=3, COMMENT_INPUT=4, LINE_COMMENT=5, + ADD=6, ALL=7, ALTER=8, ALWAYS=9, ANALYZE=10, AND=11, ARRAY=12, AS=13, + ASC=14, ATTRIBUTE=15, BEFORE=16, BETWEEN=17, BOTH=18, BUCKETS=19, BY=20, + CALL=21, CASCADE=22, CASE=23, CAST=24, CHANGE=25, CHARACTER=26, CHECK=27, + COLLATE=28, COLUMN=29, CONDITION=30, CONSTRAINT=31, CONTINUE=32, CONVERT=33, + CREATE=34, CROSS=35, CURRENT=36, CURRENT_ROLE=37, CURRENT_USER=38, CURSOR=39, + DATABASE=40, DATABASES=41, DECLARE=42, DEFAULT=43, DELAYED=44, DELETE=45, + DESC=46, DESCRIBE=47, DETERMINISTIC=48, DIAGNOSTICS=49, DISTINCT=50, DISTINCTROW=51, + DROP=52, EACH=53, ELSE=54, ELSEIF=55, EMPTY=56, ENCLOSED=57, ENFORCED=58, + ESCAPED=59, EXCEPT=60, EXISTS=61, EXIT=62, EXPLAIN=63, FALSE=64, FETCH=65, + FOR=66, FORCE=67, FOREIGN=68, FROM=69, FULLTEXT=70, GENERATED=71, GET=72, + GRANT=73, GROUP=74, HAVING=75, HIGH_PRIORITY=76, HISTOGRAM=77, IF=78, + IGNORE=79, IGNORED=80, IN=81, INDEX=82, INFILE=83, INNER=84, INOUT=85, + INSERT=86, INTERVAL=87, INTO=88, IS=89, ITERATE=90, JOIN=91, KEY=92, KEYS=93, + KILL=94, LATERAL=95, LEADING=96, LEAVE=97, LEFT=98, LIKE=99, LIMIT=100, + LINEAR=101, LINES=102, LOAD=103, LOCK=104, LOCKED=105, LOOP=106, LOW_PRIORITY=107, + MASTER_BIND=108, MASTER_SSL_VERIFY_SERVER_CERT=109, MATCH=110, MAXVALUE=111, + MINVALUE=112, MODIFIES=113, NATURAL=114, NOT=115, NO_WRITE_TO_BINLOG=116, + NULL_LITERAL=117, NUMBER=118, ON=119, OPTIMIZE=120, OPTION=121, OPTIONAL=122, + OPTIONALLY=123, OR=124, ORDER=125, OUT=126, OUTER=127, OUTFILE=128, OVER=129, + PARTITION=130, PRIMARY=131, PROCEDURE=132, PURGE=133, RANGE=134, READ=135, + READS=136, REFERENCES=137, REGEXP=138, RELEASE=139, RENAME=140, REPEAT=141, + REPLACE=142, REQUIRE=143, RESIGNAL=144, RESTRICT=145, RETAIN=146, RETURN=147, + REVOKE=148, RIGHT=149, RLIKE=150, SCHEMA=151, SCHEMAS=152, SELECT=153, + SET=154, SEPARATOR=155, SHOW=156, SIGNAL=157, SKIP_=158, SKIP_QUERY_REWRITE=159, + SPATIAL=160, SQL=161, SQLEXCEPTION=162, SQLSTATE=163, SQLWARNING=164, + SQL_BIG_RESULT=165, SQL_CALC_FOUND_ROWS=166, SQL_SMALL_RESULT=167, SSL=168, + STACKED=169, STARTING=170, STATEMENT=171, STRAIGHT_JOIN=172, TABLE=173, + TERMINATED=174, THEN=175, TO=176, TRAILING=177, TRIGGER=178, TRUE=179, + UNDO=180, UNION=181, UNIQUE=182, UNLOCK=183, UNSIGNED=184, UPDATE=185, + USAGE=186, USE=187, USING=188, VALUES=189, WHEN=190, WHERE=191, WHILE=192, + WITH=193, WRITE=194, XOR=195, ZEROFILL=196, TINYINT=197, SMALLINT=198, + MEDIUMINT=199, MIDDLEINT=200, INT=201, INT1=202, INT2=203, INT3=204, INT4=205, + INT8=206, INTEGER=207, BIGINT=208, REAL=209, DOUBLE=210, PRECISION=211, + FLOAT=212, FLOAT4=213, FLOAT8=214, DECIMAL=215, DEC=216, NUMERIC=217, + DATE=218, TIME=219, TIMESTAMP=220, DATETIME=221, YEAR=222, CHAR=223, VARCHAR=224, + NVARCHAR=225, NATIONAL=226, BINARY=227, VARBINARY=228, TINYBLOB=229, BLOB=230, + MEDIUMBLOB=231, LONG=232, LONGBLOB=233, TINYTEXT=234, TEXT=235, MEDIUMTEXT=236, + LONGTEXT=237, ENUM=238, VARYING=239, SERIAL=240, YEAR_MONTH=241, DAY_HOUR=242, + DAY_MINUTE=243, DAY_SECOND=244, HOUR_MINUTE=245, HOUR_SECOND=246, MINUTE_SECOND=247, + SECOND_MICROSECOND=248, MINUTE_MICROSECOND=249, HOUR_MICROSECOND=250, + DAY_MICROSECOND=251, JSON_ARRAY=252, JSON_ARRAYAGG=253, JSON_ARRAY_APPEND=254, + JSON_ARRAY_INSERT=255, JSON_CONTAINS=256, JSON_CONTAINS_PATH=257, JSON_DEPTH=258, + JSON_EXTRACT=259, JSON_INSERT=260, JSON_KEYS=261, JSON_LENGTH=262, JSON_MERGE=263, + JSON_MERGE_PATCH=264, JSON_MERGE_PRESERVE=265, JSON_OBJECT=266, JSON_OBJECTAGG=267, + JSON_OVERLAPS=268, JSON_PRETTY=269, JSON_QUOTE=270, JSON_REMOVE=271, JSON_REPLACE=272, + JSON_SCHEMA_VALID=273, JSON_SCHEMA_VALIDATION_REPORT=274, JSON_SEARCH=275, + JSON_SET=276, JSON_STORAGE_FREE=277, JSON_STORAGE_SIZE=278, JSON_TABLE=279, + JSON_TYPE=280, JSON_UNQUOTE=281, JSON_VALID=282, JSON_VALUE=283, NESTED=284, + ORDINALITY=285, PATH=286, AVG=287, BIT_AND=288, BIT_OR=289, BIT_XOR=290, + COUNT=291, CUME_DIST=292, DENSE_RANK=293, FIRST_VALUE=294, GROUP_CONCAT=295, + LAG=296, LAST_VALUE=297, LEAD=298, MAX=299, MIN=300, NTILE=301, NTH_VALUE=302, + PERCENT_RANK=303, RANK=304, ROW_NUMBER=305, STD=306, STDDEV=307, STDDEV_POP=308, + STDDEV_SAMP=309, SUM=310, VAR_POP=311, VAR_SAMP=312, VARIANCE=313, CURRENT_DATE=314, + CURRENT_TIME=315, CURRENT_TIMESTAMP=316, LOCALTIME=317, CURDATE=318, CURTIME=319, + DATE_ADD=320, DATE_SUB=321, EXTRACT=322, LOCALTIMESTAMP=323, NOW=324, + POSITION=325, SUBSTR=326, SUBSTRING=327, SYSDATE=328, TRIM=329, UTC_DATE=330, + UTC_TIME=331, UTC_TIMESTAMP=332, ACCOUNT=333, ACTION=334, AFTER=335, AGGREGATE=336, + ALGORITHM=337, ANY=338, AT=339, AUTHORS=340, AUTOCOMMIT=341, AUTOEXTEND_SIZE=342, + AUTO_INCREMENT=343, AVG_ROW_LENGTH=344, BEGIN=345, BINLOG=346, BIT=347, + BLOCK=348, BOOL=349, BOOLEAN=350, BTREE=351, CACHE=352, CASCADED=353, + CHAIN=354, CHANGED=355, CHANNEL=356, CHECKSUM=357, PAGE_CHECKSUM=358, + CIPHER=359, CLASS_ORIGIN=360, CLIENT=361, CLOSE=362, CLUSTERING=363, COALESCE=364, + CODE=365, COLUMNS=366, COLUMN_FORMAT=367, COLUMN_NAME=368, COMMENT=369, + COMMIT=370, COMPACT=371, COMPLETION=372, COMPRESSED=373, COMPRESSION=374, + CONCURRENT=375, CONNECT=376, CONNECTION=377, CONSISTENT=378, CONSTRAINT_CATALOG=379, + CONSTRAINT_SCHEMA=380, CONSTRAINT_NAME=381, CONTAINS=382, CONTEXT=383, + CONTRIBUTORS=384, COPY=385, CPU=386, CYCLE=387, CURSOR_NAME=388, DATA=389, + DATAFILE=390, DEALLOCATE=391, DEFAULT_AUTH=392, DEFINER=393, DELAY_KEY_WRITE=394, + DES_KEY_FILE=395, DIRECTORY=396, DISABLE=397, DISCARD=398, DISK=399, DO=400, + DUMPFILE=401, DUPLICATE=402, DYNAMIC=403, ENABLE=404, ENCRYPTED=405, ENCRYPTION=406, + ENCRYPTION_KEY_ID=407, END=408, ENDS=409, ENGINE=410, ENGINES=411, ERROR=412, + ERRORS=413, ESCAPE=414, EVEN=415, EVENT=416, EVENTS=417, EVERY=418, EXCHANGE=419, + EXCLUSIVE=420, EXPIRE=421, EXPORT=422, EXTENDED=423, EXTENT_SIZE=424, + FAILED_LOGIN_ATTEMPTS=425, FAST=426, FAULTS=427, FIELDS=428, FILE_BLOCK_SIZE=429, + FILTER=430, FIRST=431, FIXED=432, FLUSH=433, FOLLOWING=434, FOLLOWS=435, + FOUND=436, FULL=437, FUNCTION=438, GENERAL=439, GLOBAL=440, GRANTS=441, + GROUP_REPLICATION=442, HANDLER=443, HASH=444, HELP=445, HISTORY=446, HOST=447, + HOSTS=448, IDENTIFIED=449, IGNORE_SERVER_IDS=450, IMPORT=451, INCREMENT=452, + INDEXES=453, INITIAL_SIZE=454, INPLACE=455, INSERT_METHOD=456, INSTALL=457, + INSTANCE=458, INSTANT=459, INVISIBLE=460, INVOKER=461, IO=462, IO_THREAD=463, + IPC=464, ISOLATION=465, ISSUER=466, JSON=467, KEY_BLOCK_SIZE=468, LANGUAGE=469, + LAST=470, LEAVES=471, LESS=472, LEVEL=473, LIST=474, LOCAL=475, LOGFILE=476, + LOGS=477, MASTER=478, MASTER_AUTO_POSITION=479, MASTER_CONNECT_RETRY=480, + MASTER_DELAY=481, MASTER_HEARTBEAT_PERIOD=482, MASTER_HOST=483, MASTER_LOG_FILE=484, + MASTER_LOG_POS=485, MASTER_PASSWORD=486, MASTER_PORT=487, MASTER_RETRY_COUNT=488, + MASTER_SSL=489, MASTER_SSL_CA=490, MASTER_SSL_CAPATH=491, MASTER_SSL_CERT=492, + MASTER_SSL_CIPHER=493, MASTER_SSL_CRL=494, MASTER_SSL_CRLPATH=495, MASTER_SSL_KEY=496, + MASTER_TLS_VERSION=497, MASTER_USER=498, MAX_CONNECTIONS_PER_HOUR=499, + MAX_QUERIES_PER_HOUR=500, MAX_ROWS=501, MAX_SIZE=502, MAX_UPDATES_PER_HOUR=503, + MAX_USER_CONNECTIONS=504, MEDIUM=505, MEMBER=506, MERGE=507, MESSAGE_TEXT=508, + MID=509, MIGRATE=510, MIN_ROWS=511, MODE=512, MODIFY=513, MUTEX=514, MYSQL=515, + MYSQL_ERRNO=516, NAME=517, NAMES=518, NCHAR=519, NEVER=520, NEXT=521, + NO=522, NOCACHE=523, NOCOPY=524, NOCYCLE=525, NOMAXVALUE=526, NOMINVALUE=527, + NOWAIT=528, NODEGROUP=529, NONE=530, ODBC=531, OFFLINE=532, OFFSET=533, + OF=534, OJ=535, OLD_PASSWORD=536, ONE=537, ONLINE=538, ONLY=539, OPEN=540, + OPTIMIZER_COSTS=541, OPTIONS=542, OWNER=543, PACK_KEYS=544, PAGE=545, + PAGE_COMPRESSED=546, PAGE_COMPRESSION_LEVEL=547, PARSER=548, PARTIAL=549, + PARTITIONING=550, PARTITIONS=551, PASSWORD=552, PASSWORD_LOCK_TIME=553, + PHASE=554, PLUGIN=555, PLUGIN_DIR=556, PLUGINS=557, PORT=558, PRECEDES=559, + PRECEDING=560, PREPARE=561, PRESERVE=562, PREV=563, PROCESSLIST=564, PROFILE=565, + PROFILES=566, PROXY=567, QUERY=568, QUICK=569, REBUILD=570, RECOVER=571, + RECURSIVE=572, REDO_BUFFER_SIZE=573, REDUNDANT=574, RELAY=575, RELAY_LOG_FILE=576, + RELAY_LOG_POS=577, RELAYLOG=578, REMOVE=579, REORGANIZE=580, REPAIR=581, + REPLICATE_DO_DB=582, REPLICATE_DO_TABLE=583, REPLICATE_IGNORE_DB=584, + REPLICATE_IGNORE_TABLE=585, REPLICATE_REWRITE_DB=586, REPLICATE_WILD_DO_TABLE=587, + REPLICATE_WILD_IGNORE_TABLE=588, REPLICATION=589, RESET=590, RESTART=591, + RESUME=592, RETURNED_SQLSTATE=593, RETURNING=594, RETURNS=595, REUSE=596, + ROLE=597, ROLLBACK=598, ROLLUP=599, ROTATE=600, ROW=601, ROWS=602, ROW_FORMAT=603, + RTREE=604, SAVEPOINT=605, SCHEDULE=606, SECURITY=607, SEQUENCE=608, SERVER=609, + SESSION=610, SHARE=611, SHARED=612, SIGNED=613, SIMPLE=614, SLAVE=615, + SLOW=616, SNAPSHOT=617, SOCKET=618, SOME=619, SONAME=620, SOUNDS=621, + SOURCE=622, SQL_AFTER_GTIDS=623, SQL_AFTER_MTS_GAPS=624, SQL_BEFORE_GTIDS=625, + SQL_BUFFER_RESULT=626, SQL_CACHE=627, SQL_NO_CACHE=628, SQL_THREAD=629, + START=630, STARTS=631, STATS_AUTO_RECALC=632, STATS_PERSISTENT=633, STATS_SAMPLE_PAGES=634, + STATUS=635, STOP=636, STORAGE=637, STORED=638, STRING=639, SUBCLASS_ORIGIN=640, + SUBJECT=641, SUBPARTITION=642, SUBPARTITIONS=643, SUSPEND=644, SWAPS=645, + SWITCHES=646, TABLE_NAME=647, TABLESPACE=648, TABLE_TYPE=649, TEMPORARY=650, + TEMPTABLE=651, THAN=652, TRADITIONAL=653, TRANSACTION=654, TRANSACTIONAL=655, + TRIGGERS=656, TRUNCATE=657, UNBOUNDED=658, UNDEFINED=659, UNDOFILE=660, + UNDO_BUFFER_SIZE=661, UNINSTALL=662, UNKNOWN=663, UNTIL=664, UPGRADE=665, + USER=666, USE_FRM=667, USER_RESOURCES=668, VALIDATION=669, VALUE=670, + VARIABLES=671, VIEW=672, VIRTUAL=673, VISIBLE=674, WAIT=675, WARNINGS=676, + WINDOW=677, WITHOUT=678, WORK=679, WRAPPER=680, X509=681, XA=682, XML=683, + YES=684, EUR=685, USA=686, JIS=687, ISO=688, INTERNAL=689, QUARTER=690, + MONTH=691, DAY=692, HOUR=693, MINUTE=694, WEEK=695, SECOND=696, MICROSECOND=697, + ADMIN=698, APPLICATION_PASSWORD_ADMIN=699, AUDIT_ABORT_EXEMPT=700, AUDIT_ADMIN=701, + AUTHENTICATION_POLICY_ADMIN=702, BACKUP_ADMIN=703, BINLOG_ADMIN=704, BINLOG_ENCRYPTION_ADMIN=705, + CLONE_ADMIN=706, CONNECTION_ADMIN=707, ENCRYPTION_KEY_ADMIN=708, EXECUTE=709, + FILE=710, FIREWALL_ADMIN=711, FIREWALL_EXEMPT=712, FIREWALL_USER=713, + FLUSH_OPTIMIZER_COSTS=714, FLUSH_STATUS=715, FLUSH_TABLES=716, FLUSH_USER_RESOURCES=717, + GROUP_REPLICATION_ADMIN=718, INNODB_REDO_LOG_ARCHIVE=719, INNODB_REDO_LOG_ENABLE=720, + INVOKE=721, LAMBDA=722, NDB_STORED_USER=723, PASSWORDLESS_USER_ADMIN=724, + PERSIST_RO_VARIABLES_ADMIN=725, PRIVILEGES=726, PROCESS=727, RELOAD=728, + REPLICATION_APPLIER=729, REPLICATION_SLAVE_ADMIN=730, RESOURCE_GROUP_ADMIN=731, + RESOURCE_GROUP_USER=732, ROLE_ADMIN=733, ROUTINE=734, S3=735, SERVICE_CONNECTION_ADMIN=736, + SESSION_VARIABLES_ADMIN=737, SET_USER_ID=738, SHOW_ROUTINE=739, SHUTDOWN=740, + SUPER=741, SYSTEM_VARIABLES_ADMIN=742, TABLES=743, TABLE_ENCRYPTION_ADMIN=744, + VERSION_TOKEN_ADMIN=745, XA_RECOVER_ADMIN=746, ARMSCII8=747, ASCII=748, + BIG5=749, CP1250=750, CP1251=751, CP1256=752, CP1257=753, CP850=754, CP852=755, + CP866=756, CP932=757, DEC8=758, EUCJPMS=759, EUCKR=760, GB18030=761, GB2312=762, + GBK=763, GEOSTD8=764, GREEK=765, HEBREW=766, HP8=767, KEYBCS2=768, KOI8R=769, + KOI8U=770, LATIN1=771, LATIN2=772, LATIN5=773, LATIN7=774, MACCE=775, + MACROMAN=776, SJIS=777, SWE7=778, TIS620=779, UCS2=780, UJIS=781, UTF16=782, + UTF16LE=783, UTF32=784, UTF8=785, UTF8MB3=786, UTF8MB4=787, ARCHIVE=788, + BLACKHOLE=789, CSV=790, FEDERATED=791, INNODB=792, MEMORY=793, MRG_MYISAM=794, + MYISAM=795, NDB=796, NDBCLUSTER=797, PERFORMANCE_SCHEMA=798, TOKUDB=799, + REPEATABLE=800, COMMITTED=801, UNCOMMITTED=802, SERIALIZABLE=803, GEOMETRYCOLLECTION=804, + GEOMCOLLECTION=805, GEOMETRY=806, LINESTRING=807, MULTILINESTRING=808, + MULTIPOINT=809, MULTIPOLYGON=810, POINT=811, POLYGON=812, ABS=813, ACOS=814, + ADDDATE=815, ADDTIME=816, AES_DECRYPT=817, AES_ENCRYPT=818, AREA=819, + ASBINARY=820, ASIN=821, ASTEXT=822, ASWKB=823, ASWKT=824, ASYMMETRIC_DECRYPT=825, + ASYMMETRIC_DERIVE=826, ASYMMETRIC_ENCRYPT=827, ASYMMETRIC_SIGN=828, ASYMMETRIC_VERIFY=829, + ATAN=830, ATAN2=831, BENCHMARK=832, BIN=833, BIT_COUNT=834, BIT_LENGTH=835, + BUFFER=836, CATALOG_NAME=837, CEIL=838, CEILING=839, CENTROID=840, CHARACTER_LENGTH=841, + CHARSET=842, CHAR_LENGTH=843, COERCIBILITY=844, COLLATION=845, COMPRESS=846, + CONCAT=847, CONCAT_WS=848, CONNECTION_ID=849, CONV=850, CONVERT_TZ=851, + COS=852, COT=853, CRC32=854, CREATE_ASYMMETRIC_PRIV_KEY=855, CREATE_ASYMMETRIC_PUB_KEY=856, + CREATE_DH_PARAMETERS=857, CREATE_DIGEST=858, CROSSES=859, DATEDIFF=860, + DATE_FORMAT=861, DAYNAME=862, DAYOFMONTH=863, DAYOFWEEK=864, DAYOFYEAR=865, + DECODE=866, DEGREES=867, DES_DECRYPT=868, DES_ENCRYPT=869, DIMENSION=870, + DISJOINT=871, ELT=872, ENCODE=873, ENCRYPT=874, ENDPOINT=875, ENGINE_ATTRIBUTE=876, + ENVELOPE=877, EQUALS=878, EXP=879, EXPORT_SET=880, EXTERIORRING=881, EXTRACTVALUE=882, + FIELD=883, FIND_IN_SET=884, FLOOR=885, FORMAT=886, FOUND_ROWS=887, FROM_BASE64=888, + FROM_DAYS=889, FROM_UNIXTIME=890, GEOMCOLLFROMTEXT=891, GEOMCOLLFROMWKB=892, + GEOMETRYCOLLECTIONFROMTEXT=893, GEOMETRYCOLLECTIONFROMWKB=894, GEOMETRYFROMTEXT=895, + GEOMETRYFROMWKB=896, GEOMETRYN=897, GEOMETRYTYPE=898, GEOMFROMTEXT=899, + GEOMFROMWKB=900, GET_FORMAT=901, GET_LOCK=902, GLENGTH=903, GREATEST=904, + GTID_SUBSET=905, GTID_SUBTRACT=906, HEX=907, IFNULL=908, INET6_ATON=909, + INET6_NTOA=910, INET_ATON=911, INET_NTOA=912, INSTR=913, INTERIORRINGN=914, + INTERSECTS=915, ISCLOSED=916, ISEMPTY=917, ISNULL=918, ISSIMPLE=919, IS_FREE_LOCK=920, + IS_IPV4=921, IS_IPV4_COMPAT=922, IS_IPV4_MAPPED=923, IS_IPV6=924, IS_USED_LOCK=925, + LAST_INSERT_ID=926, LCASE=927, LEAST=928, LENGTH=929, LINEFROMTEXT=930, + LINEFROMWKB=931, LINESTRINGFROMTEXT=932, LINESTRINGFROMWKB=933, LN=934, + LOAD_FILE=935, LOCATE=936, LOG=937, LOG10=938, LOG2=939, LOWER=940, LPAD=941, + LTRIM=942, MAKEDATE=943, MAKETIME=944, MAKE_SET=945, MASTER_POS_WAIT=946, + MBRCONTAINS=947, MBRDISJOINT=948, MBREQUAL=949, MBRINTERSECTS=950, MBROVERLAPS=951, + MBRTOUCHES=952, MBRWITHIN=953, MD5=954, MLINEFROMTEXT=955, MLINEFROMWKB=956, + MONTHNAME=957, MPOINTFROMTEXT=958, MPOINTFROMWKB=959, MPOLYFROMTEXT=960, + MPOLYFROMWKB=961, MULTILINESTRINGFROMTEXT=962, MULTILINESTRINGFROMWKB=963, + MULTIPOINTFROMTEXT=964, MULTIPOINTFROMWKB=965, MULTIPOLYGONFROMTEXT=966, + MULTIPOLYGONFROMWKB=967, NAME_CONST=968, NULLIF=969, NUMGEOMETRIES=970, + NUMINTERIORRINGS=971, NUMPOINTS=972, OCT=973, OCTET_LENGTH=974, ORD=975, + OVERLAPS=976, PERIOD_ADD=977, PERIOD_DIFF=978, PI=979, POINTFROMTEXT=980, + POINTFROMWKB=981, POINTN=982, POLYFROMTEXT=983, POLYFROMWKB=984, POLYGONFROMTEXT=985, + POLYGONFROMWKB=986, POW=987, POWER=988, QUOTE=989, RADIANS=990, RAND=991, + RANDOM=992, RANDOM_BYTES=993, RELEASE_LOCK=994, REVERSE=995, ROUND=996, + ROW_COUNT=997, RPAD=998, RTRIM=999, SEC_TO_TIME=1000, SECONDARY_ENGINE_ATTRIBUTE=1001, + SESSION_USER=1002, SHA=1003, SHA1=1004, SHA2=1005, SCHEMA_NAME=1006, SIGN=1007, + SIN=1008, SLEEP=1009, SOUNDEX=1010, SQL_THREAD_WAIT_AFTER_GTIDS=1011, + SQRT=1012, SRID=1013, STARTPOINT=1014, STRCMP=1015, STR_TO_DATE=1016, + ST_AREA=1017, ST_ASBINARY=1018, ST_ASTEXT=1019, ST_ASWKB=1020, ST_ASWKT=1021, + ST_BUFFER=1022, ST_CENTROID=1023, ST_CONTAINS=1024, ST_CROSSES=1025, ST_DIFFERENCE=1026, + ST_DIMENSION=1027, ST_DISJOINT=1028, ST_DISTANCE=1029, ST_ENDPOINT=1030, + ST_ENVELOPE=1031, ST_EQUALS=1032, ST_EXTERIORRING=1033, ST_GEOMCOLLFROMTEXT=1034, + ST_GEOMCOLLFROMTXT=1035, ST_GEOMCOLLFROMWKB=1036, ST_GEOMETRYCOLLECTIONFROMTEXT=1037, + ST_GEOMETRYCOLLECTIONFROMWKB=1038, ST_GEOMETRYFROMTEXT=1039, ST_GEOMETRYFROMWKB=1040, + ST_GEOMETRYN=1041, ST_GEOMETRYTYPE=1042, ST_GEOMFROMTEXT=1043, ST_GEOMFROMWKB=1044, + ST_INTERIORRINGN=1045, ST_INTERSECTION=1046, ST_INTERSECTS=1047, ST_ISCLOSED=1048, + ST_ISEMPTY=1049, ST_ISSIMPLE=1050, ST_LINEFROMTEXT=1051, ST_LINEFROMWKB=1052, + ST_LINESTRINGFROMTEXT=1053, ST_LINESTRINGFROMWKB=1054, ST_NUMGEOMETRIES=1055, + ST_NUMINTERIORRING=1056, ST_NUMINTERIORRINGS=1057, ST_NUMPOINTS=1058, + ST_OVERLAPS=1059, ST_POINTFROMTEXT=1060, ST_POINTFROMWKB=1061, ST_POINTN=1062, + ST_POLYFROMTEXT=1063, ST_POLYFROMWKB=1064, ST_POLYGONFROMTEXT=1065, ST_POLYGONFROMWKB=1066, + ST_SRID=1067, ST_STARTPOINT=1068, ST_SYMDIFFERENCE=1069, ST_TOUCHES=1070, + ST_UNION=1071, ST_WITHIN=1072, ST_X=1073, ST_Y=1074, SUBDATE=1075, SUBSTRING_INDEX=1076, + SUBTIME=1077, SYSTEM_USER=1078, TAN=1079, TIMEDIFF=1080, TIMESTAMPADD=1081, + TIMESTAMPDIFF=1082, TIME_FORMAT=1083, TIME_TO_SEC=1084, TOUCHES=1085, + TO_BASE64=1086, TO_DAYS=1087, TO_SECONDS=1088, TP_CONNECTION_ADMIN=1089, + UCASE=1090, UNCOMPRESS=1091, UNCOMPRESSED_LENGTH=1092, UNHEX=1093, UNIX_TIMESTAMP=1094, + UPDATEXML=1095, UPPER=1096, UUID=1097, UUID_SHORT=1098, VALIDATE_PASSWORD_STRENGTH=1099, + VERSION=1100, WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS=1101, WEEKDAY=1102, WEEKOFYEAR=1103, + WEIGHT_STRING=1104, WITHIN=1105, YEARWEEK=1106, Y_FUNCTION=1107, X_FUNCTION=1108, + VAR_ASSIGN=1109, PLUS_ASSIGN=1110, MINUS_ASSIGN=1111, MULT_ASSIGN=1112, + DIV_ASSIGN=1113, MOD_ASSIGN=1114, AND_ASSIGN=1115, XOR_ASSIGN=1116, OR_ASSIGN=1117, + STAR=1118, DIVIDE=1119, MODULE=1120, PLUS=1121, MINUS=1122, DIV=1123, + MOD=1124, EQUAL_SYMBOL=1125, GREATER_SYMBOL=1126, LESS_SYMBOL=1127, EXCLAMATION_SYMBOL=1128, + BIT_NOT_OP=1129, BIT_OR_OP=1130, BIT_AND_OP=1131, BIT_XOR_OP=1132, DOT=1133, + LR_BRACKET=1134, RR_BRACKET=1135, COMMA=1136, SEMI=1137, AT_SIGN=1138, + ZERO_DECIMAL=1139, ONE_DECIMAL=1140, TWO_DECIMAL=1141, SINGLE_QUOTE_SYMB=1142, + DOUBLE_QUOTE_SYMB=1143, REVERSE_QUOTE_SYMB=1144, COLON_SYMB=1145, CHARSET_REVERSE_QOUTE_STRING=1146, + FILESIZE_LITERAL=1147, START_NATIONAL_STRING_LITERAL=1148, STRING_LITERAL=1149, + DECIMAL_LITERAL=1150, HEXADECIMAL_LITERAL=1151, REAL_LITERAL=1152, NULL_SPEC_LITERAL=1153, + BIT_STRING=1154, STRING_CHARSET_NAME=1155, DOT_ID=1156, ID=1157, REVERSE_QUOTE_ID=1158, + HOST_IP_ADDRESS=1159, LOCAL_ID=1160, GLOBAL_ID=1161, ERROR_RECONGNIGION=1162; + public static final int + MYSQLCOMMENT=2, ERRORCHANNEL=3; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "MYSQLCOMMENT", "ERRORCHANNEL" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "SPEL", "SPACE", "SPEC_MYSQL_COMMENT", "COMMENT_INPUT", "LINE_COMMENT", + "ADD", "ALL", "ALTER", "ALWAYS", "ANALYZE", "AND", "ARRAY", "AS", "ASC", + "ATTRIBUTE", "BEFORE", "BETWEEN", "BOTH", "BUCKETS", "BY", "CALL", "CASCADE", + "CASE", "CAST", "CHANGE", "CHARACTER", "CHECK", "COLLATE", "COLUMN", + "CONDITION", "CONSTRAINT", "CONTINUE", "CONVERT", "CREATE", "CROSS", + "CURRENT", "CURRENT_ROLE", "CURRENT_USER", "CURSOR", "DATABASE", "DATABASES", + "DECLARE", "DEFAULT", "DELAYED", "DELETE", "DESC", "DESCRIBE", "DETERMINISTIC", + "DIAGNOSTICS", "DISTINCT", "DISTINCTROW", "DROP", "EACH", "ELSE", "ELSEIF", + "EMPTY", "ENCLOSED", "ENFORCED", "ESCAPED", "EXCEPT", "EXISTS", "EXIT", + "EXPLAIN", "FALSE", "FETCH", "FOR", "FORCE", "FOREIGN", "FROM", "FULLTEXT", + "GENERATED", "GET", "GRANT", "GROUP", "HAVING", "HIGH_PRIORITY", "HISTOGRAM", + "IF", "IGNORE", "IGNORED", "IN", "INDEX", "INFILE", "INNER", "INOUT", + "INSERT", "INTERVAL", "INTO", "IS", "ITERATE", "JOIN", "KEY", "KEYS", + "KILL", "LATERAL", "LEADING", "LEAVE", "LEFT", "LIKE", "LIMIT", "LINEAR", + "LINES", "LOAD", "LOCK", "LOCKED", "LOOP", "LOW_PRIORITY", "MASTER_BIND", + "MASTER_SSL_VERIFY_SERVER_CERT", "MATCH", "MAXVALUE", "MINVALUE", "MODIFIES", + "NATURAL", "NOT", "NO_WRITE_TO_BINLOG", "NULL_LITERAL", "NUMBER", "ON", + "OPTIMIZE", "OPTION", "OPTIONAL", "OPTIONALLY", "OR", "ORDER", "OUT", + "OUTER", "OUTFILE", "OVER", "PARTITION", "PRIMARY", "PROCEDURE", "PURGE", + "RANGE", "READ", "READS", "REFERENCES", "REGEXP", "RELEASE", "RENAME", + "REPEAT", "REPLACE", "REQUIRE", "RESIGNAL", "RESTRICT", "RETAIN", "RETURN", + "REVOKE", "RIGHT", "RLIKE", "SCHEMA", "SCHEMAS", "SELECT", "SET", "SEPARATOR", + "SHOW", "SIGNAL", "SKIP_", "SKIP_QUERY_REWRITE", "SPATIAL", "SQL", "SQLEXCEPTION", + "SQLSTATE", "SQLWARNING", "SQL_BIG_RESULT", "SQL_CALC_FOUND_ROWS", "SQL_SMALL_RESULT", + "SSL", "STACKED", "STARTING", "STATEMENT", "STRAIGHT_JOIN", "TABLE", + "TERMINATED", "THEN", "TO", "TRAILING", "TRIGGER", "TRUE", "UNDO", "UNION", + "UNIQUE", "UNLOCK", "UNSIGNED", "UPDATE", "USAGE", "USE", "USING", "VALUES", + "WHEN", "WHERE", "WHILE", "WITH", "WRITE", "XOR", "ZEROFILL", "TINYINT", + "SMALLINT", "MEDIUMINT", "MIDDLEINT", "INT", "INT1", "INT2", "INT3", + "INT4", "INT8", "INTEGER", "BIGINT", "REAL", "DOUBLE", "PRECISION", "FLOAT", + "FLOAT4", "FLOAT8", "DECIMAL", "DEC", "NUMERIC", "DATE", "TIME", "TIMESTAMP", + "DATETIME", "YEAR", "CHAR", "VARCHAR", "NVARCHAR", "NATIONAL", "BINARY", + "VARBINARY", "TINYBLOB", "BLOB", "MEDIUMBLOB", "LONG", "LONGBLOB", "TINYTEXT", + "TEXT", "MEDIUMTEXT", "LONGTEXT", "ENUM", "VARYING", "SERIAL", "YEAR_MONTH", + "DAY_HOUR", "DAY_MINUTE", "DAY_SECOND", "HOUR_MINUTE", "HOUR_SECOND", + "MINUTE_SECOND", "SECOND_MICROSECOND", "MINUTE_MICROSECOND", "HOUR_MICROSECOND", + "DAY_MICROSECOND", "JSON_ARRAY", "JSON_ARRAYAGG", "JSON_ARRAY_APPEND", + "JSON_ARRAY_INSERT", "JSON_CONTAINS", "JSON_CONTAINS_PATH", "JSON_DEPTH", + "JSON_EXTRACT", "JSON_INSERT", "JSON_KEYS", "JSON_LENGTH", "JSON_MERGE", + "JSON_MERGE_PATCH", "JSON_MERGE_PRESERVE", "JSON_OBJECT", "JSON_OBJECTAGG", + "JSON_OVERLAPS", "JSON_PRETTY", "JSON_QUOTE", "JSON_REMOVE", "JSON_REPLACE", + "JSON_SCHEMA_VALID", "JSON_SCHEMA_VALIDATION_REPORT", "JSON_SEARCH", + "JSON_SET", "JSON_STORAGE_FREE", "JSON_STORAGE_SIZE", "JSON_TABLE", "JSON_TYPE", + "JSON_UNQUOTE", "JSON_VALID", "JSON_VALUE", "NESTED", "ORDINALITY", "PATH", + "AVG", "BIT_AND", "BIT_OR", "BIT_XOR", "COUNT", "CUME_DIST", "DENSE_RANK", + "FIRST_VALUE", "GROUP_CONCAT", "LAG", "LAST_VALUE", "LEAD", "MAX", "MIN", + "NTILE", "NTH_VALUE", "PERCENT_RANK", "RANK", "ROW_NUMBER", "STD", "STDDEV", + "STDDEV_POP", "STDDEV_SAMP", "SUM", "VAR_POP", "VAR_SAMP", "VARIANCE", + "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "LOCALTIME", "CURDATE", + "CURTIME", "DATE_ADD", "DATE_SUB", "EXTRACT", "LOCALTIMESTAMP", "NOW", + "POSITION", "SUBSTR", "SUBSTRING", "SYSDATE", "TRIM", "UTC_DATE", "UTC_TIME", + "UTC_TIMESTAMP", "ACCOUNT", "ACTION", "AFTER", "AGGREGATE", "ALGORITHM", + "ANY", "AT", "AUTHORS", "AUTOCOMMIT", "AUTOEXTEND_SIZE", "AUTO_INCREMENT", + "AVG_ROW_LENGTH", "BEGIN", "BINLOG", "BIT", "BLOCK", "BOOL", "BOOLEAN", + "BTREE", "CACHE", "CASCADED", "CHAIN", "CHANGED", "CHANNEL", "CHECKSUM", + "PAGE_CHECKSUM", "CIPHER", "CLASS_ORIGIN", "CLIENT", "CLOSE", "CLUSTERING", + "COALESCE", "CODE", "COLUMNS", "COLUMN_FORMAT", "COLUMN_NAME", "COMMENT", + "COMMIT", "COMPACT", "COMPLETION", "COMPRESSED", "COMPRESSION", "CONCURRENT", + "CONNECT", "CONNECTION", "CONSISTENT", "CONSTRAINT_CATALOG", "CONSTRAINT_SCHEMA", + "CONSTRAINT_NAME", "CONTAINS", "CONTEXT", "CONTRIBUTORS", "COPY", "CPU", + "CYCLE", "CURSOR_NAME", "DATA", "DATAFILE", "DEALLOCATE", "DEFAULT_AUTH", + "DEFINER", "DELAY_KEY_WRITE", "DES_KEY_FILE", "DIRECTORY", "DISABLE", + "DISCARD", "DISK", "DO", "DUMPFILE", "DUPLICATE", "DYNAMIC", "ENABLE", + "ENCRYPTED", "ENCRYPTION", "ENCRYPTION_KEY_ID", "END", "ENDS", "ENGINE", + "ENGINES", "ERROR", "ERRORS", "ESCAPE", "EVEN", "EVENT", "EVENTS", "EVERY", + "EXCHANGE", "EXCLUSIVE", "EXPIRE", "EXPORT", "EXTENDED", "EXTENT_SIZE", + "FAILED_LOGIN_ATTEMPTS", "FAST", "FAULTS", "FIELDS", "FILE_BLOCK_SIZE", + "FILTER", "FIRST", "FIXED", "FLUSH", "FOLLOWING", "FOLLOWS", "FOUND", + "FULL", "FUNCTION", "GENERAL", "GLOBAL", "GRANTS", "GROUP_REPLICATION", + "HANDLER", "HASH", "HELP", "HISTORY", "HOST", "HOSTS", "IDENTIFIED", + "IGNORE_SERVER_IDS", "IMPORT", "INCREMENT", "INDEXES", "INITIAL_SIZE", + "INPLACE", "INSERT_METHOD", "INSTALL", "INSTANCE", "INSTANT", "INVISIBLE", + "INVOKER", "IO", "IO_THREAD", "IPC", "ISOLATION", "ISSUER", "JSON", "KEY_BLOCK_SIZE", + "LANGUAGE", "LAST", "LEAVES", "LESS", "LEVEL", "LIST", "LOCAL", "LOGFILE", + "LOGS", "MASTER", "MASTER_AUTO_POSITION", "MASTER_CONNECT_RETRY", "MASTER_DELAY", + "MASTER_HEARTBEAT_PERIOD", "MASTER_HOST", "MASTER_LOG_FILE", "MASTER_LOG_POS", + "MASTER_PASSWORD", "MASTER_PORT", "MASTER_RETRY_COUNT", "MASTER_SSL", + "MASTER_SSL_CA", "MASTER_SSL_CAPATH", "MASTER_SSL_CERT", "MASTER_SSL_CIPHER", + "MASTER_SSL_CRL", "MASTER_SSL_CRLPATH", "MASTER_SSL_KEY", "MASTER_TLS_VERSION", + "MASTER_USER", "MAX_CONNECTIONS_PER_HOUR", "MAX_QUERIES_PER_HOUR", "MAX_ROWS", + "MAX_SIZE", "MAX_UPDATES_PER_HOUR", "MAX_USER_CONNECTIONS", "MEDIUM", + "MEMBER", "MERGE", "MESSAGE_TEXT", "MID", "MIGRATE", "MIN_ROWS", "MODE", + "MODIFY", "MUTEX", "MYSQL", "MYSQL_ERRNO", "NAME", "NAMES", "NCHAR", + "NEVER", "NEXT", "NO", "NOCACHE", "NOCOPY", "NOCYCLE", "NOMAXVALUE", + "NOMINVALUE", "NOWAIT", "NODEGROUP", "NONE", "ODBC", "OFFLINE", "OFFSET", + "OF", "OJ", "OLD_PASSWORD", "ONE", "ONLINE", "ONLY", "OPEN", "OPTIMIZER_COSTS", + "OPTIONS", "OWNER", "PACK_KEYS", "PAGE", "PAGE_COMPRESSED", "PAGE_COMPRESSION_LEVEL", + "PARSER", "PARTIAL", "PARTITIONING", "PARTITIONS", "PASSWORD", "PASSWORD_LOCK_TIME", + "PHASE", "PLUGIN", "PLUGIN_DIR", "PLUGINS", "PORT", "PRECEDES", "PRECEDING", + "PREPARE", "PRESERVE", "PREV", "PROCESSLIST", "PROFILE", "PROFILES", + "PROXY", "QUERY", "QUICK", "REBUILD", "RECOVER", "RECURSIVE", "REDO_BUFFER_SIZE", + "REDUNDANT", "RELAY", "RELAY_LOG_FILE", "RELAY_LOG_POS", "RELAYLOG", + "REMOVE", "REORGANIZE", "REPAIR", "REPLICATE_DO_DB", "REPLICATE_DO_TABLE", + "REPLICATE_IGNORE_DB", "REPLICATE_IGNORE_TABLE", "REPLICATE_REWRITE_DB", + "REPLICATE_WILD_DO_TABLE", "REPLICATE_WILD_IGNORE_TABLE", "REPLICATION", + "RESET", "RESTART", "RESUME", "RETURNED_SQLSTATE", "RETURNING", "RETURNS", + "REUSE", "ROLE", "ROLLBACK", "ROLLUP", "ROTATE", "ROW", "ROWS", "ROW_FORMAT", + "RTREE", "SAVEPOINT", "SCHEDULE", "SECURITY", "SEQUENCE", "SERVER", "SESSION", + "SHARE", "SHARED", "SIGNED", "SIMPLE", "SLAVE", "SLOW", "SNAPSHOT", "SOCKET", + "SOME", "SONAME", "SOUNDS", "SOURCE", "SQL_AFTER_GTIDS", "SQL_AFTER_MTS_GAPS", + "SQL_BEFORE_GTIDS", "SQL_BUFFER_RESULT", "SQL_CACHE", "SQL_NO_CACHE", + "SQL_THREAD", "START", "STARTS", "STATS_AUTO_RECALC", "STATS_PERSISTENT", + "STATS_SAMPLE_PAGES", "STATUS", "STOP", "STORAGE", "STORED", "STRING", + "SUBCLASS_ORIGIN", "SUBJECT", "SUBPARTITION", "SUBPARTITIONS", "SUSPEND", + "SWAPS", "SWITCHES", "TABLE_NAME", "TABLESPACE", "TABLE_TYPE", "TEMPORARY", + "TEMPTABLE", "THAN", "TRADITIONAL", "TRANSACTION", "TRANSACTIONAL", "TRIGGERS", + "TRUNCATE", "UNBOUNDED", "UNDEFINED", "UNDOFILE", "UNDO_BUFFER_SIZE", + "UNINSTALL", "UNKNOWN", "UNTIL", "UPGRADE", "USER", "USE_FRM", "USER_RESOURCES", + "VALIDATION", "VALUE", "VARIABLES", "VIEW", "VIRTUAL", "VISIBLE", "WAIT", + "WARNINGS", "WINDOW", "WITHOUT", "WORK", "WRAPPER", "X509", "XA", "XML", + "YES", "EUR", "USA", "JIS", "ISO", "INTERNAL", "QUARTER", "MONTH", "DAY", + "HOUR", "MINUTE", "WEEK", "SECOND", "MICROSECOND", "ADMIN", "APPLICATION_PASSWORD_ADMIN", + "AUDIT_ABORT_EXEMPT", "AUDIT_ADMIN", "AUTHENTICATION_POLICY_ADMIN", "BACKUP_ADMIN", + "BINLOG_ADMIN", "BINLOG_ENCRYPTION_ADMIN", "CLONE_ADMIN", "CONNECTION_ADMIN", + "ENCRYPTION_KEY_ADMIN", "EXECUTE", "FILE", "FIREWALL_ADMIN", "FIREWALL_EXEMPT", + "FIREWALL_USER", "FLUSH_OPTIMIZER_COSTS", "FLUSH_STATUS", "FLUSH_TABLES", + "FLUSH_USER_RESOURCES", "GROUP_REPLICATION_ADMIN", "INNODB_REDO_LOG_ARCHIVE", + "INNODB_REDO_LOG_ENABLE", "INVOKE", "LAMBDA", "NDB_STORED_USER", "PASSWORDLESS_USER_ADMIN", + "PERSIST_RO_VARIABLES_ADMIN", "PRIVILEGES", "PROCESS", "RELOAD", "REPLICATION_APPLIER", + "REPLICATION_SLAVE_ADMIN", "RESOURCE_GROUP_ADMIN", "RESOURCE_GROUP_USER", + "ROLE_ADMIN", "ROUTINE", "S3", "SERVICE_CONNECTION_ADMIN", "SESSION_VARIABLES_ADMIN", + "SET_USER_ID", "SHOW_ROUTINE", "SHUTDOWN", "SUPER", "SYSTEM_VARIABLES_ADMIN", + "TABLES", "TABLE_ENCRYPTION_ADMIN", "VERSION_TOKEN_ADMIN", "XA_RECOVER_ADMIN", + "ARMSCII8", "ASCII", "BIG5", "CP1250", "CP1251", "CP1256", "CP1257", + "CP850", "CP852", "CP866", "CP932", "DEC8", "EUCJPMS", "EUCKR", "GB18030", + "GB2312", "GBK", "GEOSTD8", "GREEK", "HEBREW", "HP8", "KEYBCS2", "KOI8R", + "KOI8U", "LATIN1", "LATIN2", "LATIN5", "LATIN7", "MACCE", "MACROMAN", + "SJIS", "SWE7", "TIS620", "UCS2", "UJIS", "UTF16", "UTF16LE", "UTF32", + "UTF8", "UTF8MB3", "UTF8MB4", "ARCHIVE", "BLACKHOLE", "CSV", "FEDERATED", + "INNODB", "MEMORY", "MRG_MYISAM", "MYISAM", "NDB", "NDBCLUSTER", "PERFORMANCE_SCHEMA", + "TOKUDB", "REPEATABLE", "COMMITTED", "UNCOMMITTED", "SERIALIZABLE", "GEOMETRYCOLLECTION", + "GEOMCOLLECTION", "GEOMETRY", "LINESTRING", "MULTILINESTRING", "MULTIPOINT", + "MULTIPOLYGON", "POINT", "POLYGON", "ABS", "ACOS", "ADDDATE", "ADDTIME", + "AES_DECRYPT", "AES_ENCRYPT", "AREA", "ASBINARY", "ASIN", "ASTEXT", "ASWKB", + "ASWKT", "ASYMMETRIC_DECRYPT", "ASYMMETRIC_DERIVE", "ASYMMETRIC_ENCRYPT", + "ASYMMETRIC_SIGN", "ASYMMETRIC_VERIFY", "ATAN", "ATAN2", "BENCHMARK", + "BIN", "BIT_COUNT", "BIT_LENGTH", "BUFFER", "CATALOG_NAME", "CEIL", "CEILING", + "CENTROID", "CHARACTER_LENGTH", "CHARSET", "CHAR_LENGTH", "COERCIBILITY", + "COLLATION", "COMPRESS", "CONCAT", "CONCAT_WS", "CONNECTION_ID", "CONV", + "CONVERT_TZ", "COS", "COT", "CRC32", "CREATE_ASYMMETRIC_PRIV_KEY", "CREATE_ASYMMETRIC_PUB_KEY", + "CREATE_DH_PARAMETERS", "CREATE_DIGEST", "CROSSES", "DATEDIFF", "DATE_FORMAT", + "DAYNAME", "DAYOFMONTH", "DAYOFWEEK", "DAYOFYEAR", "DECODE", "DEGREES", + "DES_DECRYPT", "DES_ENCRYPT", "DIMENSION", "DISJOINT", "ELT", "ENCODE", + "ENCRYPT", "ENDPOINT", "ENGINE_ATTRIBUTE", "ENVELOPE", "EQUALS", "EXP", + "EXPORT_SET", "EXTERIORRING", "EXTRACTVALUE", "FIELD", "FIND_IN_SET", + "FLOOR", "FORMAT", "FOUND_ROWS", "FROM_BASE64", "FROM_DAYS", "FROM_UNIXTIME", + "GEOMCOLLFROMTEXT", "GEOMCOLLFROMWKB", "GEOMETRYCOLLECTIONFROMTEXT", + "GEOMETRYCOLLECTIONFROMWKB", "GEOMETRYFROMTEXT", "GEOMETRYFROMWKB", "GEOMETRYN", + "GEOMETRYTYPE", "GEOMFROMTEXT", "GEOMFROMWKB", "GET_FORMAT", "GET_LOCK", + "GLENGTH", "GREATEST", "GTID_SUBSET", "GTID_SUBTRACT", "HEX", "IFNULL", + "INET6_ATON", "INET6_NTOA", "INET_ATON", "INET_NTOA", "INSTR", "INTERIORRINGN", + "INTERSECTS", "ISCLOSED", "ISEMPTY", "ISNULL", "ISSIMPLE", "IS_FREE_LOCK", + "IS_IPV4", "IS_IPV4_COMPAT", "IS_IPV4_MAPPED", "IS_IPV6", "IS_USED_LOCK", + "LAST_INSERT_ID", "LCASE", "LEAST", "LENGTH", "LINEFROMTEXT", "LINEFROMWKB", + "LINESTRINGFROMTEXT", "LINESTRINGFROMWKB", "LN", "LOAD_FILE", "LOCATE", + "LOG", "LOG10", "LOG2", "LOWER", "LPAD", "LTRIM", "MAKEDATE", "MAKETIME", + "MAKE_SET", "MASTER_POS_WAIT", "MBRCONTAINS", "MBRDISJOINT", "MBREQUAL", + "MBRINTERSECTS", "MBROVERLAPS", "MBRTOUCHES", "MBRWITHIN", "MD5", "MLINEFROMTEXT", + "MLINEFROMWKB", "MONTHNAME", "MPOINTFROMTEXT", "MPOINTFROMWKB", "MPOLYFROMTEXT", + "MPOLYFROMWKB", "MULTILINESTRINGFROMTEXT", "MULTILINESTRINGFROMWKB", + "MULTIPOINTFROMTEXT", "MULTIPOINTFROMWKB", "MULTIPOLYGONFROMTEXT", "MULTIPOLYGONFROMWKB", + "NAME_CONST", "NULLIF", "NUMGEOMETRIES", "NUMINTERIORRINGS", "NUMPOINTS", + "OCT", "OCTET_LENGTH", "ORD", "OVERLAPS", "PERIOD_ADD", "PERIOD_DIFF", + "PI", "POINTFROMTEXT", "POINTFROMWKB", "POINTN", "POLYFROMTEXT", "POLYFROMWKB", + "POLYGONFROMTEXT", "POLYGONFROMWKB", "POW", "POWER", "QUOTE", "RADIANS", + "RAND", "RANDOM", "RANDOM_BYTES", "RELEASE_LOCK", "REVERSE", "ROUND", + "ROW_COUNT", "RPAD", "RTRIM", "SEC_TO_TIME", "SECONDARY_ENGINE_ATTRIBUTE", + "SESSION_USER", "SHA", "SHA1", "SHA2", "SCHEMA_NAME", "SIGN", "SIN", + "SLEEP", "SOUNDEX", "SQL_THREAD_WAIT_AFTER_GTIDS", "SQRT", "SRID", "STARTPOINT", + "STRCMP", "STR_TO_DATE", "ST_AREA", "ST_ASBINARY", "ST_ASTEXT", "ST_ASWKB", + "ST_ASWKT", "ST_BUFFER", "ST_CENTROID", "ST_CONTAINS", "ST_CROSSES", + "ST_DIFFERENCE", "ST_DIMENSION", "ST_DISJOINT", "ST_DISTANCE", "ST_ENDPOINT", + "ST_ENVELOPE", "ST_EQUALS", "ST_EXTERIORRING", "ST_GEOMCOLLFROMTEXT", + "ST_GEOMCOLLFROMTXT", "ST_GEOMCOLLFROMWKB", "ST_GEOMETRYCOLLECTIONFROMTEXT", + "ST_GEOMETRYCOLLECTIONFROMWKB", "ST_GEOMETRYFROMTEXT", "ST_GEOMETRYFROMWKB", + "ST_GEOMETRYN", "ST_GEOMETRYTYPE", "ST_GEOMFROMTEXT", "ST_GEOMFROMWKB", + "ST_INTERIORRINGN", "ST_INTERSECTION", "ST_INTERSECTS", "ST_ISCLOSED", + "ST_ISEMPTY", "ST_ISSIMPLE", "ST_LINEFROMTEXT", "ST_LINEFROMWKB", "ST_LINESTRINGFROMTEXT", + "ST_LINESTRINGFROMWKB", "ST_NUMGEOMETRIES", "ST_NUMINTERIORRING", "ST_NUMINTERIORRINGS", + "ST_NUMPOINTS", "ST_OVERLAPS", "ST_POINTFROMTEXT", "ST_POINTFROMWKB", + "ST_POINTN", "ST_POLYFROMTEXT", "ST_POLYFROMWKB", "ST_POLYGONFROMTEXT", + "ST_POLYGONFROMWKB", "ST_SRID", "ST_STARTPOINT", "ST_SYMDIFFERENCE", + "ST_TOUCHES", "ST_UNION", "ST_WITHIN", "ST_X", "ST_Y", "SUBDATE", "SUBSTRING_INDEX", + "SUBTIME", "SYSTEM_USER", "TAN", "TIMEDIFF", "TIMESTAMPADD", "TIMESTAMPDIFF", + "TIME_FORMAT", "TIME_TO_SEC", "TOUCHES", "TO_BASE64", "TO_DAYS", "TO_SECONDS", + "TP_CONNECTION_ADMIN", "UCASE", "UNCOMPRESS", "UNCOMPRESSED_LENGTH", + "UNHEX", "UNIX_TIMESTAMP", "UPDATEXML", "UPPER", "UUID", "UUID_SHORT", + "VALIDATE_PASSWORD_STRENGTH", "VERSION", "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS", + "WEEKDAY", "WEEKOFYEAR", "WEIGHT_STRING", "WITHIN", "YEARWEEK", "Y_FUNCTION", + "X_FUNCTION", "VAR_ASSIGN", "PLUS_ASSIGN", "MINUS_ASSIGN", "MULT_ASSIGN", + "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", + "STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "DIV", "MOD", "EQUAL_SYMBOL", + "GREATER_SYMBOL", "LESS_SYMBOL", "EXCLAMATION_SYMBOL", "BIT_NOT_OP", + "BIT_OR_OP", "BIT_AND_OP", "BIT_XOR_OP", "DOT", "LR_BRACKET", "RR_BRACKET", + "COMMA", "SEMI", "AT_SIGN", "ZERO_DECIMAL", "ONE_DECIMAL", "TWO_DECIMAL", + "SINGLE_QUOTE_SYMB", "DOUBLE_QUOTE_SYMB", "REVERSE_QUOTE_SYMB", "COLON_SYMB", + "QUOTE_SYMB", "CHARSET_REVERSE_QOUTE_STRING", "FILESIZE_LITERAL", "START_NATIONAL_STRING_LITERAL", + "STRING_LITERAL", "DECIMAL_LITERAL", "HEXADECIMAL_LITERAL", "REAL_LITERAL", + "NULL_SPEC_LITERAL", "BIT_STRING", "STRING_CHARSET_NAME", "DOT_ID", "ID", + "REVERSE_QUOTE_ID", "HOST_IP_ADDRESS", "LOCAL_ID", "GLOBAL_ID", "CHARSET_NAME", + "EXPONENT_NUM_PART", "ID_LITERAL", "DQUOTA_STRING", "SQUOTA_STRING", + "BQUOTA_STRING", "HEX_DIGIT", "DEC_DIGIT", "BIT_STRING_L", "IP_ADDRESS", + "ERROR_RECONGNIGION" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, null, null, "'ADD'", "'ALL'", "'ALTER'", "'ALWAYS'", + "'ANALYZE'", "'AND'", "'ARRAY'", "'AS'", "'ASC'", "'ATTRIBUTE'", "'BEFORE'", + "'BETWEEN'", "'BOTH'", "'BUCKETS'", "'BY'", "'CALL'", "'CASCADE'", "'CASE'", + "'CAST'", "'CHANGE'", "'CHARACTER'", "'CHECK'", "'COLLATE'", "'COLUMN'", + "'CONDITION'", "'CONSTRAINT'", "'CONTINUE'", "'CONVERT'", "'CREATE'", + "'CROSS'", "'CURRENT'", "'CURRENT_ROLE'", "'CURRENT_USER'", "'CURSOR'", + "'DATABASE'", "'DATABASES'", "'DECLARE'", "'DEFAULT'", "'DELAYED'", "'DELETE'", + "'DESC'", "'DESCRIBE'", "'DETERMINISTIC'", "'DIAGNOSTICS'", "'DISTINCT'", + "'DISTINCTROW'", "'DROP'", "'EACH'", "'ELSE'", "'ELSEIF'", "'EMPTY'", + "'ENCLOSED'", "'ENFORCED'", "'ESCAPED'", "'EXCEPT'", "'EXISTS'", "'EXIT'", + "'EXPLAIN'", "'FALSE'", "'FETCH'", "'FOR'", "'FORCE'", "'FOREIGN'", "'FROM'", + "'FULLTEXT'", "'GENERATED'", "'GET'", "'GRANT'", "'GROUP'", "'HAVING'", + "'HIGH_PRIORITY'", "'HISTOGRAM'", "'IF'", "'IGNORE'", "'IGNORED'", "'IN'", + "'INDEX'", "'INFILE'", "'INNER'", "'INOUT'", "'INSERT'", "'INTERVAL'", + "'INTO'", "'IS'", "'ITERATE'", "'JOIN'", "'KEY'", "'KEYS'", "'KILL'", + "'LATERAL'", "'LEADING'", "'LEAVE'", "'LEFT'", "'LIKE'", "'LIMIT'", "'LINEAR'", + "'LINES'", "'LOAD'", "'LOCK'", "'LOCKED'", "'LOOP'", "'LOW_PRIORITY'", + "'MASTER_BIND'", "'MASTER_SSL_VERIFY_SERVER_CERT'", "'MATCH'", "'MAXVALUE'", + "'MINVALUE'", "'MODIFIES'", "'NATURAL'", "'NOT'", "'NO_WRITE_TO_BINLOG'", + "'NULL'", "'NUMBER'", "'ON'", "'OPTIMIZE'", "'OPTION'", "'OPTIONAL'", + "'OPTIONALLY'", "'OR'", "'ORDER'", "'OUT'", "'OUTER'", "'OUTFILE'", "'OVER'", + "'PARTITION'", "'PRIMARY'", "'PROCEDURE'", "'PURGE'", "'RANGE'", "'READ'", + "'READS'", "'REFERENCES'", "'REGEXP'", "'RELEASE'", "'RENAME'", "'REPEAT'", + "'REPLACE'", "'REQUIRE'", "'RESIGNAL'", "'RESTRICT'", "'RETAIN'", "'RETURN'", + "'REVOKE'", "'RIGHT'", "'RLIKE'", "'SCHEMA'", "'SCHEMAS'", "'SELECT'", + "'SET'", "'SEPARATOR'", "'SHOW'", "'SIGNAL'", "'SKIP'", "'SKIP_QUERY_REWRITE'", + "'SPATIAL'", "'SQL'", "'SQLEXCEPTION'", "'SQLSTATE'", "'SQLWARNING'", + "'SQL_BIG_RESULT'", "'SQL_CALC_FOUND_ROWS'", "'SQL_SMALL_RESULT'", "'SSL'", + "'STACKED'", "'STARTING'", "'STATEMENT'", "'STRAIGHT_JOIN'", "'TABLE'", + "'TERMINATED'", "'THEN'", "'TO'", "'TRAILING'", "'TRIGGER'", "'TRUE'", + "'UNDO'", "'UNION'", "'UNIQUE'", "'UNLOCK'", "'UNSIGNED'", "'UPDATE'", + "'USAGE'", "'USE'", "'USING'", "'VALUES'", "'WHEN'", "'WHERE'", "'WHILE'", + "'WITH'", "'WRITE'", "'XOR'", "'ZEROFILL'", "'TINYINT'", "'SMALLINT'", + "'MEDIUMINT'", "'MIDDLEINT'", "'INT'", "'INT1'", "'INT2'", "'INT3'", + "'INT4'", "'INT8'", "'INTEGER'", "'BIGINT'", "'REAL'", "'DOUBLE'", "'PRECISION'", + "'FLOAT'", "'FLOAT4'", "'FLOAT8'", "'DECIMAL'", "'DEC'", "'NUMERIC'", + "'DATE'", "'TIME'", "'TIMESTAMP'", "'DATETIME'", "'YEAR'", "'CHAR'", + "'VARCHAR'", "'NVARCHAR'", "'NATIONAL'", "'BINARY'", "'VARBINARY'", "'TINYBLOB'", + "'BLOB'", "'MEDIUMBLOB'", "'LONG'", "'LONGBLOB'", "'TINYTEXT'", "'TEXT'", + "'MEDIUMTEXT'", "'LONGTEXT'", "'ENUM'", "'VARYING'", "'SERIAL'", "'YEAR_MONTH'", + "'DAY_HOUR'", "'DAY_MINUTE'", "'DAY_SECOND'", "'HOUR_MINUTE'", "'HOUR_SECOND'", + "'MINUTE_SECOND'", "'SECOND_MICROSECOND'", "'MINUTE_MICROSECOND'", "'HOUR_MICROSECOND'", + "'DAY_MICROSECOND'", "'JSON_ARRAY'", "'JSON_ARRAYAGG'", "'JSON_ARRAY_APPEND'", + "'JSON_ARRAY_INSERT'", "'JSON_CONTAINS'", "'JSON_CONTAINS_PATH'", "'JSON_DEPTH'", + "'JSON_EXTRACT'", "'JSON_INSERT'", "'JSON_KEYS'", "'JSON_LENGTH'", "'JSON_MERGE'", + "'JSON_MERGE_PATCH'", "'JSON_MERGE_PRESERVE'", "'JSON_OBJECT'", "'JSON_OBJECTAGG'", + "'JSON_OVERLAPS'", "'JSON_PRETTY'", "'JSON_QUOTE'", "'JSON_REMOVE'", + "'JSON_REPLACE'", "'JSON_SCHEMA_VALID'", "'JSON_SCHEMA_VALIDATION_REPORT'", + "'JSON_SEARCH'", "'JSON_SET'", "'JSON_STORAGE_FREE'", "'JSON_STORAGE_SIZE'", + "'JSON_TABLE'", "'JSON_TYPE'", "'JSON_UNQUOTE'", "'JSON_VALID'", "'JSON_VALUE'", + "'NESTED'", "'ORDINALITY'", "'PATH'", "'AVG'", "'BIT_AND'", "'BIT_OR'", + "'BIT_XOR'", "'COUNT'", "'CUME_DIST'", "'DENSE_RANK'", "'FIRST_VALUE'", + "'GROUP_CONCAT'", "'LAG'", "'LAST_VALUE'", "'LEAD'", "'MAX'", "'MIN'", + "'NTILE'", "'NTH_VALUE'", "'PERCENT_RANK'", "'RANK'", "'ROW_NUMBER'", + "'STD'", "'STDDEV'", "'STDDEV_POP'", "'STDDEV_SAMP'", "'SUM'", "'VAR_POP'", + "'VAR_SAMP'", "'VARIANCE'", "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'LOCALTIME'", "'CURDATE'", "'CURTIME'", "'DATE_ADD'", "'DATE_SUB'", + "'EXTRACT'", "'LOCALTIMESTAMP'", "'NOW'", "'POSITION'", "'SUBSTR'", "'SUBSTRING'", + "'SYSDATE'", "'TRIM'", "'UTC_DATE'", "'UTC_TIME'", "'UTC_TIMESTAMP'", + "'ACCOUNT'", "'ACTION'", "'AFTER'", "'AGGREGATE'", "'ALGORITHM'", "'ANY'", + "'AT'", "'AUTHORS'", "'AUTOCOMMIT'", "'AUTOEXTEND_SIZE'", "'AUTO_INCREMENT'", + "'AVG_ROW_LENGTH'", "'BEGIN'", "'BINLOG'", "'BIT'", "'BLOCK'", "'BOOL'", + "'BOOLEAN'", "'BTREE'", "'CACHE'", "'CASCADED'", "'CHAIN'", "'CHANGED'", + "'CHANNEL'", "'CHECKSUM'", "'PAGE_CHECKSUM'", "'CIPHER'", "'CLASS_ORIGIN'", + "'CLIENT'", "'CLOSE'", "'CLUSTERING'", "'COALESCE'", "'CODE'", "'COLUMNS'", + "'COLUMN_FORMAT'", "'COLUMN_NAME'", "'COMMENT'", "'COMMIT'", "'COMPACT'", + "'COMPLETION'", "'COMPRESSED'", "'COMPRESSION'", "'CONCURRENT'", "'CONNECT'", + "'CONNECTION'", "'CONSISTENT'", "'CONSTRAINT_CATALOG'", "'CONSTRAINT_SCHEMA'", + "'CONSTRAINT_NAME'", "'CONTAINS'", "'CONTEXT'", "'CONTRIBUTORS'", "'COPY'", + "'CPU'", "'CYCLE'", "'CURSOR_NAME'", "'DATA'", "'DATAFILE'", "'DEALLOCATE'", + "'DEFAULT_AUTH'", "'DEFINER'", "'DELAY_KEY_WRITE'", "'DES_KEY_FILE'", + "'DIRECTORY'", "'DISABLE'", "'DISCARD'", "'DISK'", "'DO'", "'DUMPFILE'", + "'DUPLICATE'", "'DYNAMIC'", "'ENABLE'", "'ENCRYPTED'", "'ENCRYPTION'", + "'ENCRYPTION_KEY_ID'", "'END'", "'ENDS'", "'ENGINE'", "'ENGINES'", "'ERROR'", + "'ERRORS'", "'ESCAPE'", "'EVEN'", "'EVENT'", "'EVENTS'", "'EVERY'", "'EXCHANGE'", + "'EXCLUSIVE'", "'EXPIRE'", "'EXPORT'", "'EXTENDED'", "'EXTENT_SIZE'", + "'FAILED_LOGIN_ATTEMPTS'", "'FAST'", "'FAULTS'", "'FIELDS'", "'FILE_BLOCK_SIZE'", + "'FILTER'", "'FIRST'", "'FIXED'", "'FLUSH'", "'FOLLOWING'", "'FOLLOWS'", + "'FOUND'", "'FULL'", "'FUNCTION'", "'GENERAL'", "'GLOBAL'", "'GRANTS'", + "'GROUP_REPLICATION'", "'HANDLER'", "'HASH'", "'HELP'", "'HISTORY'", + "'HOST'", "'HOSTS'", "'IDENTIFIED'", "'IGNORE_SERVER_IDS'", "'IMPORT'", + "'INCREMENT'", "'INDEXES'", "'INITIAL_SIZE'", "'INPLACE'", "'INSERT_METHOD'", + "'INSTALL'", "'INSTANCE'", "'INSTANT'", "'INVISIBLE'", "'INVOKER'", "'IO'", + "'IO_THREAD'", "'IPC'", "'ISOLATION'", "'ISSUER'", "'JSON'", "'KEY_BLOCK_SIZE'", + "'LANGUAGE'", "'LAST'", "'LEAVES'", "'LESS'", "'LEVEL'", "'LIST'", "'LOCAL'", + "'LOGFILE'", "'LOGS'", "'MASTER'", "'MASTER_AUTO_POSITION'", "'MASTER_CONNECT_RETRY'", + "'MASTER_DELAY'", "'MASTER_HEARTBEAT_PERIOD'", "'MASTER_HOST'", "'MASTER_LOG_FILE'", + "'MASTER_LOG_POS'", "'MASTER_PASSWORD'", "'MASTER_PORT'", "'MASTER_RETRY_COUNT'", + "'MASTER_SSL'", "'MASTER_SSL_CA'", "'MASTER_SSL_CAPATH'", "'MASTER_SSL_CERT'", + "'MASTER_SSL_CIPHER'", "'MASTER_SSL_CRL'", "'MASTER_SSL_CRLPATH'", "'MASTER_SSL_KEY'", + "'MASTER_TLS_VERSION'", "'MASTER_USER'", "'MAX_CONNECTIONS_PER_HOUR'", + "'MAX_QUERIES_PER_HOUR'", "'MAX_ROWS'", "'MAX_SIZE'", "'MAX_UPDATES_PER_HOUR'", + "'MAX_USER_CONNECTIONS'", "'MEDIUM'", "'MEMBER'", "'MERGE'", "'MESSAGE_TEXT'", + "'MID'", "'MIGRATE'", "'MIN_ROWS'", "'MODE'", "'MODIFY'", "'MUTEX'", + "'MYSQL'", "'MYSQL_ERRNO'", "'NAME'", "'NAMES'", "'NCHAR'", "'NEVER'", + "'NEXT'", "'NO'", "'NOCACHE'", "'NOCOPY'", "'NOCYCLE'", "'NOMAXVALUE'", + "'NOMINVALUE'", "'NOWAIT'", "'NODEGROUP'", "'NONE'", "'ODBC'", "'OFFLINE'", + "'OFFSET'", "'OF'", "'OJ'", "'OLD_PASSWORD'", "'ONE'", "'ONLINE'", "'ONLY'", + "'OPEN'", "'OPTIMIZER_COSTS'", "'OPTIONS'", "'OWNER'", "'PACK_KEYS'", + "'PAGE'", "'PAGE_COMPRESSED'", "'PAGE_COMPRESSION_LEVEL'", "'PARSER'", + "'PARTIAL'", "'PARTITIONING'", "'PARTITIONS'", "'PASSWORD'", "'PASSWORD_LOCK_TIME'", + "'PHASE'", "'PLUGIN'", "'PLUGIN_DIR'", "'PLUGINS'", "'PORT'", "'PRECEDES'", + "'PRECEDING'", "'PREPARE'", "'PRESERVE'", "'PREV'", "'PROCESSLIST'", + "'PROFILE'", "'PROFILES'", "'PROXY'", "'QUERY'", "'QUICK'", "'REBUILD'", + "'RECOVER'", "'RECURSIVE'", "'REDO_BUFFER_SIZE'", "'REDUNDANT'", "'RELAY'", + "'RELAY_LOG_FILE'", "'RELAY_LOG_POS'", "'RELAYLOG'", "'REMOVE'", "'REORGANIZE'", + "'REPAIR'", "'REPLICATE_DO_DB'", "'REPLICATE_DO_TABLE'", "'REPLICATE_IGNORE_DB'", + "'REPLICATE_IGNORE_TABLE'", "'REPLICATE_REWRITE_DB'", "'REPLICATE_WILD_DO_TABLE'", + "'REPLICATE_WILD_IGNORE_TABLE'", "'REPLICATION'", "'RESET'", "'RESTART'", + "'RESUME'", "'RETURNED_SQLSTATE'", "'RETURNING'", "'RETURNS'", "'REUSE'", + "'ROLE'", "'ROLLBACK'", "'ROLLUP'", "'ROTATE'", "'ROW'", "'ROWS'", "'ROW_FORMAT'", + "'RTREE'", "'SAVEPOINT'", "'SCHEDULE'", "'SECURITY'", "'SEQUENCE'", "'SERVER'", + "'SESSION'", "'SHARE'", "'SHARED'", "'SIGNED'", "'SIMPLE'", "'SLAVE'", + "'SLOW'", "'SNAPSHOT'", "'SOCKET'", "'SOME'", "'SONAME'", "'SOUNDS'", + "'SOURCE'", "'SQL_AFTER_GTIDS'", "'SQL_AFTER_MTS_GAPS'", "'SQL_BEFORE_GTIDS'", + "'SQL_BUFFER_RESULT'", "'SQL_CACHE'", "'SQL_NO_CACHE'", "'SQL_THREAD'", + "'START'", "'STARTS'", "'STATS_AUTO_RECALC'", "'STATS_PERSISTENT'", "'STATS_SAMPLE_PAGES'", + "'STATUS'", "'STOP'", "'STORAGE'", "'STORED'", "'STRING'", "'SUBCLASS_ORIGIN'", + "'SUBJECT'", "'SUBPARTITION'", "'SUBPARTITIONS'", "'SUSPEND'", "'SWAPS'", + "'SWITCHES'", "'TABLE_NAME'", "'TABLESPACE'", "'TABLE_TYPE'", "'TEMPORARY'", + "'TEMPTABLE'", "'THAN'", "'TRADITIONAL'", "'TRANSACTION'", "'TRANSACTIONAL'", + "'TRIGGERS'", "'TRUNCATE'", "'UNBOUNDED'", "'UNDEFINED'", "'UNDOFILE'", + "'UNDO_BUFFER_SIZE'", "'UNINSTALL'", "'UNKNOWN'", "'UNTIL'", "'UPGRADE'", + "'USER'", "'USE_FRM'", "'USER_RESOURCES'", "'VALIDATION'", "'VALUE'", + "'VARIABLES'", "'VIEW'", "'VIRTUAL'", "'VISIBLE'", "'WAIT'", "'WARNINGS'", + "'WINDOW'", "'WITHOUT'", "'WORK'", "'WRAPPER'", "'X509'", "'XA'", "'XML'", + "'YES'", "'EUR'", "'USA'", "'JIS'", "'ISO'", "'INTERNAL'", "'QUARTER'", + "'MONTH'", "'DAY'", "'HOUR'", "'MINUTE'", "'WEEK'", "'SECOND'", "'MICROSECOND'", + "'ADMIN'", "'APPLICATION_PASSWORD_ADMIN'", "'AUDIT_ABORT_EXEMPT'", "'AUDIT_ADMIN'", + "'AUTHENTICATION_POLICY_ADMIN'", "'BACKUP_ADMIN'", "'BINLOG_ADMIN'", + "'BINLOG_ENCRYPTION_ADMIN'", "'CLONE_ADMIN'", "'CONNECTION_ADMIN'", "'ENCRYPTION_KEY_ADMIN'", + "'EXECUTE'", "'FILE'", "'FIREWALL_ADMIN'", "'FIREWALL_EXEMPT'", "'FIREWALL_USER'", + "'FLUSH_OPTIMIZER_COSTS'", "'FLUSH_STATUS'", "'FLUSH_TABLES'", "'FLUSH_USER_RESOURCES'", + "'GROUP_REPLICATION_ADMIN'", "'INNODB_REDO_LOG_ARCHIVE'", "'INNODB_REDO_LOG_ENABLE'", + "'INVOKE'", "'LAMBDA'", "'NDB_STORED_USER'", "'PASSWORDLESS_USER_ADMIN'", + "'PERSIST_RO_VARIABLES_ADMIN'", "'PRIVILEGES'", "'PROCESS'", "'RELOAD'", + "'REPLICATION_APPLIER'", "'REPLICATION_SLAVE_ADMIN'", "'RESOURCE_GROUP_ADMIN'", + "'RESOURCE_GROUP_USER'", "'ROLE_ADMIN'", "'ROUTINE'", "'S3'", "'SERVICE_CONNECTION_ADMIN'", + null, "'SET_USER_ID'", "'SHOW_ROUTINE'", "'SHUTDOWN'", "'SUPER'", "'SYSTEM_VARIABLES_ADMIN'", + "'TABLES'", "'TABLE_ENCRYPTION_ADMIN'", "'VERSION_TOKEN_ADMIN'", "'XA_RECOVER_ADMIN'", + "'ARMSCII8'", "'ASCII'", "'BIG5'", "'CP1250'", "'CP1251'", "'CP1256'", + "'CP1257'", "'CP850'", "'CP852'", "'CP866'", "'CP932'", "'DEC8'", "'EUCJPMS'", + "'EUCKR'", "'GB18030'", "'GB2312'", "'GBK'", "'GEOSTD8'", "'GREEK'", + "'HEBREW'", "'HP8'", "'KEYBCS2'", "'KOI8R'", "'KOI8U'", "'LATIN1'", "'LATIN2'", + "'LATIN5'", "'LATIN7'", "'MACCE'", "'MACROMAN'", "'SJIS'", "'SWE7'", + "'TIS620'", "'UCS2'", "'UJIS'", "'UTF16'", "'UTF16LE'", "'UTF32'", "'UTF8'", + "'UTF8MB3'", "'UTF8MB4'", "'ARCHIVE'", "'BLACKHOLE'", "'CSV'", "'FEDERATED'", + "'INNODB'", "'MEMORY'", "'MRG_MYISAM'", "'MYISAM'", "'NDB'", "'NDBCLUSTER'", + "'PERFORMANCE_SCHEMA'", "'TOKUDB'", "'REPEATABLE'", "'COMMITTED'", "'UNCOMMITTED'", + "'SERIALIZABLE'", "'GEOMETRYCOLLECTION'", "'GEOMCOLLECTION'", "'GEOMETRY'", + "'LINESTRING'", "'MULTILINESTRING'", "'MULTIPOINT'", "'MULTIPOLYGON'", + "'POINT'", "'POLYGON'", "'ABS'", "'ACOS'", "'ADDDATE'", "'ADDTIME'", + "'AES_DECRYPT'", "'AES_ENCRYPT'", "'AREA'", "'ASBINARY'", "'ASIN'", "'ASTEXT'", + "'ASWKB'", "'ASWKT'", "'ASYMMETRIC_DECRYPT'", "'ASYMMETRIC_DERIVE'", + "'ASYMMETRIC_ENCRYPT'", "'ASYMMETRIC_SIGN'", "'ASYMMETRIC_VERIFY'", "'ATAN'", + "'ATAN2'", "'BENCHMARK'", "'BIN'", "'BIT_COUNT'", "'BIT_LENGTH'", "'BUFFER'", + "'CATALOG_NAME'", "'CEIL'", "'CEILING'", "'CENTROID'", "'CHARACTER_LENGTH'", + "'CHARSET'", "'CHAR_LENGTH'", "'COERCIBILITY'", "'COLLATION'", "'COMPRESS'", + "'CONCAT'", "'CONCAT_WS'", "'CONNECTION_ID'", "'CONV'", "'CONVERT_TZ'", + "'COS'", "'COT'", "'CRC32'", "'CREATE_ASYMMETRIC_PRIV_KEY'", "'CREATE_ASYMMETRIC_PUB_KEY'", + "'CREATE_DH_PARAMETERS'", "'CREATE_DIGEST'", "'CROSSES'", "'DATEDIFF'", + "'DATE_FORMAT'", "'DAYNAME'", "'DAYOFMONTH'", "'DAYOFWEEK'", "'DAYOFYEAR'", + "'DECODE'", "'DEGREES'", "'DES_DECRYPT'", "'DES_ENCRYPT'", "'DIMENSION'", + "'DISJOINT'", "'ELT'", "'ENCODE'", "'ENCRYPT'", "'ENDPOINT'", "'ENGINE_ATTRIBUTE'", + "'ENVELOPE'", "'EQUALS'", "'EXP'", "'EXPORT_SET'", "'EXTERIORRING'", + "'EXTRACTVALUE'", "'FIELD'", "'FIND_IN_SET'", "'FLOOR'", "'FORMAT'", + "'FOUND_ROWS'", "'FROM_BASE64'", "'FROM_DAYS'", "'FROM_UNIXTIME'", "'GEOMCOLLFROMTEXT'", + "'GEOMCOLLFROMWKB'", "'GEOMETRYCOLLECTIONFROMTEXT'", "'GEOMETRYCOLLECTIONFROMWKB'", + "'GEOMETRYFROMTEXT'", "'GEOMETRYFROMWKB'", "'GEOMETRYN'", "'GEOMETRYTYPE'", + "'GEOMFROMTEXT'", "'GEOMFROMWKB'", "'GET_FORMAT'", "'GET_LOCK'", "'GLENGTH'", + "'GREATEST'", "'GTID_SUBSET'", "'GTID_SUBTRACT'", "'HEX'", "'IFNULL'", + "'INET6_ATON'", "'INET6_NTOA'", "'INET_ATON'", "'INET_NTOA'", "'INSTR'", + "'INTERIORRINGN'", "'INTERSECTS'", "'ISCLOSED'", "'ISEMPTY'", "'ISNULL'", + "'ISSIMPLE'", "'IS_FREE_LOCK'", "'IS_IPV4'", "'IS_IPV4_COMPAT'", "'IS_IPV4_MAPPED'", + "'IS_IPV6'", "'IS_USED_LOCK'", "'LAST_INSERT_ID'", "'LCASE'", "'LEAST'", + "'LENGTH'", "'LINEFROMTEXT'", "'LINEFROMWKB'", "'LINESTRINGFROMTEXT'", + "'LINESTRINGFROMWKB'", "'LN'", "'LOAD_FILE'", "'LOCATE'", "'LOG'", "'LOG10'", + "'LOG2'", "'LOWER'", "'LPAD'", "'LTRIM'", "'MAKEDATE'", "'MAKETIME'", + "'MAKE_SET'", "'MASTER_POS_WAIT'", "'MBRCONTAINS'", "'MBRDISJOINT'", + "'MBREQUAL'", "'MBRINTERSECTS'", "'MBROVERLAPS'", "'MBRTOUCHES'", "'MBRWITHIN'", + "'MD5'", "'MLINEFROMTEXT'", "'MLINEFROMWKB'", "'MONTHNAME'", "'MPOINTFROMTEXT'", + "'MPOINTFROMWKB'", "'MPOLYFROMTEXT'", "'MPOLYFROMWKB'", "'MULTILINESTRINGFROMTEXT'", + "'MULTILINESTRINGFROMWKB'", "'MULTIPOINTFROMTEXT'", "'MULTIPOINTFROMWKB'", + "'MULTIPOLYGONFROMTEXT'", "'MULTIPOLYGONFROMWKB'", "'NAME_CONST'", "'NULLIF'", + "'NUMGEOMETRIES'", "'NUMINTERIORRINGS'", "'NUMPOINTS'", "'OCT'", "'OCTET_LENGTH'", + "'ORD'", "'OVERLAPS'", "'PERIOD_ADD'", "'PERIOD_DIFF'", "'PI'", "'POINTFROMTEXT'", + "'POINTFROMWKB'", "'POINTN'", "'POLYFROMTEXT'", "'POLYFROMWKB'", "'POLYGONFROMTEXT'", + "'POLYGONFROMWKB'", "'POW'", "'POWER'", "'QUOTE'", "'RADIANS'", "'RAND'", + "'RANDOM'", "'RANDOM_BYTES'", "'RELEASE_LOCK'", "'REVERSE'", "'ROUND'", + "'ROW_COUNT'", "'RPAD'", "'RTRIM'", "'SEC_TO_TIME'", "'SECONDARY_ENGINE_ATTRIBUTE'", + "'SESSION_USER'", "'SHA'", "'SHA1'", "'SHA2'", "'SCHEMA_NAME'", "'SIGN'", + "'SIN'", "'SLEEP'", "'SOUNDEX'", "'SQL_THREAD_WAIT_AFTER_GTIDS'", "'SQRT'", + "'SRID'", "'STARTPOINT'", "'STRCMP'", "'STR_TO_DATE'", "'ST_AREA'", "'ST_ASBINARY'", + "'ST_ASTEXT'", "'ST_ASWKB'", "'ST_ASWKT'", "'ST_BUFFER'", "'ST_CENTROID'", + "'ST_CONTAINS'", "'ST_CROSSES'", "'ST_DIFFERENCE'", "'ST_DIMENSION'", + "'ST_DISJOINT'", "'ST_DISTANCE'", "'ST_ENDPOINT'", "'ST_ENVELOPE'", "'ST_EQUALS'", + "'ST_EXTERIORRING'", "'ST_GEOMCOLLFROMTEXT'", "'ST_GEOMCOLLFROMTXT'", + "'ST_GEOMCOLLFROMWKB'", "'ST_GEOMETRYCOLLECTIONFROMTEXT'", "'ST_GEOMETRYCOLLECTIONFROMWKB'", + "'ST_GEOMETRYFROMTEXT'", "'ST_GEOMETRYFROMWKB'", "'ST_GEOMETRYN'", "'ST_GEOMETRYTYPE'", + "'ST_GEOMFROMTEXT'", "'ST_GEOMFROMWKB'", "'ST_INTERIORRINGN'", "'ST_INTERSECTION'", + "'ST_INTERSECTS'", "'ST_ISCLOSED'", "'ST_ISEMPTY'", "'ST_ISSIMPLE'", + "'ST_LINEFROMTEXT'", "'ST_LINEFROMWKB'", "'ST_LINESTRINGFROMTEXT'", "'ST_LINESTRINGFROMWKB'", + "'ST_NUMGEOMETRIES'", "'ST_NUMINTERIORRING'", "'ST_NUMINTERIORRINGS'", + "'ST_NUMPOINTS'", "'ST_OVERLAPS'", "'ST_POINTFROMTEXT'", "'ST_POINTFROMWKB'", + "'ST_POINTN'", "'ST_POLYFROMTEXT'", "'ST_POLYFROMWKB'", "'ST_POLYGONFROMTEXT'", + "'ST_POLYGONFROMWKB'", "'ST_SRID'", "'ST_STARTPOINT'", "'ST_SYMDIFFERENCE'", + "'ST_TOUCHES'", "'ST_UNION'", "'ST_WITHIN'", "'ST_X'", "'ST_Y'", "'SUBDATE'", + "'SUBSTRING_INDEX'", "'SUBTIME'", "'SYSTEM_USER'", "'TAN'", "'TIMEDIFF'", + "'TIMESTAMPADD'", "'TIMESTAMPDIFF'", "'TIME_FORMAT'", "'TIME_TO_SEC'", + "'TOUCHES'", "'TO_BASE64'", "'TO_DAYS'", "'TO_SECONDS'", "'TP_CONNECTION_ADMIN'", + "'UCASE'", "'UNCOMPRESS'", "'UNCOMPRESSED_LENGTH'", "'UNHEX'", "'UNIX_TIMESTAMP'", + "'UPDATEXML'", "'UPPER'", "'UUID'", "'UUID_SHORT'", "'VALIDATE_PASSWORD_STRENGTH'", + "'VERSION'", "'WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS'", "'WEEKDAY'", "'WEEKOFYEAR'", + "'WEIGHT_STRING'", "'WITHIN'", "'YEARWEEK'", "'Y'", "'X'", "':='", "'+='", + "'-='", "'*='", "'/='", "'%='", "'&='", "'^='", "'|='", "'*'", "'/'", + "'%'", "'+'", "'-'", "'DIV'", "'MOD'", "'='", "'>'", "'<'", "'!'", "'~'", + "'|'", "'&'", "'^'", "'.'", "'('", "')'", "','", "';'", "'@'", "'0'", + "'1'", "'2'", "'''", "'\"'", "'`'", "':'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "SPEL", "SPACE", "SPEC_MYSQL_COMMENT", "COMMENT_INPUT", "LINE_COMMENT", + "ADD", "ALL", "ALTER", "ALWAYS", "ANALYZE", "AND", "ARRAY", "AS", "ASC", + "ATTRIBUTE", "BEFORE", "BETWEEN", "BOTH", "BUCKETS", "BY", "CALL", "CASCADE", + "CASE", "CAST", "CHANGE", "CHARACTER", "CHECK", "COLLATE", "COLUMN", + "CONDITION", "CONSTRAINT", "CONTINUE", "CONVERT", "CREATE", "CROSS", + "CURRENT", "CURRENT_ROLE", "CURRENT_USER", "CURSOR", "DATABASE", "DATABASES", + "DECLARE", "DEFAULT", "DELAYED", "DELETE", "DESC", "DESCRIBE", "DETERMINISTIC", + "DIAGNOSTICS", "DISTINCT", "DISTINCTROW", "DROP", "EACH", "ELSE", "ELSEIF", + "EMPTY", "ENCLOSED", "ENFORCED", "ESCAPED", "EXCEPT", "EXISTS", "EXIT", + "EXPLAIN", "FALSE", "FETCH", "FOR", "FORCE", "FOREIGN", "FROM", "FULLTEXT", + "GENERATED", "GET", "GRANT", "GROUP", "HAVING", "HIGH_PRIORITY", "HISTOGRAM", + "IF", "IGNORE", "IGNORED", "IN", "INDEX", "INFILE", "INNER", "INOUT", + "INSERT", "INTERVAL", "INTO", "IS", "ITERATE", "JOIN", "KEY", "KEYS", + "KILL", "LATERAL", "LEADING", "LEAVE", "LEFT", "LIKE", "LIMIT", "LINEAR", + "LINES", "LOAD", "LOCK", "LOCKED", "LOOP", "LOW_PRIORITY", "MASTER_BIND", + "MASTER_SSL_VERIFY_SERVER_CERT", "MATCH", "MAXVALUE", "MINVALUE", "MODIFIES", + "NATURAL", "NOT", "NO_WRITE_TO_BINLOG", "NULL_LITERAL", "NUMBER", "ON", + "OPTIMIZE", "OPTION", "OPTIONAL", "OPTIONALLY", "OR", "ORDER", "OUT", + "OUTER", "OUTFILE", "OVER", "PARTITION", "PRIMARY", "PROCEDURE", "PURGE", + "RANGE", "READ", "READS", "REFERENCES", "REGEXP", "RELEASE", "RENAME", + "REPEAT", "REPLACE", "REQUIRE", "RESIGNAL", "RESTRICT", "RETAIN", "RETURN", + "REVOKE", "RIGHT", "RLIKE", "SCHEMA", "SCHEMAS", "SELECT", "SET", "SEPARATOR", + "SHOW", "SIGNAL", "SKIP_", "SKIP_QUERY_REWRITE", "SPATIAL", "SQL", "SQLEXCEPTION", + "SQLSTATE", "SQLWARNING", "SQL_BIG_RESULT", "SQL_CALC_FOUND_ROWS", "SQL_SMALL_RESULT", + "SSL", "STACKED", "STARTING", "STATEMENT", "STRAIGHT_JOIN", "TABLE", + "TERMINATED", "THEN", "TO", "TRAILING", "TRIGGER", "TRUE", "UNDO", "UNION", + "UNIQUE", "UNLOCK", "UNSIGNED", "UPDATE", "USAGE", "USE", "USING", "VALUES", + "WHEN", "WHERE", "WHILE", "WITH", "WRITE", "XOR", "ZEROFILL", "TINYINT", + "SMALLINT", "MEDIUMINT", "MIDDLEINT", "INT", "INT1", "INT2", "INT3", + "INT4", "INT8", "INTEGER", "BIGINT", "REAL", "DOUBLE", "PRECISION", "FLOAT", + "FLOAT4", "FLOAT8", "DECIMAL", "DEC", "NUMERIC", "DATE", "TIME", "TIMESTAMP", + "DATETIME", "YEAR", "CHAR", "VARCHAR", "NVARCHAR", "NATIONAL", "BINARY", + "VARBINARY", "TINYBLOB", "BLOB", "MEDIUMBLOB", "LONG", "LONGBLOB", "TINYTEXT", + "TEXT", "MEDIUMTEXT", "LONGTEXT", "ENUM", "VARYING", "SERIAL", "YEAR_MONTH", + "DAY_HOUR", "DAY_MINUTE", "DAY_SECOND", "HOUR_MINUTE", "HOUR_SECOND", + "MINUTE_SECOND", "SECOND_MICROSECOND", "MINUTE_MICROSECOND", "HOUR_MICROSECOND", + "DAY_MICROSECOND", "JSON_ARRAY", "JSON_ARRAYAGG", "JSON_ARRAY_APPEND", + "JSON_ARRAY_INSERT", "JSON_CONTAINS", "JSON_CONTAINS_PATH", "JSON_DEPTH", + "JSON_EXTRACT", "JSON_INSERT", "JSON_KEYS", "JSON_LENGTH", "JSON_MERGE", + "JSON_MERGE_PATCH", "JSON_MERGE_PRESERVE", "JSON_OBJECT", "JSON_OBJECTAGG", + "JSON_OVERLAPS", "JSON_PRETTY", "JSON_QUOTE", "JSON_REMOVE", "JSON_REPLACE", + "JSON_SCHEMA_VALID", "JSON_SCHEMA_VALIDATION_REPORT", "JSON_SEARCH", + "JSON_SET", "JSON_STORAGE_FREE", "JSON_STORAGE_SIZE", "JSON_TABLE", "JSON_TYPE", + "JSON_UNQUOTE", "JSON_VALID", "JSON_VALUE", "NESTED", "ORDINALITY", "PATH", + "AVG", "BIT_AND", "BIT_OR", "BIT_XOR", "COUNT", "CUME_DIST", "DENSE_RANK", + "FIRST_VALUE", "GROUP_CONCAT", "LAG", "LAST_VALUE", "LEAD", "MAX", "MIN", + "NTILE", "NTH_VALUE", "PERCENT_RANK", "RANK", "ROW_NUMBER", "STD", "STDDEV", + "STDDEV_POP", "STDDEV_SAMP", "SUM", "VAR_POP", "VAR_SAMP", "VARIANCE", + "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "LOCALTIME", "CURDATE", + "CURTIME", "DATE_ADD", "DATE_SUB", "EXTRACT", "LOCALTIMESTAMP", "NOW", + "POSITION", "SUBSTR", "SUBSTRING", "SYSDATE", "TRIM", "UTC_DATE", "UTC_TIME", + "UTC_TIMESTAMP", "ACCOUNT", "ACTION", "AFTER", "AGGREGATE", "ALGORITHM", + "ANY", "AT", "AUTHORS", "AUTOCOMMIT", "AUTOEXTEND_SIZE", "AUTO_INCREMENT", + "AVG_ROW_LENGTH", "BEGIN", "BINLOG", "BIT", "BLOCK", "BOOL", "BOOLEAN", + "BTREE", "CACHE", "CASCADED", "CHAIN", "CHANGED", "CHANNEL", "CHECKSUM", + "PAGE_CHECKSUM", "CIPHER", "CLASS_ORIGIN", "CLIENT", "CLOSE", "CLUSTERING", + "COALESCE", "CODE", "COLUMNS", "COLUMN_FORMAT", "COLUMN_NAME", "COMMENT", + "COMMIT", "COMPACT", "COMPLETION", "COMPRESSED", "COMPRESSION", "CONCURRENT", + "CONNECT", "CONNECTION", "CONSISTENT", "CONSTRAINT_CATALOG", "CONSTRAINT_SCHEMA", + "CONSTRAINT_NAME", "CONTAINS", "CONTEXT", "CONTRIBUTORS", "COPY", "CPU", + "CYCLE", "CURSOR_NAME", "DATA", "DATAFILE", "DEALLOCATE", "DEFAULT_AUTH", + "DEFINER", "DELAY_KEY_WRITE", "DES_KEY_FILE", "DIRECTORY", "DISABLE", + "DISCARD", "DISK", "DO", "DUMPFILE", "DUPLICATE", "DYNAMIC", "ENABLE", + "ENCRYPTED", "ENCRYPTION", "ENCRYPTION_KEY_ID", "END", "ENDS", "ENGINE", + "ENGINES", "ERROR", "ERRORS", "ESCAPE", "EVEN", "EVENT", "EVENTS", "EVERY", + "EXCHANGE", "EXCLUSIVE", "EXPIRE", "EXPORT", "EXTENDED", "EXTENT_SIZE", + "FAILED_LOGIN_ATTEMPTS", "FAST", "FAULTS", "FIELDS", "FILE_BLOCK_SIZE", + "FILTER", "FIRST", "FIXED", "FLUSH", "FOLLOWING", "FOLLOWS", "FOUND", + "FULL", "FUNCTION", "GENERAL", "GLOBAL", "GRANTS", "GROUP_REPLICATION", + "HANDLER", "HASH", "HELP", "HISTORY", "HOST", "HOSTS", "IDENTIFIED", + "IGNORE_SERVER_IDS", "IMPORT", "INCREMENT", "INDEXES", "INITIAL_SIZE", + "INPLACE", "INSERT_METHOD", "INSTALL", "INSTANCE", "INSTANT", "INVISIBLE", + "INVOKER", "IO", "IO_THREAD", "IPC", "ISOLATION", "ISSUER", "JSON", "KEY_BLOCK_SIZE", + "LANGUAGE", "LAST", "LEAVES", "LESS", "LEVEL", "LIST", "LOCAL", "LOGFILE", + "LOGS", "MASTER", "MASTER_AUTO_POSITION", "MASTER_CONNECT_RETRY", "MASTER_DELAY", + "MASTER_HEARTBEAT_PERIOD", "MASTER_HOST", "MASTER_LOG_FILE", "MASTER_LOG_POS", + "MASTER_PASSWORD", "MASTER_PORT", "MASTER_RETRY_COUNT", "MASTER_SSL", + "MASTER_SSL_CA", "MASTER_SSL_CAPATH", "MASTER_SSL_CERT", "MASTER_SSL_CIPHER", + "MASTER_SSL_CRL", "MASTER_SSL_CRLPATH", "MASTER_SSL_KEY", "MASTER_TLS_VERSION", + "MASTER_USER", "MAX_CONNECTIONS_PER_HOUR", "MAX_QUERIES_PER_HOUR", "MAX_ROWS", + "MAX_SIZE", "MAX_UPDATES_PER_HOUR", "MAX_USER_CONNECTIONS", "MEDIUM", + "MEMBER", "MERGE", "MESSAGE_TEXT", "MID", "MIGRATE", "MIN_ROWS", "MODE", + "MODIFY", "MUTEX", "MYSQL", "MYSQL_ERRNO", "NAME", "NAMES", "NCHAR", + "NEVER", "NEXT", "NO", "NOCACHE", "NOCOPY", "NOCYCLE", "NOMAXVALUE", + "NOMINVALUE", "NOWAIT", "NODEGROUP", "NONE", "ODBC", "OFFLINE", "OFFSET", + "OF", "OJ", "OLD_PASSWORD", "ONE", "ONLINE", "ONLY", "OPEN", "OPTIMIZER_COSTS", + "OPTIONS", "OWNER", "PACK_KEYS", "PAGE", "PAGE_COMPRESSED", "PAGE_COMPRESSION_LEVEL", + "PARSER", "PARTIAL", "PARTITIONING", "PARTITIONS", "PASSWORD", "PASSWORD_LOCK_TIME", + "PHASE", "PLUGIN", "PLUGIN_DIR", "PLUGINS", "PORT", "PRECEDES", "PRECEDING", + "PREPARE", "PRESERVE", "PREV", "PROCESSLIST", "PROFILE", "PROFILES", + "PROXY", "QUERY", "QUICK", "REBUILD", "RECOVER", "RECURSIVE", "REDO_BUFFER_SIZE", + "REDUNDANT", "RELAY", "RELAY_LOG_FILE", "RELAY_LOG_POS", "RELAYLOG", + "REMOVE", "REORGANIZE", "REPAIR", "REPLICATE_DO_DB", "REPLICATE_DO_TABLE", + "REPLICATE_IGNORE_DB", "REPLICATE_IGNORE_TABLE", "REPLICATE_REWRITE_DB", + "REPLICATE_WILD_DO_TABLE", "REPLICATE_WILD_IGNORE_TABLE", "REPLICATION", + "RESET", "RESTART", "RESUME", "RETURNED_SQLSTATE", "RETURNING", "RETURNS", + "REUSE", "ROLE", "ROLLBACK", "ROLLUP", "ROTATE", "ROW", "ROWS", "ROW_FORMAT", + "RTREE", "SAVEPOINT", "SCHEDULE", "SECURITY", "SEQUENCE", "SERVER", "SESSION", + "SHARE", "SHARED", "SIGNED", "SIMPLE", "SLAVE", "SLOW", "SNAPSHOT", "SOCKET", + "SOME", "SONAME", "SOUNDS", "SOURCE", "SQL_AFTER_GTIDS", "SQL_AFTER_MTS_GAPS", + "SQL_BEFORE_GTIDS", "SQL_BUFFER_RESULT", "SQL_CACHE", "SQL_NO_CACHE", + "SQL_THREAD", "START", "STARTS", "STATS_AUTO_RECALC", "STATS_PERSISTENT", + "STATS_SAMPLE_PAGES", "STATUS", "STOP", "STORAGE", "STORED", "STRING", + "SUBCLASS_ORIGIN", "SUBJECT", "SUBPARTITION", "SUBPARTITIONS", "SUSPEND", + "SWAPS", "SWITCHES", "TABLE_NAME", "TABLESPACE", "TABLE_TYPE", "TEMPORARY", + "TEMPTABLE", "THAN", "TRADITIONAL", "TRANSACTION", "TRANSACTIONAL", "TRIGGERS", + "TRUNCATE", "UNBOUNDED", "UNDEFINED", "UNDOFILE", "UNDO_BUFFER_SIZE", + "UNINSTALL", "UNKNOWN", "UNTIL", "UPGRADE", "USER", "USE_FRM", "USER_RESOURCES", + "VALIDATION", "VALUE", "VARIABLES", "VIEW", "VIRTUAL", "VISIBLE", "WAIT", + "WARNINGS", "WINDOW", "WITHOUT", "WORK", "WRAPPER", "X509", "XA", "XML", + "YES", "EUR", "USA", "JIS", "ISO", "INTERNAL", "QUARTER", "MONTH", "DAY", + "HOUR", "MINUTE", "WEEK", "SECOND", "MICROSECOND", "ADMIN", "APPLICATION_PASSWORD_ADMIN", + "AUDIT_ABORT_EXEMPT", "AUDIT_ADMIN", "AUTHENTICATION_POLICY_ADMIN", "BACKUP_ADMIN", + "BINLOG_ADMIN", "BINLOG_ENCRYPTION_ADMIN", "CLONE_ADMIN", "CONNECTION_ADMIN", + "ENCRYPTION_KEY_ADMIN", "EXECUTE", "FILE", "FIREWALL_ADMIN", "FIREWALL_EXEMPT", + "FIREWALL_USER", "FLUSH_OPTIMIZER_COSTS", "FLUSH_STATUS", "FLUSH_TABLES", + "FLUSH_USER_RESOURCES", "GROUP_REPLICATION_ADMIN", "INNODB_REDO_LOG_ARCHIVE", + "INNODB_REDO_LOG_ENABLE", "INVOKE", "LAMBDA", "NDB_STORED_USER", "PASSWORDLESS_USER_ADMIN", + "PERSIST_RO_VARIABLES_ADMIN", "PRIVILEGES", "PROCESS", "RELOAD", "REPLICATION_APPLIER", + "REPLICATION_SLAVE_ADMIN", "RESOURCE_GROUP_ADMIN", "RESOURCE_GROUP_USER", + "ROLE_ADMIN", "ROUTINE", "S3", "SERVICE_CONNECTION_ADMIN", "SESSION_VARIABLES_ADMIN", + "SET_USER_ID", "SHOW_ROUTINE", "SHUTDOWN", "SUPER", "SYSTEM_VARIABLES_ADMIN", + "TABLES", "TABLE_ENCRYPTION_ADMIN", "VERSION_TOKEN_ADMIN", "XA_RECOVER_ADMIN", + "ARMSCII8", "ASCII", "BIG5", "CP1250", "CP1251", "CP1256", "CP1257", + "CP850", "CP852", "CP866", "CP932", "DEC8", "EUCJPMS", "EUCKR", "GB18030", + "GB2312", "GBK", "GEOSTD8", "GREEK", "HEBREW", "HP8", "KEYBCS2", "KOI8R", + "KOI8U", "LATIN1", "LATIN2", "LATIN5", "LATIN7", "MACCE", "MACROMAN", + "SJIS", "SWE7", "TIS620", "UCS2", "UJIS", "UTF16", "UTF16LE", "UTF32", + "UTF8", "UTF8MB3", "UTF8MB4", "ARCHIVE", "BLACKHOLE", "CSV", "FEDERATED", + "INNODB", "MEMORY", "MRG_MYISAM", "MYISAM", "NDB", "NDBCLUSTER", "PERFORMANCE_SCHEMA", + "TOKUDB", "REPEATABLE", "COMMITTED", "UNCOMMITTED", "SERIALIZABLE", "GEOMETRYCOLLECTION", + "GEOMCOLLECTION", "GEOMETRY", "LINESTRING", "MULTILINESTRING", "MULTIPOINT", + "MULTIPOLYGON", "POINT", "POLYGON", "ABS", "ACOS", "ADDDATE", "ADDTIME", + "AES_DECRYPT", "AES_ENCRYPT", "AREA", "ASBINARY", "ASIN", "ASTEXT", "ASWKB", + "ASWKT", "ASYMMETRIC_DECRYPT", "ASYMMETRIC_DERIVE", "ASYMMETRIC_ENCRYPT", + "ASYMMETRIC_SIGN", "ASYMMETRIC_VERIFY", "ATAN", "ATAN2", "BENCHMARK", + "BIN", "BIT_COUNT", "BIT_LENGTH", "BUFFER", "CATALOG_NAME", "CEIL", "CEILING", + "CENTROID", "CHARACTER_LENGTH", "CHARSET", "CHAR_LENGTH", "COERCIBILITY", + "COLLATION", "COMPRESS", "CONCAT", "CONCAT_WS", "CONNECTION_ID", "CONV", + "CONVERT_TZ", "COS", "COT", "CRC32", "CREATE_ASYMMETRIC_PRIV_KEY", "CREATE_ASYMMETRIC_PUB_KEY", + "CREATE_DH_PARAMETERS", "CREATE_DIGEST", "CROSSES", "DATEDIFF", "DATE_FORMAT", + "DAYNAME", "DAYOFMONTH", "DAYOFWEEK", "DAYOFYEAR", "DECODE", "DEGREES", + "DES_DECRYPT", "DES_ENCRYPT", "DIMENSION", "DISJOINT", "ELT", "ENCODE", + "ENCRYPT", "ENDPOINT", "ENGINE_ATTRIBUTE", "ENVELOPE", "EQUALS", "EXP", + "EXPORT_SET", "EXTERIORRING", "EXTRACTVALUE", "FIELD", "FIND_IN_SET", + "FLOOR", "FORMAT", "FOUND_ROWS", "FROM_BASE64", "FROM_DAYS", "FROM_UNIXTIME", + "GEOMCOLLFROMTEXT", "GEOMCOLLFROMWKB", "GEOMETRYCOLLECTIONFROMTEXT", + "GEOMETRYCOLLECTIONFROMWKB", "GEOMETRYFROMTEXT", "GEOMETRYFROMWKB", "GEOMETRYN", + "GEOMETRYTYPE", "GEOMFROMTEXT", "GEOMFROMWKB", "GET_FORMAT", "GET_LOCK", + "GLENGTH", "GREATEST", "GTID_SUBSET", "GTID_SUBTRACT", "HEX", "IFNULL", + "INET6_ATON", "INET6_NTOA", "INET_ATON", "INET_NTOA", "INSTR", "INTERIORRINGN", + "INTERSECTS", "ISCLOSED", "ISEMPTY", "ISNULL", "ISSIMPLE", "IS_FREE_LOCK", + "IS_IPV4", "IS_IPV4_COMPAT", "IS_IPV4_MAPPED", "IS_IPV6", "IS_USED_LOCK", + "LAST_INSERT_ID", "LCASE", "LEAST", "LENGTH", "LINEFROMTEXT", "LINEFROMWKB", + "LINESTRINGFROMTEXT", "LINESTRINGFROMWKB", "LN", "LOAD_FILE", "LOCATE", + "LOG", "LOG10", "LOG2", "LOWER", "LPAD", "LTRIM", "MAKEDATE", "MAKETIME", + "MAKE_SET", "MASTER_POS_WAIT", "MBRCONTAINS", "MBRDISJOINT", "MBREQUAL", + "MBRINTERSECTS", "MBROVERLAPS", "MBRTOUCHES", "MBRWITHIN", "MD5", "MLINEFROMTEXT", + "MLINEFROMWKB", "MONTHNAME", "MPOINTFROMTEXT", "MPOINTFROMWKB", "MPOLYFROMTEXT", + "MPOLYFROMWKB", "MULTILINESTRINGFROMTEXT", "MULTILINESTRINGFROMWKB", + "MULTIPOINTFROMTEXT", "MULTIPOINTFROMWKB", "MULTIPOLYGONFROMTEXT", "MULTIPOLYGONFROMWKB", + "NAME_CONST", "NULLIF", "NUMGEOMETRIES", "NUMINTERIORRINGS", "NUMPOINTS", + "OCT", "OCTET_LENGTH", "ORD", "OVERLAPS", "PERIOD_ADD", "PERIOD_DIFF", + "PI", "POINTFROMTEXT", "POINTFROMWKB", "POINTN", "POLYFROMTEXT", "POLYFROMWKB", + "POLYGONFROMTEXT", "POLYGONFROMWKB", "POW", "POWER", "QUOTE", "RADIANS", + "RAND", "RANDOM", "RANDOM_BYTES", "RELEASE_LOCK", "REVERSE", "ROUND", + "ROW_COUNT", "RPAD", "RTRIM", "SEC_TO_TIME", "SECONDARY_ENGINE_ATTRIBUTE", + "SESSION_USER", "SHA", "SHA1", "SHA2", "SCHEMA_NAME", "SIGN", "SIN", + "SLEEP", "SOUNDEX", "SQL_THREAD_WAIT_AFTER_GTIDS", "SQRT", "SRID", "STARTPOINT", + "STRCMP", "STR_TO_DATE", "ST_AREA", "ST_ASBINARY", "ST_ASTEXT", "ST_ASWKB", + "ST_ASWKT", "ST_BUFFER", "ST_CENTROID", "ST_CONTAINS", "ST_CROSSES", + "ST_DIFFERENCE", "ST_DIMENSION", "ST_DISJOINT", "ST_DISTANCE", "ST_ENDPOINT", + "ST_ENVELOPE", "ST_EQUALS", "ST_EXTERIORRING", "ST_GEOMCOLLFROMTEXT", + "ST_GEOMCOLLFROMTXT", "ST_GEOMCOLLFROMWKB", "ST_GEOMETRYCOLLECTIONFROMTEXT", + "ST_GEOMETRYCOLLECTIONFROMWKB", "ST_GEOMETRYFROMTEXT", "ST_GEOMETRYFROMWKB", + "ST_GEOMETRYN", "ST_GEOMETRYTYPE", "ST_GEOMFROMTEXT", "ST_GEOMFROMWKB", + "ST_INTERIORRINGN", "ST_INTERSECTION", "ST_INTERSECTS", "ST_ISCLOSED", + "ST_ISEMPTY", "ST_ISSIMPLE", "ST_LINEFROMTEXT", "ST_LINEFROMWKB", "ST_LINESTRINGFROMTEXT", + "ST_LINESTRINGFROMWKB", "ST_NUMGEOMETRIES", "ST_NUMINTERIORRING", "ST_NUMINTERIORRINGS", + "ST_NUMPOINTS", "ST_OVERLAPS", "ST_POINTFROMTEXT", "ST_POINTFROMWKB", + "ST_POINTN", "ST_POLYFROMTEXT", "ST_POLYFROMWKB", "ST_POLYGONFROMTEXT", + "ST_POLYGONFROMWKB", "ST_SRID", "ST_STARTPOINT", "ST_SYMDIFFERENCE", + "ST_TOUCHES", "ST_UNION", "ST_WITHIN", "ST_X", "ST_Y", "SUBDATE", "SUBSTRING_INDEX", + "SUBTIME", "SYSTEM_USER", "TAN", "TIMEDIFF", "TIMESTAMPADD", "TIMESTAMPDIFF", + "TIME_FORMAT", "TIME_TO_SEC", "TOUCHES", "TO_BASE64", "TO_DAYS", "TO_SECONDS", + "TP_CONNECTION_ADMIN", "UCASE", "UNCOMPRESS", "UNCOMPRESSED_LENGTH", + "UNHEX", "UNIX_TIMESTAMP", "UPDATEXML", "UPPER", "UUID", "UUID_SHORT", + "VALIDATE_PASSWORD_STRENGTH", "VERSION", "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS", + "WEEKDAY", "WEEKOFYEAR", "WEIGHT_STRING", "WITHIN", "YEARWEEK", "Y_FUNCTION", + "X_FUNCTION", "VAR_ASSIGN", "PLUS_ASSIGN", "MINUS_ASSIGN", "MULT_ASSIGN", + "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", + "STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "DIV", "MOD", "EQUAL_SYMBOL", + "GREATER_SYMBOL", "LESS_SYMBOL", "EXCLAMATION_SYMBOL", "BIT_NOT_OP", + "BIT_OR_OP", "BIT_AND_OP", "BIT_XOR_OP", "DOT", "LR_BRACKET", "RR_BRACKET", + "COMMA", "SEMI", "AT_SIGN", "ZERO_DECIMAL", "ONE_DECIMAL", "TWO_DECIMAL", + "SINGLE_QUOTE_SYMB", "DOUBLE_QUOTE_SYMB", "REVERSE_QUOTE_SYMB", "COLON_SYMB", + "CHARSET_REVERSE_QOUTE_STRING", "FILESIZE_LITERAL", "START_NATIONAL_STRING_LITERAL", + "STRING_LITERAL", "DECIMAL_LITERAL", "HEXADECIMAL_LITERAL", "REAL_LITERAL", + "NULL_SPEC_LITERAL", "BIT_STRING", "STRING_CHARSET_NAME", "DOT_ID", "ID", + "REVERSE_QUOTE_ID", "HOST_IP_ADDRESS", "LOCAL_ID", "GLOBAL_ID", "ERROR_RECONGNIGION" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public MySqlLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "MySqlLexer.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + private static final String _serializedATNSegment0 = + "\u0004\u0000\u048a\u3593\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002"+ + "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002"+ + "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002"+ + "\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002"+ + "\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e"+ + "\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011"+ + "\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014"+ + "\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017"+ + "\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a"+ + "\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d"+ + "\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!"+ + "\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002"+ + "&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002"+ + "+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u0002"+ + "0\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u0002"+ + "5\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0002"+ + ":\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002"+ + "?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002"+ + "D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002"+ + "I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002"+ + "N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002"+ + "S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002"+ + "X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002"+ + "]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002"+ + "b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002"+ + "g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002"+ + "l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002"+ + "q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002"+ + "v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002"+ + "{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f"+ + "\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082"+ + "\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085"+ + "\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088"+ + "\u0002\u0089\u0007\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b"+ + "\u0002\u008c\u0007\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e"+ + "\u0002\u008f\u0007\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091"+ + "\u0002\u0092\u0007\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094"+ + "\u0002\u0095\u0007\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097"+ + "\u0002\u0098\u0007\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a"+ + "\u0002\u009b\u0007\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d"+ + "\u0002\u009e\u0007\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0"+ + "\u0002\u00a1\u0007\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3"+ + "\u0002\u00a4\u0007\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6"+ + "\u0002\u00a7\u0007\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9"+ + "\u0002\u00aa\u0007\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac"+ + "\u0002\u00ad\u0007\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af"+ + "\u0002\u00b0\u0007\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2"+ + "\u0002\u00b3\u0007\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5"+ + "\u0002\u00b6\u0007\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8"+ + "\u0002\u00b9\u0007\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb"+ + "\u0002\u00bc\u0007\u00bc\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be"+ + "\u0002\u00bf\u0007\u00bf\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1"+ + "\u0002\u00c2\u0007\u00c2\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4"+ + "\u0002\u00c5\u0007\u00c5\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7"+ + "\u0002\u00c8\u0007\u00c8\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca"+ + "\u0002\u00cb\u0007\u00cb\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd"+ + "\u0002\u00ce\u0007\u00ce\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0"+ + "\u0002\u00d1\u0007\u00d1\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3"+ + "\u0002\u00d4\u0007\u00d4\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6"+ + "\u0002\u00d7\u0007\u00d7\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9"+ + "\u0002\u00da\u0007\u00da\u0002\u00db\u0007\u00db\u0002\u00dc\u0007\u00dc"+ + "\u0002\u00dd\u0007\u00dd\u0002\u00de\u0007\u00de\u0002\u00df\u0007\u00df"+ + "\u0002\u00e0\u0007\u00e0\u0002\u00e1\u0007\u00e1\u0002\u00e2\u0007\u00e2"+ + "\u0002\u00e3\u0007\u00e3\u0002\u00e4\u0007\u00e4\u0002\u00e5\u0007\u00e5"+ + "\u0002\u00e6\u0007\u00e6\u0002\u00e7\u0007\u00e7\u0002\u00e8\u0007\u00e8"+ + "\u0002\u00e9\u0007\u00e9\u0002\u00ea\u0007\u00ea\u0002\u00eb\u0007\u00eb"+ + "\u0002\u00ec\u0007\u00ec\u0002\u00ed\u0007\u00ed\u0002\u00ee\u0007\u00ee"+ + "\u0002\u00ef\u0007\u00ef\u0002\u00f0\u0007\u00f0\u0002\u00f1\u0007\u00f1"+ + "\u0002\u00f2\u0007\u00f2\u0002\u00f3\u0007\u00f3\u0002\u00f4\u0007\u00f4"+ + "\u0002\u00f5\u0007\u00f5\u0002\u00f6\u0007\u00f6\u0002\u00f7\u0007\u00f7"+ + "\u0002\u00f8\u0007\u00f8\u0002\u00f9\u0007\u00f9\u0002\u00fa\u0007\u00fa"+ + "\u0002\u00fb\u0007\u00fb\u0002\u00fc\u0007\u00fc\u0002\u00fd\u0007\u00fd"+ + "\u0002\u00fe\u0007\u00fe\u0002\u00ff\u0007\u00ff\u0002\u0100\u0007\u0100"+ + "\u0002\u0101\u0007\u0101\u0002\u0102\u0007\u0102\u0002\u0103\u0007\u0103"+ + "\u0002\u0104\u0007\u0104\u0002\u0105\u0007\u0105\u0002\u0106\u0007\u0106"+ + "\u0002\u0107\u0007\u0107\u0002\u0108\u0007\u0108\u0002\u0109\u0007\u0109"+ + "\u0002\u010a\u0007\u010a\u0002\u010b\u0007\u010b\u0002\u010c\u0007\u010c"+ + "\u0002\u010d\u0007\u010d\u0002\u010e\u0007\u010e\u0002\u010f\u0007\u010f"+ + "\u0002\u0110\u0007\u0110\u0002\u0111\u0007\u0111\u0002\u0112\u0007\u0112"+ + "\u0002\u0113\u0007\u0113\u0002\u0114\u0007\u0114\u0002\u0115\u0007\u0115"+ + "\u0002\u0116\u0007\u0116\u0002\u0117\u0007\u0117\u0002\u0118\u0007\u0118"+ + "\u0002\u0119\u0007\u0119\u0002\u011a\u0007\u011a\u0002\u011b\u0007\u011b"+ + "\u0002\u011c\u0007\u011c\u0002\u011d\u0007\u011d\u0002\u011e\u0007\u011e"+ + "\u0002\u011f\u0007\u011f\u0002\u0120\u0007\u0120\u0002\u0121\u0007\u0121"+ + "\u0002\u0122\u0007\u0122\u0002\u0123\u0007\u0123\u0002\u0124\u0007\u0124"+ + "\u0002\u0125\u0007\u0125\u0002\u0126\u0007\u0126\u0002\u0127\u0007\u0127"+ + "\u0002\u0128\u0007\u0128\u0002\u0129\u0007\u0129\u0002\u012a\u0007\u012a"+ + "\u0002\u012b\u0007\u012b\u0002\u012c\u0007\u012c\u0002\u012d\u0007\u012d"+ + "\u0002\u012e\u0007\u012e\u0002\u012f\u0007\u012f\u0002\u0130\u0007\u0130"+ + "\u0002\u0131\u0007\u0131\u0002\u0132\u0007\u0132\u0002\u0133\u0007\u0133"+ + "\u0002\u0134\u0007\u0134\u0002\u0135\u0007\u0135\u0002\u0136\u0007\u0136"+ + "\u0002\u0137\u0007\u0137\u0002\u0138\u0007\u0138\u0002\u0139\u0007\u0139"+ + "\u0002\u013a\u0007\u013a\u0002\u013b\u0007\u013b\u0002\u013c\u0007\u013c"+ + "\u0002\u013d\u0007\u013d\u0002\u013e\u0007\u013e\u0002\u013f\u0007\u013f"+ + "\u0002\u0140\u0007\u0140\u0002\u0141\u0007\u0141\u0002\u0142\u0007\u0142"+ + "\u0002\u0143\u0007\u0143\u0002\u0144\u0007\u0144\u0002\u0145\u0007\u0145"+ + "\u0002\u0146\u0007\u0146\u0002\u0147\u0007\u0147\u0002\u0148\u0007\u0148"+ + "\u0002\u0149\u0007\u0149\u0002\u014a\u0007\u014a\u0002\u014b\u0007\u014b"+ + "\u0002\u014c\u0007\u014c\u0002\u014d\u0007\u014d\u0002\u014e\u0007\u014e"+ + "\u0002\u014f\u0007\u014f\u0002\u0150\u0007\u0150\u0002\u0151\u0007\u0151"+ + "\u0002\u0152\u0007\u0152\u0002\u0153\u0007\u0153\u0002\u0154\u0007\u0154"+ + "\u0002\u0155\u0007\u0155\u0002\u0156\u0007\u0156\u0002\u0157\u0007\u0157"+ + "\u0002\u0158\u0007\u0158\u0002\u0159\u0007\u0159\u0002\u015a\u0007\u015a"+ + "\u0002\u015b\u0007\u015b\u0002\u015c\u0007\u015c\u0002\u015d\u0007\u015d"+ + "\u0002\u015e\u0007\u015e\u0002\u015f\u0007\u015f\u0002\u0160\u0007\u0160"+ + "\u0002\u0161\u0007\u0161\u0002\u0162\u0007\u0162\u0002\u0163\u0007\u0163"+ + "\u0002\u0164\u0007\u0164\u0002\u0165\u0007\u0165\u0002\u0166\u0007\u0166"+ + "\u0002\u0167\u0007\u0167\u0002\u0168\u0007\u0168\u0002\u0169\u0007\u0169"+ + "\u0002\u016a\u0007\u016a\u0002\u016b\u0007\u016b\u0002\u016c\u0007\u016c"+ + "\u0002\u016d\u0007\u016d\u0002\u016e\u0007\u016e\u0002\u016f\u0007\u016f"+ + "\u0002\u0170\u0007\u0170\u0002\u0171\u0007\u0171\u0002\u0172\u0007\u0172"+ + "\u0002\u0173\u0007\u0173\u0002\u0174\u0007\u0174\u0002\u0175\u0007\u0175"+ + "\u0002\u0176\u0007\u0176\u0002\u0177\u0007\u0177\u0002\u0178\u0007\u0178"+ + "\u0002\u0179\u0007\u0179\u0002\u017a\u0007\u017a\u0002\u017b\u0007\u017b"+ + "\u0002\u017c\u0007\u017c\u0002\u017d\u0007\u017d\u0002\u017e\u0007\u017e"+ + "\u0002\u017f\u0007\u017f\u0002\u0180\u0007\u0180\u0002\u0181\u0007\u0181"+ + "\u0002\u0182\u0007\u0182\u0002\u0183\u0007\u0183\u0002\u0184\u0007\u0184"+ + "\u0002\u0185\u0007\u0185\u0002\u0186\u0007\u0186\u0002\u0187\u0007\u0187"+ + "\u0002\u0188\u0007\u0188\u0002\u0189\u0007\u0189\u0002\u018a\u0007\u018a"+ + "\u0002\u018b\u0007\u018b\u0002\u018c\u0007\u018c\u0002\u018d\u0007\u018d"+ + "\u0002\u018e\u0007\u018e\u0002\u018f\u0007\u018f\u0002\u0190\u0007\u0190"+ + "\u0002\u0191\u0007\u0191\u0002\u0192\u0007\u0192\u0002\u0193\u0007\u0193"+ + "\u0002\u0194\u0007\u0194\u0002\u0195\u0007\u0195\u0002\u0196\u0007\u0196"+ + "\u0002\u0197\u0007\u0197\u0002\u0198\u0007\u0198\u0002\u0199\u0007\u0199"+ + "\u0002\u019a\u0007\u019a\u0002\u019b\u0007\u019b\u0002\u019c\u0007\u019c"+ + "\u0002\u019d\u0007\u019d\u0002\u019e\u0007\u019e\u0002\u019f\u0007\u019f"+ + "\u0002\u01a0\u0007\u01a0\u0002\u01a1\u0007\u01a1\u0002\u01a2\u0007\u01a2"+ + "\u0002\u01a3\u0007\u01a3\u0002\u01a4\u0007\u01a4\u0002\u01a5\u0007\u01a5"+ + "\u0002\u01a6\u0007\u01a6\u0002\u01a7\u0007\u01a7\u0002\u01a8\u0007\u01a8"+ + "\u0002\u01a9\u0007\u01a9\u0002\u01aa\u0007\u01aa\u0002\u01ab\u0007\u01ab"+ + "\u0002\u01ac\u0007\u01ac\u0002\u01ad\u0007\u01ad\u0002\u01ae\u0007\u01ae"+ + "\u0002\u01af\u0007\u01af\u0002\u01b0\u0007\u01b0\u0002\u01b1\u0007\u01b1"+ + "\u0002\u01b2\u0007\u01b2\u0002\u01b3\u0007\u01b3\u0002\u01b4\u0007\u01b4"+ + "\u0002\u01b5\u0007\u01b5\u0002\u01b6\u0007\u01b6\u0002\u01b7\u0007\u01b7"+ + "\u0002\u01b8\u0007\u01b8\u0002\u01b9\u0007\u01b9\u0002\u01ba\u0007\u01ba"+ + "\u0002\u01bb\u0007\u01bb\u0002\u01bc\u0007\u01bc\u0002\u01bd\u0007\u01bd"+ + "\u0002\u01be\u0007\u01be\u0002\u01bf\u0007\u01bf\u0002\u01c0\u0007\u01c0"+ + "\u0002\u01c1\u0007\u01c1\u0002\u01c2\u0007\u01c2\u0002\u01c3\u0007\u01c3"+ + "\u0002\u01c4\u0007\u01c4\u0002\u01c5\u0007\u01c5\u0002\u01c6\u0007\u01c6"+ + "\u0002\u01c7\u0007\u01c7\u0002\u01c8\u0007\u01c8\u0002\u01c9\u0007\u01c9"+ + "\u0002\u01ca\u0007\u01ca\u0002\u01cb\u0007\u01cb\u0002\u01cc\u0007\u01cc"+ + "\u0002\u01cd\u0007\u01cd\u0002\u01ce\u0007\u01ce\u0002\u01cf\u0007\u01cf"+ + "\u0002\u01d0\u0007\u01d0\u0002\u01d1\u0007\u01d1\u0002\u01d2\u0007\u01d2"+ + "\u0002\u01d3\u0007\u01d3\u0002\u01d4\u0007\u01d4\u0002\u01d5\u0007\u01d5"+ + "\u0002\u01d6\u0007\u01d6\u0002\u01d7\u0007\u01d7\u0002\u01d8\u0007\u01d8"+ + "\u0002\u01d9\u0007\u01d9\u0002\u01da\u0007\u01da\u0002\u01db\u0007\u01db"+ + "\u0002\u01dc\u0007\u01dc\u0002\u01dd\u0007\u01dd\u0002\u01de\u0007\u01de"+ + "\u0002\u01df\u0007\u01df\u0002\u01e0\u0007\u01e0\u0002\u01e1\u0007\u01e1"+ + "\u0002\u01e2\u0007\u01e2\u0002\u01e3\u0007\u01e3\u0002\u01e4\u0007\u01e4"+ + "\u0002\u01e5\u0007\u01e5\u0002\u01e6\u0007\u01e6\u0002\u01e7\u0007\u01e7"+ + "\u0002\u01e8\u0007\u01e8\u0002\u01e9\u0007\u01e9\u0002\u01ea\u0007\u01ea"+ + "\u0002\u01eb\u0007\u01eb\u0002\u01ec\u0007\u01ec\u0002\u01ed\u0007\u01ed"+ + "\u0002\u01ee\u0007\u01ee\u0002\u01ef\u0007\u01ef\u0002\u01f0\u0007\u01f0"+ + "\u0002\u01f1\u0007\u01f1\u0002\u01f2\u0007\u01f2\u0002\u01f3\u0007\u01f3"+ + "\u0002\u01f4\u0007\u01f4\u0002\u01f5\u0007\u01f5\u0002\u01f6\u0007\u01f6"+ + "\u0002\u01f7\u0007\u01f7\u0002\u01f8\u0007\u01f8\u0002\u01f9\u0007\u01f9"+ + "\u0002\u01fa\u0007\u01fa\u0002\u01fb\u0007\u01fb\u0002\u01fc\u0007\u01fc"+ + "\u0002\u01fd\u0007\u01fd\u0002\u01fe\u0007\u01fe\u0002\u01ff\u0007\u01ff"+ + "\u0002\u0200\u0007\u0200\u0002\u0201\u0007\u0201\u0002\u0202\u0007\u0202"+ + "\u0002\u0203\u0007\u0203\u0002\u0204\u0007\u0204\u0002\u0205\u0007\u0205"+ + "\u0002\u0206\u0007\u0206\u0002\u0207\u0007\u0207\u0002\u0208\u0007\u0208"+ + "\u0002\u0209\u0007\u0209\u0002\u020a\u0007\u020a\u0002\u020b\u0007\u020b"+ + "\u0002\u020c\u0007\u020c\u0002\u020d\u0007\u020d\u0002\u020e\u0007\u020e"+ + "\u0002\u020f\u0007\u020f\u0002\u0210\u0007\u0210\u0002\u0211\u0007\u0211"+ + "\u0002\u0212\u0007\u0212\u0002\u0213\u0007\u0213\u0002\u0214\u0007\u0214"+ + "\u0002\u0215\u0007\u0215\u0002\u0216\u0007\u0216\u0002\u0217\u0007\u0217"+ + "\u0002\u0218\u0007\u0218\u0002\u0219\u0007\u0219\u0002\u021a\u0007\u021a"+ + "\u0002\u021b\u0007\u021b\u0002\u021c\u0007\u021c\u0002\u021d\u0007\u021d"+ + "\u0002\u021e\u0007\u021e\u0002\u021f\u0007\u021f\u0002\u0220\u0007\u0220"+ + "\u0002\u0221\u0007\u0221\u0002\u0222\u0007\u0222\u0002\u0223\u0007\u0223"+ + "\u0002\u0224\u0007\u0224\u0002\u0225\u0007\u0225\u0002\u0226\u0007\u0226"+ + "\u0002\u0227\u0007\u0227\u0002\u0228\u0007\u0228\u0002\u0229\u0007\u0229"+ + "\u0002\u022a\u0007\u022a\u0002\u022b\u0007\u022b\u0002\u022c\u0007\u022c"+ + "\u0002\u022d\u0007\u022d\u0002\u022e\u0007\u022e\u0002\u022f\u0007\u022f"+ + "\u0002\u0230\u0007\u0230\u0002\u0231\u0007\u0231\u0002\u0232\u0007\u0232"+ + "\u0002\u0233\u0007\u0233\u0002\u0234\u0007\u0234\u0002\u0235\u0007\u0235"+ + "\u0002\u0236\u0007\u0236\u0002\u0237\u0007\u0237\u0002\u0238\u0007\u0238"+ + "\u0002\u0239\u0007\u0239\u0002\u023a\u0007\u023a\u0002\u023b\u0007\u023b"+ + "\u0002\u023c\u0007\u023c\u0002\u023d\u0007\u023d\u0002\u023e\u0007\u023e"+ + "\u0002\u023f\u0007\u023f\u0002\u0240\u0007\u0240\u0002\u0241\u0007\u0241"+ + "\u0002\u0242\u0007\u0242\u0002\u0243\u0007\u0243\u0002\u0244\u0007\u0244"+ + "\u0002\u0245\u0007\u0245\u0002\u0246\u0007\u0246\u0002\u0247\u0007\u0247"+ + "\u0002\u0248\u0007\u0248\u0002\u0249\u0007\u0249\u0002\u024a\u0007\u024a"+ + "\u0002\u024b\u0007\u024b\u0002\u024c\u0007\u024c\u0002\u024d\u0007\u024d"+ + "\u0002\u024e\u0007\u024e\u0002\u024f\u0007\u024f\u0002\u0250\u0007\u0250"+ + "\u0002\u0251\u0007\u0251\u0002\u0252\u0007\u0252\u0002\u0253\u0007\u0253"+ + "\u0002\u0254\u0007\u0254\u0002\u0255\u0007\u0255\u0002\u0256\u0007\u0256"+ + "\u0002\u0257\u0007\u0257\u0002\u0258\u0007\u0258\u0002\u0259\u0007\u0259"+ + "\u0002\u025a\u0007\u025a\u0002\u025b\u0007\u025b\u0002\u025c\u0007\u025c"+ + "\u0002\u025d\u0007\u025d\u0002\u025e\u0007\u025e\u0002\u025f\u0007\u025f"+ + "\u0002\u0260\u0007\u0260\u0002\u0261\u0007\u0261\u0002\u0262\u0007\u0262"+ + "\u0002\u0263\u0007\u0263\u0002\u0264\u0007\u0264\u0002\u0265\u0007\u0265"+ + "\u0002\u0266\u0007\u0266\u0002\u0267\u0007\u0267\u0002\u0268\u0007\u0268"+ + "\u0002\u0269\u0007\u0269\u0002\u026a\u0007\u026a\u0002\u026b\u0007\u026b"+ + "\u0002\u026c\u0007\u026c\u0002\u026d\u0007\u026d\u0002\u026e\u0007\u026e"+ + "\u0002\u026f\u0007\u026f\u0002\u0270\u0007\u0270\u0002\u0271\u0007\u0271"+ + "\u0002\u0272\u0007\u0272\u0002\u0273\u0007\u0273\u0002\u0274\u0007\u0274"+ + "\u0002\u0275\u0007\u0275\u0002\u0276\u0007\u0276\u0002\u0277\u0007\u0277"+ + "\u0002\u0278\u0007\u0278\u0002\u0279\u0007\u0279\u0002\u027a\u0007\u027a"+ + "\u0002\u027b\u0007\u027b\u0002\u027c\u0007\u027c\u0002\u027d\u0007\u027d"+ + "\u0002\u027e\u0007\u027e\u0002\u027f\u0007\u027f\u0002\u0280\u0007\u0280"+ + "\u0002\u0281\u0007\u0281\u0002\u0282\u0007\u0282\u0002\u0283\u0007\u0283"+ + "\u0002\u0284\u0007\u0284\u0002\u0285\u0007\u0285\u0002\u0286\u0007\u0286"+ + "\u0002\u0287\u0007\u0287\u0002\u0288\u0007\u0288\u0002\u0289\u0007\u0289"+ + "\u0002\u028a\u0007\u028a\u0002\u028b\u0007\u028b\u0002\u028c\u0007\u028c"+ + "\u0002\u028d\u0007\u028d\u0002\u028e\u0007\u028e\u0002\u028f\u0007\u028f"+ + "\u0002\u0290\u0007\u0290\u0002\u0291\u0007\u0291\u0002\u0292\u0007\u0292"+ + "\u0002\u0293\u0007\u0293\u0002\u0294\u0007\u0294\u0002\u0295\u0007\u0295"+ + "\u0002\u0296\u0007\u0296\u0002\u0297\u0007\u0297\u0002\u0298\u0007\u0298"+ + "\u0002\u0299\u0007\u0299\u0002\u029a\u0007\u029a\u0002\u029b\u0007\u029b"+ + "\u0002\u029c\u0007\u029c\u0002\u029d\u0007\u029d\u0002\u029e\u0007\u029e"+ + "\u0002\u029f\u0007\u029f\u0002\u02a0\u0007\u02a0\u0002\u02a1\u0007\u02a1"+ + "\u0002\u02a2\u0007\u02a2\u0002\u02a3\u0007\u02a3\u0002\u02a4\u0007\u02a4"+ + "\u0002\u02a5\u0007\u02a5\u0002\u02a6\u0007\u02a6\u0002\u02a7\u0007\u02a7"+ + "\u0002\u02a8\u0007\u02a8\u0002\u02a9\u0007\u02a9\u0002\u02aa\u0007\u02aa"+ + "\u0002\u02ab\u0007\u02ab\u0002\u02ac\u0007\u02ac\u0002\u02ad\u0007\u02ad"+ + "\u0002\u02ae\u0007\u02ae\u0002\u02af\u0007\u02af\u0002\u02b0\u0007\u02b0"+ + "\u0002\u02b1\u0007\u02b1\u0002\u02b2\u0007\u02b2\u0002\u02b3\u0007\u02b3"+ + "\u0002\u02b4\u0007\u02b4\u0002\u02b5\u0007\u02b5\u0002\u02b6\u0007\u02b6"+ + "\u0002\u02b7\u0007\u02b7\u0002\u02b8\u0007\u02b8\u0002\u02b9\u0007\u02b9"+ + "\u0002\u02ba\u0007\u02ba\u0002\u02bb\u0007\u02bb\u0002\u02bc\u0007\u02bc"+ + "\u0002\u02bd\u0007\u02bd\u0002\u02be\u0007\u02be\u0002\u02bf\u0007\u02bf"+ + "\u0002\u02c0\u0007\u02c0\u0002\u02c1\u0007\u02c1\u0002\u02c2\u0007\u02c2"+ + "\u0002\u02c3\u0007\u02c3\u0002\u02c4\u0007\u02c4\u0002\u02c5\u0007\u02c5"+ + "\u0002\u02c6\u0007\u02c6\u0002\u02c7\u0007\u02c7\u0002\u02c8\u0007\u02c8"+ + "\u0002\u02c9\u0007\u02c9\u0002\u02ca\u0007\u02ca\u0002\u02cb\u0007\u02cb"+ + "\u0002\u02cc\u0007\u02cc\u0002\u02cd\u0007\u02cd\u0002\u02ce\u0007\u02ce"+ + "\u0002\u02cf\u0007\u02cf\u0002\u02d0\u0007\u02d0\u0002\u02d1\u0007\u02d1"+ + "\u0002\u02d2\u0007\u02d2\u0002\u02d3\u0007\u02d3\u0002\u02d4\u0007\u02d4"+ + "\u0002\u02d5\u0007\u02d5\u0002\u02d6\u0007\u02d6\u0002\u02d7\u0007\u02d7"+ + "\u0002\u02d8\u0007\u02d8\u0002\u02d9\u0007\u02d9\u0002\u02da\u0007\u02da"+ + "\u0002\u02db\u0007\u02db\u0002\u02dc\u0007\u02dc\u0002\u02dd\u0007\u02dd"+ + "\u0002\u02de\u0007\u02de\u0002\u02df\u0007\u02df\u0002\u02e0\u0007\u02e0"+ + "\u0002\u02e1\u0007\u02e1\u0002\u02e2\u0007\u02e2\u0002\u02e3\u0007\u02e3"+ + "\u0002\u02e4\u0007\u02e4\u0002\u02e5\u0007\u02e5\u0002\u02e6\u0007\u02e6"+ + "\u0002\u02e7\u0007\u02e7\u0002\u02e8\u0007\u02e8\u0002\u02e9\u0007\u02e9"+ + "\u0002\u02ea\u0007\u02ea\u0002\u02eb\u0007\u02eb\u0002\u02ec\u0007\u02ec"+ + "\u0002\u02ed\u0007\u02ed\u0002\u02ee\u0007\u02ee\u0002\u02ef\u0007\u02ef"+ + "\u0002\u02f0\u0007\u02f0\u0002\u02f1\u0007\u02f1\u0002\u02f2\u0007\u02f2"+ + "\u0002\u02f3\u0007\u02f3\u0002\u02f4\u0007\u02f4\u0002\u02f5\u0007\u02f5"+ + "\u0002\u02f6\u0007\u02f6\u0002\u02f7\u0007\u02f7\u0002\u02f8\u0007\u02f8"+ + "\u0002\u02f9\u0007\u02f9\u0002\u02fa\u0007\u02fa\u0002\u02fb\u0007\u02fb"+ + "\u0002\u02fc\u0007\u02fc\u0002\u02fd\u0007\u02fd\u0002\u02fe\u0007\u02fe"+ + "\u0002\u02ff\u0007\u02ff\u0002\u0300\u0007\u0300\u0002\u0301\u0007\u0301"+ + "\u0002\u0302\u0007\u0302\u0002\u0303\u0007\u0303\u0002\u0304\u0007\u0304"+ + "\u0002\u0305\u0007\u0305\u0002\u0306\u0007\u0306\u0002\u0307\u0007\u0307"+ + "\u0002\u0308\u0007\u0308\u0002\u0309\u0007\u0309\u0002\u030a\u0007\u030a"+ + "\u0002\u030b\u0007\u030b\u0002\u030c\u0007\u030c\u0002\u030d\u0007\u030d"+ + "\u0002\u030e\u0007\u030e\u0002\u030f\u0007\u030f\u0002\u0310\u0007\u0310"+ + "\u0002\u0311\u0007\u0311\u0002\u0312\u0007\u0312\u0002\u0313\u0007\u0313"+ + "\u0002\u0314\u0007\u0314\u0002\u0315\u0007\u0315\u0002\u0316\u0007\u0316"+ + "\u0002\u0317\u0007\u0317\u0002\u0318\u0007\u0318\u0002\u0319\u0007\u0319"+ + "\u0002\u031a\u0007\u031a\u0002\u031b\u0007\u031b\u0002\u031c\u0007\u031c"+ + "\u0002\u031d\u0007\u031d\u0002\u031e\u0007\u031e\u0002\u031f\u0007\u031f"+ + "\u0002\u0320\u0007\u0320\u0002\u0321\u0007\u0321\u0002\u0322\u0007\u0322"+ + "\u0002\u0323\u0007\u0323\u0002\u0324\u0007\u0324\u0002\u0325\u0007\u0325"+ + "\u0002\u0326\u0007\u0326\u0002\u0327\u0007\u0327\u0002\u0328\u0007\u0328"+ + "\u0002\u0329\u0007\u0329\u0002\u032a\u0007\u032a\u0002\u032b\u0007\u032b"+ + "\u0002\u032c\u0007\u032c\u0002\u032d\u0007\u032d\u0002\u032e\u0007\u032e"+ + "\u0002\u032f\u0007\u032f\u0002\u0330\u0007\u0330\u0002\u0331\u0007\u0331"+ + "\u0002\u0332\u0007\u0332\u0002\u0333\u0007\u0333\u0002\u0334\u0007\u0334"+ + "\u0002\u0335\u0007\u0335\u0002\u0336\u0007\u0336\u0002\u0337\u0007\u0337"+ + "\u0002\u0338\u0007\u0338\u0002\u0339\u0007\u0339\u0002\u033a\u0007\u033a"+ + "\u0002\u033b\u0007\u033b\u0002\u033c\u0007\u033c\u0002\u033d\u0007\u033d"+ + "\u0002\u033e\u0007\u033e\u0002\u033f\u0007\u033f\u0002\u0340\u0007\u0340"+ + "\u0002\u0341\u0007\u0341\u0002\u0342\u0007\u0342\u0002\u0343\u0007\u0343"+ + "\u0002\u0344\u0007\u0344\u0002\u0345\u0007\u0345\u0002\u0346\u0007\u0346"+ + "\u0002\u0347\u0007\u0347\u0002\u0348\u0007\u0348\u0002\u0349\u0007\u0349"+ + "\u0002\u034a\u0007\u034a\u0002\u034b\u0007\u034b\u0002\u034c\u0007\u034c"+ + "\u0002\u034d\u0007\u034d\u0002\u034e\u0007\u034e\u0002\u034f\u0007\u034f"+ + "\u0002\u0350\u0007\u0350\u0002\u0351\u0007\u0351\u0002\u0352\u0007\u0352"+ + "\u0002\u0353\u0007\u0353\u0002\u0354\u0007\u0354\u0002\u0355\u0007\u0355"+ + "\u0002\u0356\u0007\u0356\u0002\u0357\u0007\u0357\u0002\u0358\u0007\u0358"+ + "\u0002\u0359\u0007\u0359\u0002\u035a\u0007\u035a\u0002\u035b\u0007\u035b"+ + "\u0002\u035c\u0007\u035c\u0002\u035d\u0007\u035d\u0002\u035e\u0007\u035e"+ + "\u0002\u035f\u0007\u035f\u0002\u0360\u0007\u0360\u0002\u0361\u0007\u0361"+ + "\u0002\u0362\u0007\u0362\u0002\u0363\u0007\u0363\u0002\u0364\u0007\u0364"+ + "\u0002\u0365\u0007\u0365\u0002\u0366\u0007\u0366\u0002\u0367\u0007\u0367"+ + "\u0002\u0368\u0007\u0368\u0002\u0369\u0007\u0369\u0002\u036a\u0007\u036a"+ + "\u0002\u036b\u0007\u036b\u0002\u036c\u0007\u036c\u0002\u036d\u0007\u036d"+ + "\u0002\u036e\u0007\u036e\u0002\u036f\u0007\u036f\u0002\u0370\u0007\u0370"+ + "\u0002\u0371\u0007\u0371\u0002\u0372\u0007\u0372\u0002\u0373\u0007\u0373"+ + "\u0002\u0374\u0007\u0374\u0002\u0375\u0007\u0375\u0002\u0376\u0007\u0376"+ + "\u0002\u0377\u0007\u0377\u0002\u0378\u0007\u0378\u0002\u0379\u0007\u0379"+ + "\u0002\u037a\u0007\u037a\u0002\u037b\u0007\u037b\u0002\u037c\u0007\u037c"+ + "\u0002\u037d\u0007\u037d\u0002\u037e\u0007\u037e\u0002\u037f\u0007\u037f"+ + "\u0002\u0380\u0007\u0380\u0002\u0381\u0007\u0381\u0002\u0382\u0007\u0382"+ + "\u0002\u0383\u0007\u0383\u0002\u0384\u0007\u0384\u0002\u0385\u0007\u0385"+ + "\u0002\u0386\u0007\u0386\u0002\u0387\u0007\u0387\u0002\u0388\u0007\u0388"+ + "\u0002\u0389\u0007\u0389\u0002\u038a\u0007\u038a\u0002\u038b\u0007\u038b"+ + "\u0002\u038c\u0007\u038c\u0002\u038d\u0007\u038d\u0002\u038e\u0007\u038e"+ + "\u0002\u038f\u0007\u038f\u0002\u0390\u0007\u0390\u0002\u0391\u0007\u0391"+ + "\u0002\u0392\u0007\u0392\u0002\u0393\u0007\u0393\u0002\u0394\u0007\u0394"+ + "\u0002\u0395\u0007\u0395\u0002\u0396\u0007\u0396\u0002\u0397\u0007\u0397"+ + "\u0002\u0398\u0007\u0398\u0002\u0399\u0007\u0399\u0002\u039a\u0007\u039a"+ + "\u0002\u039b\u0007\u039b\u0002\u039c\u0007\u039c\u0002\u039d\u0007\u039d"+ + "\u0002\u039e\u0007\u039e\u0002\u039f\u0007\u039f\u0002\u03a0\u0007\u03a0"+ + "\u0002\u03a1\u0007\u03a1\u0002\u03a2\u0007\u03a2\u0002\u03a3\u0007\u03a3"+ + "\u0002\u03a4\u0007\u03a4\u0002\u03a5\u0007\u03a5\u0002\u03a6\u0007\u03a6"+ + "\u0002\u03a7\u0007\u03a7\u0002\u03a8\u0007\u03a8\u0002\u03a9\u0007\u03a9"+ + "\u0002\u03aa\u0007\u03aa\u0002\u03ab\u0007\u03ab\u0002\u03ac\u0007\u03ac"+ + "\u0002\u03ad\u0007\u03ad\u0002\u03ae\u0007\u03ae\u0002\u03af\u0007\u03af"+ + "\u0002\u03b0\u0007\u03b0\u0002\u03b1\u0007\u03b1\u0002\u03b2\u0007\u03b2"+ + "\u0002\u03b3\u0007\u03b3\u0002\u03b4\u0007\u03b4\u0002\u03b5\u0007\u03b5"+ + "\u0002\u03b6\u0007\u03b6\u0002\u03b7\u0007\u03b7\u0002\u03b8\u0007\u03b8"+ + "\u0002\u03b9\u0007\u03b9\u0002\u03ba\u0007\u03ba\u0002\u03bb\u0007\u03bb"+ + "\u0002\u03bc\u0007\u03bc\u0002\u03bd\u0007\u03bd\u0002\u03be\u0007\u03be"+ + "\u0002\u03bf\u0007\u03bf\u0002\u03c0\u0007\u03c0\u0002\u03c1\u0007\u03c1"+ + "\u0002\u03c2\u0007\u03c2\u0002\u03c3\u0007\u03c3\u0002\u03c4\u0007\u03c4"+ + "\u0002\u03c5\u0007\u03c5\u0002\u03c6\u0007\u03c6\u0002\u03c7\u0007\u03c7"+ + "\u0002\u03c8\u0007\u03c8\u0002\u03c9\u0007\u03c9\u0002\u03ca\u0007\u03ca"+ + "\u0002\u03cb\u0007\u03cb\u0002\u03cc\u0007\u03cc\u0002\u03cd\u0007\u03cd"+ + "\u0002\u03ce\u0007\u03ce\u0002\u03cf\u0007\u03cf\u0002\u03d0\u0007\u03d0"+ + "\u0002\u03d1\u0007\u03d1\u0002\u03d2\u0007\u03d2\u0002\u03d3\u0007\u03d3"+ + "\u0002\u03d4\u0007\u03d4\u0002\u03d5\u0007\u03d5\u0002\u03d6\u0007\u03d6"+ + "\u0002\u03d7\u0007\u03d7\u0002\u03d8\u0007\u03d8\u0002\u03d9\u0007\u03d9"+ + "\u0002\u03da\u0007\u03da\u0002\u03db\u0007\u03db\u0002\u03dc\u0007\u03dc"+ + "\u0002\u03dd\u0007\u03dd\u0002\u03de\u0007\u03de\u0002\u03df\u0007\u03df"+ + "\u0002\u03e0\u0007\u03e0\u0002\u03e1\u0007\u03e1\u0002\u03e2\u0007\u03e2"+ + "\u0002\u03e3\u0007\u03e3\u0002\u03e4\u0007\u03e4\u0002\u03e5\u0007\u03e5"+ + "\u0002\u03e6\u0007\u03e6\u0002\u03e7\u0007\u03e7\u0002\u03e8\u0007\u03e8"+ + "\u0002\u03e9\u0007\u03e9\u0002\u03ea\u0007\u03ea\u0002\u03eb\u0007\u03eb"+ + "\u0002\u03ec\u0007\u03ec\u0002\u03ed\u0007\u03ed\u0002\u03ee\u0007\u03ee"+ + "\u0002\u03ef\u0007\u03ef\u0002\u03f0\u0007\u03f0\u0002\u03f1\u0007\u03f1"+ + "\u0002\u03f2\u0007\u03f2\u0002\u03f3\u0007\u03f3\u0002\u03f4\u0007\u03f4"+ + "\u0002\u03f5\u0007\u03f5\u0002\u03f6\u0007\u03f6\u0002\u03f7\u0007\u03f7"+ + "\u0002\u03f8\u0007\u03f8\u0002\u03f9\u0007\u03f9\u0002\u03fa\u0007\u03fa"+ + "\u0002\u03fb\u0007\u03fb\u0002\u03fc\u0007\u03fc\u0002\u03fd\u0007\u03fd"+ + "\u0002\u03fe\u0007\u03fe\u0002\u03ff\u0007\u03ff\u0002\u0400\u0007\u0400"+ + "\u0002\u0401\u0007\u0401\u0002\u0402\u0007\u0402\u0002\u0403\u0007\u0403"+ + "\u0002\u0404\u0007\u0404\u0002\u0405\u0007\u0405\u0002\u0406\u0007\u0406"+ + "\u0002\u0407\u0007\u0407\u0002\u0408\u0007\u0408\u0002\u0409\u0007\u0409"+ + "\u0002\u040a\u0007\u040a\u0002\u040b\u0007\u040b\u0002\u040c\u0007\u040c"+ + "\u0002\u040d\u0007\u040d\u0002\u040e\u0007\u040e\u0002\u040f\u0007\u040f"+ + "\u0002\u0410\u0007\u0410\u0002\u0411\u0007\u0411\u0002\u0412\u0007\u0412"+ + "\u0002\u0413\u0007\u0413\u0002\u0414\u0007\u0414\u0002\u0415\u0007\u0415"+ + "\u0002\u0416\u0007\u0416\u0002\u0417\u0007\u0417\u0002\u0418\u0007\u0418"+ + "\u0002\u0419\u0007\u0419\u0002\u041a\u0007\u041a\u0002\u041b\u0007\u041b"+ + "\u0002\u041c\u0007\u041c\u0002\u041d\u0007\u041d\u0002\u041e\u0007\u041e"+ + "\u0002\u041f\u0007\u041f\u0002\u0420\u0007\u0420\u0002\u0421\u0007\u0421"+ + "\u0002\u0422\u0007\u0422\u0002\u0423\u0007\u0423\u0002\u0424\u0007\u0424"+ + "\u0002\u0425\u0007\u0425\u0002\u0426\u0007\u0426\u0002\u0427\u0007\u0427"+ + "\u0002\u0428\u0007\u0428\u0002\u0429\u0007\u0429\u0002\u042a\u0007\u042a"+ + "\u0002\u042b\u0007\u042b\u0002\u042c\u0007\u042c\u0002\u042d\u0007\u042d"+ + "\u0002\u042e\u0007\u042e\u0002\u042f\u0007\u042f\u0002\u0430\u0007\u0430"+ + "\u0002\u0431\u0007\u0431\u0002\u0432\u0007\u0432\u0002\u0433\u0007\u0433"+ + "\u0002\u0434\u0007\u0434\u0002\u0435\u0007\u0435\u0002\u0436\u0007\u0436"+ + "\u0002\u0437\u0007\u0437\u0002\u0438\u0007\u0438\u0002\u0439\u0007\u0439"+ + "\u0002\u043a\u0007\u043a\u0002\u043b\u0007\u043b\u0002\u043c\u0007\u043c"+ + "\u0002\u043d\u0007\u043d\u0002\u043e\u0007\u043e\u0002\u043f\u0007\u043f"+ + "\u0002\u0440\u0007\u0440\u0002\u0441\u0007\u0441\u0002\u0442\u0007\u0442"+ + "\u0002\u0443\u0007\u0443\u0002\u0444\u0007\u0444\u0002\u0445\u0007\u0445"+ + "\u0002\u0446\u0007\u0446\u0002\u0447\u0007\u0447\u0002\u0448\u0007\u0448"+ + "\u0002\u0449\u0007\u0449\u0002\u044a\u0007\u044a\u0002\u044b\u0007\u044b"+ + "\u0002\u044c\u0007\u044c\u0002\u044d\u0007\u044d\u0002\u044e\u0007\u044e"+ + "\u0002\u044f\u0007\u044f\u0002\u0450\u0007\u0450\u0002\u0451\u0007\u0451"+ + "\u0002\u0452\u0007\u0452\u0002\u0453\u0007\u0453\u0002\u0454\u0007\u0454"+ + "\u0002\u0455\u0007\u0455\u0002\u0456\u0007\u0456\u0002\u0457\u0007\u0457"+ + "\u0002\u0458\u0007\u0458\u0002\u0459\u0007\u0459\u0002\u045a\u0007\u045a"+ + "\u0002\u045b\u0007\u045b\u0002\u045c\u0007\u045c\u0002\u045d\u0007\u045d"+ + "\u0002\u045e\u0007\u045e\u0002\u045f\u0007\u045f\u0002\u0460\u0007\u0460"+ + "\u0002\u0461\u0007\u0461\u0002\u0462\u0007\u0462\u0002\u0463\u0007\u0463"+ + "\u0002\u0464\u0007\u0464\u0002\u0465\u0007\u0465\u0002\u0466\u0007\u0466"+ + "\u0002\u0467\u0007\u0467\u0002\u0468\u0007\u0468\u0002\u0469\u0007\u0469"+ + "\u0002\u046a\u0007\u046a\u0002\u046b\u0007\u046b\u0002\u046c\u0007\u046c"+ + "\u0002\u046d\u0007\u046d\u0002\u046e\u0007\u046e\u0002\u046f\u0007\u046f"+ + "\u0002\u0470\u0007\u0470\u0002\u0471\u0007\u0471\u0002\u0472\u0007\u0472"+ + "\u0002\u0473\u0007\u0473\u0002\u0474\u0007\u0474\u0002\u0475\u0007\u0475"+ + "\u0002\u0476\u0007\u0476\u0002\u0477\u0007\u0477\u0002\u0478\u0007\u0478"+ + "\u0002\u0479\u0007\u0479\u0002\u047a\u0007\u047a\u0002\u047b\u0007\u047b"+ + "\u0002\u047c\u0007\u047c\u0002\u047d\u0007\u047d\u0002\u047e\u0007\u047e"+ + "\u0002\u047f\u0007\u047f\u0002\u0480\u0007\u0480\u0002\u0481\u0007\u0481"+ + "\u0002\u0482\u0007\u0482\u0002\u0483\u0007\u0483\u0002\u0484\u0007\u0484"+ + "\u0002\u0485\u0007\u0485\u0002\u0486\u0007\u0486\u0002\u0487\u0007\u0487"+ + "\u0002\u0488\u0007\u0488\u0002\u0489\u0007\u0489\u0002\u048a\u0007\u048a"+ + "\u0002\u048b\u0007\u048b\u0002\u048c\u0007\u048c\u0002\u048d\u0007\u048d"+ + "\u0002\u048e\u0007\u048e\u0002\u048f\u0007\u048f\u0002\u0490\u0007\u0490"+ + "\u0002\u0491\u0007\u0491\u0002\u0492\u0007\u0492\u0002\u0493\u0007\u0493"+ + "\u0002\u0494\u0007\u0494\u0001\u0000\u0001\u0000\u0001\u0000\u0005\u0000"+ + "\u092f\b\u0000\n\u0000\f\u0000\u0932\t\u0000\u0001\u0000\u0001\u0000\u0001"+ + "\u0001\u0004\u0001\u0937\b\u0001\u000b\u0001\f\u0001\u0938\u0001\u0001"+ + "\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+ + "\u0004\u0002\u0942\b\u0002\u000b\u0002\f\u0002\u0943\u0001\u0002\u0001"+ + "\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001"+ + "\u0003\u0001\u0003\u0005\u0003\u094f\b\u0003\n\u0003\f\u0003\u0952\t\u0003"+ + "\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0005\u0004\u095d\b\u0004\n\u0004"+ + "\f\u0004\u0960\t\u0004\u0001\u0004\u0003\u0004\u0963\b\u0004\u0001\u0004"+ + "\u0005\u0004\u0966\b\u0004\n\u0004\f\u0004\u0969\t\u0004\u0001\u0004\u0003"+ + "\u0004\u096c\b\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u0970\b\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u0976\b\u0004"+ + "\u0001\u0004\u0001\u0004\u0003\u0004\u097a\b\u0004\u0003\u0004\u097c\b"+ + "\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+ + "\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0007\u0001"+ + "\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b"+ + "\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001"+ + "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+ + "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ + "\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e"+ + "\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e"+ + "\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+ + "\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0010"+ + "\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0011"+ + "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012"+ + "\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012"+ + "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014"+ + "\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015"+ + "\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016"+ + "\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017"+ + "\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+ + "\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019"+ + "\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+ + "\u0001\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ + "\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b"+ + "\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c"+ + "\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d"+ + "\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d"+ + "\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+ + "\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+ + "\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f"+ + "\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 "+ + "\u0001 \u0001 \u0001 \u0001 \u0001 \u0001!\u0001!\u0001!\u0001!\u0001"+ + "!\u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001"+ + "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001$\u0001"+ + "$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001"+ + "$\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001"+ + "%\u0001%\u0001%\u0001%\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ + "&\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ + "\'\u0001(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001"+ + "(\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001*\u0001"+ + "*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001+\u0001+\u0001+\u0001"+ + "+\u0001+\u0001+\u0001+\u0001+\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ + ",\u0001,\u0001-\u0001-\u0001-\u0001-\u0001-\u0001.\u0001.\u0001.\u0001"+ + ".\u0001.\u0001.\u0001.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u0001"+ + "/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ + "0\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u0001"+ + "0\u00010\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u0001"+ + "1\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u0001"+ + "2\u00012\u00012\u00013\u00013\u00013\u00013\u00013\u00014\u00014\u0001"+ + "4\u00014\u00014\u00015\u00015\u00015\u00015\u00015\u00016\u00016\u0001"+ + "6\u00016\u00016\u00016\u00016\u00017\u00017\u00017\u00017\u00017\u0001"+ + "7\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001:\u0001"+ + ":\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001;\u0001;\u0001;\u0001"+ + ";\u0001;\u0001;\u0001;\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001"+ + "<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001>\u0001"+ + ">\u0001>\u0001>\u0001>\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001"+ + "@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001A\u0001A\u0001A\u0001A\u0001"+ + "B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001C\u0001C\u0001C\u0001C\u0001"+ + "C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001D\u0001E\u0001"+ + "E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001F\u0001F\u0001"+ + "F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001G\u0001G\u0001"+ + "G\u0001G\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001"+ + "I\u0001I\u0001I\u0001I\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001"+ + "K\u0001K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001L\u0001L\u0001L\u0001"+ + "L\u0001L\u0001L\u0001L\u0001L\u0001M\u0001M\u0001M\u0001N\u0001N\u0001"+ + "N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001O\u0001O\u0001O\u0001O\u0001"+ + "O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ + "Q\u0001Q\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001T\u0001T\u0001"+ + "T\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001V\u0001V\u0001"+ + "V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001W\u0001W\u0001W\u0001"+ + "W\u0001W\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ + "Y\u0001Y\u0001Y\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001[\u0001[\u0001"+ + "[\u0001[\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001]\u0001]\u0001]"+ + "\u0001]\u0001]\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001`\u0001"+ + "`\u0001`\u0001`\u0001`\u0001`\u0001a\u0001a\u0001a\u0001a\u0001a\u0001"+ + "b\u0001b\u0001b\u0001b\u0001b\u0001c\u0001c\u0001c\u0001c\u0001c\u0001"+ + "c\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001e\u0001e\u0001"+ + "e\u0001e\u0001e\u0001e\u0001f\u0001f\u0001f\u0001f\u0001f\u0001g\u0001"+ + "g\u0001g\u0001g\u0001g\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001"+ + "h\u0001i\u0001i\u0001i\u0001i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001k\u0001"+ + "k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001"+ + "k\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001"+ + "l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001"+ + "l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001"+ + "l\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001n\u0001n\u0001n\u0001"+ + "n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001o\u0001o\u0001o\u0001o\u0001"+ + "o\u0001o\u0001o\u0001o\u0001o\u0001p\u0001p\u0001p\u0001p\u0001p\u0001"+ + "p\u0001p\u0001p\u0001p\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001"+ + "q\u0001q\u0001r\u0001r\u0001r\u0001r\u0001s\u0001s\u0001s\u0001s\u0001"+ + "s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001"+ + "s\u0001s\u0001s\u0001s\u0001s\u0001t\u0001t\u0001t\u0001t\u0001t\u0001"+ + "u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001"+ + "w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001x\u0001"+ + "x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001y\u0001y\u0001y\u0001y\u0001"+ + "y\u0001y\u0001y\u0001y\u0001y\u0001z\u0001z\u0001z\u0001z\u0001z\u0001"+ + "z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001{\u0001{\u0001{\u0001|\u0001"+ + "|\u0001|\u0001|\u0001|\u0001|\u0001}\u0001}\u0001}\u0001}\u0001~\u0001"+ + "~\u0001~\u0001~\u0001~\u0001~\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u0080\u0001"+ + "\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0081\u0001\u0081\u0001"+ + "\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001"+ + "\u0081\u0001\u0081\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001"+ + "\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0083\u0001\u0083\u0001"+ + "\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001"+ + "\u0083\u0001\u0083\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001"+ + "\u0084\u0001\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001"+ + "\u0085\u0001\u0085\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001"+ + "\u0086\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001"+ + "\u0087\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001"+ + "\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001"+ + "\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001"+ + "\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001"+ + "\u008a\u0001\u008a\u0001\u008a\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+ + "\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008c\u0001\u008c\u0001"+ + "\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008d\u0001"+ + "\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001"+ + "\u008d\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001"+ + "\u008e\u0001\u008e\u0001\u008e\u0001\u008f\u0001\u008f\u0001\u008f\u0001"+ + "\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001"+ + "\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+ + "\u0090\u0001\u0090\u0001\u0090\u0001\u0091\u0001\u0091\u0001\u0091\u0001"+ + "\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0092\u0001\u0092\u0001"+ + "\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0093\u0001"+ + "\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001"+ + "\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001"+ + "\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001"+ + "\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001"+ + "\u0096\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001"+ + "\u0097\u0001\u0097\u0001\u0097\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+ + "\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0099\u0001\u0099\u0001"+ + "\u0099\u0001\u0099\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001"+ + "\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001"+ + "\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009c\u0001"+ + "\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001"+ + "\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009e\u0001"+ + "\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001"+ + "\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001"+ + "\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001"+ + "\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001"+ + "\u009f\u0001\u009f\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001"+ + "\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+ + "\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+ + "\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001"+ + "\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a3\u0001\u00a3\u0001"+ + "\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001"+ + "\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001"+ + "\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001"+ + "\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001"+ + "\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001"+ + "\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001"+ + "\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001"+ + "\u00a5\u0001\u00a5\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+ + "\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+ + "\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+ + "\u00a6\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a8\u0001"+ + "\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001"+ + "\u00a8\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001"+ + "\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00aa\u0001\u00aa\u0001"+ + "\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001"+ + "\u00aa\u0001\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ + "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ + "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ac\u0001\u00ac\u0001"+ + "\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ad\u0001\u00ad\u0001"+ + "\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+ + "\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001"+ + "\u00ae\u0001\u00ae\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00b0\u0001"+ + "\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001"+ + "\u00b0\u0001\u00b0\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001"+ + "\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b2\u0001\u00b2\u0001"+ + "\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001"+ + "\u00b3\u0001\u00b3\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001"+ + "\u00b4\u0001\u00b4\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001"+ + "\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001"+ + "\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b7\u0001\u00b7\u0001"+ + "\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001"+ + "\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001"+ + "\u00b8\u0001\u00b8\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001"+ + "\u00b9\u0001\u00b9\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001"+ + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001"+ + "\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001"+ + "\u00bc\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001"+ + "\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001"+ + "\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001"+ + "\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c1\u0001"+ + "\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c2\u0001"+ + "\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001"+ + "\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001"+ + "\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001"+ + "\u00c4\u0001\u00c4\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001"+ + "\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c6\u0001"+ + "\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001"+ + "\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001"+ + "\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001"+ + "\u00c7\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c9\u0001"+ + "\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00ca\u0001\u00ca\u0001"+ + "\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001"+ + "\u00cb\u0001\u00cb\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001"+ + "\u00cc\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001"+ + "\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001"+ + "\u00ce\u0001\u00ce\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001"+ + "\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001"+ + "\u00d0\u0001\u00d0\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001"+ + "\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001"+ + "\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001"+ + "\u00d2\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001"+ + "\u00d3\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+ + "\u00d4\u0001\u00d4\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001"+ + "\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001"+ + "\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d7\u0001"+ + "\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d9\u0001"+ + "\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00da\u0001\u00da\u0001"+ + "\u00da\u0001\u00da\u0001\u00da\u0001\u00db\u0001\u00db\u0001\u00db\u0001"+ + "\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001"+ + "\u00db\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ + "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dd\u0001\u00dd\u0001"+ + "\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00de\u0001\u00de\u0001\u00de\u0001"+ + "\u00de\u0001\u00de\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df\u0001"+ + "\u00df\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00e0\u0001\u00e0\u0001"+ + "\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001"+ + "\u00e0\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001"+ + "\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e2\u0001\u00e2\u0001"+ + "\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e3\u0001"+ + "\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001"+ + "\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001"+ + "\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e6\u0001"+ + "\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001"+ + "\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e7\u0001\u00e7\u0001"+ + "\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001"+ + "\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001"+ + "\u00ea\u0001\u00ea\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001"+ + "\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001"+ + "\u00eb\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001"+ + "\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ed\u0001\u00ed\u0001"+ + "\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001"+ + "\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ef\u0001"+ + "\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001"+ + "\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001"+ + "\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f1\u0001"+ + "\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001"+ + "\u00f1\u0001\u00f1\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001"+ + "\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001"+ + "\u00f2\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001"+ + "\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001"+ + "\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001"+ + "\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001"+ + "\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001"+ + "\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001"+ + "\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001"+ + "\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001"+ + "\u00f6\u0001\u00f6\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001"+ + "\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001"+ + "\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001"+ + "\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001"+ + "\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001"+ + "\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001"+ + "\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f9\u0001\u00f9\u0001"+ + "\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001"+ + "\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001"+ + "\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001"+ + "\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001"+ + "\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001"+ + "\u00fa\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001"+ + "\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001"+ + "\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001"+ + "\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001"+ + "\u00fc\u0001\u00fc\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001"+ + "\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001"+ + "\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001"+ + "\u00fd\u0001\u00fd\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001"+ + "\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001"+ + "\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001"+ + "\u00fe\u0001\u00fe\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001"+ + "\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001"+ + "\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u0100\u0001\u0100\u0001"+ + "\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001"+ + "\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001"+ + "\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0101\u0001"+ + "\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001"+ + "\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0102\u0001\u0102\u0001"+ + "\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001"+ + "\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0103\u0001"+ + "\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001"+ + "\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0104\u0001"+ + "\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0001"+ + "\u0104\u0001\u0104\u0001\u0104\u0001\u0105\u0001\u0105\u0001\u0105\u0001"+ + "\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001"+ + "\u0105\u0001\u0105\u0001\u0105\u0001\u0106\u0001\u0106\u0001\u0106\u0001"+ + "\u0106\u0001\u0106\u0001\u0106\u0001\u0106\u0001\u0106\u0001\u0106\u0001"+ + "\u0106\u0001\u0106\u0001\u0107\u0001\u0107\u0001\u0107\u0001\u0107\u0001"+ + "\u0107\u0001\u0107\u0001\u0107\u0001\u0107\u0001\u0107\u0001\u0107\u0001"+ + "\u0107\u0001\u0107\u0001\u0107\u0001\u0107\u0001\u0107\u0001\u0107\u0001"+ + "\u0107\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001"+ + "\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001"+ + "\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001"+ + "\u0108\u0001\u0108\u0001\u0108\u0001\u0109\u0001\u0109\u0001\u0109\u0001"+ + "\u0109\u0001\u0109\u0001\u0109\u0001\u0109\u0001\u0109\u0001\u0109\u0001"+ + "\u0109\u0001\u0109\u0001\u0109\u0001\u010a\u0001\u010a\u0001\u010a\u0001"+ + "\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001"+ + "\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001"+ + "\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001"+ + "\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001"+ + "\u010b\u0001\u010b\u0001\u010c\u0001\u010c\u0001\u010c\u0001\u010c\u0001"+ + "\u010c\u0001\u010c\u0001\u010c\u0001\u010c\u0001\u010c\u0001\u010c\u0001"+ + "\u010c\u0001\u010c\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001"+ + "\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001"+ + "\u010d\u0001\u010e\u0001\u010e\u0001\u010e\u0001\u010e\u0001\u010e\u0001"+ + "\u010e\u0001\u010e\u0001\u010e\u0001\u010e\u0001\u010e\u0001\u010e\u0001"+ + "\u010e\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u010f\u0001"+ + "\u010f\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u010f\u0001"+ + "\u010f\u0001\u010f\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001"+ + "\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001"+ + "\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001"+ + "\u0110\u0001\u0110\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001"+ + "\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001"+ + "\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001"+ + "\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001"+ + "\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001"+ + "\u0111\u0001\u0111\u0001\u0112\u0001\u0112\u0001\u0112\u0001\u0112\u0001"+ + "\u0112\u0001\u0112\u0001\u0112\u0001\u0112\u0001\u0112\u0001\u0112\u0001"+ + "\u0112\u0001\u0112\u0001\u0113\u0001\u0113\u0001\u0113\u0001\u0113\u0001"+ + "\u0113\u0001\u0113\u0001\u0113\u0001\u0113\u0001\u0113\u0001\u0114\u0001"+ + "\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001"+ + "\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001"+ + "\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0115\u0001"+ + "\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001"+ + "\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001"+ + "\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0116\u0001"+ + "\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0001"+ + "\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0117\u0001\u0117\u0001"+ + "\u0117\u0001\u0117\u0001\u0117\u0001\u0117\u0001\u0117\u0001\u0117\u0001"+ + "\u0117\u0001\u0117\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001"+ + "\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001"+ + "\u0118\u0001\u0118\u0001\u0118\u0001\u0119\u0001\u0119\u0001\u0119\u0001"+ + "\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001"+ + "\u0119\u0001\u0119\u0001\u011a\u0001\u011a\u0001\u011a\u0001\u011a\u0001"+ + "\u011a\u0001\u011a\u0001\u011a\u0001\u011a\u0001\u011a\u0001\u011a\u0001"+ + "\u011a\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b\u0001"+ + "\u011b\u0001\u011b\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001"+ + "\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001"+ + "\u011c\u0001\u011d\u0001\u011d\u0001\u011d\u0001\u011d\u0001\u011d\u0001"+ + "\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001\u011f\u0001\u011f\u0001"+ + "\u011f\u0001\u011f\u0001\u011f\u0001\u011f\u0001\u011f\u0001\u011f\u0001"+ + "\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001"+ + "\u0120\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0001"+ + "\u0121\u0001\u0121\u0001\u0121\u0001\u0122\u0001\u0122\u0001\u0122\u0001"+ + "\u0122\u0001\u0122\u0001\u0122\u0001\u0123\u0001\u0123\u0001\u0123\u0001"+ + "\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001"+ + "\u0123\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001"+ + "\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001"+ + "\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001"+ + "\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001"+ + "\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001"+ + "\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001"+ + "\u0126\u0001\u0127\u0001\u0127\u0001\u0127\u0001\u0127\u0001\u0128\u0001"+ + "\u0128\u0001\u0128\u0001\u0128\u0001\u0128\u0001\u0128\u0001\u0128\u0001"+ + "\u0128\u0001\u0128\u0001\u0128\u0001\u0128\u0001\u0129\u0001\u0129\u0001"+ + "\u0129\u0001\u0129\u0001\u0129\u0001\u012a\u0001\u012a\u0001\u012a\u0001"+ + "\u012a\u0001\u012b\u0001\u012b\u0001\u012b\u0001\u012b\u0001\u012c\u0001"+ + "\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012d\u0001"+ + "\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001"+ + "\u012d\u0001\u012d\u0001\u012d\u0001\u012e\u0001\u012e\u0001\u012e\u0001"+ + "\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001"+ + "\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012f\u0001\u012f\u0001"+ + "\u012f\u0001\u012f\u0001\u012f\u0001\u0130\u0001\u0130\u0001\u0130\u0001"+ + "\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0001"+ + "\u0130\u0001\u0130\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0001"+ + "\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001"+ + "\u0132\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001"+ + "\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001"+ + "\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001"+ + "\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001"+ + "\u0135\u0001\u0135\u0001\u0135\u0001\u0135\u0001\u0136\u0001\u0136\u0001"+ + "\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0001"+ + "\u0137\u0001\u0137\u0001\u0137\u0001\u0137\u0001\u0137\u0001\u0137\u0001"+ + "\u0137\u0001\u0137\u0001\u0137\u0001\u0138\u0001\u0138\u0001\u0138\u0001"+ + "\u0138\u0001\u0138\u0001\u0138\u0001\u0138\u0001\u0138\u0001\u0138\u0001"+ + "\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001"+ + "\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001"+ + "\u0139\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001"+ + "\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001"+ + "\u013a\u0001\u013a\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001"+ + "\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001"+ + "\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001"+ + "\u013b\u0001\u013b\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001"+ + "\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001"+ + "\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001"+ + "\u013d\u0001\u013d\u0001\u013e\u0001\u013e\u0001\u013e\u0001\u013e\u0001"+ + "\u013e\u0001\u013e\u0001\u013e\u0001\u013e\u0001\u013f\u0001\u013f\u0001"+ + "\u013f\u0001\u013f\u0001\u013f\u0001\u013f\u0001\u013f\u0001\u013f\u0001"+ + "\u013f\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001"+ + "\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0141\u0001\u0141\u0001"+ + "\u0141\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0141\u0001"+ + "\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001"+ + "\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001"+ + "\u0142\u0001\u0142\u0001\u0142\u0001\u0143\u0001\u0143\u0001\u0143\u0001"+ + "\u0143\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001"+ + "\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0146\u0001"+ + "\u0146\u0001\u0146\u0001\u0146\u0001\u0146\u0001\u0146\u0001\u0146\u0001"+ + "\u0146\u0001\u0146\u0001\u0146\u0001\u0147\u0001\u0147\u0001\u0147\u0001"+ + "\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0001\u0148\u0001"+ + "\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0149\u0001\u0149\u0001"+ + "\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001"+ + "\u0149\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001"+ + "\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014b\u0001\u014b\u0001"+ + "\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001"+ + "\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001"+ + "\u014c\u0001\u014c\u0001\u014c\u0001\u014c\u0001\u014c\u0001\u014c\u0001"+ + "\u014c\u0001\u014c\u0001\u014d\u0001\u014d\u0001\u014d\u0001\u014d\u0001"+ + "\u014d\u0001\u014d\u0001\u014d\u0001\u014e\u0001\u014e\u0001\u014e\u0001"+ + "\u014e\u0001\u014e\u0001\u014e\u0001\u014f\u0001\u014f\u0001\u014f\u0001"+ + "\u014f\u0001\u014f\u0001\u014f\u0001\u014f\u0001\u014f\u0001\u014f\u0001"+ + "\u014f\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001"+ + "\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0151\u0001"+ + "\u0151\u0001\u0151\u0001\u0151\u0001\u0152\u0001\u0152\u0001\u0152\u0001"+ + "\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001"+ + "\u0153\u0001\u0153\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001"+ + "\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001"+ + "\u0154\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001"+ + "\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001"+ + "\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0156\u0001"+ + "\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0001"+ + "\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0001"+ + "\u0156\u0001\u0156\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001"+ + "\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001"+ + "\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0158\u0001"+ + "\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015b\u0001\u015b\u0001"+ + "\u015b\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015c\u0001\u015c\u0001"+ + "\u015c\u0001\u015c\u0001\u015c\u0001\u015d\u0001\u015d\u0001\u015d\u0001"+ + "\u015d\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015e\u0001"+ + "\u015e\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015f\u0001"+ + "\u015f\u0001\u015f\u0001\u015f\u0001\u015f\u0001\u015f\u0001\u0160\u0001"+ + "\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0001"+ + "\u0160\u0001\u0160\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001"+ + "\u0161\u0001\u0161\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162\u0001"+ + "\u0162\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0163\u0001\u0163\u0001"+ + "\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001"+ + "\u0164\u0001\u0164\u0001\u0164\u0001\u0164\u0001\u0164\u0001\u0164\u0001"+ + "\u0164\u0001\u0164\u0001\u0164\u0001\u0165\u0001\u0165\u0001\u0165\u0001"+ + "\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001"+ + "\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0166\u0001"+ + "\u0166\u0001\u0166\u0001\u0166\u0001\u0166\u0001\u0166\u0001\u0166\u0001"+ + "\u0167\u0001\u0167\u0001\u0167\u0001\u0167\u0001\u0167\u0001\u0167\u0001"+ + "\u0167\u0001\u0167\u0001\u0167\u0001\u0167\u0001\u0167\u0001\u0167\u0001"+ + "\u0167\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168\u0001"+ + "\u0168\u0001\u0168\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001"+ + "\u0169\u0001\u0169\u0001\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001"+ + "\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001"+ + "\u016a\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001"+ + "\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016d\u0001\u016d\u0001\u016d\u0001"+ + "\u016d\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001"+ + "\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001"+ + "\u016f\u0001\u0170\u0001\u0170\u0001\u0170\u0001\u0170\u0001\u0170\u0001"+ + "\u0170\u0001\u0170\u0001\u0170\u0001\u0171\u0001\u0171\u0001\u0171\u0001"+ + "\u0171\u0001\u0171\u0001\u0171\u0001\u0171\u0001\u0172\u0001\u0172\u0001"+ + "\u0172\u0001\u0172\u0001\u0172\u0001\u0172\u0001\u0172\u0001\u0172\u0001"+ + "\u0173\u0001\u0173\u0001\u0173\u0001\u0173\u0001\u0173\u0001\u0173\u0001"+ + "\u0173\u0001\u0173\u0001\u0173\u0001\u0173\u0001\u0173\u0001\u0174\u0001"+ + "\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001"+ + "\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0175\u0001\u0175\u0001"+ + "\u0175\u0001\u0175\u0001\u0175\u0001\u0175\u0001\u0175\u0001\u0175\u0001"+ + "\u0175\u0001\u0175\u0001\u0175\u0001\u0175\u0001\u0176\u0001\u0176\u0001"+ + "\u0176\u0001\u0176\u0001\u0176\u0001\u0176\u0001\u0176\u0001\u0176\u0001"+ + "\u0176\u0001\u0176\u0001\u0176\u0001\u0177\u0001\u0177\u0001\u0177\u0001"+ + "\u0177\u0001\u0177\u0001\u0177\u0001\u0177\u0001\u0177\u0001\u0178\u0001"+ + "\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001"+ + "\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0179\u0001\u0179\u0001"+ + "\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001"+ + "\u0179\u0001\u0179\u0001\u0179\u0001\u017a\u0001\u017a\u0001\u017a\u0001"+ + "\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001"+ + "\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001"+ + "\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017b\u0001\u017b\u0001"+ + "\u017b\u0001\u017b\u0001\u017b\u0001\u017b\u0001\u017b\u0001\u017b\u0001"+ + "\u017b\u0001\u017b\u0001\u017b\u0001\u017b\u0001\u017b\u0001\u017b\u0001"+ + "\u017b\u0001\u017b\u0001\u017b\u0001\u017b\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001"+ + "\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017e\u0001"+ + "\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001"+ + "\u017e\u0001\u017f\u0001\u017f\u0001\u017f\u0001\u017f\u0001\u017f\u0001"+ + "\u017f\u0001\u017f\u0001\u017f\u0001\u017f\u0001\u017f\u0001\u017f\u0001"+ + "\u017f\u0001\u017f\u0001\u0180\u0001\u0180\u0001\u0180\u0001\u0180\u0001"+ + "\u0180\u0001\u0181\u0001\u0181\u0001\u0181\u0001\u0181\u0001\u0182\u0001"+ + "\u0182\u0001\u0182\u0001\u0182\u0001\u0182\u0001\u0182\u0001\u0183\u0001"+ + "\u0183\u0001\u0183\u0001\u0183\u0001\u0183\u0001\u0183\u0001\u0183\u0001"+ + "\u0183\u0001\u0183\u0001\u0183\u0001\u0183\u0001\u0183\u0001\u0184\u0001"+ + "\u0184\u0001\u0184\u0001\u0184\u0001\u0184\u0001\u0185\u0001\u0185\u0001"+ + "\u0185\u0001\u0185\u0001\u0185\u0001\u0185\u0001\u0185\u0001\u0185\u0001"+ + "\u0185\u0001\u0186\u0001\u0186\u0001\u0186\u0001\u0186\u0001\u0186\u0001"+ + "\u0186\u0001\u0186\u0001\u0186\u0001\u0186\u0001\u0186\u0001\u0186\u0001"+ + "\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001"+ + "\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001"+ + "\u0187\u0001\u0188\u0001\u0188\u0001\u0188\u0001\u0188\u0001\u0188\u0001"+ + "\u0188\u0001\u0188\u0001\u0188\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001"+ + "\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001"+ + "\u018a\u0001\u018a\u0001\u018b\u0001\u018b\u0001\u018b\u0001\u018b\u0001"+ + "\u018b\u0001\u018b\u0001\u018b\u0001\u018b\u0001\u018b\u0001\u018b\u0001"+ + "\u018c\u0001\u018c\u0001\u018c\u0001\u018c\u0001\u018c\u0001\u018c\u0001"+ + "\u018c\u0001\u018c\u0001\u018d\u0001\u018d\u0001\u018d\u0001\u018d\u0001"+ + "\u018d\u0001\u018d\u0001\u018d\u0001\u018d\u0001\u018e\u0001\u018e\u0001"+ + "\u018e\u0001\u018e\u0001\u018e\u0001\u018f\u0001\u018f\u0001\u018f\u0001"+ + "\u0190\u0001\u0190\u0001\u0190\u0001\u0190\u0001\u0190\u0001\u0190\u0001"+ + "\u0190\u0001\u0190\u0001\u0190\u0001\u0191\u0001\u0191\u0001\u0191\u0001"+ + "\u0191\u0001\u0191\u0001\u0191\u0001\u0191\u0001\u0191\u0001\u0191\u0001"+ + "\u0191\u0001\u0192\u0001\u0192\u0001\u0192\u0001\u0192\u0001\u0192\u0001"+ + "\u0192\u0001\u0192\u0001\u0192\u0001\u0193\u0001\u0193\u0001\u0193\u0001"+ + "\u0193\u0001\u0193\u0001\u0193\u0001\u0193\u0001\u0194\u0001\u0194\u0001"+ + "\u0194\u0001\u0194\u0001\u0194\u0001\u0194\u0001\u0194\u0001\u0194\u0001"+ + "\u0194\u0001\u0194\u0001\u0195\u0001\u0195\u0001\u0195\u0001\u0195\u0001"+ + "\u0195\u0001\u0195\u0001\u0195\u0001\u0195\u0001\u0195\u0001\u0195\u0001"+ + "\u0195\u0001\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0001"+ + "\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0001"+ + "\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0001"+ + "\u0196\u0001\u0197\u0001\u0197\u0001\u0197\u0001\u0197\u0001\u0198\u0001"+ + "\u0198\u0001\u0198\u0001\u0198\u0001\u0198\u0001\u0199\u0001\u0199\u0001"+ + "\u0199\u0001\u0199\u0001\u0199\u0001\u0199\u0001\u0199\u0001\u019a\u0001"+ + "\u019a\u0001\u019a\u0001\u019a\u0001\u019a\u0001\u019a\u0001\u019a\u0001"+ + "\u019a\u0001\u019b\u0001\u019b\u0001\u019b\u0001\u019b\u0001\u019b\u0001"+ + "\u019b\u0001\u019c\u0001\u019c\u0001\u019c\u0001\u019c\u0001\u019c\u0001"+ + "\u019c\u0001\u019c\u0001\u019d\u0001\u019d\u0001\u019d\u0001\u019d\u0001"+ + "\u019d\u0001\u019d\u0001\u019d\u0001\u019e\u0001\u019e\u0001\u019e\u0001"+ + "\u019e\u0001\u019e\u0001\u019f\u0001\u019f\u0001\u019f\u0001\u019f\u0001"+ + "\u019f\u0001\u019f\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001"+ + "\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a1\u0001\u01a1\u0001\u01a1\u0001"+ + "\u01a1\u0001\u01a1\u0001\u01a1\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001"+ + "\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a4\u0001\u01a4\u0001"+ + "\u01a4\u0001\u01a4\u0001\u01a4\u0001\u01a4\u0001\u01a4\u0001\u01a5\u0001"+ + "\u01a5\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001"+ + "\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001"+ + "\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001"+ + "\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001"+ + "\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001"+ + "\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001"+ + "\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001"+ + "\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001"+ + "\u01a8\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001"+ + "\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001"+ + "\u01aa\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001"+ + "\u01ab\u0001\u01ab\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001"+ + "\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001"+ + "\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001"+ + "\u01ad\u0001\u01ad\u0001\u01ad\u0001\u01ad\u0001\u01ad\u0001\u01ad\u0001"+ + "\u01ad\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001"+ + "\u01ae\u0001\u01af\u0001\u01af\u0001\u01af\u0001\u01af\u0001\u01af\u0001"+ + "\u01af\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001"+ + "\u01b0\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001"+ + "\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b2\u0001"+ + "\u01b2\u0001\u01b2\u0001\u01b2\u0001\u01b2\u0001\u01b2\u0001\u01b2\u0001"+ + "\u01b2\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001"+ + "\u01b3\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001"+ + "\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001"+ + "\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001"+ + "\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b7\u0001"+ + "\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001"+ + "\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001"+ + "\u01b8\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001"+ + "\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001"+ + "\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001"+ + "\u01b9\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001"+ + "\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01bb\u0001\u01bb\u0001\u01bb\u0001"+ + "\u01bb\u0001\u01bb\u0001\u01bc\u0001\u01bc\u0001\u01bc\u0001\u01bc\u0001"+ + "\u01bc\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001"+ + "\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01be\u0001\u01be\u0001\u01be\u0001"+ + "\u01be\u0001\u01be\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0001"+ + "\u01bf\u0001\u01bf\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001"+ + "\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001"+ + "\u01c0\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001"+ + "\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001"+ + "\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001"+ + "\u01c1\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001"+ + "\u01c2\u0001\u01c2\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001"+ + "\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001"+ + "\u01c4\u0001\u01c4\u0001\u01c4\u0001\u01c4\u0001\u01c4\u0001\u01c4\u0001"+ + "\u01c4\u0001\u01c4\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001"+ + "\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001"+ + "\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c6\u0001\u01c6\u0001\u01c6\u0001"+ + "\u01c6\u0001\u01c6\u0001\u01c6\u0001\u01c6\u0001\u01c6\u0001\u01c7\u0001"+ + "\u01c7\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0001"+ + "\u01c7\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0001"+ + "\u01c7\u0001\u01c8\u0001\u01c8\u0001\u01c8\u0001\u01c8\u0001\u01c8\u0001"+ + "\u01c8\u0001\u01c8\u0001\u01c8\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001"+ + "\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001"+ + "\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001"+ + "\u01ca\u0001\u01ca\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001"+ + "\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001"+ + "\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0001"+ + "\u01cc\u0001\u01cc\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01ce\u0001"+ + "\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001"+ + "\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01cf\u0001\u01cf\u0001\u01cf\u0001"+ + "\u01cf\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001"+ + "\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d1\u0001"+ + "\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001"+ + "\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d3\u0001"+ + "\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001"+ + "\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001"+ + "\u01d3\u0001\u01d3\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001"+ + "\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d5\u0001"+ + "\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d6\u0001\u01d6\u0001"+ + "\u01d6\u0001\u01d6\u0001\u01d6\u0001\u01d6\u0001\u01d6\u0001\u01d7\u0001"+ + "\u01d7\u0001\u01d7\u0001\u01d7\u0001\u01d7\u0001\u01d8\u0001\u01d8\u0001"+ + "\u01d8\u0001\u01d8\u0001\u01d8\u0001\u01d8\u0001\u01d9\u0001\u01d9\u0001"+ + "\u01d9\u0001\u01d9\u0001\u01d9\u0001\u01da\u0001\u01da\u0001\u01da\u0001"+ + "\u01da\u0001\u01da\u0001\u01da\u0001\u01db\u0001\u01db\u0001\u01db\u0001"+ + "\u01db\u0001\u01db\u0001\u01db\u0001\u01db\u0001\u01db\u0001\u01dc\u0001"+ + "\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dd\u0001\u01dd\u0001"+ + "\u01dd\u0001\u01dd\u0001\u01dd\u0001\u01dd\u0001\u01dd\u0001\u01de\u0001"+ + "\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001"+ + "\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001"+ + "\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001"+ + "\u01de\u0001\u01de\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001"+ + "\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001"+ + "\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001"+ + "\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01e0\u0001"+ + "\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001"+ + "\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001"+ + "\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001"+ + "\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001"+ + "\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001"+ + "\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001"+ + "\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001"+ + "\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001"+ + "\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001"+ + "\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001"+ + "\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e4\u0001\u01e4\u0001"+ + "\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001"+ + "\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001"+ + "\u01e4\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001"+ + "\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001"+ + "\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e6\u0001"+ + "\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001"+ + "\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e7\u0001"+ + "\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001"+ + "\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001"+ + "\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001"+ + "\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001"+ + "\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e9\u0001"+ + "\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001"+ + "\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001"+ + "\u01e9\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001"+ + "\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001"+ + "\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001"+ + "\u01ea\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001"+ + "\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001"+ + "\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01ec\u0001"+ + "\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001"+ + "\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001"+ + "\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ed\u0001"+ + "\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001"+ + "\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001"+ + "\u01ed\u0001\u01ed\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001"+ + "\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001"+ + "\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001"+ + "\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001"+ + "\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001"+ + "\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001"+ + "\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001"+ + "\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001"+ + "\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001"+ + "\u01f0\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001"+ + "\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001"+ + "\u01f1\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001"+ + "\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001"+ + "\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001"+ + "\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001"+ + "\u01f2\u0001\u01f2\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001"+ + "\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001"+ + "\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001"+ + "\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f4\u0001"+ + "\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001"+ + "\u01f4\u0001\u01f4\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001"+ + "\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f6\u0001"+ + "\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001"+ + "\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001"+ + "\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001"+ + "\u01f6\u0001\u01f6\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001"+ + "\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001"+ + "\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001"+ + "\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f8\u0001"+ + "\u01f8\u0001\u01f8\u0001\u01f8\u0001\u01f8\u0001\u01f8\u0001\u01f8\u0001"+ + "\u01f9\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001"+ + "\u01f9\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001"+ + "\u01fa\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001"+ + "\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001"+ + "\u01fb\u0001\u01fb\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001"+ + "\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001"+ + "\u01fd\u0001\u01fd\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001"+ + "\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01ff\u0001"+ + "\u01ff\u0001\u01ff\u0001\u01ff\u0001\u01ff\u0001\u0200\u0001\u0200\u0001"+ + "\u0200\u0001\u0200\u0001\u0200\u0001\u0200\u0001\u0200\u0001\u0201\u0001"+ + "\u0201\u0001\u0201\u0001\u0201\u0001\u0201\u0001\u0201\u0001\u0202\u0001"+ + "\u0202\u0001\u0202\u0001\u0202\u0001\u0202\u0001\u0202\u0001\u0203\u0001"+ + "\u0203\u0001\u0203\u0001\u0203\u0001\u0203\u0001\u0203\u0001\u0203\u0001"+ + "\u0203\u0001\u0203\u0001\u0203\u0001\u0203\u0001\u0203\u0001\u0204\u0001"+ + "\u0204\u0001\u0204\u0001\u0204\u0001\u0204\u0001\u0205\u0001\u0205\u0001"+ + "\u0205\u0001\u0205\u0001\u0205\u0001\u0205\u0001\u0206\u0001\u0206\u0001"+ + "\u0206\u0001\u0206\u0001\u0206\u0001\u0206\u0001\u0207\u0001\u0207\u0001"+ + "\u0207\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0208\u0001\u0208\u0001"+ + "\u0208\u0001\u0208\u0001\u0208\u0001\u0209\u0001\u0209\u0001\u0209\u0001"+ + "\u020a\u0001\u020a\u0001\u020a\u0001\u020a\u0001\u020a\u0001\u020a\u0001"+ + "\u020a\u0001\u020a\u0001\u020b\u0001\u020b\u0001\u020b\u0001\u020b\u0001"+ + "\u020b\u0001\u020b\u0001\u020b\u0001\u020c\u0001\u020c\u0001\u020c\u0001"+ + "\u020c\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020d\u0001"+ + "\u020d\u0001\u020d\u0001\u020d\u0001\u020d\u0001\u020d\u0001\u020d\u0001"+ + "\u020d\u0001\u020d\u0001\u020d\u0001\u020d\u0001\u020e\u0001\u020e\u0001"+ + "\u020e\u0001\u020e\u0001\u020e\u0001\u020e\u0001\u020e\u0001\u020e\u0001"+ + "\u020e\u0001\u020e\u0001\u020e\u0001\u020f\u0001\u020f\u0001\u020f\u0001"+ + "\u020f\u0001\u020f\u0001\u020f\u0001\u020f\u0001\u0210\u0001\u0210\u0001"+ + "\u0210\u0001\u0210\u0001\u0210\u0001\u0210\u0001\u0210\u0001\u0210\u0001"+ + "\u0210\u0001\u0210\u0001\u0211\u0001\u0211\u0001\u0211\u0001\u0211\u0001"+ + "\u0211\u0001\u0212\u0001\u0212\u0001\u0212\u0001\u0212\u0001\u0212\u0001"+ + "\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001"+ + "\u0213\u0001\u0213\u0001\u0214\u0001\u0214\u0001\u0214\u0001\u0214\u0001"+ + "\u0214\u0001\u0214\u0001\u0214\u0001\u0215\u0001\u0215\u0001\u0215\u0001"+ + "\u0216\u0001\u0216\u0001\u0216\u0001\u0217\u0001\u0217\u0001\u0217\u0001"+ + "\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001"+ + "\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0218\u0001\u0218\u0001"+ + "\u0218\u0001\u0218\u0001\u0219\u0001\u0219\u0001\u0219\u0001\u0219\u0001"+ + "\u0219\u0001\u0219\u0001\u0219\u0001\u021a\u0001\u021a\u0001\u021a\u0001"+ + "\u021a\u0001\u021a\u0001\u021b\u0001\u021b\u0001\u021b\u0001\u021b\u0001"+ + "\u021b\u0001\u021c\u0001\u021c\u0001\u021c\u0001\u021c\u0001\u021c\u0001"+ + "\u021c\u0001\u021c\u0001\u021c\u0001\u021c\u0001\u021c\u0001\u021c\u0001"+ + "\u021c\u0001\u021c\u0001\u021c\u0001\u021c\u0001\u021c\u0001\u021d\u0001"+ + "\u021d\u0001\u021d\u0001\u021d\u0001\u021d\u0001\u021d\u0001\u021d\u0001"+ + "\u021d\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021e\u0001"+ + "\u021e\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f\u0001"+ + "\u021f\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u0220\u0001"+ + "\u0220\u0001\u0220\u0001\u0220\u0001\u0220\u0001\u0221\u0001\u0221\u0001"+ + "\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001"+ + "\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001"+ + "\u0221\u0001\u0221\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001"+ + "\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001"+ + "\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001"+ + "\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001"+ + "\u0222\u0001\u0223\u0001\u0223\u0001\u0223\u0001\u0223\u0001\u0223\u0001"+ + "\u0223\u0001\u0223\u0001\u0224\u0001\u0224\u0001\u0224\u0001\u0224\u0001"+ + "\u0224\u0001\u0224\u0001\u0224\u0001\u0224\u0001\u0225\u0001\u0225\u0001"+ + "\u0225\u0001\u0225\u0001\u0225\u0001\u0225\u0001\u0225\u0001\u0225\u0001"+ + "\u0225\u0001\u0225\u0001\u0225\u0001\u0225\u0001\u0225\u0001\u0226\u0001"+ + "\u0226\u0001\u0226\u0001\u0226\u0001\u0226\u0001\u0226\u0001\u0226\u0001"+ + "\u0226\u0001\u0226\u0001\u0226\u0001\u0226\u0001\u0227\u0001\u0227\u0001"+ + "\u0227\u0001\u0227\u0001\u0227\u0001\u0227\u0001\u0227\u0001\u0227\u0001"+ + "\u0227\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001"+ + "\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001"+ + "\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001"+ + "\u0228\u0001\u0228\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229\u0001"+ + "\u0229\u0001\u0229\u0001\u022a\u0001\u022a\u0001\u022a\u0001\u022a\u0001"+ + "\u022a\u0001\u022a\u0001\u022a\u0001\u022b\u0001\u022b\u0001\u022b\u0001"+ + "\u022b\u0001\u022b\u0001\u022b\u0001\u022b\u0001\u022b\u0001\u022b\u0001"+ + "\u022b\u0001\u022b\u0001\u022c\u0001\u022c\u0001\u022c\u0001\u022c\u0001"+ + "\u022c\u0001\u022c\u0001\u022c\u0001\u022c\u0001\u022d\u0001\u022d\u0001"+ + "\u022d\u0001\u022d\u0001\u022d\u0001\u022e\u0001\u022e\u0001\u022e\u0001"+ + "\u022e\u0001\u022e\u0001\u022e\u0001\u022e\u0001\u022e\u0001\u022e\u0001"+ + "\u022f\u0001\u022f\u0001\u022f\u0001\u022f\u0001\u022f\u0001\u022f\u0001"+ + "\u022f\u0001\u022f\u0001\u022f\u0001\u022f\u0001\u0230\u0001\u0230\u0001"+ + "\u0230\u0001\u0230\u0001\u0230\u0001\u0230\u0001\u0230\u0001\u0230\u0001"+ + "\u0231\u0001\u0231\u0001\u0231\u0001\u0231\u0001\u0231\u0001\u0231\u0001"+ + "\u0231\u0001\u0231\u0001\u0231\u0001\u0232\u0001\u0232\u0001\u0232\u0001"+ + "\u0232\u0001\u0232\u0001\u0233\u0001\u0233\u0001\u0233\u0001\u0233\u0001"+ + "\u0233\u0001\u0233\u0001\u0233\u0001\u0233\u0001\u0233\u0001\u0233\u0001"+ + "\u0233\u0001\u0233\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234\u0001"+ + "\u0234\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0235\u0001\u0235\u0001"+ + "\u0235\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0235\u0001"+ + "\u0235\u0001\u0236\u0001\u0236\u0001\u0236\u0001\u0236\u0001\u0236\u0001"+ + "\u0236\u0001\u0237\u0001\u0237\u0001\u0237\u0001\u0237\u0001\u0237\u0001"+ + "\u0237\u0001\u0238\u0001\u0238\u0001\u0238\u0001\u0238\u0001\u0238\u0001"+ + "\u0238\u0001\u0239\u0001\u0239\u0001\u0239\u0001\u0239\u0001\u0239\u0001"+ + "\u0239\u0001\u0239\u0001\u0239\u0001\u023a\u0001\u023a\u0001\u023a\u0001"+ + "\u023a\u0001\u023a\u0001\u023a\u0001\u023a\u0001\u023a\u0001\u023b\u0001"+ + "\u023b\u0001\u023b\u0001\u023b\u0001\u023b\u0001\u023b\u0001\u023b\u0001"+ + "\u023b\u0001\u023b\u0001\u023b\u0001\u023c\u0001\u023c\u0001\u023c\u0001"+ + "\u023c\u0001\u023c\u0001\u023c\u0001\u023c\u0001\u023c\u0001\u023c\u0001"+ + "\u023c\u0001\u023c\u0001\u023c\u0001\u023c\u0001\u023c\u0001\u023c\u0001"+ + "\u023c\u0001\u023c\u0001\u023d\u0001\u023d\u0001\u023d\u0001\u023d\u0001"+ + "\u023d\u0001\u023d\u0001\u023d\u0001\u023d\u0001\u023d\u0001\u023d\u0001"+ + "\u023e\u0001\u023e\u0001\u023e\u0001\u023e\u0001\u023e\u0001\u023e\u0001"+ + "\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001"+ + "\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001"+ + "\u023f\u0001\u023f\u0001\u023f\u0001\u0240\u0001\u0240\u0001\u0240\u0001"+ + "\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001"+ + "\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0241\u0001"+ + "\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001"+ + "\u0241\u0001\u0241\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001"+ + "\u0242\u0001\u0242\u0001\u0242\u0001\u0243\u0001\u0243\u0001\u0243\u0001"+ + "\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001"+ + "\u0243\u0001\u0243\u0001\u0244\u0001\u0244\u0001\u0244\u0001\u0244\u0001"+ + "\u0244\u0001\u0244\u0001\u0244\u0001\u0245\u0001\u0245\u0001\u0245\u0001"+ + "\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001"+ + "\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001"+ + "\u0245\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001"+ + "\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001"+ + "\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001"+ + "\u0246\u0001\u0246\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001"+ + "\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001"+ + "\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001"+ + "\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0248\u0001\u0248\u0001"+ + "\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001"+ + "\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001"+ + "\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001"+ + "\u0248\u0001\u0248\u0001\u0248\u0001\u0249\u0001\u0249\u0001\u0249\u0001"+ + "\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001"+ + "\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001"+ + "\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001"+ + "\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001"+ + "\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001"+ + "\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001"+ + "\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001"+ + "\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001"+ + "\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001"+ + "\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001"+ + "\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001"+ + "\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024c\u0001\u024c\u0001"+ + "\u024c\u0001\u024c\u0001\u024c\u0001\u024c\u0001\u024c\u0001\u024c\u0001"+ + "\u024c\u0001\u024c\u0001\u024c\u0001\u024c\u0001\u024d\u0001\u024d\u0001"+ + "\u024d\u0001\u024d\u0001\u024d\u0001\u024d\u0001\u024e\u0001\u024e\u0001"+ + "\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001"+ + "\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001"+ + "\u024f\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001"+ + "\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001"+ + "\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001"+ + "\u0250\u0001\u0251\u0001\u0251\u0001\u0251\u0001\u0251\u0001\u0251\u0001"+ + "\u0251\u0001\u0251\u0001\u0251\u0001\u0251\u0001\u0251\u0001\u0252\u0001"+ + "\u0252\u0001\u0252\u0001\u0252\u0001\u0252\u0001\u0252\u0001\u0252\u0001"+ + "\u0252\u0001\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001"+ + "\u0253\u0001\u0254\u0001\u0254\u0001\u0254\u0001\u0254\u0001\u0254\u0001"+ + "\u0255\u0001\u0255\u0001\u0255\u0001\u0255\u0001\u0255\u0001\u0255\u0001"+ + "\u0255\u0001\u0255\u0001\u0255\u0001\u0256\u0001\u0256\u0001\u0256\u0001"+ + "\u0256\u0001\u0256\u0001\u0256\u0001\u0256\u0001\u0257\u0001\u0257\u0001"+ + "\u0257\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0258\u0001"+ + "\u0258\u0001\u0258\u0001\u0258\u0001\u0259\u0001\u0259\u0001\u0259\u0001"+ + "\u0259\u0001\u0259\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001"+ + "\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001"+ + "\u025a\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001"+ + "\u025b\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001"+ + "\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025d\u0001"+ + "\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001"+ + "\u025d\u0001\u025d\u0001\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001"+ + "\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001\u025f\u0001"+ + "\u025f\u0001\u025f\u0001\u025f\u0001\u025f\u0001\u025f\u0001\u025f\u0001"+ + "\u025f\u0001\u025f\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0261\u0001\u0261\u0001\u0261\u0001"+ + "\u0261\u0001\u0261\u0001\u0261\u0001\u0261\u0001\u0261\u0001\u0262\u0001"+ + "\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0263\u0001"+ + "\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001"+ + "\u0264\u0001\u0264\u0001\u0264\u0001\u0264\u0001\u0264\u0001\u0264\u0001"+ + "\u0264\u0001\u0265\u0001\u0265\u0001\u0265\u0001\u0265\u0001\u0265\u0001"+ + "\u0265\u0001\u0265\u0001\u0266\u0001\u0266\u0001\u0266\u0001\u0266\u0001"+ + "\u0266\u0001\u0266\u0001\u0267\u0001\u0267\u0001\u0267\u0001\u0267\u0001"+ + "\u0267\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001"+ + "\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0269\u0001\u0269\u0001"+ + "\u0269\u0001\u0269\u0001\u0269\u0001\u0269\u0001\u0269\u0001\u026a\u0001"+ + "\u026a\u0001\u026a\u0001\u026a\u0001\u026a\u0001\u026b\u0001\u026b\u0001"+ + "\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026c\u0001"+ + "\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001"+ + "\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001"+ + "\u026d\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001"+ + "\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001"+ + "\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026f\u0001"+ + "\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001"+ + "\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001"+ + "\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001"+ + "\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001"+ + "\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001"+ + "\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0271\u0001"+ + "\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001"+ + "\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001"+ + "\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0272\u0001"+ + "\u0272\u0001\u0272\u0001\u0272\u0001\u0272\u0001\u0272\u0001\u0272\u0001"+ + "\u0272\u0001\u0272\u0001\u0272\u0001\u0273\u0001\u0273\u0001\u0273\u0001"+ + "\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001"+ + "\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0274\u0001\u0274\u0001"+ + "\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001"+ + "\u0274\u0001\u0274\u0001\u0274\u0001\u0275\u0001\u0275\u0001\u0275\u0001"+ + "\u0275\u0001\u0275\u0001\u0275\u0001\u0276\u0001\u0276\u0001\u0276\u0001"+ + "\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0277\u0001\u0277\u0001"+ + "\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001"+ + "\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001"+ + "\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0278\u0001\u0278\u0001"+ + "\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001"+ + "\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001"+ + "\u0278\u0001\u0278\u0001\u0278\u0001\u0279\u0001\u0279\u0001\u0279\u0001"+ + "\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001"+ + "\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001"+ + "\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u027a\u0001\u027a\u0001"+ + "\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027b\u0001"+ + "\u027b\u0001\u027b\u0001\u027b\u0001\u027b\u0001\u027c\u0001\u027c\u0001"+ + "\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001"+ + "\u027d\u0001\u027d\u0001\u027d\u0001\u027d\u0001\u027d\u0001\u027d\u0001"+ + "\u027d\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001"+ + "\u027e\u0001\u027e\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001"+ + "\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001"+ + "\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001"+ + "\u0280\u0001\u0280\u0001\u0280\u0001\u0280\u0001\u0280\u0001\u0280\u0001"+ + "\u0280\u0001\u0280\u0001\u0281\u0001\u0281\u0001\u0281\u0001\u0281\u0001"+ + "\u0281\u0001\u0281\u0001\u0281\u0001\u0281\u0001\u0281\u0001\u0281\u0001"+ + "\u0281\u0001\u0281\u0001\u0281\u0001\u0282\u0001\u0282\u0001\u0282\u0001"+ + "\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001"+ + "\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0283\u0001"+ + "\u0283\u0001\u0283\u0001\u0283\u0001\u0283\u0001\u0283\u0001\u0283\u0001"+ + "\u0283\u0001\u0284\u0001\u0284\u0001\u0284\u0001\u0284\u0001\u0284\u0001"+ + "\u0284\u0001\u0285\u0001\u0285\u0001\u0285\u0001\u0285\u0001\u0285\u0001"+ + "\u0285\u0001\u0285\u0001\u0285\u0001\u0285\u0001\u0286\u0001\u0286\u0001"+ + "\u0286\u0001\u0286\u0001\u0286\u0001\u0286\u0001\u0286\u0001\u0286\u0001"+ + "\u0286\u0001\u0286\u0001\u0286\u0001\u0287\u0001\u0287\u0001\u0287\u0001"+ + "\u0287\u0001\u0287\u0001\u0287\u0001\u0287\u0001\u0287\u0001\u0287\u0001"+ + "\u0287\u0001\u0287\u0001\u0288\u0001\u0288\u0001\u0288\u0001\u0288\u0001"+ + "\u0288\u0001\u0288\u0001\u0288\u0001\u0288\u0001\u0288\u0001\u0288\u0001"+ + "\u0288\u0001\u0289\u0001\u0289\u0001\u0289\u0001\u0289\u0001\u0289\u0001"+ + "\u0289\u0001\u0289\u0001\u0289\u0001\u0289\u0001\u0289\u0001\u028a\u0001"+ + "\u028a\u0001\u028a\u0001\u028a\u0001\u028a\u0001\u028a\u0001\u028a\u0001"+ + "\u028a\u0001\u028a\u0001\u028a\u0001\u028b\u0001\u028b\u0001\u028b\u0001"+ + "\u028b\u0001\u028b\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001"+ + "\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001"+ + "\u028c\u0001\u028c\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001"+ + "\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001"+ + "\u028d\u0001\u028d\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001"+ + "\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001"+ + "\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028f\u0001\u028f\u0001"+ + "\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001"+ + "\u028f\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001"+ + "\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0291\u0001\u0291\u0001"+ + "\u0291\u0001\u0291\u0001\u0291\u0001\u0291\u0001\u0291\u0001\u0291\u0001"+ + "\u0291\u0001\u0291\u0001\u0292\u0001\u0292\u0001\u0292\u0001\u0292\u0001"+ + "\u0292\u0001\u0292\u0001\u0292\u0001\u0292\u0001\u0292\u0001\u0292\u0001"+ + "\u0293\u0001\u0293\u0001\u0293\u0001\u0293\u0001\u0293\u0001\u0293\u0001"+ + "\u0293\u0001\u0293\u0001\u0293\u0001\u0294\u0001\u0294\u0001\u0294\u0001"+ + "\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001"+ + "\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001"+ + "\u0294\u0001\u0294\u0001\u0295\u0001\u0295\u0001\u0295\u0001\u0295\u0001"+ + "\u0295\u0001\u0295\u0001\u0295\u0001\u0295\u0001\u0295\u0001\u0295\u0001"+ + "\u0296\u0001\u0296\u0001\u0296\u0001\u0296\u0001\u0296\u0001\u0296\u0001"+ + "\u0296\u0001\u0296\u0001\u0297\u0001\u0297\u0001\u0297\u0001\u0297\u0001"+ + "\u0297\u0001\u0297\u0001\u0298\u0001\u0298\u0001\u0298\u0001\u0298\u0001"+ + "\u0298\u0001\u0298\u0001\u0298\u0001\u0298\u0001\u0299\u0001\u0299\u0001"+ + "\u0299\u0001\u0299\u0001\u0299\u0001\u029a\u0001\u029a\u0001\u029a\u0001"+ + "\u029a\u0001\u029a\u0001\u029a\u0001\u029a\u0001\u029a\u0001\u029b\u0001"+ + "\u029b\u0001\u029b\u0001\u029b\u0001\u029b\u0001\u029b\u0001\u029b\u0001"+ + "\u029b\u0001\u029b\u0001\u029b\u0001\u029b\u0001\u029b\u0001\u029b\u0001"+ + "\u029b\u0001\u029b\u0001\u029c\u0001\u029c\u0001\u029c\u0001\u029c\u0001"+ + "\u029c\u0001\u029c\u0001\u029c\u0001\u029c\u0001\u029c\u0001\u029c\u0001"+ + "\u029c\u0001\u029d\u0001\u029d\u0001\u029d\u0001\u029d\u0001\u029d\u0001"+ + "\u029d\u0001\u029e\u0001\u029e\u0001\u029e\u0001\u029e\u0001\u029e\u0001"+ + "\u029e\u0001\u029e\u0001\u029e\u0001\u029e\u0001\u029e\u0001\u029f\u0001"+ + "\u029f\u0001\u029f\u0001\u029f\u0001\u029f\u0001\u02a0\u0001\u02a0\u0001"+ + "\u02a0\u0001\u02a0\u0001\u02a0\u0001\u02a0\u0001\u02a0\u0001\u02a0\u0001"+ + "\u02a1\u0001\u02a1\u0001\u02a1\u0001\u02a1\u0001\u02a1\u0001\u02a1\u0001"+ + "\u02a1\u0001\u02a1\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001"+ + "\u02a2\u0001\u02a3\u0001\u02a3\u0001\u02a3\u0001\u02a3\u0001\u02a3\u0001"+ + "\u02a3\u0001\u02a3\u0001\u02a3\u0001\u02a3\u0001\u02a4\u0001\u02a4\u0001"+ + "\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a5\u0001"+ + "\u02a5\u0001\u02a5\u0001\u02a5\u0001\u02a5\u0001\u02a5\u0001\u02a5\u0001"+ + "\u02a5\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001"+ + "\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a7\u0001"+ + "\u02a7\u0001\u02a7\u0001\u02a8\u0001\u02a8\u0001\u02a8\u0001\u02a8\u0001"+ + "\u02a8\u0001\u02a9\u0001\u02a9\u0001\u02a9\u0001\u02aa\u0001\u02aa\u0001"+ + "\u02aa\u0001\u02aa\u0001\u02ab\u0001\u02ab\u0001\u02ab\u0001\u02ab\u0001"+ + "\u02ac\u0001\u02ac\u0001\u02ac\u0001\u02ac\u0001\u02ad\u0001\u02ad\u0001"+ + "\u02ad\u0001\u02ad\u0001\u02ae\u0001\u02ae\u0001\u02ae\u0001\u02ae\u0001"+ + "\u02af\u0001\u02af\u0001\u02af\u0001\u02af\u0001\u02b0\u0001\u02b0\u0001"+ + "\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001"+ + "\u02b0\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001"+ + "\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001"+ + "\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b3\u0001\u02b3\u0001\u02b3\u0001"+ + "\u02b3\u0001\u02b4\u0001\u02b4\u0001\u02b4\u0001\u02b4\u0001\u02b4\u0001"+ + "\u02b5\u0001\u02b5\u0001\u02b5\u0001\u02b5\u0001\u02b5\u0001\u02b5\u0001"+ + "\u02b5\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001"+ + "\u02b7\u0001\u02b7\u0001\u02b7\u0001\u02b7\u0001\u02b7\u0001\u02b7\u0001"+ + "\u02b7\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001"+ + "\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001"+ + "\u02b8\u0001\u02b9\u0001\u02b9\u0001\u02b9\u0001\u02b9\u0001\u02b9\u0001"+ + "\u02b9\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001"+ + "\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001"+ + "\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001"+ + "\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001"+ + "\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02bb\u0001\u02bb\u0001"+ + "\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bb\u0001"+ + "\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bb\u0001"+ + "\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bc\u0001"+ + "\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001"+ + "\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bd\u0001"+ + "\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001"+ + "\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001"+ + "\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001"+ + "\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001"+ + "\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02be\u0001\u02be\u0001\u02be\u0001"+ + "\u02be\u0001\u02be\u0001\u02be\u0001\u02be\u0001\u02be\u0001\u02be\u0001"+ + "\u02be\u0001\u02be\u0001\u02be\u0001\u02be\u0001\u02bf\u0001\u02bf\u0001"+ + "\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001"+ + "\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02c0\u0001"+ + "\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001"+ + "\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001"+ + "\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001"+ + "\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c1\u0001"+ + "\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001"+ + "\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c2\u0001"+ + "\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001"+ + "\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001"+ + "\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c3\u0001\u02c3\u0001"+ + "\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001"+ + "\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001"+ + "\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001"+ + "\u02c3\u0001\u02c4\u0001\u02c4\u0001\u02c4\u0001\u02c4\u0001\u02c4\u0001"+ + "\u02c4\u0001\u02c4\u0001\u02c4\u0001\u02c5\u0001\u02c5\u0001\u02c5\u0001"+ + "\u02c5\u0001\u02c5\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001"+ + "\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001"+ + "\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c7\u0001"+ + "\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c7\u0001"+ + "\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c7\u0001"+ + "\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c8\u0001\u02c8\u0001\u02c8\u0001"+ + "\u02c8\u0001\u02c8\u0001\u02c8\u0001\u02c8\u0001\u02c8\u0001\u02c8\u0001"+ + "\u02c8\u0001\u02c8\u0001\u02c8\u0001\u02c8\u0001\u02c8\u0001\u02c9\u0001"+ + "\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001"+ + "\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001"+ + "\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001"+ + "\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001"+ + "\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001"+ + "\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02cb\u0001\u02cb\u0001"+ + "\u02cb\u0001\u02cb\u0001\u02cb\u0001\u02cb\u0001\u02cb\u0001\u02cb\u0001"+ + "\u02cb\u0001\u02cb\u0001\u02cb\u0001\u02cb\u0001\u02cb\u0001\u02cc\u0001"+ + "\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001"+ + "\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001"+ + "\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001"+ + "\u02cc\u0001\u02cc\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001"+ + "\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001"+ + "\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001"+ + "\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001"+ + "\u02cd\u0001\u02cd\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001"+ + "\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001"+ + "\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001"+ + "\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001"+ + "\u02ce\u0001\u02ce\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001"+ + "\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001"+ + "\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001"+ + "\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001"+ + "\u02cf\u0001\u02d0\u0001\u02d0\u0001\u02d0\u0001\u02d0\u0001\u02d0\u0001"+ + "\u02d0\u0001\u02d0\u0001\u02d1\u0001\u02d1\u0001\u02d1\u0001\u02d1\u0001"+ + "\u02d1\u0001\u02d1\u0001\u02d1\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001"+ + "\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001"+ + "\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001"+ + "\u02d2\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001"+ + "\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001"+ + "\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001"+ + "\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001"+ + "\u02d3\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001"+ + "\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001"+ + "\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001"+ + "\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001"+ + "\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d5\u0001\u02d5\u0001"+ + "\u02d5\u0001\u02d5\u0001\u02d5\u0001\u02d5\u0001\u02d5\u0001\u02d5\u0001"+ + "\u02d5\u0001\u02d5\u0001\u02d5\u0001\u02d6\u0001\u02d6\u0001\u02d6\u0001"+ + "\u02d6\u0001\u02d6\u0001\u02d6\u0001\u02d6\u0001\u02d6\u0001\u02d7\u0001"+ + "\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001"+ + "\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001"+ + "\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001"+ + "\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001"+ + "\u02d8\u0001\u02d8\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001"+ + "\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001"+ + "\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001"+ + "\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001"+ + "\u02d9\u0001\u02d9\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001"+ + "\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001"+ + "\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001"+ + "\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02db\u0001"+ + "\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001"+ + "\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001"+ + "\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001"+ + "\u02db\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001"+ + "\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001"+ + "\u02dd\u0001\u02dd\u0001\u02dd\u0001\u02dd\u0001\u02dd\u0001\u02dd\u0001"+ + "\u02dd\u0001\u02dd\u0001\u02de\u0001\u02de\u0001\u02de\u0001\u02df\u0001"+ + "\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001"+ + "\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001"+ + "\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001"+ + "\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001"+ + "\u02e0\u0003\u02e0\u243a\b\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001"+ + "\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001"+ + "\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001"+ + "\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001"+ + "\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0003\u02e0\u2455\b\u02e0\u0001"+ + "\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001"+ + "\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001"+ + "\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001"+ + "\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001"+ + "\u02e2\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001"+ + "\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e4\u0001\u02e4\u0001"+ + "\u02e4\u0001\u02e4\u0001\u02e4\u0001\u02e4\u0001\u02e5\u0001\u02e5\u0001"+ + "\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001"+ + "\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001"+ + "\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001"+ + "\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e6\u0001\u02e6\u0001\u02e6\u0001"+ + "\u02e6\u0001\u02e6\u0001\u02e6\u0001\u02e6\u0001\u02e7\u0001\u02e7\u0001"+ + "\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001"+ + "\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001"+ + "\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001"+ + "\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001"+ + "\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001"+ + "\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001"+ + "\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e9\u0001"+ + "\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001"+ + "\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001"+ + "\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02ea\u0001\u02ea\u0001"+ + "\u02ea\u0001\u02ea\u0001\u02ea\u0001\u02ea\u0001\u02ea\u0001\u02ea\u0001"+ + "\u02ea\u0001\u02eb\u0001\u02eb\u0001\u02eb\u0001\u02eb\u0001\u02eb\u0001"+ + "\u02eb\u0001\u02ec\u0001\u02ec\u0001\u02ec\u0001\u02ec\u0001\u02ec\u0001"+ + "\u02ed\u0001\u02ed\u0001\u02ed\u0001\u02ed\u0001\u02ed\u0001\u02ed\u0001"+ + "\u02ed\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001"+ + "\u02ee\u0001\u02ee\u0001\u02ef\u0001\u02ef\u0001\u02ef\u0001\u02ef\u0001"+ + "\u02ef\u0001\u02ef\u0001\u02ef\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0001"+ + "\u02f0\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0001\u02f1\u0001\u02f1\u0001"+ + "\u02f1\u0001\u02f1\u0001\u02f1\u0001\u02f1\u0001\u02f2\u0001\u02f2\u0001"+ + "\u02f2\u0001\u02f2\u0001\u02f2\u0001\u02f2\u0001\u02f3\u0001\u02f3\u0001"+ + "\u02f3\u0001\u02f3\u0001\u02f3\u0001\u02f3\u0001\u02f4\u0001\u02f4\u0001"+ + "\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f5\u0001\u02f5\u0001"+ + "\u02f5\u0001\u02f5\u0001\u02f5\u0001\u02f6\u0001\u02f6\u0001\u02f6\u0001"+ + "\u02f6\u0001\u02f6\u0001\u02f6\u0001\u02f6\u0001\u02f6\u0001\u02f7\u0001"+ + "\u02f7\u0001\u02f7\u0001\u02f7\u0001\u02f7\u0001\u02f7\u0001\u02f8\u0001"+ + "\u02f8\u0001\u02f8\u0001\u02f8\u0001\u02f8\u0001\u02f8\u0001\u02f8\u0001"+ + "\u02f8\u0001\u02f9\u0001\u02f9\u0001\u02f9\u0001\u02f9\u0001\u02f9\u0001"+ + "\u02f9\u0001\u02f9\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001"+ + "\u02fb\u0001\u02fb\u0001\u02fb\u0001\u02fb\u0001\u02fb\u0001\u02fb\u0001"+ + "\u02fb\u0001\u02fb\u0001\u02fc\u0001\u02fc\u0001\u02fc\u0001\u02fc\u0001"+ + "\u02fc\u0001\u02fc\u0001\u02fd\u0001\u02fd\u0001\u02fd\u0001\u02fd\u0001"+ + "\u02fd\u0001\u02fd\u0001\u02fd\u0001\u02fe\u0001\u02fe\u0001\u02fe\u0001"+ + "\u02fe\u0001\u02ff\u0001\u02ff\u0001\u02ff\u0001\u02ff\u0001\u02ff\u0001"+ + "\u02ff\u0001\u02ff\u0001\u02ff\u0001\u0300\u0001\u0300\u0001\u0300\u0001"+ + "\u0300\u0001\u0300\u0001\u0300\u0001\u0301\u0001\u0301\u0001\u0301\u0001"+ + "\u0301\u0001\u0301\u0001\u0301\u0001\u0302\u0001\u0302\u0001\u0302\u0001"+ + "\u0302\u0001\u0302\u0001\u0302\u0001\u0302\u0001\u0303\u0001\u0303\u0001"+ + "\u0303\u0001\u0303\u0001\u0303\u0001\u0303\u0001\u0303\u0001\u0304\u0001"+ + "\u0304\u0001\u0304\u0001\u0304\u0001\u0304\u0001\u0304\u0001\u0304\u0001"+ + "\u0305\u0001\u0305\u0001\u0305\u0001\u0305\u0001\u0305\u0001\u0305\u0001"+ + "\u0305\u0001\u0306\u0001\u0306\u0001\u0306\u0001\u0306\u0001\u0306\u0001"+ + "\u0306\u0001\u0307\u0001\u0307\u0001\u0307\u0001\u0307\u0001\u0307\u0001"+ + "\u0307\u0001\u0307\u0001\u0307\u0001\u0307\u0001\u0308\u0001\u0308\u0001"+ + "\u0308\u0001\u0308\u0001\u0308\u0001\u0309\u0001\u0309\u0001\u0309\u0001"+ + "\u0309\u0001\u0309\u0001\u030a\u0001\u030a\u0001\u030a\u0001\u030a\u0001"+ + "\u030a\u0001\u030a\u0001\u030a\u0001\u030b\u0001\u030b\u0001\u030b\u0001"+ + "\u030b\u0001\u030b\u0001\u030c\u0001\u030c\u0001\u030c\u0001\u030c\u0001"+ + "\u030c\u0001\u030d\u0001\u030d\u0001\u030d\u0001\u030d\u0001\u030d\u0001"+ + "\u030d\u0001\u030e\u0001\u030e\u0001\u030e\u0001\u030e\u0001\u030e\u0001"+ + "\u030e\u0001\u030e\u0001\u030e\u0001\u030f\u0001\u030f\u0001\u030f\u0001"+ + "\u030f\u0001\u030f\u0001\u030f\u0001\u0310\u0001\u0310\u0001\u0310\u0001"+ + "\u0310\u0001\u0310\u0001\u0311\u0001\u0311\u0001\u0311\u0001\u0311\u0001"+ + "\u0311\u0001\u0311\u0001\u0311\u0001\u0311\u0001\u0312\u0001\u0312\u0001"+ + "\u0312\u0001\u0312\u0001\u0312\u0001\u0312\u0001\u0312\u0001\u0312\u0001"+ + "\u0313\u0001\u0313\u0001\u0313\u0001\u0313\u0001\u0313\u0001\u0313\u0001"+ + "\u0313\u0001\u0313\u0001\u0314\u0001\u0314\u0001\u0314\u0001\u0314\u0001"+ + "\u0314\u0001\u0314\u0001\u0314\u0001\u0314\u0001\u0314\u0001\u0314\u0001"+ + "\u0315\u0001\u0315\u0001\u0315\u0001\u0315\u0001\u0316\u0001\u0316\u0001"+ + "\u0316\u0001\u0316\u0001\u0316\u0001\u0316\u0001\u0316\u0001\u0316\u0001"+ + "\u0316\u0001\u0316\u0001\u0317\u0001\u0317\u0001\u0317\u0001\u0317\u0001"+ + "\u0317\u0001\u0317\u0001\u0317\u0001\u0318\u0001\u0318\u0001\u0318\u0001"+ + "\u0318\u0001\u0318\u0001\u0318\u0001\u0318\u0001\u0319\u0001\u0319\u0001"+ + "\u0319\u0001\u0319\u0001\u0319\u0001\u0319\u0001\u0319\u0001\u0319\u0001"+ + "\u0319\u0001\u0319\u0001\u0319\u0001\u031a\u0001\u031a\u0001\u031a\u0001"+ + "\u031a\u0001\u031a\u0001\u031a\u0001\u031a\u0001\u031b\u0001\u031b\u0001"+ + "\u031b\u0001\u031b\u0001\u031c\u0001\u031c\u0001\u031c\u0001\u031c\u0001"+ + "\u031c\u0001\u031c\u0001\u031c\u0001\u031c\u0001\u031c\u0001\u031c\u0001"+ + "\u031c\u0001\u031d\u0001\u031d\u0001\u031d\u0001\u031d\u0001\u031d\u0001"+ + "\u031d\u0001\u031d\u0001\u031d\u0001\u031d\u0001\u031d\u0001\u031d\u0001"+ + "\u031d\u0001\u031d\u0001\u031d\u0001\u031d\u0001\u031d\u0001\u031d\u0001"+ + "\u031d\u0001\u031d\u0001\u031e\u0001\u031e\u0001\u031e\u0001\u031e\u0001"+ + "\u031e\u0001\u031e\u0001\u031e\u0001\u031f\u0001\u031f\u0001\u031f\u0001"+ + "\u031f\u0001\u031f\u0001\u031f\u0001\u031f\u0001\u031f\u0001\u031f\u0001"+ + "\u031f\u0001\u031f\u0001\u0320\u0001\u0320\u0001\u0320\u0001\u0320\u0001"+ + "\u0320\u0001\u0320\u0001\u0320\u0001\u0320\u0001\u0320\u0001\u0320\u0001"+ + "\u0321\u0001\u0321\u0001\u0321\u0001\u0321\u0001\u0321\u0001\u0321\u0001"+ + "\u0321\u0001\u0321\u0001\u0321\u0001\u0321\u0001\u0321\u0001\u0321\u0001"+ + "\u0322\u0001\u0322\u0001\u0322\u0001\u0322\u0001\u0322\u0001\u0322\u0001"+ + "\u0322\u0001\u0322\u0001\u0322\u0001\u0322\u0001\u0322\u0001\u0322\u0001"+ + "\u0322\u0001\u0323\u0001\u0323\u0001\u0323\u0001\u0323\u0001\u0323\u0001"+ + "\u0323\u0001\u0323\u0001\u0323\u0001\u0323\u0001\u0323\u0001\u0323\u0001"+ + "\u0323\u0001\u0323\u0001\u0323\u0001\u0323\u0001\u0323\u0001\u0323\u0001"+ + "\u0323\u0001\u0323\u0001\u0324\u0001\u0324\u0001\u0324\u0001\u0324\u0001"+ + "\u0324\u0001\u0324\u0001\u0324\u0001\u0324\u0001\u0324\u0001\u0324\u0001"+ + "\u0324\u0001\u0324\u0001\u0324\u0001\u0324\u0001\u0324\u0001\u0325\u0001"+ + "\u0325\u0001\u0325\u0001\u0325\u0001\u0325\u0001\u0325\u0001\u0325\u0001"+ + "\u0325\u0001\u0325\u0001\u0326\u0001\u0326\u0001\u0326\u0001\u0326\u0001"+ + "\u0326\u0001\u0326\u0001\u0326\u0001\u0326\u0001\u0326\u0001\u0326\u0001"+ + "\u0326\u0001\u0327\u0001\u0327\u0001\u0327\u0001\u0327\u0001\u0327\u0001"+ + "\u0327\u0001\u0327\u0001\u0327\u0001\u0327\u0001\u0327\u0001\u0327\u0001"+ + "\u0327\u0001\u0327\u0001\u0327\u0001\u0327\u0001\u0327\u0001\u0328\u0001"+ + "\u0328\u0001\u0328\u0001\u0328\u0001\u0328\u0001\u0328\u0001\u0328\u0001"+ + "\u0328\u0001\u0328\u0001\u0328\u0001\u0328\u0001\u0329\u0001\u0329\u0001"+ + "\u0329\u0001\u0329\u0001\u0329\u0001\u0329\u0001\u0329\u0001\u0329\u0001"+ + "\u0329\u0001\u0329\u0001\u0329\u0001\u0329\u0001\u0329\u0001\u032a\u0001"+ + "\u032a\u0001\u032a\u0001\u032a\u0001\u032a\u0001\u032a\u0001\u032b\u0001"+ + "\u032b\u0001\u032b\u0001\u032b\u0001\u032b\u0001\u032b\u0001\u032b\u0001"+ + "\u032b\u0001\u032c\u0001\u032c\u0001\u032c\u0001\u032c\u0001\u032d\u0001"+ + "\u032d\u0001\u032d\u0001\u032d\u0001\u032d\u0001\u032e\u0001\u032e\u0001"+ + "\u032e\u0001\u032e\u0001\u032e\u0001\u032e\u0001\u032e\u0001\u032e\u0001"+ + "\u032f\u0001\u032f\u0001\u032f\u0001\u032f\u0001\u032f\u0001\u032f\u0001"+ + "\u032f\u0001\u032f\u0001\u0330\u0001\u0330\u0001\u0330\u0001\u0330\u0001"+ + "\u0330\u0001\u0330\u0001\u0330\u0001\u0330\u0001\u0330\u0001\u0330\u0001"+ + "\u0330\u0001\u0330\u0001\u0331\u0001\u0331\u0001\u0331\u0001\u0331\u0001"+ + "\u0331\u0001\u0331\u0001\u0331\u0001\u0331\u0001\u0331\u0001\u0331\u0001"+ + "\u0331\u0001\u0331\u0001\u0332\u0001\u0332\u0001\u0332\u0001\u0332\u0001"+ + "\u0332\u0001\u0333\u0001\u0333\u0001\u0333\u0001\u0333\u0001\u0333\u0001"+ + "\u0333\u0001\u0333\u0001\u0333\u0001\u0333\u0001\u0334\u0001\u0334\u0001"+ + "\u0334\u0001\u0334\u0001\u0334\u0001\u0335\u0001\u0335\u0001\u0335\u0001"+ + "\u0335\u0001\u0335\u0001\u0335\u0001\u0335\u0001\u0336\u0001\u0336\u0001"+ + "\u0336\u0001\u0336\u0001\u0336\u0001\u0336\u0001\u0337\u0001\u0337\u0001"+ + "\u0337\u0001\u0337\u0001\u0337\u0001\u0337\u0001\u0338\u0001\u0338\u0001"+ + "\u0338\u0001\u0338\u0001\u0338\u0001\u0338\u0001\u0338\u0001\u0338\u0001"+ + "\u0338\u0001\u0338\u0001\u0338\u0001\u0338\u0001\u0338\u0001\u0338\u0001"+ + "\u0338\u0001\u0338\u0001\u0338\u0001\u0338\u0001\u0338\u0001\u0339\u0001"+ + "\u0339\u0001\u0339\u0001\u0339\u0001\u0339\u0001\u0339\u0001\u0339\u0001"+ + "\u0339\u0001\u0339\u0001\u0339\u0001\u0339\u0001\u0339\u0001\u0339\u0001"+ + "\u0339\u0001\u0339\u0001\u0339\u0001\u0339\u0001\u0339\u0001\u033a\u0001"+ + "\u033a\u0001\u033a\u0001\u033a\u0001\u033a\u0001\u033a\u0001\u033a\u0001"+ + "\u033a\u0001\u033a\u0001\u033a\u0001\u033a\u0001\u033a\u0001\u033a\u0001"+ + "\u033a\u0001\u033a\u0001\u033a\u0001\u033a\u0001\u033a\u0001\u033a\u0001"+ + "\u033b\u0001\u033b\u0001\u033b\u0001\u033b\u0001\u033b\u0001\u033b\u0001"+ + "\u033b\u0001\u033b\u0001\u033b\u0001\u033b\u0001\u033b\u0001\u033b\u0001"+ + "\u033b\u0001\u033b\u0001\u033b\u0001\u033b\u0001\u033c\u0001\u033c\u0001"+ + "\u033c\u0001\u033c\u0001\u033c\u0001\u033c\u0001\u033c\u0001\u033c\u0001"+ + "\u033c\u0001\u033c\u0001\u033c\u0001\u033c\u0001\u033c\u0001\u033c\u0001"+ + "\u033c\u0001\u033c\u0001\u033c\u0001\u033c\u0001\u033d\u0001\u033d\u0001"+ + "\u033d\u0001\u033d\u0001\u033d\u0001\u033e\u0001\u033e\u0001\u033e\u0001"+ + "\u033e\u0001\u033e\u0001\u033e\u0001\u033f\u0001\u033f\u0001\u033f\u0001"+ + "\u033f\u0001\u033f\u0001\u033f\u0001\u033f\u0001\u033f\u0001\u033f\u0001"+ + "\u033f\u0001\u0340\u0001\u0340\u0001\u0340\u0001\u0340\u0001\u0341\u0001"+ + "\u0341\u0001\u0341\u0001\u0341\u0001\u0341\u0001\u0341\u0001\u0341\u0001"+ + "\u0341\u0001\u0341\u0001\u0341\u0001\u0342\u0001\u0342\u0001\u0342\u0001"+ + "\u0342\u0001\u0342\u0001\u0342\u0001\u0342\u0001\u0342\u0001\u0342\u0001"+ + "\u0342\u0001\u0342\u0001\u0343\u0001\u0343\u0001\u0343\u0001\u0343\u0001"+ + "\u0343\u0001\u0343\u0001\u0343\u0001\u0344\u0001\u0344\u0001\u0344\u0001"+ + "\u0344\u0001\u0344\u0001\u0344\u0001\u0344\u0001\u0344\u0001\u0344\u0001"+ + "\u0344\u0001\u0344\u0001\u0344\u0001\u0344\u0001\u0345\u0001\u0345\u0001"+ + "\u0345\u0001\u0345\u0001\u0345\u0001\u0346\u0001\u0346\u0001\u0346\u0001"+ + "\u0346\u0001\u0346\u0001\u0346\u0001\u0346\u0001\u0346\u0001\u0347\u0001"+ + "\u0347\u0001\u0347\u0001\u0347\u0001\u0347\u0001\u0347\u0001\u0347\u0001"+ + "\u0347\u0001\u0347\u0001\u0348\u0001\u0348\u0001\u0348\u0001\u0348\u0001"+ + "\u0348\u0001\u0348\u0001\u0348\u0001\u0348\u0001\u0348\u0001\u0348\u0001"+ + "\u0348\u0001\u0348\u0001\u0348\u0001\u0348\u0001\u0348\u0001\u0348\u0001"+ + "\u0348\u0001\u0349\u0001\u0349\u0001\u0349\u0001\u0349\u0001\u0349\u0001"+ + "\u0349\u0001\u0349\u0001\u0349\u0001\u034a\u0001\u034a\u0001\u034a\u0001"+ + "\u034a\u0001\u034a\u0001\u034a\u0001\u034a\u0001\u034a\u0001\u034a\u0001"+ + "\u034a\u0001\u034a\u0001\u034a\u0001\u034b\u0001\u034b\u0001\u034b\u0001"+ + "\u034b\u0001\u034b\u0001\u034b\u0001\u034b\u0001\u034b\u0001\u034b\u0001"+ + "\u034b\u0001\u034b\u0001\u034b\u0001\u034b\u0001\u034c\u0001\u034c\u0001"+ + "\u034c\u0001\u034c\u0001\u034c\u0001\u034c\u0001\u034c\u0001\u034c\u0001"+ + "\u034c\u0001\u034c\u0001\u034d\u0001\u034d\u0001\u034d\u0001\u034d\u0001"+ + "\u034d\u0001\u034d\u0001\u034d\u0001\u034d\u0001\u034d\u0001\u034e\u0001"+ + "\u034e\u0001\u034e\u0001\u034e\u0001\u034e\u0001\u034e\u0001\u034e\u0001"+ + "\u034f\u0001\u034f\u0001\u034f\u0001\u034f\u0001\u034f\u0001\u034f\u0001"+ + "\u034f\u0001\u034f\u0001\u034f\u0001\u034f\u0001\u0350\u0001\u0350\u0001"+ + "\u0350\u0001\u0350\u0001\u0350\u0001\u0350\u0001\u0350\u0001\u0350\u0001"+ + "\u0350\u0001\u0350\u0001\u0350\u0001\u0350\u0001\u0350\u0001\u0350\u0001"+ + "\u0351\u0001\u0351\u0001\u0351\u0001\u0351\u0001\u0351\u0001\u0352\u0001"+ + "\u0352\u0001\u0352\u0001\u0352\u0001\u0352\u0001\u0352\u0001\u0352\u0001"+ + "\u0352\u0001\u0352\u0001\u0352\u0001\u0352\u0001\u0353\u0001\u0353\u0001"+ + "\u0353\u0001\u0353\u0001\u0354\u0001\u0354\u0001\u0354\u0001\u0354\u0001"+ + "\u0355\u0001\u0355\u0001\u0355\u0001\u0355\u0001\u0355\u0001\u0355\u0001"+ + "\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001"+ + "\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001"+ + "\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001"+ + "\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001\u0356\u0001"+ + "\u0356\u0001\u0356\u0001\u0356\u0001\u0357\u0001\u0357\u0001\u0357\u0001"+ + "\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001"+ + "\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001"+ + "\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001"+ + "\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001\u0357\u0001\u0358\u0001"+ + "\u0358\u0001\u0358\u0001\u0358\u0001\u0358\u0001\u0358\u0001\u0358\u0001"+ + "\u0358\u0001\u0358\u0001\u0358\u0001\u0358\u0001\u0358\u0001\u0358\u0001"+ + "\u0358\u0001\u0358\u0001\u0358\u0001\u0358\u0001\u0358\u0001\u0358\u0001"+ + "\u0358\u0001\u0358\u0001\u0359\u0001\u0359\u0001\u0359\u0001\u0359\u0001"+ + "\u0359\u0001\u0359\u0001\u0359\u0001\u0359\u0001\u0359\u0001\u0359\u0001"+ + "\u0359\u0001\u0359\u0001\u0359\u0001\u0359\u0001\u035a\u0001\u035a\u0001"+ + "\u035a\u0001\u035a\u0001\u035a\u0001\u035a\u0001\u035a\u0001\u035a\u0001"+ + "\u035b\u0001\u035b\u0001\u035b\u0001\u035b\u0001\u035b\u0001\u035b\u0001"+ + "\u035b\u0001\u035b\u0001\u035b\u0001\u035c\u0001\u035c\u0001\u035c\u0001"+ + "\u035c\u0001\u035c\u0001\u035c\u0001\u035c\u0001\u035c\u0001\u035c\u0001"+ + "\u035c\u0001\u035c\u0001\u035c\u0001\u035d\u0001\u035d\u0001\u035d\u0001"+ + "\u035d\u0001\u035d\u0001\u035d\u0001\u035d\u0001\u035d\u0001\u035e\u0001"+ + "\u035e\u0001\u035e\u0001\u035e\u0001\u035e\u0001\u035e\u0001\u035e\u0001"+ + "\u035e\u0001\u035e\u0001\u035e\u0001\u035e\u0001\u035f\u0001\u035f\u0001"+ + "\u035f\u0001\u035f\u0001\u035f\u0001\u035f\u0001\u035f\u0001\u035f\u0001"+ + "\u035f\u0001\u035f\u0001\u0360\u0001\u0360\u0001\u0360\u0001\u0360\u0001"+ + "\u0360\u0001\u0360\u0001\u0360\u0001\u0360\u0001\u0360\u0001\u0360\u0001"+ + "\u0361\u0001\u0361\u0001\u0361\u0001\u0361\u0001\u0361\u0001\u0361\u0001"+ + "\u0361\u0001\u0362\u0001\u0362\u0001\u0362\u0001\u0362\u0001\u0362\u0001"+ + "\u0362\u0001\u0362\u0001\u0362\u0001\u0363\u0001\u0363\u0001\u0363\u0001"+ + "\u0363\u0001\u0363\u0001\u0363\u0001\u0363\u0001\u0363\u0001\u0363\u0001"+ + "\u0363\u0001\u0363\u0001\u0363\u0001\u0364\u0001\u0364\u0001\u0364\u0001"+ + "\u0364\u0001\u0364\u0001\u0364\u0001\u0364\u0001\u0364\u0001\u0364\u0001"+ + "\u0364\u0001\u0364\u0001\u0364\u0001\u0365\u0001\u0365\u0001\u0365\u0001"+ + "\u0365\u0001\u0365\u0001\u0365\u0001\u0365\u0001\u0365\u0001\u0365\u0001"+ + "\u0365\u0001\u0366\u0001\u0366\u0001\u0366\u0001\u0366\u0001\u0366\u0001"+ + "\u0366\u0001\u0366\u0001\u0366\u0001\u0366\u0001\u0367\u0001\u0367\u0001"+ + "\u0367\u0001\u0367\u0001\u0368\u0001\u0368\u0001\u0368\u0001\u0368\u0001"+ + "\u0368\u0001\u0368\u0001\u0368\u0001\u0369\u0001\u0369\u0001\u0369\u0001"+ + "\u0369\u0001\u0369\u0001\u0369\u0001\u0369\u0001\u0369\u0001\u036a\u0001"+ + "\u036a\u0001\u036a\u0001\u036a\u0001\u036a\u0001\u036a\u0001\u036a\u0001"+ + "\u036a\u0001\u036a\u0001\u036b\u0001\u036b\u0001\u036b\u0001\u036b\u0001"+ + "\u036b\u0001\u036b\u0001\u036b\u0001\u036b\u0001\u036b\u0001\u036b\u0001"+ + "\u036b\u0001\u036b\u0001\u036b\u0001\u036b\u0001\u036b\u0001\u036b\u0001"+ + "\u036b\u0001\u036c\u0001\u036c\u0001\u036c\u0001\u036c\u0001\u036c\u0001"+ + "\u036c\u0001\u036c\u0001\u036c\u0001\u036c\u0001\u036d\u0001\u036d\u0001"+ + "\u036d\u0001\u036d\u0001\u036d\u0001\u036d\u0001\u036d\u0001\u036e\u0001"+ + "\u036e\u0001\u036e\u0001\u036e\u0001\u036f\u0001\u036f\u0001\u036f\u0001"+ + "\u036f\u0001\u036f\u0001\u036f\u0001\u036f\u0001\u036f\u0001\u036f\u0001"+ + "\u036f\u0001\u036f\u0001\u0370\u0001\u0370\u0001\u0370\u0001\u0370\u0001"+ + "\u0370\u0001\u0370\u0001\u0370\u0001\u0370\u0001\u0370\u0001\u0370\u0001"+ + "\u0370\u0001\u0370\u0001\u0370\u0001\u0371\u0001\u0371\u0001\u0371\u0001"+ + "\u0371\u0001\u0371\u0001\u0371\u0001\u0371\u0001\u0371\u0001\u0371\u0001"+ + "\u0371\u0001\u0371\u0001\u0371\u0001\u0371\u0001\u0372\u0001\u0372\u0001"+ + "\u0372\u0001\u0372\u0001\u0372\u0001\u0372\u0001\u0373\u0001\u0373\u0001"+ + "\u0373\u0001\u0373\u0001\u0373\u0001\u0373\u0001\u0373\u0001\u0373\u0001"+ + "\u0373\u0001\u0373\u0001\u0373\u0001\u0373\u0001\u0374\u0001\u0374\u0001"+ + "\u0374\u0001\u0374\u0001\u0374\u0001\u0374\u0001\u0375\u0001\u0375\u0001"+ + "\u0375\u0001\u0375\u0001\u0375\u0001\u0375\u0001\u0375\u0001\u0376\u0001"+ + "\u0376\u0001\u0376\u0001\u0376\u0001\u0376\u0001\u0376\u0001\u0376\u0001"+ + "\u0376\u0001\u0376\u0001\u0376\u0001\u0376\u0001\u0377\u0001\u0377\u0001"+ + "\u0377\u0001\u0377\u0001\u0377\u0001\u0377\u0001\u0377\u0001\u0377\u0001"+ + "\u0377\u0001\u0377\u0001\u0377\u0001\u0377\u0001\u0378\u0001\u0378\u0001"+ + "\u0378\u0001\u0378\u0001\u0378\u0001\u0378\u0001\u0378\u0001\u0378\u0001"+ + "\u0378\u0001\u0378\u0001\u0379\u0001\u0379\u0001\u0379\u0001\u0379\u0001"+ + "\u0379\u0001\u0379\u0001\u0379\u0001\u0379\u0001\u0379\u0001\u0379\u0001"+ + "\u0379\u0001\u0379\u0001\u0379\u0001\u0379\u0001\u037a\u0001\u037a\u0001"+ + "\u037a\u0001\u037a\u0001\u037a\u0001\u037a\u0001\u037a\u0001\u037a\u0001"+ + "\u037a\u0001\u037a\u0001\u037a\u0001\u037a\u0001\u037a\u0001\u037a\u0001"+ + "\u037a\u0001\u037a\u0001\u037a\u0001\u037b\u0001\u037b\u0001\u037b\u0001"+ + "\u037b\u0001\u037b\u0001\u037b\u0001\u037b\u0001\u037b\u0001\u037b\u0001"+ + "\u037b\u0001\u037b\u0001\u037b\u0001\u037b\u0001\u037b\u0001\u037b\u0001"+ + "\u037b\u0001\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001"+ + "\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001"+ + "\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001"+ + "\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001"+ + "\u037c\u0001\u037c\u0001\u037c\u0001\u037c\u0001\u037d\u0001\u037d\u0001"+ + "\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001"+ + "\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001"+ + "\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001"+ + "\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001\u037d\u0001"+ + "\u037e\u0001\u037e\u0001\u037e\u0001\u037e\u0001\u037e\u0001\u037e\u0001"+ + "\u037e\u0001\u037e\u0001\u037e\u0001\u037e\u0001\u037e\u0001\u037e\u0001"+ + "\u037e\u0001\u037e\u0001\u037e\u0001\u037e\u0001\u037e\u0001\u037f\u0001"+ + "\u037f\u0001\u037f\u0001\u037f\u0001\u037f\u0001\u037f\u0001\u037f\u0001"+ + "\u037f\u0001\u037f\u0001\u037f\u0001\u037f\u0001\u037f\u0001\u037f\u0001"+ + "\u037f\u0001\u037f\u0001\u037f\u0001\u0380\u0001\u0380\u0001\u0380\u0001"+ + "\u0380\u0001\u0380\u0001\u0380\u0001\u0380\u0001\u0380\u0001\u0380\u0001"+ + "\u0380\u0001\u0381\u0001\u0381\u0001\u0381\u0001\u0381\u0001\u0381\u0001"+ + "\u0381\u0001\u0381\u0001\u0381\u0001\u0381\u0001\u0381\u0001\u0381\u0001"+ + "\u0381\u0001\u0381\u0001\u0382\u0001\u0382\u0001\u0382\u0001\u0382\u0001"+ + "\u0382\u0001\u0382\u0001\u0382\u0001\u0382\u0001\u0382\u0001\u0382\u0001"+ + "\u0382\u0001\u0382\u0001\u0382\u0001\u0383\u0001\u0383\u0001\u0383\u0001"+ + "\u0383\u0001\u0383\u0001\u0383\u0001\u0383\u0001\u0383\u0001\u0383"; + private static final String _serializedATNSegment1 = + "\u0001\u0383\u0001\u0383\u0001\u0383\u0001\u0384\u0001\u0384\u0001\u0384"+ + "\u0001\u0384\u0001\u0384\u0001\u0384\u0001\u0384\u0001\u0384\u0001\u0384"+ + "\u0001\u0384\u0001\u0384\u0001\u0385\u0001\u0385\u0001\u0385\u0001\u0385"+ + "\u0001\u0385\u0001\u0385\u0001\u0385\u0001\u0385\u0001\u0385\u0001\u0386"+ + "\u0001\u0386\u0001\u0386\u0001\u0386\u0001\u0386\u0001\u0386\u0001\u0386"+ + "\u0001\u0386\u0001\u0387\u0001\u0387\u0001\u0387\u0001\u0387\u0001\u0387"+ + "\u0001\u0387\u0001\u0387\u0001\u0387\u0001\u0387\u0001\u0388\u0001\u0388"+ + "\u0001\u0388\u0001\u0388\u0001\u0388\u0001\u0388\u0001\u0388\u0001\u0388"+ + "\u0001\u0388\u0001\u0388\u0001\u0388\u0001\u0388\u0001\u0389\u0001\u0389"+ + "\u0001\u0389\u0001\u0389\u0001\u0389\u0001\u0389\u0001\u0389\u0001\u0389"+ + "\u0001\u0389\u0001\u0389\u0001\u0389\u0001\u0389\u0001\u0389\u0001\u0389"+ + "\u0001\u038a\u0001\u038a\u0001\u038a\u0001\u038a\u0001\u038b\u0001\u038b"+ + "\u0001\u038b\u0001\u038b\u0001\u038b\u0001\u038b\u0001\u038b\u0001\u038c"+ + "\u0001\u038c\u0001\u038c\u0001\u038c\u0001\u038c\u0001\u038c\u0001\u038c"+ + "\u0001\u038c\u0001\u038c\u0001\u038c\u0001\u038c\u0001\u038d\u0001\u038d"+ + "\u0001\u038d\u0001\u038d\u0001\u038d\u0001\u038d\u0001\u038d\u0001\u038d"+ + "\u0001\u038d\u0001\u038d\u0001\u038d\u0001\u038e\u0001\u038e\u0001\u038e"+ + "\u0001\u038e\u0001\u038e\u0001\u038e\u0001\u038e\u0001\u038e\u0001\u038e"+ + "\u0001\u038e\u0001\u038f\u0001\u038f\u0001\u038f\u0001\u038f\u0001\u038f"+ + "\u0001\u038f\u0001\u038f\u0001\u038f\u0001\u038f\u0001\u038f\u0001\u0390"+ + "\u0001\u0390\u0001\u0390\u0001\u0390\u0001\u0390\u0001\u0390\u0001\u0391"+ + "\u0001\u0391\u0001\u0391\u0001\u0391\u0001\u0391\u0001\u0391\u0001\u0391"+ + "\u0001\u0391\u0001\u0391\u0001\u0391\u0001\u0391\u0001\u0391\u0001\u0391"+ + "\u0001\u0391\u0001\u0392\u0001\u0392\u0001\u0392\u0001\u0392\u0001\u0392"+ + "\u0001\u0392\u0001\u0392\u0001\u0392\u0001\u0392\u0001\u0392\u0001\u0392"+ + "\u0001\u0393\u0001\u0393\u0001\u0393\u0001\u0393\u0001\u0393\u0001\u0393"+ + "\u0001\u0393\u0001\u0393\u0001\u0393\u0001\u0394\u0001\u0394\u0001\u0394"+ + "\u0001\u0394\u0001\u0394\u0001\u0394\u0001\u0394\u0001\u0394\u0001\u0395"+ + "\u0001\u0395\u0001\u0395\u0001\u0395\u0001\u0395\u0001\u0395\u0001\u0395"+ + "\u0001\u0396\u0001\u0396\u0001\u0396\u0001\u0396\u0001\u0396\u0001\u0396"+ + "\u0001\u0396\u0001\u0396\u0001\u0396\u0001\u0397\u0001\u0397\u0001\u0397"+ + "\u0001\u0397\u0001\u0397\u0001\u0397\u0001\u0397\u0001\u0397\u0001\u0397"+ + "\u0001\u0397\u0001\u0397\u0001\u0397\u0001\u0397\u0001\u0398\u0001\u0398"+ + "\u0001\u0398\u0001\u0398\u0001\u0398\u0001\u0398\u0001\u0398\u0001\u0398"+ + "\u0001\u0399\u0001\u0399\u0001\u0399\u0001\u0399\u0001\u0399\u0001\u0399"+ + "\u0001\u0399\u0001\u0399\u0001\u0399\u0001\u0399\u0001\u0399\u0001\u0399"+ + "\u0001\u0399\u0001\u0399\u0001\u0399\u0001\u039a\u0001\u039a\u0001\u039a"+ + "\u0001\u039a\u0001\u039a\u0001\u039a\u0001\u039a\u0001\u039a\u0001\u039a"+ + "\u0001\u039a\u0001\u039a\u0001\u039a\u0001\u039a\u0001\u039a\u0001\u039a"+ + "\u0001\u039b\u0001\u039b\u0001\u039b\u0001\u039b\u0001\u039b\u0001\u039b"+ + "\u0001\u039b\u0001\u039b\u0001\u039c\u0001\u039c\u0001\u039c\u0001\u039c"+ + "\u0001\u039c\u0001\u039c\u0001\u039c\u0001\u039c\u0001\u039c\u0001\u039c"+ + "\u0001\u039c\u0001\u039c\u0001\u039c\u0001\u039d\u0001\u039d\u0001\u039d"+ + "\u0001\u039d\u0001\u039d\u0001\u039d\u0001\u039d\u0001\u039d\u0001\u039d"+ + "\u0001\u039d\u0001\u039d\u0001\u039d\u0001\u039d\u0001\u039d\u0001\u039d"+ + "\u0001\u039e\u0001\u039e\u0001\u039e\u0001\u039e\u0001\u039e\u0001\u039e"+ + "\u0001\u039f\u0001\u039f\u0001\u039f\u0001\u039f\u0001\u039f\u0001\u039f"+ + "\u0001\u03a0\u0001\u03a0\u0001\u03a0\u0001\u03a0\u0001\u03a0\u0001\u03a0"+ + "\u0001\u03a0\u0001\u03a1\u0001\u03a1\u0001\u03a1\u0001\u03a1\u0001\u03a1"+ + "\u0001\u03a1\u0001\u03a1\u0001\u03a1\u0001\u03a1\u0001\u03a1\u0001\u03a1"+ + "\u0001\u03a1\u0001\u03a1\u0001\u03a2\u0001\u03a2\u0001\u03a2\u0001\u03a2"+ + "\u0001\u03a2\u0001\u03a2\u0001\u03a2\u0001\u03a2\u0001\u03a2\u0001\u03a2"+ + "\u0001\u03a2\u0001\u03a2\u0001\u03a3\u0001\u03a3\u0001\u03a3\u0001\u03a3"+ + "\u0001\u03a3\u0001\u03a3\u0001\u03a3\u0001\u03a3\u0001\u03a3\u0001\u03a3"+ + "\u0001\u03a3\u0001\u03a3\u0001\u03a3\u0001\u03a3\u0001\u03a3\u0001\u03a3"+ + "\u0001\u03a3\u0001\u03a3\u0001\u03a3\u0001\u03a4\u0001\u03a4\u0001\u03a4"+ + "\u0001\u03a4\u0001\u03a4\u0001\u03a4\u0001\u03a4\u0001\u03a4\u0001\u03a4"+ + "\u0001\u03a4\u0001\u03a4\u0001\u03a4\u0001\u03a4\u0001\u03a4\u0001\u03a4"+ + "\u0001\u03a4\u0001\u03a4\u0001\u03a4\u0001\u03a5\u0001\u03a5\u0001\u03a5"+ + "\u0001\u03a6\u0001\u03a6\u0001\u03a6\u0001\u03a6\u0001\u03a6\u0001\u03a6"+ + "\u0001\u03a6\u0001\u03a6\u0001\u03a6\u0001\u03a6\u0001\u03a7\u0001\u03a7"+ + "\u0001\u03a7\u0001\u03a7\u0001\u03a7\u0001\u03a7\u0001\u03a7\u0001\u03a8"+ + "\u0001\u03a8\u0001\u03a8\u0001\u03a8\u0001\u03a9\u0001\u03a9\u0001\u03a9"+ + "\u0001\u03a9\u0001\u03a9\u0001\u03a9\u0001\u03aa\u0001\u03aa\u0001\u03aa"+ + "\u0001\u03aa\u0001\u03aa\u0001\u03ab\u0001\u03ab\u0001\u03ab\u0001\u03ab"+ + "\u0001\u03ab\u0001\u03ab\u0001\u03ac\u0001\u03ac\u0001\u03ac\u0001\u03ac"+ + "\u0001\u03ac\u0001\u03ad\u0001\u03ad\u0001\u03ad\u0001\u03ad\u0001\u03ad"+ + "\u0001\u03ad\u0001\u03ae\u0001\u03ae\u0001\u03ae\u0001\u03ae\u0001\u03ae"+ + "\u0001\u03ae\u0001\u03ae\u0001\u03ae\u0001\u03ae\u0001\u03af\u0001\u03af"+ + "\u0001\u03af\u0001\u03af\u0001\u03af\u0001\u03af\u0001\u03af\u0001\u03af"+ + "\u0001\u03af\u0001\u03b0\u0001\u03b0\u0001\u03b0\u0001\u03b0\u0001\u03b0"+ + "\u0001\u03b0\u0001\u03b0\u0001\u03b0\u0001\u03b0\u0001\u03b1\u0001\u03b1"+ + "\u0001\u03b1\u0001\u03b1\u0001\u03b1\u0001\u03b1\u0001\u03b1\u0001\u03b1"+ + "\u0001\u03b1\u0001\u03b1\u0001\u03b1\u0001\u03b1\u0001\u03b1\u0001\u03b1"+ + "\u0001\u03b1\u0001\u03b1\u0001\u03b2\u0001\u03b2\u0001\u03b2\u0001\u03b2"+ + "\u0001\u03b2\u0001\u03b2\u0001\u03b2\u0001\u03b2\u0001\u03b2\u0001\u03b2"+ + "\u0001\u03b2\u0001\u03b2\u0001\u03b3\u0001\u03b3\u0001\u03b3\u0001\u03b3"+ + "\u0001\u03b3\u0001\u03b3\u0001\u03b3\u0001\u03b3\u0001\u03b3\u0001\u03b3"+ + "\u0001\u03b3\u0001\u03b3\u0001\u03b4\u0001\u03b4\u0001\u03b4\u0001\u03b4"+ + "\u0001\u03b4\u0001\u03b4\u0001\u03b4\u0001\u03b4\u0001\u03b4\u0001\u03b5"+ + "\u0001\u03b5\u0001\u03b5\u0001\u03b5\u0001\u03b5\u0001\u03b5\u0001\u03b5"+ + "\u0001\u03b5\u0001\u03b5\u0001\u03b5\u0001\u03b5\u0001\u03b5\u0001\u03b5"+ + "\u0001\u03b5\u0001\u03b6\u0001\u03b6\u0001\u03b6\u0001\u03b6\u0001\u03b6"+ + "\u0001\u03b6\u0001\u03b6\u0001\u03b6\u0001\u03b6\u0001\u03b6\u0001\u03b6"+ + "\u0001\u03b6\u0001\u03b7\u0001\u03b7\u0001\u03b7\u0001\u03b7\u0001\u03b7"+ + "\u0001\u03b7\u0001\u03b7\u0001\u03b7\u0001\u03b7\u0001\u03b7\u0001\u03b7"+ + "\u0001\u03b8\u0001\u03b8\u0001\u03b8\u0001\u03b8\u0001\u03b8\u0001\u03b8"+ + "\u0001\u03b8\u0001\u03b8\u0001\u03b8\u0001\u03b8\u0001\u03b9\u0001\u03b9"+ + "\u0001\u03b9\u0001\u03b9\u0001\u03ba\u0001\u03ba\u0001\u03ba\u0001\u03ba"+ + "\u0001\u03ba\u0001\u03ba\u0001\u03ba\u0001\u03ba\u0001\u03ba\u0001\u03ba"+ + "\u0001\u03ba\u0001\u03ba\u0001\u03ba\u0001\u03ba\u0001\u03bb\u0001\u03bb"+ + "\u0001\u03bb\u0001\u03bb\u0001\u03bb\u0001\u03bb\u0001\u03bb\u0001\u03bb"+ + "\u0001\u03bb\u0001\u03bb\u0001\u03bb\u0001\u03bb\u0001\u03bb\u0001\u03bc"+ + "\u0001\u03bc\u0001\u03bc\u0001\u03bc\u0001\u03bc\u0001\u03bc\u0001\u03bc"+ + "\u0001\u03bc\u0001\u03bc\u0001\u03bc\u0001\u03bd\u0001\u03bd\u0001\u03bd"+ + "\u0001\u03bd\u0001\u03bd\u0001\u03bd\u0001\u03bd\u0001\u03bd\u0001\u03bd"+ + "\u0001\u03bd\u0001\u03bd\u0001\u03bd\u0001\u03bd\u0001\u03bd\u0001\u03bd"+ + "\u0001\u03be\u0001\u03be\u0001\u03be\u0001\u03be\u0001\u03be\u0001\u03be"+ + "\u0001\u03be\u0001\u03be\u0001\u03be\u0001\u03be\u0001\u03be\u0001\u03be"+ + "\u0001\u03be\u0001\u03be\u0001\u03bf\u0001\u03bf\u0001\u03bf\u0001\u03bf"+ + "\u0001\u03bf\u0001\u03bf\u0001\u03bf\u0001\u03bf\u0001\u03bf\u0001\u03bf"+ + "\u0001\u03bf\u0001\u03bf\u0001\u03bf\u0001\u03bf\u0001\u03c0\u0001\u03c0"+ + "\u0001\u03c0\u0001\u03c0\u0001\u03c0\u0001\u03c0\u0001\u03c0\u0001\u03c0"+ + "\u0001\u03c0\u0001\u03c0\u0001\u03c0\u0001\u03c0\u0001\u03c0\u0001\u03c1"+ + "\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1"+ + "\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1"+ + "\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1"+ + "\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c1\u0001\u03c2"+ + "\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2"+ + "\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2"+ + "\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2"+ + "\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c2\u0001\u03c3\u0001\u03c3"+ + "\u0001\u03c3\u0001\u03c3\u0001\u03c3\u0001\u03c3\u0001\u03c3\u0001\u03c3"+ + "\u0001\u03c3\u0001\u03c3\u0001\u03c3\u0001\u03c3\u0001\u03c3\u0001\u03c3"+ + "\u0001\u03c3\u0001\u03c3\u0001\u03c3\u0001\u03c3\u0001\u03c3\u0001\u03c4"+ + "\u0001\u03c4\u0001\u03c4\u0001\u03c4\u0001\u03c4\u0001\u03c4\u0001\u03c4"+ + "\u0001\u03c4\u0001\u03c4\u0001\u03c4\u0001\u03c4\u0001\u03c4\u0001\u03c4"+ + "\u0001\u03c4\u0001\u03c4\u0001\u03c4\u0001\u03c4\u0001\u03c4\u0001\u03c5"+ + "\u0001\u03c5\u0001\u03c5\u0001\u03c5\u0001\u03c5\u0001\u03c5\u0001\u03c5"+ + "\u0001\u03c5\u0001\u03c5\u0001\u03c5\u0001\u03c5\u0001\u03c5\u0001\u03c5"+ + "\u0001\u03c5\u0001\u03c5\u0001\u03c5\u0001\u03c5\u0001\u03c5\u0001\u03c5"+ + "\u0001\u03c5\u0001\u03c5\u0001\u03c6\u0001\u03c6\u0001\u03c6\u0001\u03c6"+ + "\u0001\u03c6\u0001\u03c6\u0001\u03c6\u0001\u03c6\u0001\u03c6\u0001\u03c6"+ + "\u0001\u03c6\u0001\u03c6\u0001\u03c6\u0001\u03c6\u0001\u03c6\u0001\u03c6"+ + "\u0001\u03c6\u0001\u03c6\u0001\u03c6\u0001\u03c6\u0001\u03c7\u0001\u03c7"+ + "\u0001\u03c7\u0001\u03c7\u0001\u03c7\u0001\u03c7\u0001\u03c7\u0001\u03c7"+ + "\u0001\u03c7\u0001\u03c7\u0001\u03c7\u0001\u03c8\u0001\u03c8\u0001\u03c8"+ + "\u0001\u03c8\u0001\u03c8\u0001\u03c8\u0001\u03c8\u0001\u03c9\u0001\u03c9"+ + "\u0001\u03c9\u0001\u03c9\u0001\u03c9\u0001\u03c9\u0001\u03c9\u0001\u03c9"+ + "\u0001\u03c9\u0001\u03c9\u0001\u03c9\u0001\u03c9\u0001\u03c9\u0001\u03c9"+ + "\u0001\u03ca\u0001\u03ca\u0001\u03ca\u0001\u03ca\u0001\u03ca\u0001\u03ca"+ + "\u0001\u03ca\u0001\u03ca\u0001\u03ca\u0001\u03ca\u0001\u03ca\u0001\u03ca"+ + "\u0001\u03ca\u0001\u03ca\u0001\u03ca\u0001\u03ca\u0001\u03ca\u0001\u03cb"+ + "\u0001\u03cb\u0001\u03cb\u0001\u03cb\u0001\u03cb\u0001\u03cb\u0001\u03cb"+ + "\u0001\u03cb\u0001\u03cb\u0001\u03cb\u0001\u03cc\u0001\u03cc\u0001\u03cc"+ + "\u0001\u03cc\u0001\u03cd\u0001\u03cd\u0001\u03cd\u0001\u03cd\u0001\u03cd"+ + "\u0001\u03cd\u0001\u03cd\u0001\u03cd\u0001\u03cd\u0001\u03cd\u0001\u03cd"+ + "\u0001\u03cd\u0001\u03cd\u0001\u03ce\u0001\u03ce\u0001\u03ce\u0001\u03ce"+ + "\u0001\u03cf\u0001\u03cf\u0001\u03cf\u0001\u03cf\u0001\u03cf\u0001\u03cf"+ + "\u0001\u03cf\u0001\u03cf\u0001\u03cf\u0001\u03d0\u0001\u03d0\u0001\u03d0"+ + "\u0001\u03d0\u0001\u03d0\u0001\u03d0\u0001\u03d0\u0001\u03d0\u0001\u03d0"+ + "\u0001\u03d0\u0001\u03d0\u0001\u03d1\u0001\u03d1\u0001\u03d1\u0001\u03d1"+ + "\u0001\u03d1\u0001\u03d1\u0001\u03d1\u0001\u03d1\u0001\u03d1\u0001\u03d1"+ + "\u0001\u03d1\u0001\u03d1\u0001\u03d2\u0001\u03d2\u0001\u03d2\u0001\u03d3"+ + "\u0001\u03d3\u0001\u03d3\u0001\u03d3\u0001\u03d3\u0001\u03d3\u0001\u03d3"+ + "\u0001\u03d3\u0001\u03d3\u0001\u03d3\u0001\u03d3\u0001\u03d3\u0001\u03d3"+ + "\u0001\u03d3\u0001\u03d4\u0001\u03d4\u0001\u03d4\u0001\u03d4\u0001\u03d4"+ + "\u0001\u03d4\u0001\u03d4\u0001\u03d4\u0001\u03d4\u0001\u03d4\u0001\u03d4"+ + "\u0001\u03d4\u0001\u03d4\u0001\u03d5\u0001\u03d5\u0001\u03d5\u0001\u03d5"+ + "\u0001\u03d5\u0001\u03d5\u0001\u03d5\u0001\u03d6\u0001\u03d6\u0001\u03d6"+ + "\u0001\u03d6\u0001\u03d6\u0001\u03d6\u0001\u03d6\u0001\u03d6\u0001\u03d6"+ + "\u0001\u03d6\u0001\u03d6\u0001\u03d6\u0001\u03d6\u0001\u03d7\u0001\u03d7"+ + "\u0001\u03d7\u0001\u03d7\u0001\u03d7\u0001\u03d7\u0001\u03d7\u0001\u03d7"+ + "\u0001\u03d7\u0001\u03d7\u0001\u03d7\u0001\u03d7\u0001\u03d8\u0001\u03d8"+ + "\u0001\u03d8\u0001\u03d8\u0001\u03d8\u0001\u03d8\u0001\u03d8\u0001\u03d8"+ + "\u0001\u03d8\u0001\u03d8\u0001\u03d8\u0001\u03d8\u0001\u03d8\u0001\u03d8"+ + "\u0001\u03d8\u0001\u03d8\u0001\u03d9\u0001\u03d9\u0001\u03d9\u0001\u03d9"+ + "\u0001\u03d9\u0001\u03d9\u0001\u03d9\u0001\u03d9\u0001\u03d9\u0001\u03d9"+ + "\u0001\u03d9\u0001\u03d9\u0001\u03d9\u0001\u03d9\u0001\u03d9\u0001\u03da"+ + "\u0001\u03da\u0001\u03da\u0001\u03da\u0001\u03db\u0001\u03db\u0001\u03db"+ + "\u0001\u03db\u0001\u03db\u0001\u03db\u0001\u03dc\u0001\u03dc\u0001\u03dc"+ + "\u0001\u03dc\u0001\u03dc\u0001\u03dc\u0001\u03dd\u0001\u03dd\u0001\u03dd"+ + "\u0001\u03dd\u0001\u03dd\u0001\u03dd\u0001\u03dd\u0001\u03dd\u0001\u03de"+ + "\u0001\u03de\u0001\u03de\u0001\u03de\u0001\u03de\u0001\u03df\u0001\u03df"+ + "\u0001\u03df\u0001\u03df\u0001\u03df\u0001\u03df\u0001\u03df\u0001\u03e0"+ + "\u0001\u03e0\u0001\u03e0\u0001\u03e0\u0001\u03e0\u0001\u03e0\u0001\u03e0"+ + "\u0001\u03e0\u0001\u03e0\u0001\u03e0\u0001\u03e0\u0001\u03e0\u0001\u03e0"+ + "\u0001\u03e1\u0001\u03e1\u0001\u03e1\u0001\u03e1\u0001\u03e1\u0001\u03e1"+ + "\u0001\u03e1\u0001\u03e1\u0001\u03e1\u0001\u03e1\u0001\u03e1\u0001\u03e1"+ + "\u0001\u03e1\u0001\u03e2\u0001\u03e2\u0001\u03e2\u0001\u03e2\u0001\u03e2"+ + "\u0001\u03e2\u0001\u03e2\u0001\u03e2\u0001\u03e3\u0001\u03e3\u0001\u03e3"+ + "\u0001\u03e3\u0001\u03e3\u0001\u03e3\u0001\u03e4\u0001\u03e4\u0001\u03e4"+ + "\u0001\u03e4\u0001\u03e4\u0001\u03e4\u0001\u03e4\u0001\u03e4\u0001\u03e4"+ + "\u0001\u03e4\u0001\u03e5\u0001\u03e5\u0001\u03e5\u0001\u03e5\u0001\u03e5"+ + "\u0001\u03e6\u0001\u03e6\u0001\u03e6\u0001\u03e6\u0001\u03e6\u0001\u03e6"+ + "\u0001\u03e7\u0001\u03e7\u0001\u03e7\u0001\u03e7\u0001\u03e7\u0001\u03e7"+ + "\u0001\u03e7\u0001\u03e7\u0001\u03e7\u0001\u03e7\u0001\u03e7\u0001\u03e7"+ + "\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8"+ + "\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8"+ + "\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8"+ + "\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e8"+ + "\u0001\u03e8\u0001\u03e8\u0001\u03e8\u0001\u03e9\u0001\u03e9\u0001\u03e9"+ + "\u0001\u03e9\u0001\u03e9\u0001\u03e9\u0001\u03e9\u0001\u03e9\u0001\u03e9"+ + "\u0001\u03e9\u0001\u03e9\u0001\u03e9\u0001\u03e9\u0001\u03ea\u0001\u03ea"+ + "\u0001\u03ea\u0001\u03ea\u0001\u03eb\u0001\u03eb\u0001\u03eb\u0001\u03eb"+ + "\u0001\u03eb\u0001\u03ec\u0001\u03ec\u0001\u03ec\u0001\u03ec\u0001\u03ec"+ + "\u0001\u03ed\u0001\u03ed\u0001\u03ed\u0001\u03ed\u0001\u03ed\u0001\u03ed"+ + "\u0001\u03ed\u0001\u03ed\u0001\u03ed\u0001\u03ed\u0001\u03ed\u0001\u03ed"+ + "\u0001\u03ee\u0001\u03ee\u0001\u03ee\u0001\u03ee\u0001\u03ee\u0001\u03ef"+ + "\u0001\u03ef\u0001\u03ef\u0001\u03ef\u0001\u03f0\u0001\u03f0\u0001\u03f0"+ + "\u0001\u03f0\u0001\u03f0\u0001\u03f0\u0001\u03f1\u0001\u03f1\u0001\u03f1"+ + "\u0001\u03f1\u0001\u03f1\u0001\u03f1\u0001\u03f1\u0001\u03f1\u0001\u03f2"+ + "\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2"+ + "\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2"+ + "\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2"+ + "\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f2"+ + "\u0001\u03f2\u0001\u03f2\u0001\u03f2\u0001\u03f3\u0001\u03f3\u0001\u03f3"+ + "\u0001\u03f3\u0001\u03f3\u0001\u03f4\u0001\u03f4\u0001\u03f4\u0001\u03f4"+ + "\u0001\u03f4\u0001\u03f5\u0001\u03f5\u0001\u03f5\u0001\u03f5\u0001\u03f5"+ + "\u0001\u03f5\u0001\u03f5\u0001\u03f5\u0001\u03f5\u0001\u03f5\u0001\u03f5"+ + "\u0001\u03f6\u0001\u03f6\u0001\u03f6\u0001\u03f6\u0001\u03f6\u0001\u03f6"+ + "\u0001\u03f6\u0001\u03f7\u0001\u03f7\u0001\u03f7\u0001\u03f7\u0001\u03f7"+ + "\u0001\u03f7\u0001\u03f7\u0001\u03f7\u0001\u03f7\u0001\u03f7\u0001\u03f7"+ + "\u0001\u03f7\u0001\u03f8\u0001\u03f8\u0001\u03f8\u0001\u03f8\u0001\u03f8"+ + "\u0001\u03f8\u0001\u03f8\u0001\u03f8\u0001\u03f9\u0001\u03f9\u0001\u03f9"+ + "\u0001\u03f9\u0001\u03f9\u0001\u03f9\u0001\u03f9\u0001\u03f9\u0001\u03f9"+ + "\u0001\u03f9\u0001\u03f9\u0001\u03f9\u0001\u03fa\u0001\u03fa\u0001\u03fa"+ + "\u0001\u03fa\u0001\u03fa\u0001\u03fa\u0001\u03fa\u0001\u03fa\u0001\u03fa"+ + "\u0001\u03fa\u0001\u03fb\u0001\u03fb\u0001\u03fb\u0001\u03fb\u0001\u03fb"+ + "\u0001\u03fb\u0001\u03fb\u0001\u03fb\u0001\u03fb\u0001\u03fc\u0001\u03fc"+ + "\u0001\u03fc\u0001\u03fc\u0001\u03fc\u0001\u03fc\u0001\u03fc\u0001\u03fc"+ + "\u0001\u03fc\u0001\u03fd\u0001\u03fd\u0001\u03fd\u0001\u03fd\u0001\u03fd"+ + "\u0001\u03fd\u0001\u03fd\u0001\u03fd\u0001\u03fd\u0001\u03fd\u0001\u03fe"+ + "\u0001\u03fe\u0001\u03fe\u0001\u03fe\u0001\u03fe\u0001\u03fe\u0001\u03fe"+ + "\u0001\u03fe\u0001\u03fe\u0001\u03fe\u0001\u03fe\u0001\u03fe\u0001\u03ff"+ + "\u0001\u03ff\u0001\u03ff\u0001\u03ff\u0001\u03ff\u0001\u03ff\u0001\u03ff"+ + "\u0001\u03ff\u0001\u03ff\u0001\u03ff\u0001\u03ff\u0001\u03ff\u0001\u0400"+ + "\u0001\u0400\u0001\u0400\u0001\u0400\u0001\u0400\u0001\u0400\u0001\u0400"+ + "\u0001\u0400\u0001\u0400\u0001\u0400\u0001\u0400\u0001\u0401\u0001\u0401"+ + "\u0001\u0401\u0001\u0401\u0001\u0401\u0001\u0401\u0001\u0401\u0001\u0401"+ + "\u0001\u0401\u0001\u0401\u0001\u0401\u0001\u0401\u0001\u0401\u0001\u0401"+ + "\u0001\u0402\u0001\u0402\u0001\u0402\u0001\u0402\u0001\u0402\u0001\u0402"+ + "\u0001\u0402\u0001\u0402\u0001\u0402\u0001\u0402\u0001\u0402\u0001\u0402"+ + "\u0001\u0402\u0001\u0403\u0001\u0403\u0001\u0403\u0001\u0403\u0001\u0403"+ + "\u0001\u0403\u0001\u0403\u0001\u0403\u0001\u0403\u0001\u0403\u0001\u0403"+ + "\u0001\u0403\u0001\u0404\u0001\u0404\u0001\u0404\u0001\u0404\u0001\u0404"+ + "\u0001\u0404\u0001\u0404\u0001\u0404\u0001\u0404\u0001\u0404\u0001\u0404"+ + "\u0001\u0404\u0001\u0405\u0001\u0405\u0001\u0405\u0001\u0405\u0001\u0405"+ + "\u0001\u0405\u0001\u0405\u0001\u0405\u0001\u0405\u0001\u0405\u0001\u0405"+ + "\u0001\u0405\u0001\u0406\u0001\u0406\u0001\u0406\u0001\u0406\u0001\u0406"+ + "\u0001\u0406\u0001\u0406\u0001\u0406\u0001\u0406\u0001\u0406\u0001\u0406"+ + "\u0001\u0406\u0001\u0407\u0001\u0407\u0001\u0407\u0001\u0407\u0001\u0407"+ + "\u0001\u0407\u0001\u0407\u0001\u0407\u0001\u0407\u0001\u0407\u0001\u0408"+ + "\u0001\u0408\u0001\u0408\u0001\u0408\u0001\u0408\u0001\u0408\u0001\u0408"+ + "\u0001\u0408\u0001\u0408\u0001\u0408\u0001\u0408\u0001\u0408\u0001\u0408"+ + "\u0001\u0408\u0001\u0408\u0001\u0408\u0001\u0409\u0001\u0409\u0001\u0409"+ + "\u0001\u0409\u0001\u0409\u0001\u0409\u0001\u0409\u0001\u0409\u0001\u0409"+ + "\u0001\u0409\u0001\u0409\u0001\u0409\u0001\u0409\u0001\u0409\u0001\u0409"+ + "\u0001\u0409\u0001\u0409\u0001\u0409\u0001\u0409\u0001\u0409\u0001\u040a"+ + "\u0001\u040a\u0001\u040a\u0001\u040a\u0001\u040a\u0001\u040a\u0001\u040a"+ + "\u0001\u040a\u0001\u040a\u0001\u040a\u0001\u040a\u0001\u040a\u0001\u040a"+ + "\u0001\u040a\u0001\u040a\u0001\u040a\u0001\u040a\u0001\u040a\u0001\u040a"+ + "\u0001\u040b\u0001\u040b\u0001\u040b\u0001\u040b\u0001\u040b\u0001\u040b"+ + "\u0001\u040b\u0001\u040b\u0001\u040b\u0001\u040b\u0001\u040b\u0001\u040b"+ + "\u0001\u040b\u0001\u040b\u0001\u040b\u0001\u040b\u0001\u040b\u0001\u040b"+ + "\u0001\u040b\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c"+ + "\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c"+ + "\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c"+ + "\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c"+ + "\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c\u0001\u040c"+ + "\u0001\u040c\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d"+ + "\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d"+ + "\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d"+ + "\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d"+ + "\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d\u0001\u040d"+ + "\u0001\u040e\u0001\u040e\u0001\u040e\u0001\u040e\u0001\u040e\u0001\u040e"+ + "\u0001\u040e\u0001\u040e\u0001\u040e\u0001\u040e\u0001\u040e\u0001\u040e"+ + "\u0001\u040e\u0001\u040e\u0001\u040e\u0001\u040e\u0001\u040e\u0001\u040e"+ + "\u0001\u040e\u0001\u040e\u0001\u040f\u0001\u040f\u0001\u040f\u0001\u040f"+ + "\u0001\u040f\u0001\u040f\u0001\u040f\u0001\u040f\u0001\u040f\u0001\u040f"+ + "\u0001\u040f\u0001\u040f\u0001\u040f\u0001\u040f\u0001\u040f\u0001\u040f"+ + "\u0001\u040f\u0001\u040f\u0001\u040f\u0001\u0410\u0001\u0410\u0001\u0410"+ + "\u0001\u0410\u0001\u0410\u0001\u0410\u0001\u0410\u0001\u0410\u0001\u0410"+ + "\u0001\u0410\u0001\u0410\u0001\u0410\u0001\u0410\u0001\u0411\u0001\u0411"+ + "\u0001\u0411\u0001\u0411\u0001\u0411\u0001\u0411\u0001\u0411\u0001\u0411"+ + "\u0001\u0411\u0001\u0411\u0001\u0411\u0001\u0411\u0001\u0411\u0001\u0411"+ + "\u0001\u0411\u0001\u0411\u0001\u0412\u0001\u0412\u0001\u0412\u0001\u0412"+ + "\u0001\u0412\u0001\u0412\u0001\u0412\u0001\u0412\u0001\u0412\u0001\u0412"+ + "\u0001\u0412\u0001\u0412\u0001\u0412\u0001\u0412\u0001\u0412\u0001\u0412"+ + "\u0001\u0413\u0001\u0413\u0001\u0413\u0001\u0413\u0001\u0413\u0001\u0413"+ + "\u0001\u0413\u0001\u0413\u0001\u0413\u0001\u0413\u0001\u0413\u0001\u0413"+ + "\u0001\u0413\u0001\u0413\u0001\u0413\u0001\u0414\u0001\u0414\u0001\u0414"+ + "\u0001\u0414\u0001\u0414\u0001\u0414\u0001\u0414\u0001\u0414\u0001\u0414"+ + "\u0001\u0414\u0001\u0414\u0001\u0414\u0001\u0414\u0001\u0414\u0001\u0414"+ + "\u0001\u0414\u0001\u0414\u0001\u0415\u0001\u0415\u0001\u0415\u0001\u0415"+ + "\u0001\u0415\u0001\u0415\u0001\u0415\u0001\u0415\u0001\u0415\u0001\u0415"+ + "\u0001\u0415\u0001\u0415\u0001\u0415\u0001\u0415\u0001\u0415\u0001\u0415"+ + "\u0001\u0416\u0001\u0416\u0001\u0416\u0001\u0416\u0001\u0416\u0001\u0416"+ + "\u0001\u0416\u0001\u0416\u0001\u0416\u0001\u0416\u0001\u0416\u0001\u0416"+ + "\u0001\u0416\u0001\u0416\u0001\u0417\u0001\u0417\u0001\u0417\u0001\u0417"+ + "\u0001\u0417\u0001\u0417\u0001\u0417\u0001\u0417\u0001\u0417\u0001\u0417"+ + "\u0001\u0417\u0001\u0417\u0001\u0418\u0001\u0418\u0001\u0418\u0001\u0418"+ + "\u0001\u0418\u0001\u0418\u0001\u0418\u0001\u0418\u0001\u0418\u0001\u0418"+ + "\u0001\u0418\u0001\u0419\u0001\u0419\u0001\u0419\u0001\u0419\u0001\u0419"+ + "\u0001\u0419\u0001\u0419\u0001\u0419\u0001\u0419\u0001\u0419\u0001\u0419"+ + "\u0001\u0419\u0001\u041a\u0001\u041a\u0001\u041a\u0001\u041a\u0001\u041a"+ + "\u0001\u041a\u0001\u041a\u0001\u041a\u0001\u041a\u0001\u041a\u0001\u041a"+ + "\u0001\u041a\u0001\u041a\u0001\u041a\u0001\u041a\u0001\u041a\u0001\u041b"+ + "\u0001\u041b\u0001\u041b\u0001\u041b\u0001\u041b\u0001\u041b\u0001\u041b"+ + "\u0001\u041b\u0001\u041b\u0001\u041b\u0001\u041b\u0001\u041b\u0001\u041b"+ + "\u0001\u041b\u0001\u041b\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c"+ + "\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c"+ + "\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c"+ + "\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c\u0001\u041c"+ + "\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041d"+ + "\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041d"+ + "\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041d"+ + "\u0001\u041d\u0001\u041d\u0001\u041d\u0001\u041e\u0001\u041e\u0001\u041e"+ + "\u0001\u041e\u0001\u041e\u0001\u041e\u0001\u041e\u0001\u041e\u0001\u041e"+ + "\u0001\u041e\u0001\u041e\u0001\u041e\u0001\u041e\u0001\u041e\u0001\u041e"+ + "\u0001\u041e\u0001\u041e\u0001\u041f\u0001\u041f\u0001\u041f\u0001\u041f"+ + "\u0001\u041f\u0001\u041f\u0001\u041f\u0001\u041f\u0001\u041f\u0001\u041f"+ + "\u0001\u041f\u0001\u041f\u0001\u041f\u0001\u041f\u0001\u041f\u0001\u041f"+ + "\u0001\u041f\u0001\u041f\u0001\u041f\u0001\u0420\u0001\u0420\u0001\u0420"+ + "\u0001\u0420\u0001\u0420\u0001\u0420\u0001\u0420\u0001\u0420\u0001\u0420"+ + "\u0001\u0420\u0001\u0420\u0001\u0420\u0001\u0420\u0001\u0420\u0001\u0420"+ + "\u0001\u0420\u0001\u0420\u0001\u0420\u0001\u0420\u0001\u0420\u0001\u0421"+ + "\u0001\u0421\u0001\u0421\u0001\u0421\u0001\u0421\u0001\u0421\u0001\u0421"+ + "\u0001\u0421\u0001\u0421\u0001\u0421\u0001\u0421\u0001\u0421\u0001\u0421"+ + "\u0001\u0422\u0001\u0422\u0001\u0422\u0001\u0422\u0001\u0422\u0001\u0422"+ + "\u0001\u0422\u0001\u0422\u0001\u0422\u0001\u0422\u0001\u0422\u0001\u0422"+ + "\u0001\u0423\u0001\u0423\u0001\u0423\u0001\u0423\u0001\u0423\u0001\u0423"+ + "\u0001\u0423\u0001\u0423\u0001\u0423\u0001\u0423\u0001\u0423\u0001\u0423"+ + "\u0001\u0423\u0001\u0423\u0001\u0423\u0001\u0423\u0001\u0423\u0001\u0424"+ + "\u0001\u0424\u0001\u0424\u0001\u0424\u0001\u0424\u0001\u0424\u0001\u0424"+ + "\u0001\u0424\u0001\u0424\u0001\u0424\u0001\u0424\u0001\u0424\u0001\u0424"+ + "\u0001\u0424\u0001\u0424\u0001\u0424\u0001\u0425\u0001\u0425\u0001\u0425"+ + "\u0001\u0425\u0001\u0425\u0001\u0425\u0001\u0425\u0001\u0425\u0001\u0425"+ + "\u0001\u0425\u0001\u0426\u0001\u0426\u0001\u0426\u0001\u0426\u0001\u0426"+ + "\u0001\u0426\u0001\u0426\u0001\u0426\u0001\u0426\u0001\u0426\u0001\u0426"+ + "\u0001\u0426\u0001\u0426\u0001\u0426\u0001\u0426\u0001\u0426\u0001\u0427"+ + "\u0001\u0427\u0001\u0427\u0001\u0427\u0001\u0427\u0001\u0427\u0001\u0427"+ + "\u0001\u0427\u0001\u0427\u0001\u0427\u0001\u0427\u0001\u0427\u0001\u0427"+ + "\u0001\u0427\u0001\u0427\u0001\u0428\u0001\u0428\u0001\u0428\u0001\u0428"+ + "\u0001\u0428\u0001\u0428\u0001\u0428\u0001\u0428\u0001\u0428\u0001\u0428"+ + "\u0001\u0428\u0001\u0428\u0001\u0428\u0001\u0428\u0001\u0428\u0001\u0428"+ + "\u0001\u0428\u0001\u0428\u0001\u0428\u0001\u0429\u0001\u0429\u0001\u0429"+ + "\u0001\u0429\u0001\u0429\u0001\u0429\u0001\u0429\u0001\u0429\u0001\u0429"+ + "\u0001\u0429\u0001\u0429\u0001\u0429\u0001\u0429\u0001\u0429\u0001\u0429"+ + "\u0001\u0429\u0001\u0429\u0001\u0429\u0001\u042a\u0001\u042a\u0001\u042a"+ + "\u0001\u042a\u0001\u042a\u0001\u042a\u0001\u042a\u0001\u042a\u0001\u042b"+ + "\u0001\u042b\u0001\u042b\u0001\u042b\u0001\u042b\u0001\u042b\u0001\u042b"+ + "\u0001\u042b\u0001\u042b\u0001\u042b\u0001\u042b\u0001\u042b\u0001\u042b"+ + "\u0001\u042b\u0001\u042c\u0001\u042c\u0001\u042c\u0001\u042c\u0001\u042c"+ + "\u0001\u042c\u0001\u042c\u0001\u042c\u0001\u042c\u0001\u042c\u0001\u042c"+ + "\u0001\u042c\u0001\u042c\u0001\u042c\u0001\u042c\u0001\u042c\u0001\u042c"+ + "\u0001\u042d\u0001\u042d\u0001\u042d\u0001\u042d\u0001\u042d\u0001\u042d"+ + "\u0001\u042d\u0001\u042d\u0001\u042d\u0001\u042d\u0001\u042d\u0001\u042e"+ + "\u0001\u042e\u0001\u042e\u0001\u042e\u0001\u042e\u0001\u042e\u0001\u042e"+ + "\u0001\u042e\u0001\u042e\u0001\u042f\u0001\u042f\u0001\u042f\u0001\u042f"+ + "\u0001\u042f\u0001\u042f\u0001\u042f\u0001\u042f\u0001\u042f\u0001\u042f"+ + "\u0001\u0430\u0001\u0430\u0001\u0430\u0001\u0430\u0001\u0430\u0001\u0431"+ + "\u0001\u0431\u0001\u0431\u0001\u0431\u0001\u0431\u0001\u0432\u0001\u0432"+ + "\u0001\u0432\u0001\u0432\u0001\u0432\u0001\u0432\u0001\u0432\u0001\u0432"+ + "\u0001\u0433\u0001\u0433\u0001\u0433\u0001\u0433\u0001\u0433\u0001\u0433"+ + "\u0001\u0433\u0001\u0433\u0001\u0433\u0001\u0433\u0001\u0433\u0001\u0433"+ + "\u0001\u0433\u0001\u0433\u0001\u0433\u0001\u0433\u0001\u0434\u0001\u0434"+ + "\u0001\u0434\u0001\u0434\u0001\u0434\u0001\u0434\u0001\u0434\u0001\u0434"+ + "\u0001\u0435\u0001\u0435\u0001\u0435\u0001\u0435\u0001\u0435\u0001\u0435"+ + "\u0001\u0435\u0001\u0435\u0001\u0435\u0001\u0435\u0001\u0435\u0001\u0435"+ + "\u0001\u0436\u0001\u0436\u0001\u0436\u0001\u0436\u0001\u0437\u0001\u0437"+ + "\u0001\u0437\u0001\u0437\u0001\u0437\u0001\u0437\u0001\u0437\u0001\u0437"+ + "\u0001\u0437\u0001\u0438\u0001\u0438\u0001\u0438\u0001\u0438\u0001\u0438"+ + "\u0001\u0438\u0001\u0438\u0001\u0438\u0001\u0438\u0001\u0438\u0001\u0438"+ + "\u0001\u0438\u0001\u0438\u0001\u0439\u0001\u0439\u0001\u0439\u0001\u0439"+ + "\u0001\u0439\u0001\u0439\u0001\u0439\u0001\u0439\u0001\u0439\u0001\u0439"+ + "\u0001\u0439\u0001\u0439\u0001\u0439\u0001\u0439\u0001\u043a\u0001\u043a"+ + "\u0001\u043a\u0001\u043a\u0001\u043a\u0001\u043a\u0001\u043a\u0001\u043a"+ + "\u0001\u043a\u0001\u043a\u0001\u043a\u0001\u043a\u0001\u043b\u0001\u043b"+ + "\u0001\u043b\u0001\u043b\u0001\u043b\u0001\u043b\u0001\u043b\u0001\u043b"+ + "\u0001\u043b\u0001\u043b\u0001\u043b\u0001\u043b\u0001\u043c\u0001\u043c"+ + "\u0001\u043c\u0001\u043c\u0001\u043c\u0001\u043c\u0001\u043c\u0001\u043c"+ + "\u0001\u043d\u0001\u043d\u0001\u043d\u0001\u043d\u0001\u043d\u0001\u043d"+ + "\u0001\u043d\u0001\u043d\u0001\u043d\u0001\u043d\u0001\u043e\u0001\u043e"+ + "\u0001\u043e\u0001\u043e\u0001\u043e\u0001\u043e\u0001\u043e\u0001\u043e"+ + "\u0001\u043f\u0001\u043f\u0001\u043f\u0001\u043f\u0001\u043f\u0001\u043f"+ + "\u0001\u043f\u0001\u043f\u0001\u043f\u0001\u043f\u0001\u043f\u0001\u0440"+ + "\u0001\u0440\u0001\u0440\u0001\u0440\u0001\u0440\u0001\u0440\u0001\u0440"+ + "\u0001\u0440\u0001\u0440\u0001\u0440\u0001\u0440\u0001\u0440\u0001\u0440"+ + "\u0001\u0440\u0001\u0440\u0001\u0440\u0001\u0440\u0001\u0440\u0001\u0440"+ + "\u0001\u0440\u0001\u0441\u0001\u0441\u0001\u0441\u0001\u0441\u0001\u0441"+ + "\u0001\u0441\u0001\u0442\u0001\u0442\u0001\u0442\u0001\u0442\u0001\u0442"+ + "\u0001\u0442\u0001\u0442\u0001\u0442\u0001\u0442\u0001\u0442\u0001\u0442"+ + "\u0001\u0443\u0001\u0443\u0001\u0443\u0001\u0443\u0001\u0443\u0001\u0443"+ + "\u0001\u0443\u0001\u0443\u0001\u0443\u0001\u0443\u0001\u0443\u0001\u0443"+ + "\u0001\u0443\u0001\u0443\u0001\u0443\u0001\u0443\u0001\u0443\u0001\u0443"+ + "\u0001\u0443\u0001\u0443\u0001\u0444\u0001\u0444\u0001\u0444\u0001\u0444"+ + "\u0001\u0444\u0001\u0444\u0001\u0445\u0001\u0445\u0001\u0445\u0001\u0445"+ + "\u0001\u0445\u0001\u0445\u0001\u0445\u0001\u0445\u0001\u0445\u0001\u0445"+ + "\u0001\u0445\u0001\u0445\u0001\u0445\u0001\u0445\u0001\u0445\u0001\u0446"+ + "\u0001\u0446\u0001\u0446\u0001\u0446\u0001\u0446\u0001\u0446\u0001\u0446"+ + "\u0001\u0446\u0001\u0446\u0001\u0446\u0001\u0447\u0001\u0447\u0001\u0447"+ + "\u0001\u0447\u0001\u0447\u0001\u0447\u0001\u0448\u0001\u0448\u0001\u0448"+ + "\u0001\u0448\u0001\u0448\u0001\u0449\u0001\u0449\u0001\u0449\u0001\u0449"+ + "\u0001\u0449\u0001\u0449\u0001\u0449\u0001\u0449\u0001\u0449\u0001\u0449"+ + "\u0001\u0449\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a"+ + "\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a"+ + "\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a"+ + "\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a"+ + "\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044a\u0001\u044b\u0001\u044b"+ + "\u0001\u044b\u0001\u044b\u0001\u044b\u0001\u044b\u0001\u044b\u0001\u044b"+ + "\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c"+ + "\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c"+ + "\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c"+ + "\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c"+ + "\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c"+ + "\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044c\u0001\u044d\u0001\u044d"+ + "\u0001\u044d\u0001\u044d\u0001\u044d\u0001\u044d\u0001\u044d\u0001\u044d"+ + "\u0001\u044e\u0001\u044e\u0001\u044e\u0001\u044e\u0001\u044e\u0001\u044e"+ + "\u0001\u044e\u0001\u044e\u0001\u044e\u0001\u044e\u0001\u044e\u0001\u044f"+ + "\u0001\u044f\u0001\u044f\u0001\u044f\u0001\u044f\u0001\u044f\u0001\u044f"+ + "\u0001\u044f\u0001\u044f\u0001\u044f\u0001\u044f\u0001\u044f\u0001\u044f"+ + "\u0001\u044f\u0001\u0450\u0001\u0450\u0001\u0450\u0001\u0450\u0001\u0450"+ + "\u0001\u0450\u0001\u0450\u0001\u0451\u0001\u0451\u0001\u0451\u0001\u0451"+ + "\u0001\u0451\u0001\u0451\u0001\u0451\u0001\u0451\u0001\u0451\u0001\u0452"+ + "\u0001\u0452\u0001\u0453\u0001\u0453\u0001\u0454\u0001\u0454\u0001\u0454"+ + "\u0001\u0455\u0001\u0455\u0001\u0455\u0001\u0456\u0001\u0456\u0001\u0456"+ + "\u0001\u0457\u0001\u0457\u0001\u0457\u0001\u0458\u0001\u0458\u0001\u0458"+ + "\u0001\u0459\u0001\u0459\u0001\u0459\u0001\u045a\u0001\u045a\u0001\u045a"+ + "\u0001\u045b\u0001\u045b\u0001\u045b\u0001\u045c\u0001\u045c\u0001\u045c"+ + "\u0001\u045d\u0001\u045d\u0001\u045e\u0001\u045e\u0001\u045f\u0001\u045f"+ + "\u0001\u0460\u0001\u0460\u0001\u0461\u0001\u0461\u0001\u0462\u0001\u0462"+ + "\u0001\u0462\u0001\u0462\u0001\u0463\u0001\u0463\u0001\u0463\u0001\u0463"+ + "\u0001\u0464\u0001\u0464\u0001\u0465\u0001\u0465\u0001\u0466\u0001\u0466"+ + "\u0001\u0467\u0001\u0467\u0001\u0468\u0001\u0468\u0001\u0469\u0001\u0469"+ + "\u0001\u046a\u0001\u046a\u0001\u046b\u0001\u046b\u0001\u046c\u0001\u046c"+ + "\u0001\u046d\u0001\u046d\u0001\u046e\u0001\u046e\u0001\u046f\u0001\u046f"+ + "\u0001\u0470\u0001\u0470\u0001\u0471\u0001\u0471\u0001\u0472\u0001\u0472"+ + "\u0001\u0473\u0001\u0473\u0001\u0474\u0001\u0474\u0001\u0475\u0001\u0475"+ + "\u0001\u0476\u0001\u0476\u0001\u0477\u0001\u0477\u0001\u0478\u0001\u0478"+ + "\u0001\u0479\u0001\u0479\u0001\u0479\u0003\u0479\u347a\b\u0479\u0001\u047a"+ + "\u0001\u047a\u0001\u047a\u0001\u047a\u0001\u047b\u0004\u047b\u3481\b\u047b"+ + "\u000b\u047b\f\u047b\u3482\u0001\u047b\u0001\u047b\u0001\u047c\u0001\u047c"+ + "\u0001\u047c\u0001\u047d\u0001\u047d\u0001\u047d\u0003\u047d\u348d\b\u047d"+ + "\u0001\u047e\u0004\u047e\u3490\b\u047e\u000b\u047e\f\u047e\u3491\u0001"+ + "\u047f\u0001\u047f\u0001\u047f\u0001\u047f\u0001\u047f\u0004\u047f\u3499"+ + "\b\u047f\u000b\u047f\f\u047f\u349a\u0001\u047f\u0001\u047f\u0001\u047f"+ + "\u0001\u047f\u0001\u047f\u0001\u047f\u0004\u047f\u34a3\b\u047f\u000b\u047f"+ + "\f\u047f\u34a4\u0003\u047f\u34a7\b\u047f\u0001\u0480\u0005\u0480\u34aa"+ + "\b\u0480\n\u0480\f\u0480\u34ad\t\u0480\u0001\u0480\u0001\u0480\u0004\u0480"+ + "\u34b1\b\u0480\u000b\u0480\f\u0480\u34b2\u0001\u0480\u0004\u0480\u34b6"+ + "\b\u0480\u000b\u0480\f\u0480\u34b7\u0001\u0480\u0001\u0480\u0001\u0480"+ + "\u0001\u0480\u0005\u0480\u34be\b\u0480\n\u0480\f\u0480\u34c1\t\u0480\u0001"+ + "\u0480\u0001\u0480\u0004\u0480\u34c5\b\u0480\u000b\u0480\f\u0480\u34c6"+ + "\u0001\u0480\u0001\u0480\u0001\u0480\u0004\u0480\u34cc\b\u0480\u000b\u0480"+ + "\f\u0480\u34cd\u0001\u0480\u0001\u0480\u0003\u0480\u34d2\b\u0480\u0001"+ + "\u0481\u0001\u0481\u0001\u0481\u0001\u0482\u0001\u0482\u0001\u0483\u0001"+ + "\u0483\u0001\u0483\u0001\u0484\u0001\u0484\u0001\u0484\u0001\u0485\u0001"+ + "\u0485\u0001\u0486\u0001\u0486\u0001\u0487\u0001\u0487\u0001\u0487\u0001"+ + "\u0488\u0001\u0488\u0001\u0488\u0004\u0488\u34e9\b\u0488\u000b\u0488\f"+ + "\u0488\u34ea\u0003\u0488\u34ed\b\u0488\u0001\u0489\u0001\u0489\u0001\u0489"+ + "\u0004\u0489\u34f2\b\u0489\u000b\u0489\f\u0489\u34f3\u0001\u0489\u0003"+ + "\u0489\u34f7\b\u0489\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001"+ + "\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001"+ + "\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001"+ + "\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001"+ + "\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001"+ + "\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001"+ + "\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001\u048a\u0001"+ + "\u048a\u0003\u048a\u3522\b\u048a\u0001\u048b\u0001\u048b\u0003\u048b\u3526"+ + "\b\u048b\u0001\u048b\u0004\u048b\u3529\b\u048b\u000b\u048b\f\u048b\u352a"+ + "\u0001\u048c\u0005\u048c\u352e\b\u048c\n\u048c\f\u048c\u3531\t\u048c\u0001"+ + "\u048c\u0004\u048c\u3534\b\u048c\u000b\u048c\f\u048c\u3535\u0001\u048c"+ + "\u0005\u048c\u3539\b\u048c\n\u048c\f\u048c\u353c\t\u048c\u0001\u048d\u0001"+ + "\u048d\u0001\u048d\u0001\u048d\u0001\u048d\u0001\u048d\u0005\u048d\u3544"+ + "\b\u048d\n\u048d\f\u048d\u3547\t\u048d\u0001\u048d\u0001\u048d\u0001\u048e"+ + "\u0001\u048e\u0001\u048e\u0001\u048e\u0001\u048e\u0001\u048e\u0005\u048e"+ + "\u3551\b\u048e\n\u048e\f\u048e\u3554\t\u048e\u0001\u048e\u0001\u048e\u0001"+ + "\u048f\u0001\u048f\u0001\u048f\u0001\u048f\u0005\u048f\u355c\b\u048f\n"+ + "\u048f\f\u048f\u355f\t\u048f\u0001\u048f\u0001\u048f\u0001\u0490\u0001"+ + "\u0490\u0001\u0491\u0001\u0491\u0001\u0492\u0001\u0492\u0001\u0492\u0004"+ + "\u0492\u356a\b\u0492\u000b\u0492\f\u0492\u356b\u0001\u0492\u0001\u0492"+ + "\u0001\u0493\u0004\u0493\u3571\b\u0493\u000b\u0493\f\u0493\u3572\u0001"+ + "\u0493\u0001\u0493\u0004\u0493\u3577\b\u0493\u000b\u0493\f\u0493\u3578"+ + "\u0001\u0493\u0005\u0493\u357c\b\u0493\n\u0493\f\u0493\u357f\t\u0493\u0001"+ + "\u0493\u0001\u0493\u0005\u0493\u3583\b\u0493\n\u0493\f\u0493\u3586\t\u0493"+ + "\u0001\u0493\u0001\u0493\u0004\u0493\u358a\b\u0493\u000b\u0493\f\u0493"+ + "\u358b\u0003\u0493\u358e\b\u0493\u0001\u0494\u0001\u0494\u0001\u0494\u0001"+ + "\u0494\u0005\u0930\u0943\u0950\u352f\u3535\u0000\u0495\u0001\u0001\u0003"+ + "\u0002\u0005\u0003\u0007\u0004\t\u0005\u000b\u0006\r\u0007\u000f\b\u0011"+ + "\t\u0013\n\u0015\u000b\u0017\f\u0019\r\u001b\u000e\u001d\u000f\u001f\u0010"+ + "!\u0011#\u0012%\u0013\'\u0014)\u0015+\u0016-\u0017/\u00181\u00193\u001a"+ + "5\u001b7\u001c9\u001d;\u001e=\u001f? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]/"+ + "_0a1c2e3g4i5k6m7o8q9s:u;w}?\u007f@\u0081A\u0083B\u0085C\u0087D\u0089"+ + "E\u008bF\u008dG\u008fH\u0091I\u0093J\u0095K\u0097L\u0099M\u009bN\u009d"+ + "O\u009fP\u00a1Q\u00a3R\u00a5S\u00a7T\u00a9U\u00abV\u00adW\u00afX\u00b1"+ + "Y\u00b3Z\u00b5[\u00b7\\\u00b9]\u00bb^\u00bd_\u00bf`\u00c1a\u00c3b\u00c5"+ + "c\u00c7d\u00c9e\u00cbf\u00cdg\u00cfh\u00d1i\u00d3j\u00d5k\u00d7l\u00d9"+ + "m\u00dbn\u00ddo\u00dfp\u00e1q\u00e3r\u00e5s\u00e7t\u00e9u\u00ebv\u00ed"+ + "w\u00efx\u00f1y\u00f3z\u00f5{\u00f7|\u00f9}\u00fb~\u00fd\u007f\u00ff\u0080"+ + "\u0101\u0081\u0103\u0082\u0105\u0083\u0107\u0084\u0109\u0085\u010b\u0086"+ + "\u010d\u0087\u010f\u0088\u0111\u0089\u0113\u008a\u0115\u008b\u0117\u008c"+ + "\u0119\u008d\u011b\u008e\u011d\u008f\u011f\u0090\u0121\u0091\u0123\u0092"+ + "\u0125\u0093\u0127\u0094\u0129\u0095\u012b\u0096\u012d\u0097\u012f\u0098"+ + "\u0131\u0099\u0133\u009a\u0135\u009b\u0137\u009c\u0139\u009d\u013b\u009e"+ + "\u013d\u009f\u013f\u00a0\u0141\u00a1\u0143\u00a2\u0145\u00a3\u0147\u00a4"+ + "\u0149\u00a5\u014b\u00a6\u014d\u00a7\u014f\u00a8\u0151\u00a9\u0153\u00aa"+ + "\u0155\u00ab\u0157\u00ac\u0159\u00ad\u015b\u00ae\u015d\u00af\u015f\u00b0"+ + "\u0161\u00b1\u0163\u00b2\u0165\u00b3\u0167\u00b4\u0169\u00b5\u016b\u00b6"+ + "\u016d\u00b7\u016f\u00b8\u0171\u00b9\u0173\u00ba\u0175\u00bb\u0177\u00bc"+ + "\u0179\u00bd\u017b\u00be\u017d\u00bf\u017f\u00c0\u0181\u00c1\u0183\u00c2"+ + "\u0185\u00c3\u0187\u00c4\u0189\u00c5\u018b\u00c6\u018d\u00c7\u018f\u00c8"+ + "\u0191\u00c9\u0193\u00ca\u0195\u00cb\u0197\u00cc\u0199\u00cd\u019b\u00ce"+ + "\u019d\u00cf\u019f\u00d0\u01a1\u00d1\u01a3\u00d2\u01a5\u00d3\u01a7\u00d4"+ + "\u01a9\u00d5\u01ab\u00d6\u01ad\u00d7\u01af\u00d8\u01b1\u00d9\u01b3\u00da"+ + "\u01b5\u00db\u01b7\u00dc\u01b9\u00dd\u01bb\u00de\u01bd\u00df\u01bf\u00e0"+ + "\u01c1\u00e1\u01c3\u00e2\u01c5\u00e3\u01c7\u00e4\u01c9\u00e5\u01cb\u00e6"+ + "\u01cd\u00e7\u01cf\u00e8\u01d1\u00e9\u01d3\u00ea\u01d5\u00eb\u01d7\u00ec"+ + "\u01d9\u00ed\u01db\u00ee\u01dd\u00ef\u01df\u00f0\u01e1\u00f1\u01e3\u00f2"+ + "\u01e5\u00f3\u01e7\u00f4\u01e9\u00f5\u01eb\u00f6\u01ed\u00f7\u01ef\u00f8"+ + "\u01f1\u00f9\u01f3\u00fa\u01f5\u00fb\u01f7\u00fc\u01f9\u00fd\u01fb\u00fe"+ + "\u01fd\u00ff\u01ff\u0100\u0201\u0101\u0203\u0102\u0205\u0103\u0207\u0104"+ + "\u0209\u0105\u020b\u0106\u020d\u0107\u020f\u0108\u0211\u0109\u0213\u010a"+ + "\u0215\u010b\u0217\u010c\u0219\u010d\u021b\u010e\u021d\u010f\u021f\u0110"+ + "\u0221\u0111\u0223\u0112\u0225\u0113\u0227\u0114\u0229\u0115\u022b\u0116"+ + "\u022d\u0117\u022f\u0118\u0231\u0119\u0233\u011a\u0235\u011b\u0237\u011c"+ + "\u0239\u011d\u023b\u011e\u023d\u011f\u023f\u0120\u0241\u0121\u0243\u0122"+ + "\u0245\u0123\u0247\u0124\u0249\u0125\u024b\u0126\u024d\u0127\u024f\u0128"+ + "\u0251\u0129\u0253\u012a\u0255\u012b\u0257\u012c\u0259\u012d\u025b\u012e"+ + "\u025d\u012f\u025f\u0130\u0261\u0131\u0263\u0132\u0265\u0133\u0267\u0134"+ + "\u0269\u0135\u026b\u0136\u026d\u0137\u026f\u0138\u0271\u0139\u0273\u013a"+ + "\u0275\u013b\u0277\u013c\u0279\u013d\u027b\u013e\u027d\u013f\u027f\u0140"+ + "\u0281\u0141\u0283\u0142\u0285\u0143\u0287\u0144\u0289\u0145\u028b\u0146"+ + "\u028d\u0147\u028f\u0148\u0291\u0149\u0293\u014a\u0295\u014b\u0297\u014c"+ + "\u0299\u014d\u029b\u014e\u029d\u014f\u029f\u0150\u02a1\u0151\u02a3\u0152"+ + "\u02a5\u0153\u02a7\u0154\u02a9\u0155\u02ab\u0156\u02ad\u0157\u02af\u0158"+ + "\u02b1\u0159\u02b3\u015a\u02b5\u015b\u02b7\u015c\u02b9\u015d\u02bb\u015e"+ + "\u02bd\u015f\u02bf\u0160\u02c1\u0161\u02c3\u0162\u02c5\u0163\u02c7\u0164"+ + "\u02c9\u0165\u02cb\u0166\u02cd\u0167\u02cf\u0168\u02d1\u0169\u02d3\u016a"+ + "\u02d5\u016b\u02d7\u016c\u02d9\u016d\u02db\u016e\u02dd\u016f\u02df\u0170"+ + "\u02e1\u0171\u02e3\u0172\u02e5\u0173\u02e7\u0174\u02e9\u0175\u02eb\u0176"+ + "\u02ed\u0177\u02ef\u0178\u02f1\u0179\u02f3\u017a\u02f5\u017b\u02f7\u017c"+ + "\u02f9\u017d\u02fb\u017e\u02fd\u017f\u02ff\u0180\u0301\u0181\u0303\u0182"+ + "\u0305\u0183\u0307\u0184\u0309\u0185\u030b\u0186\u030d\u0187\u030f\u0188"+ + "\u0311\u0189\u0313\u018a\u0315\u018b\u0317\u018c\u0319\u018d\u031b\u018e"+ + "\u031d\u018f\u031f\u0190\u0321\u0191\u0323\u0192\u0325\u0193\u0327\u0194"+ + "\u0329\u0195\u032b\u0196\u032d\u0197\u032f\u0198\u0331\u0199\u0333\u019a"+ + "\u0335\u019b\u0337\u019c\u0339\u019d\u033b\u019e\u033d\u019f\u033f\u01a0"+ + "\u0341\u01a1\u0343\u01a2\u0345\u01a3\u0347\u01a4\u0349\u01a5\u034b\u01a6"+ + "\u034d\u01a7\u034f\u01a8\u0351\u01a9\u0353\u01aa\u0355\u01ab\u0357\u01ac"+ + "\u0359\u01ad\u035b\u01ae\u035d\u01af\u035f\u01b0\u0361\u01b1\u0363\u01b2"+ + "\u0365\u01b3\u0367\u01b4\u0369\u01b5\u036b\u01b6\u036d\u01b7\u036f\u01b8"+ + "\u0371\u01b9\u0373\u01ba\u0375\u01bb\u0377\u01bc\u0379\u01bd\u037b\u01be"+ + "\u037d\u01bf\u037f\u01c0\u0381\u01c1\u0383\u01c2\u0385\u01c3\u0387\u01c4"+ + "\u0389\u01c5\u038b\u01c6\u038d\u01c7\u038f\u01c8\u0391\u01c9\u0393\u01ca"+ + "\u0395\u01cb\u0397\u01cc\u0399\u01cd\u039b\u01ce\u039d\u01cf\u039f\u01d0"+ + "\u03a1\u01d1\u03a3\u01d2\u03a5\u01d3\u03a7\u01d4\u03a9\u01d5\u03ab\u01d6"+ + "\u03ad\u01d7\u03af\u01d8\u03b1\u01d9\u03b3\u01da\u03b5\u01db\u03b7\u01dc"+ + "\u03b9\u01dd\u03bb\u01de\u03bd\u01df\u03bf\u01e0\u03c1\u01e1\u03c3\u01e2"+ + "\u03c5\u01e3\u03c7\u01e4\u03c9\u01e5\u03cb\u01e6\u03cd\u01e7\u03cf\u01e8"+ + "\u03d1\u01e9\u03d3\u01ea\u03d5\u01eb\u03d7\u01ec\u03d9\u01ed\u03db\u01ee"+ + "\u03dd\u01ef\u03df\u01f0\u03e1\u01f1\u03e3\u01f2\u03e5\u01f3\u03e7\u01f4"+ + "\u03e9\u01f5\u03eb\u01f6\u03ed\u01f7\u03ef\u01f8\u03f1\u01f9\u03f3\u01fa"+ + "\u03f5\u01fb\u03f7\u01fc\u03f9\u01fd\u03fb\u01fe\u03fd\u01ff\u03ff\u0200"+ + "\u0401\u0201\u0403\u0202\u0405\u0203\u0407\u0204\u0409\u0205\u040b\u0206"+ + "\u040d\u0207\u040f\u0208\u0411\u0209\u0413\u020a\u0415\u020b\u0417\u020c"+ + "\u0419\u020d\u041b\u020e\u041d\u020f\u041f\u0210\u0421\u0211\u0423\u0212"+ + "\u0425\u0213\u0427\u0214\u0429\u0215\u042b\u0216\u042d\u0217\u042f\u0218"+ + "\u0431\u0219\u0433\u021a\u0435\u021b\u0437\u021c\u0439\u021d\u043b\u021e"+ + "\u043d\u021f\u043f\u0220\u0441\u0221\u0443\u0222\u0445\u0223\u0447\u0224"+ + "\u0449\u0225\u044b\u0226\u044d\u0227\u044f\u0228\u0451\u0229\u0453\u022a"+ + "\u0455\u022b\u0457\u022c\u0459\u022d\u045b\u022e\u045d\u022f\u045f\u0230"+ + "\u0461\u0231\u0463\u0232\u0465\u0233\u0467\u0234\u0469\u0235\u046b\u0236"+ + "\u046d\u0237\u046f\u0238\u0471\u0239\u0473\u023a\u0475\u023b\u0477\u023c"+ + "\u0479\u023d\u047b\u023e\u047d\u023f\u047f\u0240\u0481\u0241\u0483\u0242"+ + "\u0485\u0243\u0487\u0244\u0489\u0245\u048b\u0246\u048d\u0247\u048f\u0248"+ + "\u0491\u0249\u0493\u024a\u0495\u024b\u0497\u024c\u0499\u024d\u049b\u024e"+ + "\u049d\u024f\u049f\u0250\u04a1\u0251\u04a3\u0252\u04a5\u0253\u04a7\u0254"+ + "\u04a9\u0255\u04ab\u0256\u04ad\u0257\u04af\u0258\u04b1\u0259\u04b3\u025a"+ + "\u04b5\u025b\u04b7\u025c\u04b9\u025d\u04bb\u025e\u04bd\u025f\u04bf\u0260"+ + "\u04c1\u0261\u04c3\u0262\u04c5\u0263\u04c7\u0264\u04c9\u0265\u04cb\u0266"+ + "\u04cd\u0267\u04cf\u0268\u04d1\u0269\u04d3\u026a\u04d5\u026b\u04d7\u026c"+ + "\u04d9\u026d\u04db\u026e\u04dd\u026f\u04df\u0270\u04e1\u0271\u04e3\u0272"+ + "\u04e5\u0273\u04e7\u0274\u04e9\u0275\u04eb\u0276\u04ed\u0277\u04ef\u0278"+ + "\u04f1\u0279\u04f3\u027a\u04f5\u027b\u04f7\u027c\u04f9\u027d\u04fb\u027e"+ + "\u04fd\u027f\u04ff\u0280\u0501\u0281\u0503\u0282\u0505\u0283\u0507\u0284"+ + "\u0509\u0285\u050b\u0286\u050d\u0287\u050f\u0288\u0511\u0289\u0513\u028a"+ + "\u0515\u028b\u0517\u028c\u0519\u028d\u051b\u028e\u051d\u028f\u051f\u0290"+ + "\u0521\u0291\u0523\u0292\u0525\u0293\u0527\u0294\u0529\u0295\u052b\u0296"+ + "\u052d\u0297\u052f\u0298\u0531\u0299\u0533\u029a\u0535\u029b\u0537\u029c"+ + "\u0539\u029d\u053b\u029e\u053d\u029f\u053f\u02a0\u0541\u02a1\u0543\u02a2"+ + "\u0545\u02a3\u0547\u02a4\u0549\u02a5\u054b\u02a6\u054d\u02a7\u054f\u02a8"+ + "\u0551\u02a9\u0553\u02aa\u0555\u02ab\u0557\u02ac\u0559\u02ad\u055b\u02ae"+ + "\u055d\u02af\u055f\u02b0\u0561\u02b1\u0563\u02b2\u0565\u02b3\u0567\u02b4"+ + "\u0569\u02b5\u056b\u02b6\u056d\u02b7\u056f\u02b8\u0571\u02b9\u0573\u02ba"+ + "\u0575\u02bb\u0577\u02bc\u0579\u02bd\u057b\u02be\u057d\u02bf\u057f\u02c0"+ + "\u0581\u02c1\u0583\u02c2\u0585\u02c3\u0587\u02c4\u0589\u02c5\u058b\u02c6"+ + "\u058d\u02c7\u058f\u02c8\u0591\u02c9\u0593\u02ca\u0595\u02cb\u0597\u02cc"+ + "\u0599\u02cd\u059b\u02ce\u059d\u02cf\u059f\u02d0\u05a1\u02d1\u05a3\u02d2"+ + "\u05a5\u02d3\u05a7\u02d4\u05a9\u02d5\u05ab\u02d6\u05ad\u02d7\u05af\u02d8"+ + "\u05b1\u02d9\u05b3\u02da\u05b5\u02db\u05b7\u02dc\u05b9\u02dd\u05bb\u02de"+ + "\u05bd\u02df\u05bf\u02e0\u05c1\u02e1\u05c3\u02e2\u05c5\u02e3\u05c7\u02e4"+ + "\u05c9\u02e5\u05cb\u02e6\u05cd\u02e7\u05cf\u02e8\u05d1\u02e9\u05d3\u02ea"+ + "\u05d5\u02eb\u05d7\u02ec\u05d9\u02ed\u05db\u02ee\u05dd\u02ef\u05df\u02f0"+ + "\u05e1\u02f1\u05e3\u02f2\u05e5\u02f3\u05e7\u02f4\u05e9\u02f5\u05eb\u02f6"+ + "\u05ed\u02f7\u05ef\u02f8\u05f1\u02f9\u05f3\u02fa\u05f5\u02fb\u05f7\u02fc"+ + "\u05f9\u02fd\u05fb\u02fe\u05fd\u02ff\u05ff\u0300\u0601\u0301\u0603\u0302"+ + "\u0605\u0303\u0607\u0304\u0609\u0305\u060b\u0306\u060d\u0307\u060f\u0308"+ + "\u0611\u0309\u0613\u030a\u0615\u030b\u0617\u030c\u0619\u030d\u061b\u030e"+ + "\u061d\u030f\u061f\u0310\u0621\u0311\u0623\u0312\u0625\u0313\u0627\u0314"+ + "\u0629\u0315\u062b\u0316\u062d\u0317\u062f\u0318\u0631\u0319\u0633\u031a"+ + "\u0635\u031b\u0637\u031c\u0639\u031d\u063b\u031e\u063d\u031f\u063f\u0320"+ + "\u0641\u0321\u0643\u0322\u0645\u0323\u0647\u0324\u0649\u0325\u064b\u0326"+ + "\u064d\u0327\u064f\u0328\u0651\u0329\u0653\u032a\u0655\u032b\u0657\u032c"+ + "\u0659\u032d\u065b\u032e\u065d\u032f\u065f\u0330\u0661\u0331\u0663\u0332"+ + "\u0665\u0333\u0667\u0334\u0669\u0335\u066b\u0336\u066d\u0337\u066f\u0338"+ + "\u0671\u0339\u0673\u033a\u0675\u033b\u0677\u033c\u0679\u033d\u067b\u033e"+ + "\u067d\u033f\u067f\u0340\u0681\u0341\u0683\u0342\u0685\u0343\u0687\u0344"+ + "\u0689\u0345\u068b\u0346\u068d\u0347\u068f\u0348\u0691\u0349\u0693\u034a"+ + "\u0695\u034b\u0697\u034c\u0699\u034d\u069b\u034e\u069d\u034f\u069f\u0350"+ + "\u06a1\u0351\u06a3\u0352\u06a5\u0353\u06a7\u0354\u06a9\u0355\u06ab\u0356"+ + "\u06ad\u0357\u06af\u0358\u06b1\u0359\u06b3\u035a\u06b5\u035b\u06b7\u035c"+ + "\u06b9\u035d\u06bb\u035e\u06bd\u035f\u06bf\u0360\u06c1\u0361\u06c3\u0362"+ + "\u06c5\u0363\u06c7\u0364\u06c9\u0365\u06cb\u0366\u06cd\u0367\u06cf\u0368"+ + "\u06d1\u0369\u06d3\u036a\u06d5\u036b\u06d7\u036c\u06d9\u036d\u06db\u036e"+ + "\u06dd\u036f\u06df\u0370\u06e1\u0371\u06e3\u0372\u06e5\u0373\u06e7\u0374"+ + "\u06e9\u0375\u06eb\u0376\u06ed\u0377\u06ef\u0378\u06f1\u0379\u06f3\u037a"+ + "\u06f5\u037b\u06f7\u037c\u06f9\u037d\u06fb\u037e\u06fd\u037f\u06ff\u0380"+ + "\u0701\u0381\u0703\u0382\u0705\u0383\u0707\u0384\u0709\u0385\u070b\u0386"+ + "\u070d\u0387\u070f\u0388\u0711\u0389\u0713\u038a\u0715\u038b\u0717\u038c"+ + "\u0719\u038d\u071b\u038e\u071d\u038f\u071f\u0390\u0721\u0391\u0723\u0392"+ + "\u0725\u0393\u0727\u0394\u0729\u0395\u072b\u0396\u072d\u0397\u072f\u0398"+ + "\u0731\u0399\u0733\u039a\u0735\u039b\u0737\u039c\u0739\u039d\u073b\u039e"+ + "\u073d\u039f\u073f\u03a0\u0741\u03a1\u0743\u03a2\u0745\u03a3\u0747\u03a4"+ + "\u0749\u03a5\u074b\u03a6\u074d\u03a7\u074f\u03a8\u0751\u03a9\u0753\u03aa"+ + "\u0755\u03ab\u0757\u03ac\u0759\u03ad\u075b\u03ae\u075d\u03af\u075f\u03b0"+ + "\u0761\u03b1\u0763\u03b2\u0765\u03b3\u0767\u03b4\u0769\u03b5\u076b\u03b6"+ + "\u076d\u03b7\u076f\u03b8\u0771\u03b9\u0773\u03ba\u0775\u03bb\u0777\u03bc"+ + "\u0779\u03bd\u077b\u03be\u077d\u03bf\u077f\u03c0\u0781\u03c1\u0783\u03c2"+ + "\u0785\u03c3\u0787\u03c4\u0789\u03c5\u078b\u03c6\u078d\u03c7\u078f\u03c8"+ + "\u0791\u03c9\u0793\u03ca\u0795\u03cb\u0797\u03cc\u0799\u03cd\u079b\u03ce"+ + "\u079d\u03cf\u079f\u03d0\u07a1\u03d1\u07a3\u03d2\u07a5\u03d3\u07a7\u03d4"+ + "\u07a9\u03d5\u07ab\u03d6\u07ad\u03d7\u07af\u03d8\u07b1\u03d9\u07b3\u03da"+ + "\u07b5\u03db\u07b7\u03dc\u07b9\u03dd\u07bb\u03de\u07bd\u03df\u07bf\u03e0"+ + "\u07c1\u03e1\u07c3\u03e2\u07c5\u03e3\u07c7\u03e4\u07c9\u03e5\u07cb\u03e6"+ + "\u07cd\u03e7\u07cf\u03e8\u07d1\u03e9\u07d3\u03ea\u07d5\u03eb\u07d7\u03ec"+ + "\u07d9\u03ed\u07db\u03ee\u07dd\u03ef\u07df\u03f0\u07e1\u03f1\u07e3\u03f2"+ + "\u07e5\u03f3\u07e7\u03f4\u07e9\u03f5\u07eb\u03f6\u07ed\u03f7\u07ef\u03f8"+ + "\u07f1\u03f9\u07f3\u03fa\u07f5\u03fb\u07f7\u03fc\u07f9\u03fd\u07fb\u03fe"+ + "\u07fd\u03ff\u07ff\u0400\u0801\u0401\u0803\u0402\u0805\u0403\u0807\u0404"+ + "\u0809\u0405\u080b\u0406\u080d\u0407\u080f\u0408\u0811\u0409\u0813\u040a"+ + "\u0815\u040b\u0817\u040c\u0819\u040d\u081b\u040e\u081d\u040f\u081f\u0410"+ + "\u0821\u0411\u0823\u0412\u0825\u0413\u0827\u0414\u0829\u0415\u082b\u0416"+ + "\u082d\u0417\u082f\u0418\u0831\u0419\u0833\u041a\u0835\u041b\u0837\u041c"+ + "\u0839\u041d\u083b\u041e\u083d\u041f\u083f\u0420\u0841\u0421\u0843\u0422"+ + "\u0845\u0423\u0847\u0424\u0849\u0425\u084b\u0426\u084d\u0427\u084f\u0428"+ + "\u0851\u0429\u0853\u042a\u0855\u042b\u0857\u042c\u0859\u042d\u085b\u042e"+ + "\u085d\u042f\u085f\u0430\u0861\u0431\u0863\u0432\u0865\u0433\u0867\u0434"+ + "\u0869\u0435\u086b\u0436\u086d\u0437\u086f\u0438\u0871\u0439\u0873\u043a"+ + "\u0875\u043b\u0877\u043c\u0879\u043d\u087b\u043e\u087d\u043f\u087f\u0440"+ + "\u0881\u0441\u0883\u0442\u0885\u0443\u0887\u0444\u0889\u0445\u088b\u0446"+ + "\u088d\u0447\u088f\u0448\u0891\u0449\u0893\u044a\u0895\u044b\u0897\u044c"+ + "\u0899\u044d\u089b\u044e\u089d\u044f\u089f\u0450\u08a1\u0451\u08a3\u0452"+ + "\u08a5\u0453\u08a7\u0454\u08a9\u0455\u08ab\u0456\u08ad\u0457\u08af\u0458"+ + "\u08b1\u0459\u08b3\u045a\u08b5\u045b\u08b7\u045c\u08b9\u045d\u08bb\u045e"+ + "\u08bd\u045f\u08bf\u0460\u08c1\u0461\u08c3\u0462\u08c5\u0463\u08c7\u0464"+ + "\u08c9\u0465\u08cb\u0466\u08cd\u0467\u08cf\u0468\u08d1\u0469\u08d3\u046a"+ + "\u08d5\u046b\u08d7\u046c\u08d9\u046d\u08db\u046e\u08dd\u046f\u08df\u0470"+ + "\u08e1\u0471\u08e3\u0472\u08e5\u0473\u08e7\u0474\u08e9\u0475\u08eb\u0476"+ + "\u08ed\u0477\u08ef\u0478\u08f1\u0479\u08f3\u0000\u08f5\u047a\u08f7\u047b"+ + "\u08f9\u047c\u08fb\u047d\u08fd\u047e\u08ff\u047f\u0901\u0480\u0903\u0481"+ + "\u0905\u0482\u0907\u0483\u0909\u0484\u090b\u0485\u090d\u0486\u090f\u0487"+ + "\u0911\u0488\u0913\u0489\u0915\u0000\u0917\u0000\u0919\u0000\u091b\u0000"+ + "\u091d\u0000\u091f\u0000\u0921\u0000\u0923\u0000\u0925\u0000\u0927\u0000"+ + "\u0929\u048a\u0001\u0000*\u0003\u0000\t\n\r\r \u0002\u0000\t\t \u0002"+ + "\u0000\n\n\r\r\u0002\u0000AAaa\u0002\u0000DDdd\u0002\u0000LLll\u0002\u0000"+ + "TTtt\u0002\u0000EEee\u0002\u0000RRrr\u0002\u0000WWww\u0002\u0000YYyy\u0002"+ + "\u0000SSss\u0002\u0000NNnn\u0002\u0000ZZzz\u0002\u0000CCcc\u0002\u0000"+ + "IIii\u0002\u0000BBbb\u0002\u0000UUuu\u0002\u0000FFff\u0002\u0000OOoo\u0002"+ + "\u0000HHhh\u0002\u0000KKkk\u0002\u0000GGgg\u0002\u0000MMmm\u0002\u0000"+ + "VVvv\u0002\u0000PPpp\u0002\u0000XXxx\u0002\u0000JJjj\u0002\u0000QQqq\b"+ + "\u0000GGKKMMTTggkkmmtt\u0007\u0000$$..09AZ__az\u0080\u8000\uffff\u0002"+ + "\u0000++--\u0006\u0000$$09AZ__az\u0080\u8000\uffff\u0005\u0000$$AZ__a"+ + "z\u0080\u8000\uffff\u0002\u0000\"\"\\\\\u0002\u0000\'\'\\\\\u0001\u0000"+ + "``\u0003\u000009AFaf\u0001\u000009\u0001\u000001\u0002\u0000..09\u0003"+ + "\u00000:AFaf\u35e7\u0000\u0001\u0001\u0000\u0000\u0000\u0000\u0003\u0001"+ + "\u0000\u0000\u0000\u0000\u0005\u0001\u0000\u0000\u0000\u0000\u0007\u0001"+ + "\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000\u000b\u0001\u0000"+ + "\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f\u0001\u0000\u0000"+ + "\u0000\u0000\u0011\u0001\u0000\u0000\u0000\u0000\u0013\u0001\u0000\u0000"+ + "\u0000\u0000\u0015\u0001\u0000\u0000\u0000\u0000\u0017\u0001\u0000\u0000"+ + "\u0000\u0000\u0019\u0001\u0000\u0000\u0000\u0000\u001b\u0001\u0000\u0000"+ + "\u0000\u0000\u001d\u0001\u0000\u0000\u0000\u0000\u001f\u0001\u0000\u0000"+ + "\u0000\u0000!\u0001\u0000\u0000\u0000\u0000#\u0001\u0000\u0000\u0000\u0000"+ + "%\u0001\u0000\u0000\u0000\u0000\'\u0001\u0000\u0000\u0000\u0000)\u0001"+ + "\u0000\u0000\u0000\u0000+\u0001\u0000\u0000\u0000\u0000-\u0001\u0000\u0000"+ + "\u0000\u0000/\u0001\u0000\u0000\u0000\u00001\u0001\u0000\u0000\u0000\u0000"+ + "3\u0001\u0000\u0000\u0000\u00005\u0001\u0000\u0000\u0000\u00007\u0001"+ + "\u0000\u0000\u0000\u00009\u0001\u0000\u0000\u0000\u0000;\u0001\u0000\u0000"+ + "\u0000\u0000=\u0001\u0000\u0000\u0000\u0000?\u0001\u0000\u0000\u0000\u0000"+ + "A\u0001\u0000\u0000\u0000\u0000C\u0001\u0000\u0000\u0000\u0000E\u0001"+ + "\u0000\u0000\u0000\u0000G\u0001\u0000\u0000\u0000\u0000I\u0001\u0000\u0000"+ + "\u0000\u0000K\u0001\u0000\u0000\u0000\u0000M\u0001\u0000\u0000\u0000\u0000"+ + "O\u0001\u0000\u0000\u0000\u0000Q\u0001\u0000\u0000\u0000\u0000S\u0001"+ + "\u0000\u0000\u0000\u0000U\u0001\u0000\u0000\u0000\u0000W\u0001\u0000\u0000"+ + "\u0000\u0000Y\u0001\u0000\u0000\u0000\u0000[\u0001\u0000\u0000\u0000\u0000"+ + "]\u0001\u0000\u0000\u0000\u0000_\u0001\u0000\u0000\u0000\u0000a\u0001"+ + "\u0000\u0000\u0000\u0000c\u0001\u0000\u0000\u0000\u0000e\u0001\u0000\u0000"+ + "\u0000\u0000g\u0001\u0000\u0000\u0000\u0000i\u0001\u0000\u0000\u0000\u0000"+ + "k\u0001\u0000\u0000\u0000\u0000m\u0001\u0000\u0000\u0000\u0000o\u0001"+ + "\u0000\u0000\u0000\u0000q\u0001\u0000\u0000\u0000\u0000s\u0001\u0000\u0000"+ + "\u0000\u0000u\u0001\u0000\u0000\u0000\u0000w\u0001\u0000\u0000\u0000\u0000"+ + "y\u0001\u0000\u0000\u0000\u0000{\u0001\u0000\u0000\u0000\u0000}\u0001"+ + "\u0000\u0000\u0000\u0000\u007f\u0001\u0000\u0000\u0000\u0000\u0081\u0001"+ + "\u0000\u0000\u0000\u0000\u0083\u0001\u0000\u0000\u0000\u0000\u0085\u0001"+ + "\u0000\u0000\u0000\u0000\u0087\u0001\u0000\u0000\u0000\u0000\u0089\u0001"+ + "\u0000\u0000\u0000\u0000\u008b\u0001\u0000\u0000\u0000\u0000\u008d\u0001"+ + "\u0000\u0000\u0000\u0000\u008f\u0001\u0000\u0000\u0000\u0000\u0091\u0001"+ + "\u0000\u0000\u0000\u0000\u0093\u0001\u0000\u0000\u0000\u0000\u0095\u0001"+ + "\u0000\u0000\u0000\u0000\u0097\u0001\u0000\u0000\u0000\u0000\u0099\u0001"+ + "\u0000\u0000\u0000\u0000\u009b\u0001\u0000\u0000\u0000\u0000\u009d\u0001"+ + "\u0000\u0000\u0000\u0000\u009f\u0001\u0000\u0000\u0000\u0000\u00a1\u0001"+ + "\u0000\u0000\u0000\u0000\u00a3\u0001\u0000\u0000\u0000\u0000\u00a5\u0001"+ + "\u0000\u0000\u0000\u0000\u00a7\u0001\u0000\u0000\u0000\u0000\u00a9\u0001"+ + "\u0000\u0000\u0000\u0000\u00ab\u0001\u0000\u0000\u0000\u0000\u00ad\u0001"+ + "\u0000\u0000\u0000\u0000\u00af\u0001\u0000\u0000\u0000\u0000\u00b1\u0001"+ + "\u0000\u0000\u0000\u0000\u00b3\u0001\u0000\u0000\u0000\u0000\u00b5\u0001"+ + "\u0000\u0000\u0000\u0000\u00b7\u0001\u0000\u0000\u0000\u0000\u00b9\u0001"+ + "\u0000\u0000\u0000\u0000\u00bb\u0001\u0000\u0000\u0000\u0000\u00bd\u0001"+ + "\u0000\u0000\u0000\u0000\u00bf\u0001\u0000\u0000\u0000\u0000\u00c1\u0001"+ + "\u0000\u0000\u0000\u0000\u00c3\u0001\u0000\u0000\u0000\u0000\u00c5\u0001"+ + "\u0000\u0000\u0000\u0000\u00c7\u0001\u0000\u0000\u0000\u0000\u00c9\u0001"+ + "\u0000\u0000\u0000\u0000\u00cb\u0001\u0000\u0000\u0000\u0000\u00cd\u0001"+ + "\u0000\u0000\u0000\u0000\u00cf\u0001\u0000\u0000\u0000\u0000\u00d1\u0001"+ + "\u0000\u0000\u0000\u0000\u00d3\u0001\u0000\u0000\u0000\u0000\u00d5\u0001"+ + "\u0000\u0000\u0000\u0000\u00d7\u0001\u0000\u0000\u0000\u0000\u00d9\u0001"+ + "\u0000\u0000\u0000\u0000\u00db\u0001\u0000\u0000\u0000\u0000\u00dd\u0001"+ + "\u0000\u0000\u0000\u0000\u00df\u0001\u0000\u0000\u0000\u0000\u00e1\u0001"+ + "\u0000\u0000\u0000\u0000\u00e3\u0001\u0000\u0000\u0000\u0000\u00e5\u0001"+ + "\u0000\u0000\u0000\u0000\u00e7\u0001\u0000\u0000\u0000\u0000\u00e9\u0001"+ + "\u0000\u0000\u0000\u0000\u00eb\u0001\u0000\u0000\u0000\u0000\u00ed\u0001"+ + "\u0000\u0000\u0000\u0000\u00ef\u0001\u0000\u0000\u0000\u0000\u00f1\u0001"+ + "\u0000\u0000\u0000\u0000\u00f3\u0001\u0000\u0000\u0000\u0000\u00f5\u0001"+ + "\u0000\u0000\u0000\u0000\u00f7\u0001\u0000\u0000\u0000\u0000\u00f9\u0001"+ + "\u0000\u0000\u0000\u0000\u00fb\u0001\u0000\u0000\u0000\u0000\u00fd\u0001"+ + "\u0000\u0000\u0000\u0000\u00ff\u0001\u0000\u0000\u0000\u0000\u0101\u0001"+ + "\u0000\u0000\u0000\u0000\u0103\u0001\u0000\u0000\u0000\u0000\u0105\u0001"+ + "\u0000\u0000\u0000\u0000\u0107\u0001\u0000\u0000\u0000\u0000\u0109\u0001"+ + "\u0000\u0000\u0000\u0000\u010b\u0001\u0000\u0000\u0000\u0000\u010d\u0001"+ + "\u0000\u0000\u0000\u0000\u010f\u0001\u0000\u0000\u0000\u0000\u0111\u0001"+ + "\u0000\u0000\u0000\u0000\u0113\u0001\u0000\u0000\u0000\u0000\u0115\u0001"+ + "\u0000\u0000\u0000\u0000\u0117\u0001\u0000\u0000\u0000\u0000\u0119\u0001"+ + "\u0000\u0000\u0000\u0000\u011b\u0001\u0000\u0000\u0000\u0000\u011d\u0001"+ + "\u0000\u0000\u0000\u0000\u011f\u0001\u0000\u0000\u0000\u0000\u0121\u0001"+ + "\u0000\u0000\u0000\u0000\u0123\u0001\u0000\u0000\u0000\u0000\u0125\u0001"+ + "\u0000\u0000\u0000\u0000\u0127\u0001\u0000\u0000\u0000\u0000\u0129\u0001"+ + "\u0000\u0000\u0000\u0000\u012b\u0001\u0000\u0000\u0000\u0000\u012d\u0001"+ + "\u0000\u0000\u0000\u0000\u012f\u0001\u0000\u0000\u0000\u0000\u0131\u0001"+ + "\u0000\u0000\u0000\u0000\u0133\u0001\u0000\u0000\u0000\u0000\u0135\u0001"+ + "\u0000\u0000\u0000\u0000\u0137\u0001\u0000\u0000\u0000\u0000\u0139\u0001"+ + "\u0000\u0000\u0000\u0000\u013b\u0001\u0000\u0000\u0000\u0000\u013d\u0001"+ + "\u0000\u0000\u0000\u0000\u013f\u0001\u0000\u0000\u0000\u0000\u0141\u0001"+ + "\u0000\u0000\u0000\u0000\u0143\u0001\u0000\u0000\u0000\u0000\u0145\u0001"+ + "\u0000\u0000\u0000\u0000\u0147\u0001\u0000\u0000\u0000\u0000\u0149\u0001"+ + "\u0000\u0000\u0000\u0000\u014b\u0001\u0000\u0000\u0000\u0000\u014d\u0001"+ + "\u0000\u0000\u0000\u0000\u014f\u0001\u0000\u0000\u0000\u0000\u0151\u0001"+ + "\u0000\u0000\u0000\u0000\u0153\u0001\u0000\u0000\u0000\u0000\u0155\u0001"+ + "\u0000\u0000\u0000\u0000\u0157\u0001\u0000\u0000\u0000\u0000\u0159\u0001"+ + "\u0000\u0000\u0000\u0000\u015b\u0001\u0000\u0000\u0000\u0000\u015d\u0001"+ + "\u0000\u0000\u0000\u0000\u015f\u0001\u0000\u0000\u0000\u0000\u0161\u0001"+ + "\u0000\u0000\u0000\u0000\u0163\u0001\u0000\u0000\u0000\u0000\u0165\u0001"+ + "\u0000\u0000\u0000\u0000\u0167\u0001\u0000\u0000\u0000\u0000\u0169\u0001"+ + "\u0000\u0000\u0000\u0000\u016b\u0001\u0000\u0000\u0000\u0000\u016d\u0001"+ + "\u0000\u0000\u0000\u0000\u016f\u0001\u0000\u0000\u0000\u0000\u0171\u0001"+ + "\u0000\u0000\u0000\u0000\u0173\u0001\u0000\u0000\u0000\u0000\u0175\u0001"+ + "\u0000\u0000\u0000\u0000\u0177\u0001\u0000\u0000\u0000\u0000\u0179\u0001"+ + "\u0000\u0000\u0000\u0000\u017b\u0001\u0000\u0000\u0000\u0000\u017d\u0001"+ + "\u0000\u0000\u0000\u0000\u017f\u0001\u0000\u0000\u0000\u0000\u0181\u0001"+ + "\u0000\u0000\u0000\u0000\u0183\u0001\u0000\u0000\u0000\u0000\u0185\u0001"+ + "\u0000\u0000\u0000\u0000\u0187\u0001\u0000\u0000\u0000\u0000\u0189\u0001"+ + "\u0000\u0000\u0000\u0000\u018b\u0001\u0000\u0000\u0000\u0000\u018d\u0001"+ + "\u0000\u0000\u0000\u0000\u018f\u0001\u0000\u0000\u0000\u0000\u0191\u0001"+ + "\u0000\u0000\u0000\u0000\u0193\u0001\u0000\u0000\u0000\u0000\u0195\u0001"+ + "\u0000\u0000\u0000\u0000\u0197\u0001\u0000\u0000\u0000\u0000\u0199\u0001"+ + "\u0000\u0000\u0000\u0000\u019b\u0001\u0000\u0000\u0000\u0000\u019d\u0001"+ + "\u0000\u0000\u0000\u0000\u019f\u0001\u0000\u0000\u0000\u0000\u01a1\u0001"+ + "\u0000\u0000\u0000\u0000\u01a3\u0001\u0000\u0000\u0000\u0000\u01a5\u0001"+ + "\u0000\u0000\u0000\u0000\u01a7\u0001\u0000\u0000\u0000\u0000\u01a9\u0001"+ + "\u0000\u0000\u0000\u0000\u01ab\u0001\u0000\u0000\u0000\u0000\u01ad\u0001"+ + "\u0000\u0000\u0000\u0000\u01af\u0001\u0000\u0000\u0000\u0000\u01b1\u0001"+ + "\u0000\u0000\u0000\u0000\u01b3\u0001\u0000\u0000\u0000\u0000\u01b5\u0001"+ + "\u0000\u0000\u0000\u0000\u01b7\u0001\u0000\u0000\u0000\u0000\u01b9\u0001"+ + "\u0000\u0000\u0000\u0000\u01bb\u0001\u0000\u0000\u0000\u0000\u01bd\u0001"+ + "\u0000\u0000\u0000\u0000\u01bf\u0001\u0000\u0000\u0000\u0000\u01c1\u0001"+ + "\u0000\u0000\u0000\u0000\u01c3\u0001\u0000\u0000\u0000\u0000\u01c5\u0001"+ + "\u0000\u0000\u0000\u0000\u01c7\u0001\u0000\u0000\u0000\u0000\u01c9\u0001"+ + "\u0000\u0000\u0000\u0000\u01cb\u0001\u0000\u0000\u0000\u0000\u01cd\u0001"+ + "\u0000\u0000\u0000\u0000\u01cf\u0001\u0000\u0000\u0000\u0000\u01d1\u0001"+ + "\u0000\u0000\u0000\u0000\u01d3\u0001\u0000\u0000\u0000\u0000\u01d5\u0001"+ + "\u0000\u0000\u0000\u0000\u01d7\u0001\u0000\u0000\u0000\u0000\u01d9\u0001"+ + "\u0000\u0000\u0000\u0000\u01db\u0001\u0000\u0000\u0000\u0000\u01dd\u0001"+ + "\u0000\u0000\u0000\u0000\u01df\u0001\u0000\u0000\u0000\u0000\u01e1\u0001"+ + "\u0000\u0000\u0000\u0000\u01e3\u0001\u0000\u0000\u0000\u0000\u01e5\u0001"+ + "\u0000\u0000\u0000\u0000\u01e7\u0001\u0000\u0000\u0000\u0000\u01e9\u0001"+ + "\u0000\u0000\u0000\u0000\u01eb\u0001\u0000\u0000\u0000\u0000\u01ed\u0001"+ + "\u0000\u0000\u0000\u0000\u01ef\u0001\u0000\u0000\u0000\u0000\u01f1\u0001"+ + "\u0000\u0000\u0000\u0000\u01f3\u0001\u0000\u0000\u0000\u0000\u01f5\u0001"+ + "\u0000\u0000\u0000\u0000\u01f7\u0001\u0000\u0000\u0000\u0000\u01f9\u0001"+ + "\u0000\u0000\u0000\u0000\u01fb\u0001\u0000\u0000\u0000\u0000\u01fd\u0001"+ + "\u0000\u0000\u0000\u0000\u01ff\u0001\u0000\u0000\u0000\u0000\u0201\u0001"+ + "\u0000\u0000\u0000\u0000\u0203\u0001\u0000\u0000\u0000\u0000\u0205\u0001"+ + "\u0000\u0000\u0000\u0000\u0207\u0001\u0000\u0000\u0000\u0000\u0209\u0001"+ + "\u0000\u0000\u0000\u0000\u020b\u0001\u0000\u0000\u0000\u0000\u020d\u0001"+ + "\u0000\u0000\u0000\u0000\u020f\u0001\u0000\u0000\u0000\u0000\u0211\u0001"+ + "\u0000\u0000\u0000\u0000\u0213\u0001\u0000\u0000\u0000\u0000\u0215\u0001"+ + "\u0000\u0000\u0000\u0000\u0217\u0001\u0000\u0000\u0000\u0000\u0219\u0001"+ + "\u0000\u0000\u0000\u0000\u021b\u0001\u0000\u0000\u0000\u0000\u021d\u0001"+ + "\u0000\u0000\u0000\u0000\u021f\u0001\u0000\u0000\u0000\u0000\u0221\u0001"+ + "\u0000\u0000\u0000\u0000\u0223\u0001\u0000\u0000\u0000\u0000\u0225\u0001"+ + "\u0000\u0000\u0000\u0000\u0227\u0001\u0000\u0000\u0000\u0000\u0229\u0001"+ + "\u0000\u0000\u0000\u0000\u022b\u0001\u0000\u0000\u0000\u0000\u022d\u0001"+ + "\u0000\u0000\u0000\u0000\u022f\u0001\u0000\u0000\u0000\u0000\u0231\u0001"+ + "\u0000\u0000\u0000\u0000\u0233\u0001\u0000\u0000\u0000\u0000\u0235\u0001"+ + "\u0000\u0000\u0000\u0000\u0237\u0001\u0000\u0000\u0000\u0000\u0239\u0001"+ + "\u0000\u0000\u0000\u0000\u023b\u0001\u0000\u0000\u0000\u0000\u023d\u0001"+ + "\u0000\u0000\u0000\u0000\u023f\u0001\u0000\u0000\u0000\u0000\u0241\u0001"+ + "\u0000\u0000\u0000\u0000\u0243\u0001\u0000\u0000\u0000\u0000\u0245\u0001"+ + "\u0000\u0000\u0000\u0000\u0247\u0001\u0000\u0000\u0000\u0000\u0249\u0001"+ + "\u0000\u0000\u0000\u0000\u024b\u0001\u0000\u0000\u0000\u0000\u024d\u0001"+ + "\u0000\u0000\u0000\u0000\u024f\u0001\u0000\u0000\u0000\u0000\u0251\u0001"+ + "\u0000\u0000\u0000\u0000\u0253\u0001\u0000\u0000\u0000\u0000\u0255\u0001"+ + "\u0000\u0000\u0000\u0000\u0257\u0001\u0000\u0000\u0000\u0000\u0259\u0001"+ + "\u0000\u0000\u0000\u0000\u025b\u0001\u0000\u0000\u0000\u0000\u025d\u0001"+ + "\u0000\u0000\u0000\u0000\u025f\u0001\u0000\u0000\u0000\u0000\u0261\u0001"+ + "\u0000\u0000\u0000\u0000\u0263\u0001\u0000\u0000\u0000\u0000\u0265\u0001"+ + "\u0000\u0000\u0000\u0000\u0267\u0001\u0000\u0000\u0000\u0000\u0269\u0001"+ + "\u0000\u0000\u0000\u0000\u026b\u0001\u0000\u0000\u0000\u0000\u026d\u0001"+ + "\u0000\u0000\u0000\u0000\u026f\u0001\u0000\u0000\u0000\u0000\u0271\u0001"+ + "\u0000\u0000\u0000\u0000\u0273\u0001\u0000\u0000\u0000\u0000\u0275\u0001"+ + "\u0000\u0000\u0000\u0000\u0277\u0001\u0000\u0000\u0000\u0000\u0279\u0001"+ + "\u0000\u0000\u0000\u0000\u027b\u0001\u0000\u0000\u0000\u0000\u027d\u0001"+ + "\u0000\u0000\u0000\u0000\u027f\u0001\u0000\u0000\u0000\u0000\u0281\u0001"+ + "\u0000\u0000\u0000\u0000\u0283\u0001\u0000\u0000\u0000\u0000\u0285\u0001"+ + "\u0000\u0000\u0000\u0000\u0287\u0001\u0000\u0000\u0000\u0000\u0289\u0001"+ + "\u0000\u0000\u0000\u0000\u028b\u0001\u0000\u0000\u0000\u0000\u028d\u0001"+ + "\u0000\u0000\u0000\u0000\u028f\u0001\u0000\u0000\u0000\u0000\u0291\u0001"+ + "\u0000\u0000\u0000\u0000\u0293\u0001\u0000\u0000\u0000\u0000\u0295\u0001"+ + "\u0000\u0000\u0000\u0000\u0297\u0001\u0000\u0000\u0000\u0000\u0299\u0001"+ + "\u0000\u0000\u0000\u0000\u029b\u0001\u0000\u0000\u0000\u0000\u029d\u0001"+ + "\u0000\u0000\u0000\u0000\u029f\u0001\u0000\u0000\u0000\u0000\u02a1\u0001"+ + "\u0000\u0000\u0000\u0000\u02a3\u0001\u0000\u0000\u0000\u0000\u02a5\u0001"+ + "\u0000\u0000\u0000\u0000\u02a7\u0001\u0000\u0000\u0000\u0000\u02a9\u0001"+ + "\u0000\u0000\u0000\u0000\u02ab\u0001\u0000\u0000\u0000\u0000\u02ad\u0001"+ + "\u0000\u0000\u0000\u0000\u02af\u0001\u0000\u0000\u0000\u0000\u02b1\u0001"+ + "\u0000\u0000\u0000\u0000\u02b3\u0001\u0000\u0000\u0000\u0000\u02b5\u0001"+ + "\u0000\u0000\u0000\u0000\u02b7\u0001\u0000\u0000\u0000\u0000\u02b9\u0001"+ + "\u0000\u0000\u0000\u0000\u02bb\u0001\u0000\u0000\u0000\u0000\u02bd\u0001"+ + "\u0000\u0000\u0000\u0000\u02bf\u0001\u0000\u0000\u0000\u0000\u02c1\u0001"+ + "\u0000\u0000\u0000\u0000\u02c3\u0001\u0000\u0000\u0000\u0000\u02c5\u0001"+ + "\u0000\u0000\u0000\u0000\u02c7\u0001\u0000\u0000\u0000\u0000\u02c9\u0001"+ + "\u0000\u0000\u0000\u0000\u02cb\u0001\u0000\u0000\u0000\u0000\u02cd\u0001"+ + "\u0000\u0000\u0000\u0000\u02cf\u0001\u0000\u0000\u0000\u0000\u02d1\u0001"+ + "\u0000\u0000\u0000\u0000\u02d3\u0001\u0000\u0000\u0000\u0000\u02d5\u0001"+ + "\u0000\u0000\u0000\u0000\u02d7\u0001\u0000\u0000\u0000\u0000\u02d9\u0001"+ + "\u0000\u0000\u0000\u0000\u02db\u0001\u0000\u0000\u0000\u0000\u02dd\u0001"+ + "\u0000\u0000\u0000\u0000\u02df\u0001\u0000\u0000\u0000\u0000\u02e1\u0001"+ + "\u0000\u0000\u0000\u0000\u02e3\u0001\u0000\u0000\u0000\u0000\u02e5\u0001"+ + "\u0000\u0000\u0000\u0000\u02e7\u0001\u0000\u0000\u0000\u0000\u02e9\u0001"+ + "\u0000\u0000\u0000\u0000\u02eb\u0001\u0000\u0000\u0000\u0000\u02ed\u0001"+ + "\u0000\u0000\u0000\u0000\u02ef\u0001\u0000\u0000\u0000\u0000\u02f1\u0001"+ + "\u0000\u0000\u0000\u0000\u02f3\u0001\u0000\u0000\u0000\u0000\u02f5\u0001"+ + "\u0000\u0000\u0000\u0000\u02f7\u0001\u0000\u0000\u0000\u0000\u02f9\u0001"+ + "\u0000\u0000\u0000\u0000\u02fb\u0001\u0000\u0000\u0000\u0000\u02fd\u0001"+ + "\u0000\u0000\u0000\u0000\u02ff\u0001\u0000\u0000\u0000\u0000\u0301\u0001"+ + "\u0000\u0000\u0000\u0000\u0303\u0001\u0000\u0000\u0000\u0000\u0305\u0001"+ + "\u0000\u0000\u0000\u0000\u0307\u0001\u0000\u0000\u0000\u0000\u0309\u0001"+ + "\u0000\u0000\u0000\u0000\u030b\u0001\u0000\u0000\u0000\u0000\u030d\u0001"+ + "\u0000\u0000\u0000\u0000\u030f\u0001\u0000\u0000\u0000\u0000\u0311\u0001"+ + "\u0000\u0000\u0000\u0000\u0313\u0001\u0000\u0000\u0000\u0000\u0315\u0001"+ + "\u0000\u0000\u0000\u0000\u0317\u0001\u0000\u0000\u0000\u0000\u0319\u0001"+ + "\u0000\u0000\u0000\u0000\u031b\u0001\u0000\u0000\u0000\u0000\u031d\u0001"+ + "\u0000\u0000\u0000\u0000\u031f\u0001\u0000\u0000\u0000\u0000\u0321\u0001"+ + "\u0000\u0000\u0000\u0000\u0323\u0001\u0000\u0000\u0000\u0000\u0325\u0001"+ + "\u0000\u0000\u0000\u0000\u0327\u0001\u0000\u0000\u0000\u0000\u0329\u0001"+ + "\u0000\u0000\u0000\u0000\u032b\u0001\u0000\u0000\u0000\u0000\u032d\u0001"+ + "\u0000\u0000\u0000\u0000\u032f\u0001\u0000\u0000\u0000\u0000\u0331\u0001"+ + "\u0000\u0000\u0000\u0000\u0333\u0001\u0000\u0000\u0000\u0000\u0335\u0001"+ + "\u0000\u0000\u0000\u0000\u0337\u0001\u0000\u0000\u0000\u0000\u0339\u0001"+ + "\u0000\u0000\u0000\u0000\u033b\u0001\u0000\u0000\u0000\u0000\u033d\u0001"+ + "\u0000\u0000\u0000\u0000\u033f\u0001\u0000\u0000\u0000\u0000\u0341\u0001"+ + "\u0000\u0000\u0000\u0000\u0343\u0001\u0000\u0000\u0000\u0000\u0345\u0001"+ + "\u0000\u0000\u0000\u0000\u0347\u0001\u0000\u0000\u0000\u0000\u0349\u0001"+ + "\u0000\u0000\u0000\u0000\u034b\u0001\u0000\u0000\u0000\u0000\u034d\u0001"+ + "\u0000\u0000\u0000\u0000\u034f\u0001\u0000\u0000\u0000\u0000\u0351\u0001"+ + "\u0000\u0000\u0000\u0000\u0353\u0001\u0000\u0000\u0000\u0000\u0355\u0001"+ + "\u0000\u0000\u0000\u0000\u0357\u0001\u0000\u0000\u0000\u0000\u0359\u0001"+ + "\u0000\u0000\u0000\u0000\u035b\u0001\u0000\u0000\u0000\u0000\u035d\u0001"+ + "\u0000\u0000\u0000\u0000\u035f\u0001\u0000\u0000\u0000\u0000\u0361\u0001"+ + "\u0000\u0000\u0000\u0000\u0363\u0001\u0000\u0000\u0000\u0000\u0365\u0001"+ + "\u0000\u0000\u0000\u0000\u0367\u0001\u0000\u0000\u0000\u0000\u0369\u0001"+ + "\u0000\u0000\u0000\u0000\u036b\u0001\u0000\u0000\u0000\u0000\u036d\u0001"+ + "\u0000\u0000\u0000\u0000\u036f\u0001\u0000\u0000\u0000\u0000\u0371\u0001"+ + "\u0000\u0000\u0000\u0000\u0373\u0001\u0000\u0000\u0000\u0000\u0375\u0001"+ + "\u0000\u0000\u0000\u0000\u0377\u0001\u0000\u0000\u0000\u0000\u0379\u0001"+ + "\u0000\u0000\u0000\u0000\u037b\u0001\u0000\u0000\u0000\u0000\u037d\u0001"+ + "\u0000\u0000\u0000\u0000\u037f\u0001\u0000\u0000\u0000\u0000\u0381\u0001"+ + "\u0000\u0000\u0000\u0000\u0383\u0001\u0000\u0000\u0000\u0000\u0385\u0001"+ + "\u0000\u0000\u0000\u0000\u0387\u0001\u0000\u0000\u0000\u0000\u0389\u0001"+ + "\u0000\u0000\u0000\u0000\u038b\u0001\u0000\u0000\u0000\u0000\u038d\u0001"+ + "\u0000\u0000\u0000\u0000\u038f\u0001\u0000\u0000\u0000\u0000\u0391\u0001"+ + "\u0000\u0000\u0000\u0000\u0393\u0001\u0000\u0000\u0000\u0000\u0395\u0001"+ + "\u0000\u0000\u0000\u0000\u0397\u0001\u0000\u0000\u0000\u0000\u0399\u0001"+ + "\u0000\u0000\u0000\u0000\u039b\u0001\u0000\u0000\u0000\u0000\u039d\u0001"+ + "\u0000\u0000\u0000\u0000\u039f\u0001\u0000\u0000\u0000\u0000\u03a1\u0001"+ + "\u0000\u0000\u0000\u0000\u03a3\u0001\u0000\u0000\u0000\u0000\u03a5\u0001"+ + "\u0000\u0000\u0000\u0000\u03a7\u0001\u0000\u0000\u0000\u0000\u03a9\u0001"+ + "\u0000\u0000\u0000\u0000\u03ab\u0001\u0000\u0000\u0000\u0000\u03ad\u0001"+ + "\u0000\u0000\u0000\u0000\u03af\u0001\u0000\u0000\u0000\u0000\u03b1\u0001"+ + "\u0000\u0000\u0000\u0000\u03b3\u0001\u0000\u0000\u0000\u0000\u03b5\u0001"+ + "\u0000\u0000\u0000\u0000\u03b7\u0001\u0000\u0000\u0000\u0000\u03b9\u0001"+ + "\u0000\u0000\u0000\u0000\u03bb\u0001\u0000\u0000\u0000\u0000\u03bd\u0001"+ + "\u0000\u0000\u0000\u0000\u03bf\u0001\u0000\u0000\u0000\u0000\u03c1\u0001"+ + "\u0000\u0000\u0000\u0000\u03c3\u0001\u0000\u0000\u0000\u0000\u03c5\u0001"+ + "\u0000\u0000\u0000\u0000\u03c7\u0001\u0000\u0000\u0000\u0000\u03c9\u0001"+ + "\u0000\u0000\u0000\u0000\u03cb\u0001\u0000\u0000\u0000\u0000\u03cd\u0001"+ + "\u0000\u0000\u0000\u0000\u03cf\u0001\u0000\u0000\u0000\u0000\u03d1\u0001"+ + "\u0000\u0000\u0000\u0000\u03d3\u0001\u0000\u0000\u0000\u0000\u03d5\u0001"+ + "\u0000\u0000\u0000\u0000\u03d7\u0001\u0000\u0000\u0000\u0000\u03d9\u0001"+ + "\u0000\u0000\u0000\u0000\u03db\u0001\u0000\u0000\u0000\u0000\u03dd\u0001"+ + "\u0000\u0000\u0000\u0000\u03df\u0001\u0000\u0000\u0000\u0000\u03e1\u0001"+ + "\u0000\u0000\u0000\u0000\u03e3\u0001\u0000\u0000\u0000\u0000\u03e5\u0001"+ + "\u0000\u0000\u0000\u0000\u03e7\u0001\u0000\u0000\u0000\u0000\u03e9\u0001"+ + "\u0000\u0000\u0000\u0000\u03eb\u0001\u0000\u0000\u0000\u0000\u03ed\u0001"+ + "\u0000\u0000\u0000\u0000\u03ef\u0001\u0000\u0000\u0000\u0000\u03f1\u0001"+ + "\u0000\u0000\u0000\u0000\u03f3\u0001\u0000\u0000\u0000\u0000\u03f5\u0001"+ + "\u0000\u0000\u0000\u0000\u03f7\u0001\u0000\u0000\u0000\u0000\u03f9\u0001"+ + "\u0000\u0000\u0000\u0000\u03fb\u0001\u0000\u0000\u0000\u0000\u03fd\u0001"+ + "\u0000\u0000\u0000\u0000\u03ff\u0001\u0000\u0000\u0000\u0000\u0401\u0001"+ + "\u0000\u0000\u0000\u0000\u0403\u0001\u0000\u0000\u0000\u0000\u0405\u0001"+ + "\u0000\u0000\u0000\u0000\u0407\u0001\u0000\u0000\u0000\u0000\u0409\u0001"+ + "\u0000\u0000\u0000\u0000\u040b\u0001\u0000\u0000\u0000\u0000\u040d\u0001"+ + "\u0000\u0000\u0000\u0000\u040f\u0001\u0000\u0000\u0000\u0000\u0411\u0001"+ + "\u0000\u0000\u0000\u0000\u0413\u0001\u0000\u0000\u0000\u0000\u0415\u0001"+ + "\u0000\u0000\u0000\u0000\u0417\u0001\u0000\u0000\u0000\u0000\u0419\u0001"+ + "\u0000\u0000\u0000\u0000\u041b\u0001\u0000\u0000\u0000\u0000\u041d\u0001"+ + "\u0000\u0000\u0000\u0000\u041f\u0001\u0000\u0000\u0000\u0000\u0421\u0001"+ + "\u0000\u0000\u0000\u0000\u0423\u0001\u0000\u0000\u0000\u0000\u0425\u0001"+ + "\u0000\u0000\u0000\u0000\u0427\u0001\u0000\u0000\u0000\u0000\u0429\u0001"+ + "\u0000\u0000\u0000\u0000\u042b\u0001\u0000\u0000\u0000\u0000\u042d\u0001"+ + "\u0000\u0000\u0000\u0000\u042f\u0001\u0000\u0000\u0000\u0000\u0431\u0001"+ + "\u0000\u0000\u0000\u0000\u0433\u0001\u0000\u0000\u0000\u0000\u0435\u0001"+ + "\u0000\u0000\u0000\u0000\u0437\u0001\u0000\u0000\u0000\u0000\u0439\u0001"+ + "\u0000\u0000\u0000\u0000\u043b\u0001\u0000\u0000\u0000\u0000\u043d\u0001"+ + "\u0000\u0000\u0000\u0000\u043f\u0001\u0000\u0000\u0000\u0000\u0441\u0001"+ + "\u0000\u0000\u0000\u0000\u0443\u0001\u0000\u0000\u0000\u0000\u0445\u0001"+ + "\u0000\u0000\u0000\u0000\u0447\u0001\u0000\u0000\u0000\u0000\u0449\u0001"+ + "\u0000\u0000\u0000\u0000\u044b\u0001\u0000\u0000\u0000\u0000\u044d\u0001"+ + "\u0000\u0000\u0000\u0000\u044f\u0001\u0000\u0000\u0000\u0000\u0451\u0001"+ + "\u0000\u0000\u0000\u0000\u0453\u0001\u0000\u0000\u0000\u0000\u0455\u0001"+ + "\u0000\u0000\u0000\u0000\u0457\u0001\u0000\u0000\u0000\u0000\u0459\u0001"+ + "\u0000\u0000\u0000\u0000\u045b\u0001\u0000\u0000\u0000\u0000\u045d\u0001"+ + "\u0000\u0000\u0000\u0000\u045f\u0001\u0000\u0000\u0000\u0000\u0461\u0001"+ + "\u0000\u0000\u0000\u0000\u0463\u0001\u0000\u0000\u0000\u0000\u0465\u0001"+ + "\u0000\u0000\u0000\u0000\u0467\u0001\u0000\u0000\u0000\u0000\u0469\u0001"+ + "\u0000\u0000\u0000\u0000\u046b\u0001\u0000\u0000\u0000\u0000\u046d\u0001"+ + "\u0000\u0000\u0000\u0000\u046f\u0001\u0000\u0000\u0000\u0000\u0471\u0001"+ + "\u0000\u0000\u0000\u0000\u0473\u0001\u0000\u0000\u0000\u0000\u0475\u0001"+ + "\u0000\u0000\u0000\u0000\u0477\u0001\u0000\u0000\u0000\u0000\u0479\u0001"+ + "\u0000\u0000\u0000\u0000\u047b\u0001\u0000\u0000\u0000\u0000\u047d\u0001"+ + "\u0000\u0000\u0000\u0000\u047f\u0001\u0000\u0000\u0000\u0000\u0481\u0001"+ + "\u0000\u0000\u0000\u0000\u0483\u0001\u0000\u0000\u0000\u0000\u0485\u0001"+ + "\u0000\u0000\u0000\u0000\u0487\u0001\u0000\u0000\u0000\u0000\u0489\u0001"+ + "\u0000\u0000\u0000\u0000\u048b\u0001\u0000\u0000\u0000\u0000\u048d\u0001"+ + "\u0000\u0000\u0000\u0000\u048f\u0001\u0000\u0000\u0000\u0000\u0491\u0001"+ + "\u0000\u0000\u0000\u0000\u0493\u0001\u0000\u0000\u0000\u0000\u0495\u0001"+ + "\u0000\u0000\u0000\u0000\u0497\u0001\u0000\u0000\u0000\u0000\u0499\u0001"+ + "\u0000\u0000\u0000\u0000\u049b\u0001\u0000\u0000\u0000\u0000\u049d\u0001"+ + "\u0000\u0000\u0000\u0000\u049f\u0001\u0000\u0000\u0000\u0000\u04a1\u0001"+ + "\u0000\u0000\u0000\u0000\u04a3\u0001\u0000\u0000\u0000\u0000\u04a5\u0001"+ + "\u0000\u0000\u0000\u0000\u04a7\u0001\u0000\u0000\u0000\u0000\u04a9\u0001"+ + "\u0000\u0000\u0000\u0000\u04ab\u0001\u0000\u0000\u0000\u0000\u04ad\u0001"+ + "\u0000\u0000\u0000\u0000\u04af\u0001\u0000\u0000\u0000\u0000\u04b1\u0001"+ + "\u0000\u0000\u0000\u0000\u04b3\u0001\u0000\u0000\u0000\u0000\u04b5\u0001"+ + "\u0000\u0000\u0000\u0000\u04b7\u0001\u0000\u0000\u0000\u0000\u04b9\u0001"+ + "\u0000\u0000\u0000\u0000\u04bb\u0001\u0000\u0000\u0000\u0000\u04bd\u0001"+ + "\u0000\u0000\u0000\u0000\u04bf\u0001\u0000\u0000\u0000\u0000\u04c1\u0001"+ + "\u0000\u0000\u0000\u0000\u04c3\u0001\u0000\u0000\u0000\u0000\u04c5\u0001"+ + "\u0000\u0000\u0000\u0000\u04c7\u0001\u0000\u0000\u0000\u0000\u04c9\u0001"+ + "\u0000\u0000\u0000\u0000\u04cb\u0001\u0000\u0000\u0000\u0000\u04cd\u0001"+ + "\u0000\u0000\u0000\u0000\u04cf\u0001\u0000\u0000\u0000\u0000\u04d1\u0001"+ + "\u0000\u0000\u0000\u0000\u04d3\u0001\u0000\u0000\u0000\u0000\u04d5\u0001"+ + "\u0000\u0000\u0000\u0000\u04d7\u0001\u0000\u0000\u0000\u0000\u04d9\u0001"+ + "\u0000\u0000\u0000\u0000\u04db\u0001\u0000\u0000\u0000\u0000\u04dd\u0001"+ + "\u0000\u0000\u0000\u0000\u04df\u0001\u0000\u0000\u0000\u0000\u04e1\u0001"+ + "\u0000\u0000\u0000\u0000\u04e3\u0001\u0000\u0000\u0000\u0000\u04e5\u0001"+ + "\u0000\u0000\u0000\u0000\u04e7\u0001\u0000\u0000\u0000\u0000\u04e9\u0001"+ + "\u0000\u0000\u0000\u0000\u04eb\u0001\u0000\u0000\u0000\u0000\u04ed\u0001"+ + "\u0000\u0000\u0000\u0000\u04ef\u0001\u0000\u0000\u0000\u0000\u04f1\u0001"+ + "\u0000\u0000\u0000\u0000\u04f3\u0001\u0000\u0000\u0000\u0000\u04f5\u0001"+ + "\u0000\u0000\u0000\u0000\u04f7\u0001\u0000\u0000\u0000\u0000\u04f9\u0001"+ + "\u0000\u0000\u0000\u0000\u04fb\u0001\u0000\u0000\u0000\u0000\u04fd\u0001"+ + "\u0000\u0000\u0000\u0000\u04ff\u0001\u0000\u0000\u0000\u0000\u0501\u0001"+ + "\u0000\u0000\u0000\u0000\u0503\u0001\u0000\u0000\u0000\u0000\u0505\u0001"+ + "\u0000\u0000\u0000\u0000\u0507\u0001\u0000\u0000\u0000\u0000\u0509\u0001"+ + "\u0000\u0000\u0000\u0000\u050b\u0001\u0000\u0000\u0000\u0000\u050d\u0001"+ + "\u0000\u0000\u0000\u0000\u050f\u0001\u0000\u0000\u0000\u0000\u0511\u0001"+ + "\u0000\u0000\u0000\u0000\u0513\u0001\u0000\u0000\u0000\u0000\u0515\u0001"+ + "\u0000\u0000\u0000\u0000\u0517\u0001\u0000\u0000\u0000\u0000\u0519\u0001"+ + "\u0000\u0000\u0000\u0000\u051b\u0001\u0000\u0000\u0000\u0000\u051d\u0001"+ + "\u0000\u0000\u0000\u0000\u051f\u0001\u0000\u0000\u0000\u0000\u0521\u0001"+ + "\u0000\u0000\u0000\u0000\u0523\u0001\u0000\u0000\u0000\u0000\u0525\u0001"+ + "\u0000\u0000\u0000\u0000\u0527\u0001\u0000\u0000\u0000\u0000\u0529\u0001"+ + "\u0000\u0000\u0000\u0000\u052b\u0001\u0000\u0000\u0000\u0000\u052d\u0001"+ + "\u0000\u0000\u0000\u0000\u052f\u0001\u0000\u0000\u0000\u0000\u0531\u0001"+ + "\u0000\u0000\u0000\u0000\u0533\u0001\u0000\u0000\u0000\u0000\u0535\u0001"+ + "\u0000\u0000\u0000\u0000\u0537\u0001\u0000\u0000\u0000\u0000\u0539\u0001"+ + "\u0000\u0000\u0000\u0000\u053b\u0001\u0000\u0000\u0000\u0000\u053d\u0001"+ + "\u0000\u0000\u0000\u0000\u053f\u0001\u0000\u0000\u0000\u0000\u0541\u0001"+ + "\u0000\u0000\u0000\u0000\u0543\u0001\u0000\u0000\u0000\u0000\u0545\u0001"+ + "\u0000\u0000\u0000\u0000\u0547\u0001\u0000\u0000\u0000\u0000\u0549\u0001"+ + "\u0000\u0000\u0000\u0000\u054b\u0001\u0000\u0000\u0000\u0000\u054d\u0001"+ + "\u0000\u0000\u0000\u0000\u054f\u0001\u0000\u0000\u0000\u0000\u0551\u0001"+ + "\u0000\u0000\u0000\u0000\u0553\u0001\u0000\u0000\u0000\u0000\u0555\u0001"+ + "\u0000\u0000\u0000\u0000\u0557\u0001\u0000\u0000\u0000\u0000\u0559\u0001"+ + "\u0000\u0000\u0000\u0000\u055b\u0001\u0000\u0000\u0000\u0000\u055d\u0001"+ + "\u0000\u0000\u0000\u0000\u055f\u0001\u0000\u0000\u0000\u0000\u0561\u0001"+ + "\u0000\u0000\u0000\u0000\u0563\u0001\u0000\u0000\u0000\u0000\u0565\u0001"+ + "\u0000\u0000\u0000\u0000\u0567\u0001\u0000\u0000\u0000\u0000\u0569\u0001"+ + "\u0000\u0000\u0000\u0000\u056b\u0001\u0000\u0000\u0000\u0000\u056d\u0001"+ + "\u0000\u0000\u0000\u0000\u056f\u0001\u0000\u0000\u0000\u0000\u0571\u0001"+ + "\u0000\u0000\u0000\u0000\u0573\u0001\u0000\u0000\u0000\u0000\u0575\u0001"+ + "\u0000\u0000\u0000\u0000\u0577\u0001\u0000\u0000\u0000\u0000\u0579\u0001"+ + "\u0000\u0000\u0000\u0000\u057b\u0001\u0000\u0000\u0000\u0000\u057d\u0001"+ + "\u0000\u0000\u0000\u0000\u057f\u0001\u0000\u0000\u0000\u0000\u0581\u0001"+ + "\u0000\u0000\u0000\u0000\u0583\u0001\u0000\u0000\u0000\u0000\u0585\u0001"+ + "\u0000\u0000\u0000\u0000\u0587\u0001\u0000\u0000\u0000\u0000\u0589\u0001"+ + "\u0000\u0000\u0000\u0000\u058b\u0001\u0000\u0000\u0000\u0000\u058d\u0001"+ + "\u0000\u0000\u0000\u0000\u058f\u0001\u0000\u0000\u0000\u0000\u0591\u0001"+ + "\u0000\u0000\u0000\u0000\u0593\u0001\u0000\u0000\u0000\u0000\u0595\u0001"+ + "\u0000\u0000\u0000\u0000\u0597\u0001\u0000\u0000\u0000\u0000\u0599\u0001"+ + "\u0000\u0000\u0000\u0000\u059b\u0001\u0000\u0000\u0000\u0000\u059d\u0001"+ + "\u0000\u0000\u0000\u0000\u059f\u0001\u0000\u0000\u0000\u0000\u05a1\u0001"+ + "\u0000\u0000\u0000\u0000\u05a3\u0001\u0000\u0000\u0000\u0000\u05a5\u0001"+ + "\u0000\u0000\u0000\u0000\u05a7\u0001\u0000\u0000\u0000\u0000\u05a9\u0001"+ + "\u0000\u0000\u0000\u0000\u05ab\u0001\u0000\u0000\u0000\u0000\u05ad\u0001"+ + "\u0000\u0000\u0000\u0000\u05af\u0001\u0000\u0000\u0000\u0000\u05b1\u0001"+ + "\u0000\u0000\u0000\u0000\u05b3\u0001\u0000\u0000\u0000\u0000\u05b5\u0001"+ + "\u0000\u0000\u0000\u0000\u05b7\u0001\u0000\u0000\u0000\u0000\u05b9\u0001"+ + "\u0000\u0000\u0000\u0000\u05bb\u0001\u0000\u0000\u0000\u0000\u05bd\u0001"+ + "\u0000\u0000\u0000\u0000\u05bf\u0001\u0000\u0000\u0000\u0000\u05c1\u0001"+ + "\u0000\u0000\u0000\u0000\u05c3\u0001\u0000\u0000\u0000\u0000\u05c5\u0001"+ + "\u0000\u0000\u0000\u0000\u05c7\u0001\u0000\u0000\u0000\u0000\u05c9\u0001"+ + "\u0000\u0000\u0000\u0000\u05cb\u0001\u0000\u0000\u0000\u0000\u05cd\u0001"+ + "\u0000\u0000\u0000\u0000\u05cf\u0001\u0000\u0000\u0000\u0000\u05d1\u0001"+ + "\u0000\u0000\u0000\u0000\u05d3\u0001\u0000\u0000\u0000\u0000\u05d5\u0001"+ + "\u0000\u0000\u0000\u0000\u05d7\u0001\u0000\u0000\u0000\u0000\u05d9\u0001"+ + "\u0000\u0000\u0000\u0000\u05db\u0001\u0000\u0000\u0000\u0000\u05dd\u0001"+ + "\u0000\u0000\u0000\u0000\u05df\u0001\u0000\u0000\u0000\u0000\u05e1\u0001"+ + "\u0000\u0000\u0000\u0000\u05e3\u0001\u0000\u0000\u0000\u0000\u05e5\u0001"+ + "\u0000\u0000\u0000\u0000\u05e7\u0001\u0000\u0000\u0000\u0000\u05e9\u0001"+ + "\u0000\u0000\u0000\u0000\u05eb\u0001\u0000\u0000\u0000\u0000\u05ed\u0001"+ + "\u0000\u0000\u0000\u0000\u05ef\u0001\u0000\u0000\u0000\u0000\u05f1\u0001"+ + "\u0000\u0000\u0000\u0000\u05f3\u0001\u0000\u0000\u0000\u0000\u05f5\u0001"+ + "\u0000\u0000\u0000\u0000\u05f7\u0001\u0000\u0000\u0000\u0000\u05f9\u0001"+ + "\u0000\u0000\u0000\u0000\u05fb\u0001\u0000\u0000\u0000\u0000\u05fd\u0001"+ + "\u0000\u0000\u0000\u0000\u05ff\u0001\u0000\u0000\u0000\u0000\u0601\u0001"+ + "\u0000\u0000\u0000\u0000\u0603\u0001\u0000\u0000\u0000\u0000\u0605\u0001"+ + "\u0000\u0000\u0000\u0000\u0607\u0001\u0000\u0000\u0000\u0000\u0609\u0001"+ + "\u0000\u0000\u0000\u0000\u060b\u0001\u0000\u0000\u0000\u0000\u060d\u0001"+ + "\u0000\u0000\u0000\u0000\u060f\u0001\u0000\u0000\u0000\u0000\u0611\u0001"+ + "\u0000\u0000\u0000\u0000\u0613\u0001\u0000\u0000\u0000\u0000\u0615\u0001"+ + "\u0000\u0000\u0000\u0000\u0617\u0001\u0000\u0000\u0000\u0000\u0619\u0001"+ + "\u0000\u0000\u0000\u0000\u061b\u0001\u0000\u0000\u0000\u0000\u061d\u0001"+ + "\u0000\u0000\u0000\u0000\u061f\u0001\u0000\u0000\u0000\u0000\u0621\u0001"+ + "\u0000\u0000\u0000\u0000\u0623\u0001\u0000\u0000\u0000\u0000\u0625\u0001"+ + "\u0000\u0000\u0000\u0000\u0627\u0001\u0000\u0000\u0000\u0000\u0629\u0001"+ + "\u0000\u0000\u0000\u0000\u062b\u0001\u0000\u0000\u0000\u0000\u062d\u0001"+ + "\u0000\u0000\u0000\u0000\u062f\u0001\u0000\u0000\u0000\u0000\u0631\u0001"+ + "\u0000\u0000\u0000\u0000\u0633\u0001\u0000\u0000\u0000\u0000\u0635\u0001"+ + "\u0000\u0000\u0000\u0000\u0637\u0001\u0000\u0000\u0000\u0000\u0639\u0001"+ + "\u0000\u0000\u0000\u0000\u063b\u0001\u0000\u0000\u0000\u0000\u063d\u0001"+ + "\u0000\u0000\u0000\u0000\u063f\u0001\u0000\u0000\u0000\u0000\u0641\u0001"+ + "\u0000\u0000\u0000\u0000\u0643\u0001\u0000\u0000\u0000\u0000\u0645\u0001"+ + "\u0000\u0000\u0000\u0000\u0647\u0001\u0000\u0000\u0000\u0000\u0649\u0001"+ + "\u0000\u0000\u0000\u0000\u064b\u0001\u0000\u0000\u0000\u0000\u064d\u0001"+ + "\u0000\u0000\u0000\u0000\u064f\u0001\u0000\u0000\u0000\u0000\u0651\u0001"+ + "\u0000\u0000\u0000\u0000\u0653\u0001\u0000\u0000\u0000\u0000\u0655\u0001"+ + "\u0000\u0000\u0000\u0000\u0657\u0001\u0000\u0000\u0000\u0000\u0659\u0001"+ + "\u0000\u0000\u0000\u0000\u065b\u0001\u0000\u0000\u0000\u0000\u065d\u0001"+ + "\u0000\u0000\u0000\u0000\u065f\u0001\u0000\u0000\u0000\u0000\u0661\u0001"+ + "\u0000\u0000\u0000\u0000\u0663\u0001\u0000\u0000\u0000\u0000\u0665\u0001"+ + "\u0000\u0000\u0000\u0000\u0667\u0001\u0000\u0000\u0000\u0000\u0669\u0001"+ + "\u0000\u0000\u0000\u0000\u066b\u0001\u0000\u0000\u0000\u0000\u066d\u0001"+ + "\u0000\u0000\u0000\u0000\u066f\u0001\u0000\u0000\u0000\u0000\u0671\u0001"+ + "\u0000\u0000\u0000\u0000\u0673\u0001\u0000\u0000\u0000\u0000\u0675\u0001"+ + "\u0000\u0000\u0000\u0000\u0677\u0001\u0000\u0000\u0000\u0000\u0679\u0001"+ + "\u0000\u0000\u0000\u0000\u067b\u0001\u0000\u0000\u0000\u0000\u067d\u0001"+ + "\u0000\u0000\u0000\u0000\u067f\u0001\u0000\u0000\u0000\u0000\u0681\u0001"+ + "\u0000\u0000\u0000\u0000\u0683\u0001\u0000\u0000\u0000\u0000\u0685\u0001"+ + "\u0000\u0000\u0000\u0000\u0687\u0001\u0000\u0000\u0000\u0000\u0689\u0001"+ + "\u0000\u0000\u0000\u0000\u068b\u0001\u0000\u0000\u0000\u0000\u068d\u0001"+ + "\u0000\u0000\u0000\u0000\u068f\u0001\u0000\u0000\u0000\u0000\u0691\u0001"+ + "\u0000\u0000\u0000\u0000\u0693\u0001\u0000\u0000\u0000\u0000\u0695\u0001"+ + "\u0000\u0000\u0000\u0000\u0697\u0001\u0000\u0000\u0000\u0000\u0699\u0001"+ + "\u0000\u0000\u0000\u0000\u069b\u0001\u0000\u0000\u0000\u0000\u069d\u0001"+ + "\u0000\u0000\u0000\u0000\u069f\u0001\u0000\u0000\u0000\u0000\u06a1\u0001"+ + "\u0000\u0000\u0000\u0000\u06a3\u0001\u0000\u0000\u0000\u0000\u06a5\u0001"+ + "\u0000\u0000\u0000\u0000\u06a7\u0001\u0000\u0000\u0000\u0000\u06a9\u0001"+ + "\u0000\u0000\u0000\u0000\u06ab\u0001\u0000\u0000\u0000\u0000\u06ad\u0001"+ + "\u0000\u0000\u0000\u0000\u06af\u0001\u0000\u0000\u0000\u0000\u06b1\u0001"+ + "\u0000\u0000\u0000\u0000\u06b3\u0001\u0000\u0000\u0000\u0000\u06b5\u0001"+ + "\u0000\u0000\u0000\u0000\u06b7\u0001\u0000\u0000\u0000\u0000\u06b9\u0001"+ + "\u0000\u0000\u0000\u0000\u06bb\u0001\u0000\u0000\u0000\u0000\u06bd\u0001"+ + "\u0000\u0000\u0000\u0000\u06bf\u0001\u0000\u0000\u0000\u0000\u06c1\u0001"+ + "\u0000\u0000\u0000\u0000\u06c3\u0001\u0000\u0000\u0000\u0000\u06c5\u0001"+ + "\u0000\u0000\u0000\u0000\u06c7\u0001\u0000\u0000\u0000\u0000\u06c9\u0001"+ + "\u0000\u0000\u0000\u0000\u06cb\u0001\u0000\u0000\u0000\u0000\u06cd\u0001"+ + "\u0000\u0000\u0000\u0000\u06cf\u0001\u0000\u0000\u0000\u0000\u06d1\u0001"+ + "\u0000\u0000\u0000\u0000\u06d3\u0001\u0000\u0000\u0000\u0000\u06d5\u0001"+ + "\u0000\u0000\u0000\u0000\u06d7\u0001\u0000\u0000\u0000\u0000\u06d9\u0001"+ + "\u0000\u0000\u0000\u0000\u06db\u0001\u0000\u0000\u0000\u0000\u06dd\u0001"+ + "\u0000\u0000\u0000\u0000\u06df\u0001\u0000\u0000\u0000\u0000\u06e1\u0001"+ + "\u0000\u0000\u0000\u0000\u06e3\u0001\u0000\u0000\u0000\u0000\u06e5\u0001"+ + "\u0000\u0000\u0000\u0000\u06e7\u0001\u0000\u0000\u0000\u0000\u06e9\u0001"+ + "\u0000\u0000\u0000\u0000\u06eb\u0001\u0000\u0000\u0000\u0000\u06ed\u0001"+ + "\u0000\u0000\u0000\u0000\u06ef\u0001\u0000\u0000\u0000\u0000\u06f1\u0001"+ + "\u0000\u0000\u0000\u0000\u06f3\u0001\u0000\u0000\u0000\u0000\u06f5\u0001"+ + "\u0000\u0000\u0000\u0000\u06f7\u0001\u0000\u0000\u0000\u0000\u06f9\u0001"+ + "\u0000\u0000\u0000\u0000\u06fb\u0001\u0000\u0000\u0000\u0000\u06fd\u0001"+ + "\u0000\u0000\u0000\u0000\u06ff\u0001\u0000\u0000\u0000\u0000\u0701\u0001"+ + "\u0000\u0000\u0000\u0000\u0703\u0001\u0000\u0000\u0000\u0000\u0705\u0001"+ + "\u0000\u0000\u0000\u0000\u0707\u0001\u0000\u0000\u0000\u0000\u0709\u0001"+ + "\u0000\u0000\u0000\u0000\u070b\u0001\u0000\u0000\u0000\u0000\u070d\u0001"+ + "\u0000\u0000\u0000\u0000\u070f\u0001\u0000\u0000\u0000\u0000\u0711\u0001"+ + "\u0000\u0000\u0000\u0000\u0713\u0001\u0000\u0000\u0000\u0000\u0715\u0001"+ + "\u0000\u0000\u0000\u0000\u0717\u0001\u0000\u0000\u0000\u0000\u0719\u0001"+ + "\u0000\u0000\u0000\u0000\u071b\u0001\u0000\u0000\u0000\u0000\u071d\u0001"+ + "\u0000\u0000\u0000\u0000\u071f\u0001\u0000\u0000\u0000\u0000\u0721\u0001"+ + "\u0000\u0000\u0000\u0000\u0723\u0001\u0000\u0000\u0000\u0000\u0725\u0001"+ + "\u0000\u0000\u0000\u0000\u0727\u0001\u0000\u0000\u0000\u0000\u0729\u0001"+ + "\u0000\u0000\u0000\u0000\u072b\u0001\u0000\u0000\u0000\u0000\u072d\u0001"+ + "\u0000\u0000\u0000\u0000\u072f\u0001\u0000\u0000\u0000\u0000\u0731\u0001"+ + "\u0000\u0000\u0000\u0000\u0733\u0001\u0000\u0000\u0000\u0000\u0735\u0001"+ + "\u0000\u0000\u0000\u0000\u0737\u0001\u0000\u0000\u0000\u0000\u0739\u0001"+ + "\u0000\u0000\u0000\u0000\u073b\u0001\u0000\u0000\u0000\u0000\u073d\u0001"+ + "\u0000\u0000\u0000\u0000\u073f\u0001\u0000\u0000\u0000\u0000\u0741\u0001"+ + "\u0000\u0000\u0000\u0000\u0743\u0001\u0000\u0000\u0000\u0000\u0745\u0001"+ + "\u0000\u0000\u0000\u0000\u0747\u0001\u0000\u0000\u0000\u0000\u0749\u0001"+ + "\u0000\u0000\u0000\u0000\u074b\u0001\u0000\u0000\u0000\u0000\u074d\u0001"+ + "\u0000\u0000\u0000\u0000\u074f\u0001\u0000\u0000\u0000\u0000\u0751\u0001"+ + "\u0000\u0000\u0000\u0000\u0753\u0001\u0000\u0000\u0000\u0000\u0755\u0001"+ + "\u0000\u0000\u0000\u0000\u0757\u0001\u0000\u0000\u0000\u0000\u0759\u0001"+ + "\u0000\u0000\u0000\u0000\u075b\u0001\u0000\u0000\u0000\u0000\u075d\u0001"+ + "\u0000\u0000\u0000\u0000\u075f\u0001\u0000\u0000\u0000\u0000\u0761\u0001"+ + "\u0000\u0000\u0000\u0000\u0763\u0001\u0000\u0000\u0000\u0000\u0765\u0001"+ + "\u0000\u0000\u0000\u0000\u0767\u0001\u0000\u0000\u0000\u0000\u0769\u0001"+ + "\u0000\u0000\u0000\u0000\u076b\u0001\u0000\u0000\u0000\u0000\u076d\u0001"+ + "\u0000\u0000\u0000\u0000\u076f\u0001\u0000\u0000\u0000\u0000\u0771\u0001"+ + "\u0000\u0000\u0000\u0000\u0773\u0001\u0000\u0000\u0000\u0000\u0775\u0001"+ + "\u0000\u0000\u0000\u0000\u0777\u0001\u0000\u0000\u0000\u0000\u0779\u0001"+ + "\u0000\u0000\u0000\u0000\u077b\u0001\u0000\u0000\u0000\u0000\u077d\u0001"+ + "\u0000\u0000\u0000\u0000\u077f\u0001\u0000\u0000\u0000\u0000\u0781\u0001"+ + "\u0000\u0000\u0000\u0000\u0783\u0001\u0000\u0000\u0000\u0000\u0785\u0001"+ + "\u0000\u0000\u0000\u0000\u0787\u0001\u0000\u0000\u0000\u0000\u0789\u0001"+ + "\u0000\u0000\u0000\u0000\u078b\u0001\u0000\u0000\u0000\u0000\u078d\u0001"+ + "\u0000\u0000\u0000\u0000\u078f\u0001\u0000\u0000\u0000\u0000\u0791\u0001"+ + "\u0000\u0000\u0000\u0000\u0793\u0001\u0000\u0000\u0000\u0000\u0795\u0001"+ + "\u0000\u0000\u0000\u0000\u0797\u0001\u0000\u0000\u0000\u0000\u0799\u0001"+ + "\u0000\u0000\u0000\u0000\u079b\u0001\u0000\u0000\u0000\u0000\u079d\u0001"+ + "\u0000\u0000\u0000\u0000\u079f\u0001\u0000\u0000\u0000\u0000\u07a1\u0001"+ + "\u0000\u0000\u0000\u0000\u07a3\u0001\u0000\u0000\u0000\u0000\u07a5\u0001"+ + "\u0000\u0000\u0000\u0000\u07a7\u0001\u0000\u0000\u0000\u0000\u07a9\u0001"+ + "\u0000\u0000\u0000\u0000\u07ab\u0001\u0000\u0000\u0000\u0000\u07ad\u0001"+ + "\u0000\u0000\u0000\u0000\u07af\u0001\u0000\u0000\u0000\u0000\u07b1\u0001"+ + "\u0000\u0000\u0000\u0000\u07b3\u0001\u0000\u0000\u0000\u0000\u07b5\u0001"+ + "\u0000\u0000\u0000\u0000\u07b7\u0001\u0000\u0000\u0000\u0000\u07b9\u0001"+ + "\u0000\u0000\u0000\u0000\u07bb\u0001\u0000\u0000\u0000\u0000\u07bd\u0001"+ + "\u0000\u0000\u0000\u0000\u07bf\u0001\u0000\u0000\u0000\u0000\u07c1\u0001"+ + "\u0000\u0000\u0000\u0000\u07c3\u0001\u0000\u0000\u0000\u0000\u07c5\u0001"+ + "\u0000\u0000\u0000\u0000\u07c7\u0001\u0000\u0000\u0000\u0000\u07c9\u0001"+ + "\u0000\u0000\u0000\u0000\u07cb\u0001\u0000\u0000\u0000\u0000\u07cd\u0001"+ + "\u0000\u0000\u0000\u0000\u07cf\u0001\u0000\u0000\u0000\u0000\u07d1\u0001"+ + "\u0000\u0000\u0000\u0000\u07d3\u0001\u0000\u0000\u0000\u0000\u07d5\u0001"+ + "\u0000\u0000\u0000\u0000\u07d7\u0001\u0000\u0000\u0000\u0000\u07d9\u0001"+ + "\u0000\u0000\u0000\u0000\u07db\u0001\u0000\u0000\u0000\u0000\u07dd\u0001"+ + "\u0000\u0000\u0000\u0000\u07df\u0001\u0000\u0000\u0000\u0000\u07e1\u0001"+ + "\u0000\u0000\u0000\u0000\u07e3\u0001\u0000\u0000\u0000\u0000\u07e5\u0001"+ + "\u0000\u0000\u0000\u0000\u07e7\u0001\u0000\u0000\u0000\u0000\u07e9\u0001"+ + "\u0000\u0000\u0000\u0000\u07eb\u0001\u0000\u0000\u0000\u0000\u07ed\u0001"+ + "\u0000\u0000\u0000\u0000\u07ef\u0001\u0000\u0000\u0000\u0000\u07f1\u0001"+ + "\u0000\u0000\u0000\u0000\u07f3\u0001\u0000\u0000\u0000\u0000\u07f5\u0001"+ + "\u0000\u0000\u0000\u0000\u07f7\u0001\u0000\u0000\u0000\u0000\u07f9\u0001"+ + "\u0000\u0000\u0000\u0000\u07fb\u0001\u0000\u0000\u0000\u0000\u07fd\u0001"+ + "\u0000\u0000\u0000\u0000\u07ff\u0001\u0000\u0000\u0000\u0000\u0801\u0001"+ + "\u0000\u0000\u0000\u0000\u0803\u0001\u0000\u0000\u0000\u0000\u0805\u0001"+ + "\u0000\u0000\u0000\u0000\u0807\u0001\u0000\u0000\u0000\u0000\u0809\u0001"+ + "\u0000\u0000\u0000\u0000\u080b\u0001\u0000\u0000\u0000\u0000\u080d\u0001"+ + "\u0000\u0000\u0000\u0000\u080f\u0001\u0000\u0000\u0000\u0000\u0811\u0001"+ + "\u0000\u0000\u0000\u0000\u0813\u0001\u0000\u0000\u0000\u0000\u0815\u0001"+ + "\u0000\u0000\u0000\u0000\u0817\u0001\u0000\u0000\u0000\u0000\u0819\u0001"+ + "\u0000\u0000\u0000\u0000\u081b\u0001\u0000\u0000\u0000\u0000\u081d\u0001"+ + "\u0000\u0000\u0000\u0000\u081f\u0001\u0000\u0000\u0000\u0000\u0821\u0001"+ + "\u0000\u0000\u0000\u0000\u0823\u0001\u0000\u0000\u0000\u0000\u0825\u0001"+ + "\u0000\u0000\u0000\u0000\u0827\u0001\u0000\u0000\u0000\u0000\u0829\u0001"+ + "\u0000\u0000\u0000\u0000\u082b\u0001\u0000\u0000\u0000\u0000\u082d\u0001"+ + "\u0000\u0000\u0000\u0000\u082f\u0001\u0000\u0000\u0000\u0000\u0831\u0001"+ + "\u0000\u0000\u0000\u0000\u0833\u0001\u0000\u0000\u0000\u0000\u0835\u0001"+ + "\u0000\u0000\u0000\u0000\u0837\u0001\u0000\u0000\u0000\u0000\u0839\u0001"+ + "\u0000\u0000\u0000\u0000\u083b\u0001\u0000\u0000\u0000\u0000\u083d\u0001"+ + "\u0000\u0000\u0000\u0000\u083f\u0001\u0000\u0000\u0000\u0000\u0841\u0001"+ + "\u0000\u0000\u0000\u0000\u0843\u0001\u0000\u0000\u0000\u0000\u0845\u0001"+ + "\u0000\u0000\u0000\u0000\u0847\u0001\u0000\u0000\u0000\u0000\u0849\u0001"+ + "\u0000\u0000\u0000\u0000\u084b\u0001\u0000\u0000\u0000\u0000\u084d\u0001"+ + "\u0000\u0000\u0000\u0000\u084f\u0001\u0000\u0000\u0000\u0000\u0851\u0001"+ + "\u0000\u0000\u0000\u0000\u0853\u0001\u0000\u0000\u0000\u0000\u0855\u0001"+ + "\u0000\u0000\u0000\u0000\u0857\u0001\u0000\u0000\u0000\u0000\u0859\u0001"+ + "\u0000\u0000\u0000\u0000\u085b\u0001\u0000\u0000\u0000\u0000\u085d\u0001"+ + "\u0000\u0000\u0000\u0000\u085f\u0001\u0000\u0000\u0000\u0000\u0861\u0001"+ + "\u0000\u0000\u0000\u0000\u0863\u0001\u0000\u0000\u0000\u0000\u0865\u0001"+ + "\u0000\u0000\u0000\u0000\u0867\u0001\u0000\u0000\u0000\u0000\u0869\u0001"+ + "\u0000\u0000\u0000\u0000\u086b\u0001\u0000\u0000\u0000\u0000\u086d\u0001"+ + "\u0000\u0000\u0000\u0000\u086f\u0001\u0000\u0000\u0000\u0000\u0871\u0001"+ + "\u0000\u0000\u0000\u0000\u0873\u0001\u0000\u0000\u0000\u0000\u0875\u0001"+ + "\u0000\u0000\u0000\u0000\u0877\u0001\u0000\u0000\u0000\u0000\u0879\u0001"+ + "\u0000\u0000\u0000\u0000\u087b\u0001\u0000\u0000\u0000\u0000\u087d\u0001"+ + "\u0000\u0000\u0000\u0000\u087f\u0001\u0000\u0000\u0000\u0000\u0881\u0001"+ + "\u0000\u0000\u0000\u0000\u0883\u0001\u0000\u0000\u0000\u0000\u0885\u0001"+ + "\u0000\u0000\u0000\u0000\u0887\u0001\u0000\u0000\u0000\u0000\u0889\u0001"+ + "\u0000\u0000\u0000\u0000\u088b\u0001\u0000\u0000\u0000\u0000\u088d\u0001"+ + "\u0000\u0000\u0000\u0000\u088f\u0001\u0000\u0000\u0000\u0000\u0891\u0001"+ + "\u0000\u0000\u0000\u0000\u0893\u0001\u0000\u0000\u0000\u0000\u0895\u0001"+ + "\u0000\u0000\u0000\u0000\u0897\u0001\u0000\u0000\u0000\u0000\u0899\u0001"+ + "\u0000\u0000\u0000\u0000\u089b\u0001\u0000\u0000\u0000\u0000\u089d\u0001"+ + "\u0000\u0000\u0000\u0000\u089f\u0001\u0000\u0000\u0000\u0000\u08a1\u0001"+ + "\u0000\u0000\u0000\u0000\u08a3\u0001\u0000\u0000\u0000\u0000\u08a5\u0001"+ + "\u0000\u0000\u0000\u0000\u08a7\u0001\u0000\u0000\u0000\u0000\u08a9\u0001"+ + "\u0000\u0000\u0000\u0000\u08ab\u0001\u0000\u0000\u0000\u0000\u08ad\u0001"+ + "\u0000\u0000\u0000\u0000\u08af\u0001\u0000\u0000\u0000\u0000\u08b1\u0001"+ + "\u0000\u0000\u0000\u0000\u08b3\u0001\u0000\u0000\u0000\u0000\u08b5\u0001"+ + "\u0000\u0000\u0000\u0000\u08b7\u0001\u0000\u0000\u0000\u0000\u08b9\u0001"+ + "\u0000\u0000\u0000\u0000\u08bb\u0001\u0000\u0000\u0000\u0000\u08bd\u0001"+ + "\u0000\u0000\u0000\u0000\u08bf\u0001\u0000\u0000\u0000\u0000\u08c1\u0001"+ + "\u0000\u0000\u0000\u0000\u08c3\u0001\u0000\u0000\u0000\u0000\u08c5\u0001"+ + "\u0000\u0000\u0000\u0000\u08c7\u0001\u0000\u0000\u0000\u0000\u08c9\u0001"+ + "\u0000\u0000\u0000\u0000\u08cb\u0001\u0000\u0000\u0000\u0000\u08cd\u0001"+ + "\u0000\u0000\u0000\u0000\u08cf\u0001\u0000\u0000\u0000\u0000\u08d1\u0001"+ + "\u0000\u0000\u0000\u0000\u08d3\u0001\u0000\u0000\u0000\u0000\u08d5\u0001"+ + "\u0000\u0000\u0000\u0000\u08d7\u0001\u0000\u0000\u0000\u0000\u08d9\u0001"+ + "\u0000\u0000\u0000\u0000\u08db\u0001\u0000\u0000\u0000\u0000\u08dd\u0001"+ + "\u0000\u0000\u0000\u0000\u08df\u0001\u0000\u0000\u0000\u0000\u08e1\u0001"+ + "\u0000\u0000\u0000\u0000\u08e3\u0001\u0000\u0000\u0000\u0000\u08e5\u0001"+ + "\u0000\u0000\u0000\u0000\u08e7\u0001\u0000\u0000\u0000\u0000\u08e9\u0001"+ + "\u0000\u0000\u0000\u0000\u08eb\u0001\u0000\u0000\u0000\u0000\u08ed\u0001"+ + "\u0000\u0000\u0000\u0000\u08ef\u0001\u0000\u0000\u0000\u0000\u08f1\u0001"+ + "\u0000\u0000\u0000\u0000\u08f5\u0001\u0000\u0000\u0000\u0000\u08f7\u0001"+ + "\u0000\u0000\u0000\u0000\u08f9\u0001\u0000\u0000\u0000\u0000\u08fb\u0001"+ + "\u0000\u0000\u0000\u0000\u08fd\u0001\u0000\u0000\u0000\u0000\u08ff\u0001"+ + "\u0000\u0000\u0000\u0000\u0901\u0001\u0000\u0000\u0000\u0000\u0903\u0001"+ + "\u0000\u0000\u0000\u0000\u0905\u0001\u0000\u0000\u0000\u0000\u0907\u0001"+ + "\u0000\u0000\u0000\u0000\u0909\u0001\u0000\u0000\u0000\u0000\u090b\u0001"+ + "\u0000\u0000\u0000\u0000\u090d\u0001\u0000\u0000\u0000\u0000\u090f\u0001"+ + "\u0000\u0000\u0000\u0000\u0911\u0001\u0000\u0000\u0000\u0000\u0913\u0001"+ + "\u0000\u0000\u0000\u0000\u0929\u0001\u0000\u0000\u0000\u0001\u092b\u0001"+ + "\u0000\u0000\u0000\u0003\u0936\u0001\u0000\u0000\u0000\u0005\u093c\u0001"+ + "\u0000\u0000\u0000\u0007\u094a\u0001\u0000\u0000\u0000\t\u097b\u0001\u0000"+ + "\u0000\u0000\u000b\u097f\u0001\u0000\u0000\u0000\r\u0983\u0001\u0000\u0000"+ + "\u0000\u000f\u0987\u0001\u0000\u0000\u0000\u0011\u098d\u0001\u0000\u0000"+ + "\u0000\u0013\u0994\u0001\u0000\u0000\u0000\u0015\u099c\u0001\u0000\u0000"+ + "\u0000\u0017\u09a0\u0001\u0000\u0000\u0000\u0019\u09a6\u0001\u0000\u0000"+ + "\u0000\u001b\u09a9\u0001\u0000\u0000\u0000\u001d\u09ad\u0001\u0000\u0000"+ + "\u0000\u001f\u09b7\u0001\u0000\u0000\u0000!\u09be\u0001\u0000\u0000\u0000"+ + "#\u09c6\u0001\u0000\u0000\u0000%\u09cb\u0001\u0000\u0000\u0000\'\u09d3"+ + "\u0001\u0000\u0000\u0000)\u09d6\u0001\u0000\u0000\u0000+\u09db\u0001\u0000"+ + "\u0000\u0000-\u09e3\u0001\u0000\u0000\u0000/\u09e8\u0001\u0000\u0000\u0000"+ + "1\u09ed\u0001\u0000\u0000\u00003\u09f4\u0001\u0000\u0000\u00005\u09fe"+ + "\u0001\u0000\u0000\u00007\u0a04\u0001\u0000\u0000\u00009\u0a0c\u0001\u0000"+ + "\u0000\u0000;\u0a13\u0001\u0000\u0000\u0000=\u0a1d\u0001\u0000\u0000\u0000"+ + "?\u0a28\u0001\u0000\u0000\u0000A\u0a31\u0001\u0000\u0000\u0000C\u0a39"+ + "\u0001\u0000\u0000\u0000E\u0a40\u0001\u0000\u0000\u0000G\u0a46\u0001\u0000"+ + "\u0000\u0000I\u0a4e\u0001\u0000\u0000\u0000K\u0a5b\u0001\u0000\u0000\u0000"+ + "M\u0a68\u0001\u0000\u0000\u0000O\u0a6f\u0001\u0000\u0000\u0000Q\u0a78"+ + "\u0001\u0000\u0000\u0000S\u0a82\u0001\u0000\u0000\u0000U\u0a8a\u0001\u0000"+ + "\u0000\u0000W\u0a92\u0001\u0000\u0000\u0000Y\u0a9a\u0001\u0000\u0000\u0000"+ + "[\u0aa1\u0001\u0000\u0000\u0000]\u0aa6\u0001\u0000\u0000\u0000_\u0aaf"+ + "\u0001\u0000\u0000\u0000a\u0abd\u0001\u0000\u0000\u0000c\u0ac9\u0001\u0000"+ + "\u0000\u0000e\u0ad2\u0001\u0000\u0000\u0000g\u0ade\u0001\u0000\u0000\u0000"+ + "i\u0ae3\u0001\u0000\u0000\u0000k\u0ae8\u0001\u0000\u0000\u0000m\u0aed"+ + "\u0001\u0000\u0000\u0000o\u0af4\u0001\u0000\u0000\u0000q\u0afa\u0001\u0000"+ + "\u0000\u0000s\u0b03\u0001\u0000\u0000\u0000u\u0b0c\u0001\u0000\u0000\u0000"+ + "w\u0b14\u0001\u0000\u0000\u0000y\u0b1b\u0001\u0000\u0000\u0000{\u0b22"+ + "\u0001\u0000\u0000\u0000}\u0b27\u0001\u0000\u0000\u0000\u007f\u0b2f\u0001"+ + "\u0000\u0000\u0000\u0081\u0b35\u0001\u0000\u0000\u0000\u0083\u0b3b\u0001"+ + "\u0000\u0000\u0000\u0085\u0b3f\u0001\u0000\u0000\u0000\u0087\u0b45\u0001"+ + "\u0000\u0000\u0000\u0089\u0b4d\u0001\u0000\u0000\u0000\u008b\u0b52\u0001"+ + "\u0000\u0000\u0000\u008d\u0b5b\u0001\u0000\u0000\u0000\u008f\u0b65\u0001"+ + "\u0000\u0000\u0000\u0091\u0b69\u0001\u0000\u0000\u0000\u0093\u0b6f\u0001"+ + "\u0000\u0000\u0000\u0095\u0b75\u0001\u0000\u0000\u0000\u0097\u0b7c\u0001"+ + "\u0000\u0000\u0000\u0099\u0b8a\u0001\u0000\u0000\u0000\u009b\u0b94\u0001"+ + "\u0000\u0000\u0000\u009d\u0b97\u0001\u0000\u0000\u0000\u009f\u0b9e\u0001"+ + "\u0000\u0000\u0000\u00a1\u0ba6\u0001\u0000\u0000\u0000\u00a3\u0ba9\u0001"+ + "\u0000\u0000\u0000\u00a5\u0baf\u0001\u0000\u0000\u0000\u00a7\u0bb6\u0001"+ + "\u0000\u0000\u0000\u00a9\u0bbc\u0001\u0000\u0000\u0000\u00ab\u0bc2\u0001"+ + "\u0000\u0000\u0000\u00ad\u0bc9\u0001\u0000\u0000\u0000\u00af\u0bd2\u0001"+ + "\u0000\u0000\u0000\u00b1\u0bd7\u0001\u0000\u0000\u0000\u00b3\u0bda\u0001"+ + "\u0000\u0000\u0000\u00b5\u0be2\u0001\u0000\u0000\u0000\u00b7\u0be7\u0001"+ + "\u0000\u0000\u0000\u00b9\u0beb\u0001\u0000\u0000\u0000\u00bb\u0bf0\u0001"+ + "\u0000\u0000\u0000\u00bd\u0bf5\u0001\u0000\u0000\u0000\u00bf\u0bfd\u0001"+ + "\u0000\u0000\u0000\u00c1\u0c05\u0001\u0000\u0000\u0000\u00c3\u0c0b\u0001"+ + "\u0000\u0000\u0000\u00c5\u0c10\u0001\u0000\u0000\u0000\u00c7\u0c15\u0001"+ + "\u0000\u0000\u0000\u00c9\u0c1b\u0001\u0000\u0000\u0000\u00cb\u0c22\u0001"+ + "\u0000\u0000\u0000\u00cd\u0c28\u0001\u0000\u0000\u0000\u00cf\u0c2d\u0001"+ + "\u0000\u0000\u0000\u00d1\u0c32\u0001\u0000\u0000\u0000\u00d3\u0c39\u0001"+ + "\u0000\u0000\u0000\u00d5\u0c3e\u0001\u0000\u0000\u0000\u00d7\u0c4b\u0001"+ + "\u0000\u0000\u0000\u00d9\u0c57\u0001\u0000\u0000\u0000\u00db\u0c75\u0001"+ + "\u0000\u0000\u0000\u00dd\u0c7b\u0001\u0000\u0000\u0000\u00df\u0c84\u0001"+ + "\u0000\u0000\u0000\u00e1\u0c8d\u0001\u0000\u0000\u0000\u00e3\u0c96\u0001"+ + "\u0000\u0000\u0000\u00e5\u0c9e\u0001\u0000\u0000\u0000\u00e7\u0ca2\u0001"+ + "\u0000\u0000\u0000\u00e9\u0cb5\u0001\u0000\u0000\u0000\u00eb\u0cba\u0001"+ + "\u0000\u0000\u0000\u00ed\u0cc1\u0001\u0000\u0000\u0000\u00ef\u0cc4\u0001"+ + "\u0000\u0000\u0000\u00f1\u0ccd\u0001\u0000\u0000\u0000\u00f3\u0cd4\u0001"+ + "\u0000\u0000\u0000\u00f5\u0cdd\u0001\u0000\u0000\u0000\u00f7\u0ce8\u0001"+ + "\u0000\u0000\u0000\u00f9\u0ceb\u0001\u0000\u0000\u0000\u00fb\u0cf1\u0001"+ + "\u0000\u0000\u0000\u00fd\u0cf5\u0001\u0000\u0000\u0000\u00ff\u0cfb\u0001"+ + "\u0000\u0000\u0000\u0101\u0d03\u0001\u0000\u0000\u0000\u0103\u0d08\u0001"+ + "\u0000\u0000\u0000\u0105\u0d12\u0001\u0000\u0000\u0000\u0107\u0d1a\u0001"+ + "\u0000\u0000\u0000\u0109\u0d24\u0001\u0000\u0000\u0000\u010b\u0d2a\u0001"+ + "\u0000\u0000\u0000\u010d\u0d30\u0001\u0000\u0000\u0000\u010f\u0d35\u0001"+ + "\u0000\u0000\u0000\u0111\u0d3b\u0001\u0000\u0000\u0000\u0113\u0d46\u0001"+ + "\u0000\u0000\u0000\u0115\u0d4d\u0001\u0000\u0000\u0000\u0117\u0d55\u0001"+ + "\u0000\u0000\u0000\u0119\u0d5c\u0001\u0000\u0000\u0000\u011b\u0d63\u0001"+ + "\u0000\u0000\u0000\u011d\u0d6b\u0001\u0000\u0000\u0000\u011f\u0d73\u0001"+ + "\u0000\u0000\u0000\u0121\u0d7c\u0001\u0000\u0000\u0000\u0123\u0d85\u0001"+ + "\u0000\u0000\u0000\u0125\u0d8c\u0001\u0000\u0000\u0000\u0127\u0d93\u0001"+ + "\u0000\u0000\u0000\u0129\u0d9a\u0001\u0000\u0000\u0000\u012b\u0da0\u0001"+ + "\u0000\u0000\u0000\u012d\u0da6\u0001\u0000\u0000\u0000\u012f\u0dad\u0001"+ + "\u0000\u0000\u0000\u0131\u0db5\u0001\u0000\u0000\u0000\u0133\u0dbc\u0001"+ + "\u0000\u0000\u0000\u0135\u0dc0\u0001\u0000\u0000\u0000\u0137\u0dca\u0001"+ + "\u0000\u0000\u0000\u0139\u0dcf\u0001\u0000\u0000\u0000\u013b\u0dd6\u0001"+ + "\u0000\u0000\u0000\u013d\u0ddb\u0001\u0000\u0000\u0000\u013f\u0dee\u0001"+ + "\u0000\u0000\u0000\u0141\u0df6\u0001\u0000\u0000\u0000\u0143\u0dfa\u0001"+ + "\u0000\u0000\u0000\u0145\u0e07\u0001\u0000\u0000\u0000\u0147\u0e10\u0001"+ + "\u0000\u0000\u0000\u0149\u0e1b\u0001\u0000\u0000\u0000\u014b\u0e2a\u0001"+ + "\u0000\u0000\u0000\u014d\u0e3e\u0001\u0000\u0000\u0000\u014f\u0e4f\u0001"+ + "\u0000\u0000\u0000\u0151\u0e53\u0001\u0000\u0000\u0000\u0153\u0e5b\u0001"+ + "\u0000\u0000\u0000\u0155\u0e64\u0001\u0000\u0000\u0000\u0157\u0e6e\u0001"+ + "\u0000\u0000\u0000\u0159\u0e7c\u0001\u0000\u0000\u0000\u015b\u0e82\u0001"+ + "\u0000\u0000\u0000\u015d\u0e8d\u0001\u0000\u0000\u0000\u015f\u0e92\u0001"+ + "\u0000\u0000\u0000\u0161\u0e95\u0001\u0000\u0000\u0000\u0163\u0e9e\u0001"+ + "\u0000\u0000\u0000\u0165\u0ea6\u0001\u0000\u0000\u0000\u0167\u0eab\u0001"+ + "\u0000\u0000\u0000\u0169\u0eb0\u0001\u0000\u0000\u0000\u016b\u0eb6\u0001"+ + "\u0000\u0000\u0000\u016d\u0ebd\u0001\u0000\u0000\u0000\u016f\u0ec4\u0001"+ + "\u0000\u0000\u0000\u0171\u0ecd\u0001\u0000\u0000\u0000\u0173\u0ed4\u0001"+ + "\u0000\u0000\u0000\u0175\u0eda\u0001\u0000\u0000\u0000\u0177\u0ede\u0001"+ + "\u0000\u0000\u0000\u0179\u0ee4\u0001\u0000\u0000\u0000\u017b\u0eeb\u0001"+ + "\u0000\u0000\u0000\u017d\u0ef0\u0001\u0000\u0000\u0000\u017f\u0ef6\u0001"+ + "\u0000\u0000\u0000\u0181\u0efc\u0001\u0000\u0000\u0000\u0183\u0f01\u0001"+ + "\u0000\u0000\u0000\u0185\u0f07\u0001\u0000\u0000\u0000\u0187\u0f0b\u0001"+ + "\u0000\u0000\u0000\u0189\u0f14\u0001\u0000\u0000\u0000\u018b\u0f1c\u0001"+ + "\u0000\u0000\u0000\u018d\u0f25\u0001\u0000\u0000\u0000\u018f\u0f2f\u0001"+ + "\u0000\u0000\u0000\u0191\u0f39\u0001\u0000\u0000\u0000\u0193\u0f3d\u0001"+ + "\u0000\u0000\u0000\u0195\u0f42\u0001\u0000\u0000\u0000\u0197\u0f47\u0001"+ + "\u0000\u0000\u0000\u0199\u0f4c\u0001\u0000\u0000\u0000\u019b\u0f51\u0001"+ + "\u0000\u0000\u0000\u019d\u0f56\u0001\u0000\u0000\u0000\u019f\u0f5e\u0001"+ + "\u0000\u0000\u0000\u01a1\u0f65\u0001\u0000\u0000\u0000\u01a3\u0f6a\u0001"+ + "\u0000\u0000\u0000\u01a5\u0f71\u0001\u0000\u0000\u0000\u01a7\u0f7b\u0001"+ + "\u0000\u0000\u0000\u01a9\u0f81\u0001\u0000\u0000\u0000\u01ab\u0f88\u0001"+ + "\u0000\u0000\u0000\u01ad\u0f8f\u0001\u0000\u0000\u0000\u01af\u0f97\u0001"+ + "\u0000\u0000\u0000\u01b1\u0f9b\u0001\u0000\u0000\u0000\u01b3\u0fa3\u0001"+ + "\u0000\u0000\u0000\u01b5\u0fa8\u0001\u0000\u0000\u0000\u01b7\u0fad\u0001"+ + "\u0000\u0000\u0000\u01b9\u0fb7\u0001\u0000\u0000\u0000\u01bb\u0fc0\u0001"+ + "\u0000\u0000\u0000\u01bd\u0fc5\u0001\u0000\u0000\u0000\u01bf\u0fca\u0001"+ + "\u0000\u0000\u0000\u01c1\u0fd2\u0001\u0000\u0000\u0000\u01c3\u0fdb\u0001"+ + "\u0000\u0000\u0000\u01c5\u0fe4\u0001\u0000\u0000\u0000\u01c7\u0feb\u0001"+ + "\u0000\u0000\u0000\u01c9\u0ff5\u0001\u0000\u0000\u0000\u01cb\u0ffe\u0001"+ + "\u0000\u0000\u0000\u01cd\u1003\u0001\u0000\u0000\u0000\u01cf\u100e\u0001"+ + "\u0000\u0000\u0000\u01d1\u1013\u0001\u0000\u0000\u0000\u01d3\u101c\u0001"+ + "\u0000\u0000\u0000\u01d5\u1025\u0001\u0000\u0000\u0000\u01d7\u102a\u0001"+ + "\u0000\u0000\u0000\u01d9\u1035\u0001\u0000\u0000\u0000\u01db\u103e\u0001"+ + "\u0000\u0000\u0000\u01dd\u1043\u0001\u0000\u0000\u0000\u01df\u104b\u0001"+ + "\u0000\u0000\u0000\u01e1\u1052\u0001\u0000\u0000\u0000\u01e3\u105d\u0001"+ + "\u0000\u0000\u0000\u01e5\u1066\u0001\u0000\u0000\u0000\u01e7\u1071\u0001"+ + "\u0000\u0000\u0000\u01e9\u107c\u0001\u0000\u0000\u0000\u01eb\u1088\u0001"+ + "\u0000\u0000\u0000\u01ed\u1094\u0001\u0000\u0000\u0000\u01ef\u10a2\u0001"+ + "\u0000\u0000\u0000\u01f1\u10b5\u0001\u0000\u0000\u0000\u01f3\u10c8\u0001"+ + "\u0000\u0000\u0000\u01f5\u10d9\u0001\u0000\u0000\u0000\u01f7\u10e9\u0001"+ + "\u0000\u0000\u0000\u01f9\u10f4\u0001\u0000\u0000\u0000\u01fb\u1102\u0001"+ + "\u0000\u0000\u0000\u01fd\u1114\u0001\u0000\u0000\u0000\u01ff\u1126\u0001"+ + "\u0000\u0000\u0000\u0201\u1134\u0001\u0000\u0000\u0000\u0203\u1147\u0001"+ + "\u0000\u0000\u0000\u0205\u1152\u0001\u0000\u0000\u0000\u0207\u115f\u0001"+ + "\u0000\u0000\u0000\u0209\u116b\u0001\u0000\u0000\u0000\u020b\u1175\u0001"+ + "\u0000\u0000\u0000\u020d\u1181\u0001\u0000\u0000\u0000\u020f\u118c\u0001"+ + "\u0000\u0000\u0000\u0211\u119d\u0001\u0000\u0000\u0000\u0213\u11b1\u0001"+ + "\u0000\u0000\u0000\u0215\u11bd\u0001\u0000\u0000\u0000\u0217\u11cc\u0001"+ + "\u0000\u0000\u0000\u0219\u11da\u0001\u0000\u0000\u0000\u021b\u11e6\u0001"+ + "\u0000\u0000\u0000\u021d\u11f1\u0001\u0000\u0000\u0000\u021f\u11fd\u0001"+ + "\u0000\u0000\u0000\u0221\u120a\u0001\u0000\u0000\u0000\u0223\u121c\u0001"+ + "\u0000\u0000\u0000\u0225\u123a\u0001\u0000\u0000\u0000\u0227\u1246\u0001"+ + "\u0000\u0000\u0000\u0229\u124f\u0001\u0000\u0000\u0000\u022b\u1261\u0001"+ + "\u0000\u0000\u0000\u022d\u1273\u0001\u0000\u0000\u0000\u022f\u127e\u0001"+ + "\u0000\u0000\u0000\u0231\u1288\u0001\u0000\u0000\u0000\u0233\u1295\u0001"+ + "\u0000\u0000\u0000\u0235\u12a0\u0001\u0000\u0000\u0000\u0237\u12ab\u0001"+ + "\u0000\u0000\u0000\u0239\u12b2\u0001\u0000\u0000\u0000\u023b\u12bd\u0001"+ + "\u0000\u0000\u0000\u023d\u12c2\u0001\u0000\u0000\u0000\u023f\u12c6\u0001"+ + "\u0000\u0000\u0000\u0241\u12ce\u0001\u0000\u0000\u0000\u0243\u12d5\u0001"+ + "\u0000\u0000\u0000\u0245\u12dd\u0001\u0000\u0000\u0000\u0247\u12e3\u0001"+ + "\u0000\u0000\u0000\u0249\u12ed\u0001\u0000\u0000\u0000\u024b\u12f8\u0001"+ + "\u0000\u0000\u0000\u024d\u1304\u0001\u0000\u0000\u0000\u024f\u1311\u0001"+ + "\u0000\u0000\u0000\u0251\u1315\u0001\u0000\u0000\u0000\u0253\u1320\u0001"+ + "\u0000\u0000\u0000\u0255\u1325\u0001\u0000\u0000\u0000\u0257\u1329\u0001"+ + "\u0000\u0000\u0000\u0259\u132d\u0001\u0000\u0000\u0000\u025b\u1333\u0001"+ + "\u0000\u0000\u0000\u025d\u133d\u0001\u0000\u0000\u0000\u025f\u134a\u0001"+ + "\u0000\u0000\u0000\u0261\u134f\u0001\u0000\u0000\u0000\u0263\u135a\u0001"+ + "\u0000\u0000\u0000\u0265\u135e\u0001\u0000\u0000\u0000\u0267\u1365\u0001"+ + "\u0000\u0000\u0000\u0269\u1370\u0001\u0000\u0000\u0000\u026b\u137c\u0001"+ + "\u0000\u0000\u0000\u026d\u1380\u0001\u0000\u0000\u0000\u026f\u1388\u0001"+ + "\u0000\u0000\u0000\u0271\u1391\u0001\u0000\u0000\u0000\u0273\u139a\u0001"+ + "\u0000\u0000\u0000\u0275\u13a7\u0001\u0000\u0000\u0000\u0277\u13b4\u0001"+ + "\u0000\u0000\u0000\u0279\u13c6\u0001\u0000\u0000\u0000\u027b\u13d0\u0001"+ + "\u0000\u0000\u0000\u027d\u13d8\u0001\u0000\u0000\u0000\u027f\u13e0\u0001"+ + "\u0000\u0000\u0000\u0281\u13e9\u0001\u0000\u0000\u0000\u0283\u13f2\u0001"+ + "\u0000\u0000\u0000\u0285\u13fa\u0001\u0000\u0000\u0000\u0287\u1409\u0001"+ + "\u0000\u0000\u0000\u0289\u140d\u0001\u0000\u0000\u0000\u028b\u1416\u0001"+ + "\u0000\u0000\u0000\u028d\u141d\u0001\u0000\u0000\u0000\u028f\u1427\u0001"+ + "\u0000\u0000\u0000\u0291\u142f\u0001\u0000\u0000\u0000\u0293\u1434\u0001"+ + "\u0000\u0000\u0000\u0295\u143d\u0001\u0000\u0000\u0000\u0297\u1446\u0001"+ + "\u0000\u0000\u0000\u0299\u1454\u0001\u0000\u0000\u0000\u029b\u145c\u0001"+ + "\u0000\u0000\u0000\u029d\u1463\u0001\u0000\u0000\u0000\u029f\u1469\u0001"+ + "\u0000\u0000\u0000\u02a1\u1473\u0001\u0000\u0000\u0000\u02a3\u147d\u0001"+ + "\u0000\u0000\u0000\u02a5\u1481\u0001\u0000\u0000\u0000\u02a7\u1484\u0001"+ + "\u0000\u0000\u0000\u02a9\u148c\u0001\u0000\u0000\u0000\u02ab\u1497\u0001"+ + "\u0000\u0000\u0000\u02ad\u14a7\u0001\u0000\u0000\u0000\u02af\u14b6\u0001"+ + "\u0000\u0000\u0000\u02b1\u14c5\u0001\u0000\u0000\u0000\u02b3\u14cb\u0001"+ + "\u0000\u0000\u0000\u02b5\u14d2\u0001\u0000\u0000\u0000\u02b7\u14d6\u0001"+ + "\u0000\u0000\u0000\u02b9\u14dc\u0001\u0000\u0000\u0000\u02bb\u14e1\u0001"+ + "\u0000\u0000\u0000\u02bd\u14e9\u0001\u0000\u0000\u0000\u02bf\u14ef\u0001"+ + "\u0000\u0000\u0000\u02c1\u14f5\u0001\u0000\u0000\u0000\u02c3\u14fe\u0001"+ + "\u0000\u0000\u0000\u02c5\u1504\u0001\u0000\u0000\u0000\u02c7\u150c\u0001"+ + "\u0000\u0000\u0000\u02c9\u1514\u0001\u0000\u0000\u0000\u02cb\u151d\u0001"+ + "\u0000\u0000\u0000\u02cd\u152b\u0001\u0000\u0000\u0000\u02cf\u1532\u0001"+ + "\u0000\u0000\u0000\u02d1\u153f\u0001\u0000\u0000\u0000\u02d3\u1546\u0001"+ + "\u0000\u0000\u0000\u02d5\u154c\u0001\u0000\u0000\u0000\u02d7\u1557\u0001"+ + "\u0000\u0000\u0000\u02d9\u1560\u0001\u0000\u0000\u0000\u02db\u1565\u0001"+ + "\u0000\u0000\u0000\u02dd\u156d\u0001\u0000\u0000\u0000\u02df\u157b\u0001"+ + "\u0000\u0000\u0000\u02e1\u1587\u0001\u0000\u0000\u0000\u02e3\u158f\u0001"+ + "\u0000\u0000\u0000\u02e5\u1596\u0001\u0000\u0000\u0000\u02e7\u159e\u0001"+ + "\u0000\u0000\u0000\u02e9\u15a9\u0001\u0000\u0000\u0000\u02eb\u15b4\u0001"+ + "\u0000\u0000\u0000\u02ed\u15c0\u0001\u0000\u0000\u0000\u02ef\u15cb\u0001"+ + "\u0000\u0000\u0000\u02f1\u15d3\u0001\u0000\u0000\u0000\u02f3\u15de\u0001"+ + "\u0000\u0000\u0000\u02f5\u15e9\u0001\u0000\u0000\u0000\u02f7\u15fc\u0001"+ + "\u0000\u0000\u0000\u02f9\u160e\u0001\u0000\u0000\u0000\u02fb\u161e\u0001"+ + "\u0000\u0000\u0000\u02fd\u1627\u0001\u0000\u0000\u0000\u02ff\u162f\u0001"+ + "\u0000\u0000\u0000\u0301\u163c\u0001\u0000\u0000\u0000\u0303\u1641\u0001"+ + "\u0000\u0000\u0000\u0305\u1645\u0001\u0000\u0000\u0000\u0307\u164b\u0001"+ + "\u0000\u0000\u0000\u0309\u1657\u0001\u0000\u0000\u0000\u030b\u165c\u0001"+ + "\u0000\u0000\u0000\u030d\u1665\u0001\u0000\u0000\u0000\u030f\u1670\u0001"+ + "\u0000\u0000\u0000\u0311\u167d\u0001\u0000\u0000\u0000\u0313\u1685\u0001"+ + "\u0000\u0000\u0000\u0315\u1695\u0001\u0000\u0000\u0000\u0317\u16a2\u0001"+ + "\u0000\u0000\u0000\u0319\u16ac\u0001\u0000\u0000\u0000\u031b\u16b4\u0001"+ + "\u0000\u0000\u0000\u031d\u16bc\u0001\u0000\u0000\u0000\u031f\u16c1\u0001"+ + "\u0000\u0000\u0000\u0321\u16c4\u0001\u0000\u0000\u0000\u0323\u16cd\u0001"+ + "\u0000\u0000\u0000\u0325\u16d7\u0001\u0000\u0000\u0000\u0327\u16df\u0001"+ + "\u0000\u0000\u0000\u0329\u16e6\u0001\u0000\u0000\u0000\u032b\u16f0\u0001"+ + "\u0000\u0000\u0000\u032d\u16fb\u0001\u0000\u0000\u0000\u032f\u170d\u0001"+ + "\u0000\u0000\u0000\u0331\u1711\u0001\u0000\u0000\u0000\u0333\u1716\u0001"+ + "\u0000\u0000\u0000\u0335\u171d\u0001\u0000\u0000\u0000\u0337\u1725\u0001"+ + "\u0000\u0000\u0000\u0339\u172b\u0001\u0000\u0000\u0000\u033b\u1732\u0001"+ + "\u0000\u0000\u0000\u033d\u1739\u0001\u0000\u0000\u0000\u033f\u173e\u0001"+ + "\u0000\u0000\u0000\u0341\u1744\u0001\u0000\u0000\u0000\u0343\u174b\u0001"+ + "\u0000\u0000\u0000\u0345\u1751\u0001\u0000\u0000\u0000\u0347\u175a\u0001"+ + "\u0000\u0000\u0000\u0349\u1764\u0001\u0000\u0000\u0000\u034b\u176b\u0001"+ + "\u0000\u0000\u0000\u034d\u1772\u0001\u0000\u0000\u0000\u034f\u177b\u0001"+ + "\u0000\u0000\u0000\u0351\u1787\u0001\u0000\u0000\u0000\u0353\u179d\u0001"+ + "\u0000\u0000\u0000\u0355\u17a2\u0001\u0000\u0000\u0000\u0357\u17a9\u0001"+ + "\u0000\u0000\u0000\u0359\u17b0\u0001\u0000\u0000\u0000\u035b\u17c0\u0001"+ + "\u0000\u0000\u0000\u035d\u17c7\u0001\u0000\u0000\u0000\u035f\u17cd\u0001"+ + "\u0000\u0000\u0000\u0361\u17d3\u0001\u0000\u0000\u0000\u0363\u17d9\u0001"+ + "\u0000\u0000\u0000\u0365\u17e3\u0001\u0000\u0000\u0000\u0367\u17eb\u0001"+ + "\u0000\u0000\u0000\u0369\u17f1\u0001\u0000\u0000\u0000\u036b\u17f6\u0001"+ + "\u0000\u0000\u0000\u036d\u17ff\u0001\u0000\u0000\u0000\u036f\u1807\u0001"+ + "\u0000\u0000\u0000\u0371\u180e\u0001\u0000\u0000\u0000\u0373\u1815\u0001"+ + "\u0000\u0000\u0000\u0375\u1827\u0001\u0000\u0000\u0000\u0377\u182f\u0001"+ + "\u0000\u0000\u0000\u0379\u1834\u0001\u0000\u0000\u0000\u037b\u1839\u0001"+ + "\u0000\u0000\u0000\u037d\u1841\u0001\u0000\u0000\u0000\u037f\u1846\u0001"+ + "\u0000\u0000\u0000\u0381\u184c\u0001\u0000\u0000\u0000\u0383\u1857\u0001"+ + "\u0000\u0000\u0000\u0385\u1869\u0001\u0000\u0000\u0000\u0387\u1870\u0001"+ + "\u0000\u0000\u0000\u0389\u187a\u0001\u0000\u0000\u0000\u038b\u1882\u0001"+ + "\u0000\u0000\u0000\u038d\u188f\u0001\u0000\u0000\u0000\u038f\u1897\u0001"+ + "\u0000\u0000\u0000\u0391\u18a5\u0001\u0000\u0000\u0000\u0393\u18ad\u0001"+ + "\u0000\u0000\u0000\u0395\u18b6\u0001\u0000\u0000\u0000\u0397\u18be\u0001"+ + "\u0000\u0000\u0000\u0399\u18c8\u0001\u0000\u0000\u0000\u039b\u18d0\u0001"+ + "\u0000\u0000\u0000\u039d\u18d3\u0001\u0000\u0000\u0000\u039f\u18dd\u0001"+ + "\u0000\u0000\u0000\u03a1\u18e1\u0001\u0000\u0000\u0000\u03a3\u18eb\u0001"+ + "\u0000\u0000\u0000\u03a5\u18f2\u0001\u0000\u0000\u0000\u03a7\u18f7\u0001"+ + "\u0000\u0000\u0000\u03a9\u1906\u0001\u0000\u0000\u0000\u03ab\u190f\u0001"+ + "\u0000\u0000\u0000\u03ad\u1914\u0001\u0000\u0000\u0000\u03af\u191b\u0001"+ + "\u0000\u0000\u0000\u03b1\u1920\u0001\u0000\u0000\u0000\u03b3\u1926\u0001"+ + "\u0000\u0000\u0000\u03b5\u192b\u0001\u0000\u0000\u0000\u03b7\u1931\u0001"+ + "\u0000\u0000\u0000\u03b9\u1939\u0001\u0000\u0000\u0000\u03bb\u193e\u0001"+ + "\u0000\u0000\u0000\u03bd\u1945\u0001\u0000\u0000\u0000\u03bf\u195a\u0001"+ + "\u0000\u0000\u0000\u03c1\u196f\u0001\u0000\u0000\u0000\u03c3\u197c\u0001"+ + "\u0000\u0000\u0000\u03c5\u1994\u0001\u0000\u0000\u0000\u03c7\u19a0\u0001"+ + "\u0000\u0000\u0000\u03c9\u19b0\u0001\u0000\u0000\u0000\u03cb\u19bf\u0001"+ + "\u0000\u0000\u0000\u03cd\u19cf\u0001\u0000\u0000\u0000\u03cf\u19db\u0001"+ + "\u0000\u0000\u0000\u03d1\u19ee\u0001\u0000\u0000\u0000\u03d3\u19f9\u0001"+ + "\u0000\u0000\u0000\u03d5\u1a07\u0001\u0000\u0000\u0000\u03d7\u1a19\u0001"+ + "\u0000\u0000\u0000\u03d9\u1a29\u0001\u0000\u0000\u0000\u03db\u1a3b\u0001"+ + "\u0000\u0000\u0000\u03dd\u1a4a\u0001\u0000\u0000\u0000\u03df\u1a5d\u0001"+ + "\u0000\u0000\u0000\u03e1\u1a6c\u0001\u0000\u0000\u0000\u03e3\u1a7f\u0001"+ + "\u0000\u0000\u0000\u03e5\u1a8b\u0001\u0000\u0000\u0000\u03e7\u1aa4\u0001"+ + "\u0000\u0000\u0000\u03e9\u1ab9\u0001\u0000\u0000\u0000\u03eb\u1ac2\u0001"+ + "\u0000\u0000\u0000\u03ed\u1acb\u0001\u0000\u0000\u0000\u03ef\u1ae0\u0001"+ + "\u0000\u0000\u0000\u03f1\u1af5\u0001\u0000\u0000\u0000\u03f3\u1afc\u0001"+ + "\u0000\u0000\u0000\u03f5\u1b03\u0001\u0000\u0000\u0000\u03f7\u1b09\u0001"+ + "\u0000\u0000\u0000\u03f9\u1b16\u0001\u0000\u0000\u0000\u03fb\u1b1a\u0001"+ + "\u0000\u0000\u0000\u03fd\u1b22\u0001\u0000\u0000\u0000\u03ff\u1b2b\u0001"+ + "\u0000\u0000\u0000\u0401\u1b30\u0001\u0000\u0000\u0000\u0403\u1b37\u0001"+ + "\u0000\u0000\u0000\u0405\u1b3d\u0001\u0000\u0000\u0000\u0407\u1b43\u0001"+ + "\u0000\u0000\u0000\u0409\u1b4f\u0001\u0000\u0000\u0000\u040b\u1b54\u0001"+ + "\u0000\u0000\u0000\u040d\u1b5a\u0001\u0000\u0000\u0000\u040f\u1b60\u0001"+ + "\u0000\u0000\u0000\u0411\u1b66\u0001\u0000\u0000\u0000\u0413\u1b6b\u0001"+ + "\u0000\u0000\u0000\u0415\u1b6e\u0001\u0000\u0000\u0000\u0417\u1b76\u0001"+ + "\u0000\u0000\u0000\u0419\u1b7d\u0001\u0000\u0000\u0000\u041b\u1b85\u0001"+ + "\u0000\u0000\u0000\u041d\u1b90\u0001\u0000\u0000\u0000\u041f\u1b9b\u0001"+ + "\u0000\u0000\u0000\u0421\u1ba2\u0001\u0000\u0000\u0000\u0423\u1bac\u0001"+ + "\u0000\u0000\u0000\u0425\u1bb1\u0001\u0000\u0000\u0000\u0427\u1bb6\u0001"+ + "\u0000\u0000\u0000\u0429\u1bbe\u0001\u0000\u0000\u0000\u042b\u1bc5\u0001"+ + "\u0000\u0000\u0000\u042d\u1bc8\u0001\u0000\u0000\u0000\u042f\u1bcb\u0001"+ + "\u0000\u0000\u0000\u0431\u1bd8\u0001\u0000\u0000\u0000\u0433\u1bdc\u0001"+ + "\u0000\u0000\u0000\u0435\u1be3\u0001\u0000\u0000\u0000\u0437\u1be8\u0001"+ + "\u0000\u0000\u0000\u0439\u1bed\u0001\u0000\u0000\u0000\u043b\u1bfd\u0001"+ + "\u0000\u0000\u0000\u043d\u1c05\u0001\u0000\u0000\u0000\u043f\u1c0b\u0001"+ + "\u0000\u0000\u0000\u0441\u1c15\u0001\u0000\u0000\u0000\u0443\u1c1a\u0001"+ + "\u0000\u0000\u0000\u0445\u1c2a\u0001\u0000\u0000\u0000\u0447\u1c41\u0001"+ + "\u0000\u0000\u0000\u0449\u1c48\u0001\u0000\u0000\u0000\u044b\u1c50\u0001"+ + "\u0000\u0000\u0000\u044d\u1c5d\u0001\u0000\u0000\u0000\u044f\u1c68\u0001"+ + "\u0000\u0000\u0000\u0451\u1c71\u0001\u0000\u0000\u0000\u0453\u1c84\u0001"+ + "\u0000\u0000\u0000\u0455\u1c8a\u0001\u0000\u0000\u0000\u0457\u1c91\u0001"+ + "\u0000\u0000\u0000\u0459\u1c9c\u0001\u0000\u0000\u0000\u045b\u1ca4\u0001"+ + "\u0000\u0000\u0000\u045d\u1ca9\u0001\u0000\u0000\u0000\u045f\u1cb2\u0001"+ + "\u0000\u0000\u0000\u0461\u1cbc\u0001\u0000\u0000\u0000\u0463\u1cc4\u0001"+ + "\u0000\u0000\u0000\u0465\u1ccd\u0001\u0000\u0000\u0000\u0467\u1cd2\u0001"+ + "\u0000\u0000\u0000\u0469\u1cde\u0001\u0000\u0000\u0000\u046b\u1ce6\u0001"+ + "\u0000\u0000\u0000\u046d\u1cef\u0001\u0000\u0000\u0000\u046f\u1cf5\u0001"+ + "\u0000\u0000\u0000\u0471\u1cfb\u0001\u0000\u0000\u0000\u0473\u1d01\u0001"+ + "\u0000\u0000\u0000\u0475\u1d09\u0001\u0000\u0000\u0000\u0477\u1d11\u0001"+ + "\u0000\u0000\u0000\u0479\u1d1b\u0001\u0000\u0000\u0000\u047b\u1d2c\u0001"+ + "\u0000\u0000\u0000\u047d\u1d36\u0001\u0000\u0000\u0000\u047f\u1d3c\u0001"+ + "\u0000\u0000\u0000\u0481\u1d4b\u0001\u0000\u0000\u0000\u0483\u1d59\u0001"+ + "\u0000\u0000\u0000\u0485\u1d62\u0001\u0000\u0000\u0000\u0487\u1d69\u0001"+ + "\u0000\u0000\u0000\u0489\u1d74\u0001\u0000\u0000\u0000\u048b\u1d7b\u0001"+ + "\u0000\u0000\u0000\u048d\u1d8b\u0001\u0000\u0000\u0000\u048f\u1d9e\u0001"+ + "\u0000\u0000\u0000\u0491\u1db2\u0001\u0000\u0000\u0000\u0493\u1dc9\u0001"+ + "\u0000\u0000\u0000\u0495\u1dde\u0001\u0000\u0000\u0000\u0497\u1df6\u0001"+ + "\u0000\u0000\u0000\u0499\u1e12\u0001\u0000\u0000\u0000\u049b\u1e1e\u0001"+ + "\u0000\u0000\u0000\u049d\u1e24\u0001\u0000\u0000\u0000\u049f\u1e2c\u0001"+ + "\u0000\u0000\u0000\u04a1\u1e33\u0001\u0000\u0000\u0000\u04a3\u1e45\u0001"+ + "\u0000\u0000\u0000\u04a5\u1e4f\u0001\u0000\u0000\u0000\u04a7\u1e57\u0001"+ + "\u0000\u0000\u0000\u04a9\u1e5d\u0001\u0000\u0000\u0000\u04ab\u1e62\u0001"+ + "\u0000\u0000\u0000\u04ad\u1e6b\u0001\u0000\u0000\u0000\u04af\u1e72\u0001"+ + "\u0000\u0000\u0000\u04b1\u1e79\u0001\u0000\u0000\u0000\u04b3\u1e7d\u0001"+ + "\u0000\u0000\u0000\u04b5\u1e82\u0001\u0000\u0000\u0000\u04b7\u1e8d\u0001"+ + "\u0000\u0000\u0000\u04b9\u1e93\u0001\u0000\u0000\u0000\u04bb\u1e9d\u0001"+ + "\u0000\u0000\u0000\u04bd\u1ea6\u0001\u0000\u0000\u0000\u04bf\u1eaf\u0001"+ + "\u0000\u0000\u0000\u04c1\u1eb8\u0001\u0000\u0000\u0000\u04c3\u1ebf\u0001"+ + "\u0000\u0000\u0000\u04c5\u1ec7\u0001\u0000\u0000\u0000\u04c7\u1ecd\u0001"+ + "\u0000\u0000\u0000\u04c9\u1ed4\u0001\u0000\u0000\u0000\u04cb\u1edb\u0001"+ + "\u0000\u0000\u0000\u04cd\u1ee2\u0001\u0000\u0000\u0000\u04cf\u1ee8\u0001"+ + "\u0000\u0000\u0000\u04d1\u1eed\u0001\u0000\u0000\u0000\u04d3\u1ef6\u0001"+ + "\u0000\u0000\u0000\u04d5\u1efd\u0001\u0000\u0000\u0000\u04d7\u1f02\u0001"+ + "\u0000\u0000\u0000\u04d9\u1f09\u0001\u0000\u0000\u0000\u04db\u1f10\u0001"+ + "\u0000\u0000\u0000\u04dd\u1f17\u0001\u0000\u0000\u0000\u04df\u1f27\u0001"+ + "\u0000\u0000\u0000\u04e1\u1f3a\u0001\u0000\u0000\u0000\u04e3\u1f4b\u0001"+ + "\u0000\u0000\u0000\u04e5\u1f5d\u0001\u0000\u0000\u0000\u04e7\u1f67\u0001"+ + "\u0000\u0000\u0000\u04e9\u1f74\u0001\u0000\u0000\u0000\u04eb\u1f7f\u0001"+ + "\u0000\u0000\u0000\u04ed\u1f85\u0001\u0000\u0000\u0000\u04ef\u1f8c\u0001"+ + "\u0000\u0000\u0000\u04f1\u1f9e\u0001\u0000\u0000\u0000\u04f3\u1faf\u0001"+ + "\u0000\u0000\u0000\u04f5\u1fc2\u0001\u0000\u0000\u0000\u04f7\u1fc9\u0001"+ + "\u0000\u0000\u0000\u04f9\u1fce\u0001\u0000\u0000\u0000\u04fb\u1fd6\u0001"+ + "\u0000\u0000\u0000\u04fd\u1fdd\u0001\u0000\u0000\u0000\u04ff\u1fe4\u0001"+ + "\u0000\u0000\u0000\u0501\u1ff4\u0001\u0000\u0000\u0000\u0503\u1ffc\u0001"+ + "\u0000\u0000\u0000\u0505\u2009\u0001\u0000\u0000\u0000\u0507\u2017\u0001"+ + "\u0000\u0000\u0000\u0509\u201f\u0001\u0000\u0000\u0000\u050b\u2025\u0001"+ + "\u0000\u0000\u0000\u050d\u202e\u0001\u0000\u0000\u0000\u050f\u2039\u0001"+ + "\u0000\u0000\u0000\u0511\u2044\u0001\u0000\u0000\u0000\u0513\u204f\u0001"+ + "\u0000\u0000\u0000\u0515\u2059\u0001\u0000\u0000\u0000\u0517\u2063\u0001"+ + "\u0000\u0000\u0000\u0519\u2068\u0001\u0000\u0000\u0000\u051b\u2074\u0001"+ + "\u0000\u0000\u0000\u051d\u2080\u0001\u0000\u0000\u0000\u051f\u208e\u0001"+ + "\u0000\u0000\u0000\u0521\u2097\u0001\u0000\u0000\u0000\u0523\u20a0\u0001"+ + "\u0000\u0000\u0000\u0525\u20aa\u0001\u0000\u0000\u0000\u0527\u20b4\u0001"+ + "\u0000\u0000\u0000\u0529\u20bd\u0001\u0000\u0000\u0000\u052b\u20ce\u0001"+ + "\u0000\u0000\u0000\u052d\u20d8\u0001\u0000\u0000\u0000\u052f\u20e0\u0001"+ + "\u0000\u0000\u0000\u0531\u20e6\u0001\u0000\u0000\u0000\u0533\u20ee\u0001"+ + "\u0000\u0000\u0000\u0535\u20f3\u0001\u0000\u0000\u0000\u0537\u20fb\u0001"+ + "\u0000\u0000\u0000\u0539\u210a\u0001\u0000\u0000\u0000\u053b\u2115\u0001"+ + "\u0000\u0000\u0000\u053d\u211b\u0001\u0000\u0000\u0000\u053f\u2125\u0001"+ + "\u0000\u0000\u0000\u0541\u212a\u0001\u0000\u0000\u0000\u0543\u2132\u0001"+ + "\u0000\u0000\u0000\u0545\u213a\u0001\u0000\u0000\u0000\u0547\u213f\u0001"+ + "\u0000\u0000\u0000\u0549\u2148\u0001\u0000\u0000\u0000\u054b\u214f\u0001"+ + "\u0000\u0000\u0000\u054d\u2157\u0001\u0000\u0000\u0000\u054f\u215c\u0001"+ + "\u0000\u0000\u0000\u0551\u2164\u0001\u0000\u0000\u0000\u0553\u2169\u0001"+ + "\u0000\u0000\u0000\u0555\u216c\u0001\u0000\u0000\u0000\u0557\u2170\u0001"+ + "\u0000\u0000\u0000\u0559\u2174\u0001\u0000\u0000\u0000\u055b\u2178\u0001"+ + "\u0000\u0000\u0000\u055d\u217c\u0001\u0000\u0000\u0000\u055f\u2180\u0001"+ + "\u0000\u0000\u0000\u0561\u2184\u0001\u0000\u0000\u0000\u0563\u218d\u0001"+ + "\u0000\u0000\u0000\u0565\u2195\u0001\u0000\u0000\u0000\u0567\u219b\u0001"+ + "\u0000\u0000\u0000\u0569\u219f\u0001\u0000\u0000\u0000\u056b\u21a4\u0001"+ + "\u0000\u0000\u0000\u056d\u21ab\u0001\u0000\u0000\u0000\u056f\u21b0\u0001"+ + "\u0000\u0000\u0000\u0571\u21b7\u0001\u0000\u0000\u0000\u0573\u21c3\u0001"+ + "\u0000\u0000\u0000\u0575\u21c9\u0001\u0000\u0000\u0000\u0577\u21e4\u0001"+ + "\u0000\u0000\u0000\u0579\u21f7\u0001\u0000\u0000\u0000\u057b\u2203\u0001"+ + "\u0000\u0000\u0000\u057d\u221f\u0001\u0000\u0000\u0000\u057f\u222c\u0001"+ + "\u0000\u0000\u0000\u0581\u2239\u0001\u0000\u0000\u0000\u0583\u2251\u0001"+ + "\u0000\u0000\u0000\u0585\u225d\u0001\u0000\u0000\u0000\u0587\u226e\u0001"+ + "\u0000\u0000\u0000\u0589\u2283\u0001\u0000\u0000\u0000\u058b\u228b\u0001"+ + "\u0000\u0000\u0000\u058d\u2290\u0001\u0000\u0000\u0000\u058f\u229f\u0001"+ + "\u0000\u0000\u0000\u0591\u22af\u0001\u0000\u0000\u0000\u0593\u22bd\u0001"+ + "\u0000\u0000\u0000\u0595\u22d3\u0001\u0000\u0000\u0000\u0597\u22e0\u0001"+ + "\u0000\u0000\u0000\u0599\u22ed\u0001\u0000\u0000\u0000\u059b\u2302\u0001"+ + "\u0000\u0000\u0000\u059d\u231a\u0001\u0000\u0000\u0000\u059f\u2332\u0001"+ + "\u0000\u0000\u0000\u05a1\u2349\u0001\u0000\u0000\u0000\u05a3\u2350\u0001"+ + "\u0000\u0000\u0000\u05a5\u2357\u0001\u0000\u0000\u0000\u05a7\u2367\u0001"+ + "\u0000\u0000\u0000\u05a9\u237f\u0001\u0000\u0000\u0000\u05ab\u239a\u0001"+ + "\u0000\u0000\u0000\u05ad\u23a5\u0001\u0000\u0000\u0000\u05af\u23ad\u0001"+ + "\u0000\u0000\u0000\u05b1\u23b4\u0001\u0000\u0000\u0000\u05b3\u23c8\u0001"+ + "\u0000\u0000\u0000\u05b5\u23e0\u0001\u0000\u0000\u0000\u05b7\u23f5\u0001"+ + "\u0000\u0000\u0000\u05b9\u2409\u0001\u0000\u0000\u0000\u05bb\u2414\u0001"+ + "\u0000\u0000\u0000\u05bd\u241c\u0001\u0000\u0000\u0000\u05bf\u241f\u0001"+ + "\u0000\u0000\u0000\u05c1\u2439\u0001\u0000\u0000\u0000\u05c3\u2456\u0001"+ + "\u0000\u0000\u0000\u05c5\u2462\u0001\u0000\u0000\u0000\u05c7\u246f\u0001"+ + "\u0000\u0000\u0000\u05c9\u2478\u0001\u0000\u0000\u0000\u05cb\u247e\u0001"+ + "\u0000\u0000\u0000\u05cd\u2495\u0001\u0000\u0000\u0000\u05cf\u249c\u0001"+ + "\u0000\u0000\u0000\u05d1\u24b3\u0001\u0000\u0000\u0000\u05d3\u24c7\u0001"+ + "\u0000\u0000\u0000\u05d5\u24d8\u0001\u0000\u0000\u0000\u05d7\u24e1\u0001"+ + "\u0000\u0000\u0000\u05d9\u24e7\u0001\u0000\u0000\u0000\u05db\u24ec\u0001"+ + "\u0000\u0000\u0000\u05dd\u24f3\u0001\u0000\u0000\u0000\u05df\u24fa\u0001"+ + "\u0000\u0000\u0000\u05e1\u2501\u0001\u0000\u0000\u0000\u05e3\u2508\u0001"+ + "\u0000\u0000\u0000\u05e5\u250e\u0001\u0000\u0000\u0000\u05e7\u2514\u0001"+ + "\u0000\u0000\u0000\u05e9\u251a\u0001\u0000\u0000\u0000\u05eb\u2520\u0001"+ + "\u0000\u0000\u0000\u05ed\u2525\u0001\u0000\u0000\u0000\u05ef\u252d\u0001"+ + "\u0000\u0000\u0000\u05f1\u2533\u0001\u0000\u0000\u0000\u05f3\u253b\u0001"+ + "\u0000\u0000\u0000\u05f5\u2542\u0001\u0000\u0000\u0000\u05f7\u2546\u0001"+ + "\u0000\u0000\u0000\u05f9\u254e\u0001\u0000\u0000\u0000\u05fb\u2554\u0001"+ + "\u0000\u0000\u0000\u05fd\u255b\u0001\u0000\u0000\u0000\u05ff\u255f\u0001"+ + "\u0000\u0000\u0000\u0601\u2567\u0001\u0000\u0000\u0000\u0603\u256d\u0001"+ + "\u0000\u0000\u0000\u0605\u2573\u0001\u0000\u0000\u0000\u0607\u257a\u0001"+ + "\u0000\u0000\u0000\u0609\u2581\u0001\u0000\u0000\u0000\u060b\u2588\u0001"+ + "\u0000\u0000\u0000\u060d\u258f\u0001\u0000\u0000\u0000\u060f\u2595\u0001"+ + "\u0000\u0000\u0000\u0611\u259e\u0001\u0000\u0000\u0000\u0613\u25a3\u0001"+ + "\u0000\u0000\u0000\u0615\u25a8\u0001\u0000\u0000\u0000\u0617\u25af\u0001"+ + "\u0000\u0000\u0000\u0619\u25b4\u0001\u0000\u0000\u0000\u061b\u25b9\u0001"+ + "\u0000\u0000\u0000\u061d\u25bf\u0001\u0000\u0000\u0000\u061f\u25c7\u0001"+ + "\u0000\u0000\u0000\u0621\u25cd\u0001\u0000\u0000\u0000\u0623\u25d2\u0001"+ + "\u0000\u0000\u0000\u0625\u25da\u0001\u0000\u0000\u0000\u0627\u25e2\u0001"+ + "\u0000\u0000\u0000\u0629\u25ea\u0001\u0000\u0000\u0000\u062b\u25f4\u0001"+ + "\u0000\u0000\u0000\u062d\u25f8\u0001\u0000\u0000\u0000\u062f\u2602\u0001"+ + "\u0000\u0000\u0000\u0631\u2609\u0001\u0000\u0000\u0000\u0633\u2610\u0001"+ + "\u0000\u0000\u0000\u0635\u261b\u0001\u0000\u0000\u0000\u0637\u2622\u0001"+ + "\u0000\u0000\u0000\u0639\u2626\u0001\u0000\u0000\u0000\u063b\u2631\u0001"+ + "\u0000\u0000\u0000\u063d\u2644\u0001\u0000\u0000\u0000\u063f\u264b\u0001"+ + "\u0000\u0000\u0000\u0641\u2656\u0001\u0000\u0000\u0000\u0643\u2660\u0001"+ + "\u0000\u0000\u0000\u0645\u266c\u0001\u0000\u0000\u0000\u0647\u2679\u0001"+ + "\u0000\u0000\u0000\u0649\u268c\u0001\u0000\u0000\u0000\u064b\u269b\u0001"+ + "\u0000\u0000\u0000\u064d\u26a4\u0001\u0000\u0000\u0000\u064f\u26af\u0001"+ + "\u0000\u0000\u0000\u0651\u26bf\u0001\u0000\u0000\u0000\u0653\u26ca\u0001"+ + "\u0000\u0000\u0000\u0655\u26d7\u0001\u0000\u0000\u0000\u0657\u26dd\u0001"+ + "\u0000\u0000\u0000\u0659\u26e5\u0001\u0000\u0000\u0000\u065b\u26e9\u0001"+ + "\u0000\u0000\u0000\u065d\u26ee\u0001\u0000\u0000\u0000\u065f\u26f6\u0001"+ + "\u0000\u0000\u0000\u0661\u26fe\u0001\u0000\u0000\u0000\u0663\u270a\u0001"+ + "\u0000\u0000\u0000\u0665\u2716\u0001\u0000\u0000\u0000\u0667\u271b\u0001"+ + "\u0000\u0000\u0000\u0669\u2724\u0001\u0000\u0000\u0000\u066b\u2729\u0001"+ + "\u0000\u0000\u0000\u066d\u2730\u0001\u0000\u0000\u0000\u066f\u2736\u0001"+ + "\u0000\u0000\u0000\u0671\u273c\u0001\u0000\u0000\u0000\u0673\u274f\u0001"+ + "\u0000\u0000\u0000\u0675\u2761\u0001\u0000\u0000\u0000\u0677\u2774\u0001"+ + "\u0000\u0000\u0000\u0679\u2784\u0001\u0000\u0000\u0000\u067b\u2796\u0001"+ + "\u0000\u0000\u0000\u067d\u279b\u0001\u0000\u0000\u0000\u067f\u27a1\u0001"+ + "\u0000\u0000\u0000\u0681\u27ab\u0001\u0000\u0000\u0000\u0683\u27af\u0001"+ + "\u0000\u0000\u0000\u0685\u27b9\u0001\u0000\u0000\u0000\u0687\u27c4\u0001"+ + "\u0000\u0000\u0000\u0689\u27cb\u0001\u0000\u0000\u0000\u068b\u27d8\u0001"+ + "\u0000\u0000\u0000\u068d\u27dd\u0001\u0000\u0000\u0000\u068f\u27e5\u0001"+ + "\u0000\u0000\u0000\u0691\u27ee\u0001\u0000\u0000\u0000\u0693\u27ff\u0001"+ + "\u0000\u0000\u0000\u0695\u2807\u0001\u0000\u0000\u0000\u0697\u2813\u0001"+ + "\u0000\u0000\u0000\u0699\u2820\u0001\u0000\u0000\u0000\u069b\u282a\u0001"+ + "\u0000\u0000\u0000\u069d\u2833\u0001\u0000\u0000\u0000\u069f\u283a\u0001"+ + "\u0000\u0000\u0000\u06a1\u2844\u0001\u0000\u0000\u0000\u06a3\u2852\u0001"+ + "\u0000\u0000\u0000\u06a5\u2857\u0001\u0000\u0000\u0000\u06a7\u2862\u0001"+ + "\u0000\u0000\u0000\u06a9\u2866\u0001\u0000\u0000\u0000\u06ab\u286a\u0001"+ + "\u0000\u0000\u0000\u06ad\u2870\u0001\u0000\u0000\u0000\u06af\u288b\u0001"+ + "\u0000\u0000\u0000\u06b1\u28a5\u0001\u0000\u0000\u0000\u06b3\u28ba\u0001"+ + "\u0000\u0000\u0000\u06b5\u28c8\u0001\u0000\u0000\u0000\u06b7\u28d0\u0001"+ + "\u0000\u0000\u0000\u06b9\u28d9\u0001\u0000\u0000\u0000\u06bb\u28e5\u0001"+ + "\u0000\u0000\u0000\u06bd\u28ed\u0001\u0000\u0000\u0000\u06bf\u28f8\u0001"+ + "\u0000\u0000\u0000\u06c1\u2902\u0001\u0000\u0000\u0000\u06c3\u290c\u0001"+ + "\u0000\u0000\u0000\u06c5\u2913\u0001\u0000\u0000\u0000\u06c7\u291b\u0001"+ + "\u0000\u0000\u0000\u06c9\u2927\u0001\u0000\u0000\u0000\u06cb\u2933\u0001"+ + "\u0000\u0000\u0000\u06cd\u293d\u0001\u0000\u0000\u0000\u06cf\u2946\u0001"+ + "\u0000\u0000\u0000\u06d1\u294a\u0001\u0000\u0000\u0000\u06d3\u2951\u0001"+ + "\u0000\u0000\u0000\u06d5\u2959\u0001\u0000\u0000\u0000\u06d7\u2962\u0001"+ + "\u0000\u0000\u0000\u06d9\u2973\u0001\u0000\u0000\u0000\u06db\u297c\u0001"+ + "\u0000\u0000\u0000\u06dd\u2983\u0001\u0000\u0000\u0000\u06df\u2987\u0001"+ + "\u0000\u0000\u0000\u06e1\u2992\u0001\u0000\u0000\u0000\u06e3\u299f\u0001"+ + "\u0000\u0000\u0000\u06e5\u29ac\u0001\u0000\u0000\u0000\u06e7\u29b2\u0001"+ + "\u0000\u0000\u0000\u06e9\u29be\u0001\u0000\u0000\u0000\u06eb\u29c4\u0001"+ + "\u0000\u0000\u0000\u06ed\u29cb\u0001\u0000\u0000\u0000\u06ef\u29d6\u0001"+ + "\u0000\u0000\u0000\u06f1\u29e2\u0001\u0000\u0000\u0000\u06f3\u29ec\u0001"+ + "\u0000\u0000\u0000\u06f5\u29fa\u0001\u0000\u0000\u0000\u06f7\u2a0b\u0001"+ + "\u0000\u0000\u0000\u06f9\u2a1b\u0001\u0000\u0000\u0000\u06fb\u2a36\u0001"+ + "\u0000\u0000\u0000\u06fd\u2a50\u0001\u0000\u0000\u0000\u06ff\u2a61\u0001"+ + "\u0000\u0000\u0000\u0701\u2a71\u0001\u0000\u0000\u0000\u0703\u2a7b\u0001"+ + "\u0000\u0000\u0000\u0705\u2a88\u0001\u0000\u0000\u0000\u0707\u2a95\u0001"+ + "\u0000\u0000\u0000\u0709\u2aa1\u0001\u0000\u0000\u0000\u070b\u2aac\u0001"+ + "\u0000\u0000\u0000\u070d\u2ab5\u0001\u0000\u0000\u0000\u070f\u2abd\u0001"+ + "\u0000\u0000\u0000\u0711\u2ac6\u0001\u0000\u0000\u0000\u0713\u2ad2\u0001"+ + "\u0000\u0000\u0000\u0715\u2ae0\u0001\u0000\u0000\u0000\u0717\u2ae4\u0001"+ + "\u0000\u0000\u0000\u0719\u2aeb\u0001\u0000\u0000\u0000\u071b\u2af6\u0001"+ + "\u0000\u0000\u0000\u071d\u2b01\u0001\u0000\u0000\u0000\u071f\u2b0b\u0001"+ + "\u0000\u0000\u0000\u0721\u2b15\u0001\u0000\u0000\u0000\u0723\u2b1b\u0001"+ + "\u0000\u0000\u0000\u0725\u2b29\u0001\u0000\u0000\u0000\u0727\u2b34\u0001"+ + "\u0000\u0000\u0000\u0729\u2b3d\u0001\u0000\u0000\u0000\u072b\u2b45\u0001"+ + "\u0000\u0000\u0000\u072d\u2b4c\u0001\u0000\u0000\u0000\u072f\u2b55\u0001"+ + "\u0000\u0000\u0000\u0731\u2b62\u0001\u0000\u0000\u0000\u0733\u2b6a\u0001"+ + "\u0000\u0000\u0000\u0735\u2b79\u0001\u0000\u0000\u0000\u0737\u2b88\u0001"+ + "\u0000\u0000\u0000\u0739\u2b90\u0001\u0000\u0000\u0000\u073b\u2b9d\u0001"+ + "\u0000\u0000\u0000\u073d\u2bac\u0001\u0000\u0000\u0000\u073f\u2bb2\u0001"+ + "\u0000\u0000\u0000\u0741\u2bb8\u0001\u0000\u0000\u0000\u0743\u2bbf\u0001"+ + "\u0000\u0000\u0000\u0745\u2bcc\u0001\u0000\u0000\u0000\u0747\u2bd8\u0001"+ + "\u0000\u0000\u0000\u0749\u2beb\u0001\u0000\u0000\u0000\u074b\u2bfd\u0001"+ + "\u0000\u0000\u0000\u074d\u2c00\u0001\u0000\u0000\u0000\u074f\u2c0a\u0001"+ + "\u0000\u0000\u0000\u0751\u2c11\u0001\u0000\u0000\u0000\u0753\u2c15\u0001"+ + "\u0000\u0000\u0000\u0755\u2c1b\u0001\u0000\u0000\u0000\u0757\u2c20\u0001"+ + "\u0000\u0000\u0000\u0759\u2c26\u0001\u0000\u0000\u0000\u075b\u2c2b\u0001"+ + "\u0000\u0000\u0000\u075d\u2c31\u0001\u0000\u0000\u0000\u075f\u2c3a\u0001"+ + "\u0000\u0000\u0000\u0761\u2c43\u0001\u0000\u0000\u0000\u0763\u2c4c\u0001"+ + "\u0000\u0000\u0000\u0765\u2c5c\u0001\u0000\u0000\u0000\u0767\u2c68\u0001"+ + "\u0000\u0000\u0000\u0769\u2c74\u0001\u0000\u0000\u0000\u076b\u2c7d\u0001"+ + "\u0000\u0000\u0000\u076d\u2c8b\u0001\u0000\u0000\u0000\u076f\u2c97\u0001"+ + "\u0000\u0000\u0000\u0771\u2ca2\u0001\u0000\u0000\u0000\u0773\u2cac\u0001"+ + "\u0000\u0000\u0000\u0775\u2cb0\u0001\u0000\u0000\u0000\u0777\u2cbe\u0001"+ + "\u0000\u0000\u0000\u0779\u2ccb\u0001\u0000\u0000\u0000\u077b\u2cd5\u0001"+ + "\u0000\u0000\u0000\u077d\u2ce4\u0001\u0000\u0000\u0000\u077f\u2cf2\u0001"+ + "\u0000\u0000\u0000\u0781\u2d00\u0001\u0000\u0000\u0000\u0783\u2d0d\u0001"+ + "\u0000\u0000\u0000\u0785\u2d25\u0001\u0000\u0000\u0000\u0787\u2d3c\u0001"+ + "\u0000\u0000\u0000\u0789\u2d4f\u0001\u0000\u0000\u0000\u078b\u2d61\u0001"+ + "\u0000\u0000\u0000\u078d\u2d76\u0001\u0000\u0000\u0000\u078f\u2d8a\u0001"+ + "\u0000\u0000\u0000\u0791\u2d95\u0001\u0000\u0000\u0000\u0793\u2d9c\u0001"+ + "\u0000\u0000\u0000\u0795\u2daa\u0001\u0000\u0000\u0000\u0797\u2dbb\u0001"+ + "\u0000\u0000\u0000\u0799\u2dc5\u0001\u0000\u0000\u0000\u079b\u2dc9\u0001"+ + "\u0000\u0000\u0000\u079d\u2dd6\u0001\u0000\u0000\u0000\u079f\u2dda\u0001"+ + "\u0000\u0000\u0000\u07a1\u2de3\u0001\u0000\u0000\u0000\u07a3\u2dee\u0001"+ + "\u0000\u0000\u0000\u07a5\u2dfa\u0001\u0000\u0000\u0000\u07a7\u2dfd\u0001"+ + "\u0000\u0000\u0000\u07a9\u2e0b\u0001\u0000\u0000\u0000\u07ab\u2e18\u0001"+ + "\u0000\u0000\u0000\u07ad\u2e1f\u0001\u0000\u0000\u0000\u07af\u2e2c\u0001"+ + "\u0000\u0000\u0000\u07b1\u2e38\u0001\u0000\u0000\u0000\u07b3\u2e48\u0001"+ + "\u0000\u0000\u0000\u07b5\u2e57\u0001\u0000\u0000\u0000\u07b7\u2e5b\u0001"+ + "\u0000\u0000\u0000\u07b9\u2e61\u0001\u0000\u0000\u0000\u07bb\u2e67\u0001"+ + "\u0000\u0000\u0000\u07bd\u2e6f\u0001\u0000\u0000\u0000\u07bf\u2e74\u0001"+ + "\u0000\u0000\u0000\u07c1\u2e7b\u0001\u0000\u0000\u0000\u07c3\u2e88\u0001"+ + "\u0000\u0000\u0000\u07c5\u2e95\u0001\u0000\u0000\u0000\u07c7\u2e9d\u0001"+ + "\u0000\u0000\u0000\u07c9\u2ea3\u0001\u0000\u0000\u0000\u07cb\u2ead\u0001"+ + "\u0000\u0000\u0000\u07cd\u2eb2\u0001\u0000\u0000\u0000\u07cf\u2eb8\u0001"+ + "\u0000\u0000\u0000\u07d1\u2ec4\u0001\u0000\u0000\u0000\u07d3\u2edf\u0001"+ + "\u0000\u0000\u0000\u07d5\u2eec\u0001\u0000\u0000\u0000\u07d7\u2ef0\u0001"+ + "\u0000\u0000\u0000\u07d9\u2ef5\u0001\u0000\u0000\u0000\u07db\u2efa\u0001"+ + "\u0000\u0000\u0000\u07dd\u2f06\u0001\u0000\u0000\u0000\u07df\u2f0b\u0001"+ + "\u0000\u0000\u0000\u07e1\u2f0f\u0001\u0000\u0000\u0000\u07e3\u2f15\u0001"+ + "\u0000\u0000\u0000\u07e5\u2f1d\u0001\u0000\u0000\u0000\u07e7\u2f39\u0001"+ + "\u0000\u0000\u0000\u07e9\u2f3e\u0001\u0000\u0000\u0000\u07eb\u2f43\u0001"+ + "\u0000\u0000\u0000\u07ed\u2f4e\u0001\u0000\u0000\u0000\u07ef\u2f55\u0001"+ + "\u0000\u0000\u0000\u07f1\u2f61\u0001\u0000\u0000\u0000\u07f3\u2f69\u0001"+ + "\u0000\u0000\u0000\u07f5\u2f75\u0001\u0000\u0000\u0000\u07f7\u2f7f\u0001"+ + "\u0000\u0000\u0000\u07f9\u2f88\u0001\u0000\u0000\u0000\u07fb\u2f91\u0001"+ + "\u0000\u0000\u0000\u07fd\u2f9b\u0001\u0000\u0000\u0000\u07ff\u2fa7\u0001"+ + "\u0000\u0000\u0000\u0801\u2fb3\u0001\u0000\u0000\u0000\u0803\u2fbe\u0001"+ + "\u0000\u0000\u0000\u0805\u2fcc\u0001\u0000\u0000\u0000\u0807\u2fd9\u0001"+ + "\u0000\u0000\u0000\u0809\u2fe5\u0001\u0000\u0000\u0000\u080b\u2ff1\u0001"+ + "\u0000\u0000\u0000\u080d\u2ffd\u0001\u0000\u0000\u0000\u080f\u3009\u0001"+ + "\u0000\u0000\u0000\u0811\u3013\u0001\u0000\u0000\u0000\u0813\u3023\u0001"+ + "\u0000\u0000\u0000\u0815\u3037\u0001\u0000\u0000\u0000\u0817\u304a\u0001"+ + "\u0000\u0000\u0000\u0819\u305d\u0001\u0000\u0000\u0000\u081b\u307b\u0001"+ + "\u0000\u0000\u0000\u081d\u3098\u0001\u0000\u0000\u0000\u081f\u30ac\u0001"+ + "\u0000\u0000\u0000\u0821\u30bf\u0001\u0000\u0000\u0000\u0823\u30cc\u0001"+ + "\u0000\u0000\u0000\u0825\u30dc\u0001\u0000\u0000\u0000\u0827\u30ec\u0001"+ + "\u0000\u0000\u0000\u0829\u30fb\u0001\u0000\u0000\u0000\u082b\u310c\u0001"+ + "\u0000\u0000\u0000\u082d\u311c\u0001\u0000\u0000\u0000\u082f\u312a\u0001"+ + "\u0000\u0000\u0000\u0831\u3136\u0001\u0000\u0000\u0000\u0833\u3141\u0001"+ + "\u0000\u0000\u0000\u0835\u314d\u0001\u0000\u0000\u0000\u0837\u315d\u0001"+ + "\u0000\u0000\u0000\u0839\u316c\u0001\u0000\u0000\u0000\u083b\u3182\u0001"+ + "\u0000\u0000\u0000\u083d\u3197\u0001\u0000\u0000\u0000\u083f\u31a8\u0001"+ + "\u0000\u0000\u0000\u0841\u31bb\u0001\u0000\u0000\u0000\u0843\u31cf\u0001"+ + "\u0000\u0000\u0000\u0845\u31dc\u0001\u0000\u0000\u0000\u0847\u31e8\u0001"+ + "\u0000\u0000\u0000\u0849\u31f9\u0001\u0000\u0000\u0000\u084b\u3209\u0001"+ + "\u0000\u0000\u0000\u084d\u3213\u0001\u0000\u0000\u0000\u084f\u3223\u0001"+ + "\u0000\u0000\u0000\u0851\u3232\u0001\u0000\u0000\u0000\u0853\u3245\u0001"+ + "\u0000\u0000\u0000\u0855\u3257\u0001\u0000\u0000\u0000\u0857\u325f\u0001"+ + "\u0000\u0000\u0000\u0859\u326d\u0001\u0000\u0000\u0000\u085b\u327e\u0001"+ + "\u0000\u0000\u0000\u085d\u3289\u0001\u0000\u0000\u0000\u085f\u3292\u0001"+ + "\u0000\u0000\u0000\u0861\u329c\u0001\u0000\u0000\u0000\u0863\u32a1\u0001"+ + "\u0000\u0000\u0000\u0865\u32a6\u0001\u0000\u0000\u0000\u0867\u32ae\u0001"+ + "\u0000\u0000\u0000\u0869\u32be\u0001\u0000\u0000\u0000\u086b\u32c6\u0001"+ + "\u0000\u0000\u0000\u086d\u32d2\u0001\u0000\u0000\u0000\u086f\u32d6\u0001"+ + "\u0000\u0000\u0000\u0871\u32df\u0001\u0000\u0000\u0000\u0873\u32ec\u0001"+ + "\u0000\u0000\u0000\u0875\u32fa\u0001\u0000\u0000\u0000\u0877\u3306\u0001"+ + "\u0000\u0000\u0000\u0879\u3312\u0001\u0000\u0000\u0000\u087b\u331a\u0001"+ + "\u0000\u0000\u0000\u087d\u3324\u0001\u0000\u0000\u0000\u087f\u332c\u0001"+ + "\u0000\u0000\u0000\u0881\u3337\u0001\u0000\u0000\u0000\u0883\u334b\u0001"+ + "\u0000\u0000\u0000\u0885\u3351\u0001\u0000\u0000\u0000\u0887\u335c\u0001"+ + "\u0000\u0000\u0000\u0889\u3370\u0001"; + private static final String _serializedATNSegment2 = + "\u0000\u0000\u0000\u088b\u3376\u0001\u0000\u0000\u0000\u088d\u3385\u0001"+ + "\u0000\u0000\u0000\u088f\u338f\u0001\u0000\u0000\u0000\u0891\u3395\u0001"+ + "\u0000\u0000\u0000\u0893\u339a\u0001\u0000\u0000\u0000\u0895\u33a5\u0001"+ + "\u0000\u0000\u0000\u0897\u33c0\u0001\u0000\u0000\u0000\u0899\u33c8\u0001"+ + "\u0000\u0000\u0000\u089b\u33ea\u0001\u0000\u0000\u0000\u089d\u33f2\u0001"+ + "\u0000\u0000\u0000\u089f\u33fd\u0001\u0000\u0000\u0000\u08a1\u340b\u0001"+ + "\u0000\u0000\u0000\u08a3\u3412\u0001\u0000\u0000\u0000\u08a5\u341b\u0001"+ + "\u0000\u0000\u0000\u08a7\u341d\u0001\u0000\u0000\u0000\u08a9\u341f\u0001"+ + "\u0000\u0000\u0000\u08ab\u3422\u0001\u0000\u0000\u0000\u08ad\u3425\u0001"+ + "\u0000\u0000\u0000\u08af\u3428\u0001\u0000\u0000\u0000\u08b1\u342b\u0001"+ + "\u0000\u0000\u0000\u08b3\u342e\u0001\u0000\u0000\u0000\u08b5\u3431\u0001"+ + "\u0000\u0000\u0000\u08b7\u3434\u0001\u0000\u0000\u0000\u08b9\u3437\u0001"+ + "\u0000\u0000\u0000\u08bb\u343a\u0001\u0000\u0000\u0000\u08bd\u343c\u0001"+ + "\u0000\u0000\u0000\u08bf\u343e\u0001\u0000\u0000\u0000\u08c1\u3440\u0001"+ + "\u0000\u0000\u0000\u08c3\u3442\u0001\u0000\u0000\u0000\u08c5\u3444\u0001"+ + "\u0000\u0000\u0000\u08c7\u3448\u0001\u0000\u0000\u0000\u08c9\u344c\u0001"+ + "\u0000\u0000\u0000\u08cb\u344e\u0001\u0000\u0000\u0000\u08cd\u3450\u0001"+ + "\u0000\u0000\u0000\u08cf\u3452\u0001\u0000\u0000\u0000\u08d1\u3454\u0001"+ + "\u0000\u0000\u0000\u08d3\u3456\u0001\u0000\u0000\u0000\u08d5\u3458\u0001"+ + "\u0000\u0000\u0000\u08d7\u345a\u0001\u0000\u0000\u0000\u08d9\u345c\u0001"+ + "\u0000\u0000\u0000\u08db\u345e\u0001\u0000\u0000\u0000\u08dd\u3460\u0001"+ + "\u0000\u0000\u0000\u08df\u3462\u0001\u0000\u0000\u0000\u08e1\u3464\u0001"+ + "\u0000\u0000\u0000\u08e3\u3466\u0001\u0000\u0000\u0000\u08e5\u3468\u0001"+ + "\u0000\u0000\u0000\u08e7\u346a\u0001\u0000\u0000\u0000\u08e9\u346c\u0001"+ + "\u0000\u0000\u0000\u08eb\u346e\u0001\u0000\u0000\u0000\u08ed\u3470\u0001"+ + "\u0000\u0000\u0000\u08ef\u3472\u0001\u0000\u0000\u0000\u08f1\u3474\u0001"+ + "\u0000\u0000\u0000\u08f3\u3479\u0001\u0000\u0000\u0000\u08f5\u347b\u0001"+ + "\u0000\u0000\u0000\u08f7\u3480\u0001\u0000\u0000\u0000\u08f9\u3486\u0001"+ + "\u0000\u0000\u0000\u08fb\u348c\u0001\u0000\u0000\u0000\u08fd\u348f\u0001"+ + "\u0000\u0000\u0000\u08ff\u34a6\u0001\u0000\u0000\u0000\u0901\u34d1\u0001"+ + "\u0000\u0000\u0000\u0903\u34d3\u0001\u0000\u0000\u0000\u0905\u34d6\u0001"+ + "\u0000\u0000\u0000\u0907\u34d8\u0001\u0000\u0000\u0000\u0909\u34db\u0001"+ + "\u0000\u0000\u0000\u090b\u34de\u0001\u0000\u0000\u0000\u090d\u34e0\u0001"+ + "\u0000\u0000\u0000\u090f\u34e2\u0001\u0000\u0000\u0000\u0911\u34e5\u0001"+ + "\u0000\u0000\u0000\u0913\u34ee\u0001\u0000\u0000\u0000\u0915\u3521\u0001"+ + "\u0000\u0000\u0000\u0917\u3523\u0001\u0000\u0000\u0000\u0919\u352f\u0001"+ + "\u0000\u0000\u0000\u091b\u353d\u0001\u0000\u0000\u0000\u091d\u354a\u0001"+ + "\u0000\u0000\u0000\u091f\u3557\u0001\u0000\u0000\u0000\u0921\u3562\u0001"+ + "\u0000\u0000\u0000\u0923\u3564\u0001\u0000\u0000\u0000\u0925\u3566\u0001"+ + "\u0000\u0000\u0000\u0927\u358d\u0001\u0000\u0000\u0000\u0929\u358f\u0001"+ + "\u0000\u0000\u0000\u092b\u092c\u0005#\u0000\u0000\u092c\u0930\u0005{\u0000"+ + "\u0000\u092d\u092f\t\u0000\u0000\u0000\u092e\u092d\u0001\u0000\u0000\u0000"+ + "\u092f\u0932\u0001\u0000\u0000\u0000\u0930\u0931\u0001\u0000\u0000\u0000"+ + "\u0930\u092e\u0001\u0000\u0000\u0000\u0931\u0933\u0001\u0000\u0000\u0000"+ + "\u0932\u0930\u0001\u0000\u0000\u0000\u0933\u0934\u0005}\u0000\u0000\u0934"+ + "\u0002\u0001\u0000\u0000\u0000\u0935\u0937\u0007\u0000\u0000\u0000\u0936"+ + "\u0935\u0001\u0000\u0000\u0000\u0937\u0938\u0001\u0000\u0000\u0000\u0938"+ + "\u0936\u0001\u0000\u0000\u0000\u0938\u0939\u0001\u0000\u0000\u0000\u0939"+ + "\u093a\u0001\u0000\u0000\u0000\u093a\u093b\u0006\u0001\u0000\u0000\u093b"+ + "\u0004\u0001\u0000\u0000\u0000\u093c\u093d\u0005/\u0000\u0000\u093d\u093e"+ + "\u0005*\u0000\u0000\u093e\u093f\u0005!\u0000\u0000\u093f\u0941\u0001\u0000"+ + "\u0000\u0000\u0940\u0942\t\u0000\u0000\u0000\u0941\u0940\u0001\u0000\u0000"+ + "\u0000\u0942\u0943\u0001\u0000\u0000\u0000\u0943\u0944\u0001\u0000\u0000"+ + "\u0000\u0943\u0941\u0001\u0000\u0000\u0000\u0944\u0945\u0001\u0000\u0000"+ + "\u0000\u0945\u0946\u0005*\u0000\u0000\u0946\u0947\u0005/\u0000\u0000\u0947"+ + "\u0948\u0001\u0000\u0000\u0000\u0948\u0949\u0006\u0002\u0001\u0000\u0949"+ + "\u0006\u0001\u0000\u0000\u0000\u094a\u094b\u0005/\u0000\u0000\u094b\u094c"+ + "\u0005*\u0000\u0000\u094c\u0950\u0001\u0000\u0000\u0000\u094d\u094f\t"+ + "\u0000\u0000\u0000\u094e\u094d\u0001\u0000\u0000\u0000\u094f\u0952\u0001"+ + "\u0000\u0000\u0000\u0950\u0951\u0001\u0000\u0000\u0000\u0950\u094e\u0001"+ + "\u0000\u0000\u0000\u0951\u0953\u0001\u0000\u0000\u0000\u0952\u0950\u0001"+ + "\u0000\u0000\u0000\u0953\u0954\u0005*\u0000\u0000\u0954\u0955\u0005/\u0000"+ + "\u0000\u0955\u0956\u0001\u0000\u0000\u0000\u0956\u0957\u0006\u0003\u0000"+ + "\u0000\u0957\b\u0001\u0000\u0000\u0000\u0958\u0959\u0005-\u0000\u0000"+ + "\u0959\u095a\u0005-\u0000\u0000\u095a\u095e\u0001\u0000\u0000\u0000\u095b"+ + "\u095d\u0007\u0001\u0000\u0000\u095c\u095b\u0001\u0000\u0000\u0000\u095d"+ + "\u0960\u0001\u0000\u0000\u0000\u095e\u095c\u0001\u0000\u0000\u0000\u095e"+ + "\u095f\u0001\u0000\u0000\u0000\u095f\u0963\u0001\u0000\u0000\u0000\u0960"+ + "\u095e\u0001\u0000\u0000\u0000\u0961\u0963\u0005#\u0000\u0000\u0962\u0958"+ + "\u0001\u0000\u0000\u0000\u0962\u0961\u0001\u0000\u0000\u0000\u0963\u0967"+ + "\u0001\u0000\u0000\u0000\u0964\u0966\b\u0002\u0000\u0000\u0965\u0964\u0001"+ + "\u0000\u0000\u0000\u0966\u0969\u0001\u0000\u0000\u0000\u0967\u0965\u0001"+ + "\u0000\u0000\u0000\u0967\u0968\u0001\u0000\u0000\u0000\u0968\u096f\u0001"+ + "\u0000\u0000\u0000\u0969\u0967\u0001\u0000\u0000\u0000\u096a\u096c\u0005"+ + "\r\u0000\u0000\u096b\u096a\u0001\u0000\u0000\u0000\u096b\u096c\u0001\u0000"+ + "\u0000\u0000\u096c\u096d\u0001\u0000\u0000\u0000\u096d\u0970\u0005\n\u0000"+ + "\u0000\u096e\u0970\u0005\u0000\u0000\u0001\u096f\u096b\u0001\u0000\u0000"+ + "\u0000\u096f\u096e\u0001\u0000\u0000\u0000\u0970\u097c\u0001\u0000\u0000"+ + "\u0000\u0971\u0972\u0005-\u0000\u0000\u0972\u0973\u0005-\u0000\u0000\u0973"+ + "\u0979\u0001\u0000\u0000\u0000\u0974\u0976\u0005\r\u0000\u0000\u0975\u0974"+ + "\u0001\u0000\u0000\u0000\u0975\u0976\u0001\u0000\u0000\u0000\u0976\u0977"+ + "\u0001\u0000\u0000\u0000\u0977\u097a\u0005\n\u0000\u0000\u0978\u097a\u0005"+ + "\u0000\u0000\u0001\u0979\u0975\u0001\u0000\u0000\u0000\u0979\u0978\u0001"+ + "\u0000\u0000\u0000\u097a\u097c\u0001\u0000\u0000\u0000\u097b\u0962\u0001"+ + "\u0000\u0000\u0000\u097b\u0971\u0001\u0000\u0000\u0000\u097c\u097d\u0001"+ + "\u0000\u0000\u0000\u097d\u097e\u0006\u0004\u0000\u0000\u097e\n\u0001\u0000"+ + "\u0000\u0000\u097f\u0980\u0007\u0003\u0000\u0000\u0980\u0981\u0007\u0004"+ + "\u0000\u0000\u0981\u0982\u0007\u0004\u0000\u0000\u0982\f\u0001\u0000\u0000"+ + "\u0000\u0983\u0984\u0007\u0003\u0000\u0000\u0984\u0985\u0007\u0005\u0000"+ + "\u0000\u0985\u0986\u0007\u0005\u0000\u0000\u0986\u000e\u0001\u0000\u0000"+ + "\u0000\u0987\u0988\u0007\u0003\u0000\u0000\u0988\u0989\u0007\u0005\u0000"+ + "\u0000\u0989\u098a\u0007\u0006\u0000\u0000\u098a\u098b\u0007\u0007\u0000"+ + "\u0000\u098b\u098c\u0007\b\u0000\u0000\u098c\u0010\u0001\u0000\u0000\u0000"+ + "\u098d\u098e\u0007\u0003\u0000\u0000\u098e\u098f\u0007\u0005\u0000\u0000"+ + "\u098f\u0990\u0007\t\u0000\u0000\u0990\u0991\u0007\u0003\u0000\u0000\u0991"+ + "\u0992\u0007\n\u0000\u0000\u0992\u0993\u0007\u000b\u0000\u0000\u0993\u0012"+ + "\u0001\u0000\u0000\u0000\u0994\u0995\u0007\u0003\u0000\u0000\u0995\u0996"+ + "\u0007\f\u0000\u0000\u0996\u0997\u0007\u0003\u0000\u0000\u0997\u0998\u0007"+ + "\u0005\u0000\u0000\u0998\u0999\u0007\n\u0000\u0000\u0999\u099a\u0007\r"+ + "\u0000\u0000\u099a\u099b\u0007\u0007\u0000\u0000\u099b\u0014\u0001\u0000"+ + "\u0000\u0000\u099c\u099d\u0007\u0003\u0000\u0000\u099d\u099e\u0007\f\u0000"+ + "\u0000\u099e\u099f\u0007\u0004\u0000\u0000\u099f\u0016\u0001\u0000\u0000"+ + "\u0000\u09a0\u09a1\u0007\u0003\u0000\u0000\u09a1\u09a2\u0007\b\u0000\u0000"+ + "\u09a2\u09a3\u0007\b\u0000\u0000\u09a3\u09a4\u0007\u0003\u0000\u0000\u09a4"+ + "\u09a5\u0007\n\u0000\u0000\u09a5\u0018\u0001\u0000\u0000\u0000\u09a6\u09a7"+ + "\u0007\u0003\u0000\u0000\u09a7\u09a8\u0007\u000b\u0000\u0000\u09a8\u001a"+ + "\u0001\u0000\u0000\u0000\u09a9\u09aa\u0007\u0003\u0000\u0000\u09aa\u09ab"+ + "\u0007\u000b\u0000\u0000\u09ab\u09ac\u0007\u000e\u0000\u0000\u09ac\u001c"+ + "\u0001\u0000\u0000\u0000\u09ad\u09ae\u0007\u0003\u0000\u0000\u09ae\u09af"+ + "\u0007\u0006\u0000\u0000\u09af\u09b0\u0007\u0006\u0000\u0000\u09b0\u09b1"+ + "\u0007\b\u0000\u0000\u09b1\u09b2\u0007\u000f\u0000\u0000\u09b2\u09b3\u0007"+ + "\u0010\u0000\u0000\u09b3\u09b4\u0007\u0011\u0000\u0000\u09b4\u09b5\u0007"+ + "\u0006\u0000\u0000\u09b5\u09b6\u0007\u0007\u0000\u0000\u09b6\u001e\u0001"+ + "\u0000\u0000\u0000\u09b7\u09b8\u0007\u0010\u0000\u0000\u09b8\u09b9\u0007"+ + "\u0007\u0000\u0000\u09b9\u09ba\u0007\u0012\u0000\u0000\u09ba\u09bb\u0007"+ + "\u0013\u0000\u0000\u09bb\u09bc\u0007\b\u0000\u0000\u09bc\u09bd\u0007\u0007"+ + "\u0000\u0000\u09bd \u0001\u0000\u0000\u0000\u09be\u09bf\u0007\u0010\u0000"+ + "\u0000\u09bf\u09c0\u0007\u0007\u0000\u0000\u09c0\u09c1\u0007\u0006\u0000"+ + "\u0000\u09c1\u09c2\u0007\t\u0000\u0000\u09c2\u09c3\u0007\u0007\u0000\u0000"+ + "\u09c3\u09c4\u0007\u0007\u0000\u0000\u09c4\u09c5\u0007\f\u0000\u0000\u09c5"+ + "\"\u0001\u0000\u0000\u0000\u09c6\u09c7\u0007\u0010\u0000\u0000\u09c7\u09c8"+ + "\u0007\u0013\u0000\u0000\u09c8\u09c9\u0007\u0006\u0000\u0000\u09c9\u09ca"+ + "\u0007\u0014\u0000\u0000\u09ca$\u0001\u0000\u0000\u0000\u09cb\u09cc\u0007"+ + "\u0010\u0000\u0000\u09cc\u09cd\u0007\u0011\u0000\u0000\u09cd\u09ce\u0007"+ + "\u000e\u0000\u0000\u09ce\u09cf\u0007\u0015\u0000\u0000\u09cf\u09d0\u0007"+ + "\u0007\u0000\u0000\u09d0\u09d1\u0007\u0006\u0000\u0000\u09d1\u09d2\u0007"+ + "\u000b\u0000\u0000\u09d2&\u0001\u0000\u0000\u0000\u09d3\u09d4\u0007\u0010"+ + "\u0000\u0000\u09d4\u09d5\u0007\n\u0000\u0000\u09d5(\u0001\u0000\u0000"+ + "\u0000\u09d6\u09d7\u0007\u000e\u0000\u0000\u09d7\u09d8\u0007\u0003\u0000"+ + "\u0000\u09d8\u09d9\u0007\u0005\u0000\u0000\u09d9\u09da\u0007\u0005\u0000"+ + "\u0000\u09da*\u0001\u0000\u0000\u0000\u09db\u09dc\u0007\u000e\u0000\u0000"+ + "\u09dc\u09dd\u0007\u0003\u0000\u0000\u09dd\u09de\u0007\u000b\u0000\u0000"+ + "\u09de\u09df\u0007\u000e\u0000\u0000\u09df\u09e0\u0007\u0003\u0000\u0000"+ + "\u09e0\u09e1\u0007\u0004\u0000\u0000\u09e1\u09e2\u0007\u0007\u0000\u0000"+ + "\u09e2,\u0001\u0000\u0000\u0000\u09e3\u09e4\u0007\u000e\u0000\u0000\u09e4"+ + "\u09e5\u0007\u0003\u0000\u0000\u09e5\u09e6\u0007\u000b\u0000\u0000\u09e6"+ + "\u09e7\u0007\u0007\u0000\u0000\u09e7.\u0001\u0000\u0000\u0000\u09e8\u09e9"+ + "\u0007\u000e\u0000\u0000\u09e9\u09ea\u0007\u0003\u0000\u0000\u09ea\u09eb"+ + "\u0007\u000b\u0000\u0000\u09eb\u09ec\u0007\u0006\u0000\u0000\u09ec0\u0001"+ + "\u0000\u0000\u0000\u09ed\u09ee\u0007\u000e\u0000\u0000\u09ee\u09ef\u0007"+ + "\u0014\u0000\u0000\u09ef\u09f0\u0007\u0003\u0000\u0000\u09f0\u09f1\u0007"+ + "\f\u0000\u0000\u09f1\u09f2\u0007\u0016\u0000\u0000\u09f2\u09f3\u0007\u0007"+ + "\u0000\u0000\u09f32\u0001\u0000\u0000\u0000\u09f4\u09f5\u0007\u000e\u0000"+ + "\u0000\u09f5\u09f6\u0007\u0014\u0000\u0000\u09f6\u09f7\u0007\u0003\u0000"+ + "\u0000\u09f7\u09f8\u0007\b\u0000\u0000\u09f8\u09f9\u0007\u0003\u0000\u0000"+ + "\u09f9\u09fa\u0007\u000e\u0000\u0000\u09fa\u09fb\u0007\u0006\u0000\u0000"+ + "\u09fb\u09fc\u0007\u0007\u0000\u0000\u09fc\u09fd\u0007\b\u0000\u0000\u09fd"+ + "4\u0001\u0000\u0000\u0000\u09fe\u09ff\u0007\u000e\u0000\u0000\u09ff\u0a00"+ + "\u0007\u0014\u0000\u0000\u0a00\u0a01\u0007\u0007\u0000\u0000\u0a01\u0a02"+ + "\u0007\u000e\u0000\u0000\u0a02\u0a03\u0007\u0015\u0000\u0000\u0a036\u0001"+ + "\u0000\u0000\u0000\u0a04\u0a05\u0007\u000e\u0000\u0000\u0a05\u0a06\u0007"+ + "\u0013\u0000\u0000\u0a06\u0a07\u0007\u0005\u0000\u0000\u0a07\u0a08\u0007"+ + "\u0005\u0000\u0000\u0a08\u0a09\u0007\u0003\u0000\u0000\u0a09\u0a0a\u0007"+ + "\u0006\u0000\u0000\u0a0a\u0a0b\u0007\u0007\u0000\u0000\u0a0b8\u0001\u0000"+ + "\u0000\u0000\u0a0c\u0a0d\u0007\u000e\u0000\u0000\u0a0d\u0a0e\u0007\u0013"+ + "\u0000\u0000\u0a0e\u0a0f\u0007\u0005\u0000\u0000\u0a0f\u0a10\u0007\u0011"+ + "\u0000\u0000\u0a10\u0a11\u0007\u0017\u0000\u0000\u0a11\u0a12\u0007\f\u0000"+ + "\u0000\u0a12:\u0001\u0000\u0000\u0000\u0a13\u0a14\u0007\u000e\u0000\u0000"+ + "\u0a14\u0a15\u0007\u0013\u0000\u0000\u0a15\u0a16\u0007\f\u0000\u0000\u0a16"+ + "\u0a17\u0007\u0004\u0000\u0000\u0a17\u0a18\u0007\u000f\u0000\u0000\u0a18"+ + "\u0a19\u0007\u0006\u0000\u0000\u0a19\u0a1a\u0007\u000f\u0000\u0000\u0a1a"+ + "\u0a1b\u0007\u0013\u0000\u0000\u0a1b\u0a1c\u0007\f\u0000\u0000\u0a1c<"+ + "\u0001\u0000\u0000\u0000\u0a1d\u0a1e\u0007\u000e\u0000\u0000\u0a1e\u0a1f"+ + "\u0007\u0013\u0000\u0000\u0a1f\u0a20\u0007\f\u0000\u0000\u0a20\u0a21\u0007"+ + "\u000b\u0000\u0000\u0a21\u0a22\u0007\u0006\u0000\u0000\u0a22\u0a23\u0007"+ + "\b\u0000\u0000\u0a23\u0a24\u0007\u0003\u0000\u0000\u0a24\u0a25\u0007\u000f"+ + "\u0000\u0000\u0a25\u0a26\u0007\f\u0000\u0000\u0a26\u0a27\u0007\u0006\u0000"+ + "\u0000\u0a27>\u0001\u0000\u0000\u0000\u0a28\u0a29\u0007\u000e\u0000\u0000"+ + "\u0a29\u0a2a\u0007\u0013\u0000\u0000\u0a2a\u0a2b\u0007\f\u0000\u0000\u0a2b"+ + "\u0a2c\u0007\u0006\u0000\u0000\u0a2c\u0a2d\u0007\u000f\u0000\u0000\u0a2d"+ + "\u0a2e\u0007\f\u0000\u0000\u0a2e\u0a2f\u0007\u0011\u0000\u0000\u0a2f\u0a30"+ + "\u0007\u0007\u0000\u0000\u0a30@\u0001\u0000\u0000\u0000\u0a31\u0a32\u0007"+ + "\u000e\u0000\u0000\u0a32\u0a33\u0007\u0013\u0000\u0000\u0a33\u0a34\u0007"+ + "\f\u0000\u0000\u0a34\u0a35\u0007\u0018\u0000\u0000\u0a35\u0a36\u0007\u0007"+ + "\u0000\u0000\u0a36\u0a37\u0007\b\u0000\u0000\u0a37\u0a38\u0007\u0006\u0000"+ + "\u0000\u0a38B\u0001\u0000\u0000\u0000\u0a39\u0a3a\u0007\u000e\u0000\u0000"+ + "\u0a3a\u0a3b\u0007\b\u0000\u0000\u0a3b\u0a3c\u0007\u0007\u0000\u0000\u0a3c"+ + "\u0a3d\u0007\u0003\u0000\u0000\u0a3d\u0a3e\u0007\u0006\u0000\u0000\u0a3e"+ + "\u0a3f\u0007\u0007\u0000\u0000\u0a3fD\u0001\u0000\u0000\u0000\u0a40\u0a41"+ + "\u0007\u000e\u0000\u0000\u0a41\u0a42\u0007\b\u0000\u0000\u0a42\u0a43\u0007"+ + "\u0013\u0000\u0000\u0a43\u0a44\u0007\u000b\u0000\u0000\u0a44\u0a45\u0007"+ + "\u000b\u0000\u0000\u0a45F\u0001\u0000\u0000\u0000\u0a46\u0a47\u0007\u000e"+ + "\u0000\u0000\u0a47\u0a48\u0007\u0011\u0000\u0000\u0a48\u0a49\u0007\b\u0000"+ + "\u0000\u0a49\u0a4a\u0007\b\u0000\u0000\u0a4a\u0a4b\u0007\u0007\u0000\u0000"+ + "\u0a4b\u0a4c\u0007\f\u0000\u0000\u0a4c\u0a4d\u0007\u0006\u0000\u0000\u0a4d"+ + "H\u0001\u0000\u0000\u0000\u0a4e\u0a4f\u0007\u000e\u0000\u0000\u0a4f\u0a50"+ + "\u0007\u0011\u0000\u0000\u0a50\u0a51\u0007\b\u0000\u0000\u0a51\u0a52\u0007"+ + "\b\u0000\u0000\u0a52\u0a53\u0007\u0007\u0000\u0000\u0a53\u0a54\u0007\f"+ + "\u0000\u0000\u0a54\u0a55\u0007\u0006\u0000\u0000\u0a55\u0a56\u0005_\u0000"+ + "\u0000\u0a56\u0a57\u0007\b\u0000\u0000\u0a57\u0a58\u0007\u0013\u0000\u0000"+ + "\u0a58\u0a59\u0007\u0005\u0000\u0000\u0a59\u0a5a\u0007\u0007\u0000\u0000"+ + "\u0a5aJ\u0001\u0000\u0000\u0000\u0a5b\u0a5c\u0007\u000e\u0000\u0000\u0a5c"+ + "\u0a5d\u0007\u0011\u0000\u0000\u0a5d\u0a5e\u0007\b\u0000\u0000\u0a5e\u0a5f"+ + "\u0007\b\u0000\u0000\u0a5f\u0a60\u0007\u0007\u0000\u0000\u0a60\u0a61\u0007"+ + "\f\u0000\u0000\u0a61\u0a62\u0007\u0006\u0000\u0000\u0a62\u0a63\u0005_"+ + "\u0000\u0000\u0a63\u0a64\u0007\u0011\u0000\u0000\u0a64\u0a65\u0007\u000b"+ + "\u0000\u0000\u0a65\u0a66\u0007\u0007\u0000\u0000\u0a66\u0a67\u0007\b\u0000"+ + "\u0000\u0a67L\u0001\u0000\u0000\u0000\u0a68\u0a69\u0007\u000e\u0000\u0000"+ + "\u0a69\u0a6a\u0007\u0011\u0000\u0000\u0a6a\u0a6b\u0007\b\u0000\u0000\u0a6b"+ + "\u0a6c\u0007\u000b\u0000\u0000\u0a6c\u0a6d\u0007\u0013\u0000\u0000\u0a6d"+ + "\u0a6e\u0007\b\u0000\u0000\u0a6eN\u0001\u0000\u0000\u0000\u0a6f\u0a70"+ + "\u0007\u0004\u0000\u0000\u0a70\u0a71\u0007\u0003\u0000\u0000\u0a71\u0a72"+ + "\u0007\u0006\u0000\u0000\u0a72\u0a73\u0007\u0003\u0000\u0000\u0a73\u0a74"+ + "\u0007\u0010\u0000\u0000\u0a74\u0a75\u0007\u0003\u0000\u0000\u0a75\u0a76"+ + "\u0007\u000b\u0000\u0000\u0a76\u0a77\u0007\u0007\u0000\u0000\u0a77P\u0001"+ + "\u0000\u0000\u0000\u0a78\u0a79\u0007\u0004\u0000\u0000\u0a79\u0a7a\u0007"+ + "\u0003\u0000\u0000\u0a7a\u0a7b\u0007\u0006\u0000\u0000\u0a7b\u0a7c\u0007"+ + "\u0003\u0000\u0000\u0a7c\u0a7d\u0007\u0010\u0000\u0000\u0a7d\u0a7e\u0007"+ + "\u0003\u0000\u0000\u0a7e\u0a7f\u0007\u000b\u0000\u0000\u0a7f\u0a80\u0007"+ + "\u0007\u0000\u0000\u0a80\u0a81\u0007\u000b\u0000\u0000\u0a81R\u0001\u0000"+ + "\u0000\u0000\u0a82\u0a83\u0007\u0004\u0000\u0000\u0a83\u0a84\u0007\u0007"+ + "\u0000\u0000\u0a84\u0a85\u0007\u000e\u0000\u0000\u0a85\u0a86\u0007\u0005"+ + "\u0000\u0000\u0a86\u0a87\u0007\u0003\u0000\u0000\u0a87\u0a88\u0007\b\u0000"+ + "\u0000\u0a88\u0a89\u0007\u0007\u0000\u0000\u0a89T\u0001\u0000\u0000\u0000"+ + "\u0a8a\u0a8b\u0007\u0004\u0000\u0000\u0a8b\u0a8c\u0007\u0007\u0000\u0000"+ + "\u0a8c\u0a8d\u0007\u0012\u0000\u0000\u0a8d\u0a8e\u0007\u0003\u0000\u0000"+ + "\u0a8e\u0a8f\u0007\u0011\u0000\u0000\u0a8f\u0a90\u0007\u0005\u0000\u0000"+ + "\u0a90\u0a91\u0007\u0006\u0000\u0000\u0a91V\u0001\u0000\u0000\u0000\u0a92"+ + "\u0a93\u0007\u0004\u0000\u0000\u0a93\u0a94\u0007\u0007\u0000\u0000\u0a94"+ + "\u0a95\u0007\u0005\u0000\u0000\u0a95\u0a96\u0007\u0003\u0000\u0000\u0a96"+ + "\u0a97\u0007\n\u0000\u0000\u0a97\u0a98\u0007\u0007\u0000\u0000\u0a98\u0a99"+ + "\u0007\u0004\u0000\u0000\u0a99X\u0001\u0000\u0000\u0000\u0a9a\u0a9b\u0007"+ + "\u0004\u0000\u0000\u0a9b\u0a9c\u0007\u0007\u0000\u0000\u0a9c\u0a9d\u0007"+ + "\u0005\u0000\u0000\u0a9d\u0a9e\u0007\u0007\u0000\u0000\u0a9e\u0a9f\u0007"+ + "\u0006\u0000\u0000\u0a9f\u0aa0\u0007\u0007\u0000\u0000\u0aa0Z\u0001\u0000"+ + "\u0000\u0000\u0aa1\u0aa2\u0007\u0004\u0000\u0000\u0aa2\u0aa3\u0007\u0007"+ + "\u0000\u0000\u0aa3\u0aa4\u0007\u000b\u0000\u0000\u0aa4\u0aa5\u0007\u000e"+ + "\u0000\u0000\u0aa5\\\u0001\u0000\u0000\u0000\u0aa6\u0aa7\u0007\u0004\u0000"+ + "\u0000\u0aa7\u0aa8\u0007\u0007\u0000\u0000\u0aa8\u0aa9\u0007\u000b\u0000"+ + "\u0000\u0aa9\u0aaa\u0007\u000e\u0000\u0000\u0aaa\u0aab\u0007\b\u0000\u0000"+ + "\u0aab\u0aac\u0007\u000f\u0000\u0000\u0aac\u0aad\u0007\u0010\u0000\u0000"+ + "\u0aad\u0aae\u0007\u0007\u0000\u0000\u0aae^\u0001\u0000\u0000\u0000\u0aaf"+ + "\u0ab0\u0007\u0004\u0000\u0000\u0ab0\u0ab1\u0007\u0007\u0000\u0000\u0ab1"+ + "\u0ab2\u0007\u0006\u0000\u0000\u0ab2\u0ab3\u0007\u0007\u0000\u0000\u0ab3"+ + "\u0ab4\u0007\b\u0000\u0000\u0ab4\u0ab5\u0007\u0017\u0000\u0000\u0ab5\u0ab6"+ + "\u0007\u000f\u0000\u0000\u0ab6\u0ab7\u0007\f\u0000\u0000\u0ab7\u0ab8\u0007"+ + "\u000f\u0000\u0000\u0ab8\u0ab9\u0007\u000b\u0000\u0000\u0ab9\u0aba\u0007"+ + "\u0006\u0000\u0000\u0aba\u0abb\u0007\u000f\u0000\u0000\u0abb\u0abc\u0007"+ + "\u000e\u0000\u0000\u0abc`\u0001\u0000\u0000\u0000\u0abd\u0abe\u0007\u0004"+ + "\u0000\u0000\u0abe\u0abf\u0007\u000f\u0000\u0000\u0abf\u0ac0\u0007\u0003"+ + "\u0000\u0000\u0ac0\u0ac1\u0007\u0016\u0000\u0000\u0ac1\u0ac2\u0007\f\u0000"+ + "\u0000\u0ac2\u0ac3\u0007\u0013\u0000\u0000\u0ac3\u0ac4\u0007\u000b\u0000"+ + "\u0000\u0ac4\u0ac5\u0007\u0006\u0000\u0000\u0ac5\u0ac6\u0007\u000f\u0000"+ + "\u0000\u0ac6\u0ac7\u0007\u000e\u0000\u0000\u0ac7\u0ac8\u0007\u000b\u0000"+ + "\u0000\u0ac8b\u0001\u0000\u0000\u0000\u0ac9\u0aca\u0007\u0004\u0000\u0000"+ + "\u0aca\u0acb\u0007\u000f\u0000\u0000\u0acb\u0acc\u0007\u000b\u0000\u0000"+ + "\u0acc\u0acd\u0007\u0006\u0000\u0000\u0acd\u0ace\u0007\u000f\u0000\u0000"+ + "\u0ace\u0acf\u0007\f\u0000\u0000\u0acf\u0ad0\u0007\u000e\u0000\u0000\u0ad0"+ + "\u0ad1\u0007\u0006\u0000\u0000\u0ad1d\u0001\u0000\u0000\u0000\u0ad2\u0ad3"+ + "\u0007\u0004\u0000\u0000\u0ad3\u0ad4\u0007\u000f\u0000\u0000\u0ad4\u0ad5"+ + "\u0007\u000b\u0000\u0000\u0ad5\u0ad6\u0007\u0006\u0000\u0000\u0ad6\u0ad7"+ + "\u0007\u000f\u0000\u0000\u0ad7\u0ad8\u0007\f\u0000\u0000\u0ad8\u0ad9\u0007"+ + "\u000e\u0000\u0000\u0ad9\u0ada\u0007\u0006\u0000\u0000\u0ada\u0adb\u0007"+ + "\b\u0000\u0000\u0adb\u0adc\u0007\u0013\u0000\u0000\u0adc\u0add\u0007\t"+ + "\u0000\u0000\u0addf\u0001\u0000\u0000\u0000\u0ade\u0adf\u0007\u0004\u0000"+ + "\u0000\u0adf\u0ae0\u0007\b\u0000\u0000\u0ae0\u0ae1\u0007\u0013\u0000\u0000"+ + "\u0ae1\u0ae2\u0007\u0019\u0000\u0000\u0ae2h\u0001\u0000\u0000\u0000\u0ae3"+ + "\u0ae4\u0007\u0007\u0000\u0000\u0ae4\u0ae5\u0007\u0003\u0000\u0000\u0ae5"+ + "\u0ae6\u0007\u000e\u0000\u0000\u0ae6\u0ae7\u0007\u0014\u0000\u0000\u0ae7"+ + "j\u0001\u0000\u0000\u0000\u0ae8\u0ae9\u0007\u0007\u0000\u0000\u0ae9\u0aea"+ + "\u0007\u0005\u0000\u0000\u0aea\u0aeb\u0007\u000b\u0000\u0000\u0aeb\u0aec"+ + "\u0007\u0007\u0000\u0000\u0aecl\u0001\u0000\u0000\u0000\u0aed\u0aee\u0007"+ + "\u0007\u0000\u0000\u0aee\u0aef\u0007\u0005\u0000\u0000\u0aef\u0af0\u0007"+ + "\u000b\u0000\u0000\u0af0\u0af1\u0007\u0007\u0000\u0000\u0af1\u0af2\u0007"+ + "\u000f\u0000\u0000\u0af2\u0af3\u0007\u0012\u0000\u0000\u0af3n\u0001\u0000"+ + "\u0000\u0000\u0af4\u0af5\u0007\u0007\u0000\u0000\u0af5\u0af6\u0007\u0017"+ + "\u0000\u0000\u0af6\u0af7\u0007\u0019\u0000\u0000\u0af7\u0af8\u0007\u0006"+ + "\u0000\u0000\u0af8\u0af9\u0007\n\u0000\u0000\u0af9p\u0001\u0000\u0000"+ + "\u0000\u0afa\u0afb\u0007\u0007\u0000\u0000\u0afb\u0afc\u0007\f\u0000\u0000"+ + "\u0afc\u0afd\u0007\u000e\u0000\u0000\u0afd\u0afe\u0007\u0005\u0000\u0000"+ + "\u0afe\u0aff\u0007\u0013\u0000\u0000\u0aff\u0b00\u0007\u000b\u0000\u0000"+ + "\u0b00\u0b01\u0007\u0007\u0000\u0000\u0b01\u0b02\u0007\u0004\u0000\u0000"+ + "\u0b02r\u0001\u0000\u0000\u0000\u0b03\u0b04\u0007\u0007\u0000\u0000\u0b04"+ + "\u0b05\u0007\f\u0000\u0000\u0b05\u0b06\u0007\u0012\u0000\u0000\u0b06\u0b07"+ + "\u0007\u0013\u0000\u0000\u0b07\u0b08\u0007\b\u0000\u0000\u0b08\u0b09\u0007"+ + "\u000e\u0000\u0000\u0b09\u0b0a\u0007\u0007\u0000\u0000\u0b0a\u0b0b\u0007"+ + "\u0004\u0000\u0000\u0b0bt\u0001\u0000\u0000\u0000\u0b0c\u0b0d\u0007\u0007"+ + "\u0000\u0000\u0b0d\u0b0e\u0007\u000b\u0000\u0000\u0b0e\u0b0f\u0007\u000e"+ + "\u0000\u0000\u0b0f\u0b10\u0007\u0003\u0000\u0000\u0b10\u0b11\u0007\u0019"+ + "\u0000\u0000\u0b11\u0b12\u0007\u0007\u0000\u0000\u0b12\u0b13\u0007\u0004"+ + "\u0000\u0000\u0b13v\u0001\u0000\u0000\u0000\u0b14\u0b15\u0007\u0007\u0000"+ + "\u0000\u0b15\u0b16\u0007\u001a\u0000\u0000\u0b16\u0b17\u0007\u000e\u0000"+ + "\u0000\u0b17\u0b18\u0007\u0007\u0000\u0000\u0b18\u0b19\u0007\u0019\u0000"+ + "\u0000\u0b19\u0b1a\u0007\u0006\u0000\u0000\u0b1ax\u0001\u0000\u0000\u0000"+ + "\u0b1b\u0b1c\u0007\u0007\u0000\u0000\u0b1c\u0b1d\u0007\u001a\u0000\u0000"+ + "\u0b1d\u0b1e\u0007\u000f\u0000\u0000\u0b1e\u0b1f\u0007\u000b\u0000\u0000"+ + "\u0b1f\u0b20\u0007\u0006\u0000\u0000\u0b20\u0b21\u0007\u000b\u0000\u0000"+ + "\u0b21z\u0001\u0000\u0000\u0000\u0b22\u0b23\u0007\u0007\u0000\u0000\u0b23"+ + "\u0b24\u0007\u001a\u0000\u0000\u0b24\u0b25\u0007\u000f\u0000\u0000\u0b25"+ + "\u0b26\u0007\u0006\u0000\u0000\u0b26|\u0001\u0000\u0000\u0000\u0b27\u0b28"+ + "\u0007\u0007\u0000\u0000\u0b28\u0b29\u0007\u001a\u0000\u0000\u0b29\u0b2a"+ + "\u0007\u0019\u0000\u0000\u0b2a\u0b2b\u0007\u0005\u0000\u0000\u0b2b\u0b2c"+ + "\u0007\u0003\u0000\u0000\u0b2c\u0b2d\u0007\u000f\u0000\u0000\u0b2d\u0b2e"+ + "\u0007\f\u0000\u0000\u0b2e~\u0001\u0000\u0000\u0000\u0b2f\u0b30\u0007"+ + "\u0012\u0000\u0000\u0b30\u0b31\u0007\u0003\u0000\u0000\u0b31\u0b32\u0007"+ + "\u0005\u0000\u0000\u0b32\u0b33\u0007\u000b\u0000\u0000\u0b33\u0b34\u0007"+ + "\u0007\u0000\u0000\u0b34\u0080\u0001\u0000\u0000\u0000\u0b35\u0b36\u0007"+ + "\u0012\u0000\u0000\u0b36\u0b37\u0007\u0007\u0000\u0000\u0b37\u0b38\u0007"+ + "\u0006\u0000\u0000\u0b38\u0b39\u0007\u000e\u0000\u0000\u0b39\u0b3a\u0007"+ + "\u0014\u0000\u0000\u0b3a\u0082\u0001\u0000\u0000\u0000\u0b3b\u0b3c\u0007"+ + "\u0012\u0000\u0000\u0b3c\u0b3d\u0007\u0013\u0000\u0000\u0b3d\u0b3e\u0007"+ + "\b\u0000\u0000\u0b3e\u0084\u0001\u0000\u0000\u0000\u0b3f\u0b40\u0007\u0012"+ + "\u0000\u0000\u0b40\u0b41\u0007\u0013\u0000\u0000\u0b41\u0b42\u0007\b\u0000"+ + "\u0000\u0b42\u0b43\u0007\u000e\u0000\u0000\u0b43\u0b44\u0007\u0007\u0000"+ + "\u0000\u0b44\u0086\u0001\u0000\u0000\u0000\u0b45\u0b46\u0007\u0012\u0000"+ + "\u0000\u0b46\u0b47\u0007\u0013\u0000\u0000\u0b47\u0b48\u0007\b\u0000\u0000"+ + "\u0b48\u0b49\u0007\u0007\u0000\u0000\u0b49\u0b4a\u0007\u000f\u0000\u0000"+ + "\u0b4a\u0b4b\u0007\u0016\u0000\u0000\u0b4b\u0b4c\u0007\f\u0000\u0000\u0b4c"+ + "\u0088\u0001\u0000\u0000\u0000\u0b4d\u0b4e\u0007\u0012\u0000\u0000\u0b4e"+ + "\u0b4f\u0007\b\u0000\u0000\u0b4f\u0b50\u0007\u0013\u0000\u0000\u0b50\u0b51"+ + "\u0007\u0017\u0000\u0000\u0b51\u008a\u0001\u0000\u0000\u0000\u0b52\u0b53"+ + "\u0007\u0012\u0000\u0000\u0b53\u0b54\u0007\u0011\u0000\u0000\u0b54\u0b55"+ + "\u0007\u0005\u0000\u0000\u0b55\u0b56\u0007\u0005\u0000\u0000\u0b56\u0b57"+ + "\u0007\u0006\u0000\u0000\u0b57\u0b58\u0007\u0007\u0000\u0000\u0b58\u0b59"+ + "\u0007\u001a\u0000\u0000\u0b59\u0b5a\u0007\u0006\u0000\u0000\u0b5a\u008c"+ + "\u0001\u0000\u0000\u0000\u0b5b\u0b5c\u0007\u0016\u0000\u0000\u0b5c\u0b5d"+ + "\u0007\u0007\u0000\u0000\u0b5d\u0b5e\u0007\f\u0000\u0000\u0b5e\u0b5f\u0007"+ + "\u0007\u0000\u0000\u0b5f\u0b60\u0007\b\u0000\u0000\u0b60\u0b61\u0007\u0003"+ + "\u0000\u0000\u0b61\u0b62\u0007\u0006\u0000\u0000\u0b62\u0b63\u0007\u0007"+ + "\u0000\u0000\u0b63\u0b64\u0007\u0004\u0000\u0000\u0b64\u008e\u0001\u0000"+ + "\u0000\u0000\u0b65\u0b66\u0007\u0016\u0000\u0000\u0b66\u0b67\u0007\u0007"+ + "\u0000\u0000\u0b67\u0b68\u0007\u0006\u0000\u0000\u0b68\u0090\u0001\u0000"+ + "\u0000\u0000\u0b69\u0b6a\u0007\u0016\u0000\u0000\u0b6a\u0b6b\u0007\b\u0000"+ + "\u0000\u0b6b\u0b6c\u0007\u0003\u0000\u0000\u0b6c\u0b6d\u0007\f\u0000\u0000"+ + "\u0b6d\u0b6e\u0007\u0006\u0000\u0000\u0b6e\u0092\u0001\u0000\u0000\u0000"+ + "\u0b6f\u0b70\u0007\u0016\u0000\u0000\u0b70\u0b71\u0007\b\u0000\u0000\u0b71"+ + "\u0b72\u0007\u0013\u0000\u0000\u0b72\u0b73\u0007\u0011\u0000\u0000\u0b73"+ + "\u0b74\u0007\u0019\u0000\u0000\u0b74\u0094\u0001\u0000\u0000\u0000\u0b75"+ + "\u0b76\u0007\u0014\u0000\u0000\u0b76\u0b77\u0007\u0003\u0000\u0000\u0b77"+ + "\u0b78\u0007\u0018\u0000\u0000\u0b78\u0b79\u0007\u000f\u0000\u0000\u0b79"+ + "\u0b7a\u0007\f\u0000\u0000\u0b7a\u0b7b\u0007\u0016\u0000\u0000\u0b7b\u0096"+ + "\u0001\u0000\u0000\u0000\u0b7c\u0b7d\u0007\u0014\u0000\u0000\u0b7d\u0b7e"+ + "\u0007\u000f\u0000\u0000\u0b7e\u0b7f\u0007\u0016\u0000\u0000\u0b7f\u0b80"+ + "\u0007\u0014\u0000\u0000\u0b80\u0b81\u0005_\u0000\u0000\u0b81\u0b82\u0007"+ + "\u0019\u0000\u0000\u0b82\u0b83\u0007\b\u0000\u0000\u0b83\u0b84\u0007\u000f"+ + "\u0000\u0000\u0b84\u0b85\u0007\u0013\u0000\u0000\u0b85\u0b86\u0007\b\u0000"+ + "\u0000\u0b86\u0b87\u0007\u000f\u0000\u0000\u0b87\u0b88\u0007\u0006\u0000"+ + "\u0000\u0b88\u0b89\u0007\n\u0000\u0000\u0b89\u0098\u0001\u0000\u0000\u0000"+ + "\u0b8a\u0b8b\u0007\u0014\u0000\u0000\u0b8b\u0b8c\u0007\u000f\u0000\u0000"+ + "\u0b8c\u0b8d\u0007\u000b\u0000\u0000\u0b8d\u0b8e\u0007\u0006\u0000\u0000"+ + "\u0b8e\u0b8f\u0007\u0013\u0000\u0000\u0b8f\u0b90\u0007\u0016\u0000\u0000"+ + "\u0b90\u0b91\u0007\b\u0000\u0000\u0b91\u0b92\u0007\u0003\u0000\u0000\u0b92"+ + "\u0b93\u0007\u0017\u0000\u0000\u0b93\u009a\u0001\u0000\u0000\u0000\u0b94"+ + "\u0b95\u0007\u000f\u0000\u0000\u0b95\u0b96\u0007\u0012\u0000\u0000\u0b96"+ + "\u009c\u0001\u0000\u0000\u0000\u0b97\u0b98\u0007\u000f\u0000\u0000\u0b98"+ + "\u0b99\u0007\u0016\u0000\u0000\u0b99\u0b9a\u0007\f\u0000\u0000\u0b9a\u0b9b"+ + "\u0007\u0013\u0000\u0000\u0b9b\u0b9c\u0007\b\u0000\u0000\u0b9c\u0b9d\u0007"+ + "\u0007\u0000\u0000\u0b9d\u009e\u0001\u0000\u0000\u0000\u0b9e\u0b9f\u0007"+ + "\u000f\u0000\u0000\u0b9f\u0ba0\u0007\u0016\u0000\u0000\u0ba0\u0ba1\u0007"+ + "\f\u0000\u0000\u0ba1\u0ba2\u0007\u0013\u0000\u0000\u0ba2\u0ba3\u0007\b"+ + "\u0000\u0000\u0ba3\u0ba4\u0007\u0007\u0000\u0000\u0ba4\u0ba5\u0007\u0004"+ + "\u0000\u0000\u0ba5\u00a0\u0001\u0000\u0000\u0000\u0ba6\u0ba7\u0007\u000f"+ + "\u0000\u0000\u0ba7\u0ba8\u0007\f\u0000\u0000\u0ba8\u00a2\u0001\u0000\u0000"+ + "\u0000\u0ba9\u0baa\u0007\u000f\u0000\u0000\u0baa\u0bab\u0007\f\u0000\u0000"+ + "\u0bab\u0bac\u0007\u0004\u0000\u0000\u0bac\u0bad\u0007\u0007\u0000\u0000"+ + "\u0bad\u0bae\u0007\u001a\u0000\u0000\u0bae\u00a4\u0001\u0000\u0000\u0000"+ + "\u0baf\u0bb0\u0007\u000f\u0000\u0000\u0bb0\u0bb1\u0007\f\u0000\u0000\u0bb1"+ + "\u0bb2\u0007\u0012\u0000\u0000\u0bb2\u0bb3\u0007\u000f\u0000\u0000\u0bb3"+ + "\u0bb4\u0007\u0005\u0000\u0000\u0bb4\u0bb5\u0007\u0007\u0000\u0000\u0bb5"+ + "\u00a6\u0001\u0000\u0000\u0000\u0bb6\u0bb7\u0007\u000f\u0000\u0000\u0bb7"+ + "\u0bb8\u0007\f\u0000\u0000\u0bb8\u0bb9\u0007\f\u0000\u0000\u0bb9\u0bba"+ + "\u0007\u0007\u0000\u0000\u0bba\u0bbb\u0007\b\u0000\u0000\u0bbb\u00a8\u0001"+ + "\u0000\u0000\u0000\u0bbc\u0bbd\u0007\u000f\u0000\u0000\u0bbd\u0bbe\u0007"+ + "\f\u0000\u0000\u0bbe\u0bbf\u0007\u0013\u0000\u0000\u0bbf\u0bc0\u0007\u0011"+ + "\u0000\u0000\u0bc0\u0bc1\u0007\u0006\u0000\u0000\u0bc1\u00aa\u0001\u0000"+ + "\u0000\u0000\u0bc2\u0bc3\u0007\u000f\u0000\u0000\u0bc3\u0bc4\u0007\f\u0000"+ + "\u0000\u0bc4\u0bc5\u0007\u000b\u0000\u0000\u0bc5\u0bc6\u0007\u0007\u0000"+ + "\u0000\u0bc6\u0bc7\u0007\b\u0000\u0000\u0bc7\u0bc8\u0007\u0006\u0000\u0000"+ + "\u0bc8\u00ac\u0001\u0000\u0000\u0000\u0bc9\u0bca\u0007\u000f\u0000\u0000"+ + "\u0bca\u0bcb\u0007\f\u0000\u0000\u0bcb\u0bcc\u0007\u0006\u0000\u0000\u0bcc"+ + "\u0bcd\u0007\u0007\u0000\u0000\u0bcd\u0bce\u0007\b\u0000\u0000\u0bce\u0bcf"+ + "\u0007\u0018\u0000\u0000\u0bcf\u0bd0\u0007\u0003\u0000\u0000\u0bd0\u0bd1"+ + "\u0007\u0005\u0000\u0000\u0bd1\u00ae\u0001\u0000\u0000\u0000\u0bd2\u0bd3"+ + "\u0007\u000f\u0000\u0000\u0bd3\u0bd4\u0007\f\u0000\u0000\u0bd4\u0bd5\u0007"+ + "\u0006\u0000\u0000\u0bd5\u0bd6\u0007\u0013\u0000\u0000\u0bd6\u00b0\u0001"+ + "\u0000\u0000\u0000\u0bd7\u0bd8\u0007\u000f\u0000\u0000\u0bd8\u0bd9\u0007"+ + "\u000b\u0000\u0000\u0bd9\u00b2\u0001\u0000\u0000\u0000\u0bda\u0bdb\u0007"+ + "\u000f\u0000\u0000\u0bdb\u0bdc\u0007\u0006\u0000\u0000\u0bdc\u0bdd\u0007"+ + "\u0007\u0000\u0000\u0bdd\u0bde\u0007\b\u0000\u0000\u0bde\u0bdf\u0007\u0003"+ + "\u0000\u0000\u0bdf\u0be0\u0007\u0006\u0000\u0000\u0be0\u0be1\u0007\u0007"+ + "\u0000\u0000\u0be1\u00b4\u0001\u0000\u0000\u0000\u0be2\u0be3\u0007\u001b"+ + "\u0000\u0000\u0be3\u0be4\u0007\u0013\u0000\u0000\u0be4\u0be5\u0007\u000f"+ + "\u0000\u0000\u0be5\u0be6\u0007\f\u0000\u0000\u0be6\u00b6\u0001\u0000\u0000"+ + "\u0000\u0be7\u0be8\u0007\u0015\u0000\u0000\u0be8\u0be9\u0007\u0007\u0000"+ + "\u0000\u0be9\u0bea\u0007\n\u0000\u0000\u0bea\u00b8\u0001\u0000\u0000\u0000"+ + "\u0beb\u0bec\u0007\u0015\u0000\u0000\u0bec\u0bed\u0007\u0007\u0000\u0000"+ + "\u0bed\u0bee\u0007\n\u0000\u0000\u0bee\u0bef\u0007\u000b\u0000\u0000\u0bef"+ + "\u00ba\u0001\u0000\u0000\u0000\u0bf0\u0bf1\u0007\u0015\u0000\u0000\u0bf1"+ + "\u0bf2\u0007\u000f\u0000\u0000\u0bf2\u0bf3\u0007\u0005\u0000\u0000\u0bf3"+ + "\u0bf4\u0007\u0005\u0000\u0000\u0bf4\u00bc\u0001\u0000\u0000\u0000\u0bf5"+ + "\u0bf6\u0007\u0005\u0000\u0000\u0bf6\u0bf7\u0007\u0003\u0000\u0000\u0bf7"+ + "\u0bf8\u0007\u0006\u0000\u0000\u0bf8\u0bf9\u0007\u0007\u0000\u0000\u0bf9"+ + "\u0bfa\u0007\b\u0000\u0000\u0bfa\u0bfb\u0007\u0003\u0000\u0000\u0bfb\u0bfc"+ + "\u0007\u0005\u0000\u0000\u0bfc\u00be\u0001\u0000\u0000\u0000\u0bfd\u0bfe"+ + "\u0007\u0005\u0000\u0000\u0bfe\u0bff\u0007\u0007\u0000\u0000\u0bff\u0c00"+ + "\u0007\u0003\u0000\u0000\u0c00\u0c01\u0007\u0004\u0000\u0000\u0c01\u0c02"+ + "\u0007\u000f\u0000\u0000\u0c02\u0c03\u0007\f\u0000\u0000\u0c03\u0c04\u0007"+ + "\u0016\u0000\u0000\u0c04\u00c0\u0001\u0000\u0000\u0000\u0c05\u0c06\u0007"+ + "\u0005\u0000\u0000\u0c06\u0c07\u0007\u0007\u0000\u0000\u0c07\u0c08\u0007"+ + "\u0003\u0000\u0000\u0c08\u0c09\u0007\u0018\u0000\u0000\u0c09\u0c0a\u0007"+ + "\u0007\u0000\u0000\u0c0a\u00c2\u0001\u0000\u0000\u0000\u0c0b\u0c0c\u0007"+ + "\u0005\u0000\u0000\u0c0c\u0c0d\u0007\u0007\u0000\u0000\u0c0d\u0c0e\u0007"+ + "\u0012\u0000\u0000\u0c0e\u0c0f\u0007\u0006\u0000\u0000\u0c0f\u00c4\u0001"+ + "\u0000\u0000\u0000\u0c10\u0c11\u0007\u0005\u0000\u0000\u0c11\u0c12\u0007"+ + "\u000f\u0000\u0000\u0c12\u0c13\u0007\u0015\u0000\u0000\u0c13\u0c14\u0007"+ + "\u0007\u0000\u0000\u0c14\u00c6\u0001\u0000\u0000\u0000\u0c15\u0c16\u0007"+ + "\u0005\u0000\u0000\u0c16\u0c17\u0007\u000f\u0000\u0000\u0c17\u0c18\u0007"+ + "\u0017\u0000\u0000\u0c18\u0c19\u0007\u000f\u0000\u0000\u0c19\u0c1a\u0007"+ + "\u0006\u0000\u0000\u0c1a\u00c8\u0001\u0000\u0000\u0000\u0c1b\u0c1c\u0007"+ + "\u0005\u0000\u0000\u0c1c\u0c1d\u0007\u000f\u0000\u0000\u0c1d\u0c1e\u0007"+ + "\f\u0000\u0000\u0c1e\u0c1f\u0007\u0007\u0000\u0000\u0c1f\u0c20\u0007\u0003"+ + "\u0000\u0000\u0c20\u0c21\u0007\b\u0000\u0000\u0c21\u00ca\u0001\u0000\u0000"+ + "\u0000\u0c22\u0c23\u0007\u0005\u0000\u0000\u0c23\u0c24\u0007\u000f\u0000"+ + "\u0000\u0c24\u0c25\u0007\f\u0000\u0000\u0c25\u0c26\u0007\u0007\u0000\u0000"+ + "\u0c26\u0c27\u0007\u000b\u0000\u0000\u0c27\u00cc\u0001\u0000\u0000\u0000"+ + "\u0c28\u0c29\u0007\u0005\u0000\u0000\u0c29\u0c2a\u0007\u0013\u0000\u0000"+ + "\u0c2a\u0c2b\u0007\u0003\u0000\u0000\u0c2b\u0c2c\u0007\u0004\u0000\u0000"+ + "\u0c2c\u00ce\u0001\u0000\u0000\u0000\u0c2d\u0c2e\u0007\u0005\u0000\u0000"+ + "\u0c2e\u0c2f\u0007\u0013\u0000\u0000\u0c2f\u0c30\u0007\u000e\u0000\u0000"+ + "\u0c30\u0c31\u0007\u0015\u0000\u0000\u0c31\u00d0\u0001\u0000\u0000\u0000"+ + "\u0c32\u0c33\u0007\u0005\u0000\u0000\u0c33\u0c34\u0007\u0013\u0000\u0000"+ + "\u0c34\u0c35\u0007\u000e\u0000\u0000\u0c35\u0c36\u0007\u0015\u0000\u0000"+ + "\u0c36\u0c37\u0007\u0007\u0000\u0000\u0c37\u0c38\u0007\u0004\u0000\u0000"+ + "\u0c38\u00d2\u0001\u0000\u0000\u0000\u0c39\u0c3a\u0007\u0005\u0000\u0000"+ + "\u0c3a\u0c3b\u0007\u0013\u0000\u0000\u0c3b\u0c3c\u0007\u0013\u0000\u0000"+ + "\u0c3c\u0c3d\u0007\u0019\u0000\u0000\u0c3d\u00d4\u0001\u0000\u0000\u0000"+ + "\u0c3e\u0c3f\u0007\u0005\u0000\u0000\u0c3f\u0c40\u0007\u0013\u0000\u0000"+ + "\u0c40\u0c41\u0007\t\u0000\u0000\u0c41\u0c42\u0005_\u0000\u0000\u0c42"+ + "\u0c43\u0007\u0019\u0000\u0000\u0c43\u0c44\u0007\b\u0000\u0000\u0c44\u0c45"+ + "\u0007\u000f\u0000\u0000\u0c45\u0c46\u0007\u0013\u0000\u0000\u0c46\u0c47"+ + "\u0007\b\u0000\u0000\u0c47\u0c48\u0007\u000f\u0000\u0000\u0c48\u0c49\u0007"+ + "\u0006\u0000\u0000\u0c49\u0c4a\u0007\n\u0000\u0000\u0c4a\u00d6\u0001\u0000"+ + "\u0000\u0000\u0c4b\u0c4c\u0007\u0017\u0000\u0000\u0c4c\u0c4d\u0007\u0003"+ + "\u0000\u0000\u0c4d\u0c4e\u0007\u000b\u0000\u0000\u0c4e\u0c4f\u0007\u0006"+ + "\u0000\u0000\u0c4f\u0c50\u0007\u0007\u0000\u0000\u0c50\u0c51\u0007\b\u0000"+ + "\u0000\u0c51\u0c52\u0005_\u0000\u0000\u0c52\u0c53\u0007\u0010\u0000\u0000"+ + "\u0c53\u0c54\u0007\u000f\u0000\u0000\u0c54\u0c55\u0007\f\u0000\u0000\u0c55"+ + "\u0c56\u0007\u0004\u0000\u0000\u0c56\u00d8\u0001\u0000\u0000\u0000\u0c57"+ + "\u0c58\u0007\u0017\u0000\u0000\u0c58\u0c59\u0007\u0003\u0000\u0000\u0c59"+ + "\u0c5a\u0007\u000b\u0000\u0000\u0c5a\u0c5b\u0007\u0006\u0000\u0000\u0c5b"+ + "\u0c5c\u0007\u0007\u0000\u0000\u0c5c\u0c5d\u0007\b\u0000\u0000\u0c5d\u0c5e"+ + "\u0005_\u0000\u0000\u0c5e\u0c5f\u0007\u000b\u0000\u0000\u0c5f\u0c60\u0007"+ + "\u000b\u0000\u0000\u0c60\u0c61\u0007\u0005\u0000\u0000\u0c61\u0c62\u0005"+ + "_\u0000\u0000\u0c62\u0c63\u0007\u0018\u0000\u0000\u0c63\u0c64\u0007\u0007"+ + "\u0000\u0000\u0c64\u0c65\u0007\b\u0000\u0000\u0c65\u0c66\u0007\u000f\u0000"+ + "\u0000\u0c66\u0c67\u0007\u0012\u0000\u0000\u0c67\u0c68\u0007\n\u0000\u0000"+ + "\u0c68\u0c69\u0005_\u0000\u0000\u0c69\u0c6a\u0007\u000b\u0000\u0000\u0c6a"+ + "\u0c6b\u0007\u0007\u0000\u0000\u0c6b\u0c6c\u0007\b\u0000\u0000\u0c6c\u0c6d"+ + "\u0007\u0018\u0000\u0000\u0c6d\u0c6e\u0007\u0007\u0000\u0000\u0c6e\u0c6f"+ + "\u0007\b\u0000\u0000\u0c6f\u0c70\u0005_\u0000\u0000\u0c70\u0c71\u0007"+ + "\u000e\u0000\u0000\u0c71\u0c72\u0007\u0007\u0000\u0000\u0c72\u0c73\u0007"+ + "\b\u0000\u0000\u0c73\u0c74\u0007\u0006\u0000\u0000\u0c74\u00da\u0001\u0000"+ + "\u0000\u0000\u0c75\u0c76\u0007\u0017\u0000\u0000\u0c76\u0c77\u0007\u0003"+ + "\u0000\u0000\u0c77\u0c78\u0007\u0006\u0000\u0000\u0c78\u0c79\u0007\u000e"+ + "\u0000\u0000\u0c79\u0c7a\u0007\u0014\u0000\u0000\u0c7a\u00dc\u0001\u0000"+ + "\u0000\u0000\u0c7b\u0c7c\u0007\u0017\u0000\u0000\u0c7c\u0c7d\u0007\u0003"+ + "\u0000\u0000\u0c7d\u0c7e\u0007\u001a\u0000\u0000\u0c7e\u0c7f\u0007\u0018"+ + "\u0000\u0000\u0c7f\u0c80\u0007\u0003\u0000\u0000\u0c80\u0c81\u0007\u0005"+ + "\u0000\u0000\u0c81\u0c82\u0007\u0011\u0000\u0000\u0c82\u0c83\u0007\u0007"+ + "\u0000\u0000\u0c83\u00de\u0001\u0000\u0000\u0000\u0c84\u0c85\u0007\u0017"+ + "\u0000\u0000\u0c85\u0c86\u0007\u000f\u0000\u0000\u0c86\u0c87\u0007\f\u0000"+ + "\u0000\u0c87\u0c88\u0007\u0018\u0000\u0000\u0c88\u0c89\u0007\u0003\u0000"+ + "\u0000\u0c89\u0c8a\u0007\u0005\u0000\u0000\u0c8a\u0c8b\u0007\u0011\u0000"+ + "\u0000\u0c8b\u0c8c\u0007\u0007\u0000\u0000\u0c8c\u00e0\u0001\u0000\u0000"+ + "\u0000\u0c8d\u0c8e\u0007\u0017\u0000\u0000\u0c8e\u0c8f\u0007\u0013\u0000"+ + "\u0000\u0c8f\u0c90\u0007\u0004\u0000\u0000\u0c90\u0c91\u0007\u000f\u0000"+ + "\u0000\u0c91\u0c92\u0007\u0012\u0000\u0000\u0c92\u0c93\u0007\u000f\u0000"+ + "\u0000\u0c93\u0c94\u0007\u0007\u0000\u0000\u0c94\u0c95\u0007\u000b\u0000"+ + "\u0000\u0c95\u00e2\u0001\u0000\u0000\u0000\u0c96\u0c97\u0007\f\u0000\u0000"+ + "\u0c97\u0c98\u0007\u0003\u0000\u0000\u0c98\u0c99\u0007\u0006\u0000\u0000"+ + "\u0c99\u0c9a\u0007\u0011\u0000\u0000\u0c9a\u0c9b\u0007\b\u0000\u0000\u0c9b"+ + "\u0c9c\u0007\u0003\u0000\u0000\u0c9c\u0c9d\u0007\u0005\u0000\u0000\u0c9d"+ + "\u00e4\u0001\u0000\u0000\u0000\u0c9e\u0c9f\u0007\f\u0000\u0000\u0c9f\u0ca0"+ + "\u0007\u0013\u0000\u0000\u0ca0\u0ca1\u0007\u0006\u0000\u0000\u0ca1\u00e6"+ + "\u0001\u0000\u0000\u0000\u0ca2\u0ca3\u0007\f\u0000\u0000\u0ca3\u0ca4\u0007"+ + "\u0013\u0000\u0000\u0ca4\u0ca5\u0005_\u0000\u0000\u0ca5\u0ca6\u0007\t"+ + "\u0000\u0000\u0ca6\u0ca7\u0007\b\u0000\u0000\u0ca7\u0ca8\u0007\u000f\u0000"+ + "\u0000\u0ca8\u0ca9\u0007\u0006\u0000\u0000\u0ca9\u0caa\u0007\u0007\u0000"+ + "\u0000\u0caa\u0cab\u0005_\u0000\u0000\u0cab\u0cac\u0007\u0006\u0000\u0000"+ + "\u0cac\u0cad\u0007\u0013\u0000\u0000\u0cad\u0cae\u0005_\u0000\u0000\u0cae"+ + "\u0caf\u0007\u0010\u0000\u0000\u0caf\u0cb0\u0007\u000f\u0000\u0000\u0cb0"+ + "\u0cb1\u0007\f\u0000\u0000\u0cb1\u0cb2\u0007\u0005\u0000\u0000\u0cb2\u0cb3"+ + "\u0007\u0013\u0000\u0000\u0cb3\u0cb4\u0007\u0016\u0000\u0000\u0cb4\u00e8"+ + "\u0001\u0000\u0000\u0000\u0cb5\u0cb6\u0007\f\u0000\u0000\u0cb6\u0cb7\u0007"+ + "\u0011\u0000\u0000\u0cb7\u0cb8\u0007\u0005\u0000\u0000\u0cb8\u0cb9\u0007"+ + "\u0005\u0000\u0000\u0cb9\u00ea\u0001\u0000\u0000\u0000\u0cba\u0cbb\u0007"+ + "\f\u0000\u0000\u0cbb\u0cbc\u0007\u0011\u0000\u0000\u0cbc\u0cbd\u0007\u0017"+ + "\u0000\u0000\u0cbd\u0cbe\u0007\u0010\u0000\u0000\u0cbe\u0cbf\u0007\u0007"+ + "\u0000\u0000\u0cbf\u0cc0\u0007\b\u0000\u0000\u0cc0\u00ec\u0001\u0000\u0000"+ + "\u0000\u0cc1\u0cc2\u0007\u0013\u0000\u0000\u0cc2\u0cc3\u0007\f\u0000\u0000"+ + "\u0cc3\u00ee\u0001\u0000\u0000\u0000\u0cc4\u0cc5\u0007\u0013\u0000\u0000"+ + "\u0cc5\u0cc6\u0007\u0019\u0000\u0000\u0cc6\u0cc7\u0007\u0006\u0000\u0000"+ + "\u0cc7\u0cc8\u0007\u000f\u0000\u0000\u0cc8\u0cc9\u0007\u0017\u0000\u0000"+ + "\u0cc9\u0cca\u0007\u000f\u0000\u0000\u0cca\u0ccb\u0007\r\u0000\u0000\u0ccb"+ + "\u0ccc\u0007\u0007\u0000\u0000\u0ccc\u00f0\u0001\u0000\u0000\u0000\u0ccd"+ + "\u0cce\u0007\u0013\u0000\u0000\u0cce\u0ccf\u0007\u0019\u0000\u0000\u0ccf"+ + "\u0cd0\u0007\u0006\u0000\u0000\u0cd0\u0cd1\u0007\u000f\u0000\u0000\u0cd1"+ + "\u0cd2\u0007\u0013\u0000\u0000\u0cd2\u0cd3\u0007\f\u0000\u0000\u0cd3\u00f2"+ + "\u0001\u0000\u0000\u0000\u0cd4\u0cd5\u0007\u0013\u0000\u0000\u0cd5\u0cd6"+ + "\u0007\u0019\u0000\u0000\u0cd6\u0cd7\u0007\u0006\u0000\u0000\u0cd7\u0cd8"+ + "\u0007\u000f\u0000\u0000\u0cd8\u0cd9\u0007\u0013\u0000\u0000\u0cd9\u0cda"+ + "\u0007\f\u0000\u0000\u0cda\u0cdb\u0007\u0003\u0000\u0000\u0cdb\u0cdc\u0007"+ + "\u0005\u0000\u0000\u0cdc\u00f4\u0001\u0000\u0000\u0000\u0cdd\u0cde\u0007"+ + "\u0013\u0000\u0000\u0cde\u0cdf\u0007\u0019\u0000\u0000\u0cdf\u0ce0\u0007"+ + "\u0006\u0000\u0000\u0ce0\u0ce1\u0007\u000f\u0000\u0000\u0ce1\u0ce2\u0007"+ + "\u0013\u0000\u0000\u0ce2\u0ce3\u0007\f\u0000\u0000\u0ce3\u0ce4\u0007\u0003"+ + "\u0000\u0000\u0ce4\u0ce5\u0007\u0005\u0000\u0000\u0ce5\u0ce6\u0007\u0005"+ + "\u0000\u0000\u0ce6\u0ce7\u0007\n\u0000\u0000\u0ce7\u00f6\u0001\u0000\u0000"+ + "\u0000\u0ce8\u0ce9\u0007\u0013\u0000\u0000\u0ce9\u0cea\u0007\b\u0000\u0000"+ + "\u0cea\u00f8\u0001\u0000\u0000\u0000\u0ceb\u0cec\u0007\u0013\u0000\u0000"+ + "\u0cec\u0ced\u0007\b\u0000\u0000\u0ced\u0cee\u0007\u0004\u0000\u0000\u0cee"+ + "\u0cef\u0007\u0007\u0000\u0000\u0cef\u0cf0\u0007\b\u0000\u0000\u0cf0\u00fa"+ + "\u0001\u0000\u0000\u0000\u0cf1\u0cf2\u0007\u0013\u0000\u0000\u0cf2\u0cf3"+ + "\u0007\u0011\u0000\u0000\u0cf3\u0cf4\u0007\u0006\u0000\u0000\u0cf4\u00fc"+ + "\u0001\u0000\u0000\u0000\u0cf5\u0cf6\u0007\u0013\u0000\u0000\u0cf6\u0cf7"+ + "\u0007\u0011\u0000\u0000\u0cf7\u0cf8\u0007\u0006\u0000\u0000\u0cf8\u0cf9"+ + "\u0007\u0007\u0000\u0000\u0cf9\u0cfa\u0007\b\u0000\u0000\u0cfa\u00fe\u0001"+ + "\u0000\u0000\u0000\u0cfb\u0cfc\u0007\u0013\u0000\u0000\u0cfc\u0cfd\u0007"+ + "\u0011\u0000\u0000\u0cfd\u0cfe\u0007\u0006\u0000\u0000\u0cfe\u0cff\u0007"+ + "\u0012\u0000\u0000\u0cff\u0d00\u0007\u000f\u0000\u0000\u0d00\u0d01\u0007"+ + "\u0005\u0000\u0000\u0d01\u0d02\u0007\u0007\u0000\u0000\u0d02\u0100\u0001"+ + "\u0000\u0000\u0000\u0d03\u0d04\u0007\u0013\u0000\u0000\u0d04\u0d05\u0007"+ + "\u0018\u0000\u0000\u0d05\u0d06\u0007\u0007\u0000\u0000\u0d06\u0d07\u0007"+ + "\b\u0000\u0000\u0d07\u0102\u0001\u0000\u0000\u0000\u0d08\u0d09\u0007\u0019"+ + "\u0000\u0000\u0d09\u0d0a\u0007\u0003\u0000\u0000\u0d0a\u0d0b\u0007\b\u0000"+ + "\u0000\u0d0b\u0d0c\u0007\u0006\u0000\u0000\u0d0c\u0d0d\u0007\u000f\u0000"+ + "\u0000\u0d0d\u0d0e\u0007\u0006\u0000\u0000\u0d0e\u0d0f\u0007\u000f\u0000"+ + "\u0000\u0d0f\u0d10\u0007\u0013\u0000\u0000\u0d10\u0d11\u0007\f\u0000\u0000"+ + "\u0d11\u0104\u0001\u0000\u0000\u0000\u0d12\u0d13\u0007\u0019\u0000\u0000"+ + "\u0d13\u0d14\u0007\b\u0000\u0000\u0d14\u0d15\u0007\u000f\u0000\u0000\u0d15"+ + "\u0d16\u0007\u0017\u0000\u0000\u0d16\u0d17\u0007\u0003\u0000\u0000\u0d17"+ + "\u0d18\u0007\b\u0000\u0000\u0d18\u0d19\u0007\n\u0000\u0000\u0d19\u0106"+ + "\u0001\u0000\u0000\u0000\u0d1a\u0d1b\u0007\u0019\u0000\u0000\u0d1b\u0d1c"+ + "\u0007\b\u0000\u0000\u0d1c\u0d1d\u0007\u0013\u0000\u0000\u0d1d\u0d1e\u0007"+ + "\u000e\u0000\u0000\u0d1e\u0d1f\u0007\u0007\u0000\u0000\u0d1f\u0d20\u0007"+ + "\u0004\u0000\u0000\u0d20\u0d21\u0007\u0011\u0000\u0000\u0d21\u0d22\u0007"+ + "\b\u0000\u0000\u0d22\u0d23\u0007\u0007\u0000\u0000\u0d23\u0108\u0001\u0000"+ + "\u0000\u0000\u0d24\u0d25\u0007\u0019\u0000\u0000\u0d25\u0d26\u0007\u0011"+ + "\u0000\u0000\u0d26\u0d27\u0007\b\u0000\u0000\u0d27\u0d28\u0007\u0016\u0000"+ + "\u0000\u0d28\u0d29\u0007\u0007\u0000\u0000\u0d29\u010a\u0001\u0000\u0000"+ + "\u0000\u0d2a\u0d2b\u0007\b\u0000\u0000\u0d2b\u0d2c\u0007\u0003\u0000\u0000"+ + "\u0d2c\u0d2d\u0007\f\u0000\u0000\u0d2d\u0d2e\u0007\u0016\u0000\u0000\u0d2e"+ + "\u0d2f\u0007\u0007\u0000\u0000\u0d2f\u010c\u0001\u0000\u0000\u0000\u0d30"+ + "\u0d31\u0007\b\u0000\u0000\u0d31\u0d32\u0007\u0007\u0000\u0000\u0d32\u0d33"+ + "\u0007\u0003\u0000\u0000\u0d33\u0d34\u0007\u0004\u0000\u0000\u0d34\u010e"+ + "\u0001\u0000\u0000\u0000\u0d35\u0d36\u0007\b\u0000\u0000\u0d36\u0d37\u0007"+ + "\u0007\u0000\u0000\u0d37\u0d38\u0007\u0003\u0000\u0000\u0d38\u0d39\u0007"+ + "\u0004\u0000\u0000\u0d39\u0d3a\u0007\u000b\u0000\u0000\u0d3a\u0110\u0001"+ + "\u0000\u0000\u0000\u0d3b\u0d3c\u0007\b\u0000\u0000\u0d3c\u0d3d\u0007\u0007"+ + "\u0000\u0000\u0d3d\u0d3e\u0007\u0012\u0000\u0000\u0d3e\u0d3f\u0007\u0007"+ + "\u0000\u0000\u0d3f\u0d40\u0007\b\u0000\u0000\u0d40\u0d41\u0007\u0007\u0000"+ + "\u0000\u0d41\u0d42\u0007\f\u0000\u0000\u0d42\u0d43\u0007\u000e\u0000\u0000"+ + "\u0d43\u0d44\u0007\u0007\u0000\u0000\u0d44\u0d45\u0007\u000b\u0000\u0000"+ + "\u0d45\u0112\u0001\u0000\u0000\u0000\u0d46\u0d47\u0007\b\u0000\u0000\u0d47"+ + "\u0d48\u0007\u0007\u0000\u0000\u0d48\u0d49\u0007\u0016\u0000\u0000\u0d49"+ + "\u0d4a\u0007\u0007\u0000\u0000\u0d4a\u0d4b\u0007\u001a\u0000\u0000\u0d4b"+ + "\u0d4c\u0007\u0019\u0000\u0000\u0d4c\u0114\u0001\u0000\u0000\u0000\u0d4d"+ + "\u0d4e\u0007\b\u0000\u0000\u0d4e\u0d4f\u0007\u0007\u0000\u0000\u0d4f\u0d50"+ + "\u0007\u0005\u0000\u0000\u0d50\u0d51\u0007\u0007\u0000\u0000\u0d51\u0d52"+ + "\u0007\u0003\u0000\u0000\u0d52\u0d53\u0007\u000b\u0000\u0000\u0d53\u0d54"+ + "\u0007\u0007\u0000\u0000\u0d54\u0116\u0001\u0000\u0000\u0000\u0d55\u0d56"+ + "\u0007\b\u0000\u0000\u0d56\u0d57\u0007\u0007\u0000\u0000\u0d57\u0d58\u0007"+ + "\f\u0000\u0000\u0d58\u0d59\u0007\u0003\u0000\u0000\u0d59\u0d5a\u0007\u0017"+ + "\u0000\u0000\u0d5a\u0d5b\u0007\u0007\u0000\u0000\u0d5b\u0118\u0001\u0000"+ + "\u0000\u0000\u0d5c\u0d5d\u0007\b\u0000\u0000\u0d5d\u0d5e\u0007\u0007\u0000"+ + "\u0000\u0d5e\u0d5f\u0007\u0019\u0000\u0000\u0d5f\u0d60\u0007\u0007\u0000"+ + "\u0000\u0d60\u0d61\u0007\u0003\u0000\u0000\u0d61\u0d62\u0007\u0006\u0000"+ + "\u0000\u0d62\u011a\u0001\u0000\u0000\u0000\u0d63\u0d64\u0007\b\u0000\u0000"+ + "\u0d64\u0d65\u0007\u0007\u0000\u0000\u0d65\u0d66\u0007\u0019\u0000\u0000"+ + "\u0d66\u0d67\u0007\u0005\u0000\u0000\u0d67\u0d68\u0007\u0003\u0000\u0000"+ + "\u0d68\u0d69\u0007\u000e\u0000\u0000\u0d69\u0d6a\u0007\u0007\u0000\u0000"+ + "\u0d6a\u011c\u0001\u0000\u0000\u0000\u0d6b\u0d6c\u0007\b\u0000\u0000\u0d6c"+ + "\u0d6d\u0007\u0007\u0000\u0000\u0d6d\u0d6e\u0007\u001c\u0000\u0000\u0d6e"+ + "\u0d6f\u0007\u0011\u0000\u0000\u0d6f\u0d70\u0007\u000f\u0000\u0000\u0d70"+ + "\u0d71\u0007\b\u0000\u0000\u0d71\u0d72\u0007\u0007\u0000\u0000\u0d72\u011e"+ + "\u0001\u0000\u0000\u0000\u0d73\u0d74\u0007\b\u0000\u0000\u0d74\u0d75\u0007"+ + "\u0007\u0000\u0000\u0d75\u0d76\u0007\u000b\u0000\u0000\u0d76\u0d77\u0007"+ + "\u000f\u0000\u0000\u0d77\u0d78\u0007\u0016\u0000\u0000\u0d78\u0d79\u0007"+ + "\f\u0000\u0000\u0d79\u0d7a\u0007\u0003\u0000\u0000\u0d7a\u0d7b\u0007\u0005"+ + "\u0000\u0000\u0d7b\u0120\u0001\u0000\u0000\u0000\u0d7c\u0d7d\u0007\b\u0000"+ + "\u0000\u0d7d\u0d7e\u0007\u0007\u0000\u0000\u0d7e\u0d7f\u0007\u000b\u0000"+ + "\u0000\u0d7f\u0d80\u0007\u0006\u0000\u0000\u0d80\u0d81\u0007\b\u0000\u0000"+ + "\u0d81\u0d82\u0007\u000f\u0000\u0000\u0d82\u0d83\u0007\u000e\u0000\u0000"+ + "\u0d83\u0d84\u0007\u0006\u0000\u0000\u0d84\u0122\u0001\u0000\u0000\u0000"+ + "\u0d85\u0d86\u0007\b\u0000\u0000\u0d86\u0d87\u0007\u0007\u0000\u0000\u0d87"+ + "\u0d88\u0007\u0006\u0000\u0000\u0d88\u0d89\u0007\u0003\u0000\u0000\u0d89"+ + "\u0d8a\u0007\u000f\u0000\u0000\u0d8a\u0d8b\u0007\f\u0000\u0000\u0d8b\u0124"+ + "\u0001\u0000\u0000\u0000\u0d8c\u0d8d\u0007\b\u0000\u0000\u0d8d\u0d8e\u0007"+ + "\u0007\u0000\u0000\u0d8e\u0d8f\u0007\u0006\u0000\u0000\u0d8f\u0d90\u0007"+ + "\u0011\u0000\u0000\u0d90\u0d91\u0007\b\u0000\u0000\u0d91\u0d92\u0007\f"+ + "\u0000\u0000\u0d92\u0126\u0001\u0000\u0000\u0000\u0d93\u0d94\u0007\b\u0000"+ + "\u0000\u0d94\u0d95\u0007\u0007\u0000\u0000\u0d95\u0d96\u0007\u0018\u0000"+ + "\u0000\u0d96\u0d97\u0007\u0013\u0000\u0000\u0d97\u0d98\u0007\u0015\u0000"+ + "\u0000\u0d98\u0d99\u0007\u0007\u0000\u0000\u0d99\u0128\u0001\u0000\u0000"+ + "\u0000\u0d9a\u0d9b\u0007\b\u0000\u0000\u0d9b\u0d9c\u0007\u000f\u0000\u0000"+ + "\u0d9c\u0d9d\u0007\u0016\u0000\u0000\u0d9d\u0d9e\u0007\u0014\u0000\u0000"+ + "\u0d9e\u0d9f\u0007\u0006\u0000\u0000\u0d9f\u012a\u0001\u0000\u0000\u0000"+ + "\u0da0\u0da1\u0007\b\u0000\u0000\u0da1\u0da2\u0007\u0005\u0000\u0000\u0da2"+ + "\u0da3\u0007\u000f\u0000\u0000\u0da3\u0da4\u0007\u0015\u0000\u0000\u0da4"+ + "\u0da5\u0007\u0007\u0000\u0000\u0da5\u012c\u0001\u0000\u0000\u0000\u0da6"+ + "\u0da7\u0007\u000b\u0000\u0000\u0da7\u0da8\u0007\u000e\u0000\u0000\u0da8"+ + "\u0da9\u0007\u0014\u0000\u0000\u0da9\u0daa\u0007\u0007\u0000\u0000\u0daa"+ + "\u0dab\u0007\u0017\u0000\u0000\u0dab\u0dac\u0007\u0003\u0000\u0000\u0dac"+ + "\u012e\u0001\u0000\u0000\u0000\u0dad\u0dae\u0007\u000b\u0000\u0000\u0dae"+ + "\u0daf\u0007\u000e\u0000\u0000\u0daf\u0db0\u0007\u0014\u0000\u0000\u0db0"+ + "\u0db1\u0007\u0007\u0000\u0000\u0db1\u0db2\u0007\u0017\u0000\u0000\u0db2"+ + "\u0db3\u0007\u0003\u0000\u0000\u0db3\u0db4\u0007\u000b\u0000\u0000\u0db4"+ + "\u0130\u0001\u0000\u0000\u0000\u0db5\u0db6\u0007\u000b\u0000\u0000\u0db6"+ + "\u0db7\u0007\u0007\u0000\u0000\u0db7\u0db8\u0007\u0005\u0000\u0000\u0db8"+ + "\u0db9\u0007\u0007\u0000\u0000\u0db9\u0dba\u0007\u000e\u0000\u0000\u0dba"+ + "\u0dbb\u0007\u0006\u0000\u0000\u0dbb\u0132\u0001\u0000\u0000\u0000\u0dbc"+ + "\u0dbd\u0007\u000b\u0000\u0000\u0dbd\u0dbe\u0007\u0007\u0000\u0000\u0dbe"+ + "\u0dbf\u0007\u0006\u0000\u0000\u0dbf\u0134\u0001\u0000\u0000\u0000\u0dc0"+ + "\u0dc1\u0007\u000b\u0000\u0000\u0dc1\u0dc2\u0007\u0007\u0000\u0000\u0dc2"+ + "\u0dc3\u0007\u0019\u0000\u0000\u0dc3\u0dc4\u0007\u0003\u0000\u0000\u0dc4"+ + "\u0dc5\u0007\b\u0000\u0000\u0dc5\u0dc6\u0007\u0003\u0000\u0000\u0dc6\u0dc7"+ + "\u0007\u0006\u0000\u0000\u0dc7\u0dc8\u0007\u0013\u0000\u0000\u0dc8\u0dc9"+ + "\u0007\b\u0000\u0000\u0dc9\u0136\u0001\u0000\u0000\u0000\u0dca\u0dcb\u0007"+ + "\u000b\u0000\u0000\u0dcb\u0dcc\u0007\u0014\u0000\u0000\u0dcc\u0dcd\u0007"+ + "\u0013\u0000\u0000\u0dcd\u0dce\u0007\t\u0000\u0000\u0dce\u0138\u0001\u0000"+ + "\u0000\u0000\u0dcf\u0dd0\u0007\u000b\u0000\u0000\u0dd0\u0dd1\u0007\u000f"+ + "\u0000\u0000\u0dd1\u0dd2\u0007\u0016\u0000\u0000\u0dd2\u0dd3\u0007\f\u0000"+ + "\u0000\u0dd3\u0dd4\u0007\u0003\u0000\u0000\u0dd4\u0dd5\u0007\u0005\u0000"+ + "\u0000\u0dd5\u013a\u0001\u0000\u0000\u0000\u0dd6\u0dd7\u0007\u000b\u0000"+ + "\u0000\u0dd7\u0dd8\u0007\u0015\u0000\u0000\u0dd8\u0dd9\u0007\u000f\u0000"+ + "\u0000\u0dd9\u0dda\u0007\u0019\u0000\u0000\u0dda\u013c\u0001\u0000\u0000"+ + "\u0000\u0ddb\u0ddc\u0007\u000b\u0000\u0000\u0ddc\u0ddd\u0007\u0015\u0000"+ + "\u0000\u0ddd\u0dde\u0007\u000f\u0000\u0000\u0dde\u0ddf\u0007\u0019\u0000"+ + "\u0000\u0ddf\u0de0\u0005_\u0000\u0000\u0de0\u0de1\u0007\u001c\u0000\u0000"+ + "\u0de1\u0de2\u0007\u0011\u0000\u0000\u0de2\u0de3\u0007\u0007\u0000\u0000"+ + "\u0de3\u0de4\u0007\b\u0000\u0000\u0de4\u0de5\u0007\n\u0000\u0000\u0de5"+ + "\u0de6\u0005_\u0000\u0000\u0de6\u0de7\u0007\b\u0000\u0000\u0de7\u0de8"+ + "\u0007\u0007\u0000\u0000\u0de8\u0de9\u0007\t\u0000\u0000\u0de9\u0dea\u0007"+ + "\b\u0000\u0000\u0dea\u0deb\u0007\u000f\u0000\u0000\u0deb\u0dec\u0007\u0006"+ + "\u0000\u0000\u0dec\u0ded\u0007\u0007\u0000\u0000\u0ded\u013e\u0001\u0000"+ + "\u0000\u0000\u0dee\u0def\u0007\u000b\u0000\u0000\u0def\u0df0\u0007\u0019"+ + "\u0000\u0000\u0df0\u0df1\u0007\u0003\u0000\u0000\u0df1\u0df2\u0007\u0006"+ + "\u0000\u0000\u0df2\u0df3\u0007\u000f\u0000\u0000\u0df3\u0df4\u0007\u0003"+ + "\u0000\u0000\u0df4\u0df5\u0007\u0005\u0000\u0000\u0df5\u0140\u0001\u0000"+ + "\u0000\u0000\u0df6\u0df7\u0007\u000b\u0000\u0000\u0df7\u0df8\u0007\u001c"+ + "\u0000\u0000\u0df8\u0df9\u0007\u0005\u0000\u0000\u0df9\u0142\u0001\u0000"+ + "\u0000\u0000\u0dfa\u0dfb\u0007\u000b\u0000\u0000\u0dfb\u0dfc\u0007\u001c"+ + "\u0000\u0000\u0dfc\u0dfd\u0007\u0005\u0000\u0000\u0dfd\u0dfe\u0007\u0007"+ + "\u0000\u0000\u0dfe\u0dff\u0007\u001a\u0000\u0000\u0dff\u0e00\u0007\u000e"+ + "\u0000\u0000\u0e00\u0e01\u0007\u0007\u0000\u0000\u0e01\u0e02\u0007\u0019"+ + "\u0000\u0000\u0e02\u0e03\u0007\u0006\u0000\u0000\u0e03\u0e04\u0007\u000f"+ + "\u0000\u0000\u0e04\u0e05\u0007\u0013\u0000\u0000\u0e05\u0e06\u0007\f\u0000"+ + "\u0000\u0e06\u0144\u0001\u0000\u0000\u0000\u0e07\u0e08\u0007\u000b\u0000"+ + "\u0000\u0e08\u0e09\u0007\u001c\u0000\u0000\u0e09\u0e0a\u0007\u0005\u0000"+ + "\u0000\u0e0a\u0e0b\u0007\u000b\u0000\u0000\u0e0b\u0e0c\u0007\u0006\u0000"+ + "\u0000\u0e0c\u0e0d\u0007\u0003\u0000\u0000\u0e0d\u0e0e\u0007\u0006\u0000"+ + "\u0000\u0e0e\u0e0f\u0007\u0007\u0000\u0000\u0e0f\u0146\u0001\u0000\u0000"+ + "\u0000\u0e10\u0e11\u0007\u000b\u0000\u0000\u0e11\u0e12\u0007\u001c\u0000"+ + "\u0000\u0e12\u0e13\u0007\u0005\u0000\u0000\u0e13\u0e14\u0007\t\u0000\u0000"+ + "\u0e14\u0e15\u0007\u0003\u0000\u0000\u0e15\u0e16\u0007\b\u0000\u0000\u0e16"+ + "\u0e17\u0007\f\u0000\u0000\u0e17\u0e18\u0007\u000f\u0000\u0000\u0e18\u0e19"+ + "\u0007\f\u0000\u0000\u0e19\u0e1a\u0007\u0016\u0000\u0000\u0e1a\u0148\u0001"+ + "\u0000\u0000\u0000\u0e1b\u0e1c\u0007\u000b\u0000\u0000\u0e1c\u0e1d\u0007"+ + "\u001c\u0000\u0000\u0e1d\u0e1e\u0007\u0005\u0000\u0000\u0e1e\u0e1f\u0005"+ + "_\u0000\u0000\u0e1f\u0e20\u0007\u0010\u0000\u0000\u0e20\u0e21\u0007\u000f"+ + "\u0000\u0000\u0e21\u0e22\u0007\u0016\u0000\u0000\u0e22\u0e23\u0005_\u0000"+ + "\u0000\u0e23\u0e24\u0007\b\u0000\u0000\u0e24\u0e25\u0007\u0007\u0000\u0000"+ + "\u0e25\u0e26\u0007\u000b\u0000\u0000\u0e26\u0e27\u0007\u0011\u0000\u0000"+ + "\u0e27\u0e28\u0007\u0005\u0000\u0000\u0e28\u0e29\u0007\u0006\u0000\u0000"+ + "\u0e29\u014a\u0001\u0000\u0000\u0000\u0e2a\u0e2b\u0007\u000b\u0000\u0000"+ + "\u0e2b\u0e2c\u0007\u001c\u0000\u0000\u0e2c\u0e2d\u0007\u0005\u0000\u0000"+ + "\u0e2d\u0e2e\u0005_\u0000\u0000\u0e2e\u0e2f\u0007\u000e\u0000\u0000\u0e2f"+ + "\u0e30\u0007\u0003\u0000\u0000\u0e30\u0e31\u0007\u0005\u0000\u0000\u0e31"+ + "\u0e32\u0007\u000e\u0000\u0000\u0e32\u0e33\u0005_\u0000\u0000\u0e33\u0e34"+ + "\u0007\u0012\u0000\u0000\u0e34\u0e35\u0007\u0013\u0000\u0000\u0e35\u0e36"+ + "\u0007\u0011\u0000\u0000\u0e36\u0e37\u0007\f\u0000\u0000\u0e37\u0e38\u0007"+ + "\u0004\u0000\u0000\u0e38\u0e39\u0005_\u0000\u0000\u0e39\u0e3a\u0007\b"+ + "\u0000\u0000\u0e3a\u0e3b\u0007\u0013\u0000\u0000\u0e3b\u0e3c\u0007\t\u0000"+ + "\u0000\u0e3c\u0e3d\u0007\u000b\u0000\u0000\u0e3d\u014c\u0001\u0000\u0000"+ + "\u0000\u0e3e\u0e3f\u0007\u000b\u0000\u0000\u0e3f\u0e40\u0007\u001c\u0000"+ + "\u0000\u0e40\u0e41\u0007\u0005\u0000\u0000\u0e41\u0e42\u0005_\u0000\u0000"+ + "\u0e42\u0e43\u0007\u000b\u0000\u0000\u0e43\u0e44\u0007\u0017\u0000\u0000"+ + "\u0e44\u0e45\u0007\u0003\u0000\u0000\u0e45\u0e46\u0007\u0005\u0000\u0000"+ + "\u0e46\u0e47\u0007\u0005\u0000\u0000\u0e47\u0e48\u0005_\u0000\u0000\u0e48"+ + "\u0e49\u0007\b\u0000\u0000\u0e49\u0e4a\u0007\u0007\u0000\u0000\u0e4a\u0e4b"+ + "\u0007\u000b\u0000\u0000\u0e4b\u0e4c\u0007\u0011\u0000\u0000\u0e4c\u0e4d"+ + "\u0007\u0005\u0000\u0000\u0e4d\u0e4e\u0007\u0006\u0000\u0000\u0e4e\u014e"+ + "\u0001\u0000\u0000\u0000\u0e4f\u0e50\u0007\u000b\u0000\u0000\u0e50\u0e51"+ + "\u0007\u000b\u0000\u0000\u0e51\u0e52\u0007\u0005\u0000\u0000\u0e52\u0150"+ + "\u0001\u0000\u0000\u0000\u0e53\u0e54\u0007\u000b\u0000\u0000\u0e54\u0e55"+ + "\u0007\u0006\u0000\u0000\u0e55\u0e56\u0007\u0003\u0000\u0000\u0e56\u0e57"+ + "\u0007\u000e\u0000\u0000\u0e57\u0e58\u0007\u0015\u0000\u0000\u0e58\u0e59"+ + "\u0007\u0007\u0000\u0000\u0e59\u0e5a\u0007\u0004\u0000\u0000\u0e5a\u0152"+ + "\u0001\u0000\u0000\u0000\u0e5b\u0e5c\u0007\u000b\u0000\u0000\u0e5c\u0e5d"+ + "\u0007\u0006\u0000\u0000\u0e5d\u0e5e\u0007\u0003\u0000\u0000\u0e5e\u0e5f"+ + "\u0007\b\u0000\u0000\u0e5f\u0e60\u0007\u0006\u0000\u0000\u0e60\u0e61\u0007"+ + "\u000f\u0000\u0000\u0e61\u0e62\u0007\f\u0000\u0000\u0e62\u0e63\u0007\u0016"+ + "\u0000\u0000\u0e63\u0154\u0001\u0000\u0000\u0000\u0e64\u0e65\u0007\u000b"+ + "\u0000\u0000\u0e65\u0e66\u0007\u0006\u0000\u0000\u0e66\u0e67\u0007\u0003"+ + "\u0000\u0000\u0e67\u0e68\u0007\u0006\u0000\u0000\u0e68\u0e69\u0007\u0007"+ + "\u0000\u0000\u0e69\u0e6a\u0007\u0017\u0000\u0000\u0e6a\u0e6b\u0007\u0007"+ + "\u0000\u0000\u0e6b\u0e6c\u0007\f\u0000\u0000\u0e6c\u0e6d\u0007\u0006\u0000"+ + "\u0000\u0e6d\u0156\u0001\u0000\u0000\u0000\u0e6e\u0e6f\u0007\u000b\u0000"+ + "\u0000\u0e6f\u0e70\u0007\u0006\u0000\u0000\u0e70\u0e71\u0007\b\u0000\u0000"+ + "\u0e71\u0e72\u0007\u0003\u0000\u0000\u0e72\u0e73\u0007\u000f\u0000\u0000"+ + "\u0e73\u0e74\u0007\u0016\u0000\u0000\u0e74\u0e75\u0007\u0014\u0000\u0000"+ + "\u0e75\u0e76\u0007\u0006\u0000\u0000\u0e76\u0e77\u0005_\u0000\u0000\u0e77"+ + "\u0e78\u0007\u001b\u0000\u0000\u0e78\u0e79\u0007\u0013\u0000\u0000\u0e79"+ + "\u0e7a\u0007\u000f\u0000\u0000\u0e7a\u0e7b\u0007\f\u0000\u0000\u0e7b\u0158"+ + "\u0001\u0000\u0000\u0000\u0e7c\u0e7d\u0007\u0006\u0000\u0000\u0e7d\u0e7e"+ + "\u0007\u0003\u0000\u0000\u0e7e\u0e7f\u0007\u0010\u0000\u0000\u0e7f\u0e80"+ + "\u0007\u0005\u0000\u0000\u0e80\u0e81\u0007\u0007\u0000\u0000\u0e81\u015a"+ + "\u0001\u0000\u0000\u0000\u0e82\u0e83\u0007\u0006\u0000\u0000\u0e83\u0e84"+ + "\u0007\u0007\u0000\u0000\u0e84\u0e85\u0007\b\u0000\u0000\u0e85\u0e86\u0007"+ + "\u0017\u0000\u0000\u0e86\u0e87\u0007\u000f\u0000\u0000\u0e87\u0e88\u0007"+ + "\f\u0000\u0000\u0e88\u0e89\u0007\u0003\u0000\u0000\u0e89\u0e8a\u0007\u0006"+ + "\u0000\u0000\u0e8a\u0e8b\u0007\u0007\u0000\u0000\u0e8b\u0e8c\u0007\u0004"+ + "\u0000\u0000\u0e8c\u015c\u0001\u0000\u0000\u0000\u0e8d\u0e8e\u0007\u0006"+ + "\u0000\u0000\u0e8e\u0e8f\u0007\u0014\u0000\u0000\u0e8f\u0e90\u0007\u0007"+ + "\u0000\u0000\u0e90\u0e91\u0007\f\u0000\u0000\u0e91\u015e\u0001\u0000\u0000"+ + "\u0000\u0e92\u0e93\u0007\u0006\u0000\u0000\u0e93\u0e94\u0007\u0013\u0000"+ + "\u0000\u0e94\u0160\u0001\u0000\u0000\u0000\u0e95\u0e96\u0007\u0006\u0000"+ + "\u0000\u0e96\u0e97\u0007\b\u0000\u0000\u0e97\u0e98\u0007\u0003\u0000\u0000"+ + "\u0e98\u0e99\u0007\u000f\u0000\u0000\u0e99\u0e9a\u0007\u0005\u0000\u0000"+ + "\u0e9a\u0e9b\u0007\u000f\u0000\u0000\u0e9b\u0e9c\u0007\f\u0000\u0000\u0e9c"+ + "\u0e9d\u0007\u0016\u0000\u0000\u0e9d\u0162\u0001\u0000\u0000\u0000\u0e9e"+ + "\u0e9f\u0007\u0006\u0000\u0000\u0e9f\u0ea0\u0007\b\u0000\u0000\u0ea0\u0ea1"+ + "\u0007\u000f\u0000\u0000\u0ea1\u0ea2\u0007\u0016\u0000\u0000\u0ea2\u0ea3"+ + "\u0007\u0016\u0000\u0000\u0ea3\u0ea4\u0007\u0007\u0000\u0000\u0ea4\u0ea5"+ + "\u0007\b\u0000\u0000\u0ea5\u0164\u0001\u0000\u0000\u0000\u0ea6\u0ea7\u0007"+ + "\u0006\u0000\u0000\u0ea7\u0ea8\u0007\b\u0000\u0000\u0ea8\u0ea9\u0007\u0011"+ + "\u0000\u0000\u0ea9\u0eaa\u0007\u0007\u0000\u0000\u0eaa\u0166\u0001\u0000"+ + "\u0000\u0000\u0eab\u0eac\u0007\u0011\u0000\u0000\u0eac\u0ead\u0007\f\u0000"+ + "\u0000\u0ead\u0eae\u0007\u0004\u0000\u0000\u0eae\u0eaf\u0007\u0013\u0000"+ + "\u0000\u0eaf\u0168\u0001\u0000\u0000\u0000\u0eb0\u0eb1\u0007\u0011\u0000"+ + "\u0000\u0eb1\u0eb2\u0007\f\u0000\u0000\u0eb2\u0eb3\u0007\u000f\u0000\u0000"+ + "\u0eb3\u0eb4\u0007\u0013\u0000\u0000\u0eb4\u0eb5\u0007\f\u0000\u0000\u0eb5"+ + "\u016a\u0001\u0000\u0000\u0000\u0eb6\u0eb7\u0007\u0011\u0000\u0000\u0eb7"+ + "\u0eb8\u0007\f\u0000\u0000\u0eb8\u0eb9\u0007\u000f\u0000\u0000\u0eb9\u0eba"+ + "\u0007\u001c\u0000\u0000\u0eba\u0ebb\u0007\u0011\u0000\u0000\u0ebb\u0ebc"+ + "\u0007\u0007\u0000\u0000\u0ebc\u016c\u0001\u0000\u0000\u0000\u0ebd\u0ebe"+ + "\u0007\u0011\u0000\u0000\u0ebe\u0ebf\u0007\f\u0000\u0000\u0ebf\u0ec0\u0007"+ + "\u0005\u0000\u0000\u0ec0\u0ec1\u0007\u0013\u0000\u0000\u0ec1\u0ec2\u0007"+ + "\u000e\u0000\u0000\u0ec2\u0ec3\u0007\u0015\u0000\u0000\u0ec3\u016e\u0001"+ + "\u0000\u0000\u0000\u0ec4\u0ec5\u0007\u0011\u0000\u0000\u0ec5\u0ec6\u0007"+ + "\f\u0000\u0000\u0ec6\u0ec7\u0007\u000b\u0000\u0000\u0ec7\u0ec8\u0007\u000f"+ + "\u0000\u0000\u0ec8\u0ec9\u0007\u0016\u0000\u0000\u0ec9\u0eca\u0007\f\u0000"+ + "\u0000\u0eca\u0ecb\u0007\u0007\u0000\u0000\u0ecb\u0ecc\u0007\u0004\u0000"+ + "\u0000\u0ecc\u0170\u0001\u0000\u0000\u0000\u0ecd\u0ece\u0007\u0011\u0000"+ + "\u0000\u0ece\u0ecf\u0007\u0019\u0000\u0000\u0ecf\u0ed0\u0007\u0004\u0000"+ + "\u0000\u0ed0\u0ed1\u0007\u0003\u0000\u0000\u0ed1\u0ed2\u0007\u0006\u0000"+ + "\u0000\u0ed2\u0ed3\u0007\u0007\u0000\u0000\u0ed3\u0172\u0001\u0000\u0000"+ + "\u0000\u0ed4\u0ed5\u0007\u0011\u0000\u0000\u0ed5\u0ed6\u0007\u000b\u0000"+ + "\u0000\u0ed6\u0ed7\u0007\u0003\u0000\u0000\u0ed7\u0ed8\u0007\u0016\u0000"+ + "\u0000\u0ed8\u0ed9\u0007\u0007\u0000\u0000\u0ed9\u0174\u0001\u0000\u0000"+ + "\u0000\u0eda\u0edb\u0007\u0011\u0000\u0000\u0edb\u0edc\u0007\u000b\u0000"+ + "\u0000\u0edc\u0edd\u0007\u0007\u0000\u0000\u0edd\u0176\u0001\u0000\u0000"+ + "\u0000\u0ede\u0edf\u0007\u0011\u0000\u0000\u0edf\u0ee0\u0007\u000b\u0000"+ + "\u0000\u0ee0\u0ee1\u0007\u000f\u0000\u0000\u0ee1\u0ee2\u0007\f\u0000\u0000"+ + "\u0ee2\u0ee3\u0007\u0016\u0000\u0000\u0ee3\u0178\u0001\u0000\u0000\u0000"+ + "\u0ee4\u0ee5\u0007\u0018\u0000\u0000\u0ee5\u0ee6\u0007\u0003\u0000\u0000"+ + "\u0ee6\u0ee7\u0007\u0005\u0000\u0000\u0ee7\u0ee8\u0007\u0011\u0000\u0000"+ + "\u0ee8\u0ee9\u0007\u0007\u0000\u0000\u0ee9\u0eea\u0007\u000b\u0000\u0000"+ + "\u0eea\u017a\u0001\u0000\u0000\u0000\u0eeb\u0eec\u0007\t\u0000\u0000\u0eec"+ + "\u0eed\u0007\u0014\u0000\u0000\u0eed\u0eee\u0007\u0007\u0000\u0000\u0eee"+ + "\u0eef\u0007\f\u0000\u0000\u0eef\u017c\u0001\u0000\u0000\u0000\u0ef0\u0ef1"+ + "\u0007\t\u0000\u0000\u0ef1\u0ef2\u0007\u0014\u0000\u0000\u0ef2\u0ef3\u0007"+ + "\u0007\u0000\u0000\u0ef3\u0ef4\u0007\b\u0000\u0000\u0ef4\u0ef5\u0007\u0007"+ + "\u0000\u0000\u0ef5\u017e\u0001\u0000\u0000\u0000\u0ef6\u0ef7\u0007\t\u0000"+ + "\u0000\u0ef7\u0ef8\u0007\u0014\u0000\u0000\u0ef8\u0ef9\u0007\u000f\u0000"+ + "\u0000\u0ef9\u0efa\u0007\u0005\u0000\u0000\u0efa\u0efb\u0007\u0007\u0000"+ + "\u0000\u0efb\u0180\u0001\u0000\u0000\u0000\u0efc\u0efd\u0007\t\u0000\u0000"+ + "\u0efd\u0efe\u0007\u000f\u0000\u0000\u0efe\u0eff\u0007\u0006\u0000\u0000"+ + "\u0eff\u0f00\u0007\u0014\u0000\u0000\u0f00\u0182\u0001\u0000\u0000\u0000"+ + "\u0f01\u0f02\u0007\t\u0000\u0000\u0f02\u0f03\u0007\b\u0000\u0000\u0f03"+ + "\u0f04\u0007\u000f\u0000\u0000\u0f04\u0f05\u0007\u0006\u0000\u0000\u0f05"+ + "\u0f06\u0007\u0007\u0000\u0000\u0f06\u0184\u0001\u0000\u0000\u0000\u0f07"+ + "\u0f08\u0007\u001a\u0000\u0000\u0f08\u0f09\u0007\u0013\u0000\u0000\u0f09"+ + "\u0f0a\u0007\b\u0000\u0000\u0f0a\u0186\u0001\u0000\u0000\u0000\u0f0b\u0f0c"+ + "\u0007\r\u0000\u0000\u0f0c\u0f0d\u0007\u0007\u0000\u0000\u0f0d\u0f0e\u0007"+ + "\b\u0000\u0000\u0f0e\u0f0f\u0007\u0013\u0000\u0000\u0f0f\u0f10\u0007\u0012"+ + "\u0000\u0000\u0f10\u0f11\u0007\u000f\u0000\u0000\u0f11\u0f12\u0007\u0005"+ + "\u0000\u0000\u0f12\u0f13\u0007\u0005\u0000\u0000\u0f13\u0188\u0001\u0000"+ + "\u0000\u0000\u0f14\u0f15\u0007\u0006\u0000\u0000\u0f15\u0f16\u0007\u000f"+ + "\u0000\u0000\u0f16\u0f17\u0007\f\u0000\u0000\u0f17\u0f18\u0007\n\u0000"+ + "\u0000\u0f18\u0f19\u0007\u000f\u0000\u0000\u0f19\u0f1a\u0007\f\u0000\u0000"+ + "\u0f1a\u0f1b\u0007\u0006\u0000\u0000\u0f1b\u018a\u0001\u0000\u0000\u0000"+ + "\u0f1c\u0f1d\u0007\u000b\u0000\u0000\u0f1d\u0f1e\u0007\u0017\u0000\u0000"+ + "\u0f1e\u0f1f\u0007\u0003\u0000\u0000\u0f1f\u0f20\u0007\u0005\u0000\u0000"+ + "\u0f20\u0f21\u0007\u0005\u0000\u0000\u0f21\u0f22\u0007\u000f\u0000\u0000"+ + "\u0f22\u0f23\u0007\f\u0000\u0000\u0f23\u0f24\u0007\u0006\u0000\u0000\u0f24"+ + "\u018c\u0001\u0000\u0000\u0000\u0f25\u0f26\u0007\u0017\u0000\u0000\u0f26"+ + "\u0f27\u0007\u0007\u0000\u0000\u0f27\u0f28\u0007\u0004\u0000\u0000\u0f28"+ + "\u0f29\u0007\u000f\u0000\u0000\u0f29\u0f2a\u0007\u0011\u0000\u0000\u0f2a"+ + "\u0f2b\u0007\u0017\u0000\u0000\u0f2b\u0f2c\u0007\u000f\u0000\u0000\u0f2c"+ + "\u0f2d\u0007\f\u0000\u0000\u0f2d\u0f2e\u0007\u0006\u0000\u0000\u0f2e\u018e"+ + "\u0001\u0000\u0000\u0000\u0f2f\u0f30\u0007\u0017\u0000\u0000\u0f30\u0f31"+ + "\u0007\u000f\u0000\u0000\u0f31\u0f32\u0007\u0004\u0000\u0000\u0f32\u0f33"+ + "\u0007\u0004\u0000\u0000\u0f33\u0f34\u0007\u0005\u0000\u0000\u0f34\u0f35"+ + "\u0007\u0007\u0000\u0000\u0f35\u0f36\u0007\u000f\u0000\u0000\u0f36\u0f37"+ + "\u0007\f\u0000\u0000\u0f37\u0f38\u0007\u0006\u0000\u0000\u0f38\u0190\u0001"+ + "\u0000\u0000\u0000\u0f39\u0f3a\u0007\u000f\u0000\u0000\u0f3a\u0f3b\u0007"+ + "\f\u0000\u0000\u0f3b\u0f3c\u0007\u0006\u0000\u0000\u0f3c\u0192\u0001\u0000"+ + "\u0000\u0000\u0f3d\u0f3e\u0007\u000f\u0000\u0000\u0f3e\u0f3f\u0007\f\u0000"+ + "\u0000\u0f3f\u0f40\u0007\u0006\u0000\u0000\u0f40\u0f41\u00051\u0000\u0000"+ + "\u0f41\u0194\u0001\u0000\u0000\u0000\u0f42\u0f43\u0007\u000f\u0000\u0000"+ + "\u0f43\u0f44\u0007\f\u0000\u0000\u0f44\u0f45\u0007\u0006\u0000\u0000\u0f45"+ + "\u0f46\u00052\u0000\u0000\u0f46\u0196\u0001\u0000\u0000\u0000\u0f47\u0f48"+ + "\u0007\u000f\u0000\u0000\u0f48\u0f49\u0007\f\u0000\u0000\u0f49\u0f4a\u0007"+ + "\u0006\u0000\u0000\u0f4a\u0f4b\u00053\u0000\u0000\u0f4b\u0198\u0001\u0000"+ + "\u0000\u0000\u0f4c\u0f4d\u0007\u000f\u0000\u0000\u0f4d\u0f4e\u0007\f\u0000"+ + "\u0000\u0f4e\u0f4f\u0007\u0006\u0000\u0000\u0f4f\u0f50\u00054\u0000\u0000"+ + "\u0f50\u019a\u0001\u0000\u0000\u0000\u0f51\u0f52\u0007\u000f\u0000\u0000"+ + "\u0f52\u0f53\u0007\f\u0000\u0000\u0f53\u0f54\u0007\u0006\u0000\u0000\u0f54"+ + "\u0f55\u00058\u0000\u0000\u0f55\u019c\u0001\u0000\u0000\u0000\u0f56\u0f57"+ + "\u0007\u000f\u0000\u0000\u0f57\u0f58\u0007\f\u0000\u0000\u0f58\u0f59\u0007"+ + "\u0006\u0000\u0000\u0f59\u0f5a\u0007\u0007\u0000\u0000\u0f5a\u0f5b\u0007"+ + "\u0016\u0000\u0000\u0f5b\u0f5c\u0007\u0007\u0000\u0000\u0f5c\u0f5d\u0007"+ + "\b\u0000\u0000\u0f5d\u019e\u0001\u0000\u0000\u0000\u0f5e\u0f5f\u0007\u0010"+ + "\u0000\u0000\u0f5f\u0f60\u0007\u000f\u0000\u0000\u0f60\u0f61\u0007\u0016"+ + "\u0000\u0000\u0f61\u0f62\u0007\u000f\u0000\u0000\u0f62\u0f63\u0007\f\u0000"+ + "\u0000\u0f63\u0f64\u0007\u0006\u0000\u0000\u0f64\u01a0\u0001\u0000\u0000"+ + "\u0000\u0f65\u0f66\u0007\b\u0000\u0000\u0f66\u0f67\u0007\u0007\u0000\u0000"+ + "\u0f67\u0f68\u0007\u0003\u0000\u0000\u0f68\u0f69\u0007\u0005\u0000\u0000"+ + "\u0f69\u01a2\u0001\u0000\u0000\u0000\u0f6a\u0f6b\u0007\u0004\u0000\u0000"+ + "\u0f6b\u0f6c\u0007\u0013\u0000\u0000\u0f6c\u0f6d\u0007\u0011\u0000\u0000"+ + "\u0f6d\u0f6e\u0007\u0010\u0000\u0000\u0f6e\u0f6f\u0007\u0005\u0000\u0000"+ + "\u0f6f\u0f70\u0007\u0007\u0000\u0000\u0f70\u01a4\u0001\u0000\u0000\u0000"+ + "\u0f71\u0f72\u0007\u0019\u0000\u0000\u0f72\u0f73\u0007\b\u0000\u0000\u0f73"+ + "\u0f74\u0007\u0007\u0000\u0000\u0f74\u0f75\u0007\u000e\u0000\u0000\u0f75"+ + "\u0f76\u0007\u000f\u0000\u0000\u0f76\u0f77\u0007\u000b\u0000\u0000\u0f77"+ + "\u0f78\u0007\u000f\u0000\u0000\u0f78\u0f79\u0007\u0013\u0000\u0000\u0f79"+ + "\u0f7a\u0007\f\u0000\u0000\u0f7a\u01a6\u0001\u0000\u0000\u0000\u0f7b\u0f7c"+ + "\u0007\u0012\u0000\u0000\u0f7c\u0f7d\u0007\u0005\u0000\u0000\u0f7d\u0f7e"+ + "\u0007\u0013\u0000\u0000\u0f7e\u0f7f\u0007\u0003\u0000\u0000\u0f7f\u0f80"+ + "\u0007\u0006\u0000\u0000\u0f80\u01a8\u0001\u0000\u0000\u0000\u0f81\u0f82"+ + "\u0007\u0012\u0000\u0000\u0f82\u0f83\u0007\u0005\u0000\u0000\u0f83\u0f84"+ + "\u0007\u0013\u0000\u0000\u0f84\u0f85\u0007\u0003\u0000\u0000\u0f85\u0f86"+ + "\u0007\u0006\u0000\u0000\u0f86\u0f87\u00054\u0000\u0000\u0f87\u01aa\u0001"+ + "\u0000\u0000\u0000\u0f88\u0f89\u0007\u0012\u0000\u0000\u0f89\u0f8a\u0007"+ + "\u0005\u0000\u0000\u0f8a\u0f8b\u0007\u0013\u0000\u0000\u0f8b\u0f8c\u0007"+ + "\u0003\u0000\u0000\u0f8c\u0f8d\u0007\u0006\u0000\u0000\u0f8d\u0f8e\u0005"+ + "8\u0000\u0000\u0f8e\u01ac\u0001\u0000\u0000\u0000\u0f8f\u0f90\u0007\u0004"+ + "\u0000\u0000\u0f90\u0f91\u0007\u0007\u0000\u0000\u0f91\u0f92\u0007\u000e"+ + "\u0000\u0000\u0f92\u0f93\u0007\u000f\u0000\u0000\u0f93\u0f94\u0007\u0017"+ + "\u0000\u0000\u0f94\u0f95\u0007\u0003\u0000\u0000\u0f95\u0f96\u0007\u0005"+ + "\u0000\u0000\u0f96\u01ae\u0001\u0000\u0000\u0000\u0f97\u0f98\u0007\u0004"+ + "\u0000\u0000\u0f98\u0f99\u0007\u0007\u0000\u0000\u0f99\u0f9a\u0007\u000e"+ + "\u0000\u0000\u0f9a\u01b0\u0001\u0000\u0000\u0000\u0f9b\u0f9c\u0007\f\u0000"+ + "\u0000\u0f9c\u0f9d\u0007\u0011\u0000\u0000\u0f9d\u0f9e\u0007\u0017\u0000"+ + "\u0000\u0f9e\u0f9f\u0007\u0007\u0000\u0000\u0f9f\u0fa0\u0007\b\u0000\u0000"+ + "\u0fa0\u0fa1\u0007\u000f\u0000\u0000\u0fa1\u0fa2\u0007\u000e\u0000\u0000"+ + "\u0fa2\u01b2\u0001\u0000\u0000\u0000\u0fa3\u0fa4\u0007\u0004\u0000\u0000"+ + "\u0fa4\u0fa5\u0007\u0003\u0000\u0000\u0fa5\u0fa6\u0007\u0006\u0000\u0000"+ + "\u0fa6\u0fa7\u0007\u0007\u0000\u0000\u0fa7\u01b4\u0001\u0000\u0000\u0000"+ + "\u0fa8\u0fa9\u0007\u0006\u0000\u0000\u0fa9\u0faa\u0007\u000f\u0000\u0000"+ + "\u0faa\u0fab\u0007\u0017\u0000\u0000\u0fab\u0fac\u0007\u0007\u0000\u0000"+ + "\u0fac\u01b6\u0001\u0000\u0000\u0000\u0fad\u0fae\u0007\u0006\u0000\u0000"+ + "\u0fae\u0faf\u0007\u000f\u0000\u0000\u0faf\u0fb0\u0007\u0017\u0000\u0000"+ + "\u0fb0\u0fb1\u0007\u0007\u0000\u0000\u0fb1\u0fb2\u0007\u000b\u0000\u0000"+ + "\u0fb2\u0fb3\u0007\u0006\u0000\u0000\u0fb3\u0fb4\u0007\u0003\u0000\u0000"+ + "\u0fb4\u0fb5\u0007\u0017\u0000\u0000\u0fb5\u0fb6\u0007\u0019\u0000\u0000"+ + "\u0fb6\u01b8\u0001\u0000\u0000\u0000\u0fb7\u0fb8\u0007\u0004\u0000\u0000"+ + "\u0fb8\u0fb9\u0007\u0003\u0000\u0000\u0fb9\u0fba\u0007\u0006\u0000\u0000"+ + "\u0fba\u0fbb\u0007\u0007\u0000\u0000\u0fbb\u0fbc\u0007\u0006\u0000\u0000"+ + "\u0fbc\u0fbd\u0007\u000f\u0000\u0000\u0fbd\u0fbe\u0007\u0017\u0000\u0000"+ + "\u0fbe\u0fbf\u0007\u0007\u0000\u0000\u0fbf\u01ba\u0001\u0000\u0000\u0000"+ + "\u0fc0\u0fc1\u0007\n\u0000\u0000\u0fc1\u0fc2\u0007\u0007\u0000\u0000\u0fc2"+ + "\u0fc3\u0007\u0003\u0000\u0000\u0fc3\u0fc4\u0007\b\u0000\u0000\u0fc4\u01bc"+ + "\u0001\u0000\u0000\u0000\u0fc5\u0fc6\u0007\u000e\u0000\u0000\u0fc6\u0fc7"+ + "\u0007\u0014\u0000\u0000\u0fc7\u0fc8\u0007\u0003\u0000\u0000\u0fc8\u0fc9"+ + "\u0007\b\u0000\u0000\u0fc9\u01be\u0001\u0000\u0000\u0000\u0fca\u0fcb\u0007"+ + "\u0018\u0000\u0000\u0fcb\u0fcc\u0007\u0003\u0000\u0000\u0fcc\u0fcd\u0007"+ + "\b\u0000\u0000\u0fcd\u0fce\u0007\u000e\u0000\u0000\u0fce\u0fcf\u0007\u0014"+ + "\u0000\u0000\u0fcf\u0fd0\u0007\u0003\u0000\u0000\u0fd0\u0fd1\u0007\b\u0000"+ + "\u0000\u0fd1\u01c0\u0001\u0000\u0000\u0000\u0fd2\u0fd3\u0007\f\u0000\u0000"+ + "\u0fd3\u0fd4\u0007\u0018\u0000\u0000\u0fd4\u0fd5\u0007\u0003\u0000\u0000"+ + "\u0fd5\u0fd6\u0007\b\u0000\u0000\u0fd6\u0fd7\u0007\u000e\u0000\u0000\u0fd7"+ + "\u0fd8\u0007\u0014\u0000\u0000\u0fd8\u0fd9\u0007\u0003\u0000\u0000\u0fd9"+ + "\u0fda\u0007\b\u0000\u0000\u0fda\u01c2\u0001\u0000\u0000\u0000\u0fdb\u0fdc"+ + "\u0007\f\u0000\u0000\u0fdc\u0fdd\u0007\u0003\u0000\u0000\u0fdd\u0fde\u0007"+ + "\u0006\u0000\u0000\u0fde\u0fdf\u0007\u000f\u0000\u0000\u0fdf\u0fe0\u0007"+ + "\u0013\u0000\u0000\u0fe0\u0fe1\u0007\f\u0000\u0000\u0fe1\u0fe2\u0007\u0003"+ + "\u0000\u0000\u0fe2\u0fe3\u0007\u0005\u0000\u0000\u0fe3\u01c4\u0001\u0000"+ + "\u0000\u0000\u0fe4\u0fe5\u0007\u0010\u0000\u0000\u0fe5\u0fe6\u0007\u000f"+ + "\u0000\u0000\u0fe6\u0fe7\u0007\f\u0000\u0000\u0fe7\u0fe8\u0007\u0003\u0000"+ + "\u0000\u0fe8\u0fe9\u0007\b\u0000\u0000\u0fe9\u0fea\u0007\n\u0000\u0000"+ + "\u0fea\u01c6\u0001\u0000\u0000\u0000\u0feb\u0fec\u0007\u0018\u0000\u0000"+ + "\u0fec\u0fed\u0007\u0003\u0000\u0000\u0fed\u0fee\u0007\b\u0000\u0000\u0fee"+ + "\u0fef\u0007\u0010\u0000\u0000\u0fef\u0ff0\u0007\u000f\u0000\u0000\u0ff0"+ + "\u0ff1\u0007\f\u0000\u0000\u0ff1\u0ff2\u0007\u0003\u0000\u0000\u0ff2\u0ff3"+ + "\u0007\b\u0000\u0000\u0ff3\u0ff4\u0007\n\u0000\u0000\u0ff4\u01c8\u0001"+ + "\u0000\u0000\u0000\u0ff5\u0ff6\u0007\u0006\u0000\u0000\u0ff6\u0ff7\u0007"+ + "\u000f\u0000\u0000\u0ff7\u0ff8\u0007\f\u0000\u0000\u0ff8\u0ff9\u0007\n"+ + "\u0000\u0000\u0ff9\u0ffa\u0007\u0010\u0000\u0000\u0ffa\u0ffb\u0007\u0005"+ + "\u0000\u0000\u0ffb\u0ffc\u0007\u0013\u0000\u0000\u0ffc\u0ffd\u0007\u0010"+ + "\u0000\u0000\u0ffd\u01ca\u0001\u0000\u0000\u0000\u0ffe\u0fff\u0007\u0010"+ + "\u0000\u0000\u0fff\u1000\u0007\u0005\u0000\u0000\u1000\u1001\u0007\u0013"+ + "\u0000\u0000\u1001\u1002\u0007\u0010\u0000\u0000\u1002\u01cc\u0001\u0000"+ + "\u0000\u0000\u1003\u1004\u0007\u0017\u0000\u0000\u1004\u1005\u0007\u0007"+ + "\u0000\u0000\u1005\u1006\u0007\u0004\u0000\u0000\u1006\u1007\u0007\u000f"+ + "\u0000\u0000\u1007\u1008\u0007\u0011\u0000\u0000\u1008\u1009\u0007\u0017"+ + "\u0000\u0000\u1009\u100a\u0007\u0010\u0000\u0000\u100a\u100b\u0007\u0005"+ + "\u0000\u0000\u100b\u100c\u0007\u0013\u0000\u0000\u100c\u100d\u0007\u0010"+ + "\u0000\u0000\u100d\u01ce\u0001\u0000\u0000\u0000\u100e\u100f\u0007\u0005"+ + "\u0000\u0000\u100f\u1010\u0007\u0013\u0000\u0000\u1010\u1011\u0007\f\u0000"+ + "\u0000\u1011\u1012\u0007\u0016\u0000\u0000\u1012\u01d0\u0001\u0000\u0000"+ + "\u0000\u1013\u1014\u0007\u0005\u0000\u0000\u1014\u1015\u0007\u0013\u0000"+ + "\u0000\u1015\u1016\u0007\f\u0000\u0000\u1016\u1017\u0007\u0016\u0000\u0000"+ + "\u1017\u1018\u0007\u0010\u0000\u0000\u1018\u1019\u0007\u0005\u0000\u0000"+ + "\u1019\u101a\u0007\u0013\u0000\u0000\u101a\u101b\u0007\u0010\u0000\u0000"+ + "\u101b\u01d2\u0001\u0000\u0000\u0000\u101c\u101d\u0007\u0006\u0000\u0000"+ + "\u101d\u101e\u0007\u000f\u0000\u0000\u101e\u101f\u0007\f\u0000\u0000\u101f"+ + "\u1020\u0007\n\u0000\u0000\u1020\u1021\u0007\u0006\u0000\u0000\u1021\u1022"+ + "\u0007\u0007\u0000\u0000\u1022\u1023\u0007\u001a\u0000\u0000\u1023\u1024"+ + "\u0007\u0006\u0000\u0000\u1024\u01d4\u0001\u0000\u0000\u0000\u1025\u1026"+ + "\u0007\u0006\u0000\u0000\u1026\u1027\u0007\u0007\u0000\u0000\u1027\u1028"+ + "\u0007\u001a\u0000\u0000\u1028\u1029\u0007\u0006\u0000\u0000\u1029\u01d6"+ + "\u0001\u0000\u0000\u0000\u102a\u102b\u0007\u0017\u0000\u0000\u102b\u102c"+ + "\u0007\u0007\u0000\u0000\u102c\u102d\u0007\u0004\u0000\u0000\u102d\u102e"+ + "\u0007\u000f\u0000\u0000\u102e\u102f\u0007\u0011\u0000\u0000\u102f\u1030"+ + "\u0007\u0017\u0000\u0000\u1030\u1031\u0007\u0006\u0000\u0000\u1031\u1032"+ + "\u0007\u0007\u0000\u0000\u1032\u1033\u0007\u001a\u0000\u0000\u1033\u1034"+ + "\u0007\u0006\u0000\u0000\u1034\u01d8\u0001\u0000\u0000\u0000\u1035\u1036"+ + "\u0007\u0005\u0000\u0000\u1036\u1037\u0007\u0013\u0000\u0000\u1037\u1038"+ + "\u0007\f\u0000\u0000\u1038\u1039\u0007\u0016\u0000\u0000\u1039\u103a\u0007"+ + "\u0006\u0000\u0000\u103a\u103b\u0007\u0007\u0000\u0000\u103b\u103c\u0007"+ + "\u001a\u0000\u0000\u103c\u103d\u0007\u0006\u0000\u0000\u103d\u01da\u0001"+ + "\u0000\u0000\u0000\u103e\u103f\u0007\u0007\u0000\u0000\u103f\u1040\u0007"+ + "\f\u0000\u0000\u1040\u1041\u0007\u0011\u0000\u0000\u1041\u1042\u0007\u0017"+ + "\u0000\u0000\u1042\u01dc\u0001\u0000\u0000\u0000\u1043\u1044\u0007\u0018"+ + "\u0000\u0000\u1044\u1045\u0007\u0003\u0000\u0000\u1045\u1046\u0007\b\u0000"+ + "\u0000\u1046\u1047\u0007\n\u0000\u0000\u1047\u1048\u0007\u000f\u0000\u0000"+ + "\u1048\u1049\u0007\f\u0000\u0000\u1049\u104a\u0007\u0016\u0000\u0000\u104a"+ + "\u01de\u0001\u0000\u0000\u0000\u104b\u104c\u0007\u000b\u0000\u0000\u104c"+ + "\u104d\u0007\u0007\u0000\u0000\u104d\u104e\u0007\b\u0000\u0000\u104e\u104f"+ + "\u0007\u000f\u0000\u0000\u104f\u1050\u0007\u0003\u0000\u0000\u1050\u1051"+ + "\u0007\u0005\u0000\u0000\u1051\u01e0\u0001\u0000\u0000\u0000\u1052\u1053"+ + "\u0007\n\u0000\u0000\u1053\u1054\u0007\u0007\u0000\u0000\u1054\u1055\u0007"+ + "\u0003\u0000\u0000\u1055\u1056\u0007\b\u0000\u0000\u1056\u1057\u0005_"+ + "\u0000\u0000\u1057\u1058\u0007\u0017\u0000\u0000\u1058\u1059\u0007\u0013"+ + "\u0000\u0000\u1059\u105a\u0007\f\u0000\u0000\u105a\u105b\u0007\u0006\u0000"+ + "\u0000\u105b\u105c\u0007\u0014\u0000\u0000\u105c\u01e2\u0001\u0000\u0000"+ + "\u0000\u105d\u105e\u0007\u0004\u0000\u0000\u105e\u105f\u0007\u0003\u0000"+ + "\u0000\u105f\u1060\u0007\n\u0000\u0000\u1060\u1061\u0005_\u0000\u0000"+ + "\u1061\u1062\u0007\u0014\u0000\u0000\u1062\u1063\u0007\u0013\u0000\u0000"+ + "\u1063\u1064\u0007\u0011\u0000\u0000\u1064\u1065\u0007\b\u0000\u0000\u1065"+ + "\u01e4\u0001\u0000\u0000\u0000\u1066\u1067\u0007\u0004\u0000\u0000\u1067"+ + "\u1068\u0007\u0003\u0000\u0000\u1068\u1069\u0007\n\u0000\u0000\u1069\u106a"+ + "\u0005_\u0000\u0000\u106a\u106b\u0007\u0017\u0000\u0000\u106b\u106c\u0007"+ + "\u000f\u0000\u0000\u106c\u106d\u0007\f\u0000\u0000\u106d\u106e\u0007\u0011"+ + "\u0000\u0000\u106e\u106f\u0007\u0006\u0000\u0000\u106f\u1070\u0007\u0007"+ + "\u0000\u0000\u1070\u01e6\u0001\u0000\u0000\u0000\u1071\u1072\u0007\u0004"+ + "\u0000\u0000\u1072\u1073\u0007\u0003\u0000\u0000\u1073\u1074\u0007\n\u0000"+ + "\u0000\u1074\u1075\u0005_\u0000\u0000\u1075\u1076\u0007\u000b\u0000\u0000"+ + "\u1076\u1077\u0007\u0007\u0000\u0000\u1077\u1078\u0007\u000e\u0000\u0000"+ + "\u1078\u1079\u0007\u0013\u0000\u0000\u1079\u107a\u0007\f\u0000\u0000\u107a"+ + "\u107b\u0007\u0004\u0000\u0000\u107b\u01e8\u0001\u0000\u0000\u0000\u107c"+ + "\u107d\u0007\u0014\u0000\u0000\u107d\u107e\u0007\u0013\u0000\u0000\u107e"+ + "\u107f\u0007\u0011\u0000\u0000\u107f\u1080\u0007\b\u0000\u0000\u1080\u1081"+ + "\u0005_\u0000\u0000\u1081\u1082\u0007\u0017\u0000\u0000\u1082\u1083\u0007"+ + "\u000f\u0000\u0000\u1083\u1084\u0007\f\u0000\u0000\u1084\u1085\u0007\u0011"+ + "\u0000\u0000\u1085\u1086\u0007\u0006\u0000\u0000\u1086\u1087\u0007\u0007"+ + "\u0000\u0000\u1087\u01ea\u0001\u0000\u0000\u0000\u1088\u1089\u0007\u0014"+ + "\u0000\u0000\u1089\u108a\u0007\u0013\u0000\u0000\u108a\u108b\u0007\u0011"+ + "\u0000\u0000\u108b\u108c\u0007\b\u0000\u0000\u108c\u108d\u0005_\u0000"+ + "\u0000\u108d\u108e\u0007\u000b\u0000\u0000\u108e\u108f\u0007\u0007\u0000"+ + "\u0000\u108f\u1090\u0007\u000e\u0000\u0000\u1090\u1091\u0007\u0013\u0000"+ + "\u0000\u1091\u1092\u0007\f\u0000\u0000\u1092\u1093\u0007\u0004\u0000\u0000"+ + "\u1093\u01ec\u0001\u0000\u0000\u0000\u1094\u1095\u0007\u0017\u0000\u0000"+ + "\u1095\u1096\u0007\u000f\u0000\u0000\u1096\u1097\u0007\f\u0000\u0000\u1097"+ + "\u1098\u0007\u0011\u0000\u0000\u1098\u1099\u0007\u0006\u0000\u0000\u1099"+ + "\u109a\u0007\u0007\u0000\u0000\u109a\u109b\u0005_\u0000\u0000\u109b\u109c"+ + "\u0007\u000b\u0000\u0000\u109c\u109d\u0007\u0007\u0000\u0000\u109d\u109e"+ + "\u0007\u000e\u0000\u0000\u109e\u109f\u0007\u0013\u0000\u0000\u109f\u10a0"+ + "\u0007\f\u0000\u0000\u10a0\u10a1\u0007\u0004\u0000\u0000\u10a1\u01ee\u0001"+ + "\u0000\u0000\u0000\u10a2\u10a3\u0007\u000b\u0000\u0000\u10a3\u10a4\u0007"+ + "\u0007\u0000\u0000\u10a4\u10a5\u0007\u000e\u0000\u0000\u10a5\u10a6\u0007"+ + "\u0013\u0000\u0000\u10a6\u10a7\u0007\f\u0000\u0000\u10a7\u10a8\u0007\u0004"+ + "\u0000\u0000\u10a8\u10a9\u0005_\u0000\u0000\u10a9\u10aa\u0007\u0017\u0000"+ + "\u0000\u10aa\u10ab\u0007\u000f\u0000\u0000\u10ab\u10ac\u0007\u000e\u0000"+ + "\u0000\u10ac\u10ad\u0007\b\u0000\u0000\u10ad\u10ae\u0007\u0013\u0000\u0000"+ + "\u10ae\u10af\u0007\u000b\u0000\u0000\u10af\u10b0\u0007\u0007\u0000\u0000"+ + "\u10b0\u10b1\u0007\u000e\u0000\u0000\u10b1\u10b2\u0007\u0013\u0000\u0000"+ + "\u10b2\u10b3\u0007\f\u0000\u0000\u10b3\u10b4\u0007\u0004\u0000\u0000\u10b4"+ + "\u01f0\u0001\u0000\u0000\u0000\u10b5\u10b6\u0007\u0017\u0000\u0000\u10b6"+ + "\u10b7\u0007\u000f\u0000\u0000\u10b7\u10b8\u0007\f\u0000\u0000\u10b8\u10b9"+ + "\u0007\u0011\u0000\u0000\u10b9\u10ba\u0007\u0006\u0000\u0000\u10ba\u10bb"+ + "\u0007\u0007\u0000\u0000\u10bb\u10bc\u0005_\u0000\u0000\u10bc\u10bd\u0007"+ + "\u0017\u0000\u0000\u10bd\u10be\u0007\u000f\u0000\u0000\u10be\u10bf\u0007"+ + "\u000e\u0000\u0000\u10bf\u10c0\u0007\b\u0000\u0000\u10c0\u10c1\u0007\u0013"+ + "\u0000\u0000\u10c1\u10c2\u0007\u000b\u0000\u0000\u10c2\u10c3\u0007\u0007"+ + "\u0000\u0000\u10c3\u10c4\u0007\u000e\u0000\u0000\u10c4\u10c5\u0007\u0013"+ + "\u0000\u0000\u10c5\u10c6\u0007\f\u0000\u0000\u10c6\u10c7\u0007\u0004\u0000"+ + "\u0000\u10c7\u01f2\u0001\u0000\u0000\u0000\u10c8\u10c9\u0007\u0014\u0000"+ + "\u0000\u10c9\u10ca\u0007\u0013\u0000\u0000\u10ca\u10cb\u0007\u0011\u0000"+ + "\u0000\u10cb\u10cc\u0007\b\u0000\u0000\u10cc\u10cd\u0005_\u0000\u0000"+ + "\u10cd\u10ce\u0007\u0017\u0000\u0000\u10ce\u10cf\u0007\u000f\u0000\u0000"+ + "\u10cf\u10d0\u0007\u000e\u0000\u0000\u10d0\u10d1\u0007\b\u0000\u0000\u10d1"+ + "\u10d2\u0007\u0013\u0000\u0000\u10d2\u10d3\u0007\u000b\u0000\u0000\u10d3"+ + "\u10d4\u0007\u0007\u0000\u0000\u10d4\u10d5\u0007\u000e\u0000\u0000\u10d5"+ + "\u10d6\u0007\u0013\u0000\u0000\u10d6\u10d7\u0007\f\u0000\u0000\u10d7\u10d8"+ + "\u0007\u0004\u0000\u0000\u10d8\u01f4\u0001\u0000\u0000\u0000\u10d9\u10da"+ + "\u0007\u0004\u0000\u0000\u10da\u10db\u0007\u0003\u0000\u0000\u10db\u10dc"+ + "\u0007\n\u0000\u0000\u10dc\u10dd\u0005_\u0000\u0000\u10dd\u10de\u0007"+ + "\u0017\u0000\u0000\u10de\u10df\u0007\u000f\u0000\u0000\u10df\u10e0\u0007"+ + "\u000e\u0000\u0000\u10e0\u10e1\u0007\b\u0000\u0000\u10e1\u10e2\u0007\u0013"+ + "\u0000\u0000\u10e2\u10e3\u0007\u000b\u0000\u0000\u10e3\u10e4\u0007\u0007"+ + "\u0000\u0000\u10e4\u10e5\u0007\u000e\u0000\u0000\u10e5\u10e6\u0007\u0013"+ + "\u0000\u0000\u10e6\u10e7\u0007\f\u0000\u0000\u10e7\u10e8\u0007\u0004\u0000"+ + "\u0000\u10e8\u01f6\u0001\u0000\u0000\u0000\u10e9\u10ea\u0007\u001b\u0000"+ + "\u0000\u10ea\u10eb\u0007\u000b\u0000\u0000\u10eb\u10ec\u0007\u0013\u0000"+ + "\u0000\u10ec\u10ed\u0007\f\u0000\u0000\u10ed\u10ee\u0005_\u0000\u0000"+ + "\u10ee\u10ef\u0007\u0003\u0000\u0000\u10ef\u10f0\u0007\b\u0000\u0000\u10f0"+ + "\u10f1\u0007\b\u0000\u0000\u10f1\u10f2\u0007\u0003\u0000\u0000\u10f2\u10f3"+ + "\u0007\n\u0000\u0000\u10f3\u01f8\u0001\u0000\u0000\u0000\u10f4\u10f5\u0007"+ + "\u001b\u0000\u0000\u10f5\u10f6\u0007\u000b\u0000\u0000\u10f6\u10f7\u0007"+ + "\u0013\u0000\u0000\u10f7\u10f8\u0007\f\u0000\u0000\u10f8\u10f9\u0005_"+ + "\u0000\u0000\u10f9\u10fa\u0007\u0003\u0000\u0000\u10fa\u10fb\u0007\b\u0000"+ + "\u0000\u10fb\u10fc\u0007\b\u0000\u0000\u10fc\u10fd\u0007\u0003\u0000\u0000"+ + "\u10fd\u10fe\u0007\n\u0000\u0000\u10fe\u10ff\u0007\u0003\u0000\u0000\u10ff"+ + "\u1100\u0007\u0016\u0000\u0000\u1100\u1101\u0007\u0016\u0000\u0000\u1101"+ + "\u01fa\u0001\u0000\u0000\u0000\u1102\u1103\u0007\u001b\u0000\u0000\u1103"+ + "\u1104\u0007\u000b\u0000\u0000\u1104\u1105\u0007\u0013\u0000\u0000\u1105"+ + "\u1106\u0007\f\u0000\u0000\u1106\u1107\u0005_\u0000\u0000\u1107\u1108"+ + "\u0007\u0003\u0000\u0000\u1108\u1109\u0007\b\u0000\u0000\u1109\u110a\u0007"+ + "\b\u0000\u0000\u110a\u110b\u0007\u0003\u0000\u0000\u110b\u110c\u0007\n"+ + "\u0000\u0000\u110c\u110d\u0005_\u0000\u0000\u110d\u110e\u0007\u0003\u0000"+ + "\u0000\u110e\u110f\u0007\u0019\u0000\u0000\u110f\u1110\u0007\u0019\u0000"+ + "\u0000\u1110\u1111\u0007\u0007\u0000\u0000\u1111\u1112\u0007\f\u0000\u0000"+ + "\u1112\u1113\u0007\u0004\u0000\u0000\u1113\u01fc\u0001\u0000\u0000\u0000"+ + "\u1114\u1115\u0007\u001b\u0000\u0000\u1115\u1116\u0007\u000b\u0000\u0000"+ + "\u1116\u1117\u0007\u0013\u0000\u0000\u1117\u1118\u0007\f\u0000\u0000\u1118"+ + "\u1119\u0005_\u0000\u0000\u1119\u111a\u0007\u0003\u0000\u0000\u111a\u111b"+ + "\u0007\b\u0000\u0000\u111b\u111c\u0007\b\u0000\u0000\u111c\u111d\u0007"+ + "\u0003\u0000\u0000\u111d\u111e\u0007\n\u0000\u0000\u111e\u111f\u0005_"+ + "\u0000\u0000\u111f\u1120\u0007\u000f\u0000\u0000\u1120\u1121\u0007\f\u0000"+ + "\u0000\u1121\u1122\u0007\u000b\u0000\u0000\u1122\u1123\u0007\u0007\u0000"+ + "\u0000\u1123\u1124\u0007\b\u0000\u0000\u1124\u1125\u0007\u0006\u0000\u0000"+ + "\u1125\u01fe\u0001\u0000\u0000\u0000\u1126\u1127\u0007\u001b\u0000\u0000"+ + "\u1127\u1128\u0007\u000b\u0000\u0000\u1128\u1129\u0007\u0013\u0000\u0000"+ + "\u1129\u112a\u0007\f\u0000\u0000\u112a\u112b\u0005_\u0000\u0000\u112b"+ + "\u112c\u0007\u000e\u0000\u0000\u112c\u112d\u0007\u0013\u0000\u0000\u112d"+ + "\u112e\u0007\f\u0000\u0000\u112e\u112f\u0007\u0006\u0000\u0000\u112f\u1130"+ + "\u0007\u0003\u0000\u0000\u1130\u1131\u0007\u000f\u0000\u0000\u1131\u1132"+ + "\u0007\f\u0000\u0000\u1132\u1133\u0007\u000b\u0000\u0000\u1133\u0200\u0001"+ + "\u0000\u0000\u0000\u1134\u1135\u0007\u001b\u0000\u0000\u1135\u1136\u0007"+ + "\u000b\u0000\u0000\u1136\u1137\u0007\u0013\u0000\u0000\u1137\u1138\u0007"+ + "\f\u0000\u0000\u1138\u1139\u0005_\u0000\u0000\u1139\u113a\u0007\u000e"+ + "\u0000\u0000\u113a\u113b\u0007\u0013\u0000\u0000\u113b\u113c\u0007\f\u0000"+ + "\u0000\u113c\u113d\u0007\u0006\u0000\u0000\u113d\u113e\u0007\u0003\u0000"+ + "\u0000\u113e\u113f\u0007\u000f\u0000\u0000\u113f\u1140\u0007\f\u0000\u0000"+ + "\u1140\u1141\u0007\u000b\u0000\u0000\u1141\u1142\u0005_\u0000\u0000\u1142"+ + "\u1143\u0007\u0019\u0000\u0000\u1143\u1144\u0007\u0003\u0000\u0000\u1144"+ + "\u1145\u0007\u0006\u0000\u0000\u1145\u1146\u0007\u0014\u0000\u0000\u1146"+ + "\u0202\u0001\u0000\u0000\u0000\u1147\u1148\u0007\u001b\u0000\u0000\u1148"+ + "\u1149\u0007\u000b\u0000\u0000\u1149\u114a\u0007\u0013\u0000\u0000\u114a"+ + "\u114b\u0007\f\u0000\u0000\u114b\u114c\u0005_\u0000\u0000\u114c\u114d"+ + "\u0007\u0004\u0000\u0000\u114d\u114e\u0007\u0007\u0000\u0000\u114e\u114f"+ + "\u0007\u0019\u0000\u0000\u114f\u1150\u0007\u0006\u0000\u0000\u1150\u1151"+ + "\u0007\u0014\u0000\u0000\u1151\u0204\u0001\u0000\u0000\u0000\u1152\u1153"+ + "\u0007\u001b\u0000\u0000\u1153\u1154\u0007\u000b\u0000\u0000\u1154\u1155"+ + "\u0007\u0013\u0000\u0000\u1155\u1156\u0007\f\u0000\u0000\u1156\u1157\u0005"+ + "_\u0000\u0000\u1157\u1158\u0007\u0007\u0000\u0000\u1158\u1159\u0007\u001a"+ + "\u0000\u0000\u1159\u115a\u0007\u0006\u0000\u0000\u115a\u115b\u0007\b\u0000"+ + "\u0000\u115b\u115c\u0007\u0003\u0000\u0000\u115c\u115d\u0007\u000e\u0000"+ + "\u0000\u115d\u115e\u0007\u0006\u0000\u0000\u115e\u0206\u0001\u0000\u0000"+ + "\u0000\u115f\u1160\u0007\u001b\u0000\u0000\u1160\u1161\u0007\u000b\u0000"+ + "\u0000\u1161\u1162\u0007\u0013\u0000\u0000\u1162\u1163\u0007\f\u0000\u0000"+ + "\u1163\u1164\u0005_\u0000\u0000\u1164\u1165\u0007\u000f\u0000\u0000\u1165"+ + "\u1166\u0007\f\u0000\u0000\u1166\u1167\u0007\u000b\u0000\u0000\u1167\u1168"+ + "\u0007\u0007\u0000\u0000\u1168\u1169\u0007\b\u0000\u0000\u1169\u116a\u0007"+ + "\u0006\u0000\u0000\u116a\u0208\u0001\u0000\u0000\u0000\u116b\u116c\u0007"+ + "\u001b\u0000\u0000\u116c\u116d\u0007\u000b\u0000\u0000\u116d\u116e\u0007"+ + "\u0013\u0000\u0000\u116e\u116f\u0007\f\u0000\u0000\u116f\u1170\u0005_"+ + "\u0000\u0000\u1170\u1171\u0007\u0015\u0000\u0000\u1171\u1172\u0007\u0007"+ + "\u0000\u0000\u1172\u1173\u0007\n\u0000\u0000\u1173\u1174\u0007\u000b\u0000"+ + "\u0000\u1174\u020a\u0001\u0000\u0000\u0000\u1175\u1176\u0007\u001b\u0000"+ + "\u0000\u1176\u1177\u0007\u000b\u0000\u0000\u1177\u1178\u0007\u0013\u0000"+ + "\u0000\u1178\u1179\u0007\f\u0000\u0000\u1179\u117a\u0005_\u0000\u0000"+ + "\u117a\u117b\u0007\u0005\u0000\u0000\u117b\u117c\u0007\u0007\u0000\u0000"+ + "\u117c\u117d\u0007\f\u0000\u0000\u117d\u117e\u0007\u0016\u0000\u0000\u117e"+ + "\u117f\u0007\u0006\u0000\u0000\u117f\u1180\u0007\u0014\u0000\u0000\u1180"+ + "\u020c\u0001\u0000\u0000\u0000\u1181\u1182\u0007\u001b\u0000\u0000\u1182"+ + "\u1183\u0007\u000b\u0000\u0000\u1183\u1184\u0007\u0013\u0000\u0000\u1184"+ + "\u1185\u0007\f\u0000\u0000\u1185\u1186\u0005_\u0000\u0000\u1186\u1187"+ + "\u0007\u0017\u0000\u0000\u1187\u1188\u0007\u0007\u0000\u0000\u1188\u1189"+ + "\u0007\b\u0000\u0000\u1189\u118a\u0007\u0016\u0000\u0000\u118a\u118b\u0007"+ + "\u0007\u0000\u0000\u118b\u020e\u0001\u0000\u0000\u0000\u118c\u118d\u0007"+ + "\u001b\u0000\u0000\u118d\u118e\u0007\u000b\u0000\u0000\u118e\u118f\u0007"+ + "\u0013\u0000\u0000\u118f\u1190\u0007\f\u0000\u0000\u1190\u1191\u0005_"+ + "\u0000\u0000\u1191\u1192\u0007\u0017\u0000\u0000\u1192\u1193\u0007\u0007"+ + "\u0000\u0000\u1193\u1194\u0007\b\u0000\u0000\u1194\u1195\u0007\u0016\u0000"+ + "\u0000\u1195\u1196\u0007\u0007\u0000\u0000\u1196\u1197\u0005_\u0000\u0000"+ + "\u1197\u1198\u0007\u0019\u0000\u0000\u1198\u1199\u0007\u0003\u0000\u0000"+ + "\u1199\u119a\u0007\u0006\u0000\u0000\u119a\u119b\u0007\u000e\u0000\u0000"+ + "\u119b\u119c\u0007\u0014\u0000\u0000\u119c\u0210\u0001\u0000\u0000\u0000"+ + "\u119d\u119e\u0007\u001b\u0000\u0000\u119e\u119f\u0007\u000b\u0000\u0000"+ + "\u119f\u11a0\u0007\u0013\u0000\u0000\u11a0\u11a1\u0007\f\u0000\u0000\u11a1"+ + "\u11a2\u0005_\u0000\u0000\u11a2\u11a3\u0007\u0017\u0000\u0000\u11a3\u11a4"+ + "\u0007\u0007\u0000\u0000\u11a4\u11a5\u0007\b\u0000\u0000\u11a5\u11a6\u0007"+ + "\u0016\u0000\u0000\u11a6\u11a7\u0007\u0007\u0000\u0000\u11a7\u11a8\u0005"+ + "_\u0000\u0000\u11a8\u11a9\u0007\u0019\u0000\u0000\u11a9\u11aa\u0007\b"+ + "\u0000\u0000\u11aa\u11ab\u0007\u0007\u0000\u0000\u11ab\u11ac\u0007\u000b"+ + "\u0000\u0000\u11ac\u11ad\u0007\u0007\u0000\u0000\u11ad\u11ae\u0007\b\u0000"+ + "\u0000\u11ae\u11af\u0007\u0018\u0000\u0000\u11af\u11b0\u0007\u0007\u0000"+ + "\u0000\u11b0\u0212\u0001\u0000\u0000\u0000\u11b1\u11b2\u0007\u001b\u0000"+ + "\u0000\u11b2\u11b3\u0007\u000b\u0000\u0000\u11b3\u11b4\u0007\u0013\u0000"+ + "\u0000\u11b4\u11b5\u0007\f\u0000\u0000\u11b5\u11b6\u0005_\u0000\u0000"+ + "\u11b6\u11b7\u0007\u0013\u0000\u0000\u11b7\u11b8\u0007\u0010\u0000\u0000"+ + "\u11b8\u11b9\u0007\u001b\u0000\u0000\u11b9\u11ba\u0007\u0007\u0000\u0000"+ + "\u11ba\u11bb\u0007\u000e\u0000\u0000\u11bb\u11bc\u0007\u0006\u0000\u0000"+ + "\u11bc\u0214\u0001\u0000\u0000\u0000\u11bd\u11be\u0007\u001b\u0000\u0000"+ + "\u11be\u11bf\u0007\u000b\u0000\u0000\u11bf\u11c0\u0007\u0013\u0000\u0000"+ + "\u11c0\u11c1\u0007\f\u0000\u0000\u11c1\u11c2\u0005_\u0000\u0000\u11c2"+ + "\u11c3\u0007\u0013\u0000\u0000\u11c3\u11c4\u0007\u0010\u0000\u0000\u11c4"+ + "\u11c5\u0007\u001b\u0000\u0000\u11c5\u11c6\u0007\u0007\u0000\u0000\u11c6"+ + "\u11c7\u0007\u000e\u0000\u0000\u11c7\u11c8\u0007\u0006\u0000\u0000\u11c8"+ + "\u11c9\u0007\u0003\u0000\u0000\u11c9\u11ca\u0007\u0016\u0000\u0000\u11ca"+ + "\u11cb\u0007\u0016\u0000\u0000\u11cb\u0216\u0001\u0000\u0000\u0000\u11cc"+ + "\u11cd\u0007\u001b\u0000\u0000\u11cd\u11ce\u0007\u000b\u0000\u0000\u11ce"+ + "\u11cf\u0007\u0013\u0000\u0000\u11cf\u11d0\u0007\f\u0000\u0000\u11d0\u11d1"+ + "\u0005_\u0000\u0000\u11d1\u11d2\u0007\u0013\u0000\u0000\u11d2\u11d3\u0007"+ + "\u0018\u0000\u0000\u11d3\u11d4\u0007\u0007\u0000\u0000\u11d4\u11d5\u0007"+ + "\b\u0000\u0000\u11d5\u11d6\u0007\u0005\u0000\u0000\u11d6\u11d7\u0007\u0003"+ + "\u0000\u0000\u11d7\u11d8\u0007\u0019\u0000\u0000\u11d8\u11d9\u0007\u000b"+ + "\u0000\u0000\u11d9\u0218\u0001\u0000\u0000\u0000\u11da\u11db\u0007\u001b"+ + "\u0000\u0000\u11db\u11dc\u0007\u000b\u0000\u0000\u11dc\u11dd\u0007\u0013"+ + "\u0000\u0000\u11dd\u11de\u0007\f\u0000\u0000\u11de\u11df\u0005_\u0000"+ + "\u0000\u11df\u11e0\u0007\u0019\u0000\u0000\u11e0\u11e1\u0007\b\u0000\u0000"+ + "\u11e1\u11e2\u0007\u0007\u0000\u0000\u11e2\u11e3\u0007\u0006\u0000\u0000"+ + "\u11e3\u11e4\u0007\u0006\u0000\u0000\u11e4\u11e5\u0007\n\u0000\u0000\u11e5"+ + "\u021a\u0001\u0000\u0000\u0000\u11e6\u11e7\u0007\u001b\u0000\u0000\u11e7"+ + "\u11e8\u0007\u000b\u0000\u0000\u11e8\u11e9\u0007\u0013\u0000\u0000\u11e9"+ + "\u11ea\u0007\f\u0000\u0000\u11ea\u11eb\u0005_\u0000\u0000\u11eb\u11ec"+ + "\u0007\u001c\u0000\u0000\u11ec\u11ed\u0007\u0011\u0000\u0000\u11ed\u11ee"+ + "\u0007\u0013\u0000\u0000\u11ee\u11ef\u0007\u0006\u0000\u0000\u11ef\u11f0"+ + "\u0007\u0007\u0000\u0000\u11f0\u021c\u0001\u0000\u0000\u0000\u11f1\u11f2"+ + "\u0007\u001b\u0000\u0000\u11f2\u11f3\u0007\u000b\u0000\u0000\u11f3\u11f4"+ + "\u0007\u0013\u0000\u0000\u11f4\u11f5\u0007\f\u0000\u0000\u11f5\u11f6\u0005"+ + "_\u0000\u0000\u11f6\u11f7\u0007\b\u0000\u0000\u11f7\u11f8\u0007\u0007"+ + "\u0000\u0000\u11f8\u11f9\u0007\u0017\u0000\u0000\u11f9\u11fa\u0007\u0013"+ + "\u0000\u0000\u11fa\u11fb\u0007\u0018\u0000\u0000\u11fb\u11fc\u0007\u0007"+ + "\u0000\u0000\u11fc\u021e\u0001\u0000\u0000\u0000\u11fd\u11fe\u0007\u001b"+ + "\u0000\u0000\u11fe\u11ff\u0007\u000b\u0000\u0000\u11ff\u1200\u0007\u0013"+ + "\u0000\u0000\u1200\u1201\u0007\f\u0000\u0000\u1201\u1202\u0005_\u0000"+ + "\u0000\u1202\u1203\u0007\b\u0000\u0000\u1203\u1204\u0007\u0007\u0000\u0000"+ + "\u1204\u1205\u0007\u0019\u0000\u0000\u1205\u1206\u0007\u0005\u0000\u0000"+ + "\u1206\u1207\u0007\u0003\u0000\u0000\u1207\u1208\u0007\u000e\u0000\u0000"+ + "\u1208\u1209\u0007\u0007\u0000\u0000\u1209\u0220\u0001\u0000\u0000\u0000"+ + "\u120a\u120b\u0007\u001b\u0000\u0000\u120b\u120c\u0007\u000b\u0000\u0000"+ + "\u120c\u120d\u0007\u0013\u0000\u0000\u120d\u120e\u0007\f\u0000\u0000\u120e"+ + "\u120f\u0005_\u0000\u0000\u120f\u1210\u0007\u000b\u0000\u0000\u1210\u1211"+ + "\u0007\u000e\u0000\u0000\u1211\u1212\u0007\u0014\u0000\u0000\u1212\u1213"+ + "\u0007\u0007\u0000\u0000\u1213\u1214\u0007\u0017\u0000\u0000\u1214\u1215"+ + "\u0007\u0003\u0000\u0000\u1215\u1216\u0005_\u0000\u0000\u1216\u1217\u0007"+ + "\u0018\u0000\u0000\u1217\u1218\u0007\u0003\u0000\u0000\u1218\u1219\u0007"+ + "\u0005\u0000\u0000\u1219\u121a\u0007\u000f\u0000\u0000\u121a\u121b\u0007"+ + "\u0004\u0000\u0000\u121b\u0222\u0001\u0000\u0000\u0000\u121c\u121d\u0007"+ + "\u001b\u0000\u0000\u121d\u121e\u0007\u000b\u0000\u0000\u121e\u121f\u0007"+ + "\u0013\u0000\u0000\u121f\u1220\u0007\f\u0000\u0000\u1220\u1221\u0005_"+ + "\u0000\u0000\u1221\u1222\u0007\u000b\u0000\u0000\u1222\u1223\u0007\u000e"+ + "\u0000\u0000\u1223\u1224\u0007\u0014\u0000\u0000\u1224\u1225\u0007\u0007"+ + "\u0000\u0000\u1225\u1226\u0007\u0017\u0000\u0000\u1226\u1227\u0007\u0003"+ + "\u0000\u0000\u1227\u1228\u0005_\u0000\u0000\u1228\u1229\u0007\u0018\u0000"+ + "\u0000\u1229\u122a\u0007\u0003\u0000\u0000\u122a\u122b\u0007\u0005\u0000"+ + "\u0000\u122b\u122c\u0007\u000f\u0000\u0000\u122c\u122d\u0007\u0004\u0000"+ + "\u0000\u122d\u122e\u0007\u0003\u0000\u0000\u122e\u122f\u0007\u0006\u0000"+ + "\u0000\u122f\u1230\u0007\u000f\u0000\u0000\u1230\u1231\u0007\u0013\u0000"+ + "\u0000\u1231\u1232\u0007\f\u0000\u0000\u1232\u1233\u0005_\u0000\u0000"+ + "\u1233\u1234\u0007\b\u0000\u0000\u1234\u1235\u0007\u0007\u0000\u0000\u1235"+ + "\u1236\u0007\u0019\u0000\u0000\u1236\u1237\u0007\u0013\u0000\u0000\u1237"+ + "\u1238\u0007\b\u0000\u0000\u1238\u1239\u0007\u0006\u0000\u0000\u1239\u0224"+ + "\u0001\u0000\u0000\u0000\u123a\u123b\u0007\u001b\u0000\u0000\u123b\u123c"+ + "\u0007\u000b\u0000\u0000\u123c\u123d\u0007\u0013\u0000\u0000\u123d\u123e"+ + "\u0007\f\u0000\u0000\u123e\u123f\u0005_\u0000\u0000\u123f\u1240\u0007"+ + "\u000b\u0000\u0000\u1240\u1241\u0007\u0007\u0000\u0000\u1241\u1242\u0007"+ + "\u0003\u0000\u0000\u1242\u1243\u0007\b\u0000\u0000\u1243\u1244\u0007\u000e"+ + "\u0000\u0000\u1244\u1245\u0007\u0014\u0000\u0000\u1245\u0226\u0001\u0000"+ + "\u0000\u0000\u1246\u1247\u0007\u001b\u0000\u0000\u1247\u1248\u0007\u000b"+ + "\u0000\u0000\u1248\u1249\u0007\u0013\u0000\u0000\u1249\u124a\u0007\f\u0000"+ + "\u0000\u124a\u124b\u0005_\u0000\u0000\u124b\u124c\u0007\u000b\u0000\u0000"+ + "\u124c\u124d\u0007\u0007\u0000\u0000\u124d\u124e\u0007\u0006\u0000\u0000"+ + "\u124e\u0228\u0001\u0000\u0000\u0000\u124f\u1250\u0007\u001b\u0000\u0000"+ + "\u1250\u1251\u0007\u000b\u0000\u0000\u1251\u1252\u0007\u0013\u0000\u0000"+ + "\u1252\u1253\u0007\f\u0000\u0000\u1253\u1254\u0005_\u0000\u0000\u1254"+ + "\u1255\u0007\u000b\u0000\u0000\u1255\u1256\u0007\u0006\u0000\u0000\u1256"+ + "\u1257\u0007\u0013\u0000\u0000\u1257\u1258\u0007\b\u0000\u0000\u1258\u1259"+ + "\u0007\u0003\u0000\u0000\u1259\u125a\u0007\u0016\u0000\u0000\u125a\u125b"+ + "\u0007\u0007\u0000\u0000\u125b\u125c\u0005_\u0000\u0000\u125c\u125d\u0007"+ + "\u0012\u0000\u0000\u125d\u125e\u0007\b\u0000\u0000\u125e\u125f\u0007\u0007"+ + "\u0000\u0000\u125f\u1260\u0007\u0007\u0000\u0000\u1260\u022a\u0001\u0000"+ + "\u0000\u0000\u1261\u1262\u0007\u001b\u0000\u0000\u1262\u1263\u0007\u000b"+ + "\u0000\u0000\u1263\u1264\u0007\u0013\u0000\u0000\u1264\u1265\u0007\f\u0000"+ + "\u0000\u1265\u1266\u0005_\u0000\u0000\u1266\u1267\u0007\u000b\u0000\u0000"+ + "\u1267\u1268\u0007\u0006\u0000\u0000\u1268\u1269\u0007\u0013\u0000\u0000"+ + "\u1269\u126a\u0007\b\u0000\u0000\u126a\u126b\u0007\u0003\u0000\u0000\u126b"+ + "\u126c\u0007\u0016\u0000\u0000\u126c\u126d\u0007\u0007\u0000\u0000\u126d"+ + "\u126e\u0005_\u0000\u0000\u126e\u126f\u0007\u000b\u0000\u0000\u126f\u1270"+ + "\u0007\u000f\u0000\u0000\u1270\u1271\u0007\r\u0000\u0000\u1271\u1272\u0007"+ + "\u0007\u0000\u0000\u1272\u022c\u0001\u0000\u0000\u0000\u1273\u1274\u0007"+ + "\u001b\u0000\u0000\u1274\u1275\u0007\u000b\u0000\u0000\u1275\u1276\u0007"+ + "\u0013\u0000\u0000\u1276\u1277\u0007\f\u0000\u0000\u1277\u1278\u0005_"+ + "\u0000\u0000\u1278\u1279\u0007\u0006\u0000\u0000\u1279\u127a\u0007\u0003"+ + "\u0000\u0000\u127a\u127b\u0007\u0010\u0000\u0000\u127b\u127c\u0007\u0005"+ + "\u0000\u0000\u127c\u127d\u0007\u0007\u0000\u0000\u127d\u022e\u0001\u0000"+ + "\u0000\u0000\u127e\u127f\u0007\u001b\u0000\u0000\u127f\u1280\u0007\u000b"+ + "\u0000\u0000\u1280\u1281\u0007\u0013\u0000\u0000\u1281\u1282\u0007\f\u0000"+ + "\u0000\u1282\u1283\u0005_\u0000\u0000\u1283\u1284\u0007\u0006\u0000\u0000"+ + "\u1284\u1285\u0007\n\u0000\u0000\u1285\u1286\u0007\u0019\u0000\u0000\u1286"+ + "\u1287\u0007\u0007\u0000\u0000\u1287\u0230\u0001\u0000\u0000\u0000\u1288"+ + "\u1289\u0007\u001b\u0000\u0000\u1289\u128a\u0007\u000b\u0000\u0000\u128a"+ + "\u128b\u0007\u0013\u0000\u0000\u128b\u128c\u0007\f\u0000\u0000\u128c\u128d"+ + "\u0005_\u0000\u0000\u128d\u128e\u0007\u0011\u0000\u0000\u128e\u128f\u0007"+ + "\f\u0000\u0000\u128f\u1290\u0007\u001c\u0000\u0000\u1290\u1291\u0007\u0011"+ + "\u0000\u0000\u1291\u1292\u0007\u0013\u0000\u0000\u1292\u1293\u0007\u0006"+ + "\u0000\u0000\u1293\u1294\u0007\u0007\u0000\u0000\u1294\u0232\u0001\u0000"+ + "\u0000\u0000\u1295\u1296\u0007\u001b\u0000\u0000\u1296\u1297\u0007\u000b"+ + "\u0000\u0000\u1297\u1298\u0007\u0013\u0000\u0000\u1298\u1299\u0007\f\u0000"+ + "\u0000\u1299\u129a\u0005_\u0000\u0000\u129a\u129b\u0007\u0018\u0000\u0000"+ + "\u129b\u129c\u0007\u0003\u0000\u0000\u129c\u129d\u0007\u0005\u0000\u0000"+ + "\u129d\u129e\u0007\u000f\u0000\u0000\u129e\u129f\u0007\u0004\u0000\u0000"+ + "\u129f\u0234\u0001\u0000\u0000\u0000\u12a0\u12a1\u0007\u001b\u0000\u0000"+ + "\u12a1\u12a2\u0007\u000b\u0000\u0000\u12a2\u12a3\u0007\u0013\u0000\u0000"+ + "\u12a3\u12a4\u0007\f\u0000\u0000\u12a4\u12a5\u0005_\u0000\u0000\u12a5"+ + "\u12a6\u0007\u0018\u0000\u0000\u12a6\u12a7\u0007\u0003\u0000\u0000\u12a7"+ + "\u12a8\u0007\u0005\u0000\u0000\u12a8\u12a9\u0007\u0011\u0000\u0000\u12a9"+ + "\u12aa\u0007\u0007\u0000\u0000\u12aa\u0236\u0001\u0000\u0000\u0000\u12ab"+ + "\u12ac\u0007\f\u0000\u0000\u12ac\u12ad\u0007\u0007\u0000\u0000\u12ad\u12ae"+ + "\u0007\u000b\u0000\u0000\u12ae\u12af\u0007\u0006\u0000\u0000\u12af\u12b0"+ + "\u0007\u0007\u0000\u0000\u12b0\u12b1\u0007\u0004\u0000\u0000\u12b1\u0238"+ + "\u0001\u0000\u0000\u0000\u12b2\u12b3\u0007\u0013\u0000\u0000\u12b3\u12b4"+ + "\u0007\b\u0000\u0000\u12b4\u12b5\u0007\u0004\u0000\u0000\u12b5\u12b6\u0007"+ + "\u000f\u0000\u0000\u12b6\u12b7\u0007\f\u0000\u0000\u12b7\u12b8\u0007\u0003"+ + "\u0000\u0000\u12b8\u12b9\u0007\u0005\u0000\u0000\u12b9\u12ba\u0007\u000f"+ + "\u0000\u0000\u12ba\u12bb\u0007\u0006\u0000\u0000\u12bb\u12bc\u0007\n\u0000"+ + "\u0000\u12bc\u023a\u0001\u0000\u0000\u0000\u12bd\u12be\u0007\u0019\u0000"+ + "\u0000\u12be\u12bf\u0007\u0003\u0000\u0000\u12bf\u12c0\u0007\u0006\u0000"+ + "\u0000\u12c0\u12c1\u0007\u0014\u0000\u0000\u12c1\u023c\u0001\u0000\u0000"+ + "\u0000\u12c2\u12c3\u0007\u0003\u0000\u0000\u12c3\u12c4\u0007\u0018\u0000"+ + "\u0000\u12c4\u12c5\u0007\u0016\u0000\u0000\u12c5\u023e\u0001\u0000\u0000"+ + "\u0000\u12c6\u12c7\u0007\u0010\u0000\u0000\u12c7\u12c8\u0007\u000f\u0000"+ + "\u0000\u12c8\u12c9\u0007\u0006\u0000\u0000\u12c9\u12ca\u0005_\u0000\u0000"+ + "\u12ca\u12cb\u0007\u0003\u0000\u0000\u12cb\u12cc\u0007\f\u0000\u0000\u12cc"+ + "\u12cd\u0007\u0004\u0000\u0000\u12cd\u0240\u0001\u0000\u0000\u0000\u12ce"+ + "\u12cf\u0007\u0010\u0000\u0000\u12cf\u12d0\u0007\u000f\u0000\u0000\u12d0"+ + "\u12d1\u0007\u0006\u0000\u0000\u12d1\u12d2\u0005_\u0000\u0000\u12d2\u12d3"+ + "\u0007\u0013\u0000\u0000\u12d3\u12d4\u0007\b\u0000\u0000\u12d4\u0242\u0001"+ + "\u0000\u0000\u0000\u12d5\u12d6\u0007\u0010\u0000\u0000\u12d6\u12d7\u0007"+ + "\u000f\u0000\u0000\u12d7\u12d8\u0007\u0006\u0000\u0000\u12d8\u12d9\u0005"+ + "_\u0000\u0000\u12d9\u12da\u0007\u001a\u0000\u0000\u12da\u12db\u0007\u0013"+ + "\u0000\u0000\u12db\u12dc\u0007\b\u0000\u0000\u12dc\u0244\u0001\u0000\u0000"+ + "\u0000\u12dd\u12de\u0007\u000e\u0000\u0000\u12de\u12df\u0007\u0013\u0000"+ + "\u0000\u12df\u12e0\u0007\u0011\u0000\u0000\u12e0\u12e1\u0007\f\u0000\u0000"+ + "\u12e1\u12e2\u0007\u0006\u0000\u0000\u12e2\u0246\u0001\u0000\u0000\u0000"+ + "\u12e3\u12e4\u0007\u000e\u0000\u0000\u12e4\u12e5\u0007\u0011\u0000\u0000"+ + "\u12e5\u12e6\u0007\u0017\u0000\u0000\u12e6\u12e7\u0007\u0007\u0000\u0000"+ + "\u12e7\u12e8\u0005_\u0000\u0000\u12e8\u12e9\u0007\u0004\u0000\u0000\u12e9"+ + "\u12ea\u0007\u000f\u0000\u0000\u12ea\u12eb\u0007\u000b\u0000\u0000\u12eb"+ + "\u12ec\u0007\u0006\u0000\u0000\u12ec\u0248\u0001\u0000\u0000\u0000\u12ed"+ + "\u12ee\u0007\u0004\u0000\u0000\u12ee\u12ef\u0007\u0007\u0000\u0000\u12ef"+ + "\u12f0\u0007\f\u0000\u0000\u12f0\u12f1\u0007\u000b\u0000\u0000\u12f1\u12f2"+ + "\u0007\u0007\u0000\u0000\u12f2\u12f3\u0005_\u0000\u0000\u12f3\u12f4\u0007"+ + "\b\u0000\u0000\u12f4\u12f5\u0007\u0003\u0000\u0000\u12f5\u12f6\u0007\f"+ + "\u0000\u0000\u12f6\u12f7\u0007\u0015\u0000\u0000\u12f7\u024a\u0001\u0000"+ + "\u0000\u0000\u12f8\u12f9\u0007\u0012\u0000\u0000\u12f9\u12fa\u0007\u000f"+ + "\u0000\u0000\u12fa\u12fb\u0007\b\u0000\u0000\u12fb\u12fc\u0007\u000b\u0000"+ + "\u0000\u12fc\u12fd\u0007\u0006\u0000\u0000\u12fd\u12fe\u0005_\u0000\u0000"+ + "\u12fe\u12ff\u0007\u0018\u0000\u0000\u12ff\u1300\u0007\u0003\u0000\u0000"+ + "\u1300\u1301\u0007\u0005\u0000\u0000\u1301\u1302\u0007\u0011\u0000\u0000"+ + "\u1302\u1303\u0007\u0007\u0000\u0000\u1303\u024c\u0001\u0000\u0000\u0000"+ + "\u1304\u1305\u0007\u0016\u0000\u0000\u1305\u1306\u0007\b\u0000\u0000\u1306"+ + "\u1307\u0007\u0013\u0000\u0000\u1307\u1308\u0007\u0011\u0000\u0000\u1308"+ + "\u1309\u0007\u0019\u0000\u0000\u1309\u130a\u0005_\u0000\u0000\u130a\u130b"+ + "\u0007\u000e\u0000\u0000\u130b\u130c\u0007\u0013\u0000\u0000\u130c\u130d"+ + "\u0007\f\u0000\u0000\u130d\u130e\u0007\u000e\u0000\u0000\u130e\u130f\u0007"+ + "\u0003\u0000\u0000\u130f\u1310\u0007\u0006\u0000\u0000\u1310\u024e\u0001"+ + "\u0000\u0000\u0000\u1311\u1312\u0007\u0005\u0000\u0000\u1312\u1313\u0007"+ + "\u0003\u0000\u0000\u1313\u1314\u0007\u0016\u0000\u0000\u1314\u0250\u0001"+ + "\u0000\u0000\u0000\u1315\u1316\u0007\u0005\u0000\u0000\u1316\u1317\u0007"+ + "\u0003\u0000\u0000\u1317\u1318\u0007\u000b\u0000\u0000\u1318\u1319\u0007"+ + "\u0006\u0000\u0000\u1319\u131a\u0005_\u0000\u0000\u131a\u131b\u0007\u0018"+ + "\u0000\u0000\u131b\u131c\u0007\u0003\u0000\u0000\u131c\u131d\u0007\u0005"+ + "\u0000\u0000\u131d\u131e\u0007\u0011\u0000\u0000\u131e\u131f\u0007\u0007"+ + "\u0000\u0000\u131f\u0252\u0001\u0000\u0000\u0000\u1320\u1321\u0007\u0005"+ + "\u0000\u0000\u1321\u1322\u0007\u0007\u0000\u0000\u1322\u1323\u0007\u0003"+ + "\u0000\u0000\u1323\u1324\u0007\u0004\u0000\u0000\u1324\u0254\u0001\u0000"+ + "\u0000\u0000\u1325\u1326\u0007\u0017\u0000\u0000\u1326\u1327\u0007\u0003"+ + "\u0000\u0000\u1327\u1328\u0007\u001a\u0000\u0000\u1328\u0256\u0001\u0000"+ + "\u0000\u0000\u1329\u132a\u0007\u0017\u0000\u0000\u132a\u132b\u0007\u000f"+ + "\u0000\u0000\u132b\u132c\u0007\f\u0000\u0000\u132c\u0258\u0001\u0000\u0000"+ + "\u0000\u132d\u132e\u0007\f\u0000\u0000\u132e\u132f\u0007\u0006\u0000\u0000"+ + "\u132f\u1330\u0007\u000f\u0000\u0000\u1330\u1331\u0007\u0005\u0000\u0000"+ + "\u1331\u1332\u0007\u0007\u0000\u0000\u1332\u025a\u0001\u0000\u0000\u0000"+ + "\u1333\u1334\u0007\f\u0000\u0000\u1334\u1335\u0007\u0006\u0000\u0000\u1335"+ + "\u1336\u0007\u0014\u0000\u0000\u1336\u1337\u0005_\u0000\u0000\u1337\u1338"+ + "\u0007\u0018\u0000\u0000\u1338\u1339\u0007\u0003\u0000\u0000\u1339\u133a"+ + "\u0007\u0005\u0000\u0000\u133a\u133b\u0007\u0011\u0000\u0000\u133b\u133c"+ + "\u0007\u0007\u0000\u0000\u133c\u025c\u0001\u0000\u0000\u0000\u133d\u133e"+ + "\u0007\u0019\u0000\u0000\u133e\u133f\u0007\u0007\u0000\u0000\u133f\u1340"+ + "\u0007\b\u0000\u0000\u1340\u1341\u0007\u000e\u0000\u0000\u1341\u1342\u0007"+ + "\u0007\u0000\u0000\u1342\u1343\u0007\f\u0000\u0000\u1343\u1344\u0007\u0006"+ + "\u0000\u0000\u1344\u1345\u0005_\u0000\u0000\u1345\u1346\u0007\b\u0000"+ + "\u0000\u1346\u1347\u0007\u0003\u0000\u0000\u1347\u1348\u0007\f\u0000\u0000"+ + "\u1348\u1349\u0007\u0015\u0000\u0000\u1349\u025e\u0001\u0000\u0000\u0000"+ + "\u134a\u134b\u0007\b\u0000\u0000\u134b\u134c\u0007\u0003\u0000\u0000\u134c"+ + "\u134d\u0007\f\u0000\u0000\u134d\u134e\u0007\u0015\u0000\u0000\u134e\u0260"+ + "\u0001\u0000\u0000\u0000\u134f\u1350\u0007\b\u0000\u0000\u1350\u1351\u0007"+ + "\u0013\u0000\u0000\u1351\u1352\u0007\t\u0000\u0000\u1352\u1353\u0005_"+ + "\u0000\u0000\u1353\u1354\u0007\f\u0000\u0000\u1354\u1355\u0007\u0011\u0000"+ + "\u0000\u1355\u1356\u0007\u0017\u0000\u0000\u1356\u1357\u0007\u0010\u0000"+ + "\u0000\u1357\u1358\u0007\u0007\u0000\u0000\u1358\u1359\u0007\b\u0000\u0000"+ + "\u1359\u0262\u0001\u0000\u0000\u0000\u135a\u135b\u0007\u000b\u0000\u0000"+ + "\u135b\u135c\u0007\u0006\u0000\u0000\u135c\u135d\u0007\u0004\u0000\u0000"+ + "\u135d\u0264\u0001\u0000\u0000\u0000\u135e\u135f\u0007\u000b\u0000\u0000"+ + "\u135f\u1360\u0007\u0006\u0000\u0000\u1360\u1361\u0007\u0004\u0000\u0000"+ + "\u1361\u1362\u0007\u0004\u0000\u0000\u1362\u1363\u0007\u0007\u0000\u0000"+ + "\u1363\u1364\u0007\u0018\u0000\u0000\u1364\u0266\u0001\u0000\u0000\u0000"+ + "\u1365\u1366\u0007\u000b\u0000\u0000\u1366\u1367\u0007\u0006\u0000\u0000"+ + "\u1367\u1368\u0007\u0004\u0000\u0000\u1368\u1369\u0007\u0004\u0000\u0000"+ + "\u1369\u136a\u0007\u0007\u0000\u0000\u136a\u136b\u0007\u0018\u0000\u0000"+ + "\u136b\u136c\u0005_\u0000\u0000\u136c\u136d\u0007\u0019\u0000\u0000\u136d"+ + "\u136e\u0007\u0013\u0000\u0000\u136e\u136f\u0007\u0019\u0000\u0000\u136f"+ + "\u0268\u0001\u0000\u0000\u0000\u1370\u1371\u0007\u000b\u0000\u0000\u1371"+ + "\u1372\u0007\u0006\u0000\u0000\u1372\u1373\u0007\u0004\u0000\u0000\u1373"+ + "\u1374\u0007\u0004\u0000\u0000\u1374\u1375\u0007\u0007\u0000\u0000\u1375"+ + "\u1376\u0007\u0018\u0000\u0000\u1376\u1377\u0005_\u0000\u0000\u1377\u1378"+ + "\u0007\u000b\u0000\u0000\u1378\u1379\u0007\u0003\u0000\u0000\u1379\u137a"+ + "\u0007\u0017\u0000\u0000\u137a\u137b\u0007\u0019\u0000\u0000\u137b\u026a"+ + "\u0001\u0000\u0000\u0000\u137c\u137d\u0007\u000b\u0000\u0000\u137d\u137e"+ + "\u0007\u0011\u0000\u0000\u137e\u137f\u0007\u0017\u0000\u0000\u137f\u026c"+ + "\u0001\u0000\u0000\u0000\u1380\u1381\u0007\u0018\u0000\u0000\u1381\u1382"+ + "\u0007\u0003\u0000\u0000\u1382\u1383\u0007\b\u0000\u0000\u1383\u1384\u0005"+ + "_\u0000\u0000\u1384\u1385\u0007\u0019\u0000\u0000\u1385\u1386\u0007\u0013"+ + "\u0000\u0000\u1386\u1387\u0007\u0019\u0000\u0000\u1387\u026e\u0001\u0000"+ + "\u0000\u0000\u1388\u1389\u0007\u0018\u0000\u0000\u1389\u138a\u0007\u0003"+ + "\u0000\u0000\u138a\u138b\u0007\b\u0000\u0000\u138b\u138c\u0005_\u0000"+ + "\u0000\u138c\u138d\u0007\u000b\u0000\u0000\u138d\u138e\u0007\u0003\u0000"+ + "\u0000\u138e\u138f\u0007\u0017\u0000\u0000\u138f\u1390\u0007\u0019\u0000"+ + "\u0000\u1390\u0270\u0001\u0000\u0000\u0000\u1391\u1392\u0007\u0018\u0000"+ + "\u0000\u1392\u1393\u0007\u0003\u0000\u0000\u1393\u1394\u0007\b\u0000\u0000"+ + "\u1394\u1395\u0007\u000f\u0000\u0000\u1395\u1396\u0007\u0003\u0000\u0000"+ + "\u1396\u1397\u0007\f\u0000\u0000\u1397\u1398\u0007\u000e\u0000\u0000\u1398"+ + "\u1399\u0007\u0007\u0000\u0000\u1399\u0272\u0001\u0000\u0000\u0000\u139a"+ + "\u139b\u0007\u000e\u0000\u0000\u139b\u139c\u0007\u0011\u0000\u0000\u139c"+ + "\u139d\u0007\b\u0000\u0000\u139d\u139e\u0007\b\u0000\u0000\u139e\u139f"+ + "\u0007\u0007\u0000\u0000\u139f\u13a0\u0007\f\u0000\u0000\u13a0\u13a1\u0007"+ + "\u0006\u0000\u0000\u13a1\u13a2\u0005_\u0000\u0000\u13a2\u13a3\u0007\u0004"+ + "\u0000\u0000\u13a3\u13a4\u0007\u0003\u0000\u0000\u13a4\u13a5\u0007\u0006"+ + "\u0000\u0000\u13a5\u13a6\u0007\u0007\u0000\u0000\u13a6\u0274\u0001\u0000"+ + "\u0000\u0000\u13a7\u13a8\u0007\u000e\u0000\u0000\u13a8\u13a9\u0007\u0011"+ + "\u0000\u0000\u13a9\u13aa\u0007\b\u0000\u0000\u13aa\u13ab\u0007\b\u0000"+ + "\u0000\u13ab\u13ac\u0007\u0007\u0000\u0000\u13ac\u13ad\u0007\f\u0000\u0000"+ + "\u13ad\u13ae\u0007\u0006\u0000\u0000\u13ae\u13af\u0005_\u0000\u0000\u13af"+ + "\u13b0\u0007\u0006\u0000\u0000\u13b0\u13b1\u0007\u000f\u0000\u0000\u13b1"+ + "\u13b2\u0007\u0017\u0000\u0000\u13b2\u13b3\u0007\u0007\u0000\u0000\u13b3"+ + "\u0276\u0001\u0000\u0000\u0000\u13b4\u13b5\u0007\u000e\u0000\u0000\u13b5"+ + "\u13b6\u0007\u0011\u0000\u0000\u13b6\u13b7\u0007\b\u0000\u0000\u13b7\u13b8"+ + "\u0007\b\u0000\u0000\u13b8\u13b9\u0007\u0007\u0000\u0000\u13b9\u13ba\u0007"+ + "\f\u0000\u0000\u13ba\u13bb\u0007\u0006\u0000\u0000\u13bb\u13bc\u0005_"+ + "\u0000\u0000\u13bc\u13bd\u0007\u0006\u0000\u0000\u13bd\u13be\u0007\u000f"+ + "\u0000\u0000\u13be\u13bf\u0007\u0017\u0000\u0000\u13bf\u13c0\u0007\u0007"+ + "\u0000\u0000\u13c0\u13c1\u0007\u000b\u0000\u0000\u13c1\u13c2\u0007\u0006"+ + "\u0000\u0000\u13c2\u13c3\u0007\u0003\u0000\u0000\u13c3\u13c4\u0007\u0017"+ + "\u0000\u0000\u13c4\u13c5\u0007\u0019\u0000\u0000\u13c5\u0278\u0001\u0000"+ + "\u0000\u0000\u13c6\u13c7\u0007\u0005\u0000\u0000\u13c7\u13c8\u0007\u0013"+ + "\u0000\u0000\u13c8\u13c9\u0007\u000e\u0000\u0000\u13c9\u13ca\u0007\u0003"+ + "\u0000\u0000\u13ca\u13cb\u0007\u0005\u0000\u0000\u13cb\u13cc\u0007\u0006"+ + "\u0000\u0000\u13cc\u13cd\u0007\u000f\u0000\u0000\u13cd\u13ce\u0007\u0017"+ + "\u0000\u0000\u13ce\u13cf\u0007\u0007\u0000\u0000\u13cf\u027a\u0001\u0000"+ + "\u0000\u0000\u13d0\u13d1\u0007\u000e\u0000\u0000\u13d1\u13d2\u0007\u0011"+ + "\u0000\u0000\u13d2\u13d3\u0007\b\u0000\u0000\u13d3\u13d4\u0007\u0004\u0000"+ + "\u0000\u13d4\u13d5\u0007\u0003\u0000\u0000\u13d5\u13d6\u0007\u0006\u0000"+ + "\u0000\u13d6\u13d7\u0007\u0007\u0000\u0000\u13d7\u027c\u0001\u0000\u0000"+ + "\u0000\u13d8\u13d9\u0007\u000e\u0000\u0000\u13d9\u13da\u0007\u0011\u0000"+ + "\u0000\u13da\u13db\u0007\b\u0000\u0000\u13db\u13dc\u0007\u0006\u0000\u0000"+ + "\u13dc\u13dd\u0007\u000f\u0000\u0000\u13dd\u13de\u0007\u0017\u0000\u0000"+ + "\u13de\u13df\u0007\u0007\u0000\u0000\u13df\u027e\u0001\u0000\u0000\u0000"+ + "\u13e0\u13e1\u0007\u0004\u0000\u0000\u13e1\u13e2\u0007\u0003\u0000\u0000"+ + "\u13e2\u13e3\u0007\u0006\u0000\u0000\u13e3\u13e4\u0007\u0007\u0000\u0000"+ + "\u13e4\u13e5\u0005_\u0000\u0000\u13e5\u13e6\u0007\u0003\u0000\u0000\u13e6"+ + "\u13e7\u0007\u0004\u0000\u0000\u13e7\u13e8\u0007\u0004\u0000\u0000\u13e8"+ + "\u0280\u0001\u0000\u0000\u0000\u13e9\u13ea\u0007\u0004\u0000\u0000\u13ea"+ + "\u13eb\u0007\u0003\u0000\u0000\u13eb\u13ec\u0007\u0006\u0000\u0000\u13ec"+ + "\u13ed\u0007\u0007\u0000\u0000\u13ed\u13ee\u0005_\u0000\u0000\u13ee\u13ef"+ + "\u0007\u000b\u0000\u0000\u13ef\u13f0\u0007\u0011\u0000\u0000\u13f0\u13f1"+ + "\u0007\u0010\u0000\u0000\u13f1\u0282\u0001\u0000\u0000\u0000\u13f2\u13f3"+ + "\u0007\u0007\u0000\u0000\u13f3\u13f4\u0007\u001a\u0000\u0000\u13f4\u13f5"+ + "\u0007\u0006\u0000\u0000\u13f5\u13f6\u0007\b\u0000\u0000\u13f6\u13f7\u0007"+ + "\u0003\u0000\u0000\u13f7\u13f8\u0007\u000e\u0000\u0000\u13f8\u13f9\u0007"+ + "\u0006\u0000\u0000\u13f9\u0284\u0001\u0000\u0000\u0000\u13fa\u13fb\u0007"+ + "\u0005\u0000\u0000\u13fb\u13fc\u0007\u0013\u0000\u0000\u13fc\u13fd\u0007"+ + "\u000e\u0000\u0000\u13fd\u13fe\u0007\u0003\u0000\u0000\u13fe\u13ff\u0007"+ + "\u0005\u0000\u0000\u13ff\u1400\u0007\u0006\u0000\u0000\u1400\u1401\u0007"+ + "\u000f\u0000\u0000\u1401\u1402\u0007\u0017\u0000\u0000\u1402\u1403\u0007"+ + "\u0007\u0000\u0000\u1403\u1404\u0007\u000b\u0000\u0000\u1404\u1405\u0007"+ + "\u0006\u0000\u0000\u1405\u1406\u0007\u0003\u0000\u0000\u1406\u1407\u0007"+ + "\u0017\u0000\u0000\u1407\u1408\u0007\u0019\u0000\u0000\u1408\u0286\u0001"+ + "\u0000\u0000\u0000\u1409\u140a\u0007\f\u0000\u0000\u140a\u140b\u0007\u0013"+ + "\u0000\u0000\u140b\u140c\u0007\t\u0000\u0000\u140c\u0288\u0001\u0000\u0000"+ + "\u0000\u140d\u140e\u0007\u0019\u0000\u0000\u140e\u140f\u0007\u0013\u0000"+ + "\u0000\u140f\u1410\u0007\u000b\u0000\u0000\u1410\u1411\u0007\u000f\u0000"+ + "\u0000\u1411\u1412\u0007\u0006\u0000\u0000\u1412\u1413\u0007\u000f\u0000"+ + "\u0000\u1413\u1414\u0007\u0013\u0000\u0000\u1414\u1415\u0007\f\u0000\u0000"+ + "\u1415\u028a\u0001\u0000\u0000\u0000\u1416\u1417\u0007\u000b\u0000\u0000"+ + "\u1417\u1418\u0007\u0011\u0000\u0000\u1418\u1419\u0007\u0010\u0000\u0000"+ + "\u1419\u141a\u0007\u000b\u0000\u0000\u141a\u141b\u0007\u0006\u0000\u0000"+ + "\u141b\u141c\u0007\b\u0000\u0000\u141c\u028c\u0001\u0000\u0000\u0000\u141d"+ + "\u141e\u0007\u000b\u0000\u0000\u141e\u141f\u0007\u0011\u0000\u0000\u141f"+ + "\u1420\u0007\u0010\u0000\u0000\u1420\u1421\u0007\u000b\u0000\u0000\u1421"+ + "\u1422\u0007\u0006\u0000\u0000\u1422\u1423\u0007\b\u0000\u0000\u1423\u1424"+ + "\u0007\u000f\u0000\u0000\u1424\u1425\u0007\f\u0000\u0000\u1425\u1426\u0007"+ + "\u0016\u0000\u0000\u1426\u028e\u0001\u0000\u0000\u0000\u1427\u1428\u0007"+ + "\u000b\u0000\u0000\u1428\u1429\u0007\n\u0000\u0000\u1429\u142a\u0007\u000b"+ + "\u0000\u0000\u142a\u142b\u0007\u0004\u0000\u0000\u142b\u142c\u0007\u0003"+ + "\u0000\u0000\u142c\u142d\u0007\u0006\u0000\u0000\u142d\u142e\u0007\u0007"+ + "\u0000\u0000\u142e\u0290\u0001\u0000\u0000\u0000\u142f\u1430\u0007\u0006"+ + "\u0000\u0000\u1430\u1431\u0007\b\u0000\u0000\u1431\u1432\u0007\u000f\u0000"+ + "\u0000\u1432\u1433\u0007\u0017\u0000\u0000\u1433\u0292\u0001\u0000\u0000"+ + "\u0000\u1434\u1435\u0007\u0011\u0000\u0000\u1435\u1436\u0007\u0006\u0000"+ + "\u0000\u1436\u1437\u0007\u000e\u0000\u0000\u1437\u1438\u0005_\u0000\u0000"+ + "\u1438\u1439\u0007\u0004\u0000\u0000\u1439\u143a\u0007\u0003\u0000\u0000"+ + "\u143a\u143b\u0007\u0006\u0000\u0000\u143b\u143c\u0007\u0007\u0000\u0000"+ + "\u143c\u0294\u0001\u0000\u0000\u0000\u143d\u143e\u0007\u0011\u0000\u0000"+ + "\u143e\u143f\u0007\u0006\u0000\u0000\u143f\u1440\u0007\u000e\u0000\u0000"+ + "\u1440\u1441\u0005_\u0000\u0000\u1441\u1442\u0007\u0006\u0000\u0000\u1442"+ + "\u1443\u0007\u000f\u0000\u0000\u1443\u1444\u0007\u0017\u0000\u0000\u1444"+ + "\u1445\u0007\u0007\u0000\u0000\u1445\u0296\u0001\u0000\u0000\u0000\u1446"+ + "\u1447\u0007\u0011\u0000\u0000\u1447\u1448\u0007\u0006\u0000\u0000\u1448"+ + "\u1449\u0007\u000e\u0000\u0000\u1449\u144a\u0005_\u0000\u0000\u144a\u144b"+ + "\u0007\u0006\u0000\u0000\u144b\u144c\u0007\u000f\u0000\u0000\u144c\u144d"+ + "\u0007\u0017\u0000\u0000\u144d\u144e\u0007\u0007\u0000\u0000\u144e\u144f"+ + "\u0007\u000b\u0000\u0000\u144f\u1450\u0007\u0006\u0000\u0000\u1450\u1451"+ + "\u0007\u0003\u0000\u0000\u1451\u1452\u0007\u0017\u0000\u0000\u1452\u1453"+ + "\u0007\u0019\u0000\u0000\u1453\u0298\u0001\u0000\u0000\u0000\u1454\u1455"+ + "\u0007\u0003\u0000\u0000\u1455\u1456\u0007\u000e\u0000\u0000\u1456\u1457"+ + "\u0007\u000e\u0000\u0000\u1457\u1458\u0007\u0013\u0000\u0000\u1458\u1459"+ + "\u0007\u0011\u0000\u0000\u1459\u145a\u0007\f\u0000\u0000\u145a\u145b\u0007"+ + "\u0006\u0000\u0000\u145b\u029a\u0001\u0000\u0000\u0000\u145c\u145d\u0007"+ + "\u0003\u0000\u0000\u145d\u145e\u0007\u000e\u0000\u0000\u145e\u145f\u0007"+ + "\u0006\u0000\u0000\u145f\u1460\u0007\u000f\u0000\u0000\u1460\u1461\u0007"+ + "\u0013\u0000\u0000\u1461\u1462\u0007\f\u0000\u0000\u1462\u029c\u0001\u0000"+ + "\u0000\u0000\u1463\u1464\u0007\u0003\u0000\u0000\u1464\u1465\u0007\u0012"+ + "\u0000\u0000\u1465\u1466\u0007\u0006\u0000\u0000\u1466\u1467\u0007\u0007"+ + "\u0000\u0000\u1467\u1468\u0007\b\u0000\u0000\u1468\u029e\u0001\u0000\u0000"+ + "\u0000\u1469\u146a\u0007\u0003\u0000\u0000\u146a\u146b\u0007\u0016\u0000"+ + "\u0000\u146b\u146c\u0007\u0016\u0000\u0000\u146c\u146d\u0007\b\u0000\u0000"+ + "\u146d\u146e\u0007\u0007\u0000\u0000\u146e\u146f\u0007\u0016\u0000\u0000"+ + "\u146f\u1470\u0007\u0003\u0000\u0000\u1470\u1471\u0007\u0006\u0000\u0000"+ + "\u1471\u1472\u0007\u0007\u0000\u0000\u1472\u02a0\u0001\u0000\u0000\u0000"+ + "\u1473\u1474\u0007\u0003\u0000\u0000\u1474\u1475\u0007\u0005\u0000\u0000"+ + "\u1475\u1476\u0007\u0016\u0000\u0000\u1476\u1477\u0007\u0013\u0000\u0000"+ + "\u1477\u1478\u0007\b\u0000\u0000\u1478\u1479\u0007\u000f\u0000\u0000\u1479"+ + "\u147a\u0007\u0006\u0000\u0000\u147a\u147b\u0007\u0014\u0000\u0000\u147b"+ + "\u147c\u0007\u0017\u0000\u0000\u147c\u02a2\u0001\u0000\u0000\u0000\u147d"+ + "\u147e\u0007\u0003\u0000\u0000\u147e\u147f\u0007\f\u0000\u0000\u147f\u1480"+ + "\u0007\n\u0000\u0000\u1480\u02a4\u0001\u0000\u0000\u0000\u1481\u1482\u0007"+ + "\u0003\u0000\u0000\u1482\u1483\u0007\u0006\u0000\u0000\u1483\u02a6\u0001"+ + "\u0000\u0000\u0000\u1484\u1485\u0007\u0003\u0000\u0000\u1485\u1486\u0007"+ + "\u0011\u0000\u0000\u1486\u1487\u0007\u0006\u0000\u0000\u1487\u1488\u0007"+ + "\u0014\u0000\u0000\u1488\u1489\u0007\u0013\u0000\u0000\u1489\u148a\u0007"+ + "\b\u0000\u0000\u148a\u148b\u0007\u000b\u0000\u0000\u148b\u02a8\u0001\u0000"+ + "\u0000\u0000\u148c\u148d\u0007\u0003\u0000\u0000\u148d\u148e\u0007\u0011"+ + "\u0000\u0000\u148e\u148f\u0007\u0006\u0000\u0000\u148f\u1490\u0007\u0013"+ + "\u0000\u0000\u1490\u1491\u0007\u000e\u0000\u0000\u1491\u1492\u0007\u0013"+ + "\u0000\u0000\u1492\u1493\u0007\u0017\u0000\u0000\u1493\u1494\u0007\u0017"+ + "\u0000\u0000\u1494\u1495\u0007\u000f\u0000\u0000\u1495\u1496\u0007\u0006"+ + "\u0000\u0000\u1496\u02aa\u0001\u0000\u0000\u0000\u1497\u1498\u0007\u0003"+ + "\u0000\u0000\u1498\u1499\u0007\u0011\u0000\u0000\u1499\u149a\u0007\u0006"+ + "\u0000\u0000\u149a\u149b\u0007\u0013\u0000\u0000\u149b\u149c\u0007\u0007"+ + "\u0000\u0000\u149c\u149d\u0007\u001a\u0000\u0000\u149d\u149e\u0007\u0006"+ + "\u0000\u0000\u149e\u149f\u0007\u0007\u0000\u0000\u149f\u14a0\u0007\f\u0000"+ + "\u0000\u14a0\u14a1\u0007\u0004\u0000\u0000\u14a1\u14a2\u0005_\u0000\u0000"+ + "\u14a2\u14a3\u0007\u000b\u0000\u0000\u14a3\u14a4\u0007\u000f\u0000\u0000"+ + "\u14a4\u14a5\u0007\r\u0000\u0000\u14a5\u14a6\u0007\u0007\u0000\u0000\u14a6"+ + "\u02ac\u0001\u0000\u0000\u0000\u14a7\u14a8\u0007\u0003\u0000\u0000\u14a8"+ + "\u14a9\u0007\u0011\u0000\u0000\u14a9\u14aa\u0007\u0006\u0000\u0000\u14aa"+ + "\u14ab\u0007\u0013\u0000\u0000\u14ab\u14ac\u0005_\u0000\u0000\u14ac\u14ad"+ + "\u0007\u000f\u0000\u0000\u14ad\u14ae\u0007\f\u0000\u0000\u14ae\u14af\u0007"+ + "\u000e\u0000\u0000\u14af\u14b0\u0007\b\u0000\u0000\u14b0\u14b1\u0007\u0007"+ + "\u0000\u0000\u14b1\u14b2\u0007\u0017\u0000\u0000\u14b2\u14b3\u0007\u0007"+ + "\u0000\u0000\u14b3\u14b4\u0007\f\u0000\u0000\u14b4\u14b5\u0007\u0006\u0000"+ + "\u0000\u14b5\u02ae\u0001\u0000\u0000\u0000\u14b6\u14b7\u0007\u0003\u0000"+ + "\u0000\u14b7\u14b8\u0007\u0018\u0000\u0000\u14b8\u14b9\u0007\u0016\u0000"+ + "\u0000\u14b9\u14ba\u0005_\u0000\u0000\u14ba\u14bb\u0007\b\u0000\u0000"+ + "\u14bb\u14bc\u0007\u0013\u0000\u0000\u14bc\u14bd\u0007\t\u0000\u0000\u14bd"+ + "\u14be\u0005_\u0000\u0000\u14be\u14bf\u0007\u0005\u0000\u0000\u14bf\u14c0"+ + "\u0007\u0007\u0000\u0000\u14c0\u14c1\u0007\f\u0000\u0000\u14c1\u14c2\u0007"+ + "\u0016\u0000\u0000\u14c2\u14c3\u0007\u0006\u0000\u0000\u14c3\u14c4\u0007"+ + "\u0014\u0000\u0000\u14c4\u02b0\u0001\u0000\u0000\u0000\u14c5\u14c6\u0007"+ + "\u0010\u0000\u0000\u14c6\u14c7\u0007\u0007\u0000\u0000\u14c7\u14c8\u0007"+ + "\u0016\u0000\u0000\u14c8\u14c9\u0007\u000f\u0000\u0000\u14c9\u14ca\u0007"+ + "\f\u0000\u0000\u14ca\u02b2\u0001\u0000\u0000\u0000\u14cb\u14cc\u0007\u0010"+ + "\u0000\u0000\u14cc\u14cd\u0007\u000f\u0000\u0000\u14cd\u14ce\u0007\f\u0000"+ + "\u0000\u14ce\u14cf\u0007\u0005\u0000\u0000\u14cf\u14d0\u0007\u0013\u0000"+ + "\u0000\u14d0\u14d1\u0007\u0016\u0000\u0000\u14d1\u02b4\u0001\u0000\u0000"+ + "\u0000\u14d2\u14d3\u0007\u0010\u0000\u0000\u14d3\u14d4\u0007\u000f\u0000"+ + "\u0000\u14d4\u14d5\u0007\u0006\u0000\u0000\u14d5\u02b6\u0001\u0000\u0000"+ + "\u0000\u14d6\u14d7\u0007\u0010\u0000\u0000\u14d7\u14d8\u0007\u0005\u0000"+ + "\u0000\u14d8\u14d9\u0007\u0013\u0000\u0000\u14d9\u14da\u0007\u000e\u0000"+ + "\u0000\u14da\u14db\u0007\u0015\u0000\u0000\u14db\u02b8\u0001\u0000\u0000"+ + "\u0000\u14dc\u14dd\u0007\u0010\u0000\u0000\u14dd\u14de\u0007\u0013\u0000"+ + "\u0000\u14de\u14df\u0007\u0013\u0000\u0000\u14df\u14e0\u0007\u0005\u0000"+ + "\u0000\u14e0\u02ba\u0001\u0000\u0000\u0000\u14e1\u14e2\u0007\u0010\u0000"+ + "\u0000\u14e2\u14e3\u0007\u0013\u0000\u0000\u14e3\u14e4\u0007\u0013\u0000"+ + "\u0000\u14e4\u14e5\u0007\u0005\u0000\u0000\u14e5\u14e6\u0007\u0007\u0000"+ + "\u0000\u14e6\u14e7\u0007\u0003\u0000\u0000\u14e7\u14e8\u0007\f\u0000\u0000"+ + "\u14e8\u02bc\u0001\u0000\u0000\u0000\u14e9\u14ea\u0007\u0010\u0000\u0000"+ + "\u14ea\u14eb\u0007\u0006\u0000\u0000\u14eb\u14ec\u0007\b\u0000\u0000\u14ec"+ + "\u14ed\u0007\u0007\u0000\u0000\u14ed\u14ee\u0007\u0007\u0000\u0000\u14ee"+ + "\u02be\u0001\u0000\u0000\u0000\u14ef\u14f0\u0007\u000e\u0000\u0000\u14f0"+ + "\u14f1\u0007\u0003\u0000\u0000\u14f1\u14f2\u0007\u000e\u0000\u0000\u14f2"+ + "\u14f3\u0007\u0014\u0000\u0000\u14f3\u14f4\u0007\u0007\u0000\u0000\u14f4"+ + "\u02c0\u0001\u0000\u0000\u0000\u14f5\u14f6\u0007\u000e\u0000\u0000\u14f6"+ + "\u14f7\u0007\u0003\u0000\u0000\u14f7\u14f8\u0007\u000b\u0000\u0000\u14f8"+ + "\u14f9\u0007\u000e\u0000\u0000\u14f9\u14fa\u0007\u0003\u0000\u0000\u14fa"+ + "\u14fb\u0007\u0004\u0000\u0000\u14fb\u14fc\u0007\u0007\u0000\u0000\u14fc"+ + "\u14fd\u0007\u0004\u0000\u0000\u14fd\u02c2\u0001\u0000\u0000\u0000\u14fe"+ + "\u14ff\u0007\u000e\u0000\u0000\u14ff\u1500\u0007\u0014\u0000\u0000\u1500"+ + "\u1501\u0007\u0003\u0000\u0000\u1501\u1502\u0007\u000f\u0000\u0000\u1502"+ + "\u1503\u0007\f\u0000\u0000\u1503\u02c4\u0001\u0000\u0000\u0000\u1504\u1505"+ + "\u0007\u000e\u0000\u0000\u1505\u1506\u0007\u0014\u0000\u0000\u1506\u1507"+ + "\u0007\u0003\u0000\u0000\u1507\u1508\u0007\f\u0000\u0000\u1508\u1509\u0007"+ + "\u0016\u0000\u0000\u1509\u150a\u0007\u0007\u0000\u0000\u150a\u150b\u0007"+ + "\u0004\u0000\u0000\u150b\u02c6\u0001\u0000\u0000\u0000\u150c\u150d\u0007"+ + "\u000e\u0000\u0000\u150d\u150e\u0007\u0014\u0000\u0000\u150e\u150f\u0007"+ + "\u0003\u0000\u0000\u150f\u1510\u0007\f\u0000\u0000\u1510\u1511\u0007\f"+ + "\u0000\u0000\u1511\u1512\u0007\u0007\u0000\u0000\u1512\u1513\u0007\u0005"+ + "\u0000\u0000\u1513\u02c8\u0001\u0000\u0000\u0000\u1514\u1515\u0007\u000e"+ + "\u0000\u0000\u1515\u1516\u0007\u0014\u0000\u0000\u1516\u1517\u0007\u0007"+ + "\u0000\u0000\u1517\u1518\u0007\u000e\u0000\u0000\u1518\u1519\u0007\u0015"+ + "\u0000\u0000\u1519\u151a\u0007\u000b\u0000\u0000\u151a\u151b\u0007\u0011"+ + "\u0000\u0000\u151b\u151c\u0007\u0017\u0000\u0000\u151c\u02ca\u0001\u0000"+ + "\u0000\u0000\u151d\u151e\u0007\u0019\u0000\u0000\u151e\u151f\u0007\u0003"+ + "\u0000\u0000\u151f\u1520\u0007\u0016\u0000\u0000\u1520\u1521\u0007\u0007"+ + "\u0000\u0000\u1521\u1522\u0005_\u0000\u0000\u1522\u1523\u0007\u000e\u0000"+ + "\u0000\u1523\u1524\u0007\u0014\u0000\u0000\u1524\u1525\u0007\u0007\u0000"+ + "\u0000\u1525\u1526\u0007\u000e\u0000\u0000\u1526\u1527\u0007\u0015\u0000"+ + "\u0000\u1527\u1528\u0007\u000b\u0000\u0000\u1528\u1529\u0007\u0011\u0000"+ + "\u0000\u1529\u152a\u0007\u0017\u0000\u0000\u152a\u02cc\u0001\u0000\u0000"+ + "\u0000\u152b\u152c\u0007\u000e\u0000\u0000\u152c\u152d\u0007\u000f\u0000"+ + "\u0000\u152d\u152e\u0007\u0019\u0000\u0000\u152e\u152f\u0007\u0014\u0000"+ + "\u0000\u152f\u1530\u0007\u0007\u0000\u0000\u1530\u1531\u0007\b\u0000\u0000"+ + "\u1531\u02ce\u0001\u0000\u0000\u0000\u1532\u1533\u0007\u000e\u0000\u0000"+ + "\u1533\u1534\u0007\u0005\u0000\u0000\u1534\u1535\u0007\u0003\u0000\u0000"+ + "\u1535\u1536\u0007\u000b\u0000\u0000\u1536\u1537\u0007\u000b\u0000\u0000"+ + "\u1537\u1538\u0005_\u0000\u0000\u1538\u1539\u0007\u0013\u0000\u0000\u1539"+ + "\u153a\u0007\b\u0000\u0000\u153a\u153b\u0007\u000f\u0000\u0000\u153b\u153c"+ + "\u0007\u0016\u0000\u0000\u153c\u153d\u0007\u000f\u0000\u0000\u153d\u153e"+ + "\u0007\f\u0000\u0000\u153e\u02d0\u0001\u0000\u0000\u0000\u153f\u1540\u0007"+ + "\u000e\u0000\u0000\u1540\u1541\u0007\u0005\u0000\u0000\u1541\u1542\u0007"+ + "\u000f\u0000\u0000\u1542\u1543\u0007\u0007\u0000\u0000\u1543\u1544\u0007"+ + "\f\u0000\u0000\u1544\u1545\u0007\u0006\u0000\u0000\u1545\u02d2\u0001\u0000"+ + "\u0000\u0000\u1546\u1547\u0007\u000e\u0000\u0000\u1547\u1548\u0007\u0005"+ + "\u0000\u0000\u1548\u1549\u0007\u0013\u0000\u0000\u1549\u154a\u0007\u000b"+ + "\u0000\u0000\u154a\u154b\u0007\u0007\u0000\u0000\u154b\u02d4\u0001\u0000"+ + "\u0000\u0000\u154c\u154d\u0007\u000e\u0000\u0000\u154d\u154e\u0007\u0005"+ + "\u0000\u0000\u154e\u154f\u0007\u0011\u0000\u0000\u154f\u1550\u0007\u000b"+ + "\u0000\u0000\u1550\u1551\u0007\u0006\u0000\u0000\u1551\u1552\u0007\u0007"+ + "\u0000\u0000\u1552\u1553\u0007\b\u0000\u0000\u1553\u1554\u0007\u000f\u0000"+ + "\u0000\u1554\u1555\u0007\f\u0000\u0000\u1555\u1556\u0007\u0016\u0000\u0000"+ + "\u1556\u02d6\u0001\u0000\u0000\u0000\u1557\u1558\u0007\u000e\u0000\u0000"+ + "\u1558\u1559\u0007\u0013\u0000\u0000\u1559\u155a\u0007\u0003\u0000\u0000"+ + "\u155a\u155b\u0007\u0005\u0000\u0000\u155b\u155c\u0007\u0007\u0000\u0000"+ + "\u155c\u155d\u0007\u000b\u0000\u0000\u155d\u155e\u0007\u000e\u0000\u0000"+ + "\u155e\u155f\u0007\u0007\u0000\u0000\u155f\u02d8\u0001\u0000\u0000\u0000"+ + "\u1560\u1561\u0007\u000e\u0000\u0000\u1561\u1562\u0007\u0013\u0000\u0000"+ + "\u1562\u1563\u0007\u0004\u0000\u0000\u1563\u1564\u0007\u0007\u0000\u0000"+ + "\u1564\u02da\u0001\u0000\u0000\u0000\u1565\u1566\u0007\u000e\u0000\u0000"+ + "\u1566\u1567\u0007\u0013\u0000\u0000\u1567\u1568\u0007\u0005\u0000\u0000"+ + "\u1568\u1569\u0007\u0011\u0000\u0000\u1569\u156a\u0007\u0017\u0000\u0000"+ + "\u156a\u156b\u0007\f\u0000\u0000\u156b\u156c\u0007\u000b\u0000\u0000\u156c"+ + "\u02dc\u0001\u0000\u0000\u0000\u156d\u156e\u0007\u000e\u0000\u0000\u156e"+ + "\u156f\u0007\u0013\u0000\u0000\u156f\u1570\u0007\u0005\u0000\u0000\u1570"+ + "\u1571\u0007\u0011\u0000\u0000\u1571\u1572\u0007\u0017\u0000\u0000\u1572"+ + "\u1573\u0007\f\u0000\u0000\u1573\u1574\u0005_\u0000\u0000\u1574\u1575"+ + "\u0007\u0012\u0000\u0000\u1575\u1576\u0007\u0013\u0000\u0000\u1576\u1577"+ + "\u0007\b\u0000\u0000\u1577\u1578\u0007\u0017\u0000\u0000\u1578\u1579\u0007"+ + "\u0003\u0000\u0000\u1579\u157a\u0007\u0006\u0000\u0000\u157a\u02de\u0001"+ + "\u0000\u0000\u0000\u157b\u157c\u0007\u000e\u0000\u0000\u157c\u157d\u0007"+ + "\u0013\u0000\u0000\u157d\u157e\u0007\u0005\u0000\u0000\u157e\u157f\u0007"+ + "\u0011\u0000\u0000\u157f\u1580\u0007\u0017\u0000\u0000\u1580\u1581\u0007"+ + "\f\u0000\u0000\u1581\u1582\u0005_\u0000\u0000\u1582\u1583\u0007\f\u0000"+ + "\u0000\u1583\u1584\u0007\u0003\u0000\u0000\u1584\u1585\u0007\u0017\u0000"+ + "\u0000\u1585\u1586\u0007\u0007\u0000\u0000\u1586\u02e0\u0001\u0000\u0000"+ + "\u0000\u1587\u1588\u0007\u000e\u0000\u0000\u1588\u1589\u0007\u0013\u0000"+ + "\u0000\u1589\u158a\u0007\u0017\u0000\u0000\u158a\u158b\u0007\u0017\u0000"+ + "\u0000\u158b\u158c\u0007\u0007\u0000\u0000\u158c\u158d\u0007\f\u0000\u0000"+ + "\u158d\u158e\u0007\u0006\u0000\u0000\u158e\u02e2\u0001\u0000\u0000\u0000"+ + "\u158f\u1590\u0007\u000e\u0000\u0000\u1590\u1591\u0007\u0013\u0000\u0000"+ + "\u1591\u1592\u0007\u0017\u0000\u0000\u1592\u1593\u0007\u0017\u0000\u0000"+ + "\u1593\u1594\u0007\u000f\u0000\u0000\u1594\u1595\u0007\u0006\u0000\u0000"+ + "\u1595\u02e4\u0001\u0000\u0000\u0000\u1596\u1597\u0007\u000e\u0000\u0000"+ + "\u1597\u1598\u0007\u0013\u0000\u0000\u1598\u1599\u0007\u0017\u0000\u0000"+ + "\u1599\u159a\u0007\u0019\u0000\u0000\u159a\u159b\u0007\u0003\u0000\u0000"+ + "\u159b\u159c\u0007\u000e\u0000\u0000\u159c\u159d\u0007\u0006\u0000\u0000"+ + "\u159d\u02e6\u0001\u0000\u0000\u0000\u159e\u159f\u0007\u000e\u0000\u0000"+ + "\u159f\u15a0\u0007\u0013\u0000\u0000\u15a0\u15a1\u0007\u0017\u0000\u0000"+ + "\u15a1\u15a2\u0007\u0019\u0000\u0000\u15a2\u15a3\u0007\u0005\u0000\u0000"+ + "\u15a3\u15a4\u0007\u0007\u0000\u0000\u15a4\u15a5\u0007\u0006\u0000\u0000"+ + "\u15a5\u15a6\u0007\u000f\u0000\u0000\u15a6\u15a7\u0007\u0013\u0000\u0000"+ + "\u15a7\u15a8\u0007\f\u0000\u0000\u15a8\u02e8\u0001\u0000\u0000\u0000\u15a9"+ + "\u15aa\u0007\u000e\u0000\u0000\u15aa\u15ab\u0007\u0013\u0000\u0000\u15ab"+ + "\u15ac\u0007\u0017\u0000\u0000\u15ac\u15ad\u0007\u0019\u0000\u0000\u15ad"+ + "\u15ae\u0007\b\u0000\u0000\u15ae\u15af\u0007\u0007\u0000\u0000\u15af\u15b0"+ + "\u0007\u000b\u0000\u0000\u15b0\u15b1\u0007\u000b\u0000\u0000\u15b1\u15b2"+ + "\u0007\u0007\u0000\u0000\u15b2\u15b3\u0007\u0004\u0000\u0000\u15b3\u02ea"+ + "\u0001\u0000\u0000\u0000\u15b4\u15b5\u0007\u000e\u0000\u0000\u15b5\u15b6"+ + "\u0007\u0013\u0000\u0000\u15b6\u15b7\u0007\u0017\u0000\u0000\u15b7\u15b8"+ + "\u0007\u0019\u0000\u0000\u15b8\u15b9\u0007\b\u0000\u0000\u15b9\u15ba\u0007"+ + "\u0007\u0000\u0000\u15ba\u15bb\u0007\u000b\u0000\u0000\u15bb\u15bc\u0007"+ + "\u000b\u0000\u0000\u15bc\u15bd\u0007\u000f\u0000\u0000\u15bd\u15be\u0007"+ + "\u0013\u0000\u0000\u15be\u15bf\u0007\f\u0000\u0000\u15bf\u02ec\u0001\u0000"+ + "\u0000\u0000\u15c0\u15c1\u0007\u000e\u0000\u0000\u15c1\u15c2\u0007\u0013"+ + "\u0000\u0000\u15c2\u15c3\u0007\f\u0000\u0000\u15c3\u15c4\u0007\u000e\u0000"+ + "\u0000\u15c4\u15c5\u0007\u0011\u0000\u0000\u15c5\u15c6\u0007\b\u0000\u0000"+ + "\u15c6\u15c7\u0007\b\u0000\u0000\u15c7\u15c8\u0007\u0007\u0000\u0000\u15c8"+ + "\u15c9\u0007\f\u0000\u0000\u15c9\u15ca\u0007\u0006\u0000\u0000\u15ca\u02ee"+ + "\u0001\u0000\u0000\u0000\u15cb\u15cc\u0007\u000e\u0000\u0000\u15cc\u15cd"+ + "\u0007\u0013\u0000\u0000\u15cd\u15ce\u0007\f\u0000\u0000\u15ce\u15cf\u0007"+ + "\f\u0000\u0000\u15cf\u15d0\u0007\u0007\u0000\u0000\u15d0\u15d1\u0007\u000e"+ + "\u0000\u0000\u15d1\u15d2\u0007\u0006\u0000\u0000\u15d2\u02f0\u0001\u0000"+ + "\u0000\u0000\u15d3\u15d4\u0007\u000e\u0000\u0000\u15d4\u15d5\u0007\u0013"+ + "\u0000\u0000\u15d5\u15d6\u0007\f\u0000\u0000\u15d6\u15d7\u0007\f\u0000"+ + "\u0000\u15d7\u15d8\u0007\u0007\u0000\u0000\u15d8\u15d9\u0007\u000e\u0000"+ + "\u0000\u15d9\u15da\u0007\u0006\u0000\u0000\u15da\u15db\u0007\u000f\u0000"+ + "\u0000\u15db\u15dc\u0007\u0013\u0000\u0000\u15dc\u15dd\u0007\f\u0000\u0000"+ + "\u15dd\u02f2\u0001\u0000\u0000\u0000\u15de\u15df\u0007\u000e\u0000\u0000"+ + "\u15df\u15e0\u0007\u0013\u0000\u0000\u15e0\u15e1\u0007\f\u0000\u0000\u15e1"+ + "\u15e2\u0007\u000b\u0000\u0000\u15e2\u15e3\u0007\u000f\u0000\u0000\u15e3"+ + "\u15e4\u0007\u000b\u0000\u0000\u15e4\u15e5\u0007\u0006\u0000\u0000\u15e5"+ + "\u15e6\u0007\u0007\u0000\u0000\u15e6\u15e7\u0007\f\u0000\u0000\u15e7\u15e8"+ + "\u0007\u0006\u0000\u0000\u15e8\u02f4\u0001\u0000\u0000\u0000\u15e9\u15ea"+ + "\u0007\u000e\u0000\u0000\u15ea\u15eb\u0007\u0013\u0000\u0000\u15eb\u15ec"+ + "\u0007\f\u0000\u0000\u15ec\u15ed\u0007\u000b\u0000\u0000\u15ed\u15ee\u0007"+ + "\u0006\u0000\u0000\u15ee\u15ef\u0007\b\u0000\u0000\u15ef\u15f0\u0007\u0003"+ + "\u0000\u0000\u15f0\u15f1\u0007\u000f\u0000\u0000\u15f1\u15f2\u0007\f\u0000"+ + "\u0000\u15f2\u15f3\u0007\u0006\u0000\u0000\u15f3\u15f4\u0005_\u0000\u0000"+ + "\u15f4\u15f5\u0007\u000e\u0000\u0000\u15f5\u15f6\u0007\u0003\u0000\u0000"+ + "\u15f6\u15f7\u0007\u0006\u0000\u0000\u15f7\u15f8\u0007\u0003\u0000\u0000"+ + "\u15f8\u15f9\u0007\u0005\u0000\u0000\u15f9\u15fa\u0007\u0013\u0000\u0000"+ + "\u15fa\u15fb\u0007\u0016\u0000\u0000\u15fb\u02f6\u0001\u0000\u0000\u0000"+ + "\u15fc\u15fd\u0007\u000e\u0000\u0000\u15fd\u15fe\u0007\u0013\u0000\u0000"+ + "\u15fe\u15ff\u0007\f\u0000\u0000\u15ff\u1600\u0007\u000b\u0000\u0000\u1600"+ + "\u1601\u0007\u0006\u0000\u0000\u1601\u1602\u0007\b\u0000\u0000\u1602\u1603"+ + "\u0007\u0003\u0000\u0000\u1603\u1604\u0007\u000f\u0000\u0000\u1604\u1605"+ + "\u0007\f\u0000\u0000\u1605\u1606\u0007\u0006\u0000\u0000\u1606\u1607\u0005"+ + "_\u0000\u0000\u1607\u1608\u0007\u000b\u0000\u0000\u1608\u1609\u0007\u000e"+ + "\u0000\u0000\u1609\u160a\u0007\u0014\u0000\u0000\u160a\u160b\u0007\u0007"+ + "\u0000\u0000\u160b\u160c\u0007\u0017\u0000\u0000\u160c\u160d\u0007\u0003"+ + "\u0000\u0000\u160d\u02f8\u0001\u0000\u0000\u0000\u160e\u160f\u0007\u000e"+ + "\u0000\u0000\u160f\u1610\u0007\u0013\u0000\u0000\u1610\u1611\u0007\f\u0000"+ + "\u0000\u1611\u1612\u0007\u000b\u0000\u0000\u1612\u1613\u0007\u0006\u0000"+ + "\u0000\u1613\u1614\u0007\b\u0000\u0000\u1614\u1615\u0007\u0003\u0000\u0000"+ + "\u1615\u1616\u0007\u000f\u0000\u0000\u1616\u1617\u0007\f\u0000\u0000\u1617"+ + "\u1618\u0007\u0006\u0000\u0000\u1618\u1619\u0005_\u0000\u0000\u1619\u161a"+ + "\u0007\f\u0000\u0000\u161a\u161b\u0007\u0003\u0000\u0000\u161b\u161c\u0007"+ + "\u0017\u0000\u0000\u161c\u161d\u0007\u0007\u0000\u0000\u161d\u02fa\u0001"+ + "\u0000\u0000\u0000\u161e\u161f\u0007\u000e\u0000\u0000\u161f\u1620\u0007"+ + "\u0013\u0000\u0000\u1620\u1621\u0007\f\u0000\u0000\u1621\u1622\u0007\u0006"+ + "\u0000\u0000\u1622\u1623\u0007\u0003\u0000\u0000\u1623\u1624\u0007\u000f"+ + "\u0000\u0000\u1624\u1625\u0007\f\u0000\u0000\u1625\u1626\u0007\u000b\u0000"+ + "\u0000\u1626\u02fc\u0001\u0000\u0000\u0000\u1627\u1628\u0007\u000e\u0000"+ + "\u0000\u1628\u1629\u0007\u0013\u0000\u0000\u1629\u162a\u0007\f\u0000\u0000"+ + "\u162a\u162b\u0007\u0006\u0000\u0000\u162b\u162c\u0007\u0007\u0000\u0000"+ + "\u162c\u162d\u0007\u001a\u0000\u0000\u162d\u162e\u0007\u0006\u0000\u0000"+ + "\u162e\u02fe\u0001\u0000\u0000\u0000\u162f\u1630\u0007\u000e\u0000\u0000"+ + "\u1630\u1631\u0007\u0013\u0000\u0000\u1631\u1632\u0007\f\u0000\u0000\u1632"+ + "\u1633\u0007\u0006\u0000\u0000\u1633\u1634\u0007\b\u0000\u0000\u1634\u1635"+ + "\u0007\u000f\u0000\u0000\u1635\u1636\u0007\u0010\u0000\u0000\u1636\u1637"+ + "\u0007\u0011\u0000\u0000\u1637\u1638\u0007\u0006\u0000\u0000\u1638\u1639"+ + "\u0007\u0013\u0000\u0000\u1639\u163a\u0007\b\u0000\u0000\u163a\u163b\u0007"+ + "\u000b\u0000\u0000\u163b\u0300\u0001\u0000\u0000\u0000\u163c\u163d\u0007"+ + "\u000e\u0000\u0000\u163d\u163e\u0007\u0013\u0000\u0000\u163e\u163f\u0007"+ + "\u0019\u0000\u0000\u163f\u1640\u0007\n\u0000\u0000\u1640\u0302\u0001\u0000"+ + "\u0000\u0000\u1641\u1642\u0007\u000e\u0000\u0000\u1642\u1643\u0007\u0019"+ + "\u0000\u0000\u1643\u1644\u0007\u0011\u0000\u0000\u1644\u0304\u0001\u0000"+ + "\u0000\u0000\u1645\u1646\u0007\u000e\u0000\u0000\u1646\u1647\u0007\n\u0000"+ + "\u0000\u1647\u1648\u0007\u000e\u0000\u0000\u1648\u1649\u0007\u0005\u0000"+ + "\u0000\u1649\u164a\u0007\u0007\u0000\u0000\u164a\u0306\u0001\u0000\u0000"+ + "\u0000\u164b\u164c\u0007\u000e\u0000\u0000\u164c\u164d\u0007\u0011\u0000"+ + "\u0000\u164d\u164e\u0007\b\u0000\u0000\u164e\u164f\u0007\u000b\u0000\u0000"+ + "\u164f\u1650\u0007\u0013\u0000\u0000\u1650\u1651\u0007\b\u0000\u0000\u1651"+ + "\u1652\u0005_\u0000\u0000\u1652\u1653\u0007\f\u0000\u0000\u1653\u1654"+ + "\u0007\u0003\u0000\u0000\u1654\u1655\u0007\u0017\u0000\u0000\u1655\u1656"+ + "\u0007\u0007\u0000\u0000\u1656\u0308\u0001\u0000\u0000\u0000\u1657\u1658"+ + "\u0007\u0004\u0000\u0000\u1658\u1659\u0007\u0003\u0000\u0000\u1659\u165a"+ + "\u0007\u0006\u0000\u0000\u165a\u165b\u0007\u0003\u0000\u0000\u165b\u030a"+ + "\u0001\u0000\u0000\u0000\u165c\u165d\u0007\u0004\u0000\u0000\u165d\u165e"+ + "\u0007\u0003\u0000\u0000\u165e\u165f\u0007\u0006\u0000\u0000\u165f\u1660"+ + "\u0007\u0003\u0000\u0000\u1660\u1661\u0007\u0012\u0000\u0000\u1661\u1662"+ + "\u0007\u000f\u0000\u0000\u1662\u1663\u0007\u0005\u0000\u0000\u1663\u1664"+ + "\u0007\u0007\u0000\u0000\u1664\u030c\u0001\u0000\u0000\u0000\u1665\u1666"+ + "\u0007\u0004\u0000\u0000\u1666\u1667\u0007\u0007\u0000\u0000\u1667\u1668"+ + "\u0007\u0003\u0000\u0000\u1668\u1669\u0007\u0005\u0000\u0000\u1669\u166a"+ + "\u0007\u0005\u0000\u0000\u166a\u166b\u0007\u0013\u0000\u0000\u166b\u166c"+ + "\u0007\u000e\u0000\u0000\u166c\u166d\u0007\u0003\u0000\u0000\u166d\u166e"+ + "\u0007\u0006\u0000\u0000\u166e\u166f\u0007\u0007\u0000\u0000\u166f\u030e"+ + "\u0001\u0000\u0000\u0000\u1670\u1671\u0007\u0004\u0000\u0000\u1671\u1672"+ + "\u0007\u0007\u0000\u0000\u1672\u1673\u0007\u0012\u0000\u0000\u1673\u1674"+ + "\u0007\u0003\u0000\u0000\u1674\u1675\u0007\u0011\u0000\u0000\u1675\u1676"+ + "\u0007\u0005\u0000\u0000\u1676\u1677\u0007\u0006\u0000\u0000\u1677\u1678"+ + "\u0005_\u0000\u0000\u1678\u1679\u0007\u0003\u0000\u0000\u1679\u167a\u0007"+ + "\u0011\u0000\u0000\u167a\u167b\u0007\u0006\u0000\u0000\u167b\u167c\u0007"+ + "\u0014\u0000\u0000\u167c\u0310\u0001\u0000\u0000\u0000\u167d\u167e\u0007"+ + "\u0004\u0000\u0000\u167e\u167f\u0007\u0007\u0000\u0000\u167f\u1680\u0007"+ + "\u0012\u0000\u0000\u1680\u1681\u0007\u000f\u0000\u0000\u1681\u1682\u0007"+ + "\f\u0000\u0000\u1682\u1683\u0007\u0007\u0000\u0000\u1683\u1684\u0007\b"+ + "\u0000\u0000\u1684\u0312\u0001\u0000\u0000\u0000\u1685\u1686\u0007\u0004"+ + "\u0000\u0000\u1686\u1687\u0007\u0007\u0000\u0000\u1687\u1688\u0007\u0005"+ + "\u0000\u0000\u1688\u1689\u0007\u0003\u0000\u0000\u1689\u168a\u0007\n\u0000"+ + "\u0000\u168a\u168b\u0005_\u0000\u0000\u168b\u168c\u0007\u0015\u0000\u0000"+ + "\u168c\u168d\u0007\u0007\u0000\u0000\u168d\u168e\u0007\n\u0000\u0000\u168e"+ + "\u168f\u0005_\u0000\u0000\u168f\u1690\u0007\t\u0000\u0000\u1690\u1691"+ + "\u0007\b\u0000\u0000\u1691\u1692\u0007\u000f\u0000\u0000\u1692\u1693\u0007"+ + "\u0006\u0000\u0000\u1693\u1694\u0007\u0007\u0000\u0000\u1694\u0314\u0001"+ + "\u0000\u0000\u0000\u1695\u1696\u0007\u0004\u0000\u0000\u1696\u1697\u0007"+ + "\u0007\u0000\u0000\u1697\u1698\u0007\u000b\u0000\u0000\u1698\u1699\u0005"+ + "_\u0000\u0000\u1699\u169a\u0007\u0015\u0000\u0000\u169a\u169b\u0007\u0007"+ + "\u0000\u0000\u169b\u169c\u0007\n\u0000\u0000\u169c\u169d\u0005_\u0000"+ + "\u0000\u169d\u169e\u0007\u0012\u0000\u0000\u169e\u169f\u0007\u000f\u0000"+ + "\u0000\u169f\u16a0\u0007\u0005\u0000\u0000\u16a0\u16a1\u0007\u0007\u0000"+ + "\u0000\u16a1\u0316\u0001\u0000\u0000\u0000\u16a2\u16a3\u0007\u0004\u0000"+ + "\u0000\u16a3\u16a4\u0007\u000f\u0000\u0000\u16a4\u16a5\u0007\b\u0000\u0000"+ + "\u16a5\u16a6\u0007\u0007\u0000\u0000\u16a6\u16a7\u0007\u000e\u0000\u0000"+ + "\u16a7\u16a8\u0007\u0006\u0000\u0000\u16a8\u16a9\u0007\u0013\u0000\u0000"+ + "\u16a9\u16aa\u0007\b\u0000\u0000\u16aa\u16ab\u0007\n\u0000\u0000\u16ab"+ + "\u0318\u0001\u0000\u0000\u0000\u16ac\u16ad\u0007\u0004\u0000\u0000\u16ad"+ + "\u16ae\u0007\u000f\u0000\u0000\u16ae\u16af\u0007\u000b\u0000\u0000\u16af"+ + "\u16b0\u0007\u0003\u0000\u0000\u16b0\u16b1\u0007\u0010\u0000\u0000\u16b1"+ + "\u16b2\u0007\u0005\u0000\u0000\u16b2\u16b3\u0007\u0007\u0000\u0000\u16b3"+ + "\u031a\u0001\u0000\u0000\u0000\u16b4\u16b5\u0007\u0004\u0000\u0000\u16b5"+ + "\u16b6\u0007\u000f\u0000\u0000\u16b6\u16b7\u0007\u000b\u0000\u0000\u16b7"+ + "\u16b8\u0007\u000e\u0000\u0000\u16b8\u16b9\u0007\u0003\u0000\u0000\u16b9"+ + "\u16ba\u0007\b\u0000\u0000\u16ba\u16bb\u0007\u0004\u0000\u0000\u16bb\u031c"+ + "\u0001\u0000\u0000\u0000\u16bc\u16bd\u0007\u0004\u0000\u0000\u16bd\u16be"+ + "\u0007\u000f\u0000\u0000\u16be\u16bf\u0007\u000b\u0000\u0000\u16bf\u16c0"+ + "\u0007\u0015\u0000\u0000\u16c0\u031e\u0001\u0000\u0000\u0000\u16c1\u16c2"+ + "\u0007\u0004\u0000\u0000\u16c2\u16c3\u0007\u0013\u0000\u0000\u16c3\u0320"+ + "\u0001\u0000\u0000\u0000\u16c4\u16c5\u0007\u0004\u0000\u0000\u16c5\u16c6"+ + "\u0007\u0011\u0000\u0000\u16c6\u16c7\u0007\u0017\u0000\u0000\u16c7\u16c8"+ + "\u0007\u0019\u0000\u0000\u16c8\u16c9\u0007\u0012\u0000\u0000\u16c9\u16ca"+ + "\u0007\u000f\u0000\u0000\u16ca\u16cb\u0007\u0005\u0000\u0000\u16cb\u16cc"+ + "\u0007\u0007\u0000\u0000\u16cc\u0322\u0001\u0000\u0000\u0000\u16cd\u16ce"+ + "\u0007\u0004\u0000\u0000\u16ce\u16cf\u0007\u0011\u0000\u0000\u16cf\u16d0"+ + "\u0007\u0019\u0000\u0000\u16d0\u16d1\u0007\u0005\u0000\u0000\u16d1\u16d2"+ + "\u0007\u000f\u0000\u0000\u16d2\u16d3\u0007\u000e\u0000\u0000\u16d3\u16d4"+ + "\u0007\u0003\u0000\u0000\u16d4\u16d5\u0007\u0006\u0000\u0000\u16d5\u16d6"+ + "\u0007\u0007\u0000\u0000\u16d6\u0324\u0001\u0000\u0000\u0000\u16d7\u16d8"+ + "\u0007\u0004\u0000\u0000\u16d8\u16d9\u0007\n\u0000\u0000\u16d9\u16da\u0007"+ + "\f\u0000\u0000\u16da\u16db\u0007\u0003\u0000\u0000\u16db\u16dc\u0007\u0017"+ + "\u0000\u0000\u16dc\u16dd\u0007\u000f\u0000\u0000\u16dd\u16de\u0007\u000e"+ + "\u0000\u0000\u16de\u0326\u0001\u0000\u0000\u0000\u16df\u16e0\u0007\u0007"+ + "\u0000\u0000\u16e0\u16e1\u0007\f\u0000\u0000\u16e1\u16e2\u0007\u0003\u0000"+ + "\u0000\u16e2\u16e3\u0007\u0010\u0000\u0000\u16e3\u16e4\u0007\u0005\u0000"+ + "\u0000\u16e4\u16e5\u0007\u0007\u0000\u0000\u16e5\u0328\u0001\u0000\u0000"+ + "\u0000\u16e6\u16e7\u0007\u0007\u0000\u0000\u16e7\u16e8\u0007\f\u0000\u0000"+ + "\u16e8\u16e9\u0007\u000e\u0000\u0000\u16e9\u16ea\u0007\b\u0000\u0000\u16ea"+ + "\u16eb\u0007\n\u0000\u0000\u16eb\u16ec\u0007\u0019\u0000\u0000\u16ec\u16ed"+ + "\u0007\u0006\u0000\u0000\u16ed\u16ee\u0007\u0007\u0000\u0000\u16ee\u16ef"+ + "\u0007\u0004\u0000\u0000\u16ef\u032a\u0001\u0000\u0000\u0000\u16f0\u16f1"+ + "\u0007\u0007\u0000\u0000\u16f1\u16f2\u0007\f\u0000\u0000\u16f2\u16f3\u0007"+ + "\u000e\u0000\u0000\u16f3\u16f4\u0007\b\u0000\u0000\u16f4\u16f5\u0007\n"+ + "\u0000\u0000\u16f5\u16f6\u0007\u0019\u0000\u0000\u16f6\u16f7\u0007\u0006"+ + "\u0000\u0000\u16f7\u16f8\u0007\u000f\u0000\u0000\u16f8\u16f9\u0007\u0013"+ + "\u0000\u0000\u16f9\u16fa\u0007\f\u0000\u0000\u16fa\u032c\u0001\u0000\u0000"+ + "\u0000\u16fb\u16fc\u0007\u0007\u0000\u0000\u16fc\u16fd\u0007\f\u0000\u0000"+ + "\u16fd\u16fe\u0007\u000e\u0000\u0000\u16fe\u16ff\u0007\b\u0000\u0000\u16ff"+ + "\u1700\u0007\n\u0000\u0000\u1700\u1701\u0007\u0019\u0000\u0000\u1701\u1702"+ + "\u0007\u0006\u0000\u0000\u1702\u1703\u0007\u000f\u0000\u0000\u1703\u1704"+ + "\u0007\u0013\u0000\u0000\u1704\u1705\u0007\f\u0000\u0000\u1705\u1706\u0005"+ + "_\u0000\u0000\u1706\u1707\u0007\u0015\u0000\u0000\u1707\u1708"; + private static final String _serializedATNSegment3 = + "\u0007\u0007\u0000\u0000\u1708\u1709\u0007\n\u0000\u0000\u1709\u170a\u0005"+ + "_\u0000\u0000\u170a\u170b\u0007\u000f\u0000\u0000\u170b\u170c\u0007\u0004"+ + "\u0000\u0000\u170c\u032e\u0001\u0000\u0000\u0000\u170d\u170e\u0007\u0007"+ + "\u0000\u0000\u170e\u170f\u0007\f\u0000\u0000\u170f\u1710\u0007\u0004\u0000"+ + "\u0000\u1710\u0330\u0001\u0000\u0000\u0000\u1711\u1712\u0007\u0007\u0000"+ + "\u0000\u1712\u1713\u0007\f\u0000\u0000\u1713\u1714\u0007\u0004\u0000\u0000"+ + "\u1714\u1715\u0007\u000b\u0000\u0000\u1715\u0332\u0001\u0000\u0000\u0000"+ + "\u1716\u1717\u0007\u0007\u0000\u0000\u1717\u1718\u0007\f\u0000\u0000\u1718"+ + "\u1719\u0007\u0016\u0000\u0000\u1719\u171a\u0007\u000f\u0000\u0000\u171a"+ + "\u171b\u0007\f\u0000\u0000\u171b\u171c\u0007\u0007\u0000\u0000\u171c\u0334"+ + "\u0001\u0000\u0000\u0000\u171d\u171e\u0007\u0007\u0000\u0000\u171e\u171f"+ + "\u0007\f\u0000\u0000\u171f\u1720\u0007\u0016\u0000\u0000\u1720\u1721\u0007"+ + "\u000f\u0000\u0000\u1721\u1722\u0007\f\u0000\u0000\u1722\u1723\u0007\u0007"+ + "\u0000\u0000\u1723\u1724\u0007\u000b\u0000\u0000\u1724\u0336\u0001\u0000"+ + "\u0000\u0000\u1725\u1726\u0007\u0007\u0000\u0000\u1726\u1727\u0007\b\u0000"+ + "\u0000\u1727\u1728\u0007\b\u0000\u0000\u1728\u1729\u0007\u0013\u0000\u0000"+ + "\u1729\u172a\u0007\b\u0000\u0000\u172a\u0338\u0001\u0000\u0000\u0000\u172b"+ + "\u172c\u0007\u0007\u0000\u0000\u172c\u172d\u0007\b\u0000\u0000\u172d\u172e"+ + "\u0007\b\u0000\u0000\u172e\u172f\u0007\u0013\u0000\u0000\u172f\u1730\u0007"+ + "\b\u0000\u0000\u1730\u1731\u0007\u000b\u0000\u0000\u1731\u033a\u0001\u0000"+ + "\u0000\u0000\u1732\u1733\u0007\u0007\u0000\u0000\u1733\u1734\u0007\u000b"+ + "\u0000\u0000\u1734\u1735\u0007\u000e\u0000\u0000\u1735\u1736\u0007\u0003"+ + "\u0000\u0000\u1736\u1737\u0007\u0019\u0000\u0000\u1737\u1738\u0007\u0007"+ + "\u0000\u0000\u1738\u033c\u0001\u0000\u0000\u0000\u1739\u173a\u0007\u0007"+ + "\u0000\u0000\u173a\u173b\u0007\u0018\u0000\u0000\u173b\u173c\u0007\u0007"+ + "\u0000\u0000\u173c\u173d\u0007\f\u0000\u0000\u173d\u033e\u0001\u0000\u0000"+ + "\u0000\u173e\u173f\u0007\u0007\u0000\u0000\u173f\u1740\u0007\u0018\u0000"+ + "\u0000\u1740\u1741\u0007\u0007\u0000\u0000\u1741\u1742\u0007\f\u0000\u0000"+ + "\u1742\u1743\u0007\u0006\u0000\u0000\u1743\u0340\u0001\u0000\u0000\u0000"+ + "\u1744\u1745\u0007\u0007\u0000\u0000\u1745\u1746\u0007\u0018\u0000\u0000"+ + "\u1746\u1747\u0007\u0007\u0000\u0000\u1747\u1748\u0007\f\u0000\u0000\u1748"+ + "\u1749\u0007\u0006\u0000\u0000\u1749\u174a\u0007\u000b\u0000\u0000\u174a"+ + "\u0342\u0001\u0000\u0000\u0000\u174b\u174c\u0007\u0007\u0000\u0000\u174c"+ + "\u174d\u0007\u0018\u0000\u0000\u174d\u174e\u0007\u0007\u0000\u0000\u174e"+ + "\u174f\u0007\b\u0000\u0000\u174f\u1750\u0007\n\u0000\u0000\u1750\u0344"+ + "\u0001\u0000\u0000\u0000\u1751\u1752\u0007\u0007\u0000\u0000\u1752\u1753"+ + "\u0007\u001a\u0000\u0000\u1753\u1754\u0007\u000e\u0000\u0000\u1754\u1755"+ + "\u0007\u0014\u0000\u0000\u1755\u1756\u0007\u0003\u0000\u0000\u1756\u1757"+ + "\u0007\f\u0000\u0000\u1757\u1758\u0007\u0016\u0000\u0000\u1758\u1759\u0007"+ + "\u0007\u0000\u0000\u1759\u0346\u0001\u0000\u0000\u0000\u175a\u175b\u0007"+ + "\u0007\u0000\u0000\u175b\u175c\u0007\u001a\u0000\u0000\u175c\u175d\u0007"+ + "\u000e\u0000\u0000\u175d\u175e\u0007\u0005\u0000\u0000\u175e\u175f\u0007"+ + "\u0011\u0000\u0000\u175f\u1760\u0007\u000b\u0000\u0000\u1760\u1761\u0007"+ + "\u000f\u0000\u0000\u1761\u1762\u0007\u0018\u0000\u0000\u1762\u1763\u0007"+ + "\u0007\u0000\u0000\u1763\u0348\u0001\u0000\u0000\u0000\u1764\u1765\u0007"+ + "\u0007\u0000\u0000\u1765\u1766\u0007\u001a\u0000\u0000\u1766\u1767\u0007"+ + "\u0019\u0000\u0000\u1767\u1768\u0007\u000f\u0000\u0000\u1768\u1769\u0007"+ + "\b\u0000\u0000\u1769\u176a\u0007\u0007\u0000\u0000\u176a\u034a\u0001\u0000"+ + "\u0000\u0000\u176b\u176c\u0007\u0007\u0000\u0000\u176c\u176d\u0007\u001a"+ + "\u0000\u0000\u176d\u176e\u0007\u0019\u0000\u0000\u176e\u176f\u0007\u0013"+ + "\u0000\u0000\u176f\u1770\u0007\b\u0000\u0000\u1770\u1771\u0007\u0006\u0000"+ + "\u0000\u1771\u034c\u0001\u0000\u0000\u0000\u1772\u1773\u0007\u0007\u0000"+ + "\u0000\u1773\u1774\u0007\u001a\u0000\u0000\u1774\u1775\u0007\u0006\u0000"+ + "\u0000\u1775\u1776\u0007\u0007\u0000\u0000\u1776\u1777\u0007\f\u0000\u0000"+ + "\u1777\u1778\u0007\u0004\u0000\u0000\u1778\u1779\u0007\u0007\u0000\u0000"+ + "\u1779\u177a\u0007\u0004\u0000\u0000\u177a\u034e\u0001\u0000\u0000\u0000"+ + "\u177b\u177c\u0007\u0007\u0000\u0000\u177c\u177d\u0007\u001a\u0000\u0000"+ + "\u177d\u177e\u0007\u0006\u0000\u0000\u177e\u177f\u0007\u0007\u0000\u0000"+ + "\u177f\u1780\u0007\f\u0000\u0000\u1780\u1781\u0007\u0006\u0000\u0000\u1781"+ + "\u1782\u0005_\u0000\u0000\u1782\u1783\u0007\u000b\u0000\u0000\u1783\u1784"+ + "\u0007\u000f\u0000\u0000\u1784\u1785\u0007\r\u0000\u0000\u1785\u1786\u0007"+ + "\u0007\u0000\u0000\u1786\u0350\u0001\u0000\u0000\u0000\u1787\u1788\u0007"+ + "\u0012\u0000\u0000\u1788\u1789\u0007\u0003\u0000\u0000\u1789\u178a\u0007"+ + "\u000f\u0000\u0000\u178a\u178b\u0007\u0005\u0000\u0000\u178b\u178c\u0007"+ + "\u0007\u0000\u0000\u178c\u178d\u0007\u0004\u0000\u0000\u178d\u178e\u0005"+ + "_\u0000\u0000\u178e\u178f\u0007\u0005\u0000\u0000\u178f\u1790\u0007\u0013"+ + "\u0000\u0000\u1790\u1791\u0007\u0016\u0000\u0000\u1791\u1792\u0007\u000f"+ + "\u0000\u0000\u1792\u1793\u0007\f\u0000\u0000\u1793\u1794\u0005_\u0000"+ + "\u0000\u1794\u1795\u0007\u0003\u0000\u0000\u1795\u1796\u0007\u0006\u0000"+ + "\u0000\u1796\u1797\u0007\u0006\u0000\u0000\u1797\u1798\u0007\u0007\u0000"+ + "\u0000\u1798\u1799\u0007\u0017\u0000\u0000\u1799\u179a\u0007\u0019\u0000"+ + "\u0000\u179a\u179b\u0007\u0006\u0000\u0000\u179b\u179c\u0007\u000b\u0000"+ + "\u0000\u179c\u0352\u0001\u0000\u0000\u0000\u179d\u179e\u0007\u0012\u0000"+ + "\u0000\u179e\u179f\u0007\u0003\u0000\u0000\u179f\u17a0\u0007\u000b\u0000"+ + "\u0000\u17a0\u17a1\u0007\u0006\u0000\u0000\u17a1\u0354\u0001\u0000\u0000"+ + "\u0000\u17a2\u17a3\u0007\u0012\u0000\u0000\u17a3\u17a4\u0007\u0003\u0000"+ + "\u0000\u17a4\u17a5\u0007\u0011\u0000\u0000\u17a5\u17a6\u0007\u0005\u0000"+ + "\u0000\u17a6\u17a7\u0007\u0006\u0000\u0000\u17a7\u17a8\u0007\u000b\u0000"+ + "\u0000\u17a8\u0356\u0001\u0000\u0000\u0000\u17a9\u17aa\u0007\u0012\u0000"+ + "\u0000\u17aa\u17ab\u0007\u000f\u0000\u0000\u17ab\u17ac\u0007\u0007\u0000"+ + "\u0000\u17ac\u17ad\u0007\u0005\u0000\u0000\u17ad\u17ae\u0007\u0004\u0000"+ + "\u0000\u17ae\u17af\u0007\u000b\u0000\u0000\u17af\u0358\u0001\u0000\u0000"+ + "\u0000\u17b0\u17b1\u0007\u0012\u0000\u0000\u17b1\u17b2\u0007\u000f\u0000"+ + "\u0000\u17b2\u17b3\u0007\u0005\u0000\u0000\u17b3\u17b4\u0007\u0007\u0000"+ + "\u0000\u17b4\u17b5\u0005_\u0000\u0000\u17b5\u17b6\u0007\u0010\u0000\u0000"+ + "\u17b6\u17b7\u0007\u0005\u0000\u0000\u17b7\u17b8\u0007\u0013\u0000\u0000"+ + "\u17b8\u17b9\u0007\u000e\u0000\u0000\u17b9\u17ba\u0007\u0015\u0000\u0000"+ + "\u17ba\u17bb\u0005_\u0000\u0000\u17bb\u17bc\u0007\u000b\u0000\u0000\u17bc"+ + "\u17bd\u0007\u000f\u0000\u0000\u17bd\u17be\u0007\r\u0000\u0000\u17be\u17bf"+ + "\u0007\u0007\u0000\u0000\u17bf\u035a\u0001\u0000\u0000\u0000\u17c0\u17c1"+ + "\u0007\u0012\u0000\u0000\u17c1\u17c2\u0007\u000f\u0000\u0000\u17c2\u17c3"+ + "\u0007\u0005\u0000\u0000\u17c3\u17c4\u0007\u0006\u0000\u0000\u17c4\u17c5"+ + "\u0007\u0007\u0000\u0000\u17c5\u17c6\u0007\b\u0000\u0000\u17c6\u035c\u0001"+ + "\u0000\u0000\u0000\u17c7\u17c8\u0007\u0012\u0000\u0000\u17c8\u17c9\u0007"+ + "\u000f\u0000\u0000\u17c9\u17ca\u0007\b\u0000\u0000\u17ca\u17cb\u0007\u000b"+ + "\u0000\u0000\u17cb\u17cc\u0007\u0006\u0000\u0000\u17cc\u035e\u0001\u0000"+ + "\u0000\u0000\u17cd\u17ce\u0007\u0012\u0000\u0000\u17ce\u17cf\u0007\u000f"+ + "\u0000\u0000\u17cf\u17d0\u0007\u001a\u0000\u0000\u17d0\u17d1\u0007\u0007"+ + "\u0000\u0000\u17d1\u17d2\u0007\u0004\u0000\u0000\u17d2\u0360\u0001\u0000"+ + "\u0000\u0000\u17d3\u17d4\u0007\u0012\u0000\u0000\u17d4\u17d5\u0007\u0005"+ + "\u0000\u0000\u17d5\u17d6\u0007\u0011\u0000\u0000\u17d6\u17d7\u0007\u000b"+ + "\u0000\u0000\u17d7\u17d8\u0007\u0014\u0000\u0000\u17d8\u0362\u0001\u0000"+ + "\u0000\u0000\u17d9\u17da\u0007\u0012\u0000\u0000\u17da\u17db\u0007\u0013"+ + "\u0000\u0000\u17db\u17dc\u0007\u0005\u0000\u0000\u17dc\u17dd\u0007\u0005"+ + "\u0000\u0000\u17dd\u17de\u0007\u0013\u0000\u0000\u17de\u17df\u0007\t\u0000"+ + "\u0000\u17df\u17e0\u0007\u000f\u0000\u0000\u17e0\u17e1\u0007\f\u0000\u0000"+ + "\u17e1\u17e2\u0007\u0016\u0000\u0000\u17e2\u0364\u0001\u0000\u0000\u0000"+ + "\u17e3\u17e4\u0007\u0012\u0000\u0000\u17e4\u17e5\u0007\u0013\u0000\u0000"+ + "\u17e5\u17e6\u0007\u0005\u0000\u0000\u17e6\u17e7\u0007\u0005\u0000\u0000"+ + "\u17e7\u17e8\u0007\u0013\u0000\u0000\u17e8\u17e9\u0007\t\u0000\u0000\u17e9"+ + "\u17ea\u0007\u000b\u0000\u0000\u17ea\u0366\u0001\u0000\u0000\u0000\u17eb"+ + "\u17ec\u0007\u0012\u0000\u0000\u17ec\u17ed\u0007\u0013\u0000\u0000\u17ed"+ + "\u17ee\u0007\u0011\u0000\u0000\u17ee\u17ef\u0007\f\u0000\u0000\u17ef\u17f0"+ + "\u0007\u0004\u0000\u0000\u17f0\u0368\u0001\u0000\u0000\u0000\u17f1\u17f2"+ + "\u0007\u0012\u0000\u0000\u17f2\u17f3\u0007\u0011\u0000\u0000\u17f3\u17f4"+ + "\u0007\u0005\u0000\u0000\u17f4\u17f5\u0007\u0005\u0000\u0000\u17f5\u036a"+ + "\u0001\u0000\u0000\u0000\u17f6\u17f7\u0007\u0012\u0000\u0000\u17f7\u17f8"+ + "\u0007\u0011\u0000\u0000\u17f8\u17f9\u0007\f\u0000\u0000\u17f9\u17fa\u0007"+ + "\u000e\u0000\u0000\u17fa\u17fb\u0007\u0006\u0000\u0000\u17fb\u17fc\u0007"+ + "\u000f\u0000\u0000\u17fc\u17fd\u0007\u0013\u0000\u0000\u17fd\u17fe\u0007"+ + "\f\u0000\u0000\u17fe\u036c\u0001\u0000\u0000\u0000\u17ff\u1800\u0007\u0016"+ + "\u0000\u0000\u1800\u1801\u0007\u0007\u0000\u0000\u1801\u1802\u0007\f\u0000"+ + "\u0000\u1802\u1803\u0007\u0007\u0000\u0000\u1803\u1804\u0007\b\u0000\u0000"+ + "\u1804\u1805\u0007\u0003\u0000\u0000\u1805\u1806\u0007\u0005\u0000\u0000"+ + "\u1806\u036e\u0001\u0000\u0000\u0000\u1807\u1808\u0007\u0016\u0000\u0000"+ + "\u1808\u1809\u0007\u0005\u0000\u0000\u1809\u180a\u0007\u0013\u0000\u0000"+ + "\u180a\u180b\u0007\u0010\u0000\u0000\u180b\u180c\u0007\u0003\u0000\u0000"+ + "\u180c\u180d\u0007\u0005\u0000\u0000\u180d\u0370\u0001\u0000\u0000\u0000"+ + "\u180e\u180f\u0007\u0016\u0000\u0000\u180f\u1810\u0007\b\u0000\u0000\u1810"+ + "\u1811\u0007\u0003\u0000\u0000\u1811\u1812\u0007\f\u0000\u0000\u1812\u1813"+ + "\u0007\u0006\u0000\u0000\u1813\u1814\u0007\u000b\u0000\u0000\u1814\u0372"+ + "\u0001\u0000\u0000\u0000\u1815\u1816\u0007\u0016\u0000\u0000\u1816\u1817"+ + "\u0007\b\u0000\u0000\u1817\u1818\u0007\u0013\u0000\u0000\u1818\u1819\u0007"+ + "\u0011\u0000\u0000\u1819\u181a\u0007\u0019\u0000\u0000\u181a\u181b\u0005"+ + "_\u0000\u0000\u181b\u181c\u0007\b\u0000\u0000\u181c\u181d\u0007\u0007"+ + "\u0000\u0000\u181d\u181e\u0007\u0019\u0000\u0000\u181e\u181f\u0007\u0005"+ + "\u0000\u0000\u181f\u1820\u0007\u000f\u0000\u0000\u1820\u1821\u0007\u000e"+ + "\u0000\u0000\u1821\u1822\u0007\u0003\u0000\u0000\u1822\u1823\u0007\u0006"+ + "\u0000\u0000\u1823\u1824\u0007\u000f\u0000\u0000\u1824\u1825\u0007\u0013"+ + "\u0000\u0000\u1825\u1826\u0007\f\u0000\u0000\u1826\u0374\u0001\u0000\u0000"+ + "\u0000\u1827\u1828\u0007\u0014\u0000\u0000\u1828\u1829\u0007\u0003\u0000"+ + "\u0000\u1829\u182a\u0007\f\u0000\u0000\u182a\u182b\u0007\u0004\u0000\u0000"+ + "\u182b\u182c\u0007\u0005\u0000\u0000\u182c\u182d\u0007\u0007\u0000\u0000"+ + "\u182d\u182e\u0007\b\u0000\u0000\u182e\u0376\u0001\u0000\u0000\u0000\u182f"+ + "\u1830\u0007\u0014\u0000\u0000\u1830\u1831\u0007\u0003\u0000\u0000\u1831"+ + "\u1832\u0007\u000b\u0000\u0000\u1832\u1833\u0007\u0014\u0000\u0000\u1833"+ + "\u0378\u0001\u0000\u0000\u0000\u1834\u1835\u0007\u0014\u0000\u0000\u1835"+ + "\u1836\u0007\u0007\u0000\u0000\u1836\u1837\u0007\u0005\u0000\u0000\u1837"+ + "\u1838\u0007\u0019\u0000\u0000\u1838\u037a\u0001\u0000\u0000\u0000\u1839"+ + "\u183a\u0007\u0014\u0000\u0000\u183a\u183b\u0007\u000f\u0000\u0000\u183b"+ + "\u183c\u0007\u000b\u0000\u0000\u183c\u183d\u0007\u0006\u0000\u0000\u183d"+ + "\u183e\u0007\u0013\u0000\u0000\u183e\u183f\u0007\b\u0000\u0000\u183f\u1840"+ + "\u0007\n\u0000\u0000\u1840\u037c\u0001\u0000\u0000\u0000\u1841\u1842\u0007"+ + "\u0014\u0000\u0000\u1842\u1843\u0007\u0013\u0000\u0000\u1843\u1844\u0007"+ + "\u000b\u0000\u0000\u1844\u1845\u0007\u0006\u0000\u0000\u1845\u037e\u0001"+ + "\u0000\u0000\u0000\u1846\u1847\u0007\u0014\u0000\u0000\u1847\u1848\u0007"+ + "\u0013\u0000\u0000\u1848\u1849\u0007\u000b\u0000\u0000\u1849\u184a\u0007"+ + "\u0006\u0000\u0000\u184a\u184b\u0007\u000b\u0000\u0000\u184b\u0380\u0001"+ + "\u0000\u0000\u0000\u184c\u184d\u0007\u000f\u0000\u0000\u184d\u184e\u0007"+ + "\u0004\u0000\u0000\u184e\u184f\u0007\u0007\u0000\u0000\u184f\u1850\u0007"+ + "\f\u0000\u0000\u1850\u1851\u0007\u0006\u0000\u0000\u1851\u1852\u0007\u000f"+ + "\u0000\u0000\u1852\u1853\u0007\u0012\u0000\u0000\u1853\u1854\u0007\u000f"+ + "\u0000\u0000\u1854\u1855\u0007\u0007\u0000\u0000\u1855\u1856\u0007\u0004"+ + "\u0000\u0000\u1856\u0382\u0001\u0000\u0000\u0000\u1857\u1858\u0007\u000f"+ + "\u0000\u0000\u1858\u1859\u0007\u0016\u0000\u0000\u1859\u185a\u0007\f\u0000"+ + "\u0000\u185a\u185b\u0007\u0013\u0000\u0000\u185b\u185c\u0007\b\u0000\u0000"+ + "\u185c\u185d\u0007\u0007\u0000\u0000\u185d\u185e\u0005_\u0000\u0000\u185e"+ + "\u185f\u0007\u000b\u0000\u0000\u185f\u1860\u0007\u0007\u0000\u0000\u1860"+ + "\u1861\u0007\b\u0000\u0000\u1861\u1862\u0007\u0018\u0000\u0000\u1862\u1863"+ + "\u0007\u0007\u0000\u0000\u1863\u1864\u0007\b\u0000\u0000\u1864\u1865\u0005"+ + "_\u0000\u0000\u1865\u1866\u0007\u000f\u0000\u0000\u1866\u1867\u0007\u0004"+ + "\u0000\u0000\u1867\u1868\u0007\u000b\u0000\u0000\u1868\u0384\u0001\u0000"+ + "\u0000\u0000\u1869\u186a\u0007\u000f\u0000\u0000\u186a\u186b\u0007\u0017"+ + "\u0000\u0000\u186b\u186c\u0007\u0019\u0000\u0000\u186c\u186d\u0007\u0013"+ + "\u0000\u0000\u186d\u186e\u0007\b\u0000\u0000\u186e\u186f\u0007\u0006\u0000"+ + "\u0000\u186f\u0386\u0001\u0000\u0000\u0000\u1870\u1871\u0007\u000f\u0000"+ + "\u0000\u1871\u1872\u0007\f\u0000\u0000\u1872\u1873\u0007\u000e\u0000\u0000"+ + "\u1873\u1874\u0007\b\u0000\u0000\u1874\u1875\u0007\u0007\u0000\u0000\u1875"+ + "\u1876\u0007\u0017\u0000\u0000\u1876\u1877\u0007\u0007\u0000\u0000\u1877"+ + "\u1878\u0007\f\u0000\u0000\u1878\u1879\u0007\u0006\u0000\u0000\u1879\u0388"+ + "\u0001\u0000\u0000\u0000\u187a\u187b\u0007\u000f\u0000\u0000\u187b\u187c"+ + "\u0007\f\u0000\u0000\u187c\u187d\u0007\u0004\u0000\u0000\u187d\u187e\u0007"+ + "\u0007\u0000\u0000\u187e\u187f\u0007\u001a\u0000\u0000\u187f\u1880\u0007"+ + "\u0007\u0000\u0000\u1880\u1881\u0007\u000b\u0000\u0000\u1881\u038a\u0001"+ + "\u0000\u0000\u0000\u1882\u1883\u0007\u000f\u0000\u0000\u1883\u1884\u0007"+ + "\f\u0000\u0000\u1884\u1885\u0007\u000f\u0000\u0000\u1885\u1886\u0007\u0006"+ + "\u0000\u0000\u1886\u1887\u0007\u000f\u0000\u0000\u1887\u1888\u0007\u0003"+ + "\u0000\u0000\u1888\u1889\u0007\u0005\u0000\u0000\u1889\u188a\u0005_\u0000"+ + "\u0000\u188a\u188b\u0007\u000b\u0000\u0000\u188b\u188c\u0007\u000f\u0000"+ + "\u0000\u188c\u188d\u0007\r\u0000\u0000\u188d\u188e\u0007\u0007\u0000\u0000"+ + "\u188e\u038c\u0001\u0000\u0000\u0000\u188f\u1890\u0007\u000f\u0000\u0000"+ + "\u1890\u1891\u0007\f\u0000\u0000\u1891\u1892\u0007\u0019\u0000\u0000\u1892"+ + "\u1893\u0007\u0005\u0000\u0000\u1893\u1894\u0007\u0003\u0000\u0000\u1894"+ + "\u1895\u0007\u000e\u0000\u0000\u1895\u1896\u0007\u0007\u0000\u0000\u1896"+ + "\u038e\u0001\u0000\u0000\u0000\u1897\u1898\u0007\u000f\u0000\u0000\u1898"+ + "\u1899\u0007\f\u0000\u0000\u1899\u189a\u0007\u000b\u0000\u0000\u189a\u189b"+ + "\u0007\u0007\u0000\u0000\u189b\u189c\u0007\b\u0000\u0000\u189c\u189d\u0007"+ + "\u0006\u0000\u0000\u189d\u189e\u0005_\u0000\u0000\u189e\u189f\u0007\u0017"+ + "\u0000\u0000\u189f\u18a0\u0007\u0007\u0000\u0000\u18a0\u18a1\u0007\u0006"+ + "\u0000\u0000\u18a1\u18a2\u0007\u0014\u0000\u0000\u18a2\u18a3\u0007\u0013"+ + "\u0000\u0000\u18a3\u18a4\u0007\u0004\u0000\u0000\u18a4\u0390\u0001\u0000"+ + "\u0000\u0000\u18a5\u18a6\u0007\u000f\u0000\u0000\u18a6\u18a7\u0007\f\u0000"+ + "\u0000\u18a7\u18a8\u0007\u000b\u0000\u0000\u18a8\u18a9\u0007\u0006\u0000"+ + "\u0000\u18a9\u18aa\u0007\u0003\u0000\u0000\u18aa\u18ab\u0007\u0005\u0000"+ + "\u0000\u18ab\u18ac\u0007\u0005\u0000\u0000\u18ac\u0392\u0001\u0000\u0000"+ + "\u0000\u18ad\u18ae\u0007\u000f\u0000\u0000\u18ae\u18af\u0007\f\u0000\u0000"+ + "\u18af\u18b0\u0007\u000b\u0000\u0000\u18b0\u18b1\u0007\u0006\u0000\u0000"+ + "\u18b1\u18b2\u0007\u0003\u0000\u0000\u18b2\u18b3\u0007\f\u0000\u0000\u18b3"+ + "\u18b4\u0007\u000e\u0000\u0000\u18b4\u18b5\u0007\u0007\u0000\u0000\u18b5"+ + "\u0394\u0001\u0000\u0000\u0000\u18b6\u18b7\u0007\u000f\u0000\u0000\u18b7"+ + "\u18b8\u0007\f\u0000\u0000\u18b8\u18b9\u0007\u000b\u0000\u0000\u18b9\u18ba"+ + "\u0007\u0006\u0000\u0000\u18ba\u18bb\u0007\u0003\u0000\u0000\u18bb\u18bc"+ + "\u0007\f\u0000\u0000\u18bc\u18bd\u0007\u0006\u0000\u0000\u18bd\u0396\u0001"+ + "\u0000\u0000\u0000\u18be\u18bf\u0007\u000f\u0000\u0000\u18bf\u18c0\u0007"+ + "\f\u0000\u0000\u18c0\u18c1\u0007\u0018\u0000\u0000\u18c1\u18c2\u0007\u000f"+ + "\u0000\u0000\u18c2\u18c3\u0007\u000b\u0000\u0000\u18c3\u18c4\u0007\u000f"+ + "\u0000\u0000\u18c4\u18c5\u0007\u0010\u0000\u0000\u18c5\u18c6\u0007\u0005"+ + "\u0000\u0000\u18c6\u18c7\u0007\u0007\u0000\u0000\u18c7\u0398\u0001\u0000"+ + "\u0000\u0000\u18c8\u18c9\u0007\u000f\u0000\u0000\u18c9\u18ca\u0007\f\u0000"+ + "\u0000\u18ca\u18cb\u0007\u0018\u0000\u0000\u18cb\u18cc\u0007\u0013\u0000"+ + "\u0000\u18cc\u18cd\u0007\u0015\u0000\u0000\u18cd\u18ce\u0007\u0007\u0000"+ + "\u0000\u18ce\u18cf\u0007\b\u0000\u0000\u18cf\u039a\u0001\u0000\u0000\u0000"+ + "\u18d0\u18d1\u0007\u000f\u0000\u0000\u18d1\u18d2\u0007\u0013\u0000\u0000"+ + "\u18d2\u039c\u0001\u0000\u0000\u0000\u18d3\u18d4\u0007\u000f\u0000\u0000"+ + "\u18d4\u18d5\u0007\u0013\u0000\u0000\u18d5\u18d6\u0005_\u0000\u0000\u18d6"+ + "\u18d7\u0007\u0006\u0000\u0000\u18d7\u18d8\u0007\u0014\u0000\u0000\u18d8"+ + "\u18d9\u0007\b\u0000\u0000\u18d9\u18da\u0007\u0007\u0000\u0000\u18da\u18db"+ + "\u0007\u0003\u0000\u0000\u18db\u18dc\u0007\u0004\u0000\u0000\u18dc\u039e"+ + "\u0001\u0000\u0000\u0000\u18dd\u18de\u0007\u000f\u0000\u0000\u18de\u18df"+ + "\u0007\u0019\u0000\u0000\u18df\u18e0\u0007\u000e\u0000\u0000\u18e0\u03a0"+ + "\u0001\u0000\u0000\u0000\u18e1\u18e2\u0007\u000f\u0000\u0000\u18e2\u18e3"+ + "\u0007\u000b\u0000\u0000\u18e3\u18e4\u0007\u0013\u0000\u0000\u18e4\u18e5"+ + "\u0007\u0005\u0000\u0000\u18e5\u18e6\u0007\u0003\u0000\u0000\u18e6\u18e7"+ + "\u0007\u0006\u0000\u0000\u18e7\u18e8\u0007\u000f\u0000\u0000\u18e8\u18e9"+ + "\u0007\u0013\u0000\u0000\u18e9\u18ea\u0007\f\u0000\u0000\u18ea\u03a2\u0001"+ + "\u0000\u0000\u0000\u18eb\u18ec\u0007\u000f\u0000\u0000\u18ec\u18ed\u0007"+ + "\u000b\u0000\u0000\u18ed\u18ee\u0007\u000b\u0000\u0000\u18ee\u18ef\u0007"+ + "\u0011\u0000\u0000\u18ef\u18f0\u0007\u0007\u0000\u0000\u18f0\u18f1\u0007"+ + "\b\u0000\u0000\u18f1\u03a4\u0001\u0000\u0000\u0000\u18f2\u18f3\u0007\u001b"+ + "\u0000\u0000\u18f3\u18f4\u0007\u000b\u0000\u0000\u18f4\u18f5\u0007\u0013"+ + "\u0000\u0000\u18f5\u18f6\u0007\f\u0000\u0000\u18f6\u03a6\u0001\u0000\u0000"+ + "\u0000\u18f7\u18f8\u0007\u0015\u0000\u0000\u18f8\u18f9\u0007\u0007\u0000"+ + "\u0000\u18f9\u18fa\u0007\n\u0000\u0000\u18fa\u18fb\u0005_\u0000\u0000"+ + "\u18fb\u18fc\u0007\u0010\u0000\u0000\u18fc\u18fd\u0007\u0005\u0000\u0000"+ + "\u18fd\u18fe\u0007\u0013\u0000\u0000\u18fe\u18ff\u0007\u000e\u0000\u0000"+ + "\u18ff\u1900\u0007\u0015\u0000\u0000\u1900\u1901\u0005_\u0000\u0000\u1901"+ + "\u1902\u0007\u000b\u0000\u0000\u1902\u1903\u0007\u000f\u0000\u0000\u1903"+ + "\u1904\u0007\r\u0000\u0000\u1904\u1905\u0007\u0007\u0000\u0000\u1905\u03a8"+ + "\u0001\u0000\u0000\u0000\u1906\u1907\u0007\u0005\u0000\u0000\u1907\u1908"+ + "\u0007\u0003\u0000\u0000\u1908\u1909\u0007\f\u0000\u0000\u1909\u190a\u0007"+ + "\u0016\u0000\u0000\u190a\u190b\u0007\u0011\u0000\u0000\u190b\u190c\u0007"+ + "\u0003\u0000\u0000\u190c\u190d\u0007\u0016\u0000\u0000\u190d\u190e\u0007"+ + "\u0007\u0000\u0000\u190e\u03aa\u0001\u0000\u0000\u0000\u190f\u1910\u0007"+ + "\u0005\u0000\u0000\u1910\u1911\u0007\u0003\u0000\u0000\u1911\u1912\u0007"+ + "\u000b\u0000\u0000\u1912\u1913\u0007\u0006\u0000\u0000\u1913\u03ac\u0001"+ + "\u0000\u0000\u0000\u1914\u1915\u0007\u0005\u0000\u0000\u1915\u1916\u0007"+ + "\u0007\u0000\u0000\u1916\u1917\u0007\u0003\u0000\u0000\u1917\u1918\u0007"+ + "\u0018\u0000\u0000\u1918\u1919\u0007\u0007\u0000\u0000\u1919\u191a\u0007"+ + "\u000b\u0000\u0000\u191a\u03ae\u0001\u0000\u0000\u0000\u191b\u191c\u0007"+ + "\u0005\u0000\u0000\u191c\u191d\u0007\u0007\u0000\u0000\u191d\u191e\u0007"+ + "\u000b\u0000\u0000\u191e\u191f\u0007\u000b\u0000\u0000\u191f\u03b0\u0001"+ + "\u0000\u0000\u0000\u1920\u1921\u0007\u0005\u0000\u0000\u1921\u1922\u0007"+ + "\u0007\u0000\u0000\u1922\u1923\u0007\u0018\u0000\u0000\u1923\u1924\u0007"+ + "\u0007\u0000\u0000\u1924\u1925\u0007\u0005\u0000\u0000\u1925\u03b2\u0001"+ + "\u0000\u0000\u0000\u1926\u1927\u0007\u0005\u0000\u0000\u1927\u1928\u0007"+ + "\u000f\u0000\u0000\u1928\u1929\u0007\u000b\u0000\u0000\u1929\u192a\u0007"+ + "\u0006\u0000\u0000\u192a\u03b4\u0001\u0000\u0000\u0000\u192b\u192c\u0007"+ + "\u0005\u0000\u0000\u192c\u192d\u0007\u0013\u0000\u0000\u192d\u192e\u0007"+ + "\u000e\u0000\u0000\u192e\u192f\u0007\u0003\u0000\u0000\u192f\u1930\u0007"+ + "\u0005\u0000\u0000\u1930\u03b6\u0001\u0000\u0000\u0000\u1931\u1932\u0007"+ + "\u0005\u0000\u0000\u1932\u1933\u0007\u0013\u0000\u0000\u1933\u1934\u0007"+ + "\u0016\u0000\u0000\u1934\u1935\u0007\u0012\u0000\u0000\u1935\u1936\u0007"+ + "\u000f\u0000\u0000\u1936\u1937\u0007\u0005\u0000\u0000\u1937\u1938\u0007"+ + "\u0007\u0000\u0000\u1938\u03b8\u0001\u0000\u0000\u0000\u1939\u193a\u0007"+ + "\u0005\u0000\u0000\u193a\u193b\u0007\u0013\u0000\u0000\u193b\u193c\u0007"+ + "\u0016\u0000\u0000\u193c\u193d\u0007\u000b\u0000\u0000\u193d\u03ba\u0001"+ + "\u0000\u0000\u0000\u193e\u193f\u0007\u0017\u0000\u0000\u193f\u1940\u0007"+ + "\u0003\u0000\u0000\u1940\u1941\u0007\u000b\u0000\u0000\u1941\u1942\u0007"+ + "\u0006\u0000\u0000\u1942\u1943\u0007\u0007\u0000\u0000\u1943\u1944\u0007"+ + "\b\u0000\u0000\u1944\u03bc\u0001\u0000\u0000\u0000\u1945\u1946\u0007\u0017"+ + "\u0000\u0000\u1946\u1947\u0007\u0003\u0000\u0000\u1947\u1948\u0007\u000b"+ + "\u0000\u0000\u1948\u1949\u0007\u0006\u0000\u0000\u1949\u194a\u0007\u0007"+ + "\u0000\u0000\u194a\u194b\u0007\b\u0000\u0000\u194b\u194c\u0005_\u0000"+ + "\u0000\u194c\u194d\u0007\u0003\u0000\u0000\u194d\u194e\u0007\u0011\u0000"+ + "\u0000\u194e\u194f\u0007\u0006\u0000\u0000\u194f\u1950\u0007\u0013\u0000"+ + "\u0000\u1950\u1951\u0005_\u0000\u0000\u1951\u1952\u0007\u0019\u0000\u0000"+ + "\u1952\u1953\u0007\u0013\u0000\u0000\u1953\u1954\u0007\u000b\u0000\u0000"+ + "\u1954\u1955\u0007\u000f\u0000\u0000\u1955\u1956\u0007\u0006\u0000\u0000"+ + "\u1956\u1957\u0007\u000f\u0000\u0000\u1957\u1958\u0007\u0013\u0000\u0000"+ + "\u1958\u1959\u0007\f\u0000\u0000\u1959\u03be\u0001\u0000\u0000\u0000\u195a"+ + "\u195b\u0007\u0017\u0000\u0000\u195b\u195c\u0007\u0003\u0000\u0000\u195c"+ + "\u195d\u0007\u000b\u0000\u0000\u195d\u195e\u0007\u0006\u0000\u0000\u195e"+ + "\u195f\u0007\u0007\u0000\u0000\u195f\u1960\u0007\b\u0000\u0000\u1960\u1961"+ + "\u0005_\u0000\u0000\u1961\u1962\u0007\u000e\u0000\u0000\u1962\u1963\u0007"+ + "\u0013\u0000\u0000\u1963\u1964\u0007\f\u0000\u0000\u1964\u1965\u0007\f"+ + "\u0000\u0000\u1965\u1966\u0007\u0007\u0000\u0000\u1966\u1967\u0007\u000e"+ + "\u0000\u0000\u1967\u1968\u0007\u0006\u0000\u0000\u1968\u1969\u0005_\u0000"+ + "\u0000\u1969\u196a\u0007\b\u0000\u0000\u196a\u196b\u0007\u0007\u0000\u0000"+ + "\u196b\u196c\u0007\u0006\u0000\u0000\u196c\u196d\u0007\b\u0000\u0000\u196d"+ + "\u196e\u0007\n\u0000\u0000\u196e\u03c0\u0001\u0000\u0000\u0000\u196f\u1970"+ + "\u0007\u0017\u0000\u0000\u1970\u1971\u0007\u0003\u0000\u0000\u1971\u1972"+ + "\u0007\u000b\u0000\u0000\u1972\u1973\u0007\u0006\u0000\u0000\u1973\u1974"+ + "\u0007\u0007\u0000\u0000\u1974\u1975\u0007\b\u0000\u0000\u1975\u1976\u0005"+ + "_\u0000\u0000\u1976\u1977\u0007\u0004\u0000\u0000\u1977\u1978\u0007\u0007"+ + "\u0000\u0000\u1978\u1979\u0007\u0005\u0000\u0000\u1979\u197a\u0007\u0003"+ + "\u0000\u0000\u197a\u197b\u0007\n\u0000\u0000\u197b\u03c2\u0001\u0000\u0000"+ + "\u0000\u197c\u197d\u0007\u0017\u0000\u0000\u197d\u197e\u0007\u0003\u0000"+ + "\u0000\u197e\u197f\u0007\u000b\u0000\u0000\u197f\u1980\u0007\u0006\u0000"+ + "\u0000\u1980\u1981\u0007\u0007\u0000\u0000\u1981\u1982\u0007\b\u0000\u0000"+ + "\u1982\u1983\u0005_\u0000\u0000\u1983\u1984\u0007\u0014\u0000\u0000\u1984"+ + "\u1985\u0007\u0007\u0000\u0000\u1985\u1986\u0007\u0003\u0000\u0000\u1986"+ + "\u1987\u0007\b\u0000\u0000\u1987\u1988\u0007\u0006\u0000\u0000\u1988\u1989"+ + "\u0007\u0010\u0000\u0000\u1989\u198a\u0007\u0007\u0000\u0000\u198a\u198b"+ + "\u0007\u0003\u0000\u0000\u198b\u198c\u0007\u0006\u0000\u0000\u198c\u198d"+ + "\u0005_\u0000\u0000\u198d\u198e\u0007\u0019\u0000\u0000\u198e\u198f\u0007"+ + "\u0007\u0000\u0000\u198f\u1990\u0007\b\u0000\u0000\u1990\u1991\u0007\u000f"+ + "\u0000\u0000\u1991\u1992\u0007\u0013\u0000\u0000\u1992\u1993\u0007\u0004"+ + "\u0000\u0000\u1993\u03c4\u0001\u0000\u0000\u0000\u1994\u1995\u0007\u0017"+ + "\u0000\u0000\u1995\u1996\u0007\u0003\u0000\u0000\u1996\u1997\u0007\u000b"+ + "\u0000\u0000\u1997\u1998\u0007\u0006\u0000\u0000\u1998\u1999\u0007\u0007"+ + "\u0000\u0000\u1999\u199a\u0007\b\u0000\u0000\u199a\u199b\u0005_\u0000"+ + "\u0000\u199b\u199c\u0007\u0014\u0000\u0000\u199c\u199d\u0007\u0013\u0000"+ + "\u0000\u199d\u199e\u0007\u000b\u0000\u0000\u199e\u199f\u0007\u0006\u0000"+ + "\u0000\u199f\u03c6\u0001\u0000\u0000\u0000\u19a0\u19a1\u0007\u0017\u0000"+ + "\u0000\u19a1\u19a2\u0007\u0003\u0000\u0000\u19a2\u19a3\u0007\u000b\u0000"+ + "\u0000\u19a3\u19a4\u0007\u0006\u0000\u0000\u19a4\u19a5\u0007\u0007\u0000"+ + "\u0000\u19a5\u19a6\u0007\b\u0000\u0000\u19a6\u19a7\u0005_\u0000\u0000"+ + "\u19a7\u19a8\u0007\u0005\u0000\u0000\u19a8\u19a9\u0007\u0013\u0000\u0000"+ + "\u19a9\u19aa\u0007\u0016\u0000\u0000\u19aa\u19ab\u0005_\u0000\u0000\u19ab"+ + "\u19ac\u0007\u0012\u0000\u0000\u19ac\u19ad\u0007\u000f\u0000\u0000\u19ad"+ + "\u19ae\u0007\u0005\u0000\u0000\u19ae\u19af\u0007\u0007\u0000\u0000\u19af"+ + "\u03c8\u0001\u0000\u0000\u0000\u19b0\u19b1\u0007\u0017\u0000\u0000\u19b1"+ + "\u19b2\u0007\u0003\u0000\u0000\u19b2\u19b3\u0007\u000b\u0000\u0000\u19b3"+ + "\u19b4\u0007\u0006\u0000\u0000\u19b4\u19b5\u0007\u0007\u0000\u0000\u19b5"+ + "\u19b6\u0007\b\u0000\u0000\u19b6\u19b7\u0005_\u0000\u0000\u19b7\u19b8"+ + "\u0007\u0005\u0000\u0000\u19b8\u19b9\u0007\u0013\u0000\u0000\u19b9\u19ba"+ + "\u0007\u0016\u0000\u0000\u19ba\u19bb\u0005_\u0000\u0000\u19bb\u19bc\u0007"+ + "\u0019\u0000\u0000\u19bc\u19bd\u0007\u0013\u0000\u0000\u19bd\u19be\u0007"+ + "\u000b\u0000\u0000\u19be\u03ca\u0001\u0000\u0000\u0000\u19bf\u19c0\u0007"+ + "\u0017\u0000\u0000\u19c0\u19c1\u0007\u0003\u0000\u0000\u19c1\u19c2\u0007"+ + "\u000b\u0000\u0000\u19c2\u19c3\u0007\u0006\u0000\u0000\u19c3\u19c4\u0007"+ + "\u0007\u0000\u0000\u19c4\u19c5\u0007\b\u0000\u0000\u19c5\u19c6\u0005_"+ + "\u0000\u0000\u19c6\u19c7\u0007\u0019\u0000\u0000\u19c7\u19c8\u0007\u0003"+ + "\u0000\u0000\u19c8\u19c9\u0007\u000b\u0000\u0000\u19c9\u19ca\u0007\u000b"+ + "\u0000\u0000\u19ca\u19cb\u0007\t\u0000\u0000\u19cb\u19cc\u0007\u0013\u0000"+ + "\u0000\u19cc\u19cd\u0007\b\u0000\u0000\u19cd\u19ce\u0007\u0004\u0000\u0000"+ + "\u19ce\u03cc\u0001\u0000\u0000\u0000\u19cf\u19d0\u0007\u0017\u0000\u0000"+ + "\u19d0\u19d1\u0007\u0003\u0000\u0000\u19d1\u19d2\u0007\u000b\u0000\u0000"+ + "\u19d2\u19d3\u0007\u0006\u0000\u0000\u19d3\u19d4\u0007\u0007\u0000\u0000"+ + "\u19d4\u19d5\u0007\b\u0000\u0000\u19d5\u19d6\u0005_\u0000\u0000\u19d6"+ + "\u19d7\u0007\u0019\u0000\u0000\u19d7\u19d8\u0007\u0013\u0000\u0000\u19d8"+ + "\u19d9\u0007\b\u0000\u0000\u19d9\u19da\u0007\u0006\u0000\u0000\u19da\u03ce"+ + "\u0001\u0000\u0000\u0000\u19db\u19dc\u0007\u0017\u0000\u0000\u19dc\u19dd"+ + "\u0007\u0003\u0000\u0000\u19dd\u19de\u0007\u000b\u0000\u0000\u19de\u19df"+ + "\u0007\u0006\u0000\u0000\u19df\u19e0\u0007\u0007\u0000\u0000\u19e0\u19e1"+ + "\u0007\b\u0000\u0000\u19e1\u19e2\u0005_\u0000\u0000\u19e2\u19e3\u0007"+ + "\b\u0000\u0000\u19e3\u19e4\u0007\u0007\u0000\u0000\u19e4\u19e5\u0007\u0006"+ + "\u0000\u0000\u19e5\u19e6\u0007\b\u0000\u0000\u19e6\u19e7\u0007\n\u0000"+ + "\u0000\u19e7\u19e8\u0005_\u0000\u0000\u19e8\u19e9\u0007\u000e\u0000\u0000"+ + "\u19e9\u19ea\u0007\u0013\u0000\u0000\u19ea\u19eb\u0007\u0011\u0000\u0000"+ + "\u19eb\u19ec\u0007\f\u0000\u0000\u19ec\u19ed\u0007\u0006\u0000\u0000\u19ed"+ + "\u03d0\u0001\u0000\u0000\u0000\u19ee\u19ef\u0007\u0017\u0000\u0000\u19ef"+ + "\u19f0\u0007\u0003\u0000\u0000\u19f0\u19f1\u0007\u000b\u0000\u0000\u19f1"+ + "\u19f2\u0007\u0006\u0000\u0000\u19f2\u19f3\u0007\u0007\u0000\u0000\u19f3"+ + "\u19f4\u0007\b\u0000\u0000\u19f4\u19f5\u0005_\u0000\u0000\u19f5\u19f6"+ + "\u0007\u000b\u0000\u0000\u19f6\u19f7\u0007\u000b\u0000\u0000\u19f7\u19f8"+ + "\u0007\u0005\u0000\u0000\u19f8\u03d2\u0001\u0000\u0000\u0000\u19f9\u19fa"+ + "\u0007\u0017\u0000\u0000\u19fa\u19fb\u0007\u0003\u0000\u0000\u19fb\u19fc"+ + "\u0007\u000b\u0000\u0000\u19fc\u19fd\u0007\u0006\u0000\u0000\u19fd\u19fe"+ + "\u0007\u0007\u0000\u0000\u19fe\u19ff\u0007\b\u0000\u0000\u19ff\u1a00\u0005"+ + "_\u0000\u0000\u1a00\u1a01\u0007\u000b\u0000\u0000\u1a01\u1a02\u0007\u000b"+ + "\u0000\u0000\u1a02\u1a03\u0007\u0005\u0000\u0000\u1a03\u1a04\u0005_\u0000"+ + "\u0000\u1a04\u1a05\u0007\u000e\u0000\u0000\u1a05\u1a06\u0007\u0003\u0000"+ + "\u0000\u1a06\u03d4\u0001\u0000\u0000\u0000\u1a07\u1a08\u0007\u0017\u0000"+ + "\u0000\u1a08\u1a09\u0007\u0003\u0000\u0000\u1a09\u1a0a\u0007\u000b\u0000"+ + "\u0000\u1a0a\u1a0b\u0007\u0006\u0000\u0000\u1a0b\u1a0c\u0007\u0007\u0000"+ + "\u0000\u1a0c\u1a0d\u0007\b\u0000\u0000\u1a0d\u1a0e\u0005_\u0000\u0000"+ + "\u1a0e\u1a0f\u0007\u000b\u0000\u0000\u1a0f\u1a10\u0007\u000b\u0000\u0000"+ + "\u1a10\u1a11\u0007\u0005\u0000\u0000\u1a11\u1a12\u0005_\u0000\u0000\u1a12"+ + "\u1a13\u0007\u000e\u0000\u0000\u1a13\u1a14\u0007\u0003\u0000\u0000\u1a14"+ + "\u1a15\u0007\u0019\u0000\u0000\u1a15\u1a16\u0007\u0003\u0000\u0000\u1a16"+ + "\u1a17\u0007\u0006\u0000\u0000\u1a17\u1a18\u0007\u0014\u0000\u0000\u1a18"+ + "\u03d6\u0001\u0000\u0000\u0000\u1a19\u1a1a\u0007\u0017\u0000\u0000\u1a1a"+ + "\u1a1b\u0007\u0003\u0000\u0000\u1a1b\u1a1c\u0007\u000b\u0000\u0000\u1a1c"+ + "\u1a1d\u0007\u0006\u0000\u0000\u1a1d\u1a1e\u0007\u0007\u0000\u0000\u1a1e"+ + "\u1a1f\u0007\b\u0000\u0000\u1a1f\u1a20\u0005_\u0000\u0000\u1a20\u1a21"+ + "\u0007\u000b\u0000\u0000\u1a21\u1a22\u0007\u000b\u0000\u0000\u1a22\u1a23"+ + "\u0007\u0005\u0000\u0000\u1a23\u1a24\u0005_\u0000\u0000\u1a24\u1a25\u0007"+ + "\u000e\u0000\u0000\u1a25\u1a26\u0007\u0007\u0000\u0000\u1a26\u1a27\u0007"+ + "\b\u0000\u0000\u1a27\u1a28\u0007\u0006\u0000\u0000\u1a28\u03d8\u0001\u0000"+ + "\u0000\u0000\u1a29\u1a2a\u0007\u0017\u0000\u0000\u1a2a\u1a2b\u0007\u0003"+ + "\u0000\u0000\u1a2b\u1a2c\u0007\u000b\u0000\u0000\u1a2c\u1a2d\u0007\u0006"+ + "\u0000\u0000\u1a2d\u1a2e\u0007\u0007\u0000\u0000\u1a2e\u1a2f\u0007\b\u0000"+ + "\u0000\u1a2f\u1a30\u0005_\u0000\u0000\u1a30\u1a31\u0007\u000b\u0000\u0000"+ + "\u1a31\u1a32\u0007\u000b\u0000\u0000\u1a32\u1a33\u0007\u0005\u0000\u0000"+ + "\u1a33\u1a34\u0005_\u0000\u0000\u1a34\u1a35\u0007\u000e\u0000\u0000\u1a35"+ + "\u1a36\u0007\u000f\u0000\u0000\u1a36\u1a37\u0007\u0019\u0000\u0000\u1a37"+ + "\u1a38\u0007\u0014\u0000\u0000\u1a38\u1a39\u0007\u0007\u0000\u0000\u1a39"+ + "\u1a3a\u0007\b\u0000\u0000\u1a3a\u03da\u0001\u0000\u0000\u0000\u1a3b\u1a3c"+ + "\u0007\u0017\u0000\u0000\u1a3c\u1a3d\u0007\u0003\u0000\u0000\u1a3d\u1a3e"+ + "\u0007\u000b\u0000\u0000\u1a3e\u1a3f\u0007\u0006\u0000\u0000\u1a3f\u1a40"+ + "\u0007\u0007\u0000\u0000\u1a40\u1a41\u0007\b\u0000\u0000\u1a41\u1a42\u0005"+ + "_\u0000\u0000\u1a42\u1a43\u0007\u000b\u0000\u0000\u1a43\u1a44\u0007\u000b"+ + "\u0000\u0000\u1a44\u1a45\u0007\u0005\u0000\u0000\u1a45\u1a46\u0005_\u0000"+ + "\u0000\u1a46\u1a47\u0007\u000e\u0000\u0000\u1a47\u1a48\u0007\b\u0000\u0000"+ + "\u1a48\u1a49\u0007\u0005\u0000\u0000\u1a49\u03dc\u0001\u0000\u0000\u0000"+ + "\u1a4a\u1a4b\u0007\u0017\u0000\u0000\u1a4b\u1a4c\u0007\u0003\u0000\u0000"+ + "\u1a4c\u1a4d\u0007\u000b\u0000\u0000\u1a4d\u1a4e\u0007\u0006\u0000\u0000"+ + "\u1a4e\u1a4f\u0007\u0007\u0000\u0000\u1a4f\u1a50\u0007\b\u0000\u0000\u1a50"+ + "\u1a51\u0005_\u0000\u0000\u1a51\u1a52\u0007\u000b\u0000\u0000\u1a52\u1a53"+ + "\u0007\u000b\u0000\u0000\u1a53\u1a54\u0007\u0005\u0000\u0000\u1a54\u1a55"+ + "\u0005_\u0000\u0000\u1a55\u1a56\u0007\u000e\u0000\u0000\u1a56\u1a57\u0007"+ + "\b\u0000\u0000\u1a57\u1a58\u0007\u0005\u0000\u0000\u1a58\u1a59\u0007\u0019"+ + "\u0000\u0000\u1a59\u1a5a\u0007\u0003\u0000\u0000\u1a5a\u1a5b\u0007\u0006"+ + "\u0000\u0000\u1a5b\u1a5c\u0007\u0014\u0000\u0000\u1a5c\u03de\u0001\u0000"+ + "\u0000\u0000\u1a5d\u1a5e\u0007\u0017\u0000\u0000\u1a5e\u1a5f\u0007\u0003"+ + "\u0000\u0000\u1a5f\u1a60\u0007\u000b\u0000\u0000\u1a60\u1a61\u0007\u0006"+ + "\u0000\u0000\u1a61\u1a62\u0007\u0007\u0000\u0000\u1a62\u1a63\u0007\b\u0000"+ + "\u0000\u1a63\u1a64\u0005_\u0000\u0000\u1a64\u1a65\u0007\u000b\u0000\u0000"+ + "\u1a65\u1a66\u0007\u000b\u0000\u0000\u1a66\u1a67\u0007\u0005\u0000\u0000"+ + "\u1a67\u1a68\u0005_\u0000\u0000\u1a68\u1a69\u0007\u0015\u0000\u0000\u1a69"+ + "\u1a6a\u0007\u0007\u0000\u0000\u1a6a\u1a6b\u0007\n\u0000\u0000\u1a6b\u03e0"+ + "\u0001\u0000\u0000\u0000\u1a6c\u1a6d\u0007\u0017\u0000\u0000\u1a6d\u1a6e"+ + "\u0007\u0003\u0000\u0000\u1a6e\u1a6f\u0007\u000b\u0000\u0000\u1a6f\u1a70"+ + "\u0007\u0006\u0000\u0000\u1a70\u1a71\u0007\u0007\u0000\u0000\u1a71\u1a72"+ + "\u0007\b\u0000\u0000\u1a72\u1a73\u0005_\u0000\u0000\u1a73\u1a74\u0007"+ + "\u0006\u0000\u0000\u1a74\u1a75\u0007\u0005\u0000\u0000\u1a75\u1a76\u0007"+ + "\u000b\u0000\u0000\u1a76\u1a77\u0005_\u0000\u0000\u1a77\u1a78\u0007\u0018"+ + "\u0000\u0000\u1a78\u1a79\u0007\u0007\u0000\u0000\u1a79\u1a7a\u0007\b\u0000"+ + "\u0000\u1a7a\u1a7b\u0007\u000b\u0000\u0000\u1a7b\u1a7c\u0007\u000f\u0000"+ + "\u0000\u1a7c\u1a7d\u0007\u0013\u0000\u0000\u1a7d\u1a7e\u0007\f\u0000\u0000"+ + "\u1a7e\u03e2\u0001\u0000\u0000\u0000\u1a7f\u1a80\u0007\u0017\u0000\u0000"+ + "\u1a80\u1a81\u0007\u0003\u0000\u0000\u1a81\u1a82\u0007\u000b\u0000\u0000"+ + "\u1a82\u1a83\u0007\u0006\u0000\u0000\u1a83\u1a84\u0007\u0007\u0000\u0000"+ + "\u1a84\u1a85\u0007\b\u0000\u0000\u1a85\u1a86\u0005_\u0000\u0000\u1a86"+ + "\u1a87\u0007\u0011\u0000\u0000\u1a87\u1a88\u0007\u000b\u0000\u0000\u1a88"+ + "\u1a89\u0007\u0007\u0000\u0000\u1a89\u1a8a\u0007\b\u0000\u0000\u1a8a\u03e4"+ + "\u0001\u0000\u0000\u0000\u1a8b\u1a8c\u0007\u0017\u0000\u0000\u1a8c\u1a8d"+ + "\u0007\u0003\u0000\u0000\u1a8d\u1a8e\u0007\u001a\u0000\u0000\u1a8e\u1a8f"+ + "\u0005_\u0000\u0000\u1a8f\u1a90\u0007\u000e\u0000\u0000\u1a90\u1a91\u0007"+ + "\u0013\u0000\u0000\u1a91\u1a92\u0007\f\u0000\u0000\u1a92\u1a93\u0007\f"+ + "\u0000\u0000\u1a93\u1a94\u0007\u0007\u0000\u0000\u1a94\u1a95\u0007\u000e"+ + "\u0000\u0000\u1a95\u1a96\u0007\u0006\u0000\u0000\u1a96\u1a97\u0007\u000f"+ + "\u0000\u0000\u1a97\u1a98\u0007\u0013\u0000\u0000\u1a98\u1a99\u0007\f\u0000"+ + "\u0000\u1a99\u1a9a\u0007\u000b\u0000\u0000\u1a9a\u1a9b\u0005_\u0000\u0000"+ + "\u1a9b\u1a9c\u0007\u0019\u0000\u0000\u1a9c\u1a9d\u0007\u0007\u0000\u0000"+ + "\u1a9d\u1a9e\u0007\b\u0000\u0000\u1a9e\u1a9f\u0005_\u0000\u0000\u1a9f"+ + "\u1aa0\u0007\u0014\u0000\u0000\u1aa0\u1aa1\u0007\u0013\u0000\u0000\u1aa1"+ + "\u1aa2\u0007\u0011\u0000\u0000\u1aa2\u1aa3\u0007\b\u0000\u0000\u1aa3\u03e6"+ + "\u0001\u0000\u0000\u0000\u1aa4\u1aa5\u0007\u0017\u0000\u0000\u1aa5\u1aa6"+ + "\u0007\u0003\u0000\u0000\u1aa6\u1aa7\u0007\u001a\u0000\u0000\u1aa7\u1aa8"+ + "\u0005_\u0000\u0000\u1aa8\u1aa9\u0007\u001c\u0000\u0000\u1aa9\u1aaa\u0007"+ + "\u0011\u0000\u0000\u1aaa\u1aab\u0007\u0007\u0000\u0000\u1aab\u1aac\u0007"+ + "\b\u0000\u0000\u1aac\u1aad\u0007\u000f\u0000\u0000\u1aad\u1aae\u0007\u0007"+ + "\u0000\u0000\u1aae\u1aaf\u0007\u000b\u0000\u0000\u1aaf\u1ab0\u0005_\u0000"+ + "\u0000\u1ab0\u1ab1\u0007\u0019\u0000\u0000\u1ab1\u1ab2\u0007\u0007\u0000"+ + "\u0000\u1ab2\u1ab3\u0007\b\u0000\u0000\u1ab3\u1ab4\u0005_\u0000\u0000"+ + "\u1ab4\u1ab5\u0007\u0014\u0000\u0000\u1ab5\u1ab6\u0007\u0013\u0000\u0000"+ + "\u1ab6\u1ab7\u0007\u0011\u0000\u0000\u1ab7\u1ab8\u0007\b\u0000\u0000\u1ab8"+ + "\u03e8\u0001\u0000\u0000\u0000\u1ab9\u1aba\u0007\u0017\u0000\u0000\u1aba"+ + "\u1abb\u0007\u0003\u0000\u0000\u1abb\u1abc\u0007\u001a\u0000\u0000\u1abc"+ + "\u1abd\u0005_\u0000\u0000\u1abd\u1abe\u0007\b\u0000\u0000\u1abe\u1abf"+ + "\u0007\u0013\u0000\u0000\u1abf\u1ac0\u0007\t\u0000\u0000\u1ac0\u1ac1\u0007"+ + "\u000b\u0000\u0000\u1ac1\u03ea\u0001\u0000\u0000\u0000\u1ac2\u1ac3\u0007"+ + "\u0017\u0000\u0000\u1ac3\u1ac4\u0007\u0003\u0000\u0000\u1ac4\u1ac5\u0007"+ + "\u001a\u0000\u0000\u1ac5\u1ac6\u0005_\u0000\u0000\u1ac6\u1ac7\u0007\u000b"+ + "\u0000\u0000\u1ac7\u1ac8\u0007\u000f\u0000\u0000\u1ac8\u1ac9\u0007\r\u0000"+ + "\u0000\u1ac9\u1aca\u0007\u0007\u0000\u0000\u1aca\u03ec\u0001\u0000\u0000"+ + "\u0000\u1acb\u1acc\u0007\u0017\u0000\u0000\u1acc\u1acd\u0007\u0003\u0000"+ + "\u0000\u1acd\u1ace\u0007\u001a\u0000\u0000\u1ace\u1acf\u0005_\u0000\u0000"+ + "\u1acf\u1ad0\u0007\u0011\u0000\u0000\u1ad0\u1ad1\u0007\u0019\u0000\u0000"+ + "\u1ad1\u1ad2\u0007\u0004\u0000\u0000\u1ad2\u1ad3\u0007\u0003\u0000\u0000"+ + "\u1ad3\u1ad4\u0007\u0006\u0000\u0000\u1ad4\u1ad5\u0007\u0007\u0000\u0000"+ + "\u1ad5\u1ad6\u0007\u000b\u0000\u0000\u1ad6\u1ad7\u0005_\u0000\u0000\u1ad7"+ + "\u1ad8\u0007\u0019\u0000\u0000\u1ad8\u1ad9\u0007\u0007\u0000\u0000\u1ad9"+ + "\u1ada\u0007\b\u0000\u0000\u1ada\u1adb\u0005_\u0000\u0000\u1adb\u1adc"+ + "\u0007\u0014\u0000\u0000\u1adc\u1add\u0007\u0013\u0000\u0000\u1add\u1ade"+ + "\u0007\u0011\u0000\u0000\u1ade\u1adf\u0007\b\u0000\u0000\u1adf\u03ee\u0001"+ + "\u0000\u0000\u0000\u1ae0\u1ae1\u0007\u0017\u0000\u0000\u1ae1\u1ae2\u0007"+ + "\u0003\u0000\u0000\u1ae2\u1ae3\u0007\u001a\u0000\u0000\u1ae3\u1ae4\u0005"+ + "_\u0000\u0000\u1ae4\u1ae5\u0007\u0011\u0000\u0000\u1ae5\u1ae6\u0007\u000b"+ + "\u0000\u0000\u1ae6\u1ae7\u0007\u0007\u0000\u0000\u1ae7\u1ae8\u0007\b\u0000"+ + "\u0000\u1ae8\u1ae9\u0005_\u0000\u0000\u1ae9\u1aea\u0007\u000e\u0000\u0000"+ + "\u1aea\u1aeb\u0007\u0013\u0000\u0000\u1aeb\u1aec\u0007\f\u0000\u0000\u1aec"+ + "\u1aed\u0007\f\u0000\u0000\u1aed\u1aee\u0007\u0007\u0000\u0000\u1aee\u1aef"+ + "\u0007\u000e\u0000\u0000\u1aef\u1af0\u0007\u0006\u0000\u0000\u1af0\u1af1"+ + "\u0007\u000f\u0000\u0000\u1af1\u1af2\u0007\u0013\u0000\u0000\u1af2\u1af3"+ + "\u0007\f\u0000\u0000\u1af3\u1af4\u0007\u000b\u0000\u0000\u1af4\u03f0\u0001"+ + "\u0000\u0000\u0000\u1af5\u1af6\u0007\u0017\u0000\u0000\u1af6\u1af7\u0007"+ + "\u0007\u0000\u0000\u1af7\u1af8\u0007\u0004\u0000\u0000\u1af8\u1af9\u0007"+ + "\u000f\u0000\u0000\u1af9\u1afa\u0007\u0011\u0000\u0000\u1afa\u1afb\u0007"+ + "\u0017\u0000\u0000\u1afb\u03f2\u0001\u0000\u0000\u0000\u1afc\u1afd\u0007"+ + "\u0017\u0000\u0000\u1afd\u1afe\u0007\u0007\u0000\u0000\u1afe\u1aff\u0007"+ + "\u0017\u0000\u0000\u1aff\u1b00\u0007\u0010\u0000\u0000\u1b00\u1b01\u0007"+ + "\u0007\u0000\u0000\u1b01\u1b02\u0007\b\u0000\u0000\u1b02\u03f4\u0001\u0000"+ + "\u0000\u0000\u1b03\u1b04\u0007\u0017\u0000\u0000\u1b04\u1b05\u0007\u0007"+ + "\u0000\u0000\u1b05\u1b06\u0007\b\u0000\u0000\u1b06\u1b07\u0007\u0016\u0000"+ + "\u0000\u1b07\u1b08\u0007\u0007\u0000\u0000\u1b08\u03f6\u0001\u0000\u0000"+ + "\u0000\u1b09\u1b0a\u0007\u0017\u0000\u0000\u1b0a\u1b0b\u0007\u0007\u0000"+ + "\u0000\u1b0b\u1b0c\u0007\u000b\u0000\u0000\u1b0c\u1b0d\u0007\u000b\u0000"+ + "\u0000\u1b0d\u1b0e\u0007\u0003\u0000\u0000\u1b0e\u1b0f\u0007\u0016\u0000"+ + "\u0000\u1b0f\u1b10\u0007\u0007\u0000\u0000\u1b10\u1b11\u0005_\u0000\u0000"+ + "\u1b11\u1b12\u0007\u0006\u0000\u0000\u1b12\u1b13\u0007\u0007\u0000\u0000"+ + "\u1b13\u1b14\u0007\u001a\u0000\u0000\u1b14\u1b15\u0007\u0006\u0000\u0000"+ + "\u1b15\u03f8\u0001\u0000\u0000\u0000\u1b16\u1b17\u0007\u0017\u0000\u0000"+ + "\u1b17\u1b18\u0007\u000f\u0000\u0000\u1b18\u1b19\u0007\u0004\u0000\u0000"+ + "\u1b19\u03fa\u0001\u0000\u0000\u0000\u1b1a\u1b1b\u0007\u0017\u0000\u0000"+ + "\u1b1b\u1b1c\u0007\u000f\u0000\u0000\u1b1c\u1b1d\u0007\u0016\u0000\u0000"+ + "\u1b1d\u1b1e\u0007\b\u0000\u0000\u1b1e\u1b1f\u0007\u0003\u0000\u0000\u1b1f"+ + "\u1b20\u0007\u0006\u0000\u0000\u1b20\u1b21\u0007\u0007\u0000\u0000\u1b21"+ + "\u03fc\u0001\u0000\u0000\u0000\u1b22\u1b23\u0007\u0017\u0000\u0000\u1b23"+ + "\u1b24\u0007\u000f\u0000\u0000\u1b24\u1b25\u0007\f\u0000\u0000\u1b25\u1b26"+ + "\u0005_\u0000\u0000\u1b26\u1b27\u0007\b\u0000\u0000\u1b27\u1b28\u0007"+ + "\u0013\u0000\u0000\u1b28\u1b29\u0007\t\u0000\u0000\u1b29\u1b2a\u0007\u000b"+ + "\u0000\u0000\u1b2a\u03fe\u0001\u0000\u0000\u0000\u1b2b\u1b2c\u0007\u0017"+ + "\u0000\u0000\u1b2c\u1b2d\u0007\u0013\u0000\u0000\u1b2d\u1b2e\u0007\u0004"+ + "\u0000\u0000\u1b2e\u1b2f\u0007\u0007\u0000\u0000\u1b2f\u0400\u0001\u0000"+ + "\u0000\u0000\u1b30\u1b31\u0007\u0017\u0000\u0000\u1b31\u1b32\u0007\u0013"+ + "\u0000\u0000\u1b32\u1b33\u0007\u0004\u0000\u0000\u1b33\u1b34\u0007\u000f"+ + "\u0000\u0000\u1b34\u1b35\u0007\u0012\u0000\u0000\u1b35\u1b36\u0007\n\u0000"+ + "\u0000\u1b36\u0402\u0001\u0000\u0000\u0000\u1b37\u1b38\u0007\u0017\u0000"+ + "\u0000\u1b38\u1b39\u0007\u0011\u0000\u0000\u1b39\u1b3a\u0007\u0006\u0000"+ + "\u0000\u1b3a\u1b3b\u0007\u0007\u0000\u0000\u1b3b\u1b3c\u0007\u001a\u0000"+ + "\u0000\u1b3c\u0404\u0001\u0000\u0000\u0000\u1b3d\u1b3e\u0007\u0017\u0000"+ + "\u0000\u1b3e\u1b3f\u0007\n\u0000\u0000\u1b3f\u1b40\u0007\u000b\u0000\u0000"+ + "\u1b40\u1b41\u0007\u001c\u0000\u0000\u1b41\u1b42\u0007\u0005\u0000\u0000"+ + "\u1b42\u0406\u0001\u0000\u0000\u0000\u1b43\u1b44\u0007\u0017\u0000\u0000"+ + "\u1b44\u1b45\u0007\n\u0000\u0000\u1b45\u1b46\u0007\u000b\u0000\u0000\u1b46"+ + "\u1b47\u0007\u001c\u0000\u0000\u1b47\u1b48\u0007\u0005\u0000\u0000\u1b48"+ + "\u1b49\u0005_\u0000\u0000\u1b49\u1b4a\u0007\u0007\u0000\u0000\u1b4a\u1b4b"+ + "\u0007\b\u0000\u0000\u1b4b\u1b4c\u0007\b\u0000\u0000\u1b4c\u1b4d\u0007"+ + "\f\u0000\u0000\u1b4d\u1b4e\u0007\u0013\u0000\u0000\u1b4e\u0408\u0001\u0000"+ + "\u0000\u0000\u1b4f\u1b50\u0007\f\u0000\u0000\u1b50\u1b51\u0007\u0003\u0000"+ + "\u0000\u1b51\u1b52\u0007\u0017\u0000\u0000\u1b52\u1b53\u0007\u0007\u0000"+ + "\u0000\u1b53\u040a\u0001\u0000\u0000\u0000\u1b54\u1b55\u0007\f\u0000\u0000"+ + "\u1b55\u1b56\u0007\u0003\u0000\u0000\u1b56\u1b57\u0007\u0017\u0000\u0000"+ + "\u1b57\u1b58\u0007\u0007\u0000\u0000\u1b58\u1b59\u0007\u000b\u0000\u0000"+ + "\u1b59\u040c\u0001\u0000\u0000\u0000\u1b5a\u1b5b\u0007\f\u0000\u0000\u1b5b"+ + "\u1b5c\u0007\u000e\u0000\u0000\u1b5c\u1b5d\u0007\u0014\u0000\u0000\u1b5d"+ + "\u1b5e\u0007\u0003\u0000\u0000\u1b5e\u1b5f\u0007\b\u0000\u0000\u1b5f\u040e"+ + "\u0001\u0000\u0000\u0000\u1b60\u1b61\u0007\f\u0000\u0000\u1b61\u1b62\u0007"+ + "\u0007\u0000\u0000\u1b62\u1b63\u0007\u0018\u0000\u0000\u1b63\u1b64\u0007"+ + "\u0007\u0000\u0000\u1b64\u1b65\u0007\b\u0000\u0000\u1b65\u0410\u0001\u0000"+ + "\u0000\u0000\u1b66\u1b67\u0007\f\u0000\u0000\u1b67\u1b68\u0007\u0007\u0000"+ + "\u0000\u1b68\u1b69\u0007\u001a\u0000\u0000\u1b69\u1b6a\u0007\u0006\u0000"+ + "\u0000\u1b6a\u0412\u0001\u0000\u0000\u0000\u1b6b\u1b6c\u0007\f\u0000\u0000"+ + "\u1b6c\u1b6d\u0007\u0013\u0000\u0000\u1b6d\u0414\u0001\u0000\u0000\u0000"+ + "\u1b6e\u1b6f\u0007\f\u0000\u0000\u1b6f\u1b70\u0007\u0013\u0000\u0000\u1b70"+ + "\u1b71\u0007\u000e\u0000\u0000\u1b71\u1b72\u0007\u0003\u0000\u0000\u1b72"+ + "\u1b73\u0007\u000e\u0000\u0000\u1b73\u1b74\u0007\u0014\u0000\u0000\u1b74"+ + "\u1b75\u0007\u0007\u0000\u0000\u1b75\u0416\u0001\u0000\u0000\u0000\u1b76"+ + "\u1b77\u0007\f\u0000\u0000\u1b77\u1b78\u0007\u0013\u0000\u0000\u1b78\u1b79"+ + "\u0007\u000e\u0000\u0000\u1b79\u1b7a\u0007\u0013\u0000\u0000\u1b7a\u1b7b"+ + "\u0007\u0019\u0000\u0000\u1b7b\u1b7c\u0007\n\u0000\u0000\u1b7c\u0418\u0001"+ + "\u0000\u0000\u0000\u1b7d\u1b7e\u0007\f\u0000\u0000\u1b7e\u1b7f\u0007\u0013"+ + "\u0000\u0000\u1b7f\u1b80\u0007\u000e\u0000\u0000\u1b80\u1b81\u0007\n\u0000"+ + "\u0000\u1b81\u1b82\u0007\u000e\u0000\u0000\u1b82\u1b83\u0007\u0005\u0000"+ + "\u0000\u1b83\u1b84\u0007\u0007\u0000\u0000\u1b84\u041a\u0001\u0000\u0000"+ + "\u0000\u1b85\u1b86\u0007\f\u0000\u0000\u1b86\u1b87\u0007\u0013\u0000\u0000"+ + "\u1b87\u1b88\u0007\u0017\u0000\u0000\u1b88\u1b89\u0007\u0003\u0000\u0000"+ + "\u1b89\u1b8a\u0007\u001a\u0000\u0000\u1b8a\u1b8b\u0007\u0018\u0000\u0000"+ + "\u1b8b\u1b8c\u0007\u0003\u0000\u0000\u1b8c\u1b8d\u0007\u0005\u0000\u0000"+ + "\u1b8d\u1b8e\u0007\u0011\u0000\u0000\u1b8e\u1b8f\u0007\u0007\u0000\u0000"+ + "\u1b8f\u041c\u0001\u0000\u0000\u0000\u1b90\u1b91\u0007\f\u0000\u0000\u1b91"+ + "\u1b92\u0007\u0013\u0000\u0000\u1b92\u1b93\u0007\u0017\u0000\u0000\u1b93"+ + "\u1b94\u0007\u000f\u0000\u0000\u1b94\u1b95\u0007\f\u0000\u0000\u1b95\u1b96"+ + "\u0007\u0018\u0000\u0000\u1b96\u1b97\u0007\u0003\u0000\u0000\u1b97\u1b98"+ + "\u0007\u0005\u0000\u0000\u1b98\u1b99\u0007\u0011\u0000\u0000\u1b99\u1b9a"+ + "\u0007\u0007\u0000\u0000\u1b9a\u041e\u0001\u0000\u0000\u0000\u1b9b\u1b9c"+ + "\u0007\f\u0000\u0000\u1b9c\u1b9d\u0007\u0013\u0000\u0000\u1b9d\u1b9e\u0007"+ + "\t\u0000\u0000\u1b9e\u1b9f\u0007\u0003\u0000\u0000\u1b9f\u1ba0\u0007\u000f"+ + "\u0000\u0000\u1ba0\u1ba1\u0007\u0006\u0000\u0000\u1ba1\u0420\u0001\u0000"+ + "\u0000\u0000\u1ba2\u1ba3\u0007\f\u0000\u0000\u1ba3\u1ba4\u0007\u0013\u0000"+ + "\u0000\u1ba4\u1ba5\u0007\u0004\u0000\u0000\u1ba5\u1ba6\u0007\u0007\u0000"+ + "\u0000\u1ba6\u1ba7\u0007\u0016\u0000\u0000\u1ba7\u1ba8\u0007\b\u0000\u0000"+ + "\u1ba8\u1ba9\u0007\u0013\u0000\u0000\u1ba9\u1baa\u0007\u0011\u0000\u0000"+ + "\u1baa\u1bab\u0007\u0019\u0000\u0000\u1bab\u0422\u0001\u0000\u0000\u0000"+ + "\u1bac\u1bad\u0007\f\u0000\u0000\u1bad\u1bae\u0007\u0013\u0000\u0000\u1bae"+ + "\u1baf\u0007\f\u0000\u0000\u1baf\u1bb0\u0007\u0007\u0000\u0000\u1bb0\u0424"+ + "\u0001\u0000\u0000\u0000\u1bb1\u1bb2\u0007\u0013\u0000\u0000\u1bb2\u1bb3"+ + "\u0007\u0004\u0000\u0000\u1bb3\u1bb4\u0007\u0010\u0000\u0000\u1bb4\u1bb5"+ + "\u0007\u000e\u0000\u0000\u1bb5\u0426\u0001\u0000\u0000\u0000\u1bb6\u1bb7"+ + "\u0007\u0013\u0000\u0000\u1bb7\u1bb8\u0007\u0012\u0000\u0000\u1bb8\u1bb9"+ + "\u0007\u0012\u0000\u0000\u1bb9\u1bba\u0007\u0005\u0000\u0000\u1bba\u1bbb"+ + "\u0007\u000f\u0000\u0000\u1bbb\u1bbc\u0007\f\u0000\u0000\u1bbc\u1bbd\u0007"+ + "\u0007\u0000\u0000\u1bbd\u0428\u0001\u0000\u0000\u0000\u1bbe\u1bbf\u0007"+ + "\u0013\u0000\u0000\u1bbf\u1bc0\u0007\u0012\u0000\u0000\u1bc0\u1bc1\u0007"+ + "\u0012\u0000\u0000\u1bc1\u1bc2\u0007\u000b\u0000\u0000\u1bc2\u1bc3\u0007"+ + "\u0007\u0000\u0000\u1bc3\u1bc4\u0007\u0006\u0000\u0000\u1bc4\u042a\u0001"+ + "\u0000\u0000\u0000\u1bc5\u1bc6\u0007\u0013\u0000\u0000\u1bc6\u1bc7\u0007"+ + "\u0012\u0000\u0000\u1bc7\u042c\u0001\u0000\u0000\u0000\u1bc8\u1bc9\u0007"+ + "\u0013\u0000\u0000\u1bc9\u1bca\u0007\u001b\u0000\u0000\u1bca\u042e\u0001"+ + "\u0000\u0000\u0000\u1bcb\u1bcc\u0007\u0013\u0000\u0000\u1bcc\u1bcd\u0007"+ + "\u0005\u0000\u0000\u1bcd\u1bce\u0007\u0004\u0000\u0000\u1bce\u1bcf\u0005"+ + "_\u0000\u0000\u1bcf\u1bd0\u0007\u0019\u0000\u0000\u1bd0\u1bd1\u0007\u0003"+ + "\u0000\u0000\u1bd1\u1bd2\u0007\u000b\u0000\u0000\u1bd2\u1bd3\u0007\u000b"+ + "\u0000\u0000\u1bd3\u1bd4\u0007\t\u0000\u0000\u1bd4\u1bd5\u0007\u0013\u0000"+ + "\u0000\u1bd5\u1bd6\u0007\b\u0000\u0000\u1bd6\u1bd7\u0007\u0004\u0000\u0000"+ + "\u1bd7\u0430\u0001\u0000\u0000\u0000\u1bd8\u1bd9\u0007\u0013\u0000\u0000"+ + "\u1bd9\u1bda\u0007\f\u0000\u0000\u1bda\u1bdb\u0007\u0007\u0000\u0000\u1bdb"+ + "\u0432\u0001\u0000\u0000\u0000\u1bdc\u1bdd\u0007\u0013\u0000\u0000\u1bdd"+ + "\u1bde\u0007\f\u0000\u0000\u1bde\u1bdf\u0007\u0005\u0000\u0000\u1bdf\u1be0"+ + "\u0007\u000f\u0000\u0000\u1be0\u1be1\u0007\f\u0000\u0000\u1be1\u1be2\u0007"+ + "\u0007\u0000\u0000\u1be2\u0434\u0001\u0000\u0000\u0000\u1be3\u1be4\u0007"+ + "\u0013\u0000\u0000\u1be4\u1be5\u0007\f\u0000\u0000\u1be5\u1be6\u0007\u0005"+ + "\u0000\u0000\u1be6\u1be7\u0007\n\u0000\u0000\u1be7\u0436\u0001\u0000\u0000"+ + "\u0000\u1be8\u1be9\u0007\u0013\u0000\u0000\u1be9\u1bea\u0007\u0019\u0000"+ + "\u0000\u1bea\u1beb\u0007\u0007\u0000\u0000\u1beb\u1bec\u0007\f\u0000\u0000"+ + "\u1bec\u0438\u0001\u0000\u0000\u0000\u1bed\u1bee\u0007\u0013\u0000\u0000"+ + "\u1bee\u1bef\u0007\u0019\u0000\u0000\u1bef\u1bf0\u0007\u0006\u0000\u0000"+ + "\u1bf0\u1bf1\u0007\u000f\u0000\u0000\u1bf1\u1bf2\u0007\u0017\u0000\u0000"+ + "\u1bf2\u1bf3\u0007\u000f\u0000\u0000\u1bf3\u1bf4\u0007\r\u0000\u0000\u1bf4"+ + "\u1bf5\u0007\u0007\u0000\u0000\u1bf5\u1bf6\u0007\b\u0000\u0000\u1bf6\u1bf7"+ + "\u0005_\u0000\u0000\u1bf7\u1bf8\u0007\u000e\u0000\u0000\u1bf8\u1bf9\u0007"+ + "\u0013\u0000\u0000\u1bf9\u1bfa\u0007\u000b\u0000\u0000\u1bfa\u1bfb\u0007"+ + "\u0006\u0000\u0000\u1bfb\u1bfc\u0007\u000b\u0000\u0000\u1bfc\u043a\u0001"+ + "\u0000\u0000\u0000\u1bfd\u1bfe\u0007\u0013\u0000\u0000\u1bfe\u1bff\u0007"+ + "\u0019\u0000\u0000\u1bff\u1c00\u0007\u0006\u0000\u0000\u1c00\u1c01\u0007"+ + "\u000f\u0000\u0000\u1c01\u1c02\u0007\u0013\u0000\u0000\u1c02\u1c03\u0007"+ + "\f\u0000\u0000\u1c03\u1c04\u0007\u000b\u0000\u0000\u1c04\u043c\u0001\u0000"+ + "\u0000\u0000\u1c05\u1c06\u0007\u0013\u0000\u0000\u1c06\u1c07\u0007\t\u0000"+ + "\u0000\u1c07\u1c08\u0007\f\u0000\u0000\u1c08\u1c09\u0007\u0007\u0000\u0000"+ + "\u1c09\u1c0a\u0007\b\u0000\u0000\u1c0a\u043e\u0001\u0000\u0000\u0000\u1c0b"+ + "\u1c0c\u0007\u0019\u0000\u0000\u1c0c\u1c0d\u0007\u0003\u0000\u0000\u1c0d"+ + "\u1c0e\u0007\u000e\u0000\u0000\u1c0e\u1c0f\u0007\u0015\u0000\u0000\u1c0f"+ + "\u1c10\u0005_\u0000\u0000\u1c10\u1c11\u0007\u0015\u0000\u0000\u1c11\u1c12"+ + "\u0007\u0007\u0000\u0000\u1c12\u1c13\u0007\n\u0000\u0000\u1c13\u1c14\u0007"+ + "\u000b\u0000\u0000\u1c14\u0440\u0001\u0000\u0000\u0000\u1c15\u1c16\u0007"+ + "\u0019\u0000\u0000\u1c16\u1c17\u0007\u0003\u0000\u0000\u1c17\u1c18\u0007"+ + "\u0016\u0000\u0000\u1c18\u1c19\u0007\u0007\u0000\u0000\u1c19\u0442\u0001"+ + "\u0000\u0000\u0000\u1c1a\u1c1b\u0007\u0019\u0000\u0000\u1c1b\u1c1c\u0007"+ + "\u0003\u0000\u0000\u1c1c\u1c1d\u0007\u0016\u0000\u0000\u1c1d\u1c1e\u0007"+ + "\u0007\u0000\u0000\u1c1e\u1c1f\u0005_\u0000\u0000\u1c1f\u1c20\u0007\u000e"+ + "\u0000\u0000\u1c20\u1c21\u0007\u0013\u0000\u0000\u1c21\u1c22\u0007\u0017"+ + "\u0000\u0000\u1c22\u1c23\u0007\u0019\u0000\u0000\u1c23\u1c24\u0007\b\u0000"+ + "\u0000\u1c24\u1c25\u0007\u0007\u0000\u0000\u1c25\u1c26\u0007\u000b\u0000"+ + "\u0000\u1c26\u1c27\u0007\u000b\u0000\u0000\u1c27\u1c28\u0007\u0007\u0000"+ + "\u0000\u1c28\u1c29\u0007\u0004\u0000\u0000\u1c29\u0444\u0001\u0000\u0000"+ + "\u0000\u1c2a\u1c2b\u0007\u0019\u0000\u0000\u1c2b\u1c2c\u0007\u0003\u0000"+ + "\u0000\u1c2c\u1c2d\u0007\u0016\u0000\u0000\u1c2d\u1c2e\u0007\u0007\u0000"+ + "\u0000\u1c2e\u1c2f\u0005_\u0000\u0000\u1c2f\u1c30\u0007\u000e\u0000\u0000"+ + "\u1c30\u1c31\u0007\u0013\u0000\u0000\u1c31\u1c32\u0007\u0017\u0000\u0000"+ + "\u1c32\u1c33\u0007\u0019\u0000\u0000\u1c33\u1c34\u0007\b\u0000\u0000\u1c34"+ + "\u1c35\u0007\u0007\u0000\u0000\u1c35\u1c36\u0007\u000b\u0000\u0000\u1c36"+ + "\u1c37\u0007\u000b\u0000\u0000\u1c37\u1c38\u0007\u000f\u0000\u0000\u1c38"+ + "\u1c39\u0007\u0013\u0000\u0000\u1c39\u1c3a\u0007\f\u0000\u0000\u1c3a\u1c3b"+ + "\u0005_\u0000\u0000\u1c3b\u1c3c\u0007\u0005\u0000\u0000\u1c3c\u1c3d\u0007"+ + "\u0007\u0000\u0000\u1c3d\u1c3e\u0007\u0018\u0000\u0000\u1c3e\u1c3f\u0007"+ + "\u0007\u0000\u0000\u1c3f\u1c40\u0007\u0005\u0000\u0000\u1c40\u0446\u0001"+ + "\u0000\u0000\u0000\u1c41\u1c42\u0007\u0019\u0000\u0000\u1c42\u1c43\u0007"+ + "\u0003\u0000\u0000\u1c43\u1c44\u0007\b\u0000\u0000\u1c44\u1c45\u0007\u000b"+ + "\u0000\u0000\u1c45\u1c46\u0007\u0007\u0000\u0000\u1c46\u1c47\u0007\b\u0000"+ + "\u0000\u1c47\u0448\u0001\u0000\u0000\u0000\u1c48\u1c49\u0007\u0019\u0000"+ + "\u0000\u1c49\u1c4a\u0007\u0003\u0000\u0000\u1c4a\u1c4b\u0007\b\u0000\u0000"+ + "\u1c4b\u1c4c\u0007\u0006\u0000\u0000\u1c4c\u1c4d\u0007\u000f\u0000\u0000"+ + "\u1c4d\u1c4e\u0007\u0003\u0000\u0000\u1c4e\u1c4f\u0007\u0005\u0000\u0000"+ + "\u1c4f\u044a\u0001\u0000\u0000\u0000\u1c50\u1c51\u0007\u0019\u0000\u0000"+ + "\u1c51\u1c52\u0007\u0003\u0000\u0000\u1c52\u1c53\u0007\b\u0000\u0000\u1c53"+ + "\u1c54\u0007\u0006\u0000\u0000\u1c54\u1c55\u0007\u000f\u0000\u0000\u1c55"+ + "\u1c56\u0007\u0006\u0000\u0000\u1c56\u1c57\u0007\u000f\u0000\u0000\u1c57"+ + "\u1c58\u0007\u0013\u0000\u0000\u1c58\u1c59\u0007\f\u0000\u0000\u1c59\u1c5a"+ + "\u0007\u000f\u0000\u0000\u1c5a\u1c5b\u0007\f\u0000\u0000\u1c5b\u1c5c\u0007"+ + "\u0016\u0000\u0000\u1c5c\u044c\u0001\u0000\u0000\u0000\u1c5d\u1c5e\u0007"+ + "\u0019\u0000\u0000\u1c5e\u1c5f\u0007\u0003\u0000\u0000\u1c5f\u1c60\u0007"+ + "\b\u0000\u0000\u1c60\u1c61\u0007\u0006\u0000\u0000\u1c61\u1c62\u0007\u000f"+ + "\u0000\u0000\u1c62\u1c63\u0007\u0006\u0000\u0000\u1c63\u1c64\u0007\u000f"+ + "\u0000\u0000\u1c64\u1c65\u0007\u0013\u0000\u0000\u1c65\u1c66\u0007\f\u0000"+ + "\u0000\u1c66\u1c67\u0007\u000b\u0000\u0000\u1c67\u044e\u0001\u0000\u0000"+ + "\u0000\u1c68\u1c69\u0007\u0019\u0000\u0000\u1c69\u1c6a\u0007\u0003\u0000"+ + "\u0000\u1c6a\u1c6b\u0007\u000b\u0000\u0000\u1c6b\u1c6c\u0007\u000b\u0000"+ + "\u0000\u1c6c\u1c6d\u0007\t\u0000\u0000\u1c6d\u1c6e\u0007\u0013\u0000\u0000"+ + "\u1c6e\u1c6f\u0007\b\u0000\u0000\u1c6f\u1c70\u0007\u0004\u0000\u0000\u1c70"+ + "\u0450\u0001\u0000\u0000\u0000\u1c71\u1c72\u0007\u0019\u0000\u0000\u1c72"+ + "\u1c73\u0007\u0003\u0000\u0000\u1c73\u1c74\u0007\u000b\u0000\u0000\u1c74"+ + "\u1c75\u0007\u000b\u0000\u0000\u1c75\u1c76\u0007\t\u0000\u0000\u1c76\u1c77"+ + "\u0007\u0013\u0000\u0000\u1c77\u1c78\u0007\b\u0000\u0000\u1c78\u1c79\u0007"+ + "\u0004\u0000\u0000\u1c79\u1c7a\u0005_\u0000\u0000\u1c7a\u1c7b\u0007\u0005"+ + "\u0000\u0000\u1c7b\u1c7c\u0007\u0013\u0000\u0000\u1c7c\u1c7d\u0007\u000e"+ + "\u0000\u0000\u1c7d\u1c7e\u0007\u0015\u0000\u0000\u1c7e\u1c7f\u0005_\u0000"+ + "\u0000\u1c7f\u1c80\u0007\u0006\u0000\u0000\u1c80\u1c81\u0007\u000f\u0000"+ + "\u0000\u1c81\u1c82\u0007\u0017\u0000\u0000\u1c82\u1c83\u0007\u0007\u0000"+ + "\u0000\u1c83\u0452\u0001\u0000\u0000\u0000\u1c84\u1c85\u0007\u0019\u0000"+ + "\u0000\u1c85\u1c86\u0007\u0014\u0000\u0000\u1c86\u1c87\u0007\u0003\u0000"+ + "\u0000\u1c87\u1c88\u0007\u000b\u0000\u0000\u1c88\u1c89\u0007\u0007\u0000"+ + "\u0000\u1c89\u0454\u0001\u0000\u0000\u0000\u1c8a\u1c8b\u0007\u0019\u0000"+ + "\u0000\u1c8b\u1c8c\u0007\u0005\u0000\u0000\u1c8c\u1c8d\u0007\u0011\u0000"+ + "\u0000\u1c8d\u1c8e\u0007\u0016\u0000\u0000\u1c8e\u1c8f\u0007\u000f\u0000"+ + "\u0000\u1c8f\u1c90\u0007\f\u0000\u0000\u1c90\u0456\u0001\u0000\u0000\u0000"+ + "\u1c91\u1c92\u0007\u0019\u0000\u0000\u1c92\u1c93\u0007\u0005\u0000\u0000"+ + "\u1c93\u1c94\u0007\u0011\u0000\u0000\u1c94\u1c95\u0007\u0016\u0000\u0000"+ + "\u1c95\u1c96\u0007\u000f\u0000\u0000\u1c96\u1c97\u0007\f\u0000\u0000\u1c97"+ + "\u1c98\u0005_\u0000\u0000\u1c98\u1c99\u0007\u0004\u0000\u0000\u1c99\u1c9a"+ + "\u0007\u000f\u0000\u0000\u1c9a\u1c9b\u0007\b\u0000\u0000\u1c9b\u0458\u0001"+ + "\u0000\u0000\u0000\u1c9c\u1c9d\u0007\u0019\u0000\u0000\u1c9d\u1c9e\u0007"+ + "\u0005\u0000\u0000\u1c9e\u1c9f\u0007\u0011\u0000\u0000\u1c9f\u1ca0\u0007"+ + "\u0016\u0000\u0000\u1ca0\u1ca1\u0007\u000f\u0000\u0000\u1ca1\u1ca2\u0007"+ + "\f\u0000\u0000\u1ca2\u1ca3\u0007\u000b\u0000\u0000\u1ca3\u045a\u0001\u0000"+ + "\u0000\u0000\u1ca4\u1ca5\u0007\u0019\u0000\u0000\u1ca5\u1ca6\u0007\u0013"+ + "\u0000\u0000\u1ca6\u1ca7\u0007\b\u0000\u0000\u1ca7\u1ca8\u0007\u0006\u0000"+ + "\u0000\u1ca8\u045c\u0001\u0000\u0000\u0000\u1ca9\u1caa\u0007\u0019\u0000"+ + "\u0000\u1caa\u1cab\u0007\b\u0000\u0000\u1cab\u1cac\u0007\u0007\u0000\u0000"+ + "\u1cac\u1cad\u0007\u000e\u0000\u0000\u1cad\u1cae\u0007\u0007\u0000\u0000"+ + "\u1cae\u1caf\u0007\u0004\u0000\u0000\u1caf\u1cb0\u0007\u0007\u0000\u0000"+ + "\u1cb0\u1cb1\u0007\u000b\u0000\u0000\u1cb1\u045e\u0001\u0000\u0000\u0000"+ + "\u1cb2\u1cb3\u0007\u0019\u0000\u0000\u1cb3\u1cb4\u0007\b\u0000\u0000\u1cb4"+ + "\u1cb5\u0007\u0007\u0000\u0000\u1cb5\u1cb6\u0007\u000e\u0000\u0000\u1cb6"+ + "\u1cb7\u0007\u0007\u0000\u0000\u1cb7\u1cb8\u0007\u0004\u0000\u0000\u1cb8"+ + "\u1cb9\u0007\u000f\u0000\u0000\u1cb9\u1cba\u0007\f\u0000\u0000\u1cba\u1cbb"+ + "\u0007\u0016\u0000\u0000\u1cbb\u0460\u0001\u0000\u0000\u0000\u1cbc\u1cbd"+ + "\u0007\u0019\u0000\u0000\u1cbd\u1cbe\u0007\b\u0000\u0000\u1cbe\u1cbf\u0007"+ + "\u0007\u0000\u0000\u1cbf\u1cc0\u0007\u0019\u0000\u0000\u1cc0\u1cc1\u0007"+ + "\u0003\u0000\u0000\u1cc1\u1cc2\u0007\b\u0000\u0000\u1cc2\u1cc3\u0007\u0007"+ + "\u0000\u0000\u1cc3\u0462\u0001\u0000\u0000\u0000\u1cc4\u1cc5\u0007\u0019"+ + "\u0000\u0000\u1cc5\u1cc6\u0007\b\u0000\u0000\u1cc6\u1cc7\u0007\u0007\u0000"+ + "\u0000\u1cc7\u1cc8\u0007\u000b\u0000\u0000\u1cc8\u1cc9\u0007\u0007\u0000"+ + "\u0000\u1cc9\u1cca\u0007\b\u0000\u0000\u1cca\u1ccb\u0007\u0018\u0000\u0000"+ + "\u1ccb\u1ccc\u0007\u0007\u0000\u0000\u1ccc\u0464\u0001\u0000\u0000\u0000"+ + "\u1ccd\u1cce\u0007\u0019\u0000\u0000\u1cce\u1ccf\u0007\b\u0000\u0000\u1ccf"+ + "\u1cd0\u0007\u0007\u0000\u0000\u1cd0\u1cd1\u0007\u0018\u0000\u0000\u1cd1"+ + "\u0466\u0001\u0000\u0000\u0000\u1cd2\u1cd3\u0007\u0019\u0000\u0000\u1cd3"+ + "\u1cd4\u0007\b\u0000\u0000\u1cd4\u1cd5\u0007\u0013\u0000\u0000\u1cd5\u1cd6"+ + "\u0007\u000e\u0000\u0000\u1cd6\u1cd7\u0007\u0007\u0000\u0000\u1cd7\u1cd8"+ + "\u0007\u000b\u0000\u0000\u1cd8\u1cd9\u0007\u000b\u0000\u0000\u1cd9\u1cda"+ + "\u0007\u0005\u0000\u0000\u1cda\u1cdb\u0007\u000f\u0000\u0000\u1cdb\u1cdc"+ + "\u0007\u000b\u0000\u0000\u1cdc\u1cdd\u0007\u0006\u0000\u0000\u1cdd\u0468"+ + "\u0001\u0000\u0000\u0000\u1cde\u1cdf\u0007\u0019\u0000\u0000\u1cdf\u1ce0"+ + "\u0007\b\u0000\u0000\u1ce0\u1ce1\u0007\u0013\u0000\u0000\u1ce1\u1ce2\u0007"+ + "\u0012\u0000\u0000\u1ce2\u1ce3\u0007\u000f\u0000\u0000\u1ce3\u1ce4\u0007"+ + "\u0005\u0000\u0000\u1ce4\u1ce5\u0007\u0007\u0000\u0000\u1ce5\u046a\u0001"+ + "\u0000\u0000\u0000\u1ce6\u1ce7\u0007\u0019\u0000\u0000\u1ce7\u1ce8\u0007"+ + "\b\u0000\u0000\u1ce8\u1ce9\u0007\u0013\u0000\u0000\u1ce9\u1cea\u0007\u0012"+ + "\u0000\u0000\u1cea\u1ceb\u0007\u000f\u0000\u0000\u1ceb\u1cec\u0007\u0005"+ + "\u0000\u0000\u1cec\u1ced\u0007\u0007\u0000\u0000\u1ced\u1cee\u0007\u000b"+ + "\u0000\u0000\u1cee\u046c\u0001\u0000\u0000\u0000\u1cef\u1cf0\u0007\u0019"+ + "\u0000\u0000\u1cf0\u1cf1\u0007\b\u0000\u0000\u1cf1\u1cf2\u0007\u0013\u0000"+ + "\u0000\u1cf2\u1cf3\u0007\u001a\u0000\u0000\u1cf3\u1cf4\u0007\n\u0000\u0000"+ + "\u1cf4\u046e\u0001\u0000\u0000\u0000\u1cf5\u1cf6\u0007\u001c\u0000\u0000"+ + "\u1cf6\u1cf7\u0007\u0011\u0000\u0000\u1cf7\u1cf8\u0007\u0007\u0000\u0000"+ + "\u1cf8\u1cf9\u0007\b\u0000\u0000\u1cf9\u1cfa\u0007\n\u0000\u0000\u1cfa"+ + "\u0470\u0001\u0000\u0000\u0000\u1cfb\u1cfc\u0007\u001c\u0000\u0000\u1cfc"+ + "\u1cfd\u0007\u0011\u0000\u0000\u1cfd\u1cfe\u0007\u000f\u0000\u0000\u1cfe"+ + "\u1cff\u0007\u000e\u0000\u0000\u1cff\u1d00\u0007\u0015\u0000\u0000\u1d00"+ + "\u0472\u0001\u0000\u0000\u0000\u1d01\u1d02\u0007\b\u0000\u0000\u1d02\u1d03"+ + "\u0007\u0007\u0000\u0000\u1d03\u1d04\u0007\u0010\u0000\u0000\u1d04\u1d05"+ + "\u0007\u0011\u0000\u0000\u1d05\u1d06\u0007\u000f\u0000\u0000\u1d06\u1d07"+ + "\u0007\u0005\u0000\u0000\u1d07\u1d08\u0007\u0004\u0000\u0000\u1d08\u0474"+ + "\u0001\u0000\u0000\u0000\u1d09\u1d0a\u0007\b\u0000\u0000\u1d0a\u1d0b\u0007"+ + "\u0007\u0000\u0000\u1d0b\u1d0c\u0007\u000e\u0000\u0000\u1d0c\u1d0d\u0007"+ + "\u0013\u0000\u0000\u1d0d\u1d0e\u0007\u0018\u0000\u0000\u1d0e\u1d0f\u0007"+ + "\u0007\u0000\u0000\u1d0f\u1d10\u0007\b\u0000\u0000\u1d10\u0476\u0001\u0000"+ + "\u0000\u0000\u1d11\u1d12\u0007\b\u0000\u0000\u1d12\u1d13\u0007\u0007\u0000"+ + "\u0000\u1d13\u1d14\u0007\u000e\u0000\u0000\u1d14\u1d15\u0007\u0011\u0000"+ + "\u0000\u1d15\u1d16\u0007\b\u0000\u0000\u1d16\u1d17\u0007\u000b\u0000\u0000"+ + "\u1d17\u1d18\u0007\u000f\u0000\u0000\u1d18\u1d19\u0007\u0018\u0000\u0000"+ + "\u1d19\u1d1a\u0007\u0007\u0000\u0000\u1d1a\u0478\u0001\u0000\u0000\u0000"+ + "\u1d1b\u1d1c\u0007\b\u0000\u0000\u1d1c\u1d1d\u0007\u0007\u0000\u0000\u1d1d"+ + "\u1d1e\u0007\u0004\u0000\u0000\u1d1e\u1d1f\u0007\u0013\u0000\u0000\u1d1f"+ + "\u1d20\u0005_\u0000\u0000\u1d20\u1d21\u0007\u0010\u0000\u0000\u1d21\u1d22"+ + "\u0007\u0011\u0000\u0000\u1d22\u1d23\u0007\u0012\u0000\u0000\u1d23\u1d24"+ + "\u0007\u0012\u0000\u0000\u1d24\u1d25\u0007\u0007\u0000\u0000\u1d25\u1d26"+ + "\u0007\b\u0000\u0000\u1d26\u1d27\u0005_\u0000\u0000\u1d27\u1d28\u0007"+ + "\u000b\u0000\u0000\u1d28\u1d29\u0007\u000f\u0000\u0000\u1d29\u1d2a\u0007"+ + "\r\u0000\u0000\u1d2a\u1d2b\u0007\u0007\u0000\u0000\u1d2b\u047a\u0001\u0000"+ + "\u0000\u0000\u1d2c\u1d2d\u0007\b\u0000\u0000\u1d2d\u1d2e\u0007\u0007\u0000"+ + "\u0000\u1d2e\u1d2f\u0007\u0004\u0000\u0000\u1d2f\u1d30\u0007\u0011\u0000"+ + "\u0000\u1d30\u1d31\u0007\f\u0000\u0000\u1d31\u1d32\u0007\u0004\u0000\u0000"+ + "\u1d32\u1d33\u0007\u0003\u0000\u0000\u1d33\u1d34\u0007\f\u0000\u0000\u1d34"+ + "\u1d35\u0007\u0006\u0000\u0000\u1d35\u047c\u0001\u0000\u0000\u0000\u1d36"+ + "\u1d37\u0007\b\u0000\u0000\u1d37\u1d38\u0007\u0007\u0000\u0000\u1d38\u1d39"+ + "\u0007\u0005\u0000\u0000\u1d39\u1d3a\u0007\u0003\u0000\u0000\u1d3a\u1d3b"+ + "\u0007\n\u0000\u0000\u1d3b\u047e\u0001\u0000\u0000\u0000\u1d3c\u1d3d\u0007"+ + "\b\u0000\u0000\u1d3d\u1d3e\u0007\u0007\u0000\u0000\u1d3e\u1d3f\u0007\u0005"+ + "\u0000\u0000\u1d3f\u1d40\u0007\u0003\u0000\u0000\u1d40\u1d41\u0007\n\u0000"+ + "\u0000\u1d41\u1d42\u0005_\u0000\u0000\u1d42\u1d43\u0007\u0005\u0000\u0000"+ + "\u1d43\u1d44\u0007\u0013\u0000\u0000\u1d44\u1d45\u0007\u0016\u0000\u0000"+ + "\u1d45\u1d46\u0005_\u0000\u0000\u1d46\u1d47\u0007\u0012\u0000\u0000\u1d47"+ + "\u1d48\u0007\u000f\u0000\u0000\u1d48\u1d49\u0007\u0005\u0000\u0000\u1d49"+ + "\u1d4a\u0007\u0007\u0000\u0000\u1d4a\u0480\u0001\u0000\u0000\u0000\u1d4b"+ + "\u1d4c\u0007\b\u0000\u0000\u1d4c\u1d4d\u0007\u0007\u0000\u0000\u1d4d\u1d4e"+ + "\u0007\u0005\u0000\u0000\u1d4e\u1d4f\u0007\u0003\u0000\u0000\u1d4f\u1d50"+ + "\u0007\n\u0000\u0000\u1d50\u1d51\u0005_\u0000\u0000\u1d51\u1d52\u0007"+ + "\u0005\u0000\u0000\u1d52\u1d53\u0007\u0013\u0000\u0000\u1d53\u1d54\u0007"+ + "\u0016\u0000\u0000\u1d54\u1d55\u0005_\u0000\u0000\u1d55\u1d56\u0007\u0019"+ + "\u0000\u0000\u1d56\u1d57\u0007\u0013\u0000\u0000\u1d57\u1d58\u0007\u000b"+ + "\u0000\u0000\u1d58\u0482\u0001\u0000\u0000\u0000\u1d59\u1d5a\u0007\b\u0000"+ + "\u0000\u1d5a\u1d5b\u0007\u0007\u0000\u0000\u1d5b\u1d5c\u0007\u0005\u0000"+ + "\u0000\u1d5c\u1d5d\u0007\u0003\u0000\u0000\u1d5d\u1d5e\u0007\n\u0000\u0000"+ + "\u1d5e\u1d5f\u0007\u0005\u0000\u0000\u1d5f\u1d60\u0007\u0013\u0000\u0000"+ + "\u1d60\u1d61\u0007\u0016\u0000\u0000\u1d61\u0484\u0001\u0000\u0000\u0000"+ + "\u1d62\u1d63\u0007\b\u0000\u0000\u1d63\u1d64\u0007\u0007\u0000\u0000\u1d64"+ + "\u1d65\u0007\u0017\u0000\u0000\u1d65\u1d66\u0007\u0013\u0000\u0000\u1d66"+ + "\u1d67\u0007\u0018\u0000\u0000\u1d67\u1d68\u0007\u0007\u0000\u0000\u1d68"+ + "\u0486\u0001\u0000\u0000\u0000\u1d69\u1d6a\u0007\b\u0000\u0000\u1d6a\u1d6b"+ + "\u0007\u0007\u0000\u0000\u1d6b\u1d6c\u0007\u0013\u0000\u0000\u1d6c\u1d6d"+ + "\u0007\b\u0000\u0000\u1d6d\u1d6e\u0007\u0016\u0000\u0000\u1d6e\u1d6f\u0007"+ + "\u0003\u0000\u0000\u1d6f\u1d70\u0007\f\u0000\u0000\u1d70\u1d71\u0007\u000f"+ + "\u0000\u0000\u1d71\u1d72\u0007\r\u0000\u0000\u1d72\u1d73\u0007\u0007\u0000"+ + "\u0000\u1d73\u0488\u0001\u0000\u0000\u0000\u1d74\u1d75\u0007\b\u0000\u0000"+ + "\u1d75\u1d76\u0007\u0007\u0000\u0000\u1d76\u1d77\u0007\u0019\u0000\u0000"+ + "\u1d77\u1d78\u0007\u0003\u0000\u0000\u1d78\u1d79\u0007\u000f\u0000\u0000"+ + "\u1d79\u1d7a\u0007\b\u0000\u0000\u1d7a\u048a\u0001\u0000\u0000\u0000\u1d7b"+ + "\u1d7c\u0007\b\u0000\u0000\u1d7c\u1d7d\u0007\u0007\u0000\u0000\u1d7d\u1d7e"+ + "\u0007\u0019\u0000\u0000\u1d7e\u1d7f\u0007\u0005\u0000\u0000\u1d7f\u1d80"+ + "\u0007\u000f\u0000\u0000\u1d80\u1d81\u0007\u000e\u0000\u0000\u1d81\u1d82"+ + "\u0007\u0003\u0000\u0000\u1d82\u1d83\u0007\u0006\u0000\u0000\u1d83\u1d84"+ + "\u0007\u0007\u0000\u0000\u1d84\u1d85\u0005_\u0000\u0000\u1d85\u1d86\u0007"+ + "\u0004\u0000\u0000\u1d86\u1d87\u0007\u0013\u0000\u0000\u1d87\u1d88\u0005"+ + "_\u0000\u0000\u1d88\u1d89\u0007\u0004\u0000\u0000\u1d89\u1d8a\u0007\u0010"+ + "\u0000\u0000\u1d8a\u048c\u0001\u0000\u0000\u0000\u1d8b\u1d8c\u0007\b\u0000"+ + "\u0000\u1d8c\u1d8d\u0007\u0007\u0000\u0000\u1d8d\u1d8e\u0007\u0019\u0000"+ + "\u0000\u1d8e\u1d8f\u0007\u0005\u0000\u0000\u1d8f\u1d90\u0007\u000f\u0000"+ + "\u0000\u1d90\u1d91\u0007\u000e\u0000\u0000\u1d91\u1d92\u0007\u0003\u0000"+ + "\u0000\u1d92\u1d93\u0007\u0006\u0000\u0000\u1d93\u1d94\u0007\u0007\u0000"+ + "\u0000\u1d94\u1d95\u0005_\u0000\u0000\u1d95\u1d96\u0007\u0004\u0000\u0000"+ + "\u1d96\u1d97\u0007\u0013\u0000\u0000\u1d97\u1d98\u0005_\u0000\u0000\u1d98"+ + "\u1d99\u0007\u0006\u0000\u0000\u1d99\u1d9a\u0007\u0003\u0000\u0000\u1d9a"+ + "\u1d9b\u0007\u0010\u0000\u0000\u1d9b\u1d9c\u0007\u0005\u0000\u0000\u1d9c"+ + "\u1d9d\u0007\u0007\u0000\u0000\u1d9d\u048e\u0001\u0000\u0000\u0000\u1d9e"+ + "\u1d9f\u0007\b\u0000\u0000\u1d9f\u1da0\u0007\u0007\u0000\u0000\u1da0\u1da1"+ + "\u0007\u0019\u0000\u0000\u1da1\u1da2\u0007\u0005\u0000\u0000\u1da2\u1da3"+ + "\u0007\u000f\u0000\u0000\u1da3\u1da4\u0007\u000e\u0000\u0000\u1da4\u1da5"+ + "\u0007\u0003\u0000\u0000\u1da5\u1da6\u0007\u0006\u0000\u0000\u1da6\u1da7"+ + "\u0007\u0007\u0000\u0000\u1da7\u1da8\u0005_\u0000\u0000\u1da8\u1da9\u0007"+ + "\u000f\u0000\u0000\u1da9\u1daa\u0007\u0016\u0000\u0000\u1daa\u1dab\u0007"+ + "\f\u0000\u0000\u1dab\u1dac\u0007\u0013\u0000\u0000\u1dac\u1dad\u0007\b"+ + "\u0000\u0000\u1dad\u1dae\u0007\u0007\u0000\u0000\u1dae\u1daf\u0005_\u0000"+ + "\u0000\u1daf\u1db0\u0007\u0004\u0000\u0000\u1db0\u1db1\u0007\u0010\u0000"+ + "\u0000\u1db1\u0490\u0001\u0000\u0000\u0000\u1db2\u1db3\u0007\b\u0000\u0000"+ + "\u1db3\u1db4\u0007\u0007\u0000\u0000\u1db4\u1db5\u0007\u0019\u0000\u0000"+ + "\u1db5\u1db6\u0007\u0005\u0000\u0000\u1db6\u1db7\u0007\u000f\u0000\u0000"+ + "\u1db7\u1db8\u0007\u000e\u0000\u0000\u1db8\u1db9\u0007\u0003\u0000\u0000"+ + "\u1db9\u1dba\u0007\u0006\u0000\u0000\u1dba\u1dbb\u0007\u0007\u0000\u0000"+ + "\u1dbb\u1dbc\u0005_\u0000\u0000\u1dbc\u1dbd\u0007\u000f\u0000\u0000\u1dbd"+ + "\u1dbe\u0007\u0016\u0000\u0000\u1dbe\u1dbf\u0007\f\u0000\u0000\u1dbf\u1dc0"+ + "\u0007\u0013\u0000\u0000\u1dc0\u1dc1\u0007\b\u0000\u0000\u1dc1\u1dc2\u0007"+ + "\u0007\u0000\u0000\u1dc2\u1dc3\u0005_\u0000\u0000\u1dc3\u1dc4\u0007\u0006"+ + "\u0000\u0000\u1dc4\u1dc5\u0007\u0003\u0000\u0000\u1dc5\u1dc6\u0007\u0010"+ + "\u0000\u0000\u1dc6\u1dc7\u0007\u0005\u0000\u0000\u1dc7\u1dc8\u0007\u0007"+ + "\u0000\u0000\u1dc8\u0492\u0001\u0000\u0000\u0000\u1dc9\u1dca\u0007\b\u0000"+ + "\u0000\u1dca\u1dcb\u0007\u0007\u0000\u0000\u1dcb\u1dcc\u0007\u0019\u0000"+ + "\u0000\u1dcc\u1dcd\u0007\u0005\u0000\u0000\u1dcd\u1dce\u0007\u000f\u0000"+ + "\u0000\u1dce\u1dcf\u0007\u000e\u0000\u0000\u1dcf\u1dd0\u0007\u0003\u0000"+ + "\u0000\u1dd0\u1dd1\u0007\u0006\u0000\u0000\u1dd1\u1dd2\u0007\u0007\u0000"+ + "\u0000\u1dd2\u1dd3\u0005_\u0000\u0000\u1dd3\u1dd4\u0007\b\u0000\u0000"+ + "\u1dd4\u1dd5\u0007\u0007\u0000\u0000\u1dd5\u1dd6\u0007\t\u0000\u0000\u1dd6"+ + "\u1dd7\u0007\b\u0000\u0000\u1dd7\u1dd8\u0007\u000f\u0000\u0000\u1dd8\u1dd9"+ + "\u0007\u0006\u0000\u0000\u1dd9\u1dda\u0007\u0007\u0000\u0000\u1dda\u1ddb"+ + "\u0005_\u0000\u0000\u1ddb\u1ddc\u0007\u0004\u0000\u0000\u1ddc\u1ddd\u0007"+ + "\u0010\u0000\u0000\u1ddd\u0494\u0001\u0000\u0000\u0000\u1dde\u1ddf\u0007"+ + "\b\u0000\u0000\u1ddf\u1de0\u0007\u0007\u0000\u0000\u1de0\u1de1\u0007\u0019"+ + "\u0000\u0000\u1de1\u1de2\u0007\u0005\u0000\u0000\u1de2\u1de3\u0007\u000f"+ + "\u0000\u0000\u1de3\u1de4\u0007\u000e\u0000\u0000\u1de4\u1de5\u0007\u0003"+ + "\u0000\u0000\u1de5\u1de6\u0007\u0006\u0000\u0000\u1de6\u1de7\u0007\u0007"+ + "\u0000\u0000\u1de7\u1de8\u0005_\u0000\u0000\u1de8\u1de9\u0007\t\u0000"+ + "\u0000\u1de9\u1dea\u0007\u000f\u0000\u0000\u1dea\u1deb\u0007\u0005\u0000"+ + "\u0000\u1deb\u1dec\u0007\u0004\u0000\u0000\u1dec\u1ded\u0005_\u0000\u0000"+ + "\u1ded\u1dee\u0007\u0004\u0000\u0000\u1dee\u1def\u0007\u0013\u0000\u0000"+ + "\u1def\u1df0\u0005_\u0000\u0000\u1df0\u1df1\u0007\u0006\u0000\u0000\u1df1"+ + "\u1df2\u0007\u0003\u0000\u0000\u1df2\u1df3\u0007\u0010\u0000\u0000\u1df3"+ + "\u1df4\u0007\u0005\u0000\u0000\u1df4\u1df5\u0007\u0007\u0000\u0000\u1df5"+ + "\u0496\u0001\u0000\u0000\u0000\u1df6\u1df7\u0007\b\u0000\u0000\u1df7\u1df8"+ + "\u0007\u0007\u0000\u0000\u1df8\u1df9\u0007\u0019\u0000\u0000\u1df9\u1dfa"+ + "\u0007\u0005\u0000\u0000\u1dfa\u1dfb\u0007\u000f\u0000\u0000\u1dfb\u1dfc"+ + "\u0007\u000e\u0000\u0000\u1dfc\u1dfd\u0007\u0003\u0000\u0000\u1dfd\u1dfe"+ + "\u0007\u0006\u0000\u0000\u1dfe\u1dff\u0007\u0007\u0000\u0000\u1dff\u1e00"+ + "\u0005_\u0000\u0000\u1e00\u1e01\u0007\t\u0000\u0000\u1e01\u1e02\u0007"+ + "\u000f\u0000\u0000\u1e02\u1e03\u0007\u0005\u0000\u0000\u1e03\u1e04\u0007"+ + "\u0004\u0000\u0000\u1e04\u1e05\u0005_\u0000\u0000\u1e05\u1e06\u0007\u000f"+ + "\u0000\u0000\u1e06\u1e07\u0007\u0016\u0000\u0000\u1e07\u1e08\u0007\f\u0000"+ + "\u0000\u1e08\u1e09\u0007\u0013\u0000\u0000\u1e09\u1e0a\u0007\b\u0000\u0000"+ + "\u1e0a\u1e0b\u0007\u0007\u0000\u0000\u1e0b\u1e0c\u0005_\u0000\u0000\u1e0c"+ + "\u1e0d\u0007\u0006\u0000\u0000\u1e0d\u1e0e\u0007\u0003\u0000\u0000\u1e0e"+ + "\u1e0f\u0007\u0010\u0000\u0000\u1e0f\u1e10\u0007\u0005\u0000\u0000\u1e10"+ + "\u1e11\u0007\u0007\u0000\u0000\u1e11\u0498\u0001\u0000\u0000\u0000\u1e12"+ + "\u1e13\u0007\b\u0000\u0000\u1e13\u1e14\u0007\u0007\u0000\u0000\u1e14\u1e15"+ + "\u0007\u0019\u0000\u0000\u1e15\u1e16\u0007\u0005\u0000\u0000\u1e16\u1e17"+ + "\u0007\u000f\u0000\u0000\u1e17\u1e18\u0007\u000e\u0000\u0000\u1e18\u1e19"+ + "\u0007\u0003\u0000\u0000\u1e19\u1e1a\u0007\u0006\u0000\u0000\u1e1a\u1e1b"+ + "\u0007\u000f\u0000\u0000\u1e1b\u1e1c\u0007\u0013\u0000\u0000\u1e1c\u1e1d"+ + "\u0007\f\u0000\u0000\u1e1d\u049a\u0001\u0000\u0000\u0000\u1e1e\u1e1f\u0007"+ + "\b\u0000\u0000\u1e1f\u1e20\u0007\u0007\u0000\u0000\u1e20\u1e21\u0007\u000b"+ + "\u0000\u0000\u1e21\u1e22\u0007\u0007\u0000\u0000\u1e22\u1e23\u0007\u0006"+ + "\u0000\u0000\u1e23\u049c\u0001\u0000\u0000\u0000\u1e24\u1e25\u0007\b\u0000"+ + "\u0000\u1e25\u1e26\u0007\u0007\u0000\u0000\u1e26\u1e27\u0007\u000b\u0000"+ + "\u0000\u1e27\u1e28\u0007\u0006\u0000\u0000\u1e28\u1e29\u0007\u0003\u0000"+ + "\u0000\u1e29\u1e2a\u0007\b\u0000\u0000\u1e2a\u1e2b\u0007\u0006\u0000\u0000"+ + "\u1e2b\u049e\u0001\u0000\u0000\u0000\u1e2c\u1e2d\u0007\b\u0000\u0000\u1e2d"+ + "\u1e2e\u0007\u0007\u0000\u0000\u1e2e\u1e2f\u0007\u000b\u0000\u0000\u1e2f"+ + "\u1e30\u0007\u0011\u0000\u0000\u1e30\u1e31\u0007\u0017\u0000\u0000\u1e31"+ + "\u1e32\u0007\u0007\u0000\u0000\u1e32\u04a0\u0001\u0000\u0000\u0000\u1e33"+ + "\u1e34\u0007\b\u0000\u0000\u1e34\u1e35\u0007\u0007\u0000\u0000\u1e35\u1e36"+ + "\u0007\u0006\u0000\u0000\u1e36\u1e37\u0007\u0011\u0000\u0000\u1e37\u1e38"+ + "\u0007\b\u0000\u0000\u1e38\u1e39\u0007\f\u0000\u0000\u1e39\u1e3a\u0007"+ + "\u0007\u0000\u0000\u1e3a\u1e3b\u0007\u0004\u0000\u0000\u1e3b\u1e3c\u0005"+ + "_\u0000\u0000\u1e3c\u1e3d\u0007\u000b\u0000\u0000\u1e3d\u1e3e\u0007\u001c"+ + "\u0000\u0000\u1e3e\u1e3f\u0007\u0005\u0000\u0000\u1e3f\u1e40\u0007\u000b"+ + "\u0000\u0000\u1e40\u1e41\u0007\u0006\u0000\u0000\u1e41\u1e42\u0007\u0003"+ + "\u0000\u0000\u1e42\u1e43\u0007\u0006\u0000\u0000\u1e43\u1e44\u0007\u0007"+ + "\u0000\u0000\u1e44\u04a2\u0001\u0000\u0000\u0000\u1e45\u1e46\u0007\b\u0000"+ + "\u0000\u1e46\u1e47\u0007\u0007\u0000\u0000\u1e47\u1e48\u0007\u0006\u0000"+ + "\u0000\u1e48\u1e49\u0007\u0011\u0000\u0000\u1e49\u1e4a\u0007\b\u0000\u0000"+ + "\u1e4a\u1e4b\u0007\f\u0000\u0000\u1e4b\u1e4c\u0007\u000f\u0000\u0000\u1e4c"+ + "\u1e4d\u0007\f\u0000\u0000\u1e4d\u1e4e\u0007\u0016\u0000\u0000\u1e4e\u04a4"+ + "\u0001\u0000\u0000\u0000\u1e4f\u1e50\u0007\b\u0000\u0000\u1e50\u1e51\u0007"+ + "\u0007\u0000\u0000\u1e51\u1e52\u0007\u0006\u0000\u0000\u1e52\u1e53\u0007"+ + "\u0011\u0000\u0000\u1e53\u1e54\u0007\b\u0000\u0000\u1e54\u1e55\u0007\f"+ + "\u0000\u0000\u1e55\u1e56\u0007\u000b\u0000\u0000\u1e56\u04a6\u0001\u0000"+ + "\u0000\u0000\u1e57\u1e58\u0007\b\u0000\u0000\u1e58\u1e59\u0007\u0007\u0000"+ + "\u0000\u1e59\u1e5a\u0007\u0011\u0000\u0000\u1e5a\u1e5b\u0007\u000b\u0000"+ + "\u0000\u1e5b\u1e5c\u0007\u0007\u0000\u0000\u1e5c\u04a8\u0001\u0000\u0000"+ + "\u0000\u1e5d\u1e5e\u0007\b\u0000\u0000\u1e5e\u1e5f\u0007\u0013\u0000\u0000"+ + "\u1e5f\u1e60\u0007\u0005\u0000\u0000\u1e60\u1e61\u0007\u0007\u0000\u0000"+ + "\u1e61\u04aa\u0001\u0000\u0000\u0000\u1e62\u1e63\u0007\b\u0000\u0000\u1e63"+ + "\u1e64\u0007\u0013\u0000\u0000\u1e64\u1e65\u0007\u0005\u0000\u0000\u1e65"+ + "\u1e66\u0007\u0005\u0000\u0000\u1e66\u1e67\u0007\u0010\u0000\u0000\u1e67"+ + "\u1e68\u0007\u0003\u0000\u0000\u1e68\u1e69\u0007\u000e\u0000\u0000\u1e69"+ + "\u1e6a\u0007\u0015\u0000\u0000\u1e6a\u04ac\u0001\u0000\u0000\u0000\u1e6b"+ + "\u1e6c\u0007\b\u0000\u0000\u1e6c\u1e6d\u0007\u0013\u0000\u0000\u1e6d\u1e6e"+ + "\u0007\u0005\u0000\u0000\u1e6e\u1e6f\u0007\u0005\u0000\u0000\u1e6f\u1e70"+ + "\u0007\u0011\u0000\u0000\u1e70\u1e71\u0007\u0019\u0000\u0000\u1e71\u04ae"+ + "\u0001\u0000\u0000\u0000\u1e72\u1e73\u0007\b\u0000\u0000\u1e73\u1e74\u0007"+ + "\u0013\u0000\u0000\u1e74\u1e75\u0007\u0006\u0000\u0000\u1e75\u1e76\u0007"+ + "\u0003\u0000\u0000\u1e76\u1e77\u0007\u0006\u0000\u0000\u1e77\u1e78\u0007"+ + "\u0007\u0000\u0000\u1e78\u04b0\u0001\u0000\u0000\u0000\u1e79\u1e7a\u0007"+ + "\b\u0000\u0000\u1e7a\u1e7b\u0007\u0013\u0000\u0000\u1e7b\u1e7c\u0007\t"+ + "\u0000\u0000\u1e7c\u04b2\u0001\u0000\u0000\u0000\u1e7d\u1e7e\u0007\b\u0000"+ + "\u0000\u1e7e\u1e7f\u0007\u0013\u0000\u0000\u1e7f\u1e80\u0007\t\u0000\u0000"+ + "\u1e80\u1e81\u0007\u000b\u0000\u0000\u1e81\u04b4\u0001\u0000\u0000\u0000"+ + "\u1e82\u1e83\u0007\b\u0000\u0000\u1e83\u1e84\u0007\u0013\u0000\u0000\u1e84"+ + "\u1e85\u0007\t\u0000\u0000\u1e85\u1e86\u0005_\u0000\u0000\u1e86\u1e87"+ + "\u0007\u0012\u0000\u0000\u1e87\u1e88\u0007\u0013\u0000\u0000\u1e88\u1e89"+ + "\u0007\b\u0000\u0000\u1e89\u1e8a\u0007\u0017\u0000\u0000\u1e8a\u1e8b\u0007"+ + "\u0003\u0000\u0000\u1e8b\u1e8c\u0007\u0006\u0000\u0000\u1e8c\u04b6\u0001"+ + "\u0000\u0000\u0000\u1e8d\u1e8e\u0007\b\u0000\u0000\u1e8e\u1e8f\u0007\u0006"+ + "\u0000\u0000\u1e8f\u1e90\u0007\b\u0000\u0000\u1e90\u1e91\u0007\u0007\u0000"+ + "\u0000\u1e91\u1e92\u0007\u0007\u0000\u0000\u1e92\u04b8\u0001\u0000\u0000"+ + "\u0000\u1e93\u1e94\u0007\u000b\u0000\u0000\u1e94\u1e95\u0007\u0003\u0000"+ + "\u0000\u1e95\u1e96\u0007\u0018\u0000\u0000\u1e96\u1e97\u0007\u0007\u0000"+ + "\u0000\u1e97\u1e98\u0007\u0019\u0000\u0000\u1e98\u1e99\u0007\u0013\u0000"+ + "\u0000\u1e99\u1e9a\u0007\u000f\u0000\u0000\u1e9a\u1e9b\u0007\f\u0000\u0000"+ + "\u1e9b\u1e9c\u0007\u0006\u0000\u0000\u1e9c\u04ba\u0001\u0000\u0000\u0000"+ + "\u1e9d\u1e9e\u0007\u000b\u0000\u0000\u1e9e\u1e9f\u0007\u000e\u0000\u0000"+ + "\u1e9f\u1ea0\u0007\u0014\u0000\u0000\u1ea0\u1ea1\u0007\u0007\u0000\u0000"+ + "\u1ea1\u1ea2\u0007\u0004\u0000\u0000\u1ea2\u1ea3\u0007\u0011\u0000\u0000"+ + "\u1ea3\u1ea4\u0007\u0005\u0000\u0000\u1ea4\u1ea5\u0007\u0007\u0000\u0000"+ + "\u1ea5\u04bc\u0001\u0000\u0000\u0000\u1ea6\u1ea7\u0007\u000b\u0000\u0000"+ + "\u1ea7\u1ea8\u0007\u0007\u0000\u0000\u1ea8\u1ea9\u0007\u000e\u0000\u0000"+ + "\u1ea9\u1eaa\u0007\u0011\u0000\u0000\u1eaa\u1eab\u0007\b\u0000\u0000\u1eab"+ + "\u1eac\u0007\u000f\u0000\u0000\u1eac\u1ead\u0007\u0006\u0000\u0000\u1ead"+ + "\u1eae\u0007\n\u0000\u0000\u1eae\u04be\u0001\u0000\u0000\u0000\u1eaf\u1eb0"+ + "\u0007\u000b\u0000\u0000\u1eb0\u1eb1\u0007\u0007\u0000\u0000\u1eb1\u1eb2"+ + "\u0007\u001c\u0000\u0000\u1eb2\u1eb3\u0007\u0011\u0000\u0000\u1eb3\u1eb4"+ + "\u0007\u0007\u0000\u0000\u1eb4\u1eb5\u0007\f\u0000\u0000\u1eb5\u1eb6\u0007"+ + "\u000e\u0000\u0000\u1eb6\u1eb7\u0007\u0007\u0000\u0000\u1eb7\u04c0\u0001"+ + "\u0000\u0000\u0000\u1eb8\u1eb9\u0007\u000b\u0000\u0000\u1eb9\u1eba\u0007"+ + "\u0007\u0000\u0000\u1eba\u1ebb\u0007\b\u0000\u0000\u1ebb\u1ebc\u0007\u0018"+ + "\u0000\u0000\u1ebc\u1ebd\u0007\u0007\u0000\u0000\u1ebd\u1ebe\u0007\b\u0000"+ + "\u0000\u1ebe\u04c2\u0001\u0000\u0000\u0000\u1ebf\u1ec0\u0007\u000b\u0000"+ + "\u0000\u1ec0\u1ec1\u0007\u0007\u0000\u0000\u1ec1\u1ec2\u0007\u000b\u0000"+ + "\u0000\u1ec2\u1ec3\u0007\u000b\u0000\u0000\u1ec3\u1ec4\u0007\u000f\u0000"+ + "\u0000\u1ec4\u1ec5\u0007\u0013\u0000\u0000\u1ec5\u1ec6\u0007\f\u0000\u0000"+ + "\u1ec6\u04c4\u0001\u0000\u0000\u0000\u1ec7\u1ec8\u0007\u000b\u0000\u0000"+ + "\u1ec8\u1ec9\u0007\u0014\u0000\u0000\u1ec9\u1eca\u0007\u0003\u0000\u0000"+ + "\u1eca\u1ecb\u0007\b\u0000\u0000\u1ecb\u1ecc\u0007\u0007\u0000\u0000\u1ecc"+ + "\u04c6\u0001\u0000\u0000\u0000\u1ecd\u1ece\u0007\u000b\u0000\u0000\u1ece"+ + "\u1ecf\u0007\u0014\u0000\u0000\u1ecf\u1ed0\u0007\u0003\u0000\u0000\u1ed0"+ + "\u1ed1\u0007\b\u0000\u0000\u1ed1\u1ed2\u0007\u0007\u0000\u0000\u1ed2\u1ed3"+ + "\u0007\u0004\u0000\u0000\u1ed3\u04c8\u0001\u0000\u0000\u0000\u1ed4\u1ed5"+ + "\u0007\u000b\u0000\u0000\u1ed5\u1ed6\u0007\u000f\u0000\u0000\u1ed6\u1ed7"+ + "\u0007\u0016\u0000\u0000\u1ed7\u1ed8\u0007\f\u0000\u0000\u1ed8\u1ed9\u0007"+ + "\u0007\u0000\u0000\u1ed9\u1eda\u0007\u0004\u0000\u0000\u1eda\u04ca\u0001"+ + "\u0000\u0000\u0000\u1edb\u1edc\u0007\u000b\u0000\u0000\u1edc\u1edd\u0007"+ + "\u000f\u0000\u0000\u1edd\u1ede\u0007\u0017\u0000\u0000\u1ede\u1edf\u0007"+ + "\u0019\u0000\u0000\u1edf\u1ee0\u0007\u0005\u0000\u0000\u1ee0\u1ee1\u0007"+ + "\u0007\u0000\u0000\u1ee1\u04cc\u0001\u0000\u0000\u0000\u1ee2\u1ee3\u0007"+ + "\u000b\u0000\u0000\u1ee3\u1ee4\u0007\u0005\u0000\u0000\u1ee4\u1ee5\u0007"+ + "\u0003\u0000\u0000\u1ee5\u1ee6\u0007\u0018\u0000\u0000\u1ee6\u1ee7\u0007"+ + "\u0007\u0000\u0000\u1ee7\u04ce\u0001\u0000\u0000\u0000\u1ee8\u1ee9\u0007"+ + "\u000b\u0000\u0000\u1ee9\u1eea\u0007\u0005\u0000\u0000\u1eea\u1eeb\u0007"+ + "\u0013\u0000\u0000\u1eeb\u1eec\u0007\t\u0000\u0000\u1eec\u04d0\u0001\u0000"+ + "\u0000\u0000\u1eed\u1eee\u0007\u000b\u0000\u0000\u1eee\u1eef\u0007\f\u0000"+ + "\u0000\u1eef\u1ef0\u0007\u0003\u0000\u0000\u1ef0\u1ef1\u0007\u0019\u0000"+ + "\u0000\u1ef1\u1ef2\u0007\u000b\u0000\u0000\u1ef2\u1ef3\u0007\u0014\u0000"+ + "\u0000\u1ef3\u1ef4\u0007\u0013\u0000\u0000\u1ef4\u1ef5\u0007\u0006\u0000"+ + "\u0000\u1ef5\u04d2\u0001\u0000\u0000\u0000\u1ef6\u1ef7\u0007\u000b\u0000"+ + "\u0000\u1ef7\u1ef8\u0007\u0013\u0000\u0000\u1ef8\u1ef9\u0007\u000e\u0000"+ + "\u0000\u1ef9\u1efa\u0007\u0015\u0000\u0000\u1efa\u1efb\u0007\u0007\u0000"+ + "\u0000\u1efb\u1efc\u0007\u0006\u0000\u0000\u1efc\u04d4\u0001\u0000\u0000"+ + "\u0000\u1efd\u1efe\u0007\u000b\u0000\u0000\u1efe\u1eff\u0007\u0013\u0000"+ + "\u0000\u1eff\u1f00\u0007\u0017\u0000\u0000\u1f00\u1f01\u0007\u0007\u0000"+ + "\u0000\u1f01\u04d6\u0001\u0000\u0000\u0000\u1f02\u1f03\u0007\u000b\u0000"+ + "\u0000\u1f03\u1f04\u0007\u0013\u0000\u0000\u1f04\u1f05\u0007\f\u0000\u0000"+ + "\u1f05\u1f06\u0007\u0003\u0000\u0000\u1f06\u1f07\u0007\u0017\u0000\u0000"+ + "\u1f07\u1f08\u0007\u0007\u0000\u0000\u1f08\u04d8\u0001\u0000\u0000\u0000"+ + "\u1f09\u1f0a\u0007\u000b\u0000\u0000\u1f0a\u1f0b\u0007\u0013\u0000\u0000"+ + "\u1f0b\u1f0c\u0007\u0011\u0000\u0000\u1f0c\u1f0d\u0007\f\u0000\u0000\u1f0d"+ + "\u1f0e\u0007\u0004\u0000\u0000\u1f0e\u1f0f\u0007\u000b\u0000\u0000\u1f0f"+ + "\u04da\u0001\u0000\u0000\u0000\u1f10\u1f11\u0007\u000b\u0000\u0000\u1f11"+ + "\u1f12\u0007\u0013\u0000\u0000\u1f12\u1f13\u0007\u0011\u0000\u0000\u1f13"+ + "\u1f14\u0007\b\u0000\u0000\u1f14\u1f15\u0007\u000e\u0000\u0000\u1f15\u1f16"+ + "\u0007\u0007\u0000\u0000\u1f16\u04dc\u0001\u0000\u0000\u0000\u1f17\u1f18"+ + "\u0007\u000b\u0000\u0000\u1f18\u1f19\u0007\u001c\u0000\u0000\u1f19\u1f1a"+ + "\u0007\u0005\u0000\u0000\u1f1a\u1f1b\u0005_\u0000\u0000\u1f1b\u1f1c\u0007"+ + "\u0003\u0000\u0000\u1f1c\u1f1d\u0007\u0012\u0000\u0000\u1f1d\u1f1e\u0007"+ + "\u0006\u0000\u0000\u1f1e\u1f1f\u0007\u0007\u0000\u0000\u1f1f\u1f20\u0007"+ + "\b\u0000\u0000\u1f20\u1f21\u0005_\u0000\u0000\u1f21\u1f22\u0007\u0016"+ + "\u0000\u0000\u1f22\u1f23\u0007\u0006\u0000\u0000\u1f23\u1f24\u0007\u000f"+ + "\u0000\u0000\u1f24\u1f25\u0007\u0004\u0000\u0000\u1f25\u1f26\u0007\u000b"+ + "\u0000\u0000\u1f26\u04de\u0001\u0000\u0000\u0000\u1f27\u1f28\u0007\u000b"+ + "\u0000\u0000\u1f28\u1f29\u0007\u001c\u0000\u0000\u1f29\u1f2a\u0007\u0005"+ + "\u0000\u0000\u1f2a\u1f2b\u0005_\u0000\u0000\u1f2b\u1f2c\u0007\u0003\u0000"+ + "\u0000\u1f2c\u1f2d\u0007\u0012\u0000\u0000\u1f2d\u1f2e\u0007\u0006\u0000"+ + "\u0000\u1f2e\u1f2f\u0007\u0007\u0000\u0000\u1f2f\u1f30\u0007\b\u0000\u0000"+ + "\u1f30\u1f31\u0005_\u0000\u0000\u1f31\u1f32\u0007\u0017\u0000\u0000\u1f32"+ + "\u1f33\u0007\u0006\u0000\u0000\u1f33\u1f34\u0007\u000b\u0000\u0000\u1f34"+ + "\u1f35\u0005_\u0000\u0000\u1f35\u1f36\u0007\u0016\u0000\u0000\u1f36\u1f37"+ + "\u0007\u0003\u0000\u0000\u1f37\u1f38\u0007\u0019\u0000\u0000\u1f38\u1f39"+ + "\u0007\u000b\u0000\u0000\u1f39\u04e0\u0001\u0000\u0000\u0000\u1f3a\u1f3b"+ + "\u0007\u000b\u0000\u0000\u1f3b\u1f3c\u0007\u001c\u0000\u0000\u1f3c\u1f3d"+ + "\u0007\u0005\u0000\u0000\u1f3d\u1f3e\u0005_\u0000\u0000\u1f3e\u1f3f\u0007"+ + "\u0010\u0000\u0000\u1f3f\u1f40\u0007\u0007\u0000\u0000\u1f40\u1f41\u0007"+ + "\u0012\u0000\u0000\u1f41\u1f42\u0007\u0013\u0000\u0000\u1f42\u1f43\u0007"+ + "\b\u0000\u0000\u1f43\u1f44\u0007\u0007\u0000\u0000\u1f44\u1f45\u0005_"+ + "\u0000\u0000\u1f45\u1f46\u0007\u0016\u0000\u0000\u1f46\u1f47\u0007\u0006"+ + "\u0000\u0000\u1f47\u1f48\u0007\u000f\u0000\u0000\u1f48\u1f49\u0007\u0004"+ + "\u0000\u0000\u1f49\u1f4a\u0007\u000b\u0000\u0000\u1f4a\u04e2\u0001\u0000"+ + "\u0000\u0000\u1f4b\u1f4c\u0007\u000b\u0000\u0000\u1f4c\u1f4d\u0007\u001c"+ + "\u0000\u0000\u1f4d\u1f4e\u0007\u0005\u0000\u0000\u1f4e\u1f4f\u0005_\u0000"+ + "\u0000\u1f4f\u1f50\u0007\u0010\u0000\u0000\u1f50\u1f51\u0007\u0011\u0000"+ + "\u0000\u1f51\u1f52\u0007\u0012\u0000\u0000\u1f52\u1f53\u0007\u0012\u0000"+ + "\u0000\u1f53\u1f54\u0007\u0007\u0000\u0000\u1f54\u1f55\u0007\b\u0000\u0000"+ + "\u1f55\u1f56\u0005_\u0000\u0000\u1f56\u1f57\u0007\b\u0000\u0000\u1f57"+ + "\u1f58\u0007\u0007\u0000\u0000\u1f58\u1f59\u0007\u000b\u0000\u0000\u1f59"+ + "\u1f5a\u0007\u0011\u0000\u0000\u1f5a\u1f5b\u0007\u0005\u0000\u0000\u1f5b"+ + "\u1f5c\u0007\u0006\u0000\u0000\u1f5c\u04e4\u0001\u0000\u0000\u0000\u1f5d"+ + "\u1f5e\u0007\u000b\u0000\u0000\u1f5e\u1f5f\u0007\u001c\u0000\u0000\u1f5f"+ + "\u1f60\u0007\u0005\u0000\u0000\u1f60\u1f61\u0005_\u0000\u0000\u1f61\u1f62"+ + "\u0007\u000e\u0000\u0000\u1f62\u1f63\u0007\u0003\u0000\u0000\u1f63\u1f64"+ + "\u0007\u000e\u0000\u0000\u1f64\u1f65\u0007\u0014\u0000\u0000\u1f65\u1f66"+ + "\u0007\u0007\u0000\u0000\u1f66\u04e6\u0001\u0000\u0000\u0000\u1f67\u1f68"+ + "\u0007\u000b\u0000\u0000\u1f68\u1f69\u0007\u001c\u0000\u0000\u1f69\u1f6a"+ + "\u0007\u0005\u0000\u0000\u1f6a\u1f6b\u0005_\u0000\u0000\u1f6b\u1f6c\u0007"+ + "\f\u0000\u0000\u1f6c\u1f6d\u0007\u0013\u0000\u0000\u1f6d\u1f6e\u0005_"+ + "\u0000\u0000\u1f6e\u1f6f\u0007\u000e\u0000\u0000\u1f6f\u1f70\u0007\u0003"+ + "\u0000\u0000\u1f70\u1f71\u0007\u000e\u0000\u0000\u1f71\u1f72\u0007\u0014"+ + "\u0000\u0000\u1f72\u1f73\u0007\u0007\u0000\u0000\u1f73\u04e8\u0001\u0000"+ + "\u0000\u0000\u1f74\u1f75\u0007\u000b\u0000\u0000\u1f75\u1f76\u0007\u001c"+ + "\u0000\u0000\u1f76\u1f77\u0007\u0005\u0000\u0000\u1f77\u1f78\u0005_\u0000"+ + "\u0000\u1f78\u1f79\u0007\u0006\u0000\u0000\u1f79\u1f7a\u0007\u0014\u0000"+ + "\u0000\u1f7a\u1f7b\u0007\b\u0000\u0000\u1f7b\u1f7c\u0007\u0007\u0000\u0000"+ + "\u1f7c\u1f7d\u0007\u0003\u0000\u0000\u1f7d\u1f7e\u0007\u0004\u0000\u0000"+ + "\u1f7e\u04ea\u0001\u0000\u0000\u0000\u1f7f\u1f80\u0007\u000b\u0000\u0000"+ + "\u1f80\u1f81\u0007\u0006\u0000\u0000\u1f81\u1f82\u0007\u0003\u0000\u0000"+ + "\u1f82\u1f83\u0007\b\u0000\u0000\u1f83\u1f84\u0007\u0006\u0000\u0000\u1f84"+ + "\u04ec\u0001\u0000\u0000\u0000\u1f85\u1f86\u0007\u000b\u0000\u0000\u1f86"+ + "\u1f87\u0007\u0006\u0000\u0000\u1f87\u1f88\u0007\u0003\u0000\u0000\u1f88"+ + "\u1f89\u0007\b\u0000\u0000\u1f89\u1f8a\u0007\u0006\u0000\u0000\u1f8a\u1f8b"+ + "\u0007\u000b\u0000\u0000\u1f8b\u04ee\u0001\u0000\u0000\u0000\u1f8c\u1f8d"+ + "\u0007\u000b\u0000\u0000\u1f8d\u1f8e\u0007\u0006\u0000\u0000\u1f8e\u1f8f"+ + "\u0007\u0003\u0000\u0000\u1f8f\u1f90\u0007\u0006\u0000\u0000\u1f90\u1f91"+ + "\u0007\u000b\u0000\u0000\u1f91\u1f92\u0005_\u0000\u0000\u1f92\u1f93\u0007"+ + "\u0003\u0000\u0000\u1f93\u1f94\u0007\u0011\u0000\u0000\u1f94\u1f95\u0007"+ + "\u0006\u0000\u0000\u1f95\u1f96\u0007\u0013\u0000\u0000\u1f96\u1f97\u0005"+ + "_\u0000\u0000\u1f97\u1f98\u0007\b\u0000\u0000\u1f98\u1f99\u0007\u0007"+ + "\u0000\u0000\u1f99\u1f9a\u0007\u000e\u0000\u0000\u1f9a\u1f9b\u0007\u0003"+ + "\u0000\u0000\u1f9b\u1f9c\u0007\u0005\u0000\u0000\u1f9c\u1f9d\u0007\u000e"+ + "\u0000\u0000\u1f9d\u04f0\u0001\u0000\u0000\u0000\u1f9e\u1f9f\u0007\u000b"+ + "\u0000\u0000\u1f9f\u1fa0\u0007\u0006\u0000\u0000\u1fa0\u1fa1\u0007\u0003"+ + "\u0000\u0000\u1fa1\u1fa2\u0007\u0006\u0000\u0000\u1fa2\u1fa3\u0007\u000b"+ + "\u0000\u0000\u1fa3\u1fa4\u0005_\u0000\u0000\u1fa4\u1fa5\u0007\u0019\u0000"+ + "\u0000\u1fa5\u1fa6\u0007\u0007\u0000\u0000\u1fa6\u1fa7\u0007\b\u0000\u0000"+ + "\u1fa7\u1fa8\u0007\u000b\u0000\u0000\u1fa8\u1fa9\u0007\u000f\u0000\u0000"+ + "\u1fa9\u1faa\u0007\u000b\u0000\u0000\u1faa\u1fab\u0007\u0006\u0000\u0000"+ + "\u1fab\u1fac\u0007\u0007\u0000\u0000\u1fac\u1fad\u0007\f\u0000\u0000\u1fad"+ + "\u1fae\u0007\u0006\u0000\u0000\u1fae\u04f2\u0001\u0000\u0000\u0000\u1faf"+ + "\u1fb0\u0007\u000b\u0000\u0000\u1fb0\u1fb1\u0007\u0006\u0000\u0000\u1fb1"+ + "\u1fb2\u0007\u0003\u0000\u0000\u1fb2\u1fb3\u0007\u0006\u0000\u0000\u1fb3"+ + "\u1fb4\u0007\u000b\u0000\u0000\u1fb4\u1fb5\u0005_\u0000\u0000\u1fb5\u1fb6"+ + "\u0007\u000b\u0000\u0000\u1fb6\u1fb7\u0007\u0003\u0000\u0000\u1fb7\u1fb8"+ + "\u0007\u0017\u0000\u0000\u1fb8\u1fb9\u0007\u0019\u0000\u0000\u1fb9\u1fba"+ + "\u0007\u0005\u0000\u0000\u1fba\u1fbb\u0007\u0007\u0000\u0000\u1fbb\u1fbc"+ + "\u0005_\u0000\u0000\u1fbc\u1fbd\u0007\u0019\u0000\u0000\u1fbd\u1fbe\u0007"+ + "\u0003\u0000\u0000\u1fbe\u1fbf\u0007\u0016\u0000\u0000\u1fbf\u1fc0\u0007"+ + "\u0007\u0000\u0000\u1fc0\u1fc1\u0007\u000b\u0000\u0000\u1fc1\u04f4\u0001"+ + "\u0000\u0000\u0000\u1fc2\u1fc3\u0007\u000b\u0000\u0000\u1fc3\u1fc4\u0007"+ + "\u0006\u0000\u0000\u1fc4\u1fc5\u0007\u0003\u0000\u0000\u1fc5\u1fc6\u0007"+ + "\u0006\u0000\u0000\u1fc6\u1fc7\u0007\u0011\u0000\u0000\u1fc7\u1fc8\u0007"+ + "\u000b\u0000\u0000\u1fc8\u04f6\u0001\u0000\u0000\u0000\u1fc9\u1fca\u0007"+ + "\u000b\u0000\u0000\u1fca\u1fcb\u0007\u0006\u0000\u0000\u1fcb\u1fcc\u0007"+ + "\u0013\u0000\u0000\u1fcc\u1fcd\u0007\u0019\u0000\u0000\u1fcd\u04f8\u0001"+ + "\u0000\u0000\u0000\u1fce\u1fcf\u0007\u000b\u0000\u0000\u1fcf\u1fd0\u0007"+ + "\u0006\u0000\u0000\u1fd0\u1fd1\u0007\u0013\u0000\u0000\u1fd1\u1fd2\u0007"+ + "\b\u0000\u0000\u1fd2\u1fd3\u0007\u0003\u0000\u0000\u1fd3\u1fd4\u0007\u0016"+ + "\u0000\u0000\u1fd4\u1fd5\u0007\u0007\u0000\u0000\u1fd5\u04fa\u0001\u0000"+ + "\u0000\u0000\u1fd6\u1fd7\u0007\u000b\u0000\u0000\u1fd7\u1fd8\u0007\u0006"+ + "\u0000\u0000\u1fd8\u1fd9\u0007\u0013\u0000\u0000\u1fd9\u1fda\u0007\b\u0000"+ + "\u0000\u1fda\u1fdb\u0007\u0007\u0000\u0000\u1fdb\u1fdc\u0007\u0004\u0000"+ + "\u0000\u1fdc\u04fc\u0001\u0000\u0000\u0000\u1fdd\u1fde\u0007\u000b\u0000"+ + "\u0000\u1fde\u1fdf\u0007\u0006\u0000\u0000\u1fdf\u1fe0\u0007\b\u0000\u0000"+ + "\u1fe0\u1fe1\u0007\u000f\u0000\u0000\u1fe1\u1fe2\u0007\f\u0000\u0000\u1fe2"+ + "\u1fe3\u0007\u0016\u0000\u0000\u1fe3\u04fe\u0001\u0000\u0000\u0000\u1fe4"+ + "\u1fe5\u0007\u000b\u0000\u0000\u1fe5\u1fe6\u0007\u0011\u0000\u0000\u1fe6"+ + "\u1fe7\u0007\u0010\u0000\u0000\u1fe7\u1fe8\u0007\u000e\u0000\u0000\u1fe8"+ + "\u1fe9\u0007\u0005\u0000\u0000\u1fe9\u1fea\u0007\u0003\u0000\u0000\u1fea"+ + "\u1feb\u0007\u000b\u0000\u0000\u1feb\u1fec\u0007\u000b\u0000\u0000\u1fec"+ + "\u1fed\u0005_\u0000\u0000\u1fed\u1fee\u0007\u0013\u0000\u0000\u1fee\u1fef"+ + "\u0007\b\u0000\u0000\u1fef\u1ff0\u0007\u000f\u0000\u0000\u1ff0\u1ff1\u0007"+ + "\u0016\u0000\u0000\u1ff1\u1ff2\u0007\u000f\u0000\u0000\u1ff2\u1ff3\u0007"+ + "\f\u0000\u0000\u1ff3\u0500\u0001\u0000\u0000\u0000\u1ff4\u1ff5\u0007\u000b"+ + "\u0000\u0000\u1ff5\u1ff6\u0007\u0011\u0000\u0000\u1ff6\u1ff7\u0007\u0010"+ + "\u0000\u0000\u1ff7\u1ff8\u0007\u001b\u0000\u0000\u1ff8\u1ff9\u0007\u0007"+ + "\u0000\u0000\u1ff9\u1ffa\u0007\u000e\u0000\u0000\u1ffa\u1ffb\u0007\u0006"+ + "\u0000\u0000\u1ffb\u0502\u0001\u0000\u0000\u0000\u1ffc\u1ffd\u0007\u000b"+ + "\u0000\u0000\u1ffd\u1ffe\u0007\u0011\u0000\u0000\u1ffe\u1fff\u0007\u0010"+ + "\u0000\u0000\u1fff\u2000\u0007\u0019\u0000\u0000\u2000\u2001\u0007\u0003"+ + "\u0000\u0000\u2001\u2002\u0007\b\u0000\u0000\u2002\u2003\u0007\u0006\u0000"+ + "\u0000\u2003\u2004\u0007\u000f\u0000\u0000\u2004\u2005\u0007\u0006\u0000"+ + "\u0000\u2005\u2006\u0007\u000f\u0000\u0000\u2006\u2007\u0007\u0013\u0000"+ + "\u0000\u2007\u2008\u0007\f\u0000\u0000\u2008\u0504\u0001\u0000\u0000\u0000"+ + "\u2009\u200a\u0007\u000b\u0000\u0000\u200a\u200b\u0007\u0011\u0000\u0000"+ + "\u200b\u200c\u0007\u0010\u0000\u0000\u200c\u200d\u0007\u0019\u0000\u0000"+ + "\u200d\u200e\u0007\u0003\u0000\u0000\u200e\u200f\u0007\b\u0000\u0000\u200f"+ + "\u2010\u0007\u0006\u0000\u0000\u2010\u2011\u0007\u000f\u0000\u0000\u2011"+ + "\u2012\u0007\u0006\u0000\u0000\u2012\u2013\u0007\u000f\u0000\u0000\u2013"+ + "\u2014\u0007\u0013\u0000\u0000\u2014\u2015\u0007\f\u0000\u0000\u2015\u2016"+ + "\u0007\u000b\u0000\u0000\u2016\u0506\u0001\u0000\u0000\u0000\u2017\u2018"+ + "\u0007\u000b\u0000\u0000\u2018\u2019\u0007\u0011\u0000\u0000\u2019\u201a"+ + "\u0007\u000b\u0000\u0000\u201a\u201b\u0007\u0019\u0000\u0000\u201b\u201c"+ + "\u0007\u0007\u0000\u0000\u201c\u201d\u0007\f\u0000\u0000\u201d\u201e\u0007"+ + "\u0004\u0000\u0000\u201e\u0508\u0001\u0000\u0000\u0000\u201f\u2020\u0007"+ + "\u000b\u0000\u0000\u2020\u2021\u0007\t\u0000\u0000\u2021\u2022\u0007\u0003"+ + "\u0000\u0000\u2022\u2023\u0007\u0019\u0000\u0000\u2023\u2024\u0007\u000b"+ + "\u0000\u0000\u2024\u050a\u0001\u0000\u0000\u0000\u2025\u2026\u0007\u000b"+ + "\u0000\u0000\u2026\u2027\u0007\t\u0000\u0000\u2027\u2028\u0007\u000f\u0000"+ + "\u0000\u2028\u2029\u0007\u0006\u0000\u0000\u2029\u202a\u0007\u000e\u0000"+ + "\u0000\u202a\u202b\u0007\u0014\u0000\u0000\u202b\u202c\u0007\u0007\u0000"+ + "\u0000\u202c\u202d\u0007\u000b\u0000\u0000\u202d\u050c\u0001\u0000\u0000"+ + "\u0000\u202e\u202f\u0007\u0006\u0000\u0000\u202f\u2030\u0007\u0003\u0000"+ + "\u0000\u2030\u2031\u0007\u0010\u0000\u0000\u2031\u2032\u0007\u0005\u0000"+ + "\u0000\u2032\u2033\u0007\u0007\u0000\u0000\u2033\u2034\u0005_\u0000\u0000"+ + "\u2034\u2035\u0007\f\u0000\u0000\u2035\u2036\u0007\u0003\u0000\u0000\u2036"+ + "\u2037\u0007\u0017\u0000\u0000\u2037\u2038\u0007\u0007\u0000\u0000\u2038"+ + "\u050e\u0001\u0000\u0000\u0000\u2039\u203a\u0007\u0006\u0000\u0000\u203a"+ + "\u203b\u0007\u0003\u0000\u0000\u203b\u203c\u0007\u0010\u0000\u0000\u203c"+ + "\u203d\u0007\u0005\u0000\u0000\u203d\u203e\u0007\u0007\u0000\u0000\u203e"+ + "\u203f\u0007\u000b\u0000\u0000\u203f\u2040\u0007\u0019\u0000\u0000\u2040"+ + "\u2041\u0007\u0003\u0000\u0000\u2041\u2042\u0007\u000e\u0000\u0000\u2042"+ + "\u2043\u0007\u0007\u0000\u0000\u2043\u0510\u0001\u0000\u0000\u0000\u2044"+ + "\u2045\u0007\u0006\u0000\u0000\u2045\u2046\u0007\u0003\u0000\u0000\u2046"+ + "\u2047\u0007\u0010\u0000\u0000\u2047\u2048\u0007\u0005\u0000\u0000\u2048"+ + "\u2049\u0007\u0007\u0000\u0000\u2049\u204a\u0005_\u0000\u0000\u204a\u204b"+ + "\u0007\u0006\u0000\u0000\u204b\u204c\u0007\n\u0000\u0000\u204c\u204d\u0007"+ + "\u0019\u0000\u0000\u204d\u204e\u0007\u0007\u0000\u0000\u204e\u0512\u0001"+ + "\u0000\u0000\u0000\u204f\u2050\u0007\u0006\u0000\u0000\u2050\u2051\u0007"+ + "\u0007\u0000\u0000\u2051\u2052\u0007\u0017\u0000\u0000\u2052\u2053\u0007"+ + "\u0019\u0000\u0000\u2053\u2054\u0007\u0013\u0000\u0000\u2054\u2055\u0007"+ + "\b\u0000\u0000\u2055\u2056\u0007\u0003\u0000\u0000\u2056\u2057\u0007\b"+ + "\u0000\u0000\u2057\u2058\u0007\n\u0000\u0000\u2058\u0514\u0001\u0000\u0000"+ + "\u0000\u2059\u205a\u0007\u0006\u0000\u0000\u205a\u205b\u0007\u0007\u0000"+ + "\u0000\u205b\u205c\u0007\u0017\u0000\u0000\u205c\u205d\u0007\u0019\u0000"+ + "\u0000\u205d\u205e\u0007\u0006\u0000\u0000\u205e\u205f\u0007\u0003\u0000"+ + "\u0000\u205f\u2060\u0007\u0010\u0000\u0000\u2060\u2061\u0007\u0005\u0000"+ + "\u0000\u2061\u2062\u0007\u0007\u0000\u0000\u2062\u0516\u0001\u0000\u0000"+ + "\u0000\u2063\u2064\u0007\u0006\u0000\u0000\u2064\u2065\u0007\u0014\u0000"+ + "\u0000\u2065\u2066\u0007\u0003\u0000\u0000\u2066\u2067\u0007\f\u0000\u0000"+ + "\u2067\u0518\u0001\u0000\u0000\u0000\u2068\u2069\u0007\u0006\u0000\u0000"+ + "\u2069\u206a\u0007\b\u0000\u0000\u206a\u206b\u0007\u0003\u0000\u0000\u206b"+ + "\u206c\u0007\u0004\u0000\u0000\u206c\u206d\u0007\u000f\u0000\u0000\u206d"+ + "\u206e\u0007\u0006\u0000\u0000\u206e\u206f\u0007\u000f\u0000\u0000\u206f"+ + "\u2070\u0007\u0013\u0000\u0000\u2070\u2071\u0007\f\u0000\u0000\u2071\u2072"+ + "\u0007\u0003\u0000\u0000\u2072\u2073\u0007\u0005\u0000\u0000\u2073\u051a"+ + "\u0001\u0000\u0000\u0000\u2074\u2075\u0007\u0006\u0000\u0000\u2075\u2076"+ + "\u0007\b\u0000\u0000\u2076\u2077\u0007\u0003\u0000\u0000\u2077\u2078\u0007"+ + "\f\u0000\u0000\u2078\u2079\u0007\u000b\u0000\u0000\u2079\u207a\u0007\u0003"+ + "\u0000\u0000\u207a\u207b\u0007\u000e\u0000\u0000\u207b\u207c\u0007\u0006"+ + "\u0000\u0000\u207c\u207d\u0007\u000f\u0000\u0000\u207d\u207e\u0007\u0013"+ + "\u0000\u0000\u207e\u207f\u0007\f\u0000\u0000\u207f\u051c\u0001\u0000\u0000"+ + "\u0000\u2080\u2081\u0007\u0006\u0000\u0000\u2081\u2082\u0007\b\u0000\u0000"+ + "\u2082\u2083\u0007\u0003\u0000\u0000\u2083\u2084\u0007\f\u0000\u0000\u2084"+ + "\u2085\u0007\u000b\u0000\u0000\u2085\u2086\u0007\u0003\u0000\u0000\u2086"+ + "\u2087\u0007\u000e\u0000\u0000\u2087\u2088\u0007\u0006\u0000\u0000\u2088"+ + "\u2089\u0007\u000f\u0000\u0000\u2089\u208a\u0007\u0013\u0000\u0000\u208a"+ + "\u208b\u0007\f\u0000\u0000\u208b\u208c\u0007\u0003\u0000\u0000\u208c\u208d"+ + "\u0007\u0005\u0000\u0000\u208d\u051e\u0001\u0000\u0000\u0000\u208e\u208f"+ + "\u0007\u0006\u0000\u0000\u208f\u2090\u0007\b\u0000\u0000\u2090\u2091\u0007"+ + "\u000f\u0000\u0000\u2091\u2092\u0007\u0016\u0000\u0000\u2092\u2093\u0007"+ + "\u0016\u0000\u0000\u2093\u2094\u0007\u0007\u0000\u0000\u2094\u2095\u0007"+ + "\b\u0000\u0000\u2095\u2096\u0007\u000b\u0000\u0000\u2096\u0520\u0001\u0000"+ + "\u0000\u0000\u2097\u2098\u0007\u0006\u0000\u0000\u2098\u2099\u0007\b\u0000"+ + "\u0000\u2099\u209a\u0007\u0011\u0000\u0000\u209a\u209b\u0007\f\u0000\u0000"+ + "\u209b\u209c\u0007\u000e\u0000\u0000\u209c\u209d\u0007\u0003\u0000\u0000"+ + "\u209d\u209e\u0007\u0006\u0000\u0000\u209e\u209f\u0007\u0007\u0000\u0000"+ + "\u209f\u0522\u0001\u0000\u0000\u0000\u20a0\u20a1\u0007\u0011\u0000\u0000"+ + "\u20a1\u20a2\u0007\f\u0000\u0000\u20a2\u20a3\u0007\u0010\u0000\u0000\u20a3"+ + "\u20a4\u0007\u0013\u0000\u0000\u20a4\u20a5\u0007\u0011\u0000\u0000\u20a5"+ + "\u20a6\u0007\f\u0000\u0000\u20a6\u20a7\u0007\u0004\u0000\u0000\u20a7\u20a8"+ + "\u0007\u0007\u0000\u0000\u20a8\u20a9\u0007\u0004\u0000\u0000\u20a9\u0524"+ + "\u0001\u0000\u0000\u0000\u20aa\u20ab\u0007\u0011\u0000\u0000\u20ab\u20ac"+ + "\u0007\f\u0000\u0000\u20ac\u20ad\u0007\u0004\u0000\u0000\u20ad\u20ae\u0007"+ + "\u0007\u0000\u0000\u20ae\u20af\u0007\u0012\u0000\u0000\u20af\u20b0\u0007"+ + "\u000f\u0000\u0000\u20b0\u20b1\u0007\f\u0000\u0000\u20b1\u20b2\u0007\u0007"+ + "\u0000\u0000\u20b2\u20b3\u0007\u0004\u0000\u0000\u20b3\u0526\u0001\u0000"+ + "\u0000\u0000\u20b4\u20b5\u0007\u0011\u0000\u0000\u20b5\u20b6\u0007\f\u0000"+ + "\u0000\u20b6\u20b7\u0007\u0004\u0000\u0000\u20b7\u20b8\u0007\u0013\u0000"+ + "\u0000\u20b8\u20b9\u0007\u0012\u0000\u0000\u20b9\u20ba\u0007\u000f\u0000"+ + "\u0000\u20ba\u20bb\u0007\u0005\u0000\u0000\u20bb\u20bc\u0007\u0007\u0000"+ + "\u0000\u20bc\u0528\u0001\u0000\u0000\u0000\u20bd\u20be\u0007\u0011\u0000"+ + "\u0000\u20be\u20bf\u0007\f\u0000\u0000\u20bf\u20c0\u0007\u0004\u0000\u0000"+ + "\u20c0\u20c1\u0007\u0013\u0000\u0000\u20c1\u20c2\u0005_\u0000\u0000\u20c2"+ + "\u20c3\u0007\u0010\u0000\u0000\u20c3\u20c4\u0007\u0011\u0000\u0000\u20c4"+ + "\u20c5\u0007\u0012\u0000\u0000\u20c5\u20c6\u0007\u0012\u0000\u0000\u20c6"+ + "\u20c7\u0007\u0007\u0000\u0000\u20c7\u20c8\u0007\b\u0000\u0000\u20c8\u20c9"+ + "\u0005_\u0000\u0000\u20c9\u20ca\u0007\u000b\u0000\u0000\u20ca\u20cb\u0007"+ + "\u000f\u0000\u0000\u20cb\u20cc\u0007\r\u0000\u0000\u20cc\u20cd\u0007\u0007"+ + "\u0000\u0000\u20cd\u052a\u0001\u0000\u0000\u0000\u20ce\u20cf\u0007\u0011"+ + "\u0000\u0000\u20cf\u20d0\u0007\f\u0000\u0000\u20d0\u20d1\u0007\u000f\u0000"+ + "\u0000\u20d1\u20d2\u0007\f\u0000\u0000\u20d2\u20d3\u0007\u000b\u0000\u0000"+ + "\u20d3\u20d4\u0007\u0006\u0000\u0000\u20d4\u20d5\u0007\u0003\u0000\u0000"+ + "\u20d5\u20d6\u0007\u0005\u0000\u0000\u20d6\u20d7\u0007\u0005\u0000\u0000"+ + "\u20d7\u052c\u0001\u0000\u0000\u0000\u20d8\u20d9\u0007\u0011\u0000\u0000"+ + "\u20d9\u20da\u0007\f\u0000\u0000\u20da\u20db\u0007\u0015\u0000\u0000\u20db"+ + "\u20dc\u0007\f\u0000\u0000\u20dc\u20dd\u0007\u0013\u0000\u0000\u20dd\u20de"+ + "\u0007\t\u0000\u0000\u20de\u20df\u0007\f\u0000\u0000\u20df\u052e\u0001"+ + "\u0000\u0000\u0000\u20e0\u20e1\u0007\u0011\u0000\u0000\u20e1\u20e2\u0007"+ + "\f\u0000\u0000\u20e2\u20e3\u0007\u0006\u0000\u0000\u20e3\u20e4\u0007\u000f"+ + "\u0000\u0000\u20e4\u20e5\u0007\u0005\u0000\u0000\u20e5\u0530\u0001\u0000"+ + "\u0000\u0000\u20e6\u20e7\u0007\u0011\u0000\u0000\u20e7\u20e8\u0007\u0019"+ + "\u0000\u0000\u20e8\u20e9\u0007\u0016\u0000\u0000\u20e9\u20ea\u0007\b\u0000"+ + "\u0000\u20ea\u20eb\u0007\u0003\u0000\u0000\u20eb\u20ec\u0007\u0004\u0000"+ + "\u0000\u20ec\u20ed\u0007\u0007\u0000\u0000\u20ed\u0532\u0001\u0000\u0000"+ + "\u0000\u20ee\u20ef\u0007\u0011\u0000\u0000\u20ef\u20f0\u0007\u000b\u0000"+ + "\u0000\u20f0\u20f1\u0007\u0007\u0000\u0000\u20f1\u20f2\u0007\b\u0000\u0000"+ + "\u20f2\u0534\u0001\u0000\u0000\u0000\u20f3\u20f4\u0007\u0011\u0000\u0000"+ + "\u20f4\u20f5\u0007\u000b\u0000\u0000\u20f5\u20f6\u0007\u0007\u0000\u0000"+ + "\u20f6\u20f7\u0005_\u0000\u0000\u20f7\u20f8\u0007\u0012\u0000\u0000\u20f8"+ + "\u20f9\u0007\b\u0000\u0000\u20f9\u20fa\u0007\u0017\u0000\u0000\u20fa\u0536"+ + "\u0001\u0000\u0000\u0000\u20fb\u20fc\u0007\u0011\u0000\u0000\u20fc\u20fd"+ + "\u0007\u000b\u0000\u0000\u20fd\u20fe\u0007\u0007\u0000\u0000\u20fe\u20ff"+ + "\u0007\b\u0000\u0000\u20ff\u2100\u0005_\u0000\u0000\u2100\u2101\u0007"+ + "\b\u0000\u0000\u2101\u2102\u0007\u0007\u0000\u0000\u2102\u2103\u0007\u000b"+ + "\u0000\u0000\u2103\u2104\u0007\u0013\u0000\u0000\u2104\u2105\u0007\u0011"+ + "\u0000\u0000\u2105\u2106\u0007\b\u0000\u0000\u2106\u2107\u0007\u000e\u0000"+ + "\u0000\u2107\u2108\u0007\u0007\u0000\u0000\u2108\u2109\u0007\u000b\u0000"+ + "\u0000\u2109\u0538\u0001\u0000\u0000\u0000\u210a\u210b\u0007\u0018\u0000"+ + "\u0000\u210b\u210c\u0007\u0003\u0000\u0000\u210c\u210d\u0007\u0005\u0000"+ + "\u0000\u210d\u210e\u0007\u000f\u0000\u0000\u210e\u210f\u0007\u0004\u0000"+ + "\u0000\u210f\u2110\u0007\u0003\u0000\u0000\u2110\u2111\u0007\u0006\u0000"+ + "\u0000\u2111\u2112\u0007\u000f\u0000\u0000\u2112\u2113\u0007\u0013\u0000"+ + "\u0000\u2113\u2114\u0007\f\u0000\u0000\u2114\u053a\u0001\u0000\u0000\u0000"+ + "\u2115\u2116\u0007\u0018\u0000\u0000\u2116\u2117\u0007\u0003\u0000\u0000"+ + "\u2117\u2118\u0007\u0005\u0000\u0000\u2118\u2119\u0007\u0011\u0000\u0000"+ + "\u2119\u211a\u0007\u0007\u0000\u0000\u211a\u053c\u0001\u0000\u0000\u0000"+ + "\u211b\u211c\u0007\u0018\u0000\u0000\u211c\u211d\u0007\u0003\u0000\u0000"+ + "\u211d\u211e\u0007\b\u0000\u0000\u211e\u211f\u0007\u000f\u0000\u0000\u211f"+ + "\u2120\u0007\u0003\u0000\u0000\u2120\u2121\u0007\u0010\u0000\u0000\u2121"+ + "\u2122\u0007\u0005\u0000\u0000\u2122\u2123\u0007\u0007\u0000\u0000\u2123"+ + "\u2124\u0007\u000b\u0000\u0000\u2124\u053e\u0001\u0000\u0000\u0000\u2125"+ + "\u2126\u0007\u0018\u0000\u0000\u2126\u2127\u0007\u000f\u0000\u0000\u2127"+ + "\u2128\u0007\u0007\u0000\u0000\u2128\u2129\u0007\t\u0000\u0000\u2129\u0540"+ + "\u0001\u0000\u0000\u0000\u212a\u212b\u0007\u0018\u0000\u0000\u212b\u212c"+ + "\u0007\u000f\u0000\u0000\u212c\u212d\u0007\b\u0000\u0000\u212d\u212e\u0007"+ + "\u0006\u0000\u0000\u212e\u212f\u0007\u0011\u0000\u0000\u212f\u2130\u0007"+ + "\u0003\u0000\u0000\u2130\u2131\u0007\u0005\u0000\u0000\u2131\u0542\u0001"+ + "\u0000\u0000\u0000\u2132\u2133\u0007\u0018\u0000\u0000\u2133\u2134\u0007"+ + "\u000f\u0000\u0000\u2134\u2135\u0007\u000b\u0000\u0000\u2135\u2136\u0007"+ + "\u000f\u0000\u0000\u2136\u2137\u0007\u0010\u0000\u0000\u2137\u2138\u0007"+ + "\u0005\u0000\u0000\u2138\u2139\u0007\u0007\u0000\u0000\u2139\u0544\u0001"+ + "\u0000\u0000\u0000\u213a\u213b\u0007\t\u0000\u0000\u213b\u213c\u0007\u0003"+ + "\u0000\u0000\u213c\u213d\u0007\u000f\u0000\u0000\u213d\u213e\u0007\u0006"+ + "\u0000\u0000\u213e\u0546\u0001\u0000\u0000\u0000\u213f\u2140\u0007\t\u0000"+ + "\u0000\u2140\u2141\u0007\u0003\u0000\u0000\u2141\u2142\u0007\b\u0000\u0000"+ + "\u2142\u2143\u0007\f\u0000\u0000\u2143\u2144\u0007\u000f\u0000\u0000\u2144"+ + "\u2145\u0007\f\u0000\u0000\u2145\u2146\u0007\u0016\u0000\u0000\u2146\u2147"+ + "\u0007\u000b\u0000\u0000\u2147\u0548\u0001\u0000\u0000\u0000\u2148\u2149"+ + "\u0007\t\u0000\u0000\u2149\u214a\u0007\u000f\u0000\u0000\u214a\u214b\u0007"+ + "\f\u0000\u0000\u214b\u214c\u0007\u0004\u0000\u0000\u214c\u214d\u0007\u0013"+ + "\u0000\u0000\u214d\u214e\u0007\t\u0000\u0000\u214e\u054a\u0001\u0000\u0000"+ + "\u0000\u214f\u2150\u0007\t\u0000\u0000\u2150\u2151\u0007\u000f\u0000\u0000"+ + "\u2151\u2152\u0007\u0006\u0000\u0000\u2152\u2153\u0007\u0014\u0000\u0000"+ + "\u2153\u2154\u0007\u0013\u0000\u0000\u2154\u2155\u0007\u0011\u0000\u0000"+ + "\u2155\u2156\u0007\u0006\u0000\u0000\u2156\u054c\u0001\u0000\u0000\u0000"+ + "\u2157\u2158\u0007\t\u0000\u0000\u2158\u2159\u0007\u0013\u0000\u0000\u2159"+ + "\u215a\u0007\b\u0000\u0000\u215a\u215b\u0007\u0015\u0000\u0000\u215b\u054e"+ + "\u0001\u0000\u0000\u0000\u215c\u215d\u0007\t\u0000\u0000\u215d\u215e\u0007"+ + "\b\u0000\u0000\u215e\u215f\u0007\u0003\u0000\u0000\u215f\u2160\u0007\u0019"+ + "\u0000\u0000\u2160\u2161\u0007\u0019\u0000\u0000\u2161\u2162\u0007\u0007"+ + "\u0000\u0000\u2162\u2163\u0007\b\u0000\u0000\u2163\u0550\u0001\u0000\u0000"+ + "\u0000\u2164\u2165\u0007\u001a\u0000\u0000\u2165\u2166\u00055\u0000\u0000"+ + "\u2166\u2167\u00050\u0000\u0000\u2167\u2168\u00059\u0000\u0000\u2168\u0552"+ + "\u0001\u0000\u0000\u0000\u2169\u216a\u0007\u001a\u0000\u0000\u216a\u216b"+ + "\u0007\u0003\u0000\u0000\u216b\u0554\u0001\u0000\u0000\u0000\u216c\u216d"+ + "\u0007\u001a\u0000\u0000\u216d\u216e\u0007\u0017\u0000\u0000\u216e\u216f"+ + "\u0007\u0005\u0000\u0000\u216f\u0556\u0001\u0000\u0000\u0000\u2170\u2171"+ + "\u0007\n\u0000\u0000\u2171\u2172\u0007\u0007\u0000\u0000\u2172\u2173\u0007"+ + "\u000b\u0000\u0000\u2173\u0558\u0001\u0000\u0000\u0000\u2174\u2175\u0007"+ + "\u0007\u0000\u0000\u2175\u2176\u0007\u0011\u0000\u0000\u2176\u2177\u0007"+ + "\b\u0000\u0000\u2177\u055a\u0001\u0000\u0000\u0000\u2178\u2179\u0007\u0011"+ + "\u0000\u0000\u2179\u217a\u0007\u000b\u0000\u0000\u217a\u217b\u0007\u0003"+ + "\u0000\u0000\u217b\u055c\u0001\u0000\u0000\u0000\u217c\u217d\u0007\u001b"+ + "\u0000\u0000\u217d\u217e\u0007\u000f\u0000\u0000\u217e\u217f\u0007\u000b"+ + "\u0000\u0000\u217f\u055e\u0001\u0000\u0000\u0000\u2180\u2181\u0007\u000f"+ + "\u0000\u0000\u2181\u2182\u0007\u000b\u0000\u0000\u2182\u2183\u0007\u0013"+ + "\u0000\u0000\u2183\u0560\u0001\u0000\u0000\u0000\u2184\u2185\u0007\u000f"+ + "\u0000\u0000\u2185\u2186\u0007\f\u0000\u0000\u2186\u2187\u0007\u0006\u0000"+ + "\u0000\u2187\u2188\u0007\u0007\u0000\u0000\u2188\u2189\u0007\b\u0000\u0000"+ + "\u2189\u218a\u0007\f\u0000\u0000\u218a\u218b\u0007\u0003\u0000\u0000\u218b"+ + "\u218c\u0007\u0005\u0000\u0000\u218c\u0562\u0001\u0000\u0000\u0000\u218d"+ + "\u218e\u0007\u001c\u0000\u0000\u218e\u218f\u0007\u0011\u0000\u0000\u218f"+ + "\u2190\u0007\u0003\u0000\u0000\u2190\u2191\u0007\b\u0000\u0000\u2191\u2192"+ + "\u0007\u0006\u0000\u0000\u2192\u2193\u0007\u0007\u0000\u0000\u2193\u2194"+ + "\u0007\b\u0000\u0000\u2194\u0564\u0001\u0000\u0000\u0000\u2195\u2196\u0007"+ + "\u0017\u0000\u0000\u2196\u2197\u0007\u0013\u0000\u0000\u2197\u2198\u0007"+ + "\f\u0000\u0000\u2198\u2199\u0007\u0006\u0000\u0000\u2199\u219a\u0007\u0014"+ + "\u0000\u0000\u219a\u0566\u0001\u0000\u0000\u0000\u219b\u219c\u0007\u0004"+ + "\u0000\u0000\u219c\u219d\u0007\u0003\u0000\u0000\u219d\u219e\u0007\n\u0000"+ + "\u0000\u219e\u0568\u0001\u0000\u0000\u0000\u219f\u21a0\u0007\u0014\u0000"+ + "\u0000\u21a0\u21a1\u0007\u0013\u0000\u0000\u21a1\u21a2\u0007\u0011\u0000"+ + "\u0000\u21a2\u21a3\u0007\b\u0000\u0000\u21a3\u056a\u0001\u0000\u0000\u0000"+ + "\u21a4\u21a5\u0007\u0017\u0000\u0000\u21a5\u21a6\u0007\u000f\u0000\u0000"+ + "\u21a6\u21a7\u0007\f\u0000\u0000\u21a7\u21a8\u0007\u0011\u0000\u0000\u21a8"+ + "\u21a9\u0007\u0006\u0000\u0000\u21a9\u21aa\u0007\u0007\u0000\u0000\u21aa"+ + "\u056c\u0001\u0000\u0000\u0000\u21ab\u21ac\u0007\t\u0000\u0000\u21ac\u21ad"+ + "\u0007\u0007\u0000\u0000\u21ad\u21ae\u0007\u0007\u0000\u0000\u21ae\u21af"+ + "\u0007\u0015\u0000\u0000\u21af\u056e\u0001\u0000\u0000\u0000\u21b0\u21b1"+ + "\u0007\u000b\u0000\u0000\u21b1\u21b2\u0007\u0007\u0000\u0000\u21b2\u21b3"+ + "\u0007\u000e\u0000\u0000\u21b3\u21b4\u0007\u0013\u0000\u0000\u21b4\u21b5"+ + "\u0007\f\u0000\u0000\u21b5\u21b6\u0007\u0004\u0000\u0000\u21b6\u0570\u0001"+ + "\u0000\u0000\u0000\u21b7\u21b8\u0007\u0017\u0000\u0000\u21b8\u21b9\u0007"+ + "\u000f\u0000\u0000\u21b9\u21ba\u0007\u000e\u0000\u0000\u21ba\u21bb\u0007"+ + "\b\u0000\u0000\u21bb\u21bc\u0007\u0013\u0000\u0000\u21bc\u21bd\u0007\u000b"+ + "\u0000\u0000\u21bd\u21be\u0007\u0007\u0000\u0000\u21be\u21bf\u0007\u000e"+ + "\u0000\u0000\u21bf\u21c0\u0007\u0013\u0000\u0000\u21c0\u21c1\u0007\f\u0000"+ + "\u0000\u21c1\u21c2\u0007\u0004\u0000\u0000\u21c2\u0572\u0001\u0000\u0000"+ + "\u0000\u21c3\u21c4\u0007\u0003\u0000\u0000\u21c4\u21c5\u0007\u0004\u0000"+ + "\u0000\u21c5\u21c6\u0007\u0017\u0000\u0000\u21c6\u21c7\u0007\u000f\u0000"+ + "\u0000\u21c7\u21c8\u0007\f\u0000\u0000\u21c8\u0574\u0001\u0000\u0000\u0000"+ + "\u21c9\u21ca\u0007\u0003\u0000\u0000\u21ca\u21cb\u0007\u0019\u0000\u0000"+ + "\u21cb\u21cc\u0007\u0019\u0000\u0000\u21cc\u21cd\u0007\u0005\u0000\u0000"+ + "\u21cd\u21ce\u0007\u000f\u0000\u0000\u21ce\u21cf\u0007\u000e\u0000\u0000"+ + "\u21cf\u21d0\u0007\u0003\u0000\u0000\u21d0\u21d1\u0007\u0006\u0000\u0000"+ + "\u21d1\u21d2\u0007\u000f\u0000\u0000\u21d2\u21d3\u0007\u0013\u0000\u0000"+ + "\u21d3\u21d4\u0007\f\u0000\u0000\u21d4\u21d5\u0005_\u0000\u0000\u21d5"+ + "\u21d6\u0007\u0019\u0000\u0000\u21d6\u21d7\u0007\u0003\u0000\u0000\u21d7"+ + "\u21d8\u0007\u000b\u0000\u0000\u21d8\u21d9\u0007\u000b\u0000\u0000\u21d9"+ + "\u21da\u0007\t\u0000\u0000\u21da\u21db\u0007\u0013\u0000\u0000\u21db\u21dc"+ + "\u0007\b\u0000\u0000\u21dc\u21dd\u0007\u0004\u0000\u0000\u21dd\u21de\u0005"+ + "_\u0000\u0000\u21de\u21df\u0007\u0003\u0000\u0000\u21df\u21e0\u0007\u0004"+ + "\u0000\u0000\u21e0\u21e1\u0007\u0017\u0000\u0000\u21e1\u21e2\u0007\u000f"+ + "\u0000\u0000\u21e2\u21e3\u0007\f\u0000\u0000\u21e3\u0576\u0001\u0000\u0000"+ + "\u0000\u21e4\u21e5\u0007\u0003\u0000\u0000\u21e5\u21e6\u0007\u0011\u0000"+ + "\u0000\u21e6\u21e7\u0007\u0004\u0000\u0000\u21e7\u21e8\u0007\u000f\u0000"+ + "\u0000\u21e8\u21e9\u0007\u0006\u0000\u0000\u21e9\u21ea\u0005_\u0000\u0000"+ + "\u21ea\u21eb\u0007\u0003\u0000\u0000\u21eb\u21ec\u0007\u0010\u0000\u0000"+ + "\u21ec\u21ed\u0007\u0013\u0000\u0000\u21ed\u21ee\u0007\b\u0000\u0000\u21ee"+ + "\u21ef\u0007\u0006\u0000\u0000\u21ef\u21f0\u0005_\u0000\u0000\u21f0\u21f1"+ + "\u0007\u0007\u0000\u0000\u21f1\u21f2\u0007\u001a\u0000\u0000\u21f2\u21f3"+ + "\u0007\u0007\u0000\u0000\u21f3\u21f4\u0007\u0017\u0000\u0000\u21f4\u21f5"+ + "\u0007\u0019\u0000\u0000\u21f5\u21f6\u0007\u0006\u0000\u0000\u21f6\u0578"+ + "\u0001\u0000\u0000\u0000\u21f7\u21f8\u0007\u0003\u0000\u0000\u21f8\u21f9"+ + "\u0007\u0011\u0000\u0000\u21f9\u21fa\u0007\u0004\u0000\u0000\u21fa\u21fb"+ + "\u0007\u000f\u0000\u0000\u21fb\u21fc\u0007\u0006\u0000\u0000\u21fc\u21fd"+ + "\u0005_\u0000\u0000\u21fd\u21fe\u0007\u0003\u0000\u0000\u21fe\u21ff\u0007"+ + "\u0004\u0000\u0000\u21ff\u2200\u0007\u0017\u0000\u0000\u2200\u2201\u0007"+ + "\u000f\u0000\u0000\u2201\u2202\u0007\f\u0000\u0000\u2202\u057a\u0001\u0000"+ + "\u0000\u0000\u2203\u2204\u0007\u0003\u0000\u0000\u2204\u2205\u0007\u0011"+ + "\u0000\u0000\u2205\u2206\u0007\u0006\u0000\u0000\u2206\u2207\u0007\u0014"+ + "\u0000\u0000\u2207\u2208\u0007\u0007\u0000\u0000\u2208\u2209\u0007\f\u0000"+ + "\u0000\u2209\u220a\u0007\u0006\u0000\u0000\u220a\u220b\u0007\u000f\u0000"+ + "\u0000\u220b\u220c\u0007\u000e\u0000\u0000\u220c\u220d\u0007\u0003\u0000"+ + "\u0000\u220d\u220e\u0007\u0006\u0000\u0000\u220e\u220f\u0007\u000f\u0000"+ + "\u0000\u220f\u2210\u0007\u0013\u0000\u0000\u2210\u2211\u0007\f\u0000\u0000"+ + "\u2211\u2212\u0005_\u0000\u0000\u2212\u2213\u0007\u0019\u0000\u0000\u2213"+ + "\u2214\u0007\u0013\u0000\u0000\u2214\u2215\u0007\u0005\u0000\u0000\u2215"+ + "\u2216\u0007\u000f\u0000\u0000\u2216\u2217\u0007\u000e\u0000\u0000\u2217"+ + "\u2218\u0007\n\u0000\u0000\u2218\u2219\u0005_\u0000\u0000\u2219\u221a"+ + "\u0007\u0003\u0000\u0000\u221a\u221b\u0007\u0004\u0000\u0000\u221b\u221c"+ + "\u0007\u0017\u0000\u0000\u221c\u221d\u0007\u000f\u0000\u0000\u221d\u221e"+ + "\u0007\f\u0000\u0000\u221e\u057c\u0001\u0000\u0000\u0000\u221f\u2220\u0007"+ + "\u0010\u0000\u0000\u2220\u2221\u0007\u0003\u0000\u0000\u2221\u2222\u0007"+ + "\u000e\u0000\u0000\u2222\u2223\u0007\u0015\u0000\u0000\u2223\u2224\u0007"+ + "\u0011\u0000\u0000\u2224\u2225\u0007\u0019\u0000\u0000\u2225\u2226\u0005"+ + "_\u0000\u0000\u2226\u2227\u0007\u0003\u0000\u0000\u2227\u2228\u0007\u0004"+ + "\u0000\u0000\u2228\u2229\u0007\u0017\u0000\u0000\u2229\u222a\u0007\u000f"+ + "\u0000\u0000\u222a\u222b\u0007\f\u0000\u0000\u222b\u057e\u0001\u0000\u0000"+ + "\u0000\u222c\u222d\u0007\u0010\u0000\u0000\u222d\u222e\u0007\u000f\u0000"+ + "\u0000\u222e\u222f\u0007\f\u0000\u0000\u222f\u2230\u0007\u0005\u0000\u0000"+ + "\u2230\u2231\u0007\u0013\u0000\u0000\u2231\u2232\u0007\u0016\u0000\u0000"+ + "\u2232\u2233\u0005_\u0000\u0000\u2233\u2234\u0007\u0003\u0000\u0000\u2234"+ + "\u2235\u0007\u0004\u0000\u0000\u2235\u2236\u0007\u0017\u0000\u0000\u2236"+ + "\u2237\u0007\u000f\u0000\u0000\u2237\u2238\u0007\f\u0000\u0000\u2238\u0580"+ + "\u0001\u0000\u0000\u0000\u2239\u223a\u0007\u0010\u0000\u0000\u223a\u223b"+ + "\u0007\u000f\u0000\u0000\u223b\u223c\u0007\f\u0000\u0000\u223c\u223d\u0007"+ + "\u0005\u0000\u0000\u223d\u223e\u0007\u0013\u0000\u0000\u223e\u223f\u0007"+ + "\u0016\u0000\u0000\u223f\u2240\u0005_\u0000\u0000\u2240\u2241\u0007\u0007"+ + "\u0000\u0000\u2241\u2242\u0007\f\u0000\u0000\u2242\u2243\u0007\u000e\u0000"+ + "\u0000\u2243\u2244\u0007\b\u0000\u0000\u2244\u2245\u0007\n\u0000\u0000"+ + "\u2245\u2246\u0007\u0019\u0000\u0000\u2246\u2247\u0007\u0006\u0000\u0000"+ + "\u2247\u2248\u0007\u000f\u0000\u0000\u2248\u2249\u0007\u0013\u0000\u0000"+ + "\u2249\u224a\u0007\f\u0000\u0000\u224a\u224b\u0005_\u0000\u0000\u224b"+ + "\u224c\u0007\u0003\u0000\u0000\u224c\u224d\u0007\u0004\u0000\u0000\u224d"+ + "\u224e\u0007\u0017\u0000\u0000\u224e\u224f\u0007\u000f\u0000\u0000\u224f"+ + "\u2250\u0007\f\u0000\u0000\u2250\u0582\u0001\u0000\u0000\u0000\u2251\u2252"+ + "\u0007\u000e\u0000\u0000\u2252\u2253\u0007\u0005\u0000\u0000\u2253\u2254"+ + "\u0007\u0013\u0000\u0000\u2254\u2255\u0007\f\u0000\u0000\u2255\u2256\u0007"+ + "\u0007\u0000\u0000\u2256\u2257\u0005_\u0000\u0000\u2257\u2258\u0007\u0003"+ + "\u0000\u0000\u2258\u2259\u0007\u0004\u0000\u0000\u2259\u225a\u0007\u0017"+ + "\u0000\u0000\u225a\u225b\u0007\u000f\u0000\u0000\u225b\u225c\u0007\f\u0000"+ + "\u0000\u225c\u0584\u0001\u0000\u0000\u0000\u225d\u225e\u0007\u000e\u0000"+ + "\u0000\u225e\u225f\u0007\u0013\u0000\u0000\u225f\u2260\u0007\f\u0000\u0000"+ + "\u2260\u2261\u0007\f\u0000\u0000\u2261\u2262\u0007\u0007\u0000\u0000\u2262"+ + "\u2263\u0007\u000e\u0000\u0000\u2263\u2264\u0007\u0006\u0000\u0000\u2264"+ + "\u2265\u0007\u000f\u0000\u0000\u2265\u2266\u0007\u0013\u0000\u0000\u2266"+ + "\u2267\u0007\f\u0000\u0000\u2267\u2268\u0005_\u0000\u0000\u2268\u2269"+ + "\u0007\u0003\u0000\u0000\u2269\u226a\u0007\u0004\u0000\u0000\u226a\u226b"+ + "\u0007\u0017\u0000\u0000\u226b\u226c\u0007\u000f\u0000\u0000\u226c\u226d"+ + "\u0007\f\u0000\u0000\u226d\u0586\u0001\u0000\u0000\u0000\u226e\u226f\u0007"+ + "\u0007\u0000\u0000\u226f\u2270\u0007\f\u0000\u0000\u2270\u2271\u0007\u000e"+ + "\u0000\u0000\u2271\u2272\u0007\b\u0000\u0000\u2272\u2273\u0007\n\u0000"+ + "\u0000\u2273\u2274\u0007\u0019\u0000\u0000\u2274\u2275\u0007\u0006\u0000"+ + "\u0000\u2275\u2276\u0007\u000f\u0000\u0000\u2276\u2277\u0007\u0013\u0000"+ + "\u0000\u2277\u2278\u0007\f\u0000\u0000\u2278\u2279\u0005_\u0000\u0000"+ + "\u2279\u227a\u0007\u0015\u0000\u0000\u227a\u227b\u0007\u0007\u0000\u0000"+ + "\u227b\u227c\u0007\n\u0000\u0000\u227c\u227d\u0005_\u0000\u0000\u227d"+ + "\u227e\u0007\u0003\u0000\u0000\u227e\u227f\u0007\u0004\u0000\u0000\u227f"+ + "\u2280\u0007\u0017\u0000\u0000\u2280\u2281\u0007\u000f\u0000\u0000\u2281"+ + "\u2282\u0007\f\u0000\u0000\u2282\u0588\u0001\u0000\u0000\u0000\u2283\u2284"+ + "\u0007\u0007\u0000\u0000\u2284\u2285\u0007\u001a\u0000\u0000\u2285\u2286"+ + "\u0007\u0007\u0000\u0000\u2286\u2287\u0007\u000e\u0000\u0000\u2287\u2288"+ + "\u0007\u0011\u0000\u0000\u2288\u2289\u0007\u0006\u0000\u0000\u2289\u228a"+ + "\u0007\u0007\u0000\u0000\u228a\u058a\u0001\u0000\u0000\u0000\u228b\u228c"+ + "\u0007\u0012\u0000\u0000\u228c\u228d\u0007\u000f\u0000\u0000\u228d\u228e"+ + "\u0007\u0005\u0000\u0000\u228e\u228f\u0007\u0007\u0000\u0000\u228f\u058c"+ + "\u0001\u0000\u0000\u0000\u2290\u2291\u0007\u0012\u0000\u0000\u2291\u2292"+ + "\u0007\u000f\u0000\u0000\u2292\u2293\u0007\b\u0000\u0000\u2293\u2294\u0007"+ + "\u0007\u0000\u0000\u2294\u2295\u0007\t\u0000\u0000\u2295\u2296\u0007\u0003"+ + "\u0000\u0000\u2296\u2297\u0007\u0005\u0000\u0000\u2297\u2298\u0007\u0005"+ + "\u0000\u0000\u2298\u2299\u0005_\u0000\u0000\u2299\u229a\u0007\u0003\u0000"+ + "\u0000\u229a\u229b\u0007\u0004\u0000\u0000\u229b\u229c\u0007\u0017\u0000"+ + "\u0000\u229c\u229d\u0007\u000f\u0000\u0000\u229d\u229e\u0007\f\u0000\u0000"+ + "\u229e\u058e\u0001\u0000\u0000\u0000\u229f\u22a0\u0007\u0012\u0000\u0000"+ + "\u22a0\u22a1\u0007\u000f\u0000\u0000\u22a1\u22a2\u0007\b\u0000\u0000\u22a2"+ + "\u22a3\u0007\u0007\u0000\u0000\u22a3\u22a4\u0007\t\u0000\u0000\u22a4\u22a5"+ + "\u0007\u0003\u0000\u0000\u22a5\u22a6\u0007\u0005\u0000\u0000\u22a6\u22a7"+ + "\u0007\u0005\u0000\u0000\u22a7\u22a8\u0005_\u0000\u0000\u22a8\u22a9\u0007"+ + "\u0007\u0000\u0000\u22a9\u22aa\u0007\u001a\u0000\u0000\u22aa\u22ab\u0007"+ + "\u0007\u0000\u0000\u22ab\u22ac\u0007\u0017\u0000\u0000\u22ac\u22ad\u0007"+ + "\u0019\u0000\u0000\u22ad\u22ae\u0007\u0006\u0000\u0000\u22ae\u0590\u0001"+ + "\u0000\u0000\u0000\u22af\u22b0\u0007\u0012\u0000\u0000\u22b0\u22b1\u0007"+ + "\u000f\u0000\u0000\u22b1\u22b2\u0007\b\u0000\u0000\u22b2\u22b3\u0007\u0007"+ + "\u0000\u0000\u22b3\u22b4\u0007\t\u0000\u0000\u22b4\u22b5\u0007\u0003\u0000"+ + "\u0000\u22b5\u22b6\u0007\u0005\u0000\u0000\u22b6\u22b7\u0007\u0005\u0000"+ + "\u0000\u22b7\u22b8\u0005_\u0000\u0000\u22b8\u22b9\u0007\u0011\u0000\u0000"+ + "\u22b9\u22ba\u0007\u000b\u0000\u0000\u22ba\u22bb\u0007\u0007\u0000\u0000"+ + "\u22bb\u22bc\u0007\b\u0000\u0000\u22bc\u0592\u0001\u0000\u0000\u0000\u22bd"+ + "\u22be\u0007\u0012\u0000\u0000\u22be\u22bf\u0007\u0005\u0000\u0000\u22bf"+ + "\u22c0\u0007\u0011\u0000\u0000\u22c0\u22c1\u0007\u000b\u0000\u0000\u22c1"+ + "\u22c2\u0007\u0014\u0000\u0000\u22c2\u22c3\u0005_\u0000\u0000\u22c3\u22c4"+ + "\u0007\u0013\u0000\u0000\u22c4\u22c5\u0007\u0019\u0000\u0000\u22c5\u22c6"+ + "\u0007\u0006\u0000\u0000\u22c6\u22c7\u0007\u000f\u0000\u0000\u22c7\u22c8"+ + "\u0007\u0017\u0000\u0000\u22c8\u22c9\u0007\u000f\u0000\u0000\u22c9\u22ca"+ + "\u0007\r\u0000\u0000\u22ca\u22cb\u0007\u0007\u0000\u0000\u22cb\u22cc\u0007"+ + "\b\u0000\u0000\u22cc\u22cd\u0005_\u0000\u0000\u22cd\u22ce\u0007\u000e"+ + "\u0000\u0000\u22ce\u22cf\u0007\u0013\u0000\u0000\u22cf\u22d0\u0007\u000b"+ + "\u0000\u0000\u22d0\u22d1\u0007\u0006\u0000\u0000\u22d1\u22d2\u0007\u000b"+ + "\u0000\u0000\u22d2\u0594\u0001\u0000\u0000\u0000\u22d3\u22d4\u0007\u0012"+ + "\u0000\u0000\u22d4\u22d5\u0007\u0005\u0000\u0000\u22d5\u22d6\u0007\u0011"+ + "\u0000\u0000\u22d6\u22d7\u0007\u000b\u0000\u0000\u22d7\u22d8\u0007\u0014"+ + "\u0000\u0000\u22d8\u22d9\u0005_\u0000\u0000\u22d9\u22da\u0007\u000b\u0000"+ + "\u0000\u22da\u22db\u0007\u0006\u0000\u0000\u22db\u22dc\u0007\u0003\u0000"+ + "\u0000\u22dc\u22dd\u0007\u0006\u0000\u0000\u22dd\u22de\u0007\u0011\u0000"+ + "\u0000\u22de\u22df\u0007\u000b\u0000\u0000\u22df\u0596\u0001\u0000\u0000"+ + "\u0000\u22e0\u22e1\u0007\u0012\u0000\u0000\u22e1\u22e2\u0007\u0005\u0000"+ + "\u0000\u22e2\u22e3\u0007\u0011\u0000\u0000\u22e3\u22e4\u0007\u000b\u0000"+ + "\u0000\u22e4\u22e5\u0007\u0014\u0000\u0000\u22e5\u22e6\u0005_\u0000\u0000"+ + "\u22e6\u22e7\u0007\u0006\u0000\u0000\u22e7\u22e8\u0007\u0003\u0000\u0000"+ + "\u22e8\u22e9\u0007\u0010\u0000\u0000\u22e9\u22ea\u0007\u0005\u0000\u0000"+ + "\u22ea\u22eb\u0007\u0007\u0000\u0000\u22eb\u22ec\u0007\u000b\u0000\u0000"+ + "\u22ec\u0598\u0001\u0000\u0000\u0000\u22ed\u22ee\u0007\u0012\u0000\u0000"+ + "\u22ee\u22ef\u0007\u0005\u0000\u0000\u22ef\u22f0\u0007\u0011\u0000\u0000"+ + "\u22f0\u22f1\u0007\u000b\u0000\u0000\u22f1\u22f2\u0007\u0014\u0000\u0000"+ + "\u22f2\u22f3\u0005_\u0000\u0000\u22f3\u22f4\u0007\u0011\u0000\u0000\u22f4"+ + "\u22f5\u0007\u000b\u0000\u0000\u22f5\u22f6\u0007\u0007\u0000\u0000\u22f6"+ + "\u22f7\u0007\b\u0000\u0000\u22f7\u22f8\u0005_\u0000\u0000\u22f8\u22f9"+ + "\u0007\b\u0000\u0000\u22f9\u22fa\u0007\u0007\u0000\u0000\u22fa\u22fb\u0007"+ + "\u000b\u0000\u0000\u22fb\u22fc\u0007\u0013\u0000\u0000\u22fc\u22fd\u0007"+ + "\u0011\u0000\u0000\u22fd\u22fe\u0007\b\u0000\u0000\u22fe\u22ff\u0007\u000e"+ + "\u0000\u0000\u22ff\u2300\u0007\u0007\u0000\u0000\u2300\u2301\u0007\u000b"+ + "\u0000\u0000\u2301\u059a\u0001\u0000\u0000\u0000\u2302\u2303\u0007\u0016"+ + "\u0000\u0000\u2303\u2304\u0007\b\u0000\u0000\u2304\u2305\u0007\u0013\u0000"+ + "\u0000\u2305\u2306\u0007\u0011\u0000\u0000\u2306\u2307\u0007\u0019\u0000"+ + "\u0000\u2307\u2308\u0005_\u0000\u0000\u2308\u2309\u0007\b\u0000\u0000"+ + "\u2309\u230a\u0007\u0007\u0000\u0000\u230a\u230b\u0007\u0019\u0000\u0000"+ + "\u230b\u230c\u0007\u0005\u0000\u0000\u230c\u230d\u0007\u000f\u0000\u0000"+ + "\u230d\u230e\u0007\u000e\u0000\u0000\u230e\u230f\u0007\u0003\u0000\u0000"+ + "\u230f\u2310\u0007\u0006\u0000\u0000\u2310\u2311\u0007\u000f\u0000\u0000"+ + "\u2311\u2312\u0007\u0013\u0000\u0000\u2312\u2313\u0007\f\u0000\u0000\u2313"+ + "\u2314\u0005_\u0000\u0000\u2314\u2315\u0007\u0003\u0000\u0000\u2315\u2316"+ + "\u0007\u0004\u0000\u0000\u2316\u2317\u0007\u0017\u0000\u0000\u2317\u2318"+ + "\u0007\u000f\u0000\u0000\u2318\u2319\u0007\f\u0000\u0000\u2319\u059c\u0001"+ + "\u0000\u0000\u0000\u231a\u231b\u0007\u000f\u0000\u0000\u231b\u231c\u0007"+ + "\f\u0000\u0000\u231c\u231d\u0007\f\u0000\u0000\u231d\u231e\u0007\u0013"+ + "\u0000\u0000\u231e\u231f\u0007\u0004\u0000\u0000\u231f\u2320\u0007\u0010"+ + "\u0000\u0000\u2320\u2321\u0005_\u0000\u0000\u2321\u2322\u0007\b\u0000"+ + "\u0000\u2322\u2323\u0007\u0007\u0000\u0000\u2323\u2324\u0007\u0004\u0000"+ + "\u0000\u2324\u2325\u0007\u0013\u0000\u0000\u2325\u2326\u0005_\u0000\u0000"+ + "\u2326\u2327\u0007\u0005\u0000\u0000\u2327\u2328\u0007\u0013\u0000\u0000"+ + "\u2328\u2329\u0007\u0016\u0000\u0000\u2329\u232a\u0005_\u0000\u0000\u232a"+ + "\u232b\u0007\u0003\u0000\u0000\u232b\u232c\u0007\b\u0000\u0000\u232c\u232d"+ + "\u0007\u000e\u0000\u0000\u232d\u232e\u0007\u0014\u0000\u0000\u232e\u232f"+ + "\u0007\u000f\u0000\u0000\u232f\u2330\u0007\u0018\u0000\u0000\u2330\u2331"+ + "\u0007\u0007\u0000\u0000\u2331\u059e\u0001\u0000\u0000\u0000\u2332\u2333"+ + "\u0007\u000f\u0000\u0000\u2333\u2334\u0007\f\u0000\u0000\u2334\u2335\u0007"+ + "\f\u0000\u0000\u2335\u2336\u0007\u0013\u0000\u0000\u2336\u2337\u0007\u0004"+ + "\u0000\u0000\u2337\u2338\u0007\u0010\u0000\u0000\u2338\u2339\u0005_\u0000"+ + "\u0000\u2339\u233a\u0007\b\u0000\u0000\u233a\u233b\u0007\u0007\u0000\u0000"+ + "\u233b\u233c\u0007\u0004\u0000\u0000\u233c\u233d\u0007\u0013\u0000\u0000"+ + "\u233d\u233e\u0005_\u0000\u0000\u233e\u233f\u0007\u0005\u0000\u0000\u233f"+ + "\u2340\u0007\u0013\u0000\u0000\u2340\u2341\u0007\u0016\u0000\u0000\u2341"+ + "\u2342\u0005_\u0000\u0000\u2342\u2343\u0007\u0007\u0000\u0000\u2343\u2344"+ + "\u0007\f\u0000\u0000\u2344\u2345\u0007\u0003\u0000\u0000\u2345\u2346\u0007"+ + "\u0010\u0000\u0000\u2346\u2347\u0007\u0005\u0000\u0000\u2347\u2348\u0007"+ + "\u0007\u0000\u0000\u2348\u05a0\u0001\u0000\u0000\u0000\u2349\u234a\u0007"+ + "\u000f\u0000\u0000\u234a\u234b\u0007\f\u0000\u0000\u234b\u234c\u0007\u0018"+ + "\u0000\u0000\u234c\u234d\u0007\u0013\u0000\u0000\u234d\u234e\u0007\u0015"+ + "\u0000\u0000\u234e\u234f\u0007\u0007\u0000\u0000\u234f\u05a2\u0001\u0000"+ + "\u0000\u0000\u2350\u2351\u0007\u0005\u0000\u0000\u2351\u2352\u0007\u0003"+ + "\u0000\u0000\u2352\u2353\u0007\u0017\u0000\u0000\u2353\u2354\u0007\u0010"+ + "\u0000\u0000\u2354\u2355\u0007\u0004\u0000\u0000\u2355\u2356\u0007\u0003"+ + "\u0000\u0000\u2356\u05a4\u0001\u0000\u0000\u0000\u2357\u2358\u0007\f\u0000"+ + "\u0000\u2358\u2359\u0007\u0004\u0000\u0000\u2359\u235a\u0007\u0010\u0000"+ + "\u0000\u235a\u235b\u0005_\u0000\u0000\u235b\u235c\u0007\u000b\u0000\u0000"+ + "\u235c\u235d\u0007\u0006\u0000\u0000\u235d\u235e\u0007\u0013\u0000\u0000"+ + "\u235e\u235f\u0007\b\u0000\u0000\u235f\u2360\u0007\u0007\u0000\u0000\u2360"+ + "\u2361\u0007\u0004\u0000\u0000\u2361\u2362\u0005_\u0000\u0000\u2362\u2363"+ + "\u0007\u0011\u0000\u0000\u2363\u2364\u0007\u000b\u0000\u0000\u2364\u2365"+ + "\u0007\u0007\u0000\u0000\u2365\u2366\u0007\b\u0000\u0000\u2366\u05a6\u0001"+ + "\u0000\u0000\u0000\u2367\u2368\u0007\u0019\u0000\u0000\u2368\u2369\u0007"+ + "\u0003\u0000\u0000\u2369\u236a\u0007\u000b\u0000\u0000\u236a\u236b\u0007"+ + "\u000b\u0000\u0000\u236b\u236c\u0007\t\u0000\u0000\u236c\u236d\u0007\u0013"+ + "\u0000\u0000\u236d\u236e\u0007\b\u0000\u0000\u236e\u236f\u0007\u0004\u0000"+ + "\u0000\u236f\u2370\u0007\u0005\u0000\u0000\u2370\u2371\u0007\u0007\u0000"+ + "\u0000\u2371\u2372\u0007\u000b\u0000\u0000\u2372\u2373\u0007\u000b\u0000"+ + "\u0000\u2373\u2374\u0005_\u0000\u0000\u2374\u2375\u0007\u0011\u0000\u0000"+ + "\u2375\u2376\u0007\u000b\u0000\u0000\u2376\u2377\u0007\u0007\u0000\u0000"+ + "\u2377\u2378\u0007\b\u0000\u0000\u2378\u2379\u0005_\u0000\u0000\u2379"+ + "\u237a\u0007\u0003\u0000\u0000\u237a\u237b\u0007\u0004\u0000\u0000\u237b"+ + "\u237c\u0007\u0017\u0000\u0000\u237c\u237d\u0007\u000f\u0000\u0000\u237d"+ + "\u237e\u0007\f\u0000\u0000\u237e\u05a8\u0001\u0000\u0000\u0000\u237f\u2380"+ + "\u0007\u0019\u0000\u0000\u2380\u2381\u0007\u0007\u0000\u0000\u2381\u2382"+ + "\u0007\b\u0000\u0000\u2382\u2383\u0007\u000b\u0000\u0000\u2383\u2384\u0007"+ + "\u000f\u0000\u0000\u2384\u2385\u0007\u000b\u0000\u0000\u2385\u2386\u0007"+ + "\u0006\u0000\u0000\u2386\u2387\u0005_\u0000\u0000\u2387\u2388\u0007\b"+ + "\u0000\u0000\u2388\u2389\u0007\u0013\u0000\u0000\u2389\u238a\u0005_\u0000"+ + "\u0000\u238a\u238b\u0007\u0018\u0000\u0000\u238b\u238c\u0007\u0003\u0000"+ + "\u0000\u238c\u238d\u0007\b\u0000\u0000\u238d\u238e\u0007\u000f\u0000\u0000"+ + "\u238e\u238f\u0007\u0003\u0000\u0000\u238f\u2390\u0007\u0010\u0000\u0000"+ + "\u2390\u2391\u0007\u0005\u0000\u0000\u2391\u2392\u0007\u0007\u0000\u0000"+ + "\u2392\u2393\u0007\u000b\u0000\u0000\u2393\u2394\u0005_\u0000\u0000\u2394"+ + "\u2395\u0007\u0003\u0000\u0000\u2395\u2396\u0007\u0004\u0000\u0000\u2396"+ + "\u2397\u0007\u0017\u0000\u0000\u2397\u2398\u0007\u000f\u0000\u0000\u2398"+ + "\u2399\u0007\f\u0000\u0000\u2399\u05aa\u0001\u0000\u0000\u0000\u239a\u239b"+ + "\u0007\u0019\u0000\u0000\u239b\u239c\u0007\b\u0000\u0000\u239c\u239d\u0007"+ + "\u000f\u0000\u0000\u239d\u239e\u0007\u0018\u0000\u0000\u239e\u239f\u0007"+ + "\u000f\u0000\u0000\u239f\u23a0\u0007\u0005\u0000\u0000\u23a0\u23a1\u0007"+ + "\u0007\u0000\u0000\u23a1\u23a2\u0007\u0016\u0000\u0000\u23a2\u23a3\u0007"+ + "\u0007\u0000\u0000\u23a3\u23a4\u0007\u000b\u0000\u0000\u23a4\u05ac\u0001"+ + "\u0000\u0000\u0000\u23a5\u23a6\u0007\u0019\u0000\u0000\u23a6\u23a7\u0007"+ + "\b\u0000\u0000\u23a7\u23a8\u0007\u0013\u0000\u0000\u23a8\u23a9\u0007\u000e"+ + "\u0000\u0000\u23a9\u23aa\u0007\u0007\u0000\u0000\u23aa\u23ab\u0007\u000b"+ + "\u0000\u0000\u23ab\u23ac\u0007\u000b\u0000\u0000\u23ac\u05ae\u0001\u0000"+ + "\u0000\u0000\u23ad\u23ae\u0007\b\u0000\u0000\u23ae\u23af\u0007\u0007\u0000"+ + "\u0000\u23af\u23b0\u0007\u0005\u0000\u0000\u23b0\u23b1\u0007\u0013\u0000"+ + "\u0000\u23b1\u23b2\u0007\u0003\u0000\u0000\u23b2\u23b3\u0007\u0004\u0000"+ + "\u0000\u23b3\u05b0\u0001\u0000\u0000\u0000\u23b4\u23b5\u0007\b\u0000\u0000"+ + "\u23b5\u23b6\u0007\u0007\u0000\u0000\u23b6\u23b7\u0007\u0019\u0000\u0000"+ + "\u23b7\u23b8\u0007\u0005\u0000\u0000\u23b8\u23b9\u0007\u000f\u0000\u0000"+ + "\u23b9\u23ba\u0007\u000e\u0000\u0000\u23ba\u23bb\u0007\u0003\u0000\u0000"+ + "\u23bb\u23bc\u0007\u0006\u0000\u0000\u23bc\u23bd\u0007\u000f\u0000\u0000"+ + "\u23bd\u23be\u0007\u0013\u0000\u0000\u23be\u23bf\u0007\f\u0000\u0000\u23bf"+ + "\u23c0\u0005_\u0000\u0000\u23c0\u23c1\u0007\u0003\u0000\u0000\u23c1\u23c2"+ + "\u0007\u0019\u0000\u0000\u23c2\u23c3\u0007\u0019\u0000\u0000\u23c3\u23c4"+ + "\u0007\u0005\u0000\u0000\u23c4\u23c5\u0007\u000f\u0000\u0000\u23c5\u23c6"+ + "\u0007\u0007\u0000\u0000\u23c6\u23c7\u0007\b\u0000\u0000\u23c7\u05b2\u0001"+ + "\u0000\u0000\u0000\u23c8\u23c9\u0007\b\u0000\u0000\u23c9\u23ca\u0007\u0007"+ + "\u0000\u0000\u23ca\u23cb\u0007\u0019\u0000\u0000\u23cb\u23cc\u0007\u0005"+ + "\u0000\u0000\u23cc\u23cd\u0007\u000f\u0000\u0000\u23cd\u23ce\u0007\u000e"+ + "\u0000\u0000\u23ce\u23cf\u0007\u0003\u0000\u0000\u23cf\u23d0\u0007\u0006"+ + "\u0000\u0000\u23d0\u23d1\u0007\u000f\u0000\u0000\u23d1\u23d2\u0007\u0013"+ + "\u0000\u0000\u23d2\u23d3\u0007\f\u0000\u0000\u23d3\u23d4\u0005_\u0000"+ + "\u0000\u23d4\u23d5\u0007\u000b\u0000\u0000\u23d5\u23d6\u0007\u0005\u0000"+ + "\u0000\u23d6\u23d7\u0007\u0003\u0000\u0000\u23d7\u23d8\u0007\u0018\u0000"+ + "\u0000\u23d8\u23d9\u0007\u0007\u0000\u0000\u23d9\u23da\u0005_\u0000\u0000"+ + "\u23da\u23db\u0007\u0003\u0000\u0000\u23db\u23dc\u0007\u0004\u0000\u0000"+ + "\u23dc\u23dd\u0007\u0017\u0000\u0000\u23dd\u23de\u0007\u000f\u0000\u0000"+ + "\u23de\u23df\u0007\f\u0000\u0000\u23df\u05b4\u0001\u0000\u0000\u0000\u23e0"+ + "\u23e1\u0007\b\u0000\u0000\u23e1\u23e2\u0007\u0007\u0000\u0000\u23e2\u23e3"+ + "\u0007\u000b\u0000\u0000\u23e3\u23e4\u0007\u0013\u0000\u0000\u23e4\u23e5"+ + "\u0007\u0011\u0000\u0000\u23e5\u23e6\u0007\b\u0000\u0000\u23e6\u23e7\u0007"+ + "\u000e\u0000\u0000\u23e7\u23e8\u0007\u0007\u0000\u0000\u23e8\u23e9\u0005"+ + "_\u0000\u0000\u23e9\u23ea\u0007\u0016\u0000\u0000\u23ea\u23eb\u0007\b"+ + "\u0000\u0000\u23eb\u23ec\u0007\u0013\u0000\u0000\u23ec\u23ed\u0007\u0011"+ + "\u0000\u0000\u23ed\u23ee\u0007\u0019\u0000\u0000\u23ee\u23ef\u0005_\u0000"+ + "\u0000\u23ef\u23f0\u0007\u0003\u0000\u0000\u23f0\u23f1\u0007\u0004\u0000"+ + "\u0000\u23f1\u23f2\u0007\u0017\u0000\u0000\u23f2\u23f3\u0007\u000f\u0000"+ + "\u0000\u23f3\u23f4\u0007\f\u0000\u0000\u23f4\u05b6\u0001\u0000\u0000\u0000"+ + "\u23f5\u23f6\u0007\b\u0000\u0000\u23f6\u23f7\u0007\u0007\u0000\u0000\u23f7"+ + "\u23f8\u0007\u000b\u0000\u0000\u23f8\u23f9\u0007\u0013\u0000\u0000\u23f9"+ + "\u23fa\u0007\u0011\u0000\u0000\u23fa\u23fb\u0007\b\u0000\u0000\u23fb\u23fc"+ + "\u0007\u000e\u0000\u0000\u23fc\u23fd\u0007\u0007\u0000\u0000\u23fd\u23fe"+ + "\u0005_\u0000\u0000\u23fe\u23ff\u0007\u0016\u0000\u0000\u23ff\u2400\u0007"+ + "\b\u0000\u0000\u2400\u2401\u0007\u0013\u0000\u0000\u2401\u2402\u0007\u0011"+ + "\u0000\u0000\u2402\u2403\u0007\u0019\u0000\u0000\u2403\u2404\u0005_\u0000"+ + "\u0000\u2404\u2405\u0007\u0011\u0000\u0000\u2405\u2406\u0007\u000b\u0000"+ + "\u0000\u2406\u2407\u0007\u0007\u0000\u0000\u2407\u2408\u0007\b\u0000\u0000"+ + "\u2408\u05b8\u0001\u0000\u0000\u0000\u2409\u240a\u0007\b\u0000\u0000\u240a"+ + "\u240b\u0007\u0013\u0000\u0000\u240b\u240c\u0007\u0005\u0000\u0000\u240c"+ + "\u240d\u0007\u0007\u0000\u0000\u240d\u240e\u0005_\u0000\u0000\u240e\u240f"+ + "\u0007\u0003\u0000\u0000\u240f\u2410\u0007\u0004\u0000\u0000\u2410\u2411"+ + "\u0007\u0017\u0000\u0000\u2411\u2412\u0007\u000f\u0000\u0000\u2412\u2413"+ + "\u0007\f\u0000\u0000\u2413\u05ba\u0001\u0000\u0000\u0000\u2414\u2415\u0007"+ + "\b\u0000\u0000\u2415\u2416\u0007\u0013\u0000\u0000\u2416\u2417\u0007\u0011"+ + "\u0000\u0000\u2417\u2418\u0007\u0006\u0000\u0000\u2418\u2419\u0007\u000f"+ + "\u0000\u0000\u2419\u241a\u0007\f\u0000\u0000\u241a\u241b\u0007\u0007\u0000"+ + "\u0000\u241b\u05bc\u0001\u0000\u0000\u0000\u241c\u241d\u0007\u000b\u0000"+ + "\u0000\u241d\u241e\u00053\u0000\u0000\u241e\u05be\u0001\u0000\u0000\u0000"+ + "\u241f\u2420\u0007\u000b\u0000\u0000\u2420\u2421\u0007\u0007\u0000\u0000"+ + "\u2421\u2422\u0007\b\u0000\u0000\u2422\u2423\u0007\u0018\u0000\u0000\u2423"+ + "\u2424\u0007\u000f\u0000\u0000\u2424\u2425\u0007\u000e\u0000\u0000\u2425"+ + "\u2426\u0007\u0007\u0000\u0000\u2426\u2427\u0005_\u0000\u0000\u2427\u2428"+ + "\u0007\u000e\u0000\u0000\u2428\u2429\u0007\u0013\u0000\u0000\u2429\u242a"+ + "\u0007\f\u0000\u0000\u242a\u242b\u0007\f\u0000\u0000\u242b\u242c\u0007"+ + "\u0007\u0000\u0000\u242c\u242d\u0007\u000e\u0000\u0000\u242d\u242e\u0007"+ + "\u0006\u0000\u0000\u242e\u242f\u0007\u000f\u0000\u0000\u242f\u2430\u0007"+ + "\u0013\u0000\u0000\u2430\u2431\u0007\f\u0000\u0000\u2431\u2432\u0005_"+ + "\u0000\u0000\u2432\u2433\u0007\u0003\u0000\u0000\u2433\u2434\u0007\u0004"+ + "\u0000\u0000\u2434\u2435\u0007\u0017\u0000\u0000\u2435\u2436\u0007\u000f"+ + "\u0000\u0000\u2436\u2437\u0007\f\u0000\u0000\u2437\u05c0\u0001\u0000\u0000"+ + "\u0000\u2438\u243a\u0003\u08f3\u0479\u0000\u2439\u2438\u0001\u0000\u0000"+ + "\u0000\u2439\u243a\u0001\u0000\u0000\u0000\u243a\u243b\u0001\u0000\u0000"+ + "\u0000\u243b\u243c\u0007\u000b\u0000\u0000\u243c\u243d\u0007\u0007\u0000"+ + "\u0000\u243d\u243e\u0007\u000b\u0000\u0000\u243e\u243f\u0007\u000b\u0000"+ + "\u0000\u243f\u2440\u0007\u000f\u0000\u0000\u2440\u2441\u0007\u0013\u0000"+ + "\u0000\u2441\u2442\u0007\f\u0000\u0000\u2442\u2443\u0005_\u0000\u0000"+ + "\u2443\u2444\u0007\u0018\u0000\u0000\u2444\u2445\u0007\u0003\u0000\u0000"+ + "\u2445\u2446\u0007\b\u0000\u0000\u2446\u2447\u0007\u000f\u0000\u0000\u2447"+ + "\u2448\u0007\u0003\u0000\u0000\u2448\u2449\u0007\u0010\u0000\u0000\u2449"+ + "\u244a\u0007\u0005\u0000\u0000\u244a\u244b\u0007\u0007\u0000\u0000\u244b"+ + "\u244c\u0007\u000b\u0000\u0000\u244c\u244d\u0005_\u0000\u0000\u244d\u244e"+ + "\u0007\u0003\u0000\u0000\u244e\u244f\u0007\u0004\u0000\u0000\u244f\u2450"+ + "\u0007\u0017\u0000\u0000\u2450\u2451\u0007\u000f\u0000\u0000\u2451\u2452"+ + "\u0007\f\u0000\u0000\u2452\u2454\u0001\u0000\u0000\u0000\u2453\u2455\u0003"+ + "\u08f3\u0479\u0000\u2454\u2453\u0001\u0000\u0000\u0000\u2454\u2455\u0001"+ + "\u0000\u0000\u0000\u2455\u05c2\u0001\u0000\u0000\u0000\u2456\u2457\u0007"+ + "\u000b\u0000\u0000\u2457\u2458\u0007\u0007\u0000\u0000\u2458\u2459\u0007"+ + "\u0006\u0000\u0000\u2459\u245a\u0005_\u0000\u0000\u245a\u245b\u0007\u0011"+ + "\u0000\u0000\u245b\u245c\u0007\u000b\u0000\u0000\u245c\u245d\u0007\u0007"+ + "\u0000\u0000\u245d\u245e\u0007\b\u0000\u0000\u245e\u245f\u0005_\u0000"+ + "\u0000\u245f\u2460\u0007\u000f\u0000\u0000\u2460\u2461\u0007\u0004\u0000"+ + "\u0000\u2461\u05c4\u0001\u0000\u0000\u0000\u2462\u2463\u0007\u000b\u0000"+ + "\u0000\u2463\u2464\u0007\u0014\u0000\u0000\u2464\u2465\u0007\u0013\u0000"+ + "\u0000\u2465\u2466\u0007\t\u0000\u0000\u2466\u2467\u0005_\u0000\u0000"+ + "\u2467\u2468\u0007\b\u0000\u0000\u2468\u2469\u0007\u0013\u0000\u0000\u2469"+ + "\u246a\u0007\u0011\u0000\u0000\u246a\u246b\u0007\u0006\u0000\u0000\u246b"+ + "\u246c\u0007\u000f\u0000\u0000\u246c\u246d\u0007\f\u0000\u0000\u246d\u246e"+ + "\u0007\u0007\u0000\u0000\u246e\u05c6\u0001\u0000\u0000\u0000\u246f\u2470"+ + "\u0007\u000b\u0000\u0000\u2470\u2471\u0007\u0014\u0000\u0000\u2471\u2472"+ + "\u0007\u0011\u0000\u0000\u2472\u2473\u0007\u0006\u0000\u0000\u2473\u2474"+ + "\u0007\u0004\u0000\u0000\u2474\u2475\u0007\u0013\u0000\u0000\u2475\u2476"+ + "\u0007\t\u0000\u0000\u2476\u2477\u0007\f\u0000\u0000\u2477\u05c8\u0001"+ + "\u0000\u0000\u0000\u2478\u2479\u0007\u000b\u0000\u0000\u2479\u247a\u0007"+ + "\u0011\u0000\u0000\u247a\u247b\u0007\u0019\u0000\u0000\u247b\u247c\u0007"+ + "\u0007\u0000\u0000\u247c\u247d\u0007\b\u0000\u0000\u247d\u05ca\u0001\u0000"+ + "\u0000\u0000\u247e\u247f\u0007\u000b\u0000\u0000\u247f\u2480\u0007\n\u0000"+ + "\u0000\u2480\u2481\u0007\u000b\u0000\u0000\u2481\u2482\u0007\u0006\u0000"+ + "\u0000\u2482\u2483\u0007\u0007\u0000\u0000\u2483\u2484\u0007\u0017\u0000"+ + "\u0000\u2484\u2485\u0005_\u0000\u0000\u2485\u2486\u0007\u0018\u0000\u0000"+ + "\u2486\u2487\u0007\u0003\u0000\u0000\u2487\u2488\u0007\b\u0000\u0000\u2488"+ + "\u2489\u0007\u000f\u0000\u0000\u2489\u248a\u0007\u0003\u0000\u0000\u248a"+ + "\u248b\u0007\u0010\u0000\u0000\u248b\u248c\u0007\u0005\u0000\u0000\u248c"+ + "\u248d\u0007\u0007\u0000\u0000\u248d\u248e\u0007\u000b\u0000\u0000\u248e"+ + "\u248f\u0005_\u0000\u0000\u248f\u2490\u0007\u0003\u0000\u0000\u2490\u2491"+ + "\u0007\u0004\u0000\u0000\u2491\u2492\u0007\u0017\u0000\u0000\u2492\u2493"+ + "\u0007\u000f\u0000\u0000\u2493\u2494\u0007\f\u0000\u0000\u2494\u05cc\u0001"+ + "\u0000\u0000\u0000\u2495\u2496\u0007\u0006\u0000\u0000\u2496\u2497\u0007"+ + "\u0003\u0000\u0000\u2497\u2498\u0007\u0010\u0000\u0000\u2498\u2499\u0007"+ + "\u0005\u0000\u0000\u2499\u249a\u0007\u0007\u0000\u0000\u249a\u249b\u0007"+ + "\u000b\u0000\u0000\u249b\u05ce\u0001\u0000\u0000\u0000\u249c\u249d\u0007"+ + "\u0006\u0000\u0000\u249d\u249e\u0007\u0003\u0000\u0000\u249e\u249f\u0007"+ + "\u0010\u0000\u0000\u249f\u24a0\u0007\u0005\u0000\u0000\u24a0\u24a1\u0007"+ + "\u0007\u0000\u0000\u24a1\u24a2\u0005_\u0000\u0000\u24a2\u24a3\u0007\u0007"+ + "\u0000\u0000\u24a3\u24a4\u0007\f\u0000\u0000\u24a4\u24a5\u0007\u000e\u0000"+ + "\u0000\u24a5\u24a6\u0007\b\u0000\u0000\u24a6\u24a7\u0007\n\u0000\u0000"+ + "\u24a7\u24a8\u0007\u0019\u0000\u0000\u24a8\u24a9\u0007\u0006\u0000\u0000"+ + "\u24a9\u24aa\u0007\u000f\u0000\u0000\u24aa\u24ab\u0007\u0013\u0000\u0000"+ + "\u24ab\u24ac\u0007\f\u0000\u0000\u24ac\u24ad\u0005_\u0000\u0000\u24ad"+ + "\u24ae\u0007\u0003\u0000\u0000\u24ae\u24af\u0007\u0004\u0000\u0000\u24af"+ + "\u24b0\u0007\u0017\u0000\u0000\u24b0\u24b1\u0007\u000f\u0000\u0000\u24b1"+ + "\u24b2\u0007\f\u0000\u0000\u24b2\u05d0\u0001\u0000\u0000\u0000\u24b3\u24b4"+ + "\u0007\u0018\u0000\u0000\u24b4\u24b5\u0007\u0007\u0000\u0000\u24b5\u24b6"+ + "\u0007\b\u0000\u0000\u24b6\u24b7\u0007\u000b\u0000\u0000\u24b7\u24b8\u0007"+ + "\u000f\u0000\u0000\u24b8\u24b9\u0007\u0013\u0000\u0000\u24b9\u24ba\u0007"+ + "\f\u0000\u0000\u24ba\u24bb\u0005_\u0000\u0000\u24bb\u24bc\u0007\u0006"+ + "\u0000\u0000\u24bc\u24bd\u0007\u0013\u0000\u0000\u24bd\u24be\u0007\u0015"+ + "\u0000\u0000\u24be\u24bf\u0007\u0007\u0000\u0000\u24bf\u24c0\u0007\f\u0000"+ + "\u0000\u24c0\u24c1\u0005_\u0000\u0000\u24c1\u24c2\u0007\u0003\u0000\u0000"+ + "\u24c2\u24c3\u0007\u0004\u0000\u0000\u24c3\u24c4\u0007\u0017\u0000\u0000"+ + "\u24c4\u24c5\u0007\u000f\u0000\u0000\u24c5\u24c6\u0007\f\u0000\u0000\u24c6"+ + "\u05d2\u0001\u0000\u0000\u0000\u24c7\u24c8\u0007\u001a\u0000\u0000\u24c8"+ + "\u24c9\u0007\u0003\u0000\u0000\u24c9\u24ca\u0005_\u0000\u0000\u24ca\u24cb"+ + "\u0007\b\u0000\u0000\u24cb\u24cc\u0007\u0007\u0000\u0000\u24cc\u24cd\u0007"+ + "\u000e\u0000\u0000\u24cd\u24ce\u0007\u0013\u0000\u0000\u24ce\u24cf\u0007"+ + "\u0018\u0000\u0000\u24cf\u24d0\u0007\u0007\u0000\u0000\u24d0\u24d1\u0007"+ + "\b\u0000\u0000\u24d1\u24d2\u0005_\u0000\u0000\u24d2\u24d3\u0007\u0003"+ + "\u0000\u0000\u24d3\u24d4\u0007\u0004\u0000\u0000\u24d4\u24d5\u0007\u0017"+ + "\u0000\u0000\u24d5\u24d6\u0007\u000f\u0000\u0000\u24d6\u24d7\u0007\f\u0000"+ + "\u0000\u24d7\u05d4\u0001\u0000\u0000\u0000\u24d8\u24d9\u0007\u0003\u0000"+ + "\u0000\u24d9\u24da\u0007\b\u0000\u0000\u24da\u24db\u0007\u0017\u0000\u0000"+ + "\u24db\u24dc\u0007\u000b\u0000\u0000\u24dc\u24dd\u0007\u000e\u0000\u0000"+ + "\u24dd\u24de\u0007\u000f\u0000\u0000\u24de\u24df\u0007\u000f\u0000\u0000"+ + "\u24df\u24e0\u00058\u0000\u0000\u24e0\u05d6\u0001\u0000\u0000\u0000\u24e1"+ + "\u24e2\u0007\u0003\u0000\u0000\u24e2\u24e3\u0007\u000b\u0000\u0000\u24e3"+ + "\u24e4\u0007\u000e\u0000\u0000\u24e4\u24e5\u0007\u000f\u0000\u0000\u24e5"+ + "\u24e6\u0007\u000f\u0000\u0000\u24e6\u05d8\u0001\u0000\u0000\u0000\u24e7"+ + "\u24e8\u0007\u0010\u0000\u0000\u24e8\u24e9\u0007\u000f\u0000\u0000\u24e9"+ + "\u24ea\u0007\u0016\u0000\u0000\u24ea\u24eb\u00055\u0000\u0000\u24eb\u05da"+ + "\u0001\u0000\u0000\u0000\u24ec\u24ed\u0007\u000e\u0000\u0000\u24ed\u24ee"+ + "\u0007\u0019\u0000\u0000\u24ee\u24ef\u00051\u0000\u0000\u24ef\u24f0\u0005"+ + "2\u0000\u0000\u24f0\u24f1\u00055\u0000\u0000\u24f1\u24f2\u00050\u0000"+ + "\u0000\u24f2\u05dc\u0001\u0000\u0000\u0000\u24f3\u24f4\u0007\u000e\u0000"+ + "\u0000\u24f4\u24f5\u0007\u0019\u0000\u0000\u24f5\u24f6\u00051\u0000\u0000"+ + "\u24f6\u24f7\u00052\u0000\u0000\u24f7\u24f8\u00055\u0000\u0000\u24f8\u24f9"+ + "\u00051\u0000\u0000\u24f9\u05de\u0001\u0000\u0000\u0000\u24fa\u24fb\u0007"+ + "\u000e\u0000\u0000\u24fb\u24fc\u0007\u0019\u0000\u0000\u24fc\u24fd\u0005"+ + "1\u0000\u0000\u24fd\u24fe\u00052\u0000\u0000\u24fe\u24ff\u00055\u0000"+ + "\u0000\u24ff\u2500\u00056\u0000\u0000\u2500\u05e0\u0001\u0000\u0000\u0000"+ + "\u2501\u2502\u0007\u000e\u0000\u0000\u2502\u2503\u0007\u0019\u0000\u0000"+ + "\u2503\u2504\u00051\u0000\u0000\u2504\u2505\u00052\u0000\u0000\u2505\u2506"+ + "\u00055\u0000\u0000\u2506\u2507\u00057\u0000\u0000\u2507\u05e2\u0001\u0000"+ + "\u0000\u0000\u2508\u2509\u0007\u000e\u0000\u0000\u2509\u250a\u0007\u0019"+ + "\u0000\u0000\u250a\u250b\u00058\u0000\u0000\u250b\u250c\u00055\u0000\u0000"+ + "\u250c\u250d\u00050\u0000\u0000\u250d\u05e4\u0001\u0000\u0000\u0000\u250e"+ + "\u250f\u0007\u000e\u0000\u0000\u250f\u2510\u0007\u0019\u0000\u0000\u2510"+ + "\u2511\u00058\u0000\u0000\u2511\u2512\u00055\u0000\u0000\u2512\u2513\u0005"+ + "2\u0000\u0000\u2513\u05e6\u0001\u0000\u0000\u0000\u2514\u2515\u0007\u000e"+ + "\u0000\u0000\u2515\u2516\u0007\u0019\u0000\u0000\u2516\u2517\u00058\u0000"+ + "\u0000\u2517\u2518\u00056\u0000\u0000\u2518\u2519\u00056\u0000\u0000\u2519"+ + "\u05e8\u0001\u0000\u0000\u0000\u251a\u251b\u0007\u000e\u0000\u0000\u251b"+ + "\u251c\u0007\u0019\u0000\u0000\u251c\u251d\u00059\u0000\u0000\u251d\u251e"+ + "\u00053\u0000\u0000\u251e\u251f\u00052\u0000\u0000\u251f\u05ea\u0001\u0000"+ + "\u0000\u0000\u2520\u2521\u0007\u0004\u0000\u0000\u2521\u2522\u0007\u0007"+ + "\u0000\u0000\u2522\u2523\u0007\u000e\u0000\u0000\u2523\u2524\u00058\u0000"+ + "\u0000\u2524\u05ec\u0001\u0000\u0000\u0000\u2525\u2526\u0007\u0007\u0000"+ + "\u0000\u2526\u2527\u0007\u0011\u0000\u0000\u2527\u2528\u0007\u000e\u0000"+ + "\u0000\u2528\u2529\u0007\u001b\u0000\u0000\u2529\u252a\u0007\u0019\u0000"+ + "\u0000\u252a\u252b\u0007\u0017\u0000\u0000\u252b\u252c\u0007\u000b\u0000"+ + "\u0000\u252c\u05ee\u0001\u0000\u0000\u0000\u252d\u252e\u0007\u0007\u0000"+ + "\u0000\u252e\u252f\u0007\u0011\u0000\u0000\u252f\u2530\u0007\u000e\u0000"+ + "\u0000\u2530\u2531\u0007\u0015\u0000\u0000\u2531\u2532\u0007\b\u0000\u0000"+ + "\u2532\u05f0\u0001\u0000\u0000\u0000\u2533\u2534\u0007\u0016\u0000\u0000"+ + "\u2534\u2535\u0007\u0010\u0000\u0000\u2535\u2536\u00051\u0000\u0000\u2536"+ + "\u2537\u00058\u0000\u0000\u2537\u2538\u00050\u0000\u0000\u2538\u2539\u0005"+ + "3\u0000\u0000\u2539\u253a\u00050\u0000\u0000\u253a\u05f2\u0001\u0000\u0000"+ + "\u0000\u253b\u253c\u0007\u0016\u0000\u0000\u253c\u253d\u0007\u0010\u0000"+ + "\u0000\u253d\u253e\u00052\u0000\u0000\u253e"; + private static final String _serializedATNSegment4 = + "\u253f\u00053\u0000\u0000\u253f\u2540\u00051\u0000\u0000\u2540\u2541\u0005"+ + "2\u0000\u0000\u2541\u05f4\u0001\u0000\u0000\u0000\u2542\u2543\u0007\u0016"+ + "\u0000\u0000\u2543\u2544\u0007\u0010\u0000\u0000\u2544\u2545\u0007\u0015"+ + "\u0000\u0000\u2545\u05f6\u0001\u0000\u0000\u0000\u2546\u2547\u0007\u0016"+ + "\u0000\u0000\u2547\u2548\u0007\u0007\u0000\u0000\u2548\u2549\u0007\u0013"+ + "\u0000\u0000\u2549\u254a\u0007\u000b\u0000\u0000\u254a\u254b\u0007\u0006"+ + "\u0000\u0000\u254b\u254c\u0007\u0004\u0000\u0000\u254c\u254d\u00058\u0000"+ + "\u0000\u254d\u05f8\u0001\u0000\u0000\u0000\u254e\u254f\u0007\u0016\u0000"+ + "\u0000\u254f\u2550\u0007\b\u0000\u0000\u2550\u2551\u0007\u0007\u0000\u0000"+ + "\u2551\u2552\u0007\u0007\u0000\u0000\u2552\u2553\u0007\u0015\u0000\u0000"+ + "\u2553\u05fa\u0001\u0000\u0000\u0000\u2554\u2555\u0007\u0014\u0000\u0000"+ + "\u2555\u2556\u0007\u0007\u0000\u0000\u2556\u2557\u0007\u0010\u0000\u0000"+ + "\u2557\u2558\u0007\b\u0000\u0000\u2558\u2559\u0007\u0007\u0000\u0000\u2559"+ + "\u255a\u0007\t\u0000\u0000\u255a\u05fc\u0001\u0000\u0000\u0000\u255b\u255c"+ + "\u0007\u0014\u0000\u0000\u255c\u255d\u0007\u0019\u0000\u0000\u255d\u255e"+ + "\u00058\u0000\u0000\u255e\u05fe\u0001\u0000\u0000\u0000\u255f\u2560\u0007"+ + "\u0015\u0000\u0000\u2560\u2561\u0007\u0007\u0000\u0000\u2561\u2562\u0007"+ + "\n\u0000\u0000\u2562\u2563\u0007\u0010\u0000\u0000\u2563\u2564\u0007\u000e"+ + "\u0000\u0000\u2564\u2565\u0007\u000b\u0000\u0000\u2565\u2566\u00052\u0000"+ + "\u0000\u2566\u0600\u0001\u0000\u0000\u0000\u2567\u2568\u0007\u0015\u0000"+ + "\u0000\u2568\u2569\u0007\u0013\u0000\u0000\u2569\u256a\u0007\u000f\u0000"+ + "\u0000\u256a\u256b\u00058\u0000\u0000\u256b\u256c\u0007\b\u0000\u0000"+ + "\u256c\u0602\u0001\u0000\u0000\u0000\u256d\u256e\u0007\u0015\u0000\u0000"+ + "\u256e\u256f\u0007\u0013\u0000\u0000\u256f\u2570\u0007\u000f\u0000\u0000"+ + "\u2570\u2571\u00058\u0000\u0000\u2571\u2572\u0007\u0011\u0000\u0000\u2572"+ + "\u0604\u0001\u0000\u0000\u0000\u2573\u2574\u0007\u0005\u0000\u0000\u2574"+ + "\u2575\u0007\u0003\u0000\u0000\u2575\u2576\u0007\u0006\u0000\u0000\u2576"+ + "\u2577\u0007\u000f\u0000\u0000\u2577\u2578\u0007\f\u0000\u0000\u2578\u2579"+ + "\u00051\u0000\u0000\u2579\u0606\u0001\u0000\u0000\u0000\u257a\u257b\u0007"+ + "\u0005\u0000\u0000\u257b\u257c\u0007\u0003\u0000\u0000\u257c\u257d\u0007"+ + "\u0006\u0000\u0000\u257d\u257e\u0007\u000f\u0000\u0000\u257e\u257f\u0007"+ + "\f\u0000\u0000\u257f\u2580\u00052\u0000\u0000\u2580\u0608\u0001\u0000"+ + "\u0000\u0000\u2581\u2582\u0007\u0005\u0000\u0000\u2582\u2583\u0007\u0003"+ + "\u0000\u0000\u2583\u2584\u0007\u0006\u0000\u0000\u2584\u2585\u0007\u000f"+ + "\u0000\u0000\u2585\u2586\u0007\f\u0000\u0000\u2586\u2587\u00055\u0000"+ + "\u0000\u2587\u060a\u0001\u0000\u0000\u0000\u2588\u2589\u0007\u0005\u0000"+ + "\u0000\u2589\u258a\u0007\u0003\u0000\u0000\u258a\u258b\u0007\u0006\u0000"+ + "\u0000\u258b\u258c\u0007\u000f\u0000\u0000\u258c\u258d\u0007\f\u0000\u0000"+ + "\u258d\u258e\u00057\u0000\u0000\u258e\u060c\u0001\u0000\u0000\u0000\u258f"+ + "\u2590\u0007\u0017\u0000\u0000\u2590\u2591\u0007\u0003\u0000\u0000\u2591"+ + "\u2592\u0007\u000e\u0000\u0000\u2592\u2593\u0007\u000e\u0000\u0000\u2593"+ + "\u2594\u0007\u0007\u0000\u0000\u2594\u060e\u0001\u0000\u0000\u0000\u2595"+ + "\u2596\u0007\u0017\u0000\u0000\u2596\u2597\u0007\u0003\u0000\u0000\u2597"+ + "\u2598\u0007\u000e\u0000\u0000\u2598\u2599\u0007\b\u0000\u0000\u2599\u259a"+ + "\u0007\u0013\u0000\u0000\u259a\u259b\u0007\u0017\u0000\u0000\u259b\u259c"+ + "\u0007\u0003\u0000\u0000\u259c\u259d\u0007\f\u0000\u0000\u259d\u0610\u0001"+ + "\u0000\u0000\u0000\u259e\u259f\u0007\u000b\u0000\u0000\u259f\u25a0\u0007"+ + "\u001b\u0000\u0000\u25a0\u25a1\u0007\u000f\u0000\u0000\u25a1\u25a2\u0007"+ + "\u000b\u0000\u0000\u25a2\u0612\u0001\u0000\u0000\u0000\u25a3\u25a4\u0007"+ + "\u000b\u0000\u0000\u25a4\u25a5\u0007\t\u0000\u0000\u25a5\u25a6\u0007\u0007"+ + "\u0000\u0000\u25a6\u25a7\u00057\u0000\u0000\u25a7\u0614\u0001\u0000\u0000"+ + "\u0000\u25a8\u25a9\u0007\u0006\u0000\u0000\u25a9\u25aa\u0007\u000f\u0000"+ + "\u0000\u25aa\u25ab\u0007\u000b\u0000\u0000\u25ab\u25ac\u00056\u0000\u0000"+ + "\u25ac\u25ad\u00052\u0000\u0000\u25ad\u25ae\u00050\u0000\u0000\u25ae\u0616"+ + "\u0001\u0000\u0000\u0000\u25af\u25b0\u0007\u0011\u0000\u0000\u25b0\u25b1"+ + "\u0007\u000e\u0000\u0000\u25b1\u25b2\u0007\u000b\u0000\u0000\u25b2\u25b3"+ + "\u00052\u0000\u0000\u25b3\u0618\u0001\u0000\u0000\u0000\u25b4\u25b5\u0007"+ + "\u0011\u0000\u0000\u25b5\u25b6\u0007\u001b\u0000\u0000\u25b6\u25b7\u0007"+ + "\u000f\u0000\u0000\u25b7\u25b8\u0007\u000b\u0000\u0000\u25b8\u061a\u0001"+ + "\u0000\u0000\u0000\u25b9\u25ba\u0007\u0011\u0000\u0000\u25ba\u25bb\u0007"+ + "\u0006\u0000\u0000\u25bb\u25bc\u0007\u0012\u0000\u0000\u25bc\u25bd\u0005"+ + "1\u0000\u0000\u25bd\u25be\u00056\u0000\u0000\u25be\u061c\u0001\u0000\u0000"+ + "\u0000\u25bf\u25c0\u0007\u0011\u0000\u0000\u25c0\u25c1\u0007\u0006\u0000"+ + "\u0000\u25c1\u25c2\u0007\u0012\u0000\u0000\u25c2\u25c3\u00051\u0000\u0000"+ + "\u25c3\u25c4\u00056\u0000\u0000\u25c4\u25c5\u0007\u0005\u0000\u0000\u25c5"+ + "\u25c6\u0007\u0007\u0000\u0000\u25c6\u061e\u0001\u0000\u0000\u0000\u25c7"+ + "\u25c8\u0007\u0011\u0000\u0000\u25c8\u25c9\u0007\u0006\u0000\u0000\u25c9"+ + "\u25ca\u0007\u0012\u0000\u0000\u25ca\u25cb\u00053\u0000\u0000\u25cb\u25cc"+ + "\u00052\u0000\u0000\u25cc\u0620\u0001\u0000\u0000\u0000\u25cd\u25ce\u0007"+ + "\u0011\u0000\u0000\u25ce\u25cf\u0007\u0006\u0000\u0000\u25cf\u25d0\u0007"+ + "\u0012\u0000\u0000\u25d0\u25d1\u00058\u0000\u0000\u25d1\u0622\u0001\u0000"+ + "\u0000\u0000\u25d2\u25d3\u0007\u0011\u0000\u0000\u25d3\u25d4\u0007\u0006"+ + "\u0000\u0000\u25d4\u25d5\u0007\u0012\u0000\u0000\u25d5\u25d6\u00058\u0000"+ + "\u0000\u25d6\u25d7\u0007\u0017\u0000\u0000\u25d7\u25d8\u0007\u0010\u0000"+ + "\u0000\u25d8\u25d9\u00053\u0000\u0000\u25d9\u0624\u0001\u0000\u0000\u0000"+ + "\u25da\u25db\u0007\u0011\u0000\u0000\u25db\u25dc\u0007\u0006\u0000\u0000"+ + "\u25dc\u25dd\u0007\u0012\u0000\u0000\u25dd\u25de\u00058\u0000\u0000\u25de"+ + "\u25df\u0007\u0017\u0000\u0000\u25df\u25e0\u0007\u0010\u0000\u0000\u25e0"+ + "\u25e1\u00054\u0000\u0000\u25e1\u0626\u0001\u0000\u0000\u0000\u25e2\u25e3"+ + "\u0007\u0003\u0000\u0000\u25e3\u25e4\u0007\b\u0000\u0000\u25e4\u25e5\u0007"+ + "\u000e\u0000\u0000\u25e5\u25e6\u0007\u0014\u0000\u0000\u25e6\u25e7\u0007"+ + "\u000f\u0000\u0000\u25e7\u25e8\u0007\u0018\u0000\u0000\u25e8\u25e9\u0007"+ + "\u0007\u0000\u0000\u25e9\u0628\u0001\u0000\u0000\u0000\u25ea\u25eb\u0007"+ + "\u0010\u0000\u0000\u25eb\u25ec\u0007\u0005\u0000\u0000\u25ec\u25ed\u0007"+ + "\u0003\u0000\u0000\u25ed\u25ee\u0007\u000e\u0000\u0000\u25ee\u25ef\u0007"+ + "\u0015\u0000\u0000\u25ef\u25f0\u0007\u0014\u0000\u0000\u25f0\u25f1\u0007"+ + "\u0013\u0000\u0000\u25f1\u25f2\u0007\u0005\u0000\u0000\u25f2\u25f3\u0007"+ + "\u0007\u0000\u0000\u25f3\u062a\u0001\u0000\u0000\u0000\u25f4\u25f5\u0007"+ + "\u000e\u0000\u0000\u25f5\u25f6\u0007\u000b\u0000\u0000\u25f6\u25f7\u0007"+ + "\u0018\u0000\u0000\u25f7\u062c\u0001\u0000\u0000\u0000\u25f8\u25f9\u0007"+ + "\u0012\u0000\u0000\u25f9\u25fa\u0007\u0007\u0000\u0000\u25fa\u25fb\u0007"+ + "\u0004\u0000\u0000\u25fb\u25fc\u0007\u0007\u0000\u0000\u25fc\u25fd\u0007"+ + "\b\u0000\u0000\u25fd\u25fe\u0007\u0003\u0000\u0000\u25fe\u25ff\u0007\u0006"+ + "\u0000\u0000\u25ff\u2600\u0007\u0007\u0000\u0000\u2600\u2601\u0007\u0004"+ + "\u0000\u0000\u2601\u062e\u0001\u0000\u0000\u0000\u2602\u2603\u0007\u000f"+ + "\u0000\u0000\u2603\u2604\u0007\f\u0000\u0000\u2604\u2605\u0007\f\u0000"+ + "\u0000\u2605\u2606\u0007\u0013\u0000\u0000\u2606\u2607\u0007\u0004\u0000"+ + "\u0000\u2607\u2608\u0007\u0010\u0000\u0000\u2608\u0630\u0001\u0000\u0000"+ + "\u0000\u2609\u260a\u0007\u0017\u0000\u0000\u260a\u260b\u0007\u0007\u0000"+ + "\u0000\u260b\u260c\u0007\u0017\u0000\u0000\u260c\u260d\u0007\u0013\u0000"+ + "\u0000\u260d\u260e\u0007\b\u0000\u0000\u260e\u260f\u0007\n\u0000\u0000"+ + "\u260f\u0632\u0001\u0000\u0000\u0000\u2610\u2611\u0007\u0017\u0000\u0000"+ + "\u2611\u2612\u0007\b\u0000\u0000\u2612\u2613\u0007\u0016\u0000\u0000\u2613"+ + "\u2614\u0005_\u0000\u0000\u2614\u2615\u0007\u0017\u0000\u0000\u2615\u2616"+ + "\u0007\n\u0000\u0000\u2616\u2617\u0007\u000f\u0000\u0000\u2617\u2618\u0007"+ + "\u000b\u0000\u0000\u2618\u2619\u0007\u0003\u0000\u0000\u2619\u261a\u0007"+ + "\u0017\u0000\u0000\u261a\u0634\u0001\u0000\u0000\u0000\u261b\u261c\u0007"+ + "\u0017\u0000\u0000\u261c\u261d\u0007\n\u0000\u0000\u261d\u261e\u0007\u000f"+ + "\u0000\u0000\u261e\u261f\u0007\u000b\u0000\u0000\u261f\u2620\u0007\u0003"+ + "\u0000\u0000\u2620\u2621\u0007\u0017\u0000\u0000\u2621\u0636\u0001\u0000"+ + "\u0000\u0000\u2622\u2623\u0007\f\u0000\u0000\u2623\u2624\u0007\u0004\u0000"+ + "\u0000\u2624\u2625\u0007\u0010\u0000\u0000\u2625\u0638\u0001\u0000\u0000"+ + "\u0000\u2626\u2627\u0007\f\u0000\u0000\u2627\u2628\u0007\u0004\u0000\u0000"+ + "\u2628\u2629\u0007\u0010\u0000\u0000\u2629\u262a\u0007\u000e\u0000\u0000"+ + "\u262a\u262b\u0007\u0005\u0000\u0000\u262b\u262c\u0007\u0011\u0000\u0000"+ + "\u262c\u262d\u0007\u000b\u0000\u0000\u262d\u262e\u0007\u0006\u0000\u0000"+ + "\u262e\u262f\u0007\u0007\u0000\u0000\u262f\u2630\u0007\b\u0000\u0000\u2630"+ + "\u063a\u0001\u0000\u0000\u0000\u2631\u2632\u0007\u0019\u0000\u0000\u2632"+ + "\u2633\u0007\u0007\u0000\u0000\u2633\u2634\u0007\b\u0000\u0000\u2634\u2635"+ + "\u0007\u0012\u0000\u0000\u2635\u2636\u0007\u0013\u0000\u0000\u2636\u2637"+ + "\u0007\b\u0000\u0000\u2637\u2638\u0007\u0017\u0000\u0000\u2638\u2639\u0007"+ + "\u0003\u0000\u0000\u2639\u263a\u0007\f\u0000\u0000\u263a\u263b\u0007\u000e"+ + "\u0000\u0000\u263b\u263c\u0007\u0007\u0000\u0000\u263c\u263d\u0005_\u0000"+ + "\u0000\u263d\u263e\u0007\u000b\u0000\u0000\u263e\u263f\u0007\u000e\u0000"+ + "\u0000\u263f\u2640\u0007\u0014\u0000\u0000\u2640\u2641\u0007\u0007\u0000"+ + "\u0000\u2641\u2642\u0007\u0017\u0000\u0000\u2642\u2643\u0007\u0003\u0000"+ + "\u0000\u2643\u063c\u0001\u0000\u0000\u0000\u2644\u2645\u0007\u0006\u0000"+ + "\u0000\u2645\u2646\u0007\u0013\u0000\u0000\u2646\u2647\u0007\u0015\u0000"+ + "\u0000\u2647\u2648\u0007\u0011\u0000\u0000\u2648\u2649\u0007\u0004\u0000"+ + "\u0000\u2649\u264a\u0007\u0010\u0000\u0000\u264a\u063e\u0001\u0000\u0000"+ + "\u0000\u264b\u264c\u0007\b\u0000\u0000\u264c\u264d\u0007\u0007\u0000\u0000"+ + "\u264d\u264e\u0007\u0019\u0000\u0000\u264e\u264f\u0007\u0007\u0000\u0000"+ + "\u264f\u2650\u0007\u0003\u0000\u0000\u2650\u2651\u0007\u0006\u0000\u0000"+ + "\u2651\u2652\u0007\u0003\u0000\u0000\u2652\u2653\u0007\u0010\u0000\u0000"+ + "\u2653\u2654\u0007\u0005\u0000\u0000\u2654\u2655\u0007\u0007\u0000\u0000"+ + "\u2655\u0640\u0001\u0000\u0000\u0000\u2656\u2657\u0007\u000e\u0000\u0000"+ + "\u2657\u2658\u0007\u0013\u0000\u0000\u2658\u2659\u0007\u0017\u0000\u0000"+ + "\u2659\u265a\u0007\u0017\u0000\u0000\u265a\u265b\u0007\u000f\u0000\u0000"+ + "\u265b\u265c\u0007\u0006\u0000\u0000\u265c\u265d\u0007\u0006\u0000\u0000"+ + "\u265d\u265e\u0007\u0007\u0000\u0000\u265e\u265f\u0007\u0004\u0000\u0000"+ + "\u265f\u0642\u0001\u0000\u0000\u0000\u2660\u2661\u0007\u0011\u0000\u0000"+ + "\u2661\u2662\u0007\f\u0000\u0000\u2662\u2663\u0007\u000e\u0000\u0000\u2663"+ + "\u2664\u0007\u0013\u0000\u0000\u2664\u2665\u0007\u0017\u0000\u0000\u2665"+ + "\u2666\u0007\u0017\u0000\u0000\u2666\u2667\u0007\u000f\u0000\u0000\u2667"+ + "\u2668\u0007\u0006\u0000\u0000\u2668\u2669\u0007\u0006\u0000\u0000\u2669"+ + "\u266a\u0007\u0007\u0000\u0000\u266a\u266b\u0007\u0004\u0000\u0000\u266b"+ + "\u0644\u0001\u0000\u0000\u0000\u266c\u266d\u0007\u000b\u0000\u0000\u266d"+ + "\u266e\u0007\u0007\u0000\u0000\u266e\u266f\u0007\b\u0000\u0000\u266f\u2670"+ + "\u0007\u000f\u0000\u0000\u2670\u2671\u0007\u0003\u0000\u0000\u2671\u2672"+ + "\u0007\u0005\u0000\u0000\u2672\u2673\u0007\u000f\u0000\u0000\u2673\u2674"+ + "\u0007\r\u0000\u0000\u2674\u2675\u0007\u0003\u0000\u0000\u2675\u2676\u0007"+ + "\u0010\u0000\u0000\u2676\u2677\u0007\u0005\u0000\u0000\u2677\u2678\u0007"+ + "\u0007\u0000\u0000\u2678\u0646\u0001\u0000\u0000\u0000\u2679\u267a\u0007"+ + "\u0016\u0000\u0000\u267a\u267b\u0007\u0007\u0000\u0000\u267b\u267c\u0007"+ + "\u0013\u0000\u0000\u267c\u267d\u0007\u0017\u0000\u0000\u267d\u267e\u0007"+ + "\u0007\u0000\u0000\u267e\u267f\u0007\u0006\u0000\u0000\u267f\u2680\u0007"+ + "\b\u0000\u0000\u2680\u2681\u0007\n\u0000\u0000\u2681\u2682\u0007\u000e"+ + "\u0000\u0000\u2682\u2683\u0007\u0013\u0000\u0000\u2683\u2684\u0007\u0005"+ + "\u0000\u0000\u2684\u2685\u0007\u0005\u0000\u0000\u2685\u2686\u0007\u0007"+ + "\u0000\u0000\u2686\u2687\u0007\u000e\u0000\u0000\u2687\u2688\u0007\u0006"+ + "\u0000\u0000\u2688\u2689\u0007\u000f\u0000\u0000\u2689\u268a\u0007\u0013"+ + "\u0000\u0000\u268a\u268b\u0007\f\u0000\u0000\u268b\u0648\u0001\u0000\u0000"+ + "\u0000\u268c\u268d\u0007\u0016\u0000\u0000\u268d\u268e\u0007\u0007\u0000"+ + "\u0000\u268e\u268f\u0007\u0013\u0000\u0000\u268f\u2690\u0007\u0017\u0000"+ + "\u0000\u2690\u2691\u0007\u000e\u0000\u0000\u2691\u2692\u0007\u0013\u0000"+ + "\u0000\u2692\u2693\u0007\u0005\u0000\u0000\u2693\u2694\u0007\u0005\u0000"+ + "\u0000\u2694\u2695\u0007\u0007\u0000\u0000\u2695\u2696\u0007\u000e\u0000"+ + "\u0000\u2696\u2697\u0007\u0006\u0000\u0000\u2697\u2698\u0007\u000f\u0000"+ + "\u0000\u2698\u2699\u0007\u0013\u0000\u0000\u2699\u269a\u0007\f\u0000\u0000"+ + "\u269a\u064a\u0001\u0000\u0000\u0000\u269b\u269c\u0007\u0016\u0000\u0000"+ + "\u269c\u269d\u0007\u0007\u0000\u0000\u269d\u269e\u0007\u0013\u0000\u0000"+ + "\u269e\u269f\u0007\u0017\u0000\u0000\u269f\u26a0\u0007\u0007\u0000\u0000"+ + "\u26a0\u26a1\u0007\u0006\u0000\u0000\u26a1\u26a2\u0007\b\u0000\u0000\u26a2"+ + "\u26a3\u0007\n\u0000\u0000\u26a3\u064c\u0001\u0000\u0000\u0000\u26a4\u26a5"+ + "\u0007\u0005\u0000\u0000\u26a5\u26a6\u0007\u000f\u0000\u0000\u26a6\u26a7"+ + "\u0007\f\u0000\u0000\u26a7\u26a8\u0007\u0007\u0000\u0000\u26a8\u26a9\u0007"+ + "\u000b\u0000\u0000\u26a9\u26aa\u0007\u0006\u0000\u0000\u26aa\u26ab\u0007"+ + "\b\u0000\u0000\u26ab\u26ac\u0007\u000f\u0000\u0000\u26ac\u26ad\u0007\f"+ + "\u0000\u0000\u26ad\u26ae\u0007\u0016\u0000\u0000\u26ae\u064e\u0001\u0000"+ + "\u0000\u0000\u26af\u26b0\u0007\u0017\u0000\u0000\u26b0\u26b1\u0007\u0011"+ + "\u0000\u0000\u26b1\u26b2\u0007\u0005\u0000\u0000\u26b2\u26b3\u0007\u0006"+ + "\u0000\u0000\u26b3\u26b4\u0007\u000f\u0000\u0000\u26b4\u26b5\u0007\u0005"+ + "\u0000\u0000\u26b5\u26b6\u0007\u000f\u0000\u0000\u26b6\u26b7\u0007\f\u0000"+ + "\u0000\u26b7\u26b8\u0007\u0007\u0000\u0000\u26b8\u26b9\u0007\u000b\u0000"+ + "\u0000\u26b9\u26ba\u0007\u0006\u0000\u0000\u26ba\u26bb\u0007\b\u0000\u0000"+ + "\u26bb\u26bc\u0007\u000f\u0000\u0000\u26bc\u26bd\u0007\f\u0000\u0000\u26bd"+ + "\u26be\u0007\u0016\u0000\u0000\u26be\u0650\u0001\u0000\u0000\u0000\u26bf"+ + "\u26c0\u0007\u0017\u0000\u0000\u26c0\u26c1\u0007\u0011\u0000\u0000\u26c1"+ + "\u26c2\u0007\u0005\u0000\u0000\u26c2\u26c3\u0007\u0006\u0000\u0000\u26c3"+ + "\u26c4\u0007\u000f\u0000\u0000\u26c4\u26c5\u0007\u0019\u0000\u0000\u26c5"+ + "\u26c6\u0007\u0013\u0000\u0000\u26c6\u26c7\u0007\u000f\u0000\u0000\u26c7"+ + "\u26c8\u0007\f\u0000\u0000\u26c8\u26c9\u0007\u0006\u0000\u0000\u26c9\u0652"+ + "\u0001\u0000\u0000\u0000\u26ca\u26cb\u0007\u0017\u0000\u0000\u26cb\u26cc"+ + "\u0007\u0011\u0000\u0000\u26cc\u26cd\u0007\u0005\u0000\u0000\u26cd\u26ce"+ + "\u0007\u0006\u0000\u0000\u26ce\u26cf\u0007\u000f\u0000\u0000\u26cf\u26d0"+ + "\u0007\u0019\u0000\u0000\u26d0\u26d1\u0007\u0013\u0000\u0000\u26d1\u26d2"+ + "\u0007\u0005\u0000\u0000\u26d2\u26d3\u0007\n\u0000\u0000\u26d3\u26d4\u0007"+ + "\u0016\u0000\u0000\u26d4\u26d5\u0007\u0013\u0000\u0000\u26d5\u26d6\u0007"+ + "\f\u0000\u0000\u26d6\u0654\u0001\u0000\u0000\u0000\u26d7\u26d8\u0007\u0019"+ + "\u0000\u0000\u26d8\u26d9\u0007\u0013\u0000\u0000\u26d9\u26da\u0007\u000f"+ + "\u0000\u0000\u26da\u26db\u0007\f\u0000\u0000\u26db\u26dc\u0007\u0006\u0000"+ + "\u0000\u26dc\u0656\u0001\u0000\u0000\u0000\u26dd\u26de\u0007\u0019\u0000"+ + "\u0000\u26de\u26df\u0007\u0013\u0000\u0000\u26df\u26e0\u0007\u0005\u0000"+ + "\u0000\u26e0\u26e1\u0007\n\u0000\u0000\u26e1\u26e2\u0007\u0016\u0000\u0000"+ + "\u26e2\u26e3\u0007\u0013\u0000\u0000\u26e3\u26e4\u0007\f\u0000\u0000\u26e4"+ + "\u0658\u0001\u0000\u0000\u0000\u26e5\u26e6\u0007\u0003\u0000\u0000\u26e6"+ + "\u26e7\u0007\u0010\u0000\u0000\u26e7\u26e8\u0007\u000b\u0000\u0000\u26e8"+ + "\u065a\u0001\u0000\u0000\u0000\u26e9\u26ea\u0007\u0003\u0000\u0000\u26ea"+ + "\u26eb\u0007\u000e\u0000\u0000\u26eb\u26ec\u0007\u0013\u0000\u0000\u26ec"+ + "\u26ed\u0007\u000b\u0000\u0000\u26ed\u065c\u0001\u0000\u0000\u0000\u26ee"+ + "\u26ef\u0007\u0003\u0000\u0000\u26ef\u26f0\u0007\u0004\u0000\u0000\u26f0"+ + "\u26f1\u0007\u0004\u0000\u0000\u26f1\u26f2\u0007\u0004\u0000\u0000\u26f2"+ + "\u26f3\u0007\u0003\u0000\u0000\u26f3\u26f4\u0007\u0006\u0000\u0000\u26f4"+ + "\u26f5\u0007\u0007\u0000\u0000\u26f5\u065e\u0001\u0000\u0000\u0000\u26f6"+ + "\u26f7\u0007\u0003\u0000\u0000\u26f7\u26f8\u0007\u0004\u0000\u0000\u26f8"+ + "\u26f9\u0007\u0004\u0000\u0000\u26f9\u26fa\u0007\u0006\u0000\u0000\u26fa"+ + "\u26fb\u0007\u000f\u0000\u0000\u26fb\u26fc\u0007\u0017\u0000\u0000\u26fc"+ + "\u26fd\u0007\u0007\u0000\u0000\u26fd\u0660\u0001\u0000\u0000\u0000\u26fe"+ + "\u26ff\u0007\u0003\u0000\u0000\u26ff\u2700\u0007\u0007\u0000\u0000\u2700"+ + "\u2701\u0007\u000b\u0000\u0000\u2701\u2702\u0005_\u0000\u0000\u2702\u2703"+ + "\u0007\u0004\u0000\u0000\u2703\u2704\u0007\u0007\u0000\u0000\u2704\u2705"+ + "\u0007\u000e\u0000\u0000\u2705\u2706\u0007\b\u0000\u0000\u2706\u2707\u0007"+ + "\n\u0000\u0000\u2707\u2708\u0007\u0019\u0000\u0000\u2708\u2709\u0007\u0006"+ + "\u0000\u0000\u2709\u0662\u0001\u0000\u0000\u0000\u270a\u270b\u0007\u0003"+ + "\u0000\u0000\u270b\u270c\u0007\u0007\u0000\u0000\u270c\u270d\u0007\u000b"+ + "\u0000\u0000\u270d\u270e\u0005_\u0000\u0000\u270e\u270f\u0007\u0007\u0000"+ + "\u0000\u270f\u2710\u0007\f\u0000\u0000\u2710\u2711\u0007\u000e\u0000\u0000"+ + "\u2711\u2712\u0007\b\u0000\u0000\u2712\u2713\u0007\n\u0000\u0000\u2713"+ + "\u2714\u0007\u0019\u0000\u0000\u2714\u2715\u0007\u0006\u0000\u0000\u2715"+ + "\u0664\u0001\u0000\u0000\u0000\u2716\u2717\u0007\u0003\u0000\u0000\u2717"+ + "\u2718\u0007\b\u0000\u0000\u2718\u2719\u0007\u0007\u0000\u0000\u2719\u271a"+ + "\u0007\u0003\u0000\u0000\u271a\u0666\u0001\u0000\u0000\u0000\u271b\u271c"+ + "\u0007\u0003\u0000\u0000\u271c\u271d\u0007\u000b\u0000\u0000\u271d\u271e"+ + "\u0007\u0010\u0000\u0000\u271e\u271f\u0007\u000f\u0000\u0000\u271f\u2720"+ + "\u0007\f\u0000\u0000\u2720\u2721\u0007\u0003\u0000\u0000\u2721\u2722\u0007"+ + "\b\u0000\u0000\u2722\u2723\u0007\n\u0000\u0000\u2723\u0668\u0001\u0000"+ + "\u0000\u0000\u2724\u2725\u0007\u0003\u0000\u0000\u2725\u2726\u0007\u000b"+ + "\u0000\u0000\u2726\u2727\u0007\u000f\u0000\u0000\u2727\u2728\u0007\f\u0000"+ + "\u0000\u2728\u066a\u0001\u0000\u0000\u0000\u2729\u272a\u0007\u0003\u0000"+ + "\u0000\u272a\u272b\u0007\u000b\u0000\u0000\u272b\u272c\u0007\u0006\u0000"+ + "\u0000\u272c\u272d\u0007\u0007\u0000\u0000\u272d\u272e\u0007\u001a\u0000"+ + "\u0000\u272e\u272f\u0007\u0006\u0000\u0000\u272f\u066c\u0001\u0000\u0000"+ + "\u0000\u2730\u2731\u0007\u0003\u0000\u0000\u2731\u2732\u0007\u000b\u0000"+ + "\u0000\u2732\u2733\u0007\t\u0000\u0000\u2733\u2734\u0007\u0015\u0000\u0000"+ + "\u2734\u2735\u0007\u0010\u0000\u0000\u2735\u066e\u0001\u0000\u0000\u0000"+ + "\u2736\u2737\u0007\u0003\u0000\u0000\u2737\u2738\u0007\u000b\u0000\u0000"+ + "\u2738\u2739\u0007\t\u0000\u0000\u2739\u273a\u0007\u0015\u0000\u0000\u273a"+ + "\u273b\u0007\u0006\u0000\u0000\u273b\u0670\u0001\u0000\u0000\u0000\u273c"+ + "\u273d\u0007\u0003\u0000\u0000\u273d\u273e\u0007\u000b\u0000\u0000\u273e"+ + "\u273f\u0007\n\u0000\u0000\u273f\u2740\u0007\u0017\u0000\u0000\u2740\u2741"+ + "\u0007\u0017\u0000\u0000\u2741\u2742\u0007\u0007\u0000\u0000\u2742\u2743"+ + "\u0007\u0006\u0000\u0000\u2743\u2744\u0007\b\u0000\u0000\u2744\u2745\u0007"+ + "\u000f\u0000\u0000\u2745\u2746\u0007\u000e\u0000\u0000\u2746\u2747\u0005"+ + "_\u0000\u0000\u2747\u2748\u0007\u0004\u0000\u0000\u2748\u2749\u0007\u0007"+ + "\u0000\u0000\u2749\u274a\u0007\u000e\u0000\u0000\u274a\u274b\u0007\b\u0000"+ + "\u0000\u274b\u274c\u0007\n\u0000\u0000\u274c\u274d\u0007\u0019\u0000\u0000"+ + "\u274d\u274e\u0007\u0006\u0000\u0000\u274e\u0672\u0001\u0000\u0000\u0000"+ + "\u274f\u2750\u0007\u0003\u0000\u0000\u2750\u2751\u0007\u000b\u0000\u0000"+ + "\u2751\u2752\u0007\n\u0000\u0000\u2752\u2753\u0007\u0017\u0000\u0000\u2753"+ + "\u2754\u0007\u0017\u0000\u0000\u2754\u2755\u0007\u0007\u0000\u0000\u2755"+ + "\u2756\u0007\u0006\u0000\u0000\u2756\u2757\u0007\b\u0000\u0000\u2757\u2758"+ + "\u0007\u000f\u0000\u0000\u2758\u2759\u0007\u000e\u0000\u0000\u2759\u275a"+ + "\u0005_\u0000\u0000\u275a\u275b\u0007\u0004\u0000\u0000\u275b\u275c\u0007"+ + "\u0007\u0000\u0000\u275c\u275d\u0007\b\u0000\u0000\u275d\u275e\u0007\u000f"+ + "\u0000\u0000\u275e\u275f\u0007\u0018\u0000\u0000\u275f\u2760\u0007\u0007"+ + "\u0000\u0000\u2760\u0674\u0001\u0000\u0000\u0000\u2761\u2762\u0007\u0003"+ + "\u0000\u0000\u2762\u2763\u0007\u000b\u0000\u0000\u2763\u2764\u0007\n\u0000"+ + "\u0000\u2764\u2765\u0007\u0017\u0000\u0000\u2765\u2766\u0007\u0017\u0000"+ + "\u0000\u2766\u2767\u0007\u0007\u0000\u0000\u2767\u2768\u0007\u0006\u0000"+ + "\u0000\u2768\u2769\u0007\b\u0000\u0000\u2769\u276a\u0007\u000f\u0000\u0000"+ + "\u276a\u276b\u0007\u000e\u0000\u0000\u276b\u276c\u0005_\u0000\u0000\u276c"+ + "\u276d\u0007\u0007\u0000\u0000\u276d\u276e\u0007\f\u0000\u0000\u276e\u276f"+ + "\u0007\u000e\u0000\u0000\u276f\u2770\u0007\b\u0000\u0000\u2770\u2771\u0007"+ + "\n\u0000\u0000\u2771\u2772\u0007\u0019\u0000\u0000\u2772\u2773\u0007\u0006"+ + "\u0000\u0000\u2773\u0676\u0001\u0000\u0000\u0000\u2774\u2775\u0007\u0003"+ + "\u0000\u0000\u2775\u2776\u0007\u000b\u0000\u0000\u2776\u2777\u0007\n\u0000"+ + "\u0000\u2777\u2778\u0007\u0017\u0000\u0000\u2778\u2779\u0007\u0017\u0000"+ + "\u0000\u2779\u277a\u0007\u0007\u0000\u0000\u277a\u277b\u0007\u0006\u0000"+ + "\u0000\u277b\u277c\u0007\b\u0000\u0000\u277c\u277d\u0007\u000f\u0000\u0000"+ + "\u277d\u277e\u0007\u000e\u0000\u0000\u277e\u277f\u0005_\u0000\u0000\u277f"+ + "\u2780\u0007\u000b\u0000\u0000\u2780\u2781\u0007\u000f\u0000\u0000\u2781"+ + "\u2782\u0007\u0016\u0000\u0000\u2782\u2783\u0007\f\u0000\u0000\u2783\u0678"+ + "\u0001\u0000\u0000\u0000\u2784\u2785\u0007\u0003\u0000\u0000\u2785\u2786"+ + "\u0007\u000b\u0000\u0000\u2786\u2787\u0007\n\u0000\u0000\u2787\u2788\u0007"+ + "\u0017\u0000\u0000\u2788\u2789\u0007\u0017\u0000\u0000\u2789\u278a\u0007"+ + "\u0007\u0000\u0000\u278a\u278b\u0007\u0006\u0000\u0000\u278b\u278c\u0007"+ + "\b\u0000\u0000\u278c\u278d\u0007\u000f\u0000\u0000\u278d\u278e\u0007\u000e"+ + "\u0000\u0000\u278e\u278f\u0005_\u0000\u0000\u278f\u2790\u0007\u0018\u0000"+ + "\u0000\u2790\u2791\u0007\u0007\u0000\u0000\u2791\u2792\u0007\b\u0000\u0000"+ + "\u2792\u2793\u0007\u000f\u0000\u0000\u2793\u2794\u0007\u0012\u0000\u0000"+ + "\u2794\u2795\u0007\n\u0000\u0000\u2795\u067a\u0001\u0000\u0000\u0000\u2796"+ + "\u2797\u0007\u0003\u0000\u0000\u2797\u2798\u0007\u0006\u0000\u0000\u2798"+ + "\u2799\u0007\u0003\u0000\u0000\u2799\u279a\u0007\f\u0000\u0000\u279a\u067c"+ + "\u0001\u0000\u0000\u0000\u279b\u279c\u0007\u0003\u0000\u0000\u279c\u279d"+ + "\u0007\u0006\u0000\u0000\u279d\u279e\u0007\u0003\u0000\u0000\u279e\u279f"+ + "\u0007\f\u0000\u0000\u279f\u27a0\u00052\u0000\u0000\u27a0\u067e\u0001"+ + "\u0000\u0000\u0000\u27a1\u27a2\u0007\u0010\u0000\u0000\u27a2\u27a3\u0007"+ + "\u0007\u0000\u0000\u27a3\u27a4\u0007\f\u0000\u0000\u27a4\u27a5\u0007\u000e"+ + "\u0000\u0000\u27a5\u27a6\u0007\u0014\u0000\u0000\u27a6\u27a7\u0007\u0017"+ + "\u0000\u0000\u27a7\u27a8\u0007\u0003\u0000\u0000\u27a8\u27a9\u0007\b\u0000"+ + "\u0000\u27a9\u27aa\u0007\u0015\u0000\u0000\u27aa\u0680\u0001\u0000\u0000"+ + "\u0000\u27ab\u27ac\u0007\u0010\u0000\u0000\u27ac\u27ad\u0007\u000f\u0000"+ + "\u0000\u27ad\u27ae\u0007\f\u0000\u0000\u27ae\u0682\u0001\u0000\u0000\u0000"+ + "\u27af\u27b0\u0007\u0010\u0000\u0000\u27b0\u27b1\u0007\u000f\u0000\u0000"+ + "\u27b1\u27b2\u0007\u0006\u0000\u0000\u27b2\u27b3\u0005_\u0000\u0000\u27b3"+ + "\u27b4\u0007\u000e\u0000\u0000\u27b4\u27b5\u0007\u0013\u0000\u0000\u27b5"+ + "\u27b6\u0007\u0011\u0000\u0000\u27b6\u27b7\u0007\f\u0000\u0000\u27b7\u27b8"+ + "\u0007\u0006\u0000\u0000\u27b8\u0684\u0001\u0000\u0000\u0000\u27b9\u27ba"+ + "\u0007\u0010\u0000\u0000\u27ba\u27bb\u0007\u000f\u0000\u0000\u27bb\u27bc"+ + "\u0007\u0006\u0000\u0000\u27bc\u27bd\u0005_\u0000\u0000\u27bd\u27be\u0007"+ + "\u0005\u0000\u0000\u27be\u27bf\u0007\u0007\u0000\u0000\u27bf\u27c0\u0007"+ + "\f\u0000\u0000\u27c0\u27c1\u0007\u0016\u0000\u0000\u27c1\u27c2\u0007\u0006"+ + "\u0000\u0000\u27c2\u27c3\u0007\u0014\u0000\u0000\u27c3\u0686\u0001\u0000"+ + "\u0000\u0000\u27c4\u27c5\u0007\u0010\u0000\u0000\u27c5\u27c6\u0007\u0011"+ + "\u0000\u0000\u27c6\u27c7\u0007\u0012\u0000\u0000\u27c7\u27c8\u0007\u0012"+ + "\u0000\u0000\u27c8\u27c9\u0007\u0007\u0000\u0000\u27c9\u27ca\u0007\b\u0000"+ + "\u0000\u27ca\u0688\u0001\u0000\u0000\u0000\u27cb\u27cc\u0007\u000e\u0000"+ + "\u0000\u27cc\u27cd\u0007\u0003\u0000\u0000\u27cd\u27ce\u0007\u0006\u0000"+ + "\u0000\u27ce\u27cf\u0007\u0003\u0000\u0000\u27cf\u27d0\u0007\u0005\u0000"+ + "\u0000\u27d0\u27d1\u0007\u0013\u0000\u0000\u27d1\u27d2\u0007\u0016\u0000"+ + "\u0000\u27d2\u27d3\u0005_\u0000\u0000\u27d3\u27d4\u0007\f\u0000\u0000"+ + "\u27d4\u27d5\u0007\u0003\u0000\u0000\u27d5\u27d6\u0007\u0017\u0000\u0000"+ + "\u27d6\u27d7\u0007\u0007\u0000\u0000\u27d7\u068a\u0001\u0000\u0000\u0000"+ + "\u27d8\u27d9\u0007\u000e\u0000\u0000\u27d9\u27da\u0007\u0007\u0000\u0000"+ + "\u27da\u27db\u0007\u000f\u0000\u0000\u27db\u27dc\u0007\u0005\u0000\u0000"+ + "\u27dc\u068c\u0001\u0000\u0000\u0000\u27dd\u27de\u0007\u000e\u0000\u0000"+ + "\u27de\u27df\u0007\u0007\u0000\u0000\u27df\u27e0\u0007\u000f\u0000\u0000"+ + "\u27e0\u27e1\u0007\u0005\u0000\u0000\u27e1\u27e2\u0007\u000f\u0000\u0000"+ + "\u27e2\u27e3\u0007\f\u0000\u0000\u27e3\u27e4\u0007\u0016\u0000\u0000\u27e4"+ + "\u068e\u0001\u0000\u0000\u0000\u27e5\u27e6\u0007\u000e\u0000\u0000\u27e6"+ + "\u27e7\u0007\u0007\u0000\u0000\u27e7\u27e8\u0007\f\u0000\u0000\u27e8\u27e9"+ + "\u0007\u0006\u0000\u0000\u27e9\u27ea\u0007\b\u0000\u0000\u27ea\u27eb\u0007"+ + "\u0013\u0000\u0000\u27eb\u27ec\u0007\u000f\u0000\u0000\u27ec\u27ed\u0007"+ + "\u0004\u0000\u0000\u27ed\u0690\u0001\u0000\u0000\u0000\u27ee\u27ef\u0007"+ + "\u000e\u0000\u0000\u27ef\u27f0\u0007\u0014\u0000\u0000\u27f0\u27f1\u0007"+ + "\u0003\u0000\u0000\u27f1\u27f2\u0007\b\u0000\u0000\u27f2\u27f3\u0007\u0003"+ + "\u0000\u0000\u27f3\u27f4\u0007\u000e\u0000\u0000\u27f4\u27f5\u0007\u0006"+ + "\u0000\u0000\u27f5\u27f6\u0007\u0007\u0000\u0000\u27f6\u27f7\u0007\b\u0000"+ + "\u0000\u27f7\u27f8\u0005_\u0000\u0000\u27f8\u27f9\u0007\u0005\u0000\u0000"+ + "\u27f9\u27fa\u0007\u0007\u0000\u0000\u27fa\u27fb\u0007\f\u0000\u0000\u27fb"+ + "\u27fc\u0007\u0016\u0000\u0000\u27fc\u27fd\u0007\u0006\u0000\u0000\u27fd"+ + "\u27fe\u0007\u0014\u0000\u0000\u27fe\u0692\u0001\u0000\u0000\u0000\u27ff"+ + "\u2800\u0007\u000e\u0000\u0000\u2800\u2801\u0007\u0014\u0000\u0000\u2801"+ + "\u2802\u0007\u0003\u0000\u0000\u2802\u2803\u0007\b\u0000\u0000\u2803\u2804"+ + "\u0007\u000b\u0000\u0000\u2804\u2805\u0007\u0007\u0000\u0000\u2805\u2806"+ + "\u0007\u0006\u0000\u0000\u2806\u0694\u0001\u0000\u0000\u0000\u2807\u2808"+ + "\u0007\u000e\u0000\u0000\u2808\u2809\u0007\u0014\u0000\u0000\u2809\u280a"+ + "\u0007\u0003\u0000\u0000\u280a\u280b\u0007\b\u0000\u0000\u280b\u280c\u0005"+ + "_\u0000\u0000\u280c\u280d\u0007\u0005\u0000\u0000\u280d\u280e\u0007\u0007"+ + "\u0000\u0000\u280e\u280f\u0007\f\u0000\u0000\u280f\u2810\u0007\u0016\u0000"+ + "\u0000\u2810\u2811\u0007\u0006\u0000\u0000\u2811\u2812\u0007\u0014\u0000"+ + "\u0000\u2812\u0696\u0001\u0000\u0000\u0000\u2813\u2814\u0007\u000e\u0000"+ + "\u0000\u2814\u2815\u0007\u0013\u0000\u0000\u2815\u2816\u0007\u0007\u0000"+ + "\u0000\u2816\u2817\u0007\b\u0000\u0000\u2817\u2818\u0007\u000e\u0000\u0000"+ + "\u2818\u2819\u0007\u000f\u0000\u0000\u2819\u281a\u0007\u0010\u0000\u0000"+ + "\u281a\u281b\u0007\u000f\u0000\u0000\u281b\u281c\u0007\u0005\u0000\u0000"+ + "\u281c\u281d\u0007\u000f\u0000\u0000\u281d\u281e\u0007\u0006\u0000\u0000"+ + "\u281e\u281f\u0007\n\u0000\u0000\u281f\u0698\u0001\u0000\u0000\u0000\u2820"+ + "\u2821\u0007\u000e\u0000\u0000\u2821\u2822\u0007\u0013\u0000\u0000\u2822"+ + "\u2823\u0007\u0005\u0000\u0000\u2823\u2824\u0007\u0005\u0000\u0000\u2824"+ + "\u2825\u0007\u0003\u0000\u0000\u2825\u2826\u0007\u0006\u0000\u0000\u2826"+ + "\u2827\u0007\u000f\u0000\u0000\u2827\u2828\u0007\u0013\u0000\u0000\u2828"+ + "\u2829\u0007\f\u0000\u0000\u2829\u069a\u0001\u0000\u0000\u0000\u282a\u282b"+ + "\u0007\u000e\u0000\u0000\u282b\u282c\u0007\u0013\u0000\u0000\u282c\u282d"+ + "\u0007\u0017\u0000\u0000\u282d\u282e\u0007\u0019\u0000\u0000\u282e\u282f"+ + "\u0007\b\u0000\u0000\u282f\u2830\u0007\u0007\u0000\u0000\u2830\u2831\u0007"+ + "\u000b\u0000\u0000\u2831\u2832\u0007\u000b\u0000\u0000\u2832\u069c\u0001"+ + "\u0000\u0000\u0000\u2833\u2834\u0007\u000e\u0000\u0000\u2834\u2835\u0007"+ + "\u0013\u0000\u0000\u2835\u2836\u0007\f\u0000\u0000\u2836\u2837\u0007\u000e"+ + "\u0000\u0000\u2837\u2838\u0007\u0003\u0000\u0000\u2838\u2839\u0007\u0006"+ + "\u0000\u0000\u2839\u069e\u0001\u0000\u0000\u0000\u283a\u283b\u0007\u000e"+ + "\u0000\u0000\u283b\u283c\u0007\u0013\u0000\u0000\u283c\u283d\u0007\f\u0000"+ + "\u0000\u283d\u283e\u0007\u000e\u0000\u0000\u283e\u283f\u0007\u0003\u0000"+ + "\u0000\u283f\u2840\u0007\u0006\u0000\u0000\u2840\u2841\u0005_\u0000\u0000"+ + "\u2841\u2842\u0007\t\u0000\u0000\u2842\u2843\u0007\u000b\u0000\u0000\u2843"+ + "\u06a0\u0001\u0000\u0000\u0000\u2844\u2845\u0007\u000e\u0000\u0000\u2845"+ + "\u2846\u0007\u0013\u0000\u0000\u2846\u2847\u0007\f\u0000\u0000\u2847\u2848"+ + "\u0007\f\u0000\u0000\u2848\u2849\u0007\u0007\u0000\u0000\u2849\u284a\u0007"+ + "\u000e\u0000\u0000\u284a\u284b\u0007\u0006\u0000\u0000\u284b\u284c\u0007"+ + "\u000f\u0000\u0000\u284c\u284d\u0007\u0013\u0000\u0000\u284d\u284e\u0007"+ + "\f\u0000\u0000\u284e\u284f\u0005_\u0000\u0000\u284f\u2850\u0007\u000f"+ + "\u0000\u0000\u2850\u2851\u0007\u0004\u0000\u0000\u2851\u06a2\u0001\u0000"+ + "\u0000\u0000\u2852\u2853\u0007\u000e\u0000\u0000\u2853\u2854\u0007\u0013"+ + "\u0000\u0000\u2854\u2855\u0007\f\u0000\u0000\u2855\u2856\u0007\u0018\u0000"+ + "\u0000\u2856\u06a4\u0001\u0000\u0000\u0000\u2857\u2858\u0007\u000e\u0000"+ + "\u0000\u2858\u2859\u0007\u0013\u0000\u0000\u2859\u285a\u0007\f\u0000\u0000"+ + "\u285a\u285b\u0007\u0018\u0000\u0000\u285b\u285c\u0007\u0007\u0000\u0000"+ + "\u285c\u285d\u0007\b\u0000\u0000\u285d\u285e\u0007\u0006\u0000\u0000\u285e"+ + "\u285f\u0005_\u0000\u0000\u285f\u2860\u0007\u0006\u0000\u0000\u2860\u2861"+ + "\u0007\r\u0000\u0000\u2861\u06a6\u0001\u0000\u0000\u0000\u2862\u2863\u0007"+ + "\u000e\u0000\u0000\u2863\u2864\u0007\u0013\u0000\u0000\u2864\u2865\u0007"+ + "\u000b\u0000\u0000\u2865\u06a8\u0001\u0000\u0000\u0000\u2866\u2867\u0007"+ + "\u000e\u0000\u0000\u2867\u2868\u0007\u0013\u0000\u0000\u2868\u2869\u0007"+ + "\u0006\u0000\u0000\u2869\u06aa\u0001\u0000\u0000\u0000\u286a\u286b\u0007"+ + "\u000e\u0000\u0000\u286b\u286c\u0007\b\u0000\u0000\u286c\u286d\u0007\u000e"+ + "\u0000\u0000\u286d\u286e\u00053\u0000\u0000\u286e\u286f\u00052\u0000\u0000"+ + "\u286f\u06ac\u0001\u0000\u0000\u0000\u2870\u2871\u0007\u000e\u0000\u0000"+ + "\u2871\u2872\u0007\b\u0000\u0000\u2872\u2873\u0007\u0007\u0000\u0000\u2873"+ + "\u2874\u0007\u0003\u0000\u0000\u2874\u2875\u0007\u0006\u0000\u0000\u2875"+ + "\u2876\u0007\u0007\u0000\u0000\u2876\u2877\u0005_\u0000\u0000\u2877\u2878"+ + "\u0007\u0003\u0000\u0000\u2878\u2879\u0007\u000b\u0000\u0000\u2879\u287a"+ + "\u0007\n\u0000\u0000\u287a\u287b\u0007\u0017\u0000\u0000\u287b\u287c\u0007"+ + "\u0017\u0000\u0000\u287c\u287d\u0007\u0007\u0000\u0000\u287d\u287e\u0007"+ + "\u0006\u0000\u0000\u287e\u287f\u0007\b\u0000\u0000\u287f\u2880\u0007\u000f"+ + "\u0000\u0000\u2880\u2881\u0007\u000e\u0000\u0000\u2881\u2882\u0005_\u0000"+ + "\u0000\u2882\u2883\u0007\u0019\u0000\u0000\u2883\u2884\u0007\b\u0000\u0000"+ + "\u2884\u2885\u0007\u000f\u0000\u0000\u2885\u2886\u0007\u0018\u0000\u0000"+ + "\u2886\u2887\u0005_\u0000\u0000\u2887\u2888\u0007\u0015\u0000\u0000\u2888"+ + "\u2889\u0007\u0007\u0000\u0000\u2889\u288a\u0007\n\u0000\u0000\u288a\u06ae"+ + "\u0001\u0000\u0000\u0000\u288b\u288c\u0007\u000e\u0000\u0000\u288c\u288d"+ + "\u0007\b\u0000\u0000\u288d\u288e\u0007\u0007\u0000\u0000\u288e\u288f\u0007"+ + "\u0003\u0000\u0000\u288f\u2890\u0007\u0006\u0000\u0000\u2890\u2891\u0007"+ + "\u0007\u0000\u0000\u2891\u2892\u0005_\u0000\u0000\u2892\u2893\u0007\u0003"+ + "\u0000\u0000\u2893\u2894\u0007\u000b\u0000\u0000\u2894\u2895\u0007\n\u0000"+ + "\u0000\u2895\u2896\u0007\u0017\u0000\u0000\u2896\u2897\u0007\u0017\u0000"+ + "\u0000\u2897\u2898\u0007\u0007\u0000\u0000\u2898\u2899\u0007\u0006\u0000"+ + "\u0000\u2899\u289a\u0007\b\u0000\u0000\u289a\u289b\u0007\u000f\u0000\u0000"+ + "\u289b\u289c\u0007\u000e\u0000\u0000\u289c\u289d\u0005_\u0000\u0000\u289d"+ + "\u289e\u0007\u0019\u0000\u0000\u289e\u289f\u0007\u0011\u0000\u0000\u289f"+ + "\u28a0\u0007\u0010\u0000\u0000\u28a0\u28a1\u0005_\u0000\u0000\u28a1\u28a2"+ + "\u0007\u0015\u0000\u0000\u28a2\u28a3\u0007\u0007\u0000\u0000\u28a3\u28a4"+ + "\u0007\n\u0000\u0000\u28a4\u06b0\u0001\u0000\u0000\u0000\u28a5\u28a6\u0007"+ + "\u000e\u0000\u0000\u28a6\u28a7\u0007\b\u0000\u0000\u28a7\u28a8\u0007\u0007"+ + "\u0000\u0000\u28a8\u28a9\u0007\u0003\u0000\u0000\u28a9\u28aa\u0007\u0006"+ + "\u0000\u0000\u28aa\u28ab\u0007\u0007\u0000\u0000\u28ab\u28ac\u0005_\u0000"+ + "\u0000\u28ac\u28ad\u0007\u0004\u0000\u0000\u28ad\u28ae\u0007\u0014\u0000"+ + "\u0000\u28ae\u28af\u0005_\u0000\u0000\u28af\u28b0\u0007\u0019\u0000\u0000"+ + "\u28b0\u28b1\u0007\u0003\u0000\u0000\u28b1\u28b2\u0007\b\u0000\u0000\u28b2"+ + "\u28b3\u0007\u0003\u0000\u0000\u28b3\u28b4\u0007\u0017\u0000\u0000\u28b4"+ + "\u28b5\u0007\u0007\u0000\u0000\u28b5\u28b6\u0007\u0006\u0000\u0000\u28b6"+ + "\u28b7\u0007\u0007\u0000\u0000\u28b7\u28b8\u0007\b\u0000\u0000\u28b8\u28b9"+ + "\u0007\u000b\u0000\u0000\u28b9\u06b2\u0001\u0000\u0000\u0000\u28ba\u28bb"+ + "\u0007\u000e\u0000\u0000\u28bb\u28bc\u0007\b\u0000\u0000\u28bc\u28bd\u0007"+ + "\u0007\u0000\u0000\u28bd\u28be\u0007\u0003\u0000\u0000\u28be\u28bf\u0007"+ + "\u0006\u0000\u0000\u28bf\u28c0\u0007\u0007\u0000\u0000\u28c0\u28c1\u0005"+ + "_\u0000\u0000\u28c1\u28c2\u0007\u0004\u0000\u0000\u28c2\u28c3\u0007\u000f"+ + "\u0000\u0000\u28c3\u28c4\u0007\u0016\u0000\u0000\u28c4\u28c5\u0007\u0007"+ + "\u0000\u0000\u28c5\u28c6\u0007\u000b\u0000\u0000\u28c6\u28c7\u0007\u0006"+ + "\u0000\u0000\u28c7\u06b4\u0001\u0000\u0000\u0000\u28c8\u28c9\u0007\u000e"+ + "\u0000\u0000\u28c9\u28ca\u0007\b\u0000\u0000\u28ca\u28cb\u0007\u0013\u0000"+ + "\u0000\u28cb\u28cc\u0007\u000b\u0000\u0000\u28cc\u28cd\u0007\u000b\u0000"+ + "\u0000\u28cd\u28ce\u0007\u0007\u0000\u0000\u28ce\u28cf\u0007\u000b\u0000"+ + "\u0000\u28cf\u06b6\u0001\u0000\u0000\u0000\u28d0\u28d1\u0007\u0004\u0000"+ + "\u0000\u28d1\u28d2\u0007\u0003\u0000\u0000\u28d2\u28d3\u0007\u0006\u0000"+ + "\u0000\u28d3\u28d4\u0007\u0007\u0000\u0000\u28d4\u28d5\u0007\u0004\u0000"+ + "\u0000\u28d5\u28d6\u0007\u000f\u0000\u0000\u28d6\u28d7\u0007\u0012\u0000"+ + "\u0000\u28d7\u28d8\u0007\u0012\u0000\u0000\u28d8\u06b8\u0001\u0000\u0000"+ + "\u0000\u28d9\u28da\u0007\u0004\u0000\u0000\u28da\u28db\u0007\u0003\u0000"+ + "\u0000\u28db\u28dc\u0007\u0006\u0000\u0000\u28dc\u28dd\u0007\u0007\u0000"+ + "\u0000\u28dd\u28de\u0005_\u0000\u0000\u28de\u28df\u0007\u0012\u0000\u0000"+ + "\u28df\u28e0\u0007\u0013\u0000\u0000\u28e0\u28e1\u0007\b\u0000\u0000\u28e1"+ + "\u28e2\u0007\u0017\u0000\u0000\u28e2\u28e3\u0007\u0003\u0000\u0000\u28e3"+ + "\u28e4\u0007\u0006\u0000\u0000\u28e4\u06ba\u0001\u0000\u0000\u0000\u28e5"+ + "\u28e6\u0007\u0004\u0000\u0000\u28e6\u28e7\u0007\u0003\u0000\u0000\u28e7"+ + "\u28e8\u0007\n\u0000\u0000\u28e8\u28e9\u0007\f\u0000\u0000\u28e9\u28ea"+ + "\u0007\u0003\u0000\u0000\u28ea\u28eb\u0007\u0017\u0000\u0000\u28eb\u28ec"+ + "\u0007\u0007\u0000\u0000\u28ec\u06bc\u0001\u0000\u0000\u0000\u28ed\u28ee"+ + "\u0007\u0004\u0000\u0000\u28ee\u28ef\u0007\u0003\u0000\u0000\u28ef\u28f0"+ + "\u0007\n\u0000\u0000\u28f0\u28f1\u0007\u0013\u0000\u0000\u28f1\u28f2\u0007"+ + "\u0012\u0000\u0000\u28f2\u28f3\u0007\u0017\u0000\u0000\u28f3\u28f4\u0007"+ + "\u0013\u0000\u0000\u28f4\u28f5\u0007\f\u0000\u0000\u28f5\u28f6\u0007\u0006"+ + "\u0000\u0000\u28f6\u28f7\u0007\u0014\u0000\u0000\u28f7\u06be\u0001\u0000"+ + "\u0000\u0000\u28f8\u28f9\u0007\u0004\u0000\u0000\u28f9\u28fa\u0007\u0003"+ + "\u0000\u0000\u28fa\u28fb\u0007\n\u0000\u0000\u28fb\u28fc\u0007\u0013\u0000"+ + "\u0000\u28fc\u28fd\u0007\u0012\u0000\u0000\u28fd\u28fe\u0007\t\u0000\u0000"+ + "\u28fe\u28ff\u0007\u0007\u0000\u0000\u28ff\u2900\u0007\u0007\u0000\u0000"+ + "\u2900\u2901\u0007\u0015\u0000\u0000\u2901\u06c0\u0001\u0000\u0000\u0000"+ + "\u2902\u2903\u0007\u0004\u0000\u0000\u2903\u2904\u0007\u0003\u0000\u0000"+ + "\u2904\u2905\u0007\n\u0000\u0000\u2905\u2906\u0007\u0013\u0000\u0000\u2906"+ + "\u2907\u0007\u0012\u0000\u0000\u2907\u2908\u0007\n\u0000\u0000\u2908\u2909"+ + "\u0007\u0007\u0000\u0000\u2909\u290a\u0007\u0003\u0000\u0000\u290a\u290b"+ + "\u0007\b\u0000\u0000\u290b\u06c2\u0001\u0000\u0000\u0000\u290c\u290d\u0007"+ + "\u0004\u0000\u0000\u290d\u290e\u0007\u0007\u0000\u0000\u290e\u290f\u0007"+ + "\u000e\u0000\u0000\u290f\u2910\u0007\u0013\u0000\u0000\u2910\u2911\u0007"+ + "\u0004\u0000\u0000\u2911\u2912\u0007\u0007\u0000\u0000\u2912\u06c4\u0001"+ + "\u0000\u0000\u0000\u2913\u2914\u0007\u0004\u0000\u0000\u2914\u2915\u0007"+ + "\u0007\u0000\u0000\u2915\u2916\u0007\u0016\u0000\u0000\u2916\u2917\u0007"+ + "\b\u0000\u0000\u2917\u2918\u0007\u0007\u0000\u0000\u2918\u2919\u0007\u0007"+ + "\u0000\u0000\u2919\u291a\u0007\u000b\u0000\u0000\u291a\u06c6\u0001\u0000"+ + "\u0000\u0000\u291b\u291c\u0007\u0004\u0000\u0000\u291c\u291d\u0007\u0007"+ + "\u0000\u0000\u291d\u291e\u0007\u000b\u0000\u0000\u291e\u291f\u0005_\u0000"+ + "\u0000\u291f\u2920\u0007\u0004\u0000\u0000\u2920\u2921\u0007\u0007\u0000"+ + "\u0000\u2921\u2922\u0007\u000e\u0000\u0000\u2922\u2923\u0007\b\u0000\u0000"+ + "\u2923\u2924\u0007\n\u0000\u0000\u2924\u2925\u0007\u0019\u0000\u0000\u2925"+ + "\u2926\u0007\u0006\u0000\u0000\u2926\u06c8\u0001\u0000\u0000\u0000\u2927"+ + "\u2928\u0007\u0004\u0000\u0000\u2928\u2929\u0007\u0007\u0000\u0000\u2929"+ + "\u292a\u0007\u000b\u0000\u0000\u292a\u292b\u0005_\u0000\u0000\u292b\u292c"+ + "\u0007\u0007\u0000\u0000\u292c\u292d\u0007\f\u0000\u0000\u292d\u292e\u0007"+ + "\u000e\u0000\u0000\u292e\u292f\u0007\b\u0000\u0000\u292f\u2930\u0007\n"+ + "\u0000\u0000\u2930\u2931\u0007\u0019\u0000\u0000\u2931\u2932\u0007\u0006"+ + "\u0000\u0000\u2932\u06ca\u0001\u0000\u0000\u0000\u2933\u2934\u0007\u0004"+ + "\u0000\u0000\u2934\u2935\u0007\u000f\u0000\u0000\u2935\u2936\u0007\u0017"+ + "\u0000\u0000\u2936\u2937\u0007\u0007\u0000\u0000\u2937\u2938\u0007\f\u0000"+ + "\u0000\u2938\u2939\u0007\u000b\u0000\u0000\u2939\u293a\u0007\u000f\u0000"+ + "\u0000\u293a\u293b\u0007\u0013\u0000\u0000\u293b\u293c\u0007\f\u0000\u0000"+ + "\u293c\u06cc\u0001\u0000\u0000\u0000\u293d\u293e\u0007\u0004\u0000\u0000"+ + "\u293e\u293f\u0007\u000f\u0000\u0000\u293f\u2940\u0007\u000b\u0000\u0000"+ + "\u2940\u2941\u0007\u001b\u0000\u0000\u2941\u2942\u0007\u0013\u0000\u0000"+ + "\u2942\u2943\u0007\u000f\u0000\u0000\u2943\u2944\u0007\f\u0000\u0000\u2944"+ + "\u2945\u0007\u0006\u0000\u0000\u2945\u06ce\u0001\u0000\u0000\u0000\u2946"+ + "\u2947\u0007\u0007\u0000\u0000\u2947\u2948\u0007\u0005\u0000\u0000\u2948"+ + "\u2949\u0007\u0006\u0000\u0000\u2949\u06d0\u0001\u0000\u0000\u0000\u294a"+ + "\u294b\u0007\u0007\u0000\u0000\u294b\u294c\u0007\f\u0000\u0000\u294c\u294d"+ + "\u0007\u000e\u0000\u0000\u294d\u294e\u0007\u0013\u0000\u0000\u294e\u294f"+ + "\u0007\u0004\u0000\u0000\u294f\u2950\u0007\u0007\u0000\u0000\u2950\u06d2"+ + "\u0001\u0000\u0000\u0000\u2951\u2952\u0007\u0007\u0000\u0000\u2952\u2953"+ + "\u0007\f\u0000\u0000\u2953\u2954\u0007\u000e\u0000\u0000\u2954\u2955\u0007"+ + "\b\u0000\u0000\u2955\u2956\u0007\n\u0000\u0000\u2956\u2957\u0007\u0019"+ + "\u0000\u0000\u2957\u2958\u0007\u0006\u0000\u0000\u2958\u06d4\u0001\u0000"+ + "\u0000\u0000\u2959\u295a\u0007\u0007\u0000\u0000\u295a\u295b\u0007\f\u0000"+ + "\u0000\u295b\u295c\u0007\u0004\u0000\u0000\u295c\u295d\u0007\u0019\u0000"+ + "\u0000\u295d\u295e\u0007\u0013\u0000\u0000\u295e\u295f\u0007\u000f\u0000"+ + "\u0000\u295f\u2960\u0007\f\u0000\u0000\u2960\u2961\u0007\u0006\u0000\u0000"+ + "\u2961\u06d6\u0001\u0000\u0000\u0000\u2962\u2963\u0007\u0007\u0000\u0000"+ + "\u2963\u2964\u0007\f\u0000\u0000\u2964\u2965\u0007\u0016\u0000\u0000\u2965"+ + "\u2966\u0007\u000f\u0000\u0000\u2966\u2967\u0007\f\u0000\u0000\u2967\u2968"+ + "\u0007\u0007\u0000\u0000\u2968\u2969\u0005_\u0000\u0000\u2969\u296a\u0007"+ + "\u0003\u0000\u0000\u296a\u296b\u0007\u0006\u0000\u0000\u296b\u296c\u0007"+ + "\u0006\u0000\u0000\u296c\u296d\u0007\b\u0000\u0000\u296d\u296e\u0007\u000f"+ + "\u0000\u0000\u296e\u296f\u0007\u0010\u0000\u0000\u296f\u2970\u0007\u0011"+ + "\u0000\u0000\u2970\u2971\u0007\u0006\u0000\u0000\u2971\u2972\u0007\u0007"+ + "\u0000\u0000\u2972\u06d8\u0001\u0000\u0000\u0000\u2973\u2974\u0007\u0007"+ + "\u0000\u0000\u2974\u2975\u0007\f\u0000\u0000\u2975\u2976\u0007\u0018\u0000"+ + "\u0000\u2976\u2977\u0007\u0007\u0000\u0000\u2977\u2978\u0007\u0005\u0000"+ + "\u0000\u2978\u2979\u0007\u0013\u0000\u0000\u2979\u297a\u0007\u0019\u0000"+ + "\u0000\u297a\u297b\u0007\u0007\u0000\u0000\u297b\u06da\u0001\u0000\u0000"+ + "\u0000\u297c\u297d\u0007\u0007\u0000\u0000\u297d\u297e\u0007\u001c\u0000"+ + "\u0000\u297e\u297f\u0007\u0011\u0000\u0000\u297f\u2980\u0007\u0003\u0000"+ + "\u0000\u2980\u2981\u0007\u0005\u0000\u0000\u2981\u2982\u0007\u000b\u0000"+ + "\u0000\u2982\u06dc\u0001\u0000\u0000\u0000\u2983\u2984\u0007\u0007\u0000"+ + "\u0000\u2984\u2985\u0007\u001a\u0000\u0000\u2985\u2986\u0007\u0019\u0000"+ + "\u0000\u2986\u06de\u0001\u0000\u0000\u0000\u2987\u2988\u0007\u0007\u0000"+ + "\u0000\u2988\u2989\u0007\u001a\u0000\u0000\u2989\u298a\u0007\u0019\u0000"+ + "\u0000\u298a\u298b\u0007\u0013\u0000\u0000\u298b\u298c\u0007\b\u0000\u0000"+ + "\u298c\u298d\u0007\u0006\u0000\u0000\u298d\u298e\u0005_\u0000\u0000\u298e"+ + "\u298f\u0007\u000b\u0000\u0000\u298f\u2990\u0007\u0007\u0000\u0000\u2990"+ + "\u2991\u0007\u0006\u0000\u0000\u2991\u06e0\u0001\u0000\u0000\u0000\u2992"+ + "\u2993\u0007\u0007\u0000\u0000\u2993\u2994\u0007\u001a\u0000\u0000\u2994"+ + "\u2995\u0007\u0006\u0000\u0000\u2995\u2996\u0007\u0007\u0000\u0000\u2996"+ + "\u2997\u0007\b\u0000\u0000\u2997\u2998\u0007\u000f\u0000\u0000\u2998\u2999"+ + "\u0007\u0013\u0000\u0000\u2999\u299a\u0007\b\u0000\u0000\u299a\u299b\u0007"+ + "\b\u0000\u0000\u299b\u299c\u0007\u000f\u0000\u0000\u299c\u299d\u0007\f"+ + "\u0000\u0000\u299d\u299e\u0007\u0016\u0000\u0000\u299e\u06e2\u0001\u0000"+ + "\u0000\u0000\u299f\u29a0\u0007\u0007\u0000\u0000\u29a0\u29a1\u0007\u001a"+ + "\u0000\u0000\u29a1\u29a2\u0007\u0006\u0000\u0000\u29a2\u29a3\u0007\b\u0000"+ + "\u0000\u29a3\u29a4\u0007\u0003\u0000\u0000\u29a4\u29a5\u0007\u000e\u0000"+ + "\u0000\u29a5\u29a6\u0007\u0006\u0000\u0000\u29a6\u29a7\u0007\u0018\u0000"+ + "\u0000\u29a7\u29a8\u0007\u0003\u0000\u0000\u29a8\u29a9\u0007\u0005\u0000"+ + "\u0000\u29a9\u29aa\u0007\u0011\u0000\u0000\u29aa\u29ab\u0007\u0007\u0000"+ + "\u0000\u29ab\u06e4\u0001\u0000\u0000\u0000\u29ac\u29ad\u0007\u0012\u0000"+ + "\u0000\u29ad\u29ae\u0007\u000f\u0000\u0000\u29ae\u29af\u0007\u0007\u0000"+ + "\u0000\u29af\u29b0\u0007\u0005\u0000\u0000\u29b0\u29b1\u0007\u0004\u0000"+ + "\u0000\u29b1\u06e6\u0001\u0000\u0000\u0000\u29b2\u29b3\u0007\u0012\u0000"+ + "\u0000\u29b3\u29b4\u0007\u000f\u0000\u0000\u29b4\u29b5\u0007\f\u0000\u0000"+ + "\u29b5\u29b6\u0007\u0004\u0000\u0000\u29b6\u29b7\u0005_\u0000\u0000\u29b7"+ + "\u29b8\u0007\u000f\u0000\u0000\u29b8\u29b9\u0007\f\u0000\u0000\u29b9\u29ba"+ + "\u0005_\u0000\u0000\u29ba\u29bb\u0007\u000b\u0000\u0000\u29bb\u29bc\u0007"+ + "\u0007\u0000\u0000\u29bc\u29bd\u0007\u0006\u0000\u0000\u29bd\u06e8\u0001"+ + "\u0000\u0000\u0000\u29be\u29bf\u0007\u0012\u0000\u0000\u29bf\u29c0\u0007"+ + "\u0005\u0000\u0000\u29c0\u29c1\u0007\u0013\u0000\u0000\u29c1\u29c2\u0007"+ + "\u0013\u0000\u0000\u29c2\u29c3\u0007\b\u0000\u0000\u29c3\u06ea\u0001\u0000"+ + "\u0000\u0000\u29c4\u29c5\u0007\u0012\u0000\u0000\u29c5\u29c6\u0007\u0013"+ + "\u0000\u0000\u29c6\u29c7\u0007\b\u0000\u0000\u29c7\u29c8\u0007\u0017\u0000"+ + "\u0000\u29c8\u29c9\u0007\u0003\u0000\u0000\u29c9\u29ca\u0007\u0006\u0000"+ + "\u0000\u29ca\u06ec\u0001\u0000\u0000\u0000\u29cb\u29cc\u0007\u0012\u0000"+ + "\u0000\u29cc\u29cd\u0007\u0013\u0000\u0000\u29cd\u29ce\u0007\u0011\u0000"+ + "\u0000\u29ce\u29cf\u0007\f\u0000\u0000\u29cf\u29d0\u0007\u0004\u0000\u0000"+ + "\u29d0\u29d1\u0005_\u0000\u0000\u29d1\u29d2\u0007\b\u0000\u0000\u29d2"+ + "\u29d3\u0007\u0013\u0000\u0000\u29d3\u29d4\u0007\t\u0000\u0000\u29d4\u29d5"+ + "\u0007\u000b\u0000\u0000\u29d5\u06ee\u0001\u0000\u0000\u0000\u29d6\u29d7"+ + "\u0007\u0012\u0000\u0000\u29d7\u29d8\u0007\b\u0000\u0000\u29d8\u29d9\u0007"+ + "\u0013\u0000\u0000\u29d9\u29da\u0007\u0017\u0000\u0000\u29da\u29db\u0005"+ + "_\u0000\u0000\u29db\u29dc\u0007\u0010\u0000\u0000\u29dc\u29dd\u0007\u0003"+ + "\u0000\u0000\u29dd\u29de\u0007\u000b\u0000\u0000\u29de\u29df\u0007\u0007"+ + "\u0000\u0000\u29df\u29e0\u00056\u0000\u0000\u29e0\u29e1\u00054\u0000\u0000"+ + "\u29e1\u06f0\u0001\u0000\u0000\u0000\u29e2\u29e3\u0007\u0012\u0000\u0000"+ + "\u29e3\u29e4\u0007\b\u0000\u0000\u29e4\u29e5\u0007\u0013\u0000\u0000\u29e5"+ + "\u29e6\u0007\u0017\u0000\u0000\u29e6\u29e7\u0005_\u0000\u0000\u29e7\u29e8"+ + "\u0007\u0004\u0000\u0000\u29e8\u29e9\u0007\u0003\u0000\u0000\u29e9\u29ea"+ + "\u0007\n\u0000\u0000\u29ea\u29eb\u0007\u000b\u0000\u0000\u29eb\u06f2\u0001"+ + "\u0000\u0000\u0000\u29ec\u29ed\u0007\u0012\u0000\u0000\u29ed\u29ee\u0007"+ + "\b\u0000\u0000\u29ee\u29ef\u0007\u0013\u0000\u0000\u29ef\u29f0\u0007\u0017"+ + "\u0000\u0000\u29f0\u29f1\u0005_\u0000\u0000\u29f1\u29f2\u0007\u0011\u0000"+ + "\u0000\u29f2\u29f3\u0007\f\u0000\u0000\u29f3\u29f4\u0007\u000f\u0000\u0000"+ + "\u29f4\u29f5\u0007\u001a\u0000\u0000\u29f5\u29f6\u0007\u0006\u0000\u0000"+ + "\u29f6\u29f7\u0007\u000f\u0000\u0000\u29f7\u29f8\u0007\u0017\u0000\u0000"+ + "\u29f8\u29f9\u0007\u0007\u0000\u0000\u29f9\u06f4\u0001\u0000\u0000\u0000"+ + "\u29fa\u29fb\u0007\u0016\u0000\u0000\u29fb\u29fc\u0007\u0007\u0000\u0000"+ + "\u29fc\u29fd\u0007\u0013\u0000\u0000\u29fd\u29fe\u0007\u0017\u0000\u0000"+ + "\u29fe\u29ff\u0007\u000e\u0000\u0000\u29ff\u2a00\u0007\u0013\u0000\u0000"+ + "\u2a00\u2a01\u0007\u0005\u0000\u0000\u2a01\u2a02\u0007\u0005\u0000\u0000"+ + "\u2a02\u2a03\u0007\u0012\u0000\u0000\u2a03\u2a04\u0007\b\u0000\u0000\u2a04"+ + "\u2a05\u0007\u0013\u0000\u0000\u2a05\u2a06\u0007\u0017\u0000\u0000\u2a06"+ + "\u2a07\u0007\u0006\u0000\u0000\u2a07\u2a08\u0007\u0007\u0000\u0000\u2a08"+ + "\u2a09\u0007\u001a\u0000\u0000\u2a09\u2a0a\u0007\u0006\u0000\u0000\u2a0a"+ + "\u06f6\u0001\u0000\u0000\u0000\u2a0b\u2a0c\u0007\u0016\u0000\u0000\u2a0c"+ + "\u2a0d\u0007\u0007\u0000\u0000\u2a0d\u2a0e\u0007\u0013\u0000\u0000\u2a0e"+ + "\u2a0f\u0007\u0017\u0000\u0000\u2a0f\u2a10\u0007\u000e\u0000\u0000\u2a10"+ + "\u2a11\u0007\u0013\u0000\u0000\u2a11\u2a12\u0007\u0005\u0000\u0000\u2a12"+ + "\u2a13\u0007\u0005\u0000\u0000\u2a13\u2a14\u0007\u0012\u0000\u0000\u2a14"+ + "\u2a15\u0007\b\u0000\u0000\u2a15\u2a16\u0007\u0013\u0000\u0000\u2a16\u2a17"+ + "\u0007\u0017\u0000\u0000\u2a17\u2a18\u0007\t\u0000\u0000\u2a18\u2a19\u0007"+ + "\u0015\u0000\u0000\u2a19\u2a1a\u0007\u0010\u0000\u0000\u2a1a\u06f8\u0001"+ + "\u0000\u0000\u0000\u2a1b\u2a1c\u0007\u0016\u0000\u0000\u2a1c\u2a1d\u0007"+ + "\u0007\u0000\u0000\u2a1d\u2a1e\u0007\u0013\u0000\u0000\u2a1e\u2a1f\u0007"+ + "\u0017\u0000\u0000\u2a1f\u2a20\u0007\u0007\u0000\u0000\u2a20\u2a21\u0007"+ + "\u0006\u0000\u0000\u2a21\u2a22\u0007\b\u0000\u0000\u2a22\u2a23\u0007\n"+ + "\u0000\u0000\u2a23\u2a24\u0007\u000e\u0000\u0000\u2a24\u2a25\u0007\u0013"+ + "\u0000\u0000\u2a25\u2a26\u0007\u0005\u0000\u0000\u2a26\u2a27\u0007\u0005"+ + "\u0000\u0000\u2a27\u2a28\u0007\u0007\u0000\u0000\u2a28\u2a29\u0007\u000e"+ + "\u0000\u0000\u2a29\u2a2a\u0007\u0006\u0000\u0000\u2a2a\u2a2b\u0007\u000f"+ + "\u0000\u0000\u2a2b\u2a2c\u0007\u0013\u0000\u0000\u2a2c\u2a2d\u0007\f\u0000"+ + "\u0000\u2a2d\u2a2e\u0007\u0012\u0000\u0000\u2a2e\u2a2f\u0007\b\u0000\u0000"+ + "\u2a2f\u2a30\u0007\u0013\u0000\u0000\u2a30\u2a31\u0007\u0017\u0000\u0000"+ + "\u2a31\u2a32\u0007\u0006\u0000\u0000\u2a32\u2a33\u0007\u0007\u0000\u0000"+ + "\u2a33\u2a34\u0007\u001a\u0000\u0000\u2a34\u2a35\u0007\u0006\u0000\u0000"+ + "\u2a35\u06fa\u0001\u0000\u0000\u0000\u2a36\u2a37\u0007\u0016\u0000\u0000"+ + "\u2a37\u2a38\u0007\u0007\u0000\u0000\u2a38\u2a39\u0007\u0013\u0000\u0000"+ + "\u2a39\u2a3a\u0007\u0017\u0000\u0000\u2a3a\u2a3b\u0007\u0007\u0000\u0000"+ + "\u2a3b\u2a3c\u0007\u0006\u0000\u0000\u2a3c\u2a3d\u0007\b\u0000\u0000\u2a3d"+ + "\u2a3e\u0007\n\u0000\u0000\u2a3e\u2a3f\u0007\u000e\u0000\u0000\u2a3f\u2a40"+ + "\u0007\u0013\u0000\u0000\u2a40\u2a41\u0007\u0005\u0000\u0000\u2a41\u2a42"+ + "\u0007\u0005\u0000\u0000\u2a42\u2a43\u0007\u0007\u0000\u0000\u2a43\u2a44"+ + "\u0007\u000e\u0000\u0000\u2a44\u2a45\u0007\u0006\u0000\u0000\u2a45\u2a46"+ + "\u0007\u000f\u0000\u0000\u2a46\u2a47\u0007\u0013\u0000\u0000\u2a47\u2a48"+ + "\u0007\f\u0000\u0000\u2a48\u2a49\u0007\u0012\u0000\u0000\u2a49\u2a4a\u0007"+ + "\b\u0000\u0000\u2a4a\u2a4b\u0007\u0013\u0000\u0000\u2a4b\u2a4c\u0007\u0017"+ + "\u0000\u0000\u2a4c\u2a4d\u0007\t\u0000\u0000\u2a4d\u2a4e\u0007\u0015\u0000"+ + "\u0000\u2a4e\u2a4f\u0007\u0010\u0000\u0000\u2a4f\u06fc\u0001\u0000\u0000"+ + "\u0000\u2a50\u2a51\u0007\u0016\u0000\u0000\u2a51\u2a52\u0007\u0007\u0000"+ + "\u0000\u2a52\u2a53\u0007\u0013\u0000\u0000\u2a53\u2a54\u0007\u0017\u0000"+ + "\u0000\u2a54\u2a55\u0007\u0007\u0000\u0000\u2a55\u2a56\u0007\u0006\u0000"+ + "\u0000\u2a56\u2a57\u0007\b\u0000\u0000\u2a57\u2a58\u0007\n\u0000\u0000"+ + "\u2a58\u2a59\u0007\u0012\u0000\u0000\u2a59\u2a5a\u0007\b\u0000\u0000\u2a5a"+ + "\u2a5b\u0007\u0013\u0000\u0000\u2a5b\u2a5c\u0007\u0017\u0000\u0000\u2a5c"+ + "\u2a5d\u0007\u0006\u0000\u0000\u2a5d\u2a5e\u0007\u0007\u0000\u0000\u2a5e"+ + "\u2a5f\u0007\u001a\u0000\u0000\u2a5f\u2a60\u0007\u0006\u0000\u0000\u2a60"+ + "\u06fe\u0001\u0000\u0000\u0000\u2a61\u2a62\u0007\u0016\u0000\u0000\u2a62"+ + "\u2a63\u0007\u0007\u0000\u0000\u2a63\u2a64\u0007\u0013\u0000\u0000\u2a64"+ + "\u2a65\u0007\u0017\u0000\u0000\u2a65\u2a66\u0007\u0007\u0000\u0000\u2a66"+ + "\u2a67\u0007\u0006\u0000\u0000\u2a67\u2a68\u0007\b\u0000\u0000\u2a68\u2a69"+ + "\u0007\n\u0000\u0000\u2a69\u2a6a\u0007\u0012\u0000\u0000\u2a6a\u2a6b\u0007"+ + "\b\u0000\u0000\u2a6b\u2a6c\u0007\u0013\u0000\u0000\u2a6c\u2a6d\u0007\u0017"+ + "\u0000\u0000\u2a6d\u2a6e\u0007\t\u0000\u0000\u2a6e\u2a6f\u0007\u0015\u0000"+ + "\u0000\u2a6f\u2a70\u0007\u0010\u0000\u0000\u2a70\u0700\u0001\u0000\u0000"+ + "\u0000\u2a71\u2a72\u0007\u0016\u0000\u0000\u2a72\u2a73\u0007\u0007\u0000"+ + "\u0000\u2a73\u2a74\u0007\u0013\u0000\u0000\u2a74\u2a75\u0007\u0017\u0000"+ + "\u0000\u2a75\u2a76\u0007\u0007\u0000\u0000\u2a76\u2a77\u0007\u0006\u0000"+ + "\u0000\u2a77\u2a78\u0007\b\u0000\u0000\u2a78\u2a79\u0007\n\u0000\u0000"+ + "\u2a79\u2a7a\u0007\f\u0000\u0000\u2a7a\u0702\u0001\u0000\u0000\u0000\u2a7b"+ + "\u2a7c\u0007\u0016\u0000\u0000\u2a7c\u2a7d\u0007\u0007\u0000\u0000\u2a7d"+ + "\u2a7e\u0007\u0013\u0000\u0000\u2a7e\u2a7f\u0007\u0017\u0000\u0000\u2a7f"+ + "\u2a80\u0007\u0007\u0000\u0000\u2a80\u2a81\u0007\u0006\u0000\u0000\u2a81"+ + "\u2a82\u0007\b\u0000\u0000\u2a82\u2a83\u0007\n\u0000\u0000\u2a83\u2a84"+ + "\u0007\u0006\u0000\u0000\u2a84\u2a85\u0007\n\u0000\u0000\u2a85\u2a86\u0007"+ + "\u0019\u0000\u0000\u2a86\u2a87\u0007\u0007\u0000\u0000\u2a87\u0704\u0001"+ + "\u0000\u0000\u0000\u2a88\u2a89\u0007\u0016\u0000\u0000\u2a89\u2a8a\u0007"+ + "\u0007\u0000\u0000\u2a8a\u2a8b\u0007\u0013\u0000\u0000\u2a8b\u2a8c\u0007"+ + "\u0017\u0000\u0000\u2a8c\u2a8d\u0007\u0012\u0000\u0000\u2a8d\u2a8e\u0007"+ + "\b\u0000\u0000\u2a8e\u2a8f\u0007\u0013\u0000\u0000\u2a8f\u2a90\u0007\u0017"+ + "\u0000\u0000\u2a90\u2a91\u0007\u0006\u0000\u0000\u2a91\u2a92\u0007\u0007"+ + "\u0000\u0000\u2a92\u2a93\u0007\u001a\u0000\u0000\u2a93\u2a94\u0007\u0006"+ + "\u0000\u0000\u2a94\u0706\u0001\u0000\u0000\u0000\u2a95\u2a96\u0007\u0016"+ + "\u0000\u0000\u2a96\u2a97\u0007\u0007\u0000\u0000\u2a97\u2a98\u0007\u0013"+ + "\u0000\u0000\u2a98\u2a99\u0007\u0017\u0000\u0000\u2a99\u2a9a\u0007\u0012"+ + "\u0000\u0000\u2a9a\u2a9b\u0007\b\u0000\u0000\u2a9b\u2a9c\u0007\u0013\u0000"+ + "\u0000\u2a9c\u2a9d\u0007\u0017\u0000\u0000\u2a9d\u2a9e\u0007\t\u0000\u0000"+ + "\u2a9e\u2a9f\u0007\u0015\u0000\u0000\u2a9f\u2aa0\u0007\u0010\u0000\u0000"+ + "\u2aa0\u0708\u0001\u0000\u0000\u0000\u2aa1\u2aa2\u0007\u0016\u0000\u0000"+ + "\u2aa2\u2aa3\u0007\u0007\u0000\u0000\u2aa3\u2aa4\u0007\u0006\u0000\u0000"+ + "\u2aa4\u2aa5\u0005_\u0000\u0000\u2aa5\u2aa6\u0007\u0012\u0000\u0000\u2aa6"+ + "\u2aa7\u0007\u0013\u0000\u0000\u2aa7\u2aa8\u0007\b\u0000\u0000\u2aa8\u2aa9"+ + "\u0007\u0017\u0000\u0000\u2aa9\u2aaa\u0007\u0003\u0000\u0000\u2aaa\u2aab"+ + "\u0007\u0006\u0000\u0000\u2aab\u070a\u0001\u0000\u0000\u0000\u2aac\u2aad"+ + "\u0007\u0016\u0000\u0000\u2aad\u2aae\u0007\u0007\u0000\u0000\u2aae\u2aaf"+ + "\u0007\u0006\u0000\u0000\u2aaf\u2ab0\u0005_\u0000\u0000\u2ab0\u2ab1\u0007"+ + "\u0005\u0000\u0000\u2ab1\u2ab2\u0007\u0013\u0000\u0000\u2ab2\u2ab3\u0007"+ + "\u000e\u0000\u0000\u2ab3\u2ab4\u0007\u0015\u0000\u0000\u2ab4\u070c\u0001"+ + "\u0000\u0000\u0000\u2ab5\u2ab6\u0007\u0016\u0000\u0000\u2ab6\u2ab7\u0007"+ + "\u0005\u0000\u0000\u2ab7\u2ab8\u0007\u0007\u0000\u0000\u2ab8\u2ab9\u0007"+ + "\f\u0000\u0000\u2ab9\u2aba\u0007\u0016\u0000\u0000\u2aba\u2abb\u0007\u0006"+ + "\u0000\u0000\u2abb\u2abc\u0007\u0014\u0000\u0000\u2abc\u070e\u0001\u0000"+ + "\u0000\u0000\u2abd\u2abe\u0007\u0016\u0000\u0000\u2abe\u2abf\u0007\b\u0000"+ + "\u0000\u2abf\u2ac0\u0007\u0007\u0000\u0000\u2ac0\u2ac1\u0007\u0003\u0000"+ + "\u0000\u2ac1\u2ac2\u0007\u0006\u0000\u0000\u2ac2\u2ac3\u0007\u0007\u0000"+ + "\u0000\u2ac3\u2ac4\u0007\u000b\u0000\u0000\u2ac4\u2ac5\u0007\u0006\u0000"+ + "\u0000\u2ac5\u0710\u0001\u0000\u0000\u0000\u2ac6\u2ac7\u0007\u0016\u0000"+ + "\u0000\u2ac7\u2ac8\u0007\u0006\u0000\u0000\u2ac8\u2ac9\u0007\u000f\u0000"+ + "\u0000\u2ac9\u2aca\u0007\u0004\u0000\u0000\u2aca\u2acb\u0005_\u0000\u0000"+ + "\u2acb\u2acc\u0007\u000b\u0000\u0000\u2acc\u2acd\u0007\u0011\u0000\u0000"+ + "\u2acd\u2ace\u0007\u0010\u0000\u0000\u2ace\u2acf\u0007\u000b\u0000\u0000"+ + "\u2acf\u2ad0\u0007\u0007\u0000\u0000\u2ad0\u2ad1\u0007\u0006\u0000\u0000"+ + "\u2ad1\u0712\u0001\u0000\u0000\u0000\u2ad2\u2ad3\u0007\u0016\u0000\u0000"+ + "\u2ad3\u2ad4\u0007\u0006\u0000\u0000\u2ad4\u2ad5\u0007\u000f\u0000\u0000"+ + "\u2ad5\u2ad6\u0007\u0004\u0000\u0000\u2ad6\u2ad7\u0005_\u0000\u0000\u2ad7"+ + "\u2ad8\u0007\u000b\u0000\u0000\u2ad8\u2ad9\u0007\u0011\u0000\u0000\u2ad9"+ + "\u2ada\u0007\u0010\u0000\u0000\u2ada\u2adb\u0007\u0006\u0000\u0000\u2adb"+ + "\u2adc\u0007\b\u0000\u0000\u2adc\u2add\u0007\u0003\u0000\u0000\u2add\u2ade"+ + "\u0007\u000e\u0000\u0000\u2ade\u2adf\u0007\u0006\u0000\u0000\u2adf\u0714"+ + "\u0001\u0000\u0000\u0000\u2ae0\u2ae1\u0007\u0014\u0000\u0000\u2ae1\u2ae2"+ + "\u0007\u0007\u0000\u0000\u2ae2\u2ae3\u0007\u001a\u0000\u0000\u2ae3\u0716"+ + "\u0001\u0000\u0000\u0000\u2ae4\u2ae5\u0007\u000f\u0000\u0000\u2ae5\u2ae6"+ + "\u0007\u0012\u0000\u0000\u2ae6\u2ae7\u0007\f\u0000\u0000\u2ae7\u2ae8\u0007"+ + "\u0011\u0000\u0000\u2ae8\u2ae9\u0007\u0005\u0000\u0000\u2ae9\u2aea\u0007"+ + "\u0005\u0000\u0000\u2aea\u0718\u0001\u0000\u0000\u0000\u2aeb\u2aec\u0007"+ + "\u000f\u0000\u0000\u2aec\u2aed\u0007\f\u0000\u0000\u2aed\u2aee\u0007\u0007"+ + "\u0000\u0000\u2aee\u2aef\u0007\u0006\u0000\u0000\u2aef\u2af0\u00056\u0000"+ + "\u0000\u2af0\u2af1\u0005_\u0000\u0000\u2af1\u2af2\u0007\u0003\u0000\u0000"+ + "\u2af2\u2af3\u0007\u0006\u0000\u0000\u2af3\u2af4\u0007\u0013\u0000\u0000"+ + "\u2af4\u2af5\u0007\f\u0000\u0000\u2af5\u071a\u0001\u0000\u0000\u0000\u2af6"+ + "\u2af7\u0007\u000f\u0000\u0000\u2af7\u2af8\u0007\f\u0000\u0000\u2af8\u2af9"+ + "\u0007\u0007\u0000\u0000\u2af9\u2afa\u0007\u0006\u0000\u0000\u2afa\u2afb"+ + "\u00056\u0000\u0000\u2afb\u2afc\u0005_\u0000\u0000\u2afc\u2afd\u0007\f"+ + "\u0000\u0000\u2afd\u2afe\u0007\u0006\u0000\u0000\u2afe\u2aff\u0007\u0013"+ + "\u0000\u0000\u2aff\u2b00\u0007\u0003\u0000\u0000\u2b00\u071c\u0001\u0000"+ + "\u0000\u0000\u2b01\u2b02\u0007\u000f\u0000\u0000\u2b02\u2b03\u0007\f\u0000"+ + "\u0000\u2b03\u2b04\u0007\u0007\u0000\u0000\u2b04\u2b05\u0007\u0006\u0000"+ + "\u0000\u2b05\u2b06\u0005_\u0000\u0000\u2b06\u2b07\u0007\u0003\u0000\u0000"+ + "\u2b07\u2b08\u0007\u0006\u0000\u0000\u2b08\u2b09\u0007\u0013\u0000\u0000"+ + "\u2b09\u2b0a\u0007\f\u0000\u0000\u2b0a\u071e\u0001\u0000\u0000\u0000\u2b0b"+ + "\u2b0c\u0007\u000f\u0000\u0000\u2b0c\u2b0d\u0007\f\u0000\u0000\u2b0d\u2b0e"+ + "\u0007\u0007\u0000\u0000\u2b0e\u2b0f\u0007\u0006\u0000\u0000\u2b0f\u2b10"+ + "\u0005_\u0000\u0000\u2b10\u2b11\u0007\f\u0000\u0000\u2b11\u2b12\u0007"+ + "\u0006\u0000\u0000\u2b12\u2b13\u0007\u0013\u0000\u0000\u2b13\u2b14\u0007"+ + "\u0003\u0000\u0000\u2b14\u0720\u0001\u0000\u0000\u0000\u2b15\u2b16\u0007"+ + "\u000f\u0000\u0000\u2b16\u2b17\u0007\f\u0000\u0000\u2b17\u2b18\u0007\u000b"+ + "\u0000\u0000\u2b18\u2b19\u0007\u0006\u0000\u0000\u2b19\u2b1a\u0007\b\u0000"+ + "\u0000\u2b1a\u0722\u0001\u0000\u0000\u0000\u2b1b\u2b1c\u0007\u000f\u0000"+ + "\u0000\u2b1c\u2b1d\u0007\f\u0000\u0000\u2b1d\u2b1e\u0007\u0006\u0000\u0000"+ + "\u2b1e\u2b1f\u0007\u0007\u0000\u0000\u2b1f\u2b20\u0007\b\u0000\u0000\u2b20"+ + "\u2b21\u0007\u000f\u0000\u0000\u2b21\u2b22\u0007\u0013\u0000\u0000\u2b22"+ + "\u2b23\u0007\b\u0000\u0000\u2b23\u2b24\u0007\b\u0000\u0000\u2b24\u2b25"+ + "\u0007\u000f\u0000\u0000\u2b25\u2b26\u0007\f\u0000\u0000\u2b26\u2b27\u0007"+ + "\u0016\u0000\u0000\u2b27\u2b28\u0007\f\u0000\u0000\u2b28\u0724\u0001\u0000"+ + "\u0000\u0000\u2b29\u2b2a\u0007\u000f\u0000\u0000\u2b2a\u2b2b\u0007\f\u0000"+ + "\u0000\u2b2b\u2b2c\u0007\u0006\u0000\u0000\u2b2c\u2b2d\u0007\u0007\u0000"+ + "\u0000\u2b2d\u2b2e\u0007\b\u0000\u0000\u2b2e\u2b2f\u0007\u000b\u0000\u0000"+ + "\u2b2f\u2b30\u0007\u0007\u0000\u0000\u2b30\u2b31\u0007\u000e\u0000\u0000"+ + "\u2b31\u2b32\u0007\u0006\u0000\u0000\u2b32\u2b33\u0007\u000b\u0000\u0000"+ + "\u2b33\u0726\u0001\u0000\u0000\u0000\u2b34\u2b35\u0007\u000f\u0000\u0000"+ + "\u2b35\u2b36\u0007\u000b\u0000\u0000\u2b36\u2b37\u0007\u000e\u0000\u0000"+ + "\u2b37\u2b38\u0007\u0005\u0000\u0000\u2b38\u2b39\u0007\u0013\u0000\u0000"+ + "\u2b39\u2b3a\u0007\u000b\u0000\u0000\u2b3a\u2b3b\u0007\u0007\u0000\u0000"+ + "\u2b3b\u2b3c\u0007\u0004\u0000\u0000\u2b3c\u0728\u0001\u0000\u0000\u0000"+ + "\u2b3d\u2b3e\u0007\u000f\u0000\u0000\u2b3e\u2b3f\u0007\u000b\u0000\u0000"+ + "\u2b3f\u2b40\u0007\u0007\u0000\u0000\u2b40\u2b41\u0007\u0017\u0000\u0000"+ + "\u2b41\u2b42\u0007\u0019\u0000\u0000\u2b42\u2b43\u0007\u0006\u0000\u0000"+ + "\u2b43\u2b44\u0007\n\u0000\u0000\u2b44\u072a\u0001\u0000\u0000\u0000\u2b45"+ + "\u2b46\u0007\u000f\u0000\u0000\u2b46\u2b47\u0007\u000b\u0000\u0000\u2b47"+ + "\u2b48\u0007\f\u0000\u0000\u2b48\u2b49\u0007\u0011\u0000\u0000\u2b49\u2b4a"+ + "\u0007\u0005\u0000\u0000\u2b4a\u2b4b\u0007\u0005\u0000\u0000\u2b4b\u072c"+ + "\u0001\u0000\u0000\u0000\u2b4c\u2b4d\u0007\u000f\u0000\u0000\u2b4d\u2b4e"+ + "\u0007\u000b\u0000\u0000\u2b4e\u2b4f\u0007\u000b\u0000\u0000\u2b4f\u2b50"+ + "\u0007\u000f\u0000\u0000\u2b50\u2b51\u0007\u0017\u0000\u0000\u2b51\u2b52"+ + "\u0007\u0019\u0000\u0000\u2b52\u2b53\u0007\u0005\u0000\u0000\u2b53\u2b54"+ + "\u0007\u0007\u0000\u0000\u2b54\u072e\u0001\u0000\u0000\u0000\u2b55\u2b56"+ + "\u0007\u000f\u0000\u0000\u2b56\u2b57\u0007\u000b\u0000\u0000\u2b57\u2b58"+ + "\u0005_\u0000\u0000\u2b58\u2b59\u0007\u0012\u0000\u0000\u2b59\u2b5a\u0007"+ + "\b\u0000\u0000\u2b5a\u2b5b\u0007\u0007\u0000\u0000\u2b5b\u2b5c\u0007\u0007"+ + "\u0000\u0000\u2b5c\u2b5d\u0005_\u0000\u0000\u2b5d\u2b5e\u0007\u0005\u0000"+ + "\u0000\u2b5e\u2b5f\u0007\u0013\u0000\u0000\u2b5f\u2b60\u0007\u000e\u0000"+ + "\u0000\u2b60\u2b61\u0007\u0015\u0000\u0000\u2b61\u0730\u0001\u0000\u0000"+ + "\u0000\u2b62\u2b63\u0007\u000f\u0000\u0000\u2b63\u2b64\u0007\u000b\u0000"+ + "\u0000\u2b64\u2b65\u0005_\u0000\u0000\u2b65\u2b66\u0007\u000f\u0000\u0000"+ + "\u2b66\u2b67\u0007\u0019\u0000\u0000\u2b67\u2b68\u0007\u0018\u0000\u0000"+ + "\u2b68\u2b69\u00054\u0000\u0000\u2b69\u0732\u0001\u0000\u0000\u0000\u2b6a"+ + "\u2b6b\u0007\u000f\u0000\u0000\u2b6b\u2b6c\u0007\u000b\u0000\u0000\u2b6c"+ + "\u2b6d\u0005_\u0000\u0000\u2b6d\u2b6e\u0007\u000f\u0000\u0000\u2b6e\u2b6f"+ + "\u0007\u0019\u0000\u0000\u2b6f\u2b70\u0007\u0018\u0000\u0000\u2b70\u2b71"+ + "\u00054\u0000\u0000\u2b71\u2b72\u0005_\u0000\u0000\u2b72\u2b73\u0007\u000e"+ + "\u0000\u0000\u2b73\u2b74\u0007\u0013\u0000\u0000\u2b74\u2b75\u0007\u0017"+ + "\u0000\u0000\u2b75\u2b76\u0007\u0019\u0000\u0000\u2b76\u2b77\u0007\u0003"+ + "\u0000\u0000\u2b77\u2b78\u0007\u0006\u0000\u0000\u2b78\u0734\u0001\u0000"+ + "\u0000\u0000\u2b79\u2b7a\u0007\u000f\u0000\u0000\u2b7a\u2b7b\u0007\u000b"+ + "\u0000\u0000\u2b7b\u2b7c\u0005_\u0000\u0000\u2b7c\u2b7d\u0007\u000f\u0000"+ + "\u0000\u2b7d\u2b7e\u0007\u0019\u0000\u0000\u2b7e\u2b7f\u0007\u0018\u0000"+ + "\u0000\u2b7f\u2b80\u00054\u0000\u0000\u2b80\u2b81\u0005_\u0000\u0000\u2b81"+ + "\u2b82\u0007\u0017\u0000\u0000\u2b82\u2b83\u0007\u0003\u0000\u0000\u2b83"+ + "\u2b84\u0007\u0019\u0000\u0000\u2b84\u2b85\u0007\u0019\u0000\u0000\u2b85"+ + "\u2b86\u0007\u0007\u0000\u0000\u2b86\u2b87\u0007\u0004\u0000\u0000\u2b87"+ + "\u0736\u0001\u0000\u0000\u0000\u2b88\u2b89\u0007\u000f\u0000\u0000\u2b89"+ + "\u2b8a\u0007\u000b\u0000\u0000\u2b8a\u2b8b\u0005_\u0000\u0000\u2b8b\u2b8c"+ + "\u0007\u000f\u0000\u0000\u2b8c\u2b8d\u0007\u0019\u0000\u0000\u2b8d\u2b8e"+ + "\u0007\u0018\u0000\u0000\u2b8e\u2b8f\u00056\u0000\u0000\u2b8f\u0738\u0001"+ + "\u0000\u0000\u0000\u2b90\u2b91\u0007\u000f\u0000\u0000\u2b91\u2b92\u0007"+ + "\u000b\u0000\u0000\u2b92\u2b93\u0005_\u0000\u0000\u2b93\u2b94\u0007\u0011"+ + "\u0000\u0000\u2b94\u2b95\u0007\u000b\u0000\u0000\u2b95\u2b96\u0007\u0007"+ + "\u0000\u0000\u2b96\u2b97\u0007\u0004\u0000\u0000\u2b97\u2b98\u0005_\u0000"+ + "\u0000\u2b98\u2b99\u0007\u0005\u0000\u0000\u2b99\u2b9a\u0007\u0013\u0000"+ + "\u0000\u2b9a\u2b9b\u0007\u000e\u0000\u0000\u2b9b\u2b9c\u0007\u0015\u0000"+ + "\u0000\u2b9c\u073a\u0001\u0000\u0000\u0000\u2b9d\u2b9e\u0007\u0005\u0000"+ + "\u0000\u2b9e\u2b9f\u0007\u0003\u0000\u0000\u2b9f\u2ba0\u0007\u000b\u0000"+ + "\u0000\u2ba0\u2ba1\u0007\u0006\u0000\u0000\u2ba1\u2ba2\u0005_\u0000\u0000"+ + "\u2ba2\u2ba3\u0007\u000f\u0000\u0000\u2ba3\u2ba4\u0007\f\u0000\u0000\u2ba4"+ + "\u2ba5\u0007\u000b\u0000\u0000\u2ba5\u2ba6\u0007\u0007\u0000\u0000\u2ba6"+ + "\u2ba7\u0007\b\u0000\u0000\u2ba7\u2ba8\u0007\u0006\u0000\u0000\u2ba8\u2ba9"+ + "\u0005_\u0000\u0000\u2ba9\u2baa\u0007\u000f\u0000\u0000\u2baa\u2bab\u0007"+ + "\u0004\u0000\u0000\u2bab\u073c\u0001\u0000\u0000\u0000\u2bac\u2bad\u0007"+ + "\u0005\u0000\u0000\u2bad\u2bae\u0007\u000e\u0000\u0000\u2bae\u2baf\u0007"+ + "\u0003\u0000\u0000\u2baf\u2bb0\u0007\u000b\u0000\u0000\u2bb0\u2bb1\u0007"+ + "\u0007\u0000\u0000\u2bb1\u073e\u0001\u0000\u0000\u0000\u2bb2\u2bb3\u0007"+ + "\u0005\u0000\u0000\u2bb3\u2bb4\u0007\u0007\u0000\u0000\u2bb4\u2bb5\u0007"+ + "\u0003\u0000\u0000\u2bb5\u2bb6\u0007\u000b\u0000\u0000\u2bb6\u2bb7\u0007"+ + "\u0006\u0000\u0000\u2bb7\u0740\u0001\u0000\u0000\u0000\u2bb8\u2bb9\u0007"+ + "\u0005\u0000\u0000\u2bb9\u2bba\u0007\u0007\u0000\u0000\u2bba\u2bbb\u0007"+ + "\f\u0000\u0000\u2bbb\u2bbc\u0007\u0016\u0000\u0000\u2bbc\u2bbd\u0007\u0006"+ + "\u0000\u0000\u2bbd\u2bbe\u0007\u0014\u0000\u0000\u2bbe\u0742\u0001\u0000"+ + "\u0000\u0000\u2bbf\u2bc0\u0007\u0005\u0000\u0000\u2bc0\u2bc1\u0007\u000f"+ + "\u0000\u0000\u2bc1\u2bc2\u0007\f\u0000\u0000\u2bc2\u2bc3\u0007\u0007\u0000"+ + "\u0000\u2bc3\u2bc4\u0007\u0012\u0000\u0000\u2bc4\u2bc5\u0007\b\u0000\u0000"+ + "\u2bc5\u2bc6\u0007\u0013\u0000\u0000\u2bc6\u2bc7\u0007\u0017\u0000\u0000"+ + "\u2bc7\u2bc8\u0007\u0006\u0000\u0000\u2bc8\u2bc9\u0007\u0007\u0000\u0000"+ + "\u2bc9\u2bca\u0007\u001a\u0000\u0000\u2bca\u2bcb\u0007\u0006\u0000\u0000"+ + "\u2bcb\u0744\u0001\u0000\u0000\u0000\u2bcc\u2bcd\u0007\u0005\u0000\u0000"+ + "\u2bcd\u2bce\u0007\u000f\u0000\u0000\u2bce\u2bcf\u0007\f\u0000\u0000\u2bcf"+ + "\u2bd0\u0007\u0007\u0000\u0000\u2bd0\u2bd1\u0007\u0012\u0000\u0000\u2bd1"+ + "\u2bd2\u0007\b\u0000\u0000\u2bd2\u2bd3\u0007\u0013\u0000\u0000\u2bd3\u2bd4"+ + "\u0007\u0017\u0000\u0000\u2bd4\u2bd5\u0007\t\u0000\u0000\u2bd5\u2bd6\u0007"+ + "\u0015\u0000\u0000\u2bd6\u2bd7\u0007\u0010\u0000\u0000\u2bd7\u0746\u0001"+ + "\u0000\u0000\u0000\u2bd8\u2bd9\u0007\u0005\u0000\u0000\u2bd9\u2bda\u0007"+ + "\u000f\u0000\u0000\u2bda\u2bdb\u0007\f\u0000\u0000\u2bdb\u2bdc\u0007\u0007"+ + "\u0000\u0000\u2bdc\u2bdd\u0007\u000b\u0000\u0000\u2bdd\u2bde\u0007\u0006"+ + "\u0000\u0000\u2bde\u2bdf\u0007\b\u0000\u0000\u2bdf\u2be0\u0007\u000f\u0000"+ + "\u0000\u2be0\u2be1\u0007\f\u0000\u0000\u2be1\u2be2\u0007\u0016\u0000\u0000"+ + "\u2be2\u2be3\u0007\u0012\u0000\u0000\u2be3\u2be4\u0007\b\u0000\u0000\u2be4"+ + "\u2be5\u0007\u0013\u0000\u0000\u2be5\u2be6\u0007\u0017\u0000\u0000\u2be6"+ + "\u2be7\u0007\u0006\u0000\u0000\u2be7\u2be8\u0007\u0007\u0000\u0000\u2be8"+ + "\u2be9\u0007\u001a\u0000\u0000\u2be9\u2bea\u0007\u0006\u0000\u0000\u2bea"+ + "\u0748\u0001\u0000\u0000\u0000\u2beb\u2bec\u0007\u0005\u0000\u0000\u2bec"+ + "\u2bed\u0007\u000f\u0000\u0000\u2bed\u2bee\u0007\f\u0000\u0000\u2bee\u2bef"+ + "\u0007\u0007\u0000\u0000\u2bef\u2bf0\u0007\u000b\u0000\u0000\u2bf0\u2bf1"+ + "\u0007\u0006\u0000\u0000\u2bf1\u2bf2\u0007\b\u0000\u0000\u2bf2\u2bf3\u0007"+ + "\u000f\u0000\u0000\u2bf3\u2bf4\u0007\f\u0000\u0000\u2bf4\u2bf5\u0007\u0016"+ + "\u0000\u0000\u2bf5\u2bf6\u0007\u0012\u0000\u0000\u2bf6\u2bf7\u0007\b\u0000"+ + "\u0000\u2bf7\u2bf8\u0007\u0013\u0000\u0000\u2bf8\u2bf9\u0007\u0017\u0000"+ + "\u0000\u2bf9\u2bfa\u0007\t\u0000\u0000\u2bfa\u2bfb\u0007\u0015\u0000\u0000"+ + "\u2bfb\u2bfc\u0007\u0010\u0000\u0000\u2bfc\u074a\u0001\u0000\u0000\u0000"+ + "\u2bfd\u2bfe\u0007\u0005\u0000\u0000\u2bfe\u2bff\u0007\f\u0000\u0000\u2bff"+ + "\u074c\u0001\u0000\u0000\u0000\u2c00\u2c01\u0007\u0005\u0000\u0000\u2c01"+ + "\u2c02\u0007\u0013\u0000\u0000\u2c02\u2c03\u0007\u0003\u0000\u0000\u2c03"+ + "\u2c04\u0007\u0004\u0000\u0000\u2c04\u2c05\u0005_\u0000\u0000\u2c05\u2c06"+ + "\u0007\u0012\u0000\u0000\u2c06\u2c07\u0007\u000f\u0000\u0000\u2c07\u2c08"+ + "\u0007\u0005\u0000\u0000\u2c08\u2c09\u0007\u0007\u0000\u0000\u2c09\u074e"+ + "\u0001\u0000\u0000\u0000\u2c0a\u2c0b\u0007\u0005\u0000\u0000\u2c0b\u2c0c"+ + "\u0007\u0013\u0000\u0000\u2c0c\u2c0d\u0007\u000e\u0000\u0000\u2c0d\u2c0e"+ + "\u0007\u0003\u0000\u0000\u2c0e\u2c0f\u0007\u0006\u0000\u0000\u2c0f\u2c10"+ + "\u0007\u0007\u0000\u0000\u2c10\u0750\u0001\u0000\u0000\u0000\u2c11\u2c12"+ + "\u0007\u0005\u0000\u0000\u2c12\u2c13\u0007\u0013\u0000\u0000\u2c13\u2c14"+ + "\u0007\u0016\u0000\u0000\u2c14\u0752\u0001\u0000\u0000\u0000\u2c15\u2c16"+ + "\u0007\u0005\u0000\u0000\u2c16\u2c17\u0007\u0013\u0000\u0000\u2c17\u2c18"+ + "\u0007\u0016\u0000\u0000\u2c18\u2c19\u00051\u0000\u0000\u2c19\u2c1a\u0005"+ + "0\u0000\u0000\u2c1a\u0754\u0001\u0000\u0000\u0000\u2c1b\u2c1c\u0007\u0005"+ + "\u0000\u0000\u2c1c\u2c1d\u0007\u0013\u0000\u0000\u2c1d\u2c1e\u0007\u0016"+ + "\u0000\u0000\u2c1e\u2c1f\u00052\u0000\u0000\u2c1f\u0756\u0001\u0000\u0000"+ + "\u0000\u2c20\u2c21\u0007\u0005\u0000\u0000\u2c21\u2c22\u0007\u0013\u0000"+ + "\u0000\u2c22\u2c23\u0007\t\u0000\u0000\u2c23\u2c24\u0007\u0007\u0000\u0000"+ + "\u2c24\u2c25\u0007\b\u0000\u0000\u2c25\u0758\u0001\u0000\u0000\u0000\u2c26"+ + "\u2c27\u0007\u0005\u0000\u0000\u2c27\u2c28\u0007\u0019\u0000\u0000\u2c28"+ + "\u2c29\u0007\u0003\u0000\u0000\u2c29\u2c2a\u0007\u0004\u0000\u0000\u2c2a"+ + "\u075a\u0001\u0000\u0000\u0000\u2c2b\u2c2c\u0007\u0005\u0000\u0000\u2c2c"+ + "\u2c2d\u0007\u0006\u0000\u0000\u2c2d\u2c2e\u0007\b\u0000\u0000\u2c2e\u2c2f"+ + "\u0007\u000f\u0000\u0000\u2c2f\u2c30\u0007\u0017\u0000\u0000\u2c30\u075c"+ + "\u0001\u0000\u0000\u0000\u2c31\u2c32\u0007\u0017\u0000\u0000\u2c32\u2c33"+ + "\u0007\u0003\u0000\u0000\u2c33\u2c34\u0007\u0015\u0000\u0000\u2c34\u2c35"+ + "\u0007\u0007\u0000\u0000\u2c35\u2c36\u0007\u0004\u0000\u0000\u2c36\u2c37"+ + "\u0007\u0003\u0000\u0000\u2c37\u2c38\u0007\u0006\u0000\u0000\u2c38\u2c39"+ + "\u0007\u0007\u0000\u0000\u2c39\u075e\u0001\u0000\u0000\u0000\u2c3a\u2c3b"+ + "\u0007\u0017\u0000\u0000\u2c3b\u2c3c\u0007\u0003\u0000\u0000\u2c3c\u2c3d"+ + "\u0007\u0015\u0000\u0000\u2c3d\u2c3e\u0007\u0007\u0000\u0000\u2c3e\u2c3f"+ + "\u0007\u0006\u0000\u0000\u2c3f\u2c40\u0007\u000f\u0000\u0000\u2c40\u2c41"+ + "\u0007\u0017\u0000\u0000\u2c41\u2c42\u0007\u0007\u0000\u0000\u2c42\u0760"+ + "\u0001\u0000\u0000\u0000\u2c43\u2c44\u0007\u0017\u0000\u0000\u2c44\u2c45"+ + "\u0007\u0003\u0000\u0000\u2c45\u2c46\u0007\u0015\u0000\u0000\u2c46\u2c47"+ + "\u0007\u0007\u0000\u0000\u2c47\u2c48\u0005_\u0000\u0000\u2c48\u2c49\u0007"+ + "\u000b\u0000\u0000\u2c49\u2c4a\u0007\u0007\u0000\u0000\u2c4a\u2c4b\u0007"+ + "\u0006\u0000\u0000\u2c4b\u0762\u0001\u0000\u0000\u0000\u2c4c\u2c4d\u0007"+ + "\u0017\u0000\u0000\u2c4d\u2c4e\u0007\u0003\u0000\u0000\u2c4e\u2c4f\u0007"+ + "\u000b\u0000\u0000\u2c4f\u2c50\u0007\u0006\u0000\u0000\u2c50\u2c51\u0007"+ + "\u0007\u0000\u0000\u2c51\u2c52\u0007\b\u0000\u0000\u2c52\u2c53\u0005_"+ + "\u0000\u0000\u2c53\u2c54\u0007\u0019\u0000\u0000\u2c54\u2c55\u0007\u0013"+ + "\u0000\u0000\u2c55\u2c56\u0007\u000b\u0000\u0000\u2c56\u2c57\u0005_\u0000"+ + "\u0000\u2c57\u2c58\u0007\t\u0000\u0000\u2c58\u2c59\u0007\u0003\u0000\u0000"+ + "\u2c59\u2c5a\u0007\u000f\u0000\u0000\u2c5a\u2c5b\u0007\u0006\u0000\u0000"+ + "\u2c5b\u0764\u0001\u0000\u0000\u0000\u2c5c\u2c5d\u0007\u0017\u0000\u0000"+ + "\u2c5d\u2c5e\u0007\u0010\u0000\u0000\u2c5e\u2c5f\u0007\b\u0000\u0000\u2c5f"+ + "\u2c60\u0007\u000e\u0000\u0000\u2c60\u2c61\u0007\u0013\u0000\u0000\u2c61"+ + "\u2c62\u0007\f\u0000\u0000\u2c62\u2c63\u0007\u0006\u0000\u0000\u2c63\u2c64"+ + "\u0007\u0003\u0000\u0000\u2c64\u2c65\u0007\u000f\u0000\u0000\u2c65\u2c66"+ + "\u0007\f\u0000\u0000\u2c66\u2c67\u0007\u000b\u0000\u0000\u2c67\u0766\u0001"+ + "\u0000\u0000\u0000\u2c68\u2c69\u0007\u0017\u0000\u0000\u2c69\u2c6a\u0007"+ + "\u0010\u0000\u0000\u2c6a\u2c6b\u0007\b\u0000\u0000\u2c6b\u2c6c\u0007\u0004"+ + "\u0000\u0000\u2c6c\u2c6d\u0007\u000f\u0000\u0000\u2c6d\u2c6e\u0007\u000b"+ + "\u0000\u0000\u2c6e\u2c6f\u0007\u001b\u0000\u0000\u2c6f\u2c70\u0007\u0013"+ + "\u0000\u0000\u2c70\u2c71\u0007\u000f\u0000\u0000\u2c71\u2c72\u0007\f\u0000"+ + "\u0000\u2c72\u2c73\u0007\u0006\u0000\u0000\u2c73\u0768\u0001\u0000\u0000"+ + "\u0000\u2c74\u2c75\u0007\u0017\u0000\u0000\u2c75\u2c76\u0007\u0010\u0000"+ + "\u0000\u2c76\u2c77\u0007\b\u0000\u0000\u2c77\u2c78\u0007\u0007\u0000\u0000"+ + "\u2c78\u2c79\u0007\u001c\u0000\u0000\u2c79\u2c7a\u0007\u0011\u0000\u0000"+ + "\u2c7a\u2c7b\u0007\u0003\u0000\u0000\u2c7b\u2c7c\u0007\u0005\u0000\u0000"+ + "\u2c7c\u076a\u0001\u0000\u0000\u0000\u2c7d\u2c7e\u0007\u0017\u0000\u0000"+ + "\u2c7e\u2c7f\u0007\u0010\u0000\u0000\u2c7f\u2c80\u0007\b\u0000\u0000\u2c80"+ + "\u2c81\u0007\u000f\u0000\u0000\u2c81\u2c82\u0007\f\u0000\u0000\u2c82\u2c83"+ + "\u0007\u0006\u0000\u0000\u2c83\u2c84\u0007\u0007\u0000\u0000\u2c84\u2c85"+ + "\u0007\b\u0000\u0000\u2c85\u2c86\u0007\u000b\u0000\u0000\u2c86\u2c87\u0007"+ + "\u0007\u0000\u0000\u2c87\u2c88\u0007\u000e\u0000\u0000\u2c88\u2c89\u0007"+ + "\u0006\u0000\u0000\u2c89\u2c8a\u0007\u000b\u0000\u0000\u2c8a\u076c\u0001"+ + "\u0000\u0000\u0000\u2c8b\u2c8c\u0007\u0017\u0000\u0000\u2c8c\u2c8d\u0007"+ + "\u0010\u0000\u0000\u2c8d\u2c8e\u0007\b\u0000\u0000\u2c8e\u2c8f\u0007\u0013"+ + "\u0000\u0000\u2c8f\u2c90\u0007\u0018\u0000\u0000\u2c90\u2c91\u0007\u0007"+ + "\u0000\u0000\u2c91\u2c92\u0007\b\u0000\u0000\u2c92\u2c93\u0007\u0005\u0000"+ + "\u0000\u2c93\u2c94\u0007\u0003\u0000\u0000\u2c94\u2c95\u0007\u0019\u0000"+ + "\u0000\u2c95\u2c96\u0007\u000b\u0000\u0000\u2c96\u076e\u0001\u0000\u0000"+ + "\u0000\u2c97\u2c98\u0007\u0017\u0000\u0000\u2c98\u2c99\u0007\u0010\u0000"+ + "\u0000\u2c99\u2c9a\u0007\b\u0000\u0000\u2c9a\u2c9b\u0007\u0006\u0000\u0000"+ + "\u2c9b\u2c9c\u0007\u0013\u0000\u0000\u2c9c\u2c9d\u0007\u0011\u0000\u0000"+ + "\u2c9d\u2c9e\u0007\u000e\u0000\u0000\u2c9e\u2c9f\u0007\u0014\u0000\u0000"+ + "\u2c9f\u2ca0\u0007\u0007\u0000\u0000\u2ca0\u2ca1\u0007\u000b\u0000\u0000"+ + "\u2ca1\u0770\u0001\u0000\u0000\u0000\u2ca2\u2ca3\u0007\u0017\u0000\u0000"+ + "\u2ca3\u2ca4\u0007\u0010\u0000\u0000\u2ca4\u2ca5\u0007\b\u0000\u0000\u2ca5"+ + "\u2ca6\u0007\t\u0000\u0000\u2ca6\u2ca7\u0007\u000f\u0000\u0000\u2ca7\u2ca8"+ + "\u0007\u0006\u0000\u0000\u2ca8\u2ca9\u0007\u0014\u0000\u0000\u2ca9\u2caa"+ + "\u0007\u000f\u0000\u0000\u2caa\u2cab\u0007\f\u0000\u0000\u2cab\u0772\u0001"+ + "\u0000\u0000\u0000\u2cac\u2cad\u0007\u0017\u0000\u0000\u2cad\u2cae\u0007"+ + "\u0004\u0000\u0000\u2cae\u2caf\u00055\u0000\u0000\u2caf\u0774\u0001\u0000"+ + "\u0000\u0000\u2cb0\u2cb1\u0007\u0017\u0000\u0000\u2cb1\u2cb2\u0007\u0005"+ + "\u0000\u0000\u2cb2\u2cb3\u0007\u000f\u0000\u0000\u2cb3\u2cb4\u0007\f\u0000"+ + "\u0000\u2cb4\u2cb5\u0007\u0007\u0000\u0000\u2cb5\u2cb6\u0007\u0012\u0000"+ + "\u0000\u2cb6\u2cb7\u0007\b\u0000\u0000\u2cb7\u2cb8\u0007\u0013\u0000\u0000"+ + "\u2cb8\u2cb9\u0007\u0017\u0000\u0000\u2cb9\u2cba\u0007\u0006\u0000\u0000"+ + "\u2cba\u2cbb\u0007\u0007\u0000\u0000\u2cbb\u2cbc\u0007\u001a\u0000\u0000"+ + "\u2cbc\u2cbd\u0007\u0006\u0000\u0000\u2cbd\u0776\u0001\u0000\u0000\u0000"+ + "\u2cbe\u2cbf\u0007\u0017\u0000\u0000\u2cbf\u2cc0\u0007\u0005\u0000\u0000"+ + "\u2cc0\u2cc1\u0007\u000f\u0000\u0000\u2cc1\u2cc2\u0007\f\u0000\u0000\u2cc2"+ + "\u2cc3\u0007\u0007\u0000\u0000\u2cc3\u2cc4\u0007\u0012\u0000\u0000\u2cc4"+ + "\u2cc5\u0007\b\u0000\u0000\u2cc5\u2cc6\u0007\u0013\u0000\u0000\u2cc6\u2cc7"+ + "\u0007\u0017\u0000\u0000\u2cc7\u2cc8\u0007\t\u0000\u0000\u2cc8\u2cc9\u0007"+ + "\u0015\u0000\u0000\u2cc9\u2cca\u0007\u0010\u0000\u0000\u2cca\u0778\u0001"+ + "\u0000\u0000\u0000\u2ccb\u2ccc\u0007\u0017\u0000\u0000\u2ccc\u2ccd\u0007"+ + "\u0013\u0000\u0000\u2ccd\u2cce\u0007\f\u0000\u0000\u2cce\u2ccf\u0007\u0006"+ + "\u0000\u0000\u2ccf\u2cd0\u0007\u0014\u0000\u0000\u2cd0\u2cd1\u0007\f\u0000"+ + "\u0000\u2cd1\u2cd2\u0007\u0003\u0000\u0000\u2cd2\u2cd3\u0007\u0017\u0000"+ + "\u0000\u2cd3\u2cd4\u0007\u0007\u0000\u0000\u2cd4\u077a\u0001\u0000\u0000"+ + "\u0000\u2cd5\u2cd6\u0007\u0017\u0000\u0000\u2cd6\u2cd7\u0007\u0019\u0000"+ + "\u0000\u2cd7\u2cd8\u0007\u0013\u0000\u0000\u2cd8\u2cd9\u0007\u000f\u0000"+ + "\u0000\u2cd9\u2cda\u0007\f\u0000\u0000\u2cda\u2cdb\u0007\u0006\u0000\u0000"+ + "\u2cdb\u2cdc\u0007\u0012\u0000\u0000\u2cdc\u2cdd\u0007\b\u0000\u0000\u2cdd"+ + "\u2cde\u0007\u0013\u0000\u0000\u2cde\u2cdf\u0007\u0017\u0000\u0000\u2cdf"+ + "\u2ce0\u0007\u0006\u0000\u0000\u2ce0\u2ce1\u0007\u0007\u0000\u0000\u2ce1"+ + "\u2ce2\u0007\u001a\u0000\u0000\u2ce2\u2ce3\u0007\u0006\u0000\u0000\u2ce3"+ + "\u077c\u0001\u0000\u0000\u0000\u2ce4\u2ce5\u0007\u0017\u0000\u0000\u2ce5"+ + "\u2ce6\u0007\u0019\u0000\u0000\u2ce6\u2ce7\u0007\u0013\u0000\u0000\u2ce7"+ + "\u2ce8\u0007\u000f\u0000\u0000\u2ce8\u2ce9\u0007\f\u0000\u0000\u2ce9\u2cea"+ + "\u0007\u0006\u0000\u0000\u2cea\u2ceb\u0007\u0012\u0000\u0000\u2ceb\u2cec"+ + "\u0007\b\u0000\u0000\u2cec\u2ced\u0007\u0013\u0000\u0000\u2ced\u2cee\u0007"+ + "\u0017\u0000\u0000\u2cee\u2cef\u0007\t\u0000\u0000\u2cef\u2cf0\u0007\u0015"+ + "\u0000\u0000\u2cf0\u2cf1\u0007\u0010\u0000\u0000\u2cf1\u077e\u0001\u0000"+ + "\u0000\u0000\u2cf2\u2cf3\u0007\u0017\u0000\u0000\u2cf3\u2cf4\u0007\u0019"+ + "\u0000\u0000\u2cf4\u2cf5\u0007\u0013\u0000\u0000\u2cf5\u2cf6\u0007\u0005"+ + "\u0000\u0000\u2cf6\u2cf7\u0007\n\u0000\u0000\u2cf7\u2cf8\u0007\u0012\u0000"+ + "\u0000\u2cf8\u2cf9\u0007\b\u0000\u0000\u2cf9\u2cfa\u0007\u0013\u0000\u0000"+ + "\u2cfa\u2cfb\u0007\u0017\u0000\u0000\u2cfb\u2cfc\u0007\u0006\u0000\u0000"+ + "\u2cfc\u2cfd\u0007\u0007\u0000\u0000\u2cfd\u2cfe\u0007\u001a\u0000\u0000"+ + "\u2cfe\u2cff\u0007\u0006\u0000\u0000\u2cff\u0780\u0001\u0000\u0000\u0000"+ + "\u2d00\u2d01\u0007\u0017\u0000\u0000\u2d01\u2d02\u0007\u0019\u0000\u0000"+ + "\u2d02\u2d03\u0007\u0013\u0000\u0000\u2d03\u2d04\u0007\u0005\u0000\u0000"+ + "\u2d04\u2d05\u0007\n\u0000\u0000\u2d05\u2d06\u0007\u0012\u0000\u0000\u2d06"+ + "\u2d07\u0007\b\u0000\u0000\u2d07\u2d08\u0007\u0013\u0000\u0000\u2d08\u2d09"+ + "\u0007\u0017\u0000\u0000\u2d09\u2d0a\u0007\t\u0000\u0000\u2d0a\u2d0b\u0007"+ + "\u0015\u0000\u0000\u2d0b\u2d0c\u0007\u0010\u0000\u0000\u2d0c\u0782\u0001"+ + "\u0000\u0000\u0000\u2d0d\u2d0e\u0007\u0017\u0000\u0000\u2d0e\u2d0f\u0007"+ + "\u0011\u0000\u0000\u2d0f\u2d10\u0007\u0005\u0000\u0000\u2d10\u2d11\u0007"+ + "\u0006\u0000\u0000\u2d11\u2d12\u0007\u000f\u0000\u0000\u2d12\u2d13\u0007"+ + "\u0005\u0000\u0000\u2d13\u2d14\u0007\u000f\u0000\u0000\u2d14\u2d15\u0007"+ + "\f\u0000\u0000\u2d15\u2d16\u0007\u0007\u0000\u0000\u2d16\u2d17\u0007\u000b"+ + "\u0000\u0000\u2d17\u2d18\u0007\u0006\u0000\u0000\u2d18\u2d19\u0007\b\u0000"+ + "\u0000\u2d19\u2d1a\u0007\u000f\u0000\u0000\u2d1a\u2d1b\u0007\f\u0000\u0000"+ + "\u2d1b\u2d1c\u0007\u0016\u0000\u0000\u2d1c\u2d1d\u0007\u0012\u0000\u0000"+ + "\u2d1d\u2d1e\u0007\b\u0000\u0000\u2d1e\u2d1f\u0007\u0013\u0000\u0000\u2d1f"+ + "\u2d20\u0007\u0017\u0000\u0000\u2d20\u2d21\u0007\u0006\u0000\u0000\u2d21"+ + "\u2d22\u0007\u0007\u0000\u0000\u2d22\u2d23\u0007\u001a\u0000\u0000\u2d23"+ + "\u2d24\u0007\u0006\u0000\u0000\u2d24\u0784\u0001\u0000\u0000\u0000\u2d25"+ + "\u2d26\u0007\u0017\u0000\u0000\u2d26\u2d27\u0007\u0011\u0000\u0000\u2d27"+ + "\u2d28\u0007\u0005\u0000\u0000\u2d28\u2d29\u0007\u0006\u0000\u0000\u2d29"+ + "\u2d2a\u0007\u000f\u0000\u0000\u2d2a\u2d2b\u0007\u0005\u0000\u0000\u2d2b"+ + "\u2d2c\u0007\u000f\u0000\u0000\u2d2c\u2d2d\u0007\f\u0000\u0000\u2d2d\u2d2e"+ + "\u0007\u0007\u0000\u0000\u2d2e\u2d2f\u0007\u000b\u0000\u0000\u2d2f\u2d30"+ + "\u0007\u0006\u0000\u0000\u2d30\u2d31\u0007\b\u0000\u0000\u2d31\u2d32\u0007"+ + "\u000f\u0000\u0000\u2d32\u2d33\u0007\f\u0000\u0000\u2d33\u2d34\u0007\u0016"+ + "\u0000\u0000\u2d34\u2d35\u0007\u0012\u0000\u0000\u2d35\u2d36\u0007\b\u0000"+ + "\u0000\u2d36\u2d37\u0007\u0013\u0000\u0000\u2d37\u2d38\u0007\u0017\u0000"+ + "\u0000\u2d38\u2d39\u0007\t\u0000\u0000\u2d39\u2d3a\u0007\u0015\u0000\u0000"+ + "\u2d3a\u2d3b\u0007\u0010\u0000\u0000\u2d3b\u0786\u0001\u0000\u0000\u0000"+ + "\u2d3c\u2d3d\u0007\u0017\u0000\u0000\u2d3d\u2d3e\u0007\u0011\u0000\u0000"+ + "\u2d3e\u2d3f\u0007\u0005\u0000\u0000\u2d3f\u2d40\u0007\u0006\u0000\u0000"+ + "\u2d40\u2d41\u0007\u000f\u0000\u0000\u2d41\u2d42\u0007\u0019\u0000\u0000"+ + "\u2d42\u2d43\u0007\u0013\u0000\u0000\u2d43\u2d44\u0007\u000f\u0000\u0000"+ + "\u2d44\u2d45\u0007\f\u0000\u0000\u2d45\u2d46\u0007\u0006\u0000\u0000\u2d46"+ + "\u2d47\u0007\u0012\u0000\u0000\u2d47\u2d48\u0007\b\u0000\u0000\u2d48\u2d49"+ + "\u0007\u0013\u0000\u0000\u2d49\u2d4a\u0007\u0017\u0000\u0000\u2d4a\u2d4b"+ + "\u0007\u0006\u0000\u0000\u2d4b\u2d4c\u0007\u0007\u0000\u0000\u2d4c\u2d4d"+ + "\u0007\u001a\u0000\u0000\u2d4d\u2d4e\u0007\u0006\u0000\u0000\u2d4e\u0788"+ + "\u0001\u0000\u0000\u0000\u2d4f\u2d50\u0007\u0017\u0000\u0000\u2d50\u2d51"+ + "\u0007\u0011\u0000\u0000\u2d51\u2d52\u0007\u0005\u0000\u0000\u2d52\u2d53"+ + "\u0007\u0006\u0000\u0000\u2d53\u2d54\u0007\u000f\u0000\u0000\u2d54\u2d55"+ + "\u0007\u0019\u0000\u0000\u2d55\u2d56\u0007\u0013\u0000\u0000\u2d56\u2d57"+ + "\u0007\u000f\u0000\u0000\u2d57\u2d58\u0007\f\u0000\u0000\u2d58\u2d59\u0007"+ + "\u0006\u0000\u0000\u2d59\u2d5a\u0007\u0012\u0000\u0000\u2d5a\u2d5b\u0007"+ + "\b\u0000\u0000\u2d5b\u2d5c\u0007\u0013\u0000\u0000\u2d5c\u2d5d\u0007\u0017"+ + "\u0000\u0000\u2d5d\u2d5e\u0007\t\u0000\u0000\u2d5e\u2d5f\u0007\u0015\u0000"+ + "\u0000\u2d5f\u2d60\u0007\u0010\u0000\u0000\u2d60\u078a\u0001\u0000\u0000"+ + "\u0000\u2d61\u2d62\u0007\u0017\u0000\u0000\u2d62\u2d63\u0007\u0011\u0000"+ + "\u0000\u2d63\u2d64\u0007\u0005\u0000\u0000\u2d64\u2d65\u0007\u0006\u0000"+ + "\u0000\u2d65\u2d66\u0007\u000f\u0000\u0000\u2d66\u2d67\u0007\u0019\u0000"+ + "\u0000\u2d67\u2d68\u0007\u0013\u0000\u0000\u2d68\u2d69\u0007\u0005\u0000"+ + "\u0000\u2d69\u2d6a\u0007\n\u0000\u0000\u2d6a\u2d6b\u0007\u0016\u0000\u0000"+ + "\u2d6b\u2d6c\u0007\u0013\u0000\u0000\u2d6c\u2d6d\u0007\f\u0000\u0000\u2d6d"+ + "\u2d6e\u0007\u0012\u0000\u0000\u2d6e\u2d6f\u0007\b\u0000\u0000\u2d6f\u2d70"+ + "\u0007\u0013\u0000\u0000\u2d70\u2d71\u0007\u0017\u0000\u0000\u2d71\u2d72"+ + "\u0007\u0006\u0000\u0000\u2d72\u2d73\u0007\u0007\u0000\u0000\u2d73\u2d74"+ + "\u0007\u001a\u0000\u0000\u2d74\u2d75\u0007\u0006\u0000\u0000\u2d75\u078c"+ + "\u0001\u0000\u0000\u0000\u2d76\u2d77\u0007\u0017\u0000\u0000\u2d77\u2d78"+ + "\u0007\u0011\u0000\u0000\u2d78\u2d79\u0007\u0005\u0000\u0000\u2d79\u2d7a"+ + "\u0007\u0006\u0000\u0000\u2d7a\u2d7b\u0007\u000f\u0000\u0000\u2d7b\u2d7c"+ + "\u0007\u0019\u0000\u0000\u2d7c\u2d7d\u0007\u0013\u0000\u0000\u2d7d\u2d7e"+ + "\u0007\u0005\u0000\u0000\u2d7e\u2d7f\u0007\n\u0000\u0000\u2d7f\u2d80\u0007"+ + "\u0016\u0000\u0000\u2d80\u2d81\u0007\u0013\u0000\u0000\u2d81\u2d82\u0007"+ + "\f\u0000\u0000\u2d82\u2d83\u0007\u0012\u0000\u0000\u2d83\u2d84\u0007\b"+ + "\u0000\u0000\u2d84\u2d85\u0007\u0013\u0000\u0000\u2d85\u2d86\u0007\u0017"+ + "\u0000\u0000\u2d86\u2d87\u0007\t\u0000\u0000\u2d87\u2d88\u0007\u0015\u0000"+ + "\u0000\u2d88\u2d89\u0007\u0010\u0000\u0000\u2d89\u078e\u0001\u0000\u0000"+ + "\u0000\u2d8a\u2d8b\u0007\f\u0000\u0000\u2d8b\u2d8c\u0007\u0003\u0000\u0000"+ + "\u2d8c\u2d8d\u0007\u0017\u0000\u0000\u2d8d\u2d8e\u0007\u0007\u0000\u0000"+ + "\u2d8e\u2d8f\u0005_\u0000\u0000\u2d8f\u2d90\u0007\u000e\u0000\u0000\u2d90"+ + "\u2d91\u0007\u0013\u0000\u0000\u2d91\u2d92\u0007\f\u0000\u0000\u2d92\u2d93"+ + "\u0007\u000b\u0000\u0000\u2d93\u2d94\u0007\u0006\u0000\u0000\u2d94\u0790"+ + "\u0001\u0000\u0000\u0000\u2d95\u2d96\u0007\f\u0000\u0000\u2d96\u2d97\u0007"+ + "\u0011\u0000\u0000\u2d97\u2d98\u0007\u0005\u0000\u0000\u2d98\u2d99\u0007"+ + "\u0005\u0000\u0000\u2d99\u2d9a\u0007\u000f\u0000\u0000\u2d9a\u2d9b\u0007"+ + "\u0012\u0000\u0000\u2d9b\u0792\u0001\u0000\u0000\u0000\u2d9c\u2d9d\u0007"+ + "\f\u0000\u0000\u2d9d\u2d9e\u0007\u0011\u0000\u0000\u2d9e\u2d9f\u0007\u0017"+ + "\u0000\u0000\u2d9f\u2da0\u0007\u0016\u0000\u0000\u2da0\u2da1\u0007\u0007"+ + "\u0000\u0000\u2da1\u2da2\u0007\u0013\u0000\u0000\u2da2\u2da3\u0007\u0017"+ + "\u0000\u0000\u2da3\u2da4\u0007\u0007\u0000\u0000\u2da4\u2da5\u0007\u0006"+ + "\u0000\u0000\u2da5\u2da6\u0007\b\u0000\u0000\u2da6\u2da7\u0007\u000f\u0000"+ + "\u0000\u2da7\u2da8\u0007\u0007\u0000\u0000\u2da8\u2da9\u0007\u000b\u0000"+ + "\u0000\u2da9\u0794\u0001\u0000\u0000\u0000\u2daa\u2dab\u0007\f\u0000\u0000"+ + "\u2dab\u2dac\u0007\u0011\u0000\u0000\u2dac\u2dad\u0007\u0017\u0000\u0000"+ + "\u2dad\u2dae\u0007\u000f\u0000\u0000\u2dae\u2daf\u0007\f\u0000\u0000\u2daf"+ + "\u2db0\u0007\u0006\u0000\u0000\u2db0\u2db1\u0007\u0007\u0000\u0000\u2db1"+ + "\u2db2\u0007\b\u0000\u0000\u2db2\u2db3\u0007\u000f\u0000\u0000\u2db3\u2db4"+ + "\u0007\u0013\u0000\u0000\u2db4\u2db5\u0007\b\u0000\u0000\u2db5\u2db6\u0007"+ + "\b\u0000\u0000\u2db6\u2db7\u0007\u000f\u0000\u0000\u2db7\u2db8\u0007\f"+ + "\u0000\u0000\u2db8\u2db9\u0007\u0016\u0000\u0000\u2db9\u2dba\u0007\u000b"+ + "\u0000\u0000\u2dba\u0796\u0001\u0000\u0000\u0000\u2dbb\u2dbc\u0007\f\u0000"+ + "\u0000\u2dbc\u2dbd\u0007\u0011\u0000\u0000\u2dbd\u2dbe\u0007\u0017\u0000"+ + "\u0000\u2dbe\u2dbf\u0007\u0019\u0000\u0000\u2dbf\u2dc0\u0007\u0013\u0000"+ + "\u0000\u2dc0\u2dc1\u0007\u000f\u0000\u0000\u2dc1\u2dc2\u0007\f\u0000\u0000"+ + "\u2dc2\u2dc3\u0007\u0006\u0000\u0000\u2dc3\u2dc4\u0007\u000b\u0000\u0000"+ + "\u2dc4\u0798\u0001\u0000\u0000\u0000\u2dc5\u2dc6\u0007\u0013\u0000\u0000"+ + "\u2dc6\u2dc7\u0007\u000e\u0000\u0000\u2dc7\u2dc8\u0007\u0006\u0000\u0000"+ + "\u2dc8\u079a\u0001\u0000\u0000\u0000\u2dc9\u2dca\u0007\u0013\u0000\u0000"+ + "\u2dca\u2dcb\u0007\u000e\u0000\u0000\u2dcb\u2dcc\u0007\u0006\u0000\u0000"+ + "\u2dcc\u2dcd\u0007\u0007\u0000\u0000\u2dcd\u2dce\u0007\u0006\u0000\u0000"+ + "\u2dce\u2dcf\u0005_\u0000\u0000\u2dcf\u2dd0\u0007\u0005\u0000\u0000\u2dd0"+ + "\u2dd1\u0007\u0007\u0000\u0000\u2dd1\u2dd2\u0007\f\u0000\u0000\u2dd2\u2dd3"+ + "\u0007\u0016\u0000\u0000\u2dd3\u2dd4\u0007\u0006\u0000\u0000\u2dd4\u2dd5"+ + "\u0007\u0014\u0000\u0000\u2dd5\u079c\u0001\u0000\u0000\u0000\u2dd6\u2dd7"+ + "\u0007\u0013\u0000\u0000\u2dd7\u2dd8\u0007\b\u0000\u0000\u2dd8\u2dd9\u0007"+ + "\u0004\u0000\u0000\u2dd9\u079e\u0001\u0000\u0000\u0000\u2dda\u2ddb\u0007"+ + "\u0013\u0000\u0000\u2ddb\u2ddc\u0007\u0018\u0000\u0000\u2ddc\u2ddd\u0007"+ + "\u0007\u0000\u0000\u2ddd\u2dde\u0007\b\u0000\u0000\u2dde\u2ddf\u0007\u0005"+ + "\u0000\u0000\u2ddf\u2de0\u0007\u0003\u0000\u0000\u2de0\u2de1\u0007\u0019"+ + "\u0000\u0000\u2de1\u2de2\u0007\u000b\u0000\u0000\u2de2\u07a0\u0001\u0000"+ + "\u0000\u0000\u2de3\u2de4\u0007\u0019\u0000\u0000\u2de4\u2de5\u0007\u0007"+ + "\u0000\u0000\u2de5\u2de6\u0007\b\u0000\u0000\u2de6\u2de7\u0007\u000f\u0000"+ + "\u0000\u2de7\u2de8\u0007\u0013\u0000\u0000\u2de8\u2de9\u0007\u0004\u0000"+ + "\u0000\u2de9\u2dea\u0005_\u0000\u0000\u2dea\u2deb\u0007\u0003\u0000\u0000"+ + "\u2deb\u2dec\u0007\u0004\u0000\u0000\u2dec\u2ded\u0007\u0004\u0000\u0000"+ + "\u2ded\u07a2\u0001\u0000\u0000\u0000\u2dee\u2def\u0007\u0019\u0000\u0000"+ + "\u2def\u2df0\u0007\u0007\u0000\u0000\u2df0\u2df1\u0007\b\u0000\u0000\u2df1"+ + "\u2df2\u0007\u000f\u0000\u0000\u2df2\u2df3\u0007\u0013\u0000\u0000\u2df3"+ + "\u2df4\u0007\u0004\u0000\u0000\u2df4\u2df5\u0005_\u0000\u0000\u2df5\u2df6"+ + "\u0007\u0004\u0000\u0000\u2df6\u2df7\u0007\u000f\u0000\u0000\u2df7\u2df8"+ + "\u0007\u0012\u0000\u0000\u2df8\u2df9\u0007\u0012\u0000\u0000\u2df9\u07a4"+ + "\u0001\u0000\u0000\u0000\u2dfa\u2dfb\u0007\u0019\u0000\u0000\u2dfb\u2dfc"+ + "\u0007\u000f\u0000\u0000\u2dfc\u07a6\u0001\u0000\u0000\u0000\u2dfd\u2dfe"+ + "\u0007\u0019\u0000\u0000\u2dfe\u2dff\u0007\u0013\u0000\u0000\u2dff\u2e00"+ + "\u0007\u000f\u0000\u0000\u2e00\u2e01\u0007\f\u0000\u0000\u2e01\u2e02\u0007"+ + "\u0006\u0000\u0000\u2e02\u2e03\u0007\u0012\u0000\u0000\u2e03\u2e04\u0007"+ + "\b\u0000\u0000\u2e04\u2e05\u0007\u0013\u0000\u0000\u2e05\u2e06\u0007\u0017"+ + "\u0000\u0000\u2e06\u2e07\u0007\u0006\u0000\u0000\u2e07\u2e08\u0007\u0007"+ + "\u0000\u0000\u2e08\u2e09\u0007\u001a\u0000\u0000\u2e09\u2e0a\u0007\u0006"+ + "\u0000\u0000\u2e0a\u07a8\u0001\u0000\u0000\u0000\u2e0b\u2e0c\u0007\u0019"+ + "\u0000\u0000\u2e0c\u2e0d\u0007\u0013\u0000\u0000\u2e0d\u2e0e\u0007\u000f"+ + "\u0000\u0000\u2e0e\u2e0f\u0007\f\u0000\u0000\u2e0f\u2e10\u0007\u0006\u0000"+ + "\u0000\u2e10\u2e11\u0007\u0012\u0000\u0000\u2e11\u2e12\u0007\b\u0000\u0000"+ + "\u2e12\u2e13\u0007\u0013\u0000\u0000\u2e13\u2e14\u0007\u0017\u0000\u0000"+ + "\u2e14\u2e15\u0007\t\u0000\u0000\u2e15\u2e16\u0007\u0015\u0000\u0000\u2e16"+ + "\u2e17\u0007\u0010\u0000\u0000\u2e17\u07aa\u0001\u0000\u0000\u0000\u2e18"+ + "\u2e19\u0007\u0019\u0000\u0000\u2e19\u2e1a\u0007\u0013\u0000\u0000\u2e1a"+ + "\u2e1b\u0007\u000f\u0000\u0000\u2e1b\u2e1c\u0007\f\u0000\u0000\u2e1c\u2e1d"+ + "\u0007\u0006\u0000\u0000\u2e1d\u2e1e\u0007\f\u0000\u0000\u2e1e\u07ac\u0001"+ + "\u0000\u0000\u0000\u2e1f\u2e20\u0007\u0019\u0000\u0000\u2e20\u2e21\u0007"+ + "\u0013\u0000\u0000\u2e21\u2e22\u0007\u0005\u0000\u0000\u2e22\u2e23\u0007"+ + "\n\u0000\u0000\u2e23\u2e24\u0007\u0012\u0000\u0000\u2e24\u2e25\u0007\b"+ + "\u0000\u0000\u2e25\u2e26\u0007\u0013\u0000\u0000\u2e26\u2e27\u0007\u0017"+ + "\u0000\u0000\u2e27\u2e28\u0007\u0006\u0000\u0000\u2e28\u2e29\u0007\u0007"+ + "\u0000\u0000\u2e29\u2e2a\u0007\u001a\u0000\u0000\u2e2a\u2e2b\u0007\u0006"+ + "\u0000\u0000\u2e2b\u07ae\u0001\u0000\u0000\u0000\u2e2c\u2e2d\u0007\u0019"+ + "\u0000\u0000\u2e2d\u2e2e\u0007\u0013\u0000\u0000\u2e2e\u2e2f\u0007\u0005"+ + "\u0000\u0000\u2e2f\u2e30\u0007\n\u0000\u0000\u2e30\u2e31\u0007\u0012\u0000"+ + "\u0000\u2e31\u2e32\u0007\b\u0000\u0000\u2e32\u2e33\u0007\u0013\u0000\u0000"+ + "\u2e33\u2e34\u0007\u0017\u0000\u0000\u2e34\u2e35\u0007\t\u0000\u0000\u2e35"+ + "\u2e36\u0007\u0015\u0000\u0000\u2e36\u2e37\u0007\u0010\u0000\u0000\u2e37"+ + "\u07b0\u0001\u0000\u0000\u0000\u2e38\u2e39\u0007\u0019\u0000\u0000\u2e39"+ + "\u2e3a\u0007\u0013\u0000\u0000\u2e3a\u2e3b\u0007\u0005\u0000\u0000\u2e3b"+ + "\u2e3c\u0007\n\u0000\u0000\u2e3c\u2e3d\u0007\u0016\u0000\u0000\u2e3d\u2e3e"+ + "\u0007\u0013\u0000\u0000\u2e3e\u2e3f\u0007\f\u0000\u0000\u2e3f\u2e40\u0007"+ + "\u0012\u0000\u0000\u2e40\u2e41\u0007\b\u0000\u0000\u2e41\u2e42\u0007\u0013"+ + "\u0000\u0000\u2e42\u2e43\u0007\u0017\u0000\u0000\u2e43\u2e44\u0007\u0006"+ + "\u0000\u0000\u2e44\u2e45\u0007\u0007\u0000\u0000\u2e45\u2e46\u0007\u001a"+ + "\u0000\u0000\u2e46\u2e47\u0007\u0006\u0000\u0000\u2e47\u07b2\u0001\u0000"+ + "\u0000\u0000\u2e48\u2e49\u0007\u0019\u0000\u0000\u2e49\u2e4a\u0007\u0013"+ + "\u0000\u0000\u2e4a\u2e4b\u0007\u0005\u0000\u0000\u2e4b\u2e4c\u0007\n\u0000"+ + "\u0000\u2e4c\u2e4d\u0007\u0016\u0000\u0000\u2e4d\u2e4e\u0007\u0013\u0000"+ + "\u0000\u2e4e\u2e4f\u0007\f\u0000\u0000\u2e4f\u2e50\u0007\u0012\u0000\u0000"+ + "\u2e50\u2e51\u0007\b\u0000\u0000\u2e51\u2e52\u0007\u0013\u0000\u0000\u2e52"+ + "\u2e53\u0007\u0017\u0000\u0000\u2e53\u2e54\u0007\t\u0000\u0000\u2e54\u2e55"+ + "\u0007\u0015\u0000\u0000\u2e55\u2e56\u0007\u0010\u0000\u0000\u2e56\u07b4"+ + "\u0001\u0000\u0000\u0000\u2e57\u2e58\u0007\u0019\u0000\u0000\u2e58\u2e59"+ + "\u0007\u0013\u0000\u0000\u2e59\u2e5a\u0007\t\u0000\u0000\u2e5a\u07b6\u0001"+ + "\u0000\u0000\u0000\u2e5b\u2e5c\u0007\u0019\u0000\u0000\u2e5c\u2e5d\u0007"+ + "\u0013\u0000\u0000\u2e5d\u2e5e\u0007\t\u0000\u0000\u2e5e\u2e5f\u0007\u0007"+ + "\u0000\u0000\u2e5f\u2e60\u0007\b\u0000\u0000\u2e60\u07b8\u0001\u0000\u0000"+ + "\u0000\u2e61\u2e62\u0007\u001c\u0000\u0000\u2e62\u2e63\u0007\u0011\u0000"+ + "\u0000\u2e63\u2e64\u0007\u0013\u0000\u0000\u2e64\u2e65\u0007\u0006\u0000"+ + "\u0000\u2e65\u2e66\u0007\u0007\u0000\u0000\u2e66\u07ba\u0001\u0000\u0000"+ + "\u0000\u2e67\u2e68\u0007\b\u0000\u0000\u2e68\u2e69\u0007\u0003\u0000\u0000"+ + "\u2e69\u2e6a\u0007\u0004\u0000\u0000\u2e6a\u2e6b\u0007\u000f\u0000\u0000"+ + "\u2e6b\u2e6c\u0007\u0003\u0000\u0000\u2e6c\u2e6d\u0007\f\u0000\u0000\u2e6d"+ + "\u2e6e\u0007\u000b\u0000\u0000\u2e6e\u07bc\u0001\u0000\u0000\u0000\u2e6f"+ + "\u2e70\u0007\b\u0000\u0000\u2e70\u2e71\u0007\u0003\u0000\u0000\u2e71\u2e72"+ + "\u0007\f\u0000\u0000\u2e72\u2e73\u0007\u0004\u0000\u0000\u2e73\u07be\u0001"+ + "\u0000\u0000\u0000\u2e74\u2e75\u0007\b\u0000\u0000\u2e75\u2e76\u0007\u0003"+ + "\u0000\u0000\u2e76\u2e77\u0007\f\u0000\u0000\u2e77\u2e78\u0007\u0004\u0000"+ + "\u0000\u2e78\u2e79\u0007\u0013\u0000\u0000\u2e79\u2e7a\u0007\u0017\u0000"+ + "\u0000\u2e7a\u07c0\u0001\u0000\u0000\u0000\u2e7b\u2e7c\u0007\b\u0000\u0000"+ + "\u2e7c\u2e7d\u0007\u0003\u0000\u0000\u2e7d\u2e7e\u0007\f\u0000\u0000\u2e7e"+ + "\u2e7f\u0007\u0004\u0000\u0000\u2e7f\u2e80\u0007\u0013\u0000\u0000\u2e80"+ + "\u2e81\u0007\u0017\u0000\u0000\u2e81\u2e82\u0005_\u0000\u0000\u2e82\u2e83"+ + "\u0007\u0010\u0000\u0000\u2e83\u2e84\u0007\n\u0000\u0000\u2e84\u2e85\u0007"+ + "\u0006\u0000\u0000\u2e85\u2e86\u0007\u0007\u0000\u0000\u2e86\u2e87\u0007"+ + "\u000b\u0000\u0000\u2e87\u07c2\u0001\u0000\u0000\u0000\u2e88\u2e89\u0007"+ + "\b\u0000\u0000\u2e89\u2e8a\u0007\u0007\u0000\u0000\u2e8a\u2e8b\u0007\u0005"+ + "\u0000\u0000\u2e8b\u2e8c\u0007\u0007\u0000\u0000\u2e8c\u2e8d\u0007\u0003"+ + "\u0000\u0000\u2e8d\u2e8e\u0007\u000b\u0000\u0000\u2e8e\u2e8f\u0007\u0007"+ + "\u0000\u0000\u2e8f\u2e90\u0005_\u0000\u0000\u2e90\u2e91\u0007\u0005\u0000"+ + "\u0000\u2e91\u2e92\u0007\u0013\u0000\u0000\u2e92\u2e93\u0007\u000e\u0000"+ + "\u0000\u2e93\u2e94\u0007\u0015\u0000\u0000\u2e94\u07c4\u0001\u0000\u0000"+ + "\u0000\u2e95\u2e96\u0007\b\u0000\u0000\u2e96\u2e97\u0007\u0007\u0000\u0000"+ + "\u2e97\u2e98\u0007\u0018\u0000\u0000\u2e98\u2e99\u0007\u0007\u0000\u0000"+ + "\u2e99\u2e9a\u0007\b\u0000\u0000\u2e9a\u2e9b\u0007\u000b\u0000\u0000\u2e9b"+ + "\u2e9c\u0007\u0007\u0000\u0000\u2e9c\u07c6\u0001\u0000\u0000\u0000\u2e9d"+ + "\u2e9e\u0007\b\u0000\u0000\u2e9e\u2e9f\u0007\u0013\u0000\u0000\u2e9f\u2ea0"+ + "\u0007\u0011\u0000\u0000\u2ea0\u2ea1\u0007\f\u0000\u0000\u2ea1\u2ea2\u0007"+ + "\u0004\u0000\u0000\u2ea2\u07c8\u0001\u0000\u0000\u0000\u2ea3\u2ea4\u0007"+ + "\b\u0000\u0000\u2ea4\u2ea5\u0007\u0013\u0000\u0000\u2ea5\u2ea6\u0007\t"+ + "\u0000\u0000\u2ea6\u2ea7\u0005_\u0000\u0000\u2ea7\u2ea8\u0007\u000e\u0000"+ + "\u0000\u2ea8\u2ea9\u0007\u0013\u0000\u0000\u2ea9\u2eaa\u0007\u0011\u0000"+ + "\u0000\u2eaa\u2eab\u0007\f\u0000\u0000\u2eab\u2eac\u0007\u0006\u0000\u0000"+ + "\u2eac\u07ca\u0001\u0000\u0000\u0000\u2ead\u2eae\u0007\b\u0000\u0000\u2eae"+ + "\u2eaf\u0007\u0019\u0000\u0000\u2eaf\u2eb0\u0007\u0003\u0000\u0000\u2eb0"+ + "\u2eb1\u0007\u0004\u0000\u0000\u2eb1\u07cc\u0001\u0000\u0000\u0000\u2eb2"+ + "\u2eb3\u0007\b\u0000\u0000\u2eb3\u2eb4\u0007\u0006\u0000\u0000\u2eb4\u2eb5"+ + "\u0007\b\u0000\u0000\u2eb5\u2eb6\u0007\u000f\u0000\u0000\u2eb6\u2eb7\u0007"+ + "\u0017\u0000\u0000\u2eb7\u07ce\u0001\u0000\u0000\u0000\u2eb8\u2eb9\u0007"+ + "\u000b\u0000\u0000\u2eb9\u2eba\u0007\u0007\u0000\u0000\u2eba\u2ebb\u0007"+ + "\u000e\u0000\u0000\u2ebb\u2ebc\u0005_\u0000\u0000\u2ebc\u2ebd\u0007\u0006"+ + "\u0000\u0000\u2ebd\u2ebe\u0007\u0013\u0000\u0000\u2ebe\u2ebf\u0005_\u0000"+ + "\u0000\u2ebf\u2ec0\u0007\u0006\u0000\u0000\u2ec0\u2ec1\u0007\u000f\u0000"+ + "\u0000\u2ec1\u2ec2\u0007\u0017\u0000\u0000\u2ec2\u2ec3\u0007\u0007\u0000"+ + "\u0000\u2ec3\u07d0\u0001\u0000\u0000\u0000\u2ec4\u2ec5\u0007\u000b\u0000"+ + "\u0000\u2ec5\u2ec6\u0007\u0007\u0000\u0000\u2ec6\u2ec7\u0007\u000e\u0000"+ + "\u0000\u2ec7\u2ec8\u0007\u0013\u0000\u0000\u2ec8\u2ec9\u0007\f\u0000\u0000"+ + "\u2ec9\u2eca\u0007\u0004\u0000\u0000\u2eca\u2ecb\u0007\u0003\u0000\u0000"+ + "\u2ecb\u2ecc\u0007\b\u0000\u0000\u2ecc\u2ecd\u0007\n\u0000\u0000\u2ecd"+ + "\u2ece\u0005_\u0000\u0000\u2ece\u2ecf\u0007\u0007\u0000\u0000\u2ecf\u2ed0"+ + "\u0007\f\u0000\u0000\u2ed0\u2ed1\u0007\u0016\u0000\u0000\u2ed1\u2ed2\u0007"+ + "\u000f\u0000\u0000\u2ed2\u2ed3\u0007\f\u0000\u0000\u2ed3\u2ed4\u0007\u0007"+ + "\u0000\u0000\u2ed4\u2ed5\u0005_\u0000\u0000\u2ed5\u2ed6\u0007\u0003\u0000"+ + "\u0000\u2ed6\u2ed7\u0007\u0006\u0000\u0000\u2ed7\u2ed8\u0007\u0006\u0000"+ + "\u0000\u2ed8\u2ed9\u0007\b\u0000\u0000\u2ed9\u2eda\u0007\u000f\u0000\u0000"+ + "\u2eda\u2edb\u0007\u0010\u0000\u0000\u2edb\u2edc\u0007\u0011\u0000\u0000"+ + "\u2edc\u2edd\u0007\u0006\u0000\u0000\u2edd\u2ede\u0007\u0007\u0000\u0000"+ + "\u2ede\u07d2\u0001\u0000\u0000\u0000\u2edf\u2ee0\u0007\u000b\u0000\u0000"+ + "\u2ee0\u2ee1\u0007\u0007\u0000\u0000\u2ee1\u2ee2\u0007\u000b\u0000\u0000"+ + "\u2ee2\u2ee3\u0007\u000b\u0000\u0000\u2ee3\u2ee4\u0007\u000f\u0000\u0000"+ + "\u2ee4\u2ee5\u0007\u0013\u0000\u0000\u2ee5\u2ee6\u0007\f\u0000\u0000\u2ee6"+ + "\u2ee7\u0005_\u0000\u0000\u2ee7\u2ee8\u0007\u0011\u0000\u0000\u2ee8\u2ee9"+ + "\u0007\u000b\u0000\u0000\u2ee9\u2eea\u0007\u0007\u0000\u0000\u2eea\u2eeb"+ + "\u0007\b\u0000\u0000\u2eeb\u07d4\u0001\u0000\u0000\u0000\u2eec\u2eed\u0007"+ + "\u000b\u0000\u0000\u2eed\u2eee\u0007\u0014\u0000\u0000\u2eee\u2eef\u0007"+ + "\u0003\u0000\u0000\u2eef\u07d6\u0001\u0000\u0000\u0000\u2ef0\u2ef1\u0007"+ + "\u000b\u0000\u0000\u2ef1\u2ef2\u0007\u0014\u0000\u0000\u2ef2\u2ef3\u0007"+ + "\u0003\u0000\u0000\u2ef3\u2ef4\u00051\u0000\u0000\u2ef4\u07d8\u0001\u0000"+ + "\u0000\u0000\u2ef5\u2ef6\u0007\u000b\u0000\u0000\u2ef6\u2ef7\u0007\u0014"+ + "\u0000\u0000\u2ef7\u2ef8\u0007\u0003\u0000\u0000\u2ef8\u2ef9\u00052\u0000"+ + "\u0000\u2ef9\u07da\u0001\u0000\u0000\u0000\u2efa\u2efb\u0007\u000b\u0000"+ + "\u0000\u2efb\u2efc\u0007\u000e\u0000\u0000\u2efc\u2efd\u0007\u0014\u0000"+ + "\u0000\u2efd\u2efe\u0007\u0007\u0000\u0000\u2efe\u2eff\u0007\u0017\u0000"+ + "\u0000\u2eff\u2f00\u0007\u0003\u0000\u0000\u2f00\u2f01\u0005_\u0000\u0000"+ + "\u2f01\u2f02\u0007\f\u0000\u0000\u2f02\u2f03\u0007\u0003\u0000\u0000\u2f03"+ + "\u2f04\u0007\u0017\u0000\u0000\u2f04\u2f05\u0007\u0007\u0000\u0000\u2f05"+ + "\u07dc\u0001\u0000\u0000\u0000\u2f06\u2f07\u0007\u000b\u0000\u0000\u2f07"+ + "\u2f08\u0007\u000f\u0000\u0000\u2f08\u2f09\u0007\u0016\u0000\u0000\u2f09"+ + "\u2f0a\u0007\f\u0000\u0000\u2f0a\u07de\u0001\u0000\u0000\u0000\u2f0b\u2f0c"+ + "\u0007\u000b\u0000\u0000\u2f0c\u2f0d\u0007\u000f\u0000\u0000\u2f0d\u2f0e"+ + "\u0007\f\u0000\u0000\u2f0e\u07e0\u0001\u0000\u0000\u0000\u2f0f\u2f10\u0007"+ + "\u000b\u0000\u0000\u2f10\u2f11\u0007\u0005\u0000\u0000\u2f11\u2f12\u0007"+ + "\u0007\u0000\u0000\u2f12\u2f13\u0007\u0007\u0000\u0000\u2f13\u2f14\u0007"+ + "\u0019\u0000\u0000\u2f14\u07e2\u0001\u0000\u0000\u0000\u2f15\u2f16\u0007"+ + "\u000b\u0000\u0000\u2f16\u2f17\u0007\u0013\u0000\u0000\u2f17\u2f18\u0007"+ + "\u0011\u0000\u0000\u2f18\u2f19\u0007\f\u0000\u0000\u2f19\u2f1a\u0007\u0004"+ + "\u0000\u0000\u2f1a\u2f1b\u0007\u0007\u0000\u0000\u2f1b\u2f1c\u0007\u001a"+ + "\u0000\u0000\u2f1c\u07e4\u0001\u0000\u0000\u0000\u2f1d\u2f1e\u0007\u000b"+ + "\u0000\u0000\u2f1e\u2f1f\u0007\u001c\u0000\u0000\u2f1f\u2f20\u0007\u0005"+ + "\u0000\u0000\u2f20\u2f21\u0005_\u0000\u0000\u2f21\u2f22\u0007\u0006\u0000"+ + "\u0000\u2f22\u2f23\u0007\u0014\u0000\u0000\u2f23\u2f24\u0007\b\u0000\u0000"+ + "\u2f24\u2f25\u0007\u0007\u0000\u0000\u2f25\u2f26\u0007\u0003\u0000\u0000"+ + "\u2f26\u2f27\u0007\u0004\u0000\u0000\u2f27\u2f28\u0005_\u0000\u0000\u2f28"+ + "\u2f29\u0007\t\u0000\u0000\u2f29\u2f2a\u0007\u0003\u0000\u0000\u2f2a\u2f2b"+ + "\u0007\u000f\u0000\u0000\u2f2b\u2f2c\u0007\u0006\u0000\u0000\u2f2c\u2f2d"+ + "\u0005_\u0000\u0000\u2f2d\u2f2e\u0007\u0003\u0000\u0000\u2f2e\u2f2f\u0007"+ + "\u0012\u0000\u0000\u2f2f\u2f30\u0007\u0006\u0000\u0000\u2f30\u2f31\u0007"+ + "\u0007\u0000\u0000\u2f31\u2f32\u0007\b\u0000\u0000\u2f32\u2f33\u0005_"+ + "\u0000\u0000\u2f33\u2f34\u0007\u0016\u0000\u0000\u2f34\u2f35\u0007\u0006"+ + "\u0000\u0000\u2f35\u2f36\u0007\u000f\u0000\u0000\u2f36\u2f37\u0007\u0004"+ + "\u0000\u0000\u2f37\u2f38\u0007\u000b\u0000\u0000\u2f38\u07e6\u0001\u0000"+ + "\u0000\u0000\u2f39\u2f3a\u0007\u000b\u0000\u0000\u2f3a\u2f3b\u0007\u001c"+ + "\u0000\u0000\u2f3b\u2f3c\u0007\b\u0000\u0000\u2f3c\u2f3d\u0007\u0006\u0000"+ + "\u0000\u2f3d\u07e8\u0001\u0000\u0000\u0000\u2f3e\u2f3f\u0007\u000b\u0000"+ + "\u0000\u2f3f\u2f40\u0007\b\u0000\u0000\u2f40\u2f41\u0007\u000f\u0000\u0000"+ + "\u2f41\u2f42\u0007\u0004\u0000\u0000\u2f42\u07ea\u0001\u0000\u0000\u0000"+ + "\u2f43\u2f44\u0007\u000b\u0000\u0000\u2f44\u2f45\u0007\u0006\u0000\u0000"+ + "\u2f45\u2f46\u0007\u0003\u0000\u0000\u2f46\u2f47\u0007\b\u0000\u0000\u2f47"+ + "\u2f48\u0007\u0006\u0000\u0000\u2f48\u2f49\u0007\u0019\u0000\u0000\u2f49"+ + "\u2f4a\u0007\u0013\u0000\u0000\u2f4a\u2f4b\u0007\u000f\u0000\u0000\u2f4b"+ + "\u2f4c\u0007\f\u0000\u0000\u2f4c\u2f4d\u0007\u0006\u0000\u0000\u2f4d\u07ec"+ + "\u0001\u0000\u0000\u0000\u2f4e\u2f4f\u0007\u000b\u0000\u0000\u2f4f\u2f50"+ + "\u0007\u0006\u0000\u0000\u2f50\u2f51\u0007\b\u0000\u0000\u2f51\u2f52\u0007"+ + "\u000e\u0000\u0000\u2f52\u2f53\u0007\u0017\u0000\u0000\u2f53\u2f54\u0007"+ + "\u0019\u0000\u0000\u2f54\u07ee\u0001\u0000\u0000\u0000\u2f55\u2f56\u0007"+ + "\u000b\u0000\u0000\u2f56\u2f57\u0007\u0006\u0000\u0000\u2f57\u2f58\u0007"+ + "\b\u0000\u0000\u2f58\u2f59\u0005_\u0000\u0000\u2f59\u2f5a\u0007\u0006"+ + "\u0000\u0000\u2f5a\u2f5b\u0007\u0013\u0000\u0000\u2f5b\u2f5c\u0005_\u0000"+ + "\u0000\u2f5c\u2f5d\u0007\u0004\u0000\u0000\u2f5d\u2f5e\u0007\u0003\u0000"+ + "\u0000\u2f5e\u2f5f\u0007\u0006\u0000\u0000\u2f5f\u2f60\u0007\u0007\u0000"+ + "\u0000\u2f60\u07f0\u0001\u0000\u0000\u0000\u2f61\u2f62\u0007\u000b\u0000"+ + "\u0000\u2f62\u2f63\u0007\u0006\u0000\u0000\u2f63\u2f64\u0005_\u0000\u0000"+ + "\u2f64\u2f65\u0007\u0003\u0000\u0000\u2f65\u2f66\u0007\b\u0000\u0000\u2f66"+ + "\u2f67\u0007\u0007\u0000\u0000\u2f67\u2f68\u0007\u0003\u0000\u0000\u2f68"+ + "\u07f2\u0001\u0000\u0000\u0000\u2f69\u2f6a\u0007\u000b\u0000\u0000\u2f6a"+ + "\u2f6b\u0007\u0006\u0000\u0000\u2f6b\u2f6c\u0005_\u0000\u0000\u2f6c\u2f6d"+ + "\u0007\u0003\u0000\u0000\u2f6d\u2f6e\u0007\u000b\u0000\u0000\u2f6e\u2f6f"+ + "\u0007\u0010\u0000\u0000\u2f6f\u2f70\u0007\u000f\u0000\u0000\u2f70\u2f71"+ + "\u0007\f\u0000\u0000\u2f71\u2f72\u0007\u0003\u0000\u0000\u2f72\u2f73\u0007"+ + "\b\u0000\u0000\u2f73\u2f74\u0007\n\u0000\u0000\u2f74\u07f4\u0001\u0000"+ + "\u0000\u0000\u2f75\u2f76\u0007\u000b\u0000\u0000\u2f76\u2f77\u0007\u0006"+ + "\u0000\u0000\u2f77\u2f78\u0005_\u0000\u0000\u2f78\u2f79\u0007\u0003\u0000"+ + "\u0000\u2f79\u2f7a\u0007\u000b\u0000\u0000\u2f7a\u2f7b\u0007\u0006\u0000"+ + "\u0000\u2f7b\u2f7c\u0007\u0007\u0000\u0000\u2f7c\u2f7d\u0007\u001a\u0000"+ + "\u0000\u2f7d\u2f7e\u0007\u0006\u0000\u0000\u2f7e\u07f6\u0001\u0000\u0000"+ + "\u0000\u2f7f\u2f80\u0007\u000b\u0000\u0000\u2f80\u2f81\u0007\u0006\u0000"+ + "\u0000\u2f81\u2f82\u0005_\u0000\u0000\u2f82\u2f83\u0007\u0003\u0000\u0000"+ + "\u2f83\u2f84\u0007\u000b\u0000\u0000\u2f84\u2f85\u0007\t\u0000\u0000\u2f85"+ + "\u2f86\u0007\u0015\u0000\u0000\u2f86\u2f87\u0007\u0010\u0000\u0000\u2f87"+ + "\u07f8\u0001\u0000\u0000\u0000\u2f88\u2f89\u0007\u000b\u0000\u0000\u2f89"+ + "\u2f8a\u0007\u0006\u0000\u0000\u2f8a\u2f8b\u0005_\u0000\u0000\u2f8b\u2f8c"+ + "\u0007\u0003\u0000\u0000\u2f8c\u2f8d\u0007\u000b\u0000\u0000\u2f8d\u2f8e"+ + "\u0007\t\u0000\u0000\u2f8e\u2f8f\u0007\u0015\u0000\u0000\u2f8f\u2f90\u0007"+ + "\u0006\u0000\u0000\u2f90\u07fa\u0001\u0000\u0000\u0000\u2f91\u2f92\u0007"+ + "\u000b\u0000\u0000\u2f92\u2f93\u0007\u0006\u0000\u0000\u2f93\u2f94\u0005"+ + "_\u0000\u0000\u2f94\u2f95\u0007\u0010\u0000\u0000\u2f95\u2f96\u0007\u0011"+ + "\u0000\u0000\u2f96\u2f97\u0007\u0012\u0000\u0000\u2f97\u2f98\u0007\u0012"+ + "\u0000\u0000\u2f98\u2f99\u0007\u0007\u0000\u0000\u2f99\u2f9a\u0007\b\u0000"+ + "\u0000\u2f9a\u07fc\u0001\u0000\u0000\u0000\u2f9b\u2f9c\u0007\u000b\u0000"+ + "\u0000\u2f9c\u2f9d\u0007\u0006\u0000\u0000\u2f9d\u2f9e\u0005_\u0000\u0000"+ + "\u2f9e\u2f9f\u0007\u000e\u0000\u0000\u2f9f\u2fa0\u0007\u0007\u0000\u0000"+ + "\u2fa0\u2fa1\u0007\f\u0000\u0000\u2fa1\u2fa2\u0007\u0006\u0000\u0000\u2fa2"+ + "\u2fa3\u0007\b\u0000\u0000\u2fa3\u2fa4\u0007\u0013\u0000\u0000\u2fa4\u2fa5"+ + "\u0007\u000f\u0000\u0000\u2fa5\u2fa6\u0007\u0004\u0000\u0000\u2fa6\u07fe"+ + "\u0001\u0000\u0000\u0000\u2fa7\u2fa8\u0007\u000b\u0000\u0000\u2fa8\u2fa9"+ + "\u0007\u0006\u0000\u0000\u2fa9\u2faa\u0005_\u0000\u0000\u2faa\u2fab\u0007"+ + "\u000e\u0000\u0000\u2fab\u2fac\u0007\u0013\u0000\u0000\u2fac\u2fad\u0007"+ + "\f\u0000\u0000\u2fad\u2fae\u0007\u0006\u0000\u0000\u2fae\u2faf\u0007\u0003"+ + "\u0000\u0000\u2faf\u2fb0\u0007\u000f\u0000\u0000\u2fb0\u2fb1\u0007\f\u0000"+ + "\u0000\u2fb1\u2fb2\u0007\u000b\u0000\u0000\u2fb2\u0800\u0001\u0000\u0000"+ + "\u0000\u2fb3\u2fb4\u0007\u000b\u0000\u0000\u2fb4\u2fb5\u0007\u0006\u0000"+ + "\u0000\u2fb5\u2fb6\u0005_\u0000\u0000\u2fb6\u2fb7\u0007\u000e\u0000\u0000"+ + "\u2fb7\u2fb8\u0007\b\u0000\u0000\u2fb8\u2fb9\u0007\u0013\u0000\u0000\u2fb9"+ + "\u2fba\u0007\u000b\u0000\u0000\u2fba\u2fbb\u0007\u000b\u0000\u0000\u2fbb"+ + "\u2fbc\u0007\u0007\u0000\u0000\u2fbc\u2fbd\u0007\u000b\u0000\u0000\u2fbd"+ + "\u0802\u0001\u0000\u0000\u0000\u2fbe\u2fbf\u0007\u000b\u0000\u0000\u2fbf"+ + "\u2fc0\u0007\u0006\u0000\u0000\u2fc0\u2fc1\u0005_\u0000\u0000\u2fc1\u2fc2"+ + "\u0007\u0004\u0000\u0000\u2fc2\u2fc3\u0007\u000f\u0000\u0000\u2fc3\u2fc4"+ + "\u0007\u0012\u0000\u0000\u2fc4\u2fc5\u0007\u0012\u0000\u0000\u2fc5\u2fc6"+ + "\u0007\u0007\u0000\u0000\u2fc6\u2fc7\u0007\b\u0000\u0000\u2fc7\u2fc8\u0007"+ + "\u0007\u0000\u0000\u2fc8\u2fc9\u0007\f\u0000\u0000\u2fc9\u2fca\u0007\u000e"+ + "\u0000\u0000\u2fca\u2fcb\u0007\u0007\u0000\u0000\u2fcb\u0804\u0001\u0000"+ + "\u0000\u0000\u2fcc\u2fcd\u0007\u000b\u0000\u0000\u2fcd\u2fce\u0007\u0006"+ + "\u0000\u0000\u2fce\u2fcf\u0005_\u0000\u0000\u2fcf\u2fd0\u0007\u0004\u0000"+ + "\u0000\u2fd0\u2fd1\u0007\u000f\u0000\u0000\u2fd1\u2fd2\u0007\u0017\u0000"+ + "\u0000\u2fd2\u2fd3\u0007\u0007\u0000\u0000\u2fd3\u2fd4\u0007\f\u0000\u0000"+ + "\u2fd4\u2fd5\u0007\u000b\u0000\u0000\u2fd5\u2fd6\u0007\u000f\u0000\u0000"+ + "\u2fd6\u2fd7\u0007\u0013\u0000\u0000\u2fd7\u2fd8\u0007\f\u0000\u0000\u2fd8"+ + "\u0806\u0001\u0000\u0000\u0000\u2fd9\u2fda\u0007\u000b\u0000\u0000\u2fda"+ + "\u2fdb\u0007\u0006\u0000\u0000\u2fdb\u2fdc\u0005_\u0000\u0000\u2fdc\u2fdd"+ + "\u0007\u0004\u0000\u0000\u2fdd\u2fde\u0007\u000f\u0000\u0000\u2fde\u2fdf"+ + "\u0007\u000b\u0000\u0000\u2fdf\u2fe0\u0007\u001b\u0000\u0000\u2fe0\u2fe1"+ + "\u0007\u0013\u0000\u0000\u2fe1\u2fe2\u0007\u000f\u0000\u0000\u2fe2\u2fe3"+ + "\u0007\f\u0000\u0000\u2fe3\u2fe4\u0007\u0006\u0000\u0000\u2fe4\u0808\u0001"+ + "\u0000\u0000\u0000\u2fe5\u2fe6\u0007\u000b\u0000\u0000\u2fe6\u2fe7\u0007"+ + "\u0006\u0000\u0000\u2fe7\u2fe8\u0005_\u0000\u0000\u2fe8\u2fe9\u0007\u0004"+ + "\u0000\u0000\u2fe9\u2fea\u0007\u000f\u0000\u0000\u2fea\u2feb\u0007\u000b"+ + "\u0000\u0000\u2feb\u2fec\u0007\u0006\u0000\u0000\u2fec\u2fed\u0007\u0003"+ + "\u0000\u0000\u2fed\u2fee\u0007\f\u0000\u0000\u2fee\u2fef\u0007\u000e\u0000"+ + "\u0000\u2fef\u2ff0\u0007\u0007\u0000\u0000\u2ff0\u080a\u0001\u0000\u0000"+ + "\u0000\u2ff1\u2ff2\u0007\u000b\u0000\u0000\u2ff2\u2ff3\u0007\u0006\u0000"+ + "\u0000\u2ff3\u2ff4\u0005_\u0000\u0000\u2ff4\u2ff5\u0007\u0007\u0000\u0000"+ + "\u2ff5\u2ff6\u0007\f\u0000\u0000\u2ff6\u2ff7\u0007\u0004\u0000\u0000\u2ff7"+ + "\u2ff8\u0007\u0019\u0000\u0000\u2ff8\u2ff9\u0007\u0013\u0000\u0000\u2ff9"+ + "\u2ffa\u0007\u000f\u0000\u0000\u2ffa\u2ffb\u0007\f\u0000\u0000\u2ffb\u2ffc"+ + "\u0007\u0006\u0000\u0000\u2ffc\u080c\u0001\u0000\u0000\u0000\u2ffd\u2ffe"+ + "\u0007\u000b\u0000\u0000\u2ffe\u2fff\u0007\u0006\u0000\u0000\u2fff\u3000"+ + "\u0005_\u0000\u0000\u3000\u3001\u0007\u0007\u0000\u0000\u3001\u3002\u0007"+ + "\f\u0000\u0000\u3002\u3003\u0007\u0018\u0000\u0000\u3003\u3004\u0007\u0007"+ + "\u0000\u0000\u3004\u3005\u0007\u0005\u0000\u0000\u3005\u3006\u0007\u0013"+ + "\u0000\u0000\u3006\u3007\u0007\u0019\u0000\u0000\u3007\u3008\u0007\u0007"+ + "\u0000\u0000\u3008\u080e\u0001\u0000\u0000\u0000\u3009\u300a\u0007\u000b"+ + "\u0000\u0000\u300a\u300b\u0007\u0006\u0000\u0000\u300b\u300c\u0005_\u0000"+ + "\u0000\u300c\u300d\u0007\u0007\u0000\u0000\u300d\u300e\u0007\u001c\u0000"+ + "\u0000\u300e\u300f\u0007\u0011\u0000\u0000\u300f\u3010\u0007\u0003\u0000"+ + "\u0000\u3010\u3011\u0007\u0005\u0000\u0000\u3011\u3012\u0007\u000b\u0000"+ + "\u0000\u3012\u0810\u0001\u0000\u0000\u0000\u3013\u3014\u0007\u000b\u0000"+ + "\u0000\u3014\u3015\u0007\u0006\u0000\u0000\u3015\u3016\u0005_\u0000\u0000"+ + "\u3016\u3017\u0007\u0007\u0000\u0000\u3017\u3018\u0007\u001a\u0000\u0000"+ + "\u3018\u3019\u0007\u0006\u0000\u0000\u3019\u301a\u0007\u0007\u0000\u0000"+ + "\u301a\u301b\u0007\b\u0000\u0000\u301b\u301c\u0007\u000f\u0000\u0000\u301c"+ + "\u301d\u0007\u0013\u0000\u0000\u301d\u301e\u0007\b\u0000\u0000\u301e\u301f"+ + "\u0007\b\u0000\u0000\u301f\u3020\u0007\u000f\u0000\u0000\u3020\u3021\u0007"+ + "\f\u0000\u0000\u3021\u3022\u0007\u0016\u0000\u0000\u3022\u0812\u0001\u0000"+ + "\u0000\u0000\u3023\u3024\u0007\u000b\u0000\u0000\u3024\u3025\u0007\u0006"+ + "\u0000\u0000\u3025\u3026\u0005_\u0000\u0000\u3026\u3027\u0007\u0016\u0000"+ + "\u0000\u3027\u3028\u0007\u0007\u0000\u0000\u3028\u3029\u0007\u0013\u0000"+ + "\u0000\u3029\u302a\u0007\u0017\u0000\u0000\u302a\u302b\u0007\u000e\u0000"+ + "\u0000\u302b\u302c\u0007\u0013\u0000\u0000\u302c\u302d\u0007\u0005\u0000"+ + "\u0000\u302d\u302e\u0007\u0005\u0000\u0000\u302e\u302f\u0007\u0012\u0000"+ + "\u0000\u302f\u3030\u0007\b\u0000\u0000\u3030\u3031\u0007\u0013\u0000\u0000"+ + "\u3031\u3032\u0007\u0017\u0000\u0000\u3032\u3033\u0007\u0006\u0000\u0000"+ + "\u3033\u3034\u0007\u0007\u0000\u0000\u3034\u3035\u0007\u001a\u0000\u0000"+ + "\u3035\u3036\u0007\u0006\u0000\u0000\u3036\u0814\u0001\u0000\u0000\u0000"+ + "\u3037\u3038\u0007\u000b\u0000\u0000\u3038\u3039\u0007\u0006\u0000\u0000"+ + "\u3039\u303a\u0005_\u0000\u0000\u303a\u303b\u0007\u0016\u0000\u0000\u303b"+ + "\u303c\u0007\u0007\u0000\u0000\u303c\u303d\u0007\u0013\u0000\u0000\u303d"+ + "\u303e\u0007\u0017\u0000\u0000\u303e\u303f\u0007\u000e\u0000\u0000\u303f"+ + "\u3040\u0007\u0013\u0000\u0000\u3040\u3041\u0007\u0005\u0000\u0000\u3041"+ + "\u3042\u0007\u0005\u0000\u0000\u3042\u3043\u0007\u0012\u0000\u0000\u3043"+ + "\u3044\u0007\b\u0000\u0000\u3044\u3045\u0007\u0013\u0000\u0000\u3045\u3046"+ + "\u0007\u0017\u0000\u0000\u3046\u3047\u0007\u0006\u0000\u0000\u3047\u3048"+ + "\u0007\u001a\u0000\u0000\u3048\u3049\u0007\u0006\u0000\u0000\u3049\u0816"+ + "\u0001\u0000\u0000\u0000\u304a\u304b\u0007\u000b\u0000\u0000\u304b\u304c"+ + "\u0007\u0006\u0000\u0000\u304c\u304d\u0005_\u0000\u0000\u304d\u304e\u0007"+ + "\u0016\u0000\u0000\u304e\u304f\u0007\u0007\u0000\u0000\u304f\u3050\u0007"+ + "\u0013\u0000\u0000\u3050\u3051\u0007\u0017\u0000\u0000\u3051\u3052\u0007"+ + "\u000e\u0000\u0000\u3052\u3053\u0007\u0013\u0000\u0000\u3053\u3054\u0007"+ + "\u0005\u0000\u0000\u3054\u3055\u0007\u0005\u0000\u0000\u3055\u3056\u0007"+ + "\u0012\u0000\u0000\u3056\u3057\u0007\b\u0000\u0000\u3057\u3058\u0007\u0013"+ + "\u0000\u0000\u3058\u3059\u0007\u0017\u0000\u0000\u3059\u305a\u0007\t\u0000"+ + "\u0000\u305a\u305b\u0007\u0015\u0000\u0000\u305b\u305c\u0007\u0010\u0000"+ + "\u0000\u305c\u0818\u0001\u0000\u0000\u0000\u305d\u305e\u0007\u000b\u0000"+ + "\u0000\u305e\u305f\u0007\u0006\u0000\u0000\u305f\u3060\u0005_\u0000\u0000"+ + "\u3060\u3061\u0007\u0016\u0000\u0000\u3061\u3062\u0007\u0007\u0000\u0000"+ + "\u3062\u3063\u0007\u0013\u0000\u0000\u3063\u3064\u0007\u0017\u0000\u0000"+ + "\u3064\u3065\u0007\u0007\u0000\u0000\u3065\u3066\u0007\u0006\u0000\u0000"+ + "\u3066\u3067\u0007\b\u0000\u0000\u3067\u3068\u0007\n\u0000\u0000\u3068"+ + "\u3069\u0007\u000e\u0000\u0000\u3069\u306a\u0007\u0013\u0000\u0000\u306a"+ + "\u306b\u0007\u0005\u0000\u0000\u306b\u306c\u0007\u0005\u0000\u0000\u306c"+ + "\u306d\u0007\u0007\u0000\u0000\u306d\u306e\u0007\u000e\u0000\u0000\u306e"+ + "\u306f\u0007\u0006\u0000\u0000\u306f\u3070\u0007\u000f\u0000\u0000\u3070"+ + "\u3071\u0007\u0013\u0000\u0000\u3071\u3072\u0007\f\u0000\u0000\u3072\u3073"+ + "\u0007\u0012\u0000\u0000\u3073\u3074\u0007\b\u0000\u0000\u3074\u3075\u0007"+ + "\u0013\u0000\u0000\u3075\u3076\u0007\u0017\u0000\u0000\u3076\u3077\u0007"+ + "\u0006\u0000\u0000\u3077\u3078\u0007\u0007\u0000\u0000\u3078\u3079\u0007"+ + "\u001a\u0000\u0000\u3079\u307a\u0007\u0006\u0000\u0000\u307a\u081a\u0001"+ + "\u0000\u0000\u0000\u307b\u307c\u0007\u000b\u0000\u0000\u307c\u307d\u0007"+ + "\u0006\u0000\u0000\u307d\u307e\u0005_\u0000\u0000\u307e\u307f\u0007\u0016"+ + "\u0000\u0000\u307f\u3080\u0007\u0007\u0000\u0000\u3080\u3081\u0007\u0013"+ + "\u0000\u0000\u3081\u3082\u0007\u0017\u0000\u0000\u3082\u3083\u0007\u0007"+ + "\u0000\u0000\u3083\u3084\u0007\u0006\u0000\u0000\u3084\u3085\u0007\b\u0000"+ + "\u0000\u3085\u3086\u0007\n\u0000\u0000\u3086\u3087\u0007\u000e\u0000\u0000"+ + "\u3087\u3088\u0007\u0013\u0000\u0000\u3088\u3089\u0007\u0005\u0000\u0000"+ + "\u3089\u308a\u0007\u0005\u0000\u0000\u308a\u308b\u0007\u0007\u0000\u0000"+ + "\u308b\u308c\u0007\u000e\u0000\u0000\u308c\u308d\u0007\u0006\u0000\u0000"+ + "\u308d\u308e\u0007\u000f\u0000\u0000\u308e\u308f\u0007\u0013\u0000\u0000"+ + "\u308f\u3090\u0007\f\u0000\u0000\u3090\u3091\u0007\u0012\u0000\u0000\u3091"+ + "\u3092\u0007\b\u0000\u0000\u3092\u3093\u0007\u0013\u0000\u0000\u3093\u3094"+ + "\u0007\u0017\u0000\u0000\u3094\u3095\u0007\t\u0000\u0000\u3095\u3096\u0007"+ + "\u0015\u0000\u0000\u3096\u3097\u0007\u0010\u0000\u0000\u3097\u081c\u0001"+ + "\u0000\u0000\u0000\u3098\u3099\u0007\u000b\u0000\u0000\u3099\u309a\u0007"+ + "\u0006\u0000\u0000\u309a\u309b\u0005_\u0000\u0000\u309b\u309c\u0007\u0016"+ + "\u0000\u0000\u309c\u309d\u0007\u0007\u0000\u0000\u309d\u309e\u0007\u0013"+ + "\u0000\u0000\u309e\u309f\u0007\u0017\u0000\u0000\u309f\u30a0\u0007\u0007"+ + "\u0000\u0000\u30a0\u30a1\u0007\u0006\u0000\u0000\u30a1\u30a2\u0007\b\u0000"+ + "\u0000\u30a2\u30a3\u0007\n\u0000\u0000\u30a3\u30a4\u0007\u0012\u0000\u0000"+ + "\u30a4\u30a5\u0007\b\u0000\u0000\u30a5\u30a6\u0007\u0013\u0000\u0000\u30a6"+ + "\u30a7\u0007\u0017\u0000\u0000\u30a7\u30a8\u0007\u0006\u0000\u0000\u30a8"+ + "\u30a9\u0007\u0007\u0000\u0000\u30a9\u30aa\u0007\u001a\u0000\u0000\u30aa"+ + "\u30ab\u0007\u0006\u0000\u0000\u30ab\u081e\u0001\u0000\u0000\u0000\u30ac"+ + "\u30ad\u0007\u000b\u0000\u0000\u30ad\u30ae\u0007\u0006\u0000\u0000\u30ae"+ + "\u30af\u0005_\u0000\u0000\u30af\u30b0\u0007\u0016\u0000\u0000\u30b0\u30b1"+ + "\u0007\u0007\u0000\u0000\u30b1\u30b2\u0007\u0013\u0000\u0000\u30b2\u30b3"+ + "\u0007\u0017\u0000\u0000\u30b3\u30b4\u0007\u0007\u0000\u0000\u30b4\u30b5"+ + "\u0007\u0006\u0000\u0000\u30b5\u30b6\u0007\b\u0000\u0000\u30b6\u30b7\u0007"+ + "\n\u0000\u0000\u30b7\u30b8\u0007\u0012\u0000\u0000\u30b8\u30b9\u0007\b"+ + "\u0000\u0000\u30b9\u30ba\u0007\u0013\u0000\u0000\u30ba\u30bb\u0007\u0017"+ + "\u0000\u0000\u30bb\u30bc\u0007\t\u0000\u0000\u30bc\u30bd\u0007\u0015\u0000"+ + "\u0000\u30bd\u30be\u0007\u0010\u0000\u0000\u30be\u0820\u0001\u0000\u0000"+ + "\u0000\u30bf\u30c0\u0007\u000b\u0000\u0000\u30c0\u30c1\u0007\u0006\u0000"+ + "\u0000\u30c1\u30c2\u0005_\u0000\u0000\u30c2\u30c3\u0007\u0016\u0000\u0000"+ + "\u30c3\u30c4\u0007\u0007\u0000\u0000\u30c4\u30c5\u0007\u0013\u0000\u0000"+ + "\u30c5\u30c6\u0007\u0017\u0000\u0000\u30c6\u30c7\u0007\u0007\u0000\u0000"+ + "\u30c7\u30c8\u0007\u0006\u0000\u0000\u30c8\u30c9\u0007\b\u0000\u0000\u30c9"+ + "\u30ca\u0007\n\u0000\u0000\u30ca\u30cb\u0007\f\u0000\u0000\u30cb\u0822"+ + "\u0001\u0000\u0000\u0000\u30cc\u30cd\u0007\u000b\u0000\u0000\u30cd\u30ce"+ + "\u0007\u0006\u0000\u0000\u30ce\u30cf\u0005_\u0000\u0000\u30cf\u30d0\u0007"+ + "\u0016\u0000\u0000\u30d0\u30d1\u0007\u0007\u0000\u0000\u30d1\u30d2\u0007"+ + "\u0013\u0000\u0000\u30d2\u30d3\u0007\u0017\u0000\u0000\u30d3\u30d4\u0007"+ + "\u0007\u0000\u0000\u30d4\u30d5\u0007\u0006\u0000\u0000\u30d5\u30d6\u0007"+ + "\b\u0000\u0000\u30d6\u30d7\u0007\n\u0000\u0000\u30d7\u30d8\u0007\u0006"+ + "\u0000\u0000\u30d8\u30d9\u0007\n\u0000\u0000\u30d9\u30da\u0007\u0019\u0000"+ + "\u0000\u30da\u30db\u0007\u0007\u0000\u0000\u30db\u0824\u0001\u0000\u0000"+ + "\u0000\u30dc\u30dd\u0007\u000b\u0000\u0000\u30dd\u30de\u0007\u0006\u0000"+ + "\u0000\u30de\u30df\u0005_\u0000\u0000\u30df\u30e0\u0007\u0016\u0000\u0000"+ + "\u30e0\u30e1\u0007\u0007\u0000\u0000\u30e1\u30e2\u0007\u0013\u0000\u0000"+ + "\u30e2\u30e3\u0007\u0017\u0000\u0000\u30e3\u30e4\u0007\u0012\u0000\u0000"+ + "\u30e4\u30e5\u0007\b\u0000\u0000\u30e5\u30e6\u0007\u0013\u0000\u0000\u30e6"+ + "\u30e7\u0007\u0017\u0000\u0000\u30e7\u30e8\u0007\u0006\u0000\u0000\u30e8"+ + "\u30e9\u0007\u0007\u0000\u0000\u30e9\u30ea\u0007\u001a\u0000\u0000\u30ea"+ + "\u30eb\u0007\u0006\u0000\u0000\u30eb\u0826\u0001\u0000\u0000\u0000\u30ec"+ + "\u30ed\u0007\u000b\u0000\u0000\u30ed\u30ee\u0007\u0006\u0000\u0000\u30ee"+ + "\u30ef\u0005_\u0000\u0000\u30ef\u30f0\u0007\u0016\u0000\u0000\u30f0\u30f1"+ + "\u0007\u0007\u0000\u0000\u30f1\u30f2\u0007\u0013\u0000\u0000\u30f2\u30f3"+ + "\u0007\u0017\u0000\u0000\u30f3\u30f4\u0007\u0012\u0000\u0000\u30f4\u30f5"+ + "\u0007\b\u0000\u0000\u30f5\u30f6\u0007\u0013\u0000\u0000\u30f6\u30f7\u0007"+ + "\u0017\u0000\u0000\u30f7\u30f8\u0007\t\u0000\u0000\u30f8\u30f9\u0007\u0015"+ + "\u0000\u0000\u30f9\u30fa\u0007\u0010\u0000\u0000\u30fa\u0828\u0001\u0000"+ + "\u0000\u0000\u30fb\u30fc\u0007\u000b\u0000\u0000\u30fc\u30fd\u0007\u0006"+ + "\u0000\u0000\u30fd\u30fe\u0005_\u0000\u0000\u30fe\u30ff\u0007\u000f\u0000"+ + "\u0000\u30ff\u3100\u0007\f\u0000\u0000\u3100\u3101\u0007\u0006\u0000\u0000"+ + "\u3101\u3102\u0007\u0007\u0000\u0000\u3102\u3103\u0007\b\u0000\u0000\u3103"+ + "\u3104\u0007\u000f\u0000\u0000\u3104\u3105\u0007\u0013\u0000\u0000\u3105"+ + "\u3106\u0007\b\u0000\u0000\u3106\u3107\u0007\b\u0000\u0000\u3107\u3108"+ + "\u0007\u000f\u0000\u0000\u3108\u3109\u0007\f\u0000\u0000\u3109\u310a\u0007"+ + "\u0016\u0000\u0000\u310a\u310b\u0007\f\u0000\u0000\u310b\u082a\u0001\u0000"+ + "\u0000\u0000\u310c\u310d\u0007\u000b\u0000\u0000\u310d\u310e\u0007\u0006"+ + "\u0000\u0000\u310e\u310f\u0005_\u0000\u0000\u310f\u3110\u0007\u000f\u0000"+ + "\u0000\u3110\u3111\u0007\f\u0000\u0000\u3111\u3112\u0007\u0006\u0000\u0000"+ + "\u3112\u3113\u0007\u0007\u0000\u0000\u3113\u3114\u0007\b\u0000\u0000\u3114"+ + "\u3115\u0007\u000b\u0000\u0000\u3115\u3116\u0007\u0007\u0000\u0000\u3116"+ + "\u3117\u0007\u000e\u0000\u0000\u3117\u3118\u0007\u0006\u0000\u0000\u3118"+ + "\u3119\u0007\u000f\u0000\u0000\u3119\u311a\u0007\u0013\u0000\u0000\u311a"+ + "\u311b\u0007\f\u0000\u0000\u311b\u082c\u0001\u0000\u0000\u0000\u311c\u311d"+ + "\u0007\u000b\u0000\u0000\u311d\u311e\u0007\u0006\u0000\u0000\u311e\u311f"+ + "\u0005_\u0000\u0000\u311f\u3120\u0007\u000f\u0000\u0000\u3120\u3121\u0007"+ + "\f\u0000\u0000\u3121\u3122\u0007\u0006\u0000\u0000\u3122\u3123\u0007\u0007"+ + "\u0000\u0000\u3123\u3124\u0007\b\u0000\u0000\u3124\u3125\u0007\u000b\u0000"+ + "\u0000\u3125\u3126\u0007\u0007\u0000\u0000\u3126\u3127\u0007\u000e\u0000"+ + "\u0000\u3127\u3128\u0007\u0006\u0000\u0000\u3128\u3129\u0007\u000b\u0000"+ + "\u0000\u3129\u082e\u0001\u0000\u0000\u0000\u312a\u312b\u0007\u000b\u0000"+ + "\u0000\u312b\u312c\u0007\u0006\u0000\u0000\u312c\u312d\u0005_\u0000\u0000"+ + "\u312d\u312e\u0007\u000f\u0000\u0000\u312e\u312f\u0007\u000b\u0000\u0000"+ + "\u312f\u3130\u0007\u000e\u0000\u0000\u3130\u3131\u0007\u0005\u0000\u0000"+ + "\u3131\u3132\u0007\u0013\u0000\u0000\u3132\u3133\u0007\u000b\u0000\u0000"+ + "\u3133\u3134\u0007\u0007\u0000\u0000\u3134\u3135\u0007\u0004\u0000\u0000"+ + "\u3135\u0830\u0001\u0000\u0000\u0000\u3136\u3137\u0007\u000b\u0000\u0000"+ + "\u3137\u3138\u0007\u0006\u0000\u0000\u3138\u3139\u0005_\u0000\u0000\u3139"+ + "\u313a\u0007\u000f\u0000\u0000\u313a\u313b\u0007\u000b\u0000\u0000\u313b"+ + "\u313c\u0007\u0007\u0000\u0000\u313c\u313d\u0007\u0017\u0000\u0000\u313d"+ + "\u313e\u0007\u0019\u0000\u0000\u313e\u313f\u0007\u0006\u0000\u0000\u313f"+ + "\u3140\u0007\n\u0000\u0000\u3140\u0832\u0001\u0000\u0000\u0000\u3141\u3142"+ + "\u0007\u000b\u0000\u0000\u3142\u3143\u0007\u0006\u0000\u0000\u3143\u3144"+ + "\u0005_\u0000\u0000\u3144\u3145\u0007\u000f\u0000\u0000\u3145\u3146\u0007"+ + "\u000b\u0000\u0000\u3146\u3147\u0007\u000b\u0000\u0000\u3147\u3148\u0007"+ + "\u000f\u0000\u0000\u3148\u3149\u0007\u0017\u0000\u0000\u3149\u314a\u0007"+ + "\u0019\u0000\u0000\u314a\u314b\u0007\u0005\u0000\u0000\u314b\u314c\u0007"+ + "\u0007\u0000\u0000\u314c\u0834\u0001\u0000\u0000\u0000\u314d\u314e\u0007"+ + "\u000b\u0000\u0000\u314e\u314f\u0007\u0006\u0000\u0000\u314f\u3150\u0005"+ + "_\u0000\u0000\u3150\u3151\u0007\u0005\u0000\u0000\u3151\u3152\u0007\u000f"+ + "\u0000\u0000\u3152\u3153\u0007\f\u0000\u0000\u3153\u3154\u0007\u0007\u0000"+ + "\u0000\u3154\u3155\u0007\u0012\u0000\u0000\u3155\u3156\u0007\b\u0000\u0000"+ + "\u3156\u3157\u0007\u0013\u0000\u0000\u3157\u3158\u0007\u0017\u0000\u0000"+ + "\u3158\u3159\u0007\u0006\u0000\u0000\u3159\u315a\u0007\u0007\u0000\u0000"+ + "\u315a\u315b\u0007\u001a\u0000\u0000\u315b\u315c\u0007\u0006\u0000\u0000"+ + "\u315c\u0836\u0001\u0000\u0000\u0000\u315d\u315e\u0007\u000b\u0000\u0000"+ + "\u315e\u315f\u0007\u0006\u0000\u0000\u315f\u3160\u0005_\u0000\u0000\u3160"+ + "\u3161\u0007\u0005\u0000\u0000\u3161\u3162\u0007\u000f\u0000\u0000\u3162"+ + "\u3163\u0007\f\u0000\u0000\u3163\u3164\u0007\u0007\u0000\u0000\u3164\u3165"+ + "\u0007\u0012\u0000\u0000\u3165\u3166\u0007\b\u0000\u0000\u3166\u3167\u0007"+ + "\u0013\u0000\u0000\u3167\u3168\u0007\u0017\u0000\u0000\u3168\u3169\u0007"+ + "\t\u0000\u0000\u3169\u316a\u0007\u0015\u0000\u0000\u316a\u316b\u0007\u0010"+ + "\u0000\u0000\u316b\u0838\u0001\u0000\u0000\u0000\u316c\u316d\u0007\u000b"+ + "\u0000\u0000\u316d\u316e\u0007\u0006\u0000\u0000\u316e\u316f\u0005_\u0000"+ + "\u0000\u316f\u3170\u0007\u0005\u0000\u0000\u3170\u3171\u0007\u000f\u0000"+ + "\u0000\u3171\u3172\u0007\f\u0000\u0000\u3172\u3173\u0007\u0007\u0000\u0000"+ + "\u3173\u3174\u0007\u000b\u0000\u0000\u3174\u3175\u0007\u0006\u0000\u0000"+ + "\u3175\u3176\u0007\b\u0000\u0000\u3176\u3177\u0007\u000f\u0000\u0000\u3177"+ + "\u3178\u0007\f\u0000\u0000\u3178\u3179\u0007\u0016\u0000\u0000\u3179\u317a"+ + "\u0007\u0012\u0000\u0000\u317a\u317b\u0007\b\u0000\u0000\u317b\u317c\u0007"+ + "\u0013\u0000\u0000\u317c\u317d\u0007\u0017\u0000\u0000\u317d\u317e\u0007"+ + "\u0006\u0000\u0000\u317e\u317f\u0007\u0007\u0000\u0000\u317f\u3180\u0007"+ + "\u001a\u0000\u0000\u3180\u3181\u0007\u0006\u0000\u0000\u3181\u083a\u0001"+ + "\u0000\u0000\u0000\u3182\u3183\u0007\u000b\u0000\u0000\u3183\u3184\u0007"+ + "\u0006\u0000\u0000\u3184\u3185\u0005_\u0000\u0000\u3185\u3186\u0007\u0005"+ + "\u0000\u0000\u3186\u3187\u0007\u000f\u0000\u0000\u3187\u3188\u0007\f\u0000"+ + "\u0000\u3188\u3189\u0007\u0007\u0000\u0000\u3189\u318a\u0007\u000b\u0000"+ + "\u0000\u318a\u318b\u0007\u0006\u0000\u0000\u318b\u318c\u0007\b\u0000\u0000"+ + "\u318c\u318d\u0007\u000f\u0000\u0000\u318d\u318e\u0007\f\u0000\u0000\u318e"+ + "\u318f\u0007\u0016\u0000\u0000\u318f\u3190\u0007\u0012\u0000\u0000\u3190"+ + "\u3191\u0007\b\u0000\u0000\u3191\u3192\u0007\u0013\u0000\u0000\u3192\u3193"+ + "\u0007\u0017\u0000\u0000\u3193\u3194\u0007\t\u0000\u0000\u3194\u3195\u0007"+ + "\u0015\u0000\u0000\u3195\u3196\u0007\u0010\u0000\u0000\u3196\u083c\u0001"+ + "\u0000\u0000\u0000\u3197\u3198\u0007\u000b\u0000\u0000\u3198\u3199\u0007"+ + "\u0006\u0000\u0000\u3199\u319a\u0005_\u0000\u0000\u319a\u319b\u0007\f"+ + "\u0000\u0000\u319b\u319c\u0007\u0011\u0000\u0000\u319c\u319d\u0007\u0017"+ + "\u0000\u0000\u319d\u319e\u0007\u0016\u0000\u0000\u319e\u319f\u0007\u0007"+ + "\u0000\u0000\u319f\u31a0\u0007\u0013\u0000\u0000\u31a0\u31a1\u0007\u0017"+ + "\u0000\u0000\u31a1\u31a2\u0007\u0007\u0000\u0000\u31a2\u31a3\u0007\u0006"+ + "\u0000\u0000\u31a3\u31a4\u0007\b\u0000\u0000\u31a4\u31a5\u0007\u000f\u0000"+ + "\u0000\u31a5\u31a6\u0007\u0007\u0000\u0000\u31a6\u31a7\u0007\u000b\u0000"+ + "\u0000\u31a7\u083e\u0001\u0000\u0000\u0000\u31a8\u31a9\u0007\u000b\u0000"+ + "\u0000\u31a9\u31aa\u0007\u0006\u0000\u0000\u31aa\u31ab\u0005_\u0000\u0000"+ + "\u31ab\u31ac\u0007\f\u0000\u0000\u31ac\u31ad\u0007\u0011\u0000\u0000\u31ad"+ + "\u31ae\u0007\u0017\u0000\u0000\u31ae\u31af\u0007\u000f\u0000\u0000\u31af"+ + "\u31b0\u0007\f\u0000\u0000\u31b0\u31b1\u0007\u0006\u0000\u0000\u31b1\u31b2"+ + "\u0007\u0007\u0000\u0000\u31b2\u31b3\u0007\b\u0000\u0000\u31b3\u31b4\u0007"+ + "\u000f\u0000\u0000\u31b4\u31b5\u0007\u0013\u0000\u0000\u31b5\u31b6\u0007"+ + "\b\u0000\u0000\u31b6\u31b7\u0007\b\u0000\u0000\u31b7\u31b8\u0007\u000f"+ + "\u0000\u0000\u31b8\u31b9\u0007\f\u0000\u0000\u31b9\u31ba\u0007\u0016\u0000"+ + "\u0000\u31ba\u0840\u0001\u0000\u0000\u0000\u31bb\u31bc\u0007\u000b\u0000"+ + "\u0000\u31bc\u31bd\u0007\u0006\u0000\u0000\u31bd\u31be\u0005_\u0000\u0000"+ + "\u31be\u31bf\u0007\f\u0000\u0000\u31bf\u31c0\u0007\u0011\u0000\u0000\u31c0"+ + "\u31c1\u0007\u0017\u0000\u0000\u31c1\u31c2\u0007\u000f\u0000\u0000\u31c2"+ + "\u31c3\u0007\f\u0000\u0000\u31c3\u31c4\u0007\u0006\u0000\u0000\u31c4\u31c5"+ + "\u0007\u0007\u0000\u0000\u31c5\u31c6\u0007\b\u0000\u0000\u31c6\u31c7\u0007"+ + "\u000f\u0000\u0000\u31c7\u31c8\u0007\u0013\u0000\u0000\u31c8\u31c9\u0007"+ + "\b\u0000\u0000\u31c9\u31ca\u0007\b\u0000\u0000\u31ca\u31cb\u0007\u000f"+ + "\u0000\u0000\u31cb\u31cc\u0007\f\u0000\u0000\u31cc\u31cd\u0007\u0016\u0000"+ + "\u0000\u31cd\u31ce\u0007\u000b\u0000\u0000\u31ce\u0842\u0001\u0000\u0000"+ + "\u0000\u31cf\u31d0\u0007\u000b\u0000\u0000\u31d0\u31d1\u0007\u0006\u0000"+ + "\u0000\u31d1\u31d2\u0005_\u0000\u0000\u31d2\u31d3\u0007\f\u0000\u0000"+ + "\u31d3\u31d4\u0007\u0011\u0000\u0000\u31d4\u31d5\u0007\u0017\u0000\u0000"+ + "\u31d5\u31d6\u0007\u0019\u0000\u0000\u31d6\u31d7\u0007\u0013\u0000\u0000"+ + "\u31d7\u31d8\u0007\u000f\u0000\u0000\u31d8\u31d9\u0007\f\u0000\u0000\u31d9"+ + "\u31da\u0007\u0006\u0000\u0000\u31da\u31db\u0007\u000b\u0000\u0000\u31db"+ + "\u0844\u0001\u0000\u0000\u0000\u31dc\u31dd\u0007\u000b\u0000\u0000\u31dd"+ + "\u31de\u0007\u0006\u0000\u0000\u31de\u31df\u0005_\u0000\u0000\u31df\u31e0"+ + "\u0007\u0013\u0000\u0000\u31e0\u31e1\u0007\u0018\u0000\u0000\u31e1\u31e2"+ + "\u0007\u0007\u0000\u0000\u31e2\u31e3\u0007\b\u0000\u0000\u31e3\u31e4\u0007"+ + "\u0005\u0000\u0000\u31e4\u31e5\u0007\u0003\u0000\u0000\u31e5\u31e6\u0007"+ + "\u0019\u0000\u0000\u31e6\u31e7\u0007\u000b\u0000\u0000\u31e7\u0846\u0001"+ + "\u0000\u0000\u0000\u31e8\u31e9\u0007\u000b\u0000\u0000\u31e9\u31ea\u0007"+ + "\u0006\u0000\u0000\u31ea\u31eb\u0005_\u0000\u0000\u31eb\u31ec\u0007\u0019"+ + "\u0000\u0000\u31ec\u31ed\u0007\u0013\u0000\u0000\u31ed\u31ee\u0007\u000f"+ + "\u0000\u0000\u31ee\u31ef\u0007\f\u0000\u0000\u31ef\u31f0\u0007\u0006\u0000"+ + "\u0000\u31f0\u31f1\u0007\u0012\u0000\u0000\u31f1\u31f2\u0007\b\u0000\u0000"+ + "\u31f2\u31f3\u0007\u0013\u0000\u0000\u31f3\u31f4\u0007\u0017\u0000\u0000"+ + "\u31f4\u31f5\u0007\u0006\u0000\u0000\u31f5\u31f6\u0007\u0007\u0000\u0000"+ + "\u31f6\u31f7\u0007\u001a\u0000\u0000\u31f7\u31f8\u0007\u0006\u0000\u0000"+ + "\u31f8\u0848\u0001\u0000\u0000\u0000\u31f9\u31fa\u0007\u000b\u0000\u0000"+ + "\u31fa\u31fb\u0007\u0006\u0000\u0000\u31fb\u31fc\u0005_\u0000\u0000\u31fc"+ + "\u31fd\u0007\u0019\u0000\u0000\u31fd\u31fe\u0007\u0013\u0000\u0000\u31fe"+ + "\u31ff\u0007\u000f\u0000\u0000\u31ff\u3200\u0007\f\u0000\u0000\u3200\u3201"+ + "\u0007\u0006\u0000\u0000\u3201\u3202\u0007\u0012\u0000\u0000\u3202\u3203"+ + "\u0007\b\u0000\u0000\u3203\u3204\u0007\u0013\u0000\u0000\u3204\u3205\u0007"+ + "\u0017\u0000\u0000\u3205\u3206\u0007\t\u0000\u0000\u3206\u3207\u0007\u0015"+ + "\u0000\u0000\u3207\u3208\u0007\u0010\u0000\u0000\u3208\u084a\u0001\u0000"+ + "\u0000\u0000\u3209\u320a\u0007\u000b\u0000\u0000\u320a\u320b\u0007\u0006"+ + "\u0000\u0000\u320b\u320c\u0005_\u0000\u0000\u320c\u320d\u0007\u0019\u0000"+ + "\u0000\u320d\u320e\u0007\u0013\u0000\u0000\u320e\u320f\u0007\u000f\u0000"+ + "\u0000\u320f\u3210\u0007\f\u0000\u0000\u3210\u3211\u0007\u0006\u0000\u0000"+ + "\u3211\u3212\u0007\f\u0000\u0000\u3212\u084c\u0001\u0000\u0000\u0000\u3213"+ + "\u3214\u0007\u000b\u0000\u0000\u3214\u3215\u0007\u0006\u0000\u0000\u3215"+ + "\u3216\u0005_\u0000\u0000\u3216\u3217\u0007\u0019\u0000\u0000\u3217\u3218"+ + "\u0007\u0013\u0000\u0000\u3218\u3219\u0007\u0005\u0000\u0000\u3219\u321a"+ + "\u0007\n\u0000\u0000\u321a\u321b\u0007\u0012\u0000\u0000\u321b\u321c\u0007"+ + "\b\u0000\u0000\u321c\u321d\u0007\u0013\u0000\u0000\u321d\u321e\u0007\u0017"+ + "\u0000\u0000\u321e\u321f\u0007\u0006\u0000\u0000\u321f\u3220\u0007\u0007"+ + "\u0000\u0000\u3220\u3221\u0007\u001a\u0000\u0000\u3221\u3222\u0007\u0006"+ + "\u0000\u0000\u3222\u084e\u0001\u0000\u0000\u0000\u3223\u3224\u0007\u000b"+ + "\u0000\u0000\u3224\u3225\u0007\u0006\u0000\u0000\u3225\u3226\u0005_\u0000"+ + "\u0000\u3226\u3227\u0007\u0019\u0000\u0000\u3227\u3228\u0007\u0013\u0000"+ + "\u0000\u3228\u3229\u0007\u0005\u0000\u0000\u3229\u322a\u0007\n\u0000\u0000"+ + "\u322a\u322b\u0007\u0012\u0000\u0000\u322b\u322c\u0007\b\u0000\u0000\u322c"+ + "\u322d\u0007\u0013\u0000\u0000\u322d\u322e\u0007\u0017\u0000\u0000\u322e"+ + "\u322f\u0007\t\u0000\u0000\u322f\u3230\u0007\u0015\u0000\u0000\u3230\u3231"+ + "\u0007\u0010\u0000\u0000\u3231\u0850\u0001\u0000\u0000\u0000\u3232\u3233"+ + "\u0007\u000b\u0000\u0000\u3233\u3234\u0007\u0006\u0000\u0000\u3234\u3235"+ + "\u0005_\u0000\u0000\u3235\u3236\u0007\u0019\u0000\u0000\u3236\u3237\u0007"+ + "\u0013\u0000\u0000\u3237\u3238\u0007\u0005\u0000\u0000\u3238\u3239\u0007"+ + "\n\u0000\u0000\u3239\u323a\u0007\u0016\u0000\u0000\u323a\u323b\u0007\u0013"+ + "\u0000\u0000\u323b\u323c\u0007\f\u0000\u0000\u323c\u323d\u0007\u0012\u0000"+ + "\u0000\u323d\u323e\u0007\b\u0000\u0000\u323e\u323f\u0007\u0013\u0000\u0000"+ + "\u323f\u3240\u0007\u0017\u0000\u0000\u3240\u3241\u0007\u0006\u0000\u0000"+ + "\u3241\u3242\u0007\u0007\u0000\u0000\u3242\u3243\u0007\u001a\u0000\u0000"+ + "\u3243\u3244\u0007\u0006\u0000\u0000\u3244\u0852\u0001\u0000\u0000\u0000"+ + "\u3245\u3246\u0007\u000b\u0000\u0000\u3246\u3247\u0007\u0006\u0000\u0000"+ + "\u3247\u3248\u0005_\u0000\u0000\u3248\u3249\u0007\u0019\u0000\u0000\u3249"+ + "\u324a\u0007\u0013\u0000\u0000\u324a\u324b\u0007\u0005\u0000\u0000\u324b"+ + "\u324c\u0007\n\u0000\u0000\u324c\u324d\u0007\u0016\u0000\u0000\u324d\u324e"+ + "\u0007\u0013\u0000\u0000\u324e\u324f\u0007\f\u0000\u0000\u324f\u3250\u0007"+ + "\u0012\u0000\u0000\u3250\u3251\u0007\b\u0000\u0000\u3251\u3252\u0007\u0013"+ + "\u0000\u0000\u3252\u3253\u0007\u0017\u0000\u0000\u3253\u3254\u0007\t\u0000"+ + "\u0000\u3254\u3255\u0007\u0015\u0000\u0000\u3255\u3256\u0007\u0010\u0000"+ + "\u0000\u3256\u0854\u0001\u0000\u0000\u0000\u3257\u3258\u0007\u000b\u0000"+ + "\u0000\u3258\u3259\u0007\u0006\u0000\u0000\u3259\u325a\u0005_\u0000\u0000"+ + "\u325a\u325b\u0007\u000b\u0000\u0000\u325b\u325c\u0007\b\u0000\u0000\u325c"+ + "\u325d\u0007\u000f\u0000\u0000\u325d\u325e\u0007\u0004\u0000\u0000\u325e"+ + "\u0856\u0001\u0000\u0000\u0000\u325f\u3260\u0007\u000b\u0000\u0000\u3260"+ + "\u3261\u0007\u0006\u0000\u0000\u3261\u3262\u0005_\u0000\u0000\u3262\u3263"+ + "\u0007\u000b\u0000\u0000\u3263\u3264\u0007\u0006\u0000\u0000\u3264\u3265"+ + "\u0007\u0003\u0000\u0000\u3265\u3266\u0007\b\u0000\u0000\u3266\u3267\u0007"+ + "\u0006\u0000\u0000\u3267\u3268\u0007\u0019\u0000\u0000\u3268\u3269\u0007"+ + "\u0013\u0000\u0000\u3269\u326a\u0007\u000f\u0000\u0000\u326a\u326b\u0007"+ + "\f\u0000\u0000\u326b\u326c\u0007\u0006\u0000\u0000\u326c\u0858\u0001\u0000"+ + "\u0000\u0000\u326d\u326e\u0007\u000b\u0000\u0000\u326e\u326f\u0007\u0006"+ + "\u0000\u0000\u326f\u3270\u0005_\u0000\u0000\u3270\u3271\u0007\u000b\u0000"+ + "\u0000\u3271\u3272\u0007\n\u0000\u0000\u3272\u3273\u0007\u0017\u0000\u0000"+ + "\u3273\u3274\u0007\u0004\u0000\u0000\u3274\u3275\u0007\u000f\u0000\u0000"+ + "\u3275\u3276\u0007\u0012\u0000\u0000\u3276\u3277\u0007\u0012\u0000\u0000"+ + "\u3277\u3278\u0007\u0007\u0000\u0000\u3278\u3279\u0007\b\u0000\u0000\u3279"+ + "\u327a\u0007\u0007\u0000\u0000\u327a\u327b\u0007\f\u0000\u0000\u327b\u327c"+ + "\u0007\u000e\u0000\u0000\u327c\u327d\u0007\u0007\u0000\u0000\u327d\u085a"+ + "\u0001\u0000\u0000\u0000\u327e\u327f\u0007\u000b\u0000\u0000\u327f\u3280"+ + "\u0007\u0006\u0000\u0000\u3280\u3281\u0005_\u0000\u0000\u3281\u3282\u0007"+ + "\u0006\u0000\u0000\u3282\u3283\u0007\u0013\u0000\u0000\u3283\u3284\u0007"+ + "\u0011\u0000\u0000\u3284\u3285\u0007\u000e\u0000\u0000\u3285\u3286\u0007"+ + "\u0014\u0000\u0000\u3286\u3287\u0007\u0007\u0000\u0000\u3287\u3288\u0007"+ + "\u000b\u0000\u0000\u3288\u085c\u0001\u0000\u0000\u0000\u3289\u328a\u0007"+ + "\u000b\u0000\u0000\u328a\u328b\u0007\u0006\u0000\u0000\u328b\u328c\u0005"+ + "_\u0000\u0000\u328c\u328d\u0007\u0011\u0000\u0000\u328d\u328e\u0007\f"+ + "\u0000\u0000\u328e\u328f\u0007\u000f\u0000\u0000\u328f\u3290\u0007\u0013"+ + "\u0000\u0000\u3290\u3291\u0007\f\u0000\u0000\u3291\u085e\u0001\u0000\u0000"+ + "\u0000\u3292\u3293\u0007\u000b\u0000\u0000\u3293\u3294\u0007\u0006\u0000"+ + "\u0000\u3294\u3295\u0005_\u0000\u0000\u3295\u3296\u0007\t\u0000\u0000"+ + "\u3296\u3297\u0007\u000f\u0000\u0000\u3297\u3298\u0007\u0006\u0000\u0000"+ + "\u3298\u3299\u0007\u0014\u0000\u0000\u3299\u329a\u0007\u000f\u0000\u0000"+ + "\u329a\u329b\u0007\f\u0000\u0000\u329b\u0860\u0001\u0000\u0000\u0000\u329c"+ + "\u329d\u0007\u000b\u0000\u0000\u329d\u329e\u0007\u0006\u0000\u0000\u329e"+ + "\u329f\u0005_\u0000\u0000\u329f\u32a0\u0007\u001a\u0000\u0000\u32a0\u0862"+ + "\u0001\u0000\u0000\u0000\u32a1\u32a2\u0007\u000b\u0000\u0000\u32a2\u32a3"+ + "\u0007\u0006\u0000\u0000\u32a3\u32a4\u0005_\u0000\u0000\u32a4\u32a5\u0007"+ + "\n\u0000\u0000\u32a5\u0864\u0001\u0000\u0000\u0000\u32a6\u32a7\u0007\u000b"+ + "\u0000\u0000\u32a7\u32a8\u0007\u0011\u0000\u0000\u32a8\u32a9\u0007\u0010"+ + "\u0000\u0000\u32a9\u32aa\u0007\u0004\u0000\u0000\u32aa\u32ab\u0007\u0003"+ + "\u0000\u0000\u32ab\u32ac\u0007\u0006\u0000\u0000\u32ac\u32ad\u0007\u0007"+ + "\u0000\u0000\u32ad\u0866\u0001\u0000\u0000\u0000\u32ae\u32af\u0007\u000b"+ + "\u0000\u0000\u32af\u32b0\u0007\u0011\u0000\u0000\u32b0\u32b1\u0007\u0010"+ + "\u0000\u0000\u32b1\u32b2\u0007\u000b\u0000\u0000\u32b2\u32b3\u0007\u0006"+ + "\u0000\u0000\u32b3\u32b4\u0007\b\u0000\u0000\u32b4\u32b5\u0007\u000f\u0000"+ + "\u0000\u32b5\u32b6\u0007\f\u0000\u0000\u32b6\u32b7\u0007\u0016\u0000\u0000"+ + "\u32b7\u32b8\u0005_\u0000\u0000\u32b8\u32b9\u0007\u000f\u0000\u0000\u32b9"+ + "\u32ba\u0007\f\u0000\u0000\u32ba\u32bb\u0007\u0004\u0000\u0000\u32bb\u32bc"+ + "\u0007\u0007\u0000\u0000\u32bc\u32bd\u0007\u001a\u0000\u0000\u32bd\u0868"+ + "\u0001\u0000\u0000\u0000\u32be\u32bf\u0007\u000b\u0000\u0000\u32bf\u32c0"+ + "\u0007\u0011\u0000\u0000\u32c0\u32c1\u0007\u0010\u0000\u0000\u32c1\u32c2"+ + "\u0007\u0006\u0000\u0000\u32c2\u32c3\u0007\u000f\u0000\u0000\u32c3\u32c4"+ + "\u0007\u0017\u0000\u0000\u32c4\u32c5\u0007\u0007\u0000\u0000\u32c5\u086a"+ + "\u0001\u0000\u0000\u0000\u32c6\u32c7\u0007\u000b\u0000\u0000\u32c7\u32c8"+ + "\u0007\n\u0000\u0000\u32c8\u32c9\u0007\u000b\u0000\u0000\u32c9\u32ca\u0007"+ + "\u0006\u0000\u0000\u32ca\u32cb\u0007\u0007\u0000\u0000\u32cb\u32cc\u0007"+ + "\u0017\u0000\u0000\u32cc\u32cd\u0005_\u0000\u0000\u32cd\u32ce\u0007\u0011"+ + "\u0000\u0000\u32ce\u32cf\u0007\u000b\u0000\u0000\u32cf\u32d0\u0007\u0007"+ + "\u0000\u0000\u32d0\u32d1\u0007\b\u0000\u0000\u32d1\u086c\u0001\u0000\u0000"+ + "\u0000\u32d2\u32d3\u0007\u0006\u0000\u0000\u32d3\u32d4\u0007\u0003\u0000"+ + "\u0000\u32d4\u32d5\u0007\f\u0000\u0000\u32d5\u086e\u0001\u0000\u0000\u0000"+ + "\u32d6\u32d7\u0007\u0006\u0000\u0000\u32d7\u32d8\u0007\u000f\u0000\u0000"+ + "\u32d8\u32d9\u0007\u0017\u0000\u0000\u32d9\u32da\u0007\u0007\u0000\u0000"+ + "\u32da\u32db\u0007\u0004\u0000\u0000\u32db\u32dc\u0007\u000f\u0000\u0000"+ + "\u32dc\u32dd\u0007\u0012\u0000\u0000\u32dd\u32de\u0007\u0012\u0000\u0000"+ + "\u32de\u0870\u0001\u0000\u0000\u0000\u32df\u32e0\u0007\u0006\u0000\u0000"+ + "\u32e0\u32e1\u0007\u000f\u0000\u0000\u32e1\u32e2\u0007\u0017\u0000\u0000"+ + "\u32e2\u32e3\u0007\u0007\u0000\u0000\u32e3\u32e4\u0007\u000b\u0000\u0000"+ + "\u32e4\u32e5\u0007\u0006\u0000\u0000\u32e5\u32e6\u0007\u0003\u0000\u0000"+ + "\u32e6\u32e7\u0007\u0017\u0000\u0000\u32e7\u32e8\u0007\u0019\u0000\u0000"+ + "\u32e8\u32e9\u0007\u0003\u0000\u0000\u32e9\u32ea\u0007\u0004\u0000\u0000"+ + "\u32ea\u32eb\u0007\u0004\u0000\u0000\u32eb\u0872\u0001\u0000\u0000\u0000"+ + "\u32ec\u32ed\u0007\u0006\u0000\u0000\u32ed\u32ee\u0007\u000f\u0000\u0000"+ + "\u32ee\u32ef\u0007\u0017\u0000\u0000\u32ef\u32f0\u0007\u0007\u0000\u0000"+ + "\u32f0\u32f1\u0007\u000b\u0000\u0000\u32f1\u32f2\u0007\u0006\u0000\u0000"+ + "\u32f2\u32f3\u0007\u0003\u0000\u0000\u32f3\u32f4\u0007\u0017\u0000\u0000"+ + "\u32f4\u32f5\u0007\u0019\u0000\u0000\u32f5\u32f6\u0007\u0004\u0000\u0000"+ + "\u32f6\u32f7\u0007\u000f\u0000\u0000\u32f7\u32f8\u0007\u0012\u0000\u0000"+ + "\u32f8\u32f9\u0007\u0012\u0000\u0000\u32f9\u0874\u0001\u0000\u0000\u0000"+ + "\u32fa\u32fb\u0007\u0006\u0000\u0000\u32fb\u32fc\u0007\u000f\u0000\u0000"+ + "\u32fc\u32fd\u0007\u0017\u0000\u0000\u32fd\u32fe\u0007\u0007\u0000\u0000"+ + "\u32fe\u32ff\u0005_\u0000\u0000\u32ff\u3300\u0007\u0012\u0000\u0000\u3300"+ + "\u3301\u0007\u0013\u0000\u0000\u3301\u3302\u0007\b\u0000\u0000\u3302\u3303"+ + "\u0007\u0017\u0000\u0000\u3303\u3304\u0007\u0003\u0000\u0000\u3304\u3305"+ + "\u0007\u0006\u0000\u0000\u3305\u0876\u0001\u0000\u0000\u0000\u3306\u3307"+ + "\u0007\u0006\u0000\u0000\u3307\u3308\u0007\u000f\u0000\u0000\u3308\u3309"+ + "\u0007\u0017\u0000\u0000\u3309\u330a\u0007\u0007\u0000\u0000\u330a\u330b"+ + "\u0005_\u0000\u0000\u330b\u330c\u0007\u0006\u0000\u0000\u330c\u330d\u0007"+ + "\u0013\u0000\u0000\u330d\u330e\u0005_\u0000\u0000\u330e\u330f\u0007\u000b"+ + "\u0000\u0000\u330f\u3310\u0007\u0007\u0000\u0000\u3310\u3311\u0007\u000e"+ + "\u0000\u0000\u3311\u0878\u0001\u0000\u0000\u0000\u3312\u3313\u0007\u0006"+ + "\u0000\u0000\u3313\u3314\u0007\u0013\u0000\u0000\u3314\u3315\u0007\u0011"+ + "\u0000\u0000\u3315\u3316\u0007\u000e\u0000\u0000\u3316\u3317\u0007\u0014"+ + "\u0000\u0000\u3317\u3318\u0007\u0007\u0000\u0000\u3318\u3319\u0007\u000b"+ + "\u0000\u0000\u3319\u087a\u0001\u0000\u0000\u0000\u331a\u331b\u0007\u0006"+ + "\u0000\u0000\u331b\u331c\u0007\u0013\u0000\u0000\u331c\u331d\u0005_\u0000"+ + "\u0000\u331d\u331e\u0007\u0010\u0000\u0000\u331e\u331f\u0007\u0003\u0000"+ + "\u0000\u331f\u3320\u0007\u000b\u0000\u0000\u3320\u3321\u0007\u0007\u0000"+ + "\u0000\u3321\u3322\u00056\u0000\u0000\u3322\u3323\u00054\u0000\u0000\u3323"+ + "\u087c\u0001\u0000\u0000\u0000\u3324\u3325\u0007\u0006\u0000\u0000\u3325"+ + "\u3326\u0007\u0013\u0000\u0000\u3326\u3327\u0005_\u0000\u0000\u3327\u3328"+ + "\u0007\u0004\u0000\u0000\u3328\u3329\u0007\u0003\u0000\u0000\u3329\u332a"+ + "\u0007\n\u0000\u0000\u332a\u332b\u0007\u000b\u0000\u0000\u332b\u087e\u0001"+ + "\u0000\u0000\u0000\u332c\u332d\u0007\u0006\u0000\u0000\u332d\u332e\u0007"+ + "\u0013\u0000\u0000\u332e\u332f\u0005_\u0000\u0000\u332f\u3330\u0007\u000b"+ + "\u0000\u0000\u3330\u3331\u0007\u0007\u0000\u0000\u3331\u3332\u0007\u000e"+ + "\u0000\u0000\u3332\u3333\u0007\u0013\u0000\u0000\u3333\u3334\u0007\f\u0000"+ + "\u0000\u3334\u3335\u0007\u0004\u0000\u0000\u3335\u3336\u0007\u000b\u0000"+ + "\u0000\u3336\u0880\u0001\u0000\u0000\u0000\u3337\u3338\u0007\u0006\u0000"+ + "\u0000\u3338\u3339\u0007\u0019\u0000\u0000\u3339\u333a\u0005_\u0000\u0000"+ + "\u333a\u333b\u0007\u000e\u0000\u0000\u333b\u333c\u0007\u0013\u0000\u0000"+ + "\u333c\u333d\u0007\f\u0000\u0000\u333d\u333e\u0007\f\u0000\u0000\u333e"+ + "\u333f\u0007\u0007\u0000\u0000\u333f\u3340\u0007\u000e\u0000\u0000\u3340"+ + "\u3341\u0007\u0006\u0000\u0000\u3341\u3342\u0007\u000f\u0000\u0000\u3342"+ + "\u3343\u0007\u0013\u0000\u0000\u3343\u3344\u0007\f\u0000\u0000\u3344\u3345"+ + "\u0005_\u0000\u0000\u3345\u3346\u0007\u0003\u0000\u0000\u3346\u3347\u0007"+ + "\u0004\u0000\u0000\u3347\u3348\u0007\u0017\u0000\u0000\u3348\u3349\u0007"+ + "\u000f\u0000\u0000\u3349\u334a\u0007\f\u0000\u0000\u334a\u0882\u0001\u0000"+ + "\u0000\u0000\u334b\u334c\u0007\u0011\u0000\u0000\u334c\u334d\u0007\u000e"+ + "\u0000\u0000\u334d\u334e\u0007\u0003\u0000\u0000\u334e\u334f\u0007\u000b"+ + "\u0000\u0000\u334f\u3350\u0007\u0007\u0000\u0000\u3350\u0884\u0001\u0000"+ + "\u0000\u0000\u3351\u3352\u0007\u0011\u0000\u0000\u3352\u3353\u0007\f\u0000"+ + "\u0000\u3353\u3354\u0007\u000e\u0000\u0000\u3354\u3355\u0007\u0013\u0000"+ + "\u0000\u3355\u3356\u0007\u0017\u0000\u0000\u3356\u3357\u0007\u0019\u0000"+ + "\u0000\u3357\u3358\u0007\b\u0000\u0000\u3358\u3359\u0007\u0007\u0000\u0000"+ + "\u3359\u335a\u0007\u000b\u0000\u0000\u335a\u335b\u0007\u000b\u0000\u0000"+ + "\u335b\u0886\u0001\u0000\u0000\u0000\u335c\u335d\u0007\u0011\u0000\u0000"+ + "\u335d\u335e\u0007\f\u0000\u0000\u335e\u335f\u0007\u000e\u0000\u0000\u335f"+ + "\u3360\u0007\u0013\u0000\u0000\u3360\u3361\u0007\u0017\u0000\u0000\u3361"+ + "\u3362\u0007\u0019\u0000\u0000\u3362\u3363\u0007\b\u0000\u0000\u3363\u3364"+ + "\u0007\u0007\u0000\u0000\u3364\u3365\u0007\u000b\u0000\u0000\u3365\u3366"+ + "\u0007\u000b\u0000\u0000\u3366\u3367\u0007\u0007\u0000\u0000\u3367\u3368"+ + "\u0007\u0004\u0000\u0000\u3368\u3369\u0005_\u0000\u0000\u3369\u336a\u0007"+ + "\u0005\u0000\u0000\u336a\u336b\u0007\u0007\u0000\u0000\u336b\u336c\u0007"+ + "\f\u0000\u0000\u336c\u336d\u0007\u0016\u0000\u0000\u336d\u336e\u0007\u0006"+ + "\u0000\u0000\u336e\u336f\u0007\u0014\u0000\u0000\u336f\u0888\u0001\u0000"+ + "\u0000\u0000\u3370\u3371\u0007\u0011\u0000\u0000\u3371\u3372\u0007\f\u0000"+ + "\u0000\u3372\u3373\u0007\u0014\u0000\u0000\u3373\u3374\u0007\u0007\u0000"+ + "\u0000\u3374\u3375\u0007\u001a\u0000\u0000\u3375\u088a\u0001\u0000\u0000"+ + "\u0000\u3376\u3377\u0007\u0011\u0000\u0000"; + private static final String _serializedATNSegment5 = + "\u3377\u3378\u0007\f\u0000\u0000\u3378\u3379\u0007\u000f\u0000\u0000\u3379"+ + "\u337a\u0007\u001a\u0000\u0000\u337a\u337b\u0005_\u0000\u0000\u337b\u337c"+ + "\u0007\u0006\u0000\u0000\u337c\u337d\u0007\u000f\u0000\u0000\u337d\u337e"+ + "\u0007\u0017\u0000\u0000\u337e\u337f\u0007\u0007\u0000\u0000\u337f\u3380"+ + "\u0007\u000b\u0000\u0000\u3380\u3381\u0007\u0006\u0000\u0000\u3381\u3382"+ + "\u0007\u0003\u0000\u0000\u3382\u3383\u0007\u0017\u0000\u0000\u3383\u3384"+ + "\u0007\u0019\u0000\u0000\u3384\u088c\u0001\u0000\u0000\u0000\u3385\u3386"+ + "\u0007\u0011\u0000\u0000\u3386\u3387\u0007\u0019\u0000\u0000\u3387\u3388"+ + "\u0007\u0004\u0000\u0000\u3388\u3389\u0007\u0003\u0000\u0000\u3389\u338a"+ + "\u0007\u0006\u0000\u0000\u338a\u338b\u0007\u0007\u0000\u0000\u338b\u338c"+ + "\u0007\u001a\u0000\u0000\u338c\u338d\u0007\u0017\u0000\u0000\u338d\u338e"+ + "\u0007\u0005\u0000\u0000\u338e\u088e\u0001\u0000\u0000\u0000\u338f\u3390"+ + "\u0007\u0011\u0000\u0000\u3390\u3391\u0007\u0019\u0000\u0000\u3391\u3392"+ + "\u0007\u0019\u0000\u0000\u3392\u3393\u0007\u0007\u0000\u0000\u3393\u3394"+ + "\u0007\b\u0000\u0000\u3394\u0890\u0001\u0000\u0000\u0000\u3395\u3396\u0007"+ + "\u0011\u0000\u0000\u3396\u3397\u0007\u0011\u0000\u0000\u3397\u3398\u0007"+ + "\u000f\u0000\u0000\u3398\u3399\u0007\u0004\u0000\u0000\u3399\u0892\u0001"+ + "\u0000\u0000\u0000\u339a\u339b\u0007\u0011\u0000\u0000\u339b\u339c\u0007"+ + "\u0011\u0000\u0000\u339c\u339d\u0007\u000f\u0000\u0000\u339d\u339e\u0007"+ + "\u0004\u0000\u0000\u339e\u339f\u0005_\u0000\u0000\u339f\u33a0\u0007\u000b"+ + "\u0000\u0000\u33a0\u33a1\u0007\u0014\u0000\u0000\u33a1\u33a2\u0007\u0013"+ + "\u0000\u0000\u33a2\u33a3\u0007\b\u0000\u0000\u33a3\u33a4\u0007\u0006\u0000"+ + "\u0000\u33a4\u0894\u0001\u0000\u0000\u0000\u33a5\u33a6\u0007\u0018\u0000"+ + "\u0000\u33a6\u33a7\u0007\u0003\u0000\u0000\u33a7\u33a8\u0007\u0005\u0000"+ + "\u0000\u33a8\u33a9\u0007\u000f\u0000\u0000\u33a9\u33aa\u0007\u0004\u0000"+ + "\u0000\u33aa\u33ab\u0007\u0003\u0000\u0000\u33ab\u33ac\u0007\u0006\u0000"+ + "\u0000\u33ac\u33ad\u0007\u0007\u0000\u0000\u33ad\u33ae\u0005_\u0000\u0000"+ + "\u33ae\u33af\u0007\u0019\u0000\u0000\u33af\u33b0\u0007\u0003\u0000\u0000"+ + "\u33b0\u33b1\u0007\u000b\u0000\u0000\u33b1\u33b2\u0007\u000b\u0000\u0000"+ + "\u33b2\u33b3\u0007\t\u0000\u0000\u33b3\u33b4\u0007\u0013\u0000\u0000\u33b4"+ + "\u33b5\u0007\b\u0000\u0000\u33b5\u33b6\u0007\u0004\u0000\u0000\u33b6\u33b7"+ + "\u0005_\u0000\u0000\u33b7\u33b8\u0007\u000b\u0000\u0000\u33b8\u33b9\u0007"+ + "\u0006\u0000\u0000\u33b9\u33ba\u0007\b\u0000\u0000\u33ba\u33bb\u0007\u0007"+ + "\u0000\u0000\u33bb\u33bc\u0007\f\u0000\u0000\u33bc\u33bd\u0007\u0016\u0000"+ + "\u0000\u33bd\u33be\u0007\u0006\u0000\u0000\u33be\u33bf\u0007\u0014\u0000"+ + "\u0000\u33bf\u0896\u0001\u0000\u0000\u0000\u33c0\u33c1\u0007\u0018\u0000"+ + "\u0000\u33c1\u33c2\u0007\u0007\u0000\u0000\u33c2\u33c3\u0007\b\u0000\u0000"+ + "\u33c3\u33c4\u0007\u000b\u0000\u0000\u33c4\u33c5\u0007\u000f\u0000\u0000"+ + "\u33c5\u33c6\u0007\u0013\u0000\u0000\u33c6\u33c7\u0007\f\u0000\u0000\u33c7"+ + "\u0898\u0001\u0000\u0000\u0000\u33c8\u33c9\u0007\t\u0000\u0000\u33c9\u33ca"+ + "\u0007\u0003\u0000\u0000\u33ca\u33cb\u0007\u000f\u0000\u0000\u33cb\u33cc"+ + "\u0007\u0006\u0000\u0000\u33cc\u33cd\u0005_\u0000\u0000\u33cd\u33ce\u0007"+ + "\u0011\u0000\u0000\u33ce\u33cf\u0007\f\u0000\u0000\u33cf\u33d0\u0007\u0006"+ + "\u0000\u0000\u33d0\u33d1\u0007\u000f\u0000\u0000\u33d1\u33d2\u0007\u0005"+ + "\u0000\u0000\u33d2\u33d3\u0005_\u0000\u0000\u33d3\u33d4\u0007\u000b\u0000"+ + "\u0000\u33d4\u33d5\u0007\u001c\u0000\u0000\u33d5\u33d6\u0007\u0005\u0000"+ + "\u0000\u33d6\u33d7\u0005_\u0000\u0000\u33d7\u33d8\u0007\u0006\u0000\u0000"+ + "\u33d8\u33d9\u0007\u0014\u0000\u0000\u33d9\u33da\u0007\b\u0000\u0000\u33da"+ + "\u33db\u0007\u0007\u0000\u0000\u33db\u33dc\u0007\u0003\u0000\u0000\u33dc"+ + "\u33dd\u0007\u0004\u0000\u0000\u33dd\u33de\u0005_\u0000\u0000\u33de\u33df"+ + "\u0007\u0003\u0000\u0000\u33df\u33e0\u0007\u0012\u0000\u0000\u33e0\u33e1"+ + "\u0007\u0006\u0000\u0000\u33e1\u33e2\u0007\u0007\u0000\u0000\u33e2\u33e3"+ + "\u0007\b\u0000\u0000\u33e3\u33e4\u0005_\u0000\u0000\u33e4\u33e5\u0007"+ + "\u0016\u0000\u0000\u33e5\u33e6\u0007\u0006\u0000\u0000\u33e6\u33e7\u0007"+ + "\u000f\u0000\u0000\u33e7\u33e8\u0007\u0004\u0000\u0000\u33e8\u33e9\u0007"+ + "\u000b\u0000\u0000\u33e9\u089a\u0001\u0000\u0000\u0000\u33ea\u33eb\u0007"+ + "\t\u0000\u0000\u33eb\u33ec\u0007\u0007\u0000\u0000\u33ec\u33ed\u0007\u0007"+ + "\u0000\u0000\u33ed\u33ee\u0007\u0015\u0000\u0000\u33ee\u33ef\u0007\u0004"+ + "\u0000\u0000\u33ef\u33f0\u0007\u0003\u0000\u0000\u33f0\u33f1\u0007\n\u0000"+ + "\u0000\u33f1\u089c\u0001\u0000\u0000\u0000\u33f2\u33f3\u0007\t\u0000\u0000"+ + "\u33f3\u33f4\u0007\u0007\u0000\u0000\u33f4\u33f5\u0007\u0007\u0000\u0000"+ + "\u33f5\u33f6\u0007\u0015\u0000\u0000\u33f6\u33f7\u0007\u0013\u0000\u0000"+ + "\u33f7\u33f8\u0007\u0012\u0000\u0000\u33f8\u33f9\u0007\n\u0000\u0000\u33f9"+ + "\u33fa\u0007\u0007\u0000\u0000\u33fa\u33fb\u0007\u0003\u0000\u0000\u33fb"+ + "\u33fc\u0007\b\u0000\u0000\u33fc\u089e\u0001\u0000\u0000\u0000\u33fd\u33fe"+ + "\u0007\t\u0000\u0000\u33fe\u33ff\u0007\u0007\u0000\u0000\u33ff\u3400\u0007"+ + "\u000f\u0000\u0000\u3400\u3401\u0007\u0016\u0000\u0000\u3401\u3402\u0007"+ + "\u0014\u0000\u0000\u3402\u3403\u0007\u0006\u0000\u0000\u3403\u3404\u0005"+ + "_\u0000\u0000\u3404\u3405\u0007\u000b\u0000\u0000\u3405\u3406\u0007\u0006"+ + "\u0000\u0000\u3406\u3407\u0007\b\u0000\u0000\u3407\u3408\u0007\u000f\u0000"+ + "\u0000\u3408\u3409\u0007\f\u0000\u0000\u3409\u340a\u0007\u0016\u0000\u0000"+ + "\u340a\u08a0\u0001\u0000\u0000\u0000\u340b\u340c\u0007\t\u0000\u0000\u340c"+ + "\u340d\u0007\u000f\u0000\u0000\u340d\u340e\u0007\u0006\u0000\u0000\u340e"+ + "\u340f\u0007\u0014\u0000\u0000\u340f\u3410\u0007\u000f\u0000\u0000\u3410"+ + "\u3411\u0007\f\u0000\u0000\u3411\u08a2\u0001\u0000\u0000\u0000\u3412\u3413"+ + "\u0007\n\u0000\u0000\u3413\u3414\u0007\u0007\u0000\u0000\u3414\u3415\u0007"+ + "\u0003\u0000\u0000\u3415\u3416\u0007\b\u0000\u0000\u3416\u3417\u0007\t"+ + "\u0000\u0000\u3417\u3418\u0007\u0007\u0000\u0000\u3418\u3419\u0007\u0007"+ + "\u0000\u0000\u3419\u341a\u0007\u0015\u0000\u0000\u341a\u08a4\u0001\u0000"+ + "\u0000\u0000\u341b\u341c\u0007\n\u0000\u0000\u341c\u08a6\u0001\u0000\u0000"+ + "\u0000\u341d\u341e\u0007\u001a\u0000\u0000\u341e\u08a8\u0001\u0000\u0000"+ + "\u0000\u341f\u3420\u0005:\u0000\u0000\u3420\u3421\u0005=\u0000\u0000\u3421"+ + "\u08aa\u0001\u0000\u0000\u0000\u3422\u3423\u0005+\u0000\u0000\u3423\u3424"+ + "\u0005=\u0000\u0000\u3424\u08ac\u0001\u0000\u0000\u0000\u3425\u3426\u0005"+ + "-\u0000\u0000\u3426\u3427\u0005=\u0000\u0000\u3427\u08ae\u0001\u0000\u0000"+ + "\u0000\u3428\u3429\u0005*\u0000\u0000\u3429\u342a\u0005=\u0000\u0000\u342a"+ + "\u08b0\u0001\u0000\u0000\u0000\u342b\u342c\u0005/\u0000\u0000\u342c\u342d"+ + "\u0005=\u0000\u0000\u342d\u08b2\u0001\u0000\u0000\u0000\u342e\u342f\u0005"+ + "%\u0000\u0000\u342f\u3430\u0005=\u0000\u0000\u3430\u08b4\u0001\u0000\u0000"+ + "\u0000\u3431\u3432\u0005&\u0000\u0000\u3432\u3433\u0005=\u0000\u0000\u3433"+ + "\u08b6\u0001\u0000\u0000\u0000\u3434\u3435\u0005^\u0000\u0000\u3435\u3436"+ + "\u0005=\u0000\u0000\u3436\u08b8\u0001\u0000\u0000\u0000\u3437\u3438\u0005"+ + "|\u0000\u0000\u3438\u3439\u0005=\u0000\u0000\u3439\u08ba\u0001\u0000\u0000"+ + "\u0000\u343a\u343b\u0005*\u0000\u0000\u343b\u08bc\u0001\u0000\u0000\u0000"+ + "\u343c\u343d\u0005/\u0000\u0000\u343d\u08be\u0001\u0000\u0000\u0000\u343e"+ + "\u343f\u0005%\u0000\u0000\u343f\u08c0\u0001\u0000\u0000\u0000\u3440\u3441"+ + "\u0005+\u0000\u0000\u3441\u08c2\u0001\u0000\u0000\u0000\u3442\u3443\u0005"+ + "-\u0000\u0000\u3443\u08c4\u0001\u0000\u0000\u0000\u3444\u3445\u0007\u0004"+ + "\u0000\u0000\u3445\u3446\u0007\u000f\u0000\u0000\u3446\u3447\u0007\u0018"+ + "\u0000\u0000\u3447\u08c6\u0001\u0000\u0000\u0000\u3448\u3449\u0007\u0017"+ + "\u0000\u0000\u3449\u344a\u0007\u0013\u0000\u0000\u344a\u344b\u0007\u0004"+ + "\u0000\u0000\u344b\u08c8\u0001\u0000\u0000\u0000\u344c\u344d\u0005=\u0000"+ + "\u0000\u344d\u08ca\u0001\u0000\u0000\u0000\u344e\u344f\u0005>\u0000\u0000"+ + "\u344f\u08cc\u0001\u0000\u0000\u0000\u3450\u3451\u0005<\u0000\u0000\u3451"+ + "\u08ce\u0001\u0000\u0000\u0000\u3452\u3453\u0005!\u0000\u0000\u3453\u08d0"+ + "\u0001\u0000\u0000\u0000\u3454\u3455\u0005~\u0000\u0000\u3455\u08d2\u0001"+ + "\u0000\u0000\u0000\u3456\u3457\u0005|\u0000\u0000\u3457\u08d4\u0001\u0000"+ + "\u0000\u0000\u3458\u3459\u0005&\u0000\u0000\u3459\u08d6\u0001\u0000\u0000"+ + "\u0000\u345a\u345b\u0005^\u0000\u0000\u345b\u08d8\u0001\u0000\u0000\u0000"+ + "\u345c\u345d\u0005.\u0000\u0000\u345d\u08da\u0001\u0000\u0000\u0000\u345e"+ + "\u345f\u0005(\u0000\u0000\u345f\u08dc\u0001\u0000\u0000\u0000\u3460\u3461"+ + "\u0005)\u0000\u0000\u3461\u08de\u0001\u0000\u0000\u0000\u3462\u3463\u0005"+ + ",\u0000\u0000\u3463\u08e0\u0001\u0000\u0000\u0000\u3464\u3465\u0005;\u0000"+ + "\u0000\u3465\u08e2\u0001\u0000\u0000\u0000\u3466\u3467\u0005@\u0000\u0000"+ + "\u3467\u08e4\u0001\u0000\u0000\u0000\u3468\u3469\u00050\u0000\u0000\u3469"+ + "\u08e6\u0001\u0000\u0000\u0000\u346a\u346b\u00051\u0000\u0000\u346b\u08e8"+ + "\u0001\u0000\u0000\u0000\u346c\u346d\u00052\u0000\u0000\u346d\u08ea\u0001"+ + "\u0000\u0000\u0000\u346e\u346f\u0005\'\u0000\u0000\u346f\u08ec\u0001\u0000"+ + "\u0000\u0000\u3470\u3471\u0005\"\u0000\u0000\u3471\u08ee\u0001\u0000\u0000"+ + "\u0000\u3472\u3473\u0005`\u0000\u0000\u3473\u08f0\u0001\u0000\u0000\u0000"+ + "\u3474\u3475\u0005:\u0000\u0000\u3475\u08f2\u0001\u0000\u0000\u0000\u3476"+ + "\u347a\u0003\u08eb\u0475\u0000\u3477\u347a\u0003\u08ed\u0476\u0000\u3478"+ + "\u347a\u0003\u08ef\u0477\u0000\u3479\u3476\u0001\u0000\u0000\u0000\u3479"+ + "\u3477\u0001\u0000\u0000\u0000\u3479\u3478\u0001\u0000\u0000\u0000\u347a"+ + "\u08f4\u0001\u0000\u0000\u0000\u347b\u347c\u0005`\u0000\u0000\u347c\u347d"+ + "\u0003\u0915\u048a\u0000\u347d\u347e\u0005`\u0000\u0000\u347e\u08f6\u0001"+ + "\u0000\u0000\u0000\u347f\u3481\u0003\u0923\u0491\u0000\u3480\u347f\u0001"+ + "\u0000\u0000\u0000\u3481\u3482\u0001\u0000\u0000\u0000\u3482\u3480\u0001"+ + "\u0000\u0000\u0000\u3482\u3483\u0001\u0000\u0000\u0000\u3483\u3484\u0001"+ + "\u0000\u0000\u0000\u3484\u3485\u0007\u001d\u0000\u0000\u3485\u08f8\u0001"+ + "\u0000\u0000\u0000\u3486\u3487\u0007\f\u0000\u0000\u3487\u3488\u0003\u091d"+ + "\u048e\u0000\u3488\u08fa\u0001\u0000\u0000\u0000\u3489\u348d\u0003\u091b"+ + "\u048d\u0000\u348a\u348d\u0003\u091d\u048e\u0000\u348b\u348d\u0003\u091f"+ + "\u048f\u0000\u348c\u3489\u0001\u0000\u0000\u0000\u348c\u348a\u0001\u0000"+ + "\u0000\u0000\u348c\u348b\u0001\u0000\u0000\u0000\u348d\u08fc\u0001\u0000"+ + "\u0000\u0000\u348e\u3490\u0003\u0923\u0491\u0000\u348f\u348e\u0001\u0000"+ + "\u0000\u0000\u3490\u3491\u0001\u0000\u0000\u0000\u3491\u348f\u0001\u0000"+ + "\u0000\u0000\u3491\u3492\u0001\u0000\u0000\u0000\u3492\u08fe\u0001\u0000"+ + "\u0000\u0000\u3493\u3494\u0007\u001a\u0000\u0000\u3494\u3498\u0005\'\u0000"+ + "\u0000\u3495\u3496\u0003\u0921\u0490\u0000\u3496\u3497\u0003\u0921\u0490"+ + "\u0000\u3497\u3499\u0001\u0000\u0000\u0000\u3498\u3495\u0001\u0000\u0000"+ + "\u0000\u3499\u349a\u0001\u0000\u0000\u0000\u349a\u3498\u0001\u0000\u0000"+ + "\u0000\u349a\u349b\u0001\u0000\u0000\u0000\u349b\u349c\u0001\u0000\u0000"+ + "\u0000\u349c\u349d\u0005\'\u0000\u0000\u349d\u34a7\u0001\u0000\u0000\u0000"+ + "\u349e\u349f\u00050\u0000\u0000\u349f\u34a0\u0007\u001a\u0000\u0000\u34a0"+ + "\u34a2\u0001\u0000\u0000\u0000\u34a1\u34a3\u0003\u0921\u0490\u0000\u34a2"+ + "\u34a1\u0001\u0000\u0000\u0000\u34a3\u34a4\u0001\u0000\u0000\u0000\u34a4"+ + "\u34a2\u0001\u0000\u0000\u0000\u34a4\u34a5\u0001\u0000\u0000\u0000\u34a5"+ + "\u34a7\u0001\u0000\u0000\u0000\u34a6\u3493\u0001\u0000\u0000\u0000\u34a6"+ + "\u349e\u0001\u0000\u0000\u0000\u34a7\u0900\u0001\u0000\u0000\u0000\u34a8"+ + "\u34aa\u0003\u0923\u0491\u0000\u34a9\u34a8\u0001\u0000\u0000\u0000\u34aa"+ + "\u34ad\u0001\u0000\u0000\u0000\u34ab\u34a9\u0001\u0000\u0000\u0000\u34ab"+ + "\u34ac\u0001\u0000\u0000\u0000\u34ac\u34ae\u0001\u0000\u0000\u0000\u34ad"+ + "\u34ab\u0001\u0000\u0000\u0000\u34ae\u34b0\u0005.\u0000\u0000\u34af\u34b1"+ + "\u0003\u0923\u0491\u0000\u34b0\u34af\u0001\u0000\u0000\u0000\u34b1\u34b2"+ + "\u0001\u0000\u0000\u0000\u34b2\u34b0\u0001\u0000\u0000\u0000\u34b2\u34b3"+ + "\u0001\u0000\u0000\u0000\u34b3\u34d2\u0001\u0000\u0000\u0000\u34b4\u34b6"+ + "\u0003\u0923\u0491\u0000\u34b5\u34b4\u0001\u0000\u0000\u0000\u34b6\u34b7"+ + "\u0001\u0000\u0000\u0000\u34b7\u34b5\u0001\u0000\u0000\u0000\u34b7\u34b8"+ + "\u0001\u0000\u0000\u0000\u34b8\u34b9\u0001\u0000\u0000\u0000\u34b9\u34ba"+ + "\u0005.\u0000\u0000\u34ba\u34bb\u0003\u0917\u048b\u0000\u34bb\u34d2\u0001"+ + "\u0000\u0000\u0000\u34bc\u34be\u0003\u0923\u0491\u0000\u34bd\u34bc\u0001"+ + "\u0000\u0000\u0000\u34be\u34c1\u0001\u0000\u0000\u0000\u34bf\u34bd\u0001"+ + "\u0000\u0000\u0000\u34bf\u34c0\u0001\u0000\u0000\u0000\u34c0\u34c2\u0001"+ + "\u0000\u0000\u0000\u34c1\u34bf\u0001\u0000\u0000\u0000\u34c2\u34c4\u0005"+ + ".\u0000\u0000\u34c3\u34c5\u0003\u0923\u0491\u0000\u34c4\u34c3\u0001\u0000"+ + "\u0000\u0000\u34c5\u34c6\u0001\u0000\u0000\u0000\u34c6\u34c4\u0001\u0000"+ + "\u0000\u0000\u34c6\u34c7\u0001\u0000\u0000\u0000\u34c7\u34c8\u0001\u0000"+ + "\u0000\u0000\u34c8\u34c9\u0003\u0917\u048b\u0000\u34c9\u34d2\u0001\u0000"+ + "\u0000\u0000\u34ca\u34cc\u0003\u0923\u0491\u0000\u34cb\u34ca\u0001\u0000"+ + "\u0000\u0000\u34cc\u34cd\u0001\u0000\u0000\u0000\u34cd\u34cb\u0001\u0000"+ + "\u0000\u0000\u34cd\u34ce\u0001\u0000\u0000\u0000\u34ce\u34cf\u0001\u0000"+ + "\u0000\u0000\u34cf\u34d0\u0003\u0917\u048b\u0000\u34d0\u34d2\u0001\u0000"+ + "\u0000\u0000\u34d1\u34ab\u0001\u0000\u0000\u0000\u34d1\u34b5\u0001\u0000"+ + "\u0000\u0000\u34d1\u34bf\u0001\u0000\u0000\u0000\u34d1\u34cb\u0001\u0000"+ + "\u0000\u0000\u34d2\u0902\u0001\u0000\u0000\u0000\u34d3\u34d4\u0005\\\u0000"+ + "\u0000\u34d4\u34d5\u0007\f\u0000\u0000\u34d5\u0904\u0001\u0000\u0000\u0000"+ + "\u34d6\u34d7\u0003\u0925\u0492\u0000\u34d7\u0906\u0001\u0000\u0000\u0000"+ + "\u34d8\u34d9\u0005_\u0000\u0000\u34d9\u34da\u0003\u0915\u048a\u0000\u34da"+ + "\u0908\u0001\u0000\u0000\u0000\u34db\u34dc\u0005.\u0000\u0000\u34dc\u34dd"+ + "\u0003\u0919\u048c\u0000\u34dd\u090a\u0001\u0000\u0000\u0000\u34de\u34df"+ + "\u0003\u0919\u048c\u0000\u34df\u090c\u0001\u0000\u0000\u0000\u34e0\u34e1"+ + "\u0003\u091f\u048f\u0000\u34e1\u090e\u0001\u0000\u0000\u0000\u34e2\u34e3"+ + "\u0003\u08e3\u0471\u0000\u34e3\u34e4\u0003\u0927\u0493\u0000\u34e4\u0910"+ + "\u0001\u0000\u0000\u0000\u34e5\u34ec\u0003\u08e3\u0471\u0000\u34e6\u34ed"+ + "\u0003\u08fb\u047d\u0000\u34e7\u34e9\u0007\u001e\u0000\u0000\u34e8\u34e7"+ + "\u0001\u0000\u0000\u0000\u34e9\u34ea\u0001\u0000\u0000\u0000\u34ea\u34e8"+ + "\u0001\u0000\u0000\u0000\u34ea\u34eb\u0001\u0000\u0000\u0000\u34eb\u34ed"+ + "\u0001\u0000\u0000\u0000\u34ec\u34e6\u0001\u0000\u0000\u0000\u34ec\u34e8"+ + "\u0001\u0000\u0000\u0000\u34ed\u0912\u0001\u0000\u0000\u0000\u34ee\u34ef"+ + "\u0003\u08e3\u0471\u0000\u34ef\u34f6\u0003\u08e3\u0471\u0000\u34f0\u34f2"+ + "\u0007\u001e\u0000\u0000\u34f1\u34f0\u0001\u0000\u0000\u0000\u34f2\u34f3"+ + "\u0001\u0000\u0000\u0000\u34f3\u34f1\u0001\u0000\u0000\u0000\u34f3\u34f4"+ + "\u0001\u0000\u0000\u0000\u34f4\u34f7\u0001\u0000\u0000\u0000\u34f5\u34f7"+ + "\u0003\u091f\u048f\u0000\u34f6\u34f1\u0001\u0000\u0000\u0000\u34f6\u34f5"+ + "\u0001\u0000\u0000\u0000\u34f7\u0914\u0001\u0000\u0000\u0000\u34f8\u3522"+ + "\u0003\u05d5\u02ea\u0000\u34f9\u3522\u0003\u05d7\u02eb\u0000\u34fa\u3522"+ + "\u0003\u05d9\u02ec\u0000\u34fb\u3522\u0003\u01c5\u00e2\u0000\u34fc\u3522"+ + "\u0003\u05db\u02ed\u0000\u34fd\u3522\u0003\u05dd\u02ee\u0000\u34fe\u3522"+ + "\u0003\u05df\u02ef\u0000\u34ff\u3522\u0003\u05e1\u02f0\u0000\u3500\u3522"+ + "\u0003\u05e3\u02f1\u0000\u3501\u3522\u0003\u05e5\u02f2\u0000\u3502\u3522"+ + "\u0003\u05e7\u02f3\u0000\u3503\u3522\u0003\u05e9\u02f4\u0000\u3504\u3522"+ + "\u0003\u05eb\u02f5\u0000\u3505\u3522\u0003\u05ed\u02f6\u0000\u3506\u3522"+ + "\u0003\u05ef\u02f7\u0000\u3507\u3522\u0003\u05f3\u02f9\u0000\u3508\u3522"+ + "\u0003\u05f5\u02fa\u0000\u3509\u3522\u0003\u05f7\u02fb\u0000\u350a\u3522"+ + "\u0003\u05f9\u02fc\u0000\u350b\u3522\u0003\u05fb\u02fd\u0000\u350c\u3522"+ + "\u0003\u05fd\u02fe\u0000\u350d\u3522\u0003\u05ff\u02ff\u0000\u350e\u3522"+ + "\u0003\u0601\u0300\u0000\u350f\u3522\u0003\u0603\u0301\u0000\u3510\u3522"+ + "\u0003\u0605\u0302\u0000\u3511\u3522\u0003\u0607\u0303\u0000\u3512\u3522"+ + "\u0003\u0609\u0304\u0000\u3513\u3522\u0003\u060b\u0305\u0000\u3514\u3522"+ + "\u0003\u060d\u0306\u0000\u3515\u3522\u0003\u060f\u0307\u0000\u3516\u3522"+ + "\u0003\u0611\u0308\u0000\u3517\u3522\u0003\u0613\u0309\u0000\u3518\u3522"+ + "\u0003\u0615\u030a\u0000\u3519\u3522\u0003\u0617\u030b\u0000\u351a\u3522"+ + "\u0003\u0619\u030c\u0000\u351b\u3522\u0003\u061b\u030d\u0000\u351c\u3522"+ + "\u0003\u061d\u030e\u0000\u351d\u3522\u0003\u061f\u030f\u0000\u351e\u3522"+ + "\u0003\u0621\u0310\u0000\u351f\u3522\u0003\u0623\u0311\u0000\u3520\u3522"+ + "\u0003\u0625\u0312\u0000\u3521\u34f8\u0001\u0000\u0000\u0000\u3521\u34f9"+ + "\u0001\u0000\u0000\u0000\u3521\u34fa\u0001\u0000\u0000\u0000\u3521\u34fb"+ + "\u0001\u0000\u0000\u0000\u3521\u34fc\u0001\u0000\u0000\u0000\u3521\u34fd"+ + "\u0001\u0000\u0000\u0000\u3521\u34fe\u0001\u0000\u0000\u0000\u3521\u34ff"+ + "\u0001\u0000\u0000\u0000\u3521\u3500\u0001\u0000\u0000\u0000\u3521\u3501"+ + "\u0001\u0000\u0000\u0000\u3521\u3502\u0001\u0000\u0000\u0000\u3521\u3503"+ + "\u0001\u0000\u0000\u0000\u3521\u3504\u0001\u0000\u0000\u0000\u3521\u3505"+ + "\u0001\u0000\u0000\u0000\u3521\u3506\u0001\u0000\u0000\u0000\u3521\u3507"+ + "\u0001\u0000\u0000\u0000\u3521\u3508\u0001\u0000\u0000\u0000\u3521\u3509"+ + "\u0001\u0000\u0000\u0000\u3521\u350a\u0001\u0000\u0000\u0000\u3521\u350b"+ + "\u0001\u0000\u0000\u0000\u3521\u350c\u0001\u0000\u0000\u0000\u3521\u350d"+ + "\u0001\u0000\u0000\u0000\u3521\u350e\u0001\u0000\u0000\u0000\u3521\u350f"+ + "\u0001\u0000\u0000\u0000\u3521\u3510\u0001\u0000\u0000\u0000\u3521\u3511"+ + "\u0001\u0000\u0000\u0000\u3521\u3512\u0001\u0000\u0000\u0000\u3521\u3513"+ + "\u0001\u0000\u0000\u0000\u3521\u3514\u0001\u0000\u0000\u0000\u3521\u3515"+ + "\u0001\u0000\u0000\u0000\u3521\u3516\u0001\u0000\u0000\u0000\u3521\u3517"+ + "\u0001\u0000\u0000\u0000\u3521\u3518\u0001\u0000\u0000\u0000\u3521\u3519"+ + "\u0001\u0000\u0000\u0000\u3521\u351a\u0001\u0000\u0000\u0000\u3521\u351b"+ + "\u0001\u0000\u0000\u0000\u3521\u351c\u0001\u0000\u0000\u0000\u3521\u351d"+ + "\u0001\u0000\u0000\u0000\u3521\u351e\u0001\u0000\u0000\u0000\u3521\u351f"+ + "\u0001\u0000\u0000\u0000\u3521\u3520\u0001\u0000\u0000\u0000\u3522\u0916"+ + "\u0001\u0000\u0000\u0000\u3523\u3525\u0007\u0007\u0000\u0000\u3524\u3526"+ + "\u0007\u001f\u0000\u0000\u3525\u3524\u0001\u0000\u0000\u0000\u3525\u3526"+ + "\u0001\u0000\u0000\u0000\u3526\u3528\u0001\u0000\u0000\u0000\u3527\u3529"+ + "\u0003\u0923\u0491\u0000\u3528\u3527\u0001\u0000\u0000\u0000\u3529\u352a"+ + "\u0001\u0000\u0000\u0000\u352a\u3528\u0001\u0000\u0000\u0000\u352a\u352b"+ + "\u0001\u0000\u0000\u0000\u352b\u0918\u0001\u0000\u0000\u0000\u352c\u352e"+ + "\u0007 \u0000\u0000\u352d\u352c\u0001\u0000\u0000\u0000\u352e\u3531\u0001"+ + "\u0000\u0000\u0000\u352f\u3530\u0001\u0000\u0000\u0000\u352f\u352d\u0001"+ + "\u0000\u0000\u0000\u3530\u3533\u0001\u0000\u0000\u0000\u3531\u352f\u0001"+ + "\u0000\u0000\u0000\u3532\u3534\u0007!\u0000\u0000\u3533\u3532\u0001\u0000"+ + "\u0000\u0000\u3534\u3535\u0001\u0000\u0000\u0000\u3535\u3536\u0001\u0000"+ + "\u0000\u0000\u3535\u3533\u0001\u0000\u0000\u0000\u3536\u353a\u0001\u0000"+ + "\u0000\u0000\u3537\u3539\u0007 \u0000\u0000\u3538\u3537\u0001\u0000\u0000"+ + "\u0000\u3539\u353c\u0001\u0000\u0000\u0000\u353a\u3538\u0001\u0000\u0000"+ + "\u0000\u353a\u353b\u0001\u0000\u0000\u0000\u353b\u091a\u0001\u0000\u0000"+ + "\u0000\u353c\u353a\u0001\u0000\u0000\u0000\u353d\u3545\u0005\"\u0000\u0000"+ + "\u353e\u353f\u0005\\\u0000\u0000\u353f\u3544\t\u0000\u0000\u0000\u3540"+ + "\u3541\u0005\"\u0000\u0000\u3541\u3544\u0005\"\u0000\u0000\u3542\u3544"+ + "\b\"\u0000\u0000\u3543\u353e\u0001\u0000\u0000\u0000\u3543\u3540\u0001"+ + "\u0000\u0000\u0000\u3543\u3542\u0001\u0000\u0000\u0000\u3544\u3547\u0001"+ + "\u0000\u0000\u0000\u3545\u3543\u0001\u0000\u0000\u0000\u3545\u3546\u0001"+ + "\u0000\u0000\u0000\u3546\u3548\u0001\u0000\u0000\u0000\u3547\u3545\u0001"+ + "\u0000\u0000\u0000\u3548\u3549\u0005\"\u0000\u0000\u3549\u091c\u0001\u0000"+ + "\u0000\u0000\u354a\u3552\u0005\'\u0000\u0000\u354b\u354c\u0005\\\u0000"+ + "\u0000\u354c\u3551\t\u0000\u0000\u0000\u354d\u354e\u0005\'\u0000\u0000"+ + "\u354e\u3551\u0005\'\u0000\u0000\u354f\u3551\b#\u0000\u0000\u3550\u354b"+ + "\u0001\u0000\u0000\u0000\u3550\u354d\u0001\u0000\u0000\u0000\u3550\u354f"+ + "\u0001\u0000\u0000\u0000\u3551\u3554\u0001\u0000\u0000\u0000\u3552\u3550"+ + "\u0001\u0000\u0000\u0000\u3552\u3553\u0001\u0000\u0000\u0000\u3553\u3555"+ + "\u0001\u0000\u0000\u0000\u3554\u3552\u0001\u0000\u0000\u0000\u3555\u3556"+ + "\u0005\'\u0000\u0000\u3556\u091e\u0001\u0000\u0000\u0000\u3557\u355d\u0005"+ + "`\u0000\u0000\u3558\u355c\b$\u0000\u0000\u3559\u355a\u0005`\u0000\u0000"+ + "\u355a\u355c\u0005`\u0000\u0000\u355b\u3558\u0001\u0000\u0000\u0000\u355b"+ + "\u3559\u0001\u0000\u0000\u0000\u355c\u355f\u0001\u0000\u0000\u0000\u355d"+ + "\u355b\u0001\u0000\u0000\u0000\u355d\u355e\u0001\u0000\u0000\u0000\u355e"+ + "\u3560\u0001\u0000\u0000\u0000\u355f\u355d\u0001\u0000\u0000\u0000\u3560"+ + "\u3561\u0005`\u0000\u0000\u3561\u0920\u0001\u0000\u0000\u0000\u3562\u3563"+ + "\u0007%\u0000\u0000\u3563\u0922\u0001\u0000\u0000\u0000\u3564\u3565\u0007"+ + "&\u0000\u0000\u3565\u0924\u0001\u0000\u0000\u0000\u3566\u3567\u0007\u0010"+ + "\u0000\u0000\u3567\u3569\u0005\'\u0000\u0000\u3568\u356a\u0007\'\u0000"+ + "\u0000\u3569\u3568\u0001\u0000\u0000\u0000\u356a\u356b\u0001\u0000\u0000"+ + "\u0000\u356b\u3569\u0001\u0000\u0000\u0000\u356b\u356c\u0001\u0000\u0000"+ + "\u0000\u356c\u356d\u0001\u0000\u0000\u0000\u356d\u356e\u0005\'\u0000\u0000"+ + "\u356e\u0926\u0001\u0000\u0000\u0000\u356f\u3571\u0007&\u0000\u0000\u3570"+ + "\u356f\u0001\u0000\u0000\u0000\u3571\u3572\u0001\u0000\u0000\u0000\u3572"+ + "\u3570\u0001\u0000\u0000\u0000\u3572\u3573\u0001\u0000\u0000\u0000\u3573"+ + "\u3574\u0001\u0000\u0000\u0000\u3574\u3576\u0005.\u0000\u0000\u3575\u3577"+ + "\u0007(\u0000\u0000\u3576\u3575\u0001\u0000\u0000\u0000\u3577\u3578\u0001"+ + "\u0000\u0000\u0000\u3578\u3576\u0001\u0000\u0000\u0000\u3578\u3579\u0001"+ + "\u0000\u0000\u0000\u3579\u358e\u0001\u0000\u0000\u0000\u357a\u357c\u0007"+ + "%\u0000\u0000\u357b\u357a\u0001\u0000\u0000\u0000\u357c\u357f\u0001\u0000"+ + "\u0000\u0000\u357d\u357b\u0001\u0000\u0000\u0000\u357d\u357e\u0001\u0000"+ + "\u0000\u0000\u357e\u3580\u0001\u0000\u0000\u0000\u357f\u357d\u0001\u0000"+ + "\u0000\u0000\u3580\u3584\u0005:\u0000\u0000\u3581\u3583\u0007%\u0000\u0000"+ + "\u3582\u3581\u0001\u0000\u0000\u0000\u3583\u3586\u0001\u0000\u0000\u0000"+ + "\u3584\u3582\u0001\u0000\u0000\u0000\u3584\u3585\u0001\u0000\u0000\u0000"+ + "\u3585\u3587\u0001\u0000\u0000\u0000\u3586\u3584\u0001\u0000\u0000\u0000"+ + "\u3587\u3589\u0005:\u0000\u0000\u3588\u358a\u0007)\u0000\u0000\u3589\u3588"+ + "\u0001\u0000\u0000\u0000\u358a\u358b\u0001\u0000\u0000\u0000\u358b\u3589"+ + "\u0001\u0000\u0000\u0000\u358b\u358c\u0001\u0000\u0000\u0000\u358c\u358e"+ + "\u0001\u0000\u0000\u0000\u358d\u3570\u0001\u0000\u0000\u0000\u358d\u357d"+ + "\u0001\u0000\u0000\u0000\u358e\u0928\u0001\u0000\u0000\u0000\u358f\u3590"+ + "\t\u0000\u0000\u0000\u3590\u3591\u0001\u0000\u0000\u0000\u3591\u3592\u0006"+ + "\u0494\u0002\u0000\u3592\u092a\u0001\u0000\u0000\u00004\u0000\u0930\u0938"+ + "\u0943\u0950\u095e\u0962\u0967\u096b\u096f\u0975\u0979\u097b\u2439\u2454"+ + "\u3479\u3482\u348c\u3491\u349a\u34a4\u34a6\u34ab\u34b2\u34b7\u34bf\u34c6"+ + "\u34cd\u34d1\u34ea\u34ec\u34f3\u34f6\u3521\u3525\u352a\u352f\u3535\u353a"+ + "\u3543\u3545\u3550\u3552\u355b\u355d\u356b\u3572\u3578\u357d\u3584\u358b"+ + "\u358d\u0003\u0000\u0001\u0000\u0000\u0002\u0000\u0000\u0003\u0000"; + public static final String _serializedATN = Utils.join( + new String[] { + _serializedATNSegment0, + _serializedATNSegment1, + _serializedATNSegment2, + _serializedATNSegment3, + _serializedATNSegment4, + _serializedATNSegment5 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParser.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParser.java new file mode 100644 index 000000000..c7fa877a9 --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParser.java @@ -0,0 +1,73382 @@ +// Generated from MySqlParser.g4 by ANTLR 4.13.1 +package org.springframework.ide.vscode.parser.sql; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) +public class MySqlParser extends Parser { + static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + SPEL=1, SPACE=2, SPEC_MYSQL_COMMENT=3, COMMENT_INPUT=4, LINE_COMMENT=5, + ADD=6, ALL=7, ALTER=8, ALWAYS=9, ANALYZE=10, AND=11, ARRAY=12, AS=13, + ASC=14, ATTRIBUTE=15, BEFORE=16, BETWEEN=17, BOTH=18, BUCKETS=19, BY=20, + CALL=21, CASCADE=22, CASE=23, CAST=24, CHANGE=25, CHARACTER=26, CHECK=27, + COLLATE=28, COLUMN=29, CONDITION=30, CONSTRAINT=31, CONTINUE=32, CONVERT=33, + CREATE=34, CROSS=35, CURRENT=36, CURRENT_ROLE=37, CURRENT_USER=38, CURSOR=39, + DATABASE=40, DATABASES=41, DECLARE=42, DEFAULT=43, DELAYED=44, DELETE=45, + DESC=46, DESCRIBE=47, DETERMINISTIC=48, DIAGNOSTICS=49, DISTINCT=50, DISTINCTROW=51, + DROP=52, EACH=53, ELSE=54, ELSEIF=55, EMPTY=56, ENCLOSED=57, ENFORCED=58, + ESCAPED=59, EXCEPT=60, EXISTS=61, EXIT=62, EXPLAIN=63, FALSE=64, FETCH=65, + FOR=66, FORCE=67, FOREIGN=68, FROM=69, FULLTEXT=70, GENERATED=71, GET=72, + GRANT=73, GROUP=74, HAVING=75, HIGH_PRIORITY=76, HISTOGRAM=77, IF=78, + IGNORE=79, IGNORED=80, IN=81, INDEX=82, INFILE=83, INNER=84, INOUT=85, + INSERT=86, INTERVAL=87, INTO=88, IS=89, ITERATE=90, JOIN=91, KEY=92, KEYS=93, + KILL=94, LATERAL=95, LEADING=96, LEAVE=97, LEFT=98, LIKE=99, LIMIT=100, + LINEAR=101, LINES=102, LOAD=103, LOCK=104, LOCKED=105, LOOP=106, LOW_PRIORITY=107, + MASTER_BIND=108, MASTER_SSL_VERIFY_SERVER_CERT=109, MATCH=110, MAXVALUE=111, + MINVALUE=112, MODIFIES=113, NATURAL=114, NOT=115, NO_WRITE_TO_BINLOG=116, + NULL_LITERAL=117, NUMBER=118, ON=119, OPTIMIZE=120, OPTION=121, OPTIONAL=122, + OPTIONALLY=123, OR=124, ORDER=125, OUT=126, OUTER=127, OUTFILE=128, OVER=129, + PARTITION=130, PRIMARY=131, PROCEDURE=132, PURGE=133, RANGE=134, READ=135, + READS=136, REFERENCES=137, REGEXP=138, RELEASE=139, RENAME=140, REPEAT=141, + REPLACE=142, REQUIRE=143, RESIGNAL=144, RESTRICT=145, RETAIN=146, RETURN=147, + REVOKE=148, RIGHT=149, RLIKE=150, SCHEMA=151, SCHEMAS=152, SELECT=153, + SET=154, SEPARATOR=155, SHOW=156, SIGNAL=157, SKIP_=158, SKIP_QUERY_REWRITE=159, + SPATIAL=160, SQL=161, SQLEXCEPTION=162, SQLSTATE=163, SQLWARNING=164, + SQL_BIG_RESULT=165, SQL_CALC_FOUND_ROWS=166, SQL_SMALL_RESULT=167, SSL=168, + STACKED=169, STARTING=170, STATEMENT=171, STRAIGHT_JOIN=172, TABLE=173, + TERMINATED=174, THEN=175, TO=176, TRAILING=177, TRIGGER=178, TRUE=179, + UNDO=180, UNION=181, UNIQUE=182, UNLOCK=183, UNSIGNED=184, UPDATE=185, + USAGE=186, USE=187, USING=188, VALUES=189, WHEN=190, WHERE=191, WHILE=192, + WITH=193, WRITE=194, XOR=195, ZEROFILL=196, TINYINT=197, SMALLINT=198, + MEDIUMINT=199, MIDDLEINT=200, INT=201, INT1=202, INT2=203, INT3=204, INT4=205, + INT8=206, INTEGER=207, BIGINT=208, REAL=209, DOUBLE=210, PRECISION=211, + FLOAT=212, FLOAT4=213, FLOAT8=214, DECIMAL=215, DEC=216, NUMERIC=217, + DATE=218, TIME=219, TIMESTAMP=220, DATETIME=221, YEAR=222, CHAR=223, VARCHAR=224, + NVARCHAR=225, NATIONAL=226, BINARY=227, VARBINARY=228, TINYBLOB=229, BLOB=230, + MEDIUMBLOB=231, LONG=232, LONGBLOB=233, TINYTEXT=234, TEXT=235, MEDIUMTEXT=236, + LONGTEXT=237, ENUM=238, VARYING=239, SERIAL=240, YEAR_MONTH=241, DAY_HOUR=242, + DAY_MINUTE=243, DAY_SECOND=244, HOUR_MINUTE=245, HOUR_SECOND=246, MINUTE_SECOND=247, + SECOND_MICROSECOND=248, MINUTE_MICROSECOND=249, HOUR_MICROSECOND=250, + DAY_MICROSECOND=251, JSON_ARRAY=252, JSON_ARRAYAGG=253, JSON_ARRAY_APPEND=254, + JSON_ARRAY_INSERT=255, JSON_CONTAINS=256, JSON_CONTAINS_PATH=257, JSON_DEPTH=258, + JSON_EXTRACT=259, JSON_INSERT=260, JSON_KEYS=261, JSON_LENGTH=262, JSON_MERGE=263, + JSON_MERGE_PATCH=264, JSON_MERGE_PRESERVE=265, JSON_OBJECT=266, JSON_OBJECTAGG=267, + JSON_OVERLAPS=268, JSON_PRETTY=269, JSON_QUOTE=270, JSON_REMOVE=271, JSON_REPLACE=272, + JSON_SCHEMA_VALID=273, JSON_SCHEMA_VALIDATION_REPORT=274, JSON_SEARCH=275, + JSON_SET=276, JSON_STORAGE_FREE=277, JSON_STORAGE_SIZE=278, JSON_TABLE=279, + JSON_TYPE=280, JSON_UNQUOTE=281, JSON_VALID=282, JSON_VALUE=283, NESTED=284, + ORDINALITY=285, PATH=286, AVG=287, BIT_AND=288, BIT_OR=289, BIT_XOR=290, + COUNT=291, CUME_DIST=292, DENSE_RANK=293, FIRST_VALUE=294, GROUP_CONCAT=295, + LAG=296, LAST_VALUE=297, LEAD=298, MAX=299, MIN=300, NTILE=301, NTH_VALUE=302, + PERCENT_RANK=303, RANK=304, ROW_NUMBER=305, STD=306, STDDEV=307, STDDEV_POP=308, + STDDEV_SAMP=309, SUM=310, VAR_POP=311, VAR_SAMP=312, VARIANCE=313, CURRENT_DATE=314, + CURRENT_TIME=315, CURRENT_TIMESTAMP=316, LOCALTIME=317, CURDATE=318, CURTIME=319, + DATE_ADD=320, DATE_SUB=321, EXTRACT=322, LOCALTIMESTAMP=323, NOW=324, + POSITION=325, SUBSTR=326, SUBSTRING=327, SYSDATE=328, TRIM=329, UTC_DATE=330, + UTC_TIME=331, UTC_TIMESTAMP=332, ACCOUNT=333, ACTION=334, AFTER=335, AGGREGATE=336, + ALGORITHM=337, ANY=338, AT=339, AUTHORS=340, AUTOCOMMIT=341, AUTOEXTEND_SIZE=342, + AUTO_INCREMENT=343, AVG_ROW_LENGTH=344, BEGIN=345, BINLOG=346, BIT=347, + BLOCK=348, BOOL=349, BOOLEAN=350, BTREE=351, CACHE=352, CASCADED=353, + CHAIN=354, CHANGED=355, CHANNEL=356, CHECKSUM=357, PAGE_CHECKSUM=358, + CIPHER=359, CLASS_ORIGIN=360, CLIENT=361, CLOSE=362, CLUSTERING=363, COALESCE=364, + CODE=365, COLUMNS=366, COLUMN_FORMAT=367, COLUMN_NAME=368, COMMENT=369, + COMMIT=370, COMPACT=371, COMPLETION=372, COMPRESSED=373, COMPRESSION=374, + CONCURRENT=375, CONNECT=376, CONNECTION=377, CONSISTENT=378, CONSTRAINT_CATALOG=379, + CONSTRAINT_SCHEMA=380, CONSTRAINT_NAME=381, CONTAINS=382, CONTEXT=383, + CONTRIBUTORS=384, COPY=385, CPU=386, CYCLE=387, CURSOR_NAME=388, DATA=389, + DATAFILE=390, DEALLOCATE=391, DEFAULT_AUTH=392, DEFINER=393, DELAY_KEY_WRITE=394, + DES_KEY_FILE=395, DIRECTORY=396, DISABLE=397, DISCARD=398, DISK=399, DO=400, + DUMPFILE=401, DUPLICATE=402, DYNAMIC=403, ENABLE=404, ENCRYPTED=405, ENCRYPTION=406, + ENCRYPTION_KEY_ID=407, END=408, ENDS=409, ENGINE=410, ENGINES=411, ERROR=412, + ERRORS=413, ESCAPE=414, EVEN=415, EVENT=416, EVENTS=417, EVERY=418, EXCHANGE=419, + EXCLUSIVE=420, EXPIRE=421, EXPORT=422, EXTENDED=423, EXTENT_SIZE=424, + FAILED_LOGIN_ATTEMPTS=425, FAST=426, FAULTS=427, FIELDS=428, FILE_BLOCK_SIZE=429, + FILTER=430, FIRST=431, FIXED=432, FLUSH=433, FOLLOWING=434, FOLLOWS=435, + FOUND=436, FULL=437, FUNCTION=438, GENERAL=439, GLOBAL=440, GRANTS=441, + GROUP_REPLICATION=442, HANDLER=443, HASH=444, HELP=445, HISTORY=446, HOST=447, + HOSTS=448, IDENTIFIED=449, IGNORE_SERVER_IDS=450, IMPORT=451, INCREMENT=452, + INDEXES=453, INITIAL_SIZE=454, INPLACE=455, INSERT_METHOD=456, INSTALL=457, + INSTANCE=458, INSTANT=459, INVISIBLE=460, INVOKER=461, IO=462, IO_THREAD=463, + IPC=464, ISOLATION=465, ISSUER=466, JSON=467, KEY_BLOCK_SIZE=468, LANGUAGE=469, + LAST=470, LEAVES=471, LESS=472, LEVEL=473, LIST=474, LOCAL=475, LOGFILE=476, + LOGS=477, MASTER=478, MASTER_AUTO_POSITION=479, MASTER_CONNECT_RETRY=480, + MASTER_DELAY=481, MASTER_HEARTBEAT_PERIOD=482, MASTER_HOST=483, MASTER_LOG_FILE=484, + MASTER_LOG_POS=485, MASTER_PASSWORD=486, MASTER_PORT=487, MASTER_RETRY_COUNT=488, + MASTER_SSL=489, MASTER_SSL_CA=490, MASTER_SSL_CAPATH=491, MASTER_SSL_CERT=492, + MASTER_SSL_CIPHER=493, MASTER_SSL_CRL=494, MASTER_SSL_CRLPATH=495, MASTER_SSL_KEY=496, + MASTER_TLS_VERSION=497, MASTER_USER=498, MAX_CONNECTIONS_PER_HOUR=499, + MAX_QUERIES_PER_HOUR=500, MAX_ROWS=501, MAX_SIZE=502, MAX_UPDATES_PER_HOUR=503, + MAX_USER_CONNECTIONS=504, MEDIUM=505, MEMBER=506, MERGE=507, MESSAGE_TEXT=508, + MID=509, MIGRATE=510, MIN_ROWS=511, MODE=512, MODIFY=513, MUTEX=514, MYSQL=515, + MYSQL_ERRNO=516, NAME=517, NAMES=518, NCHAR=519, NEVER=520, NEXT=521, + NO=522, NOCACHE=523, NOCOPY=524, NOCYCLE=525, NOMAXVALUE=526, NOMINVALUE=527, + NOWAIT=528, NODEGROUP=529, NONE=530, ODBC=531, OFFLINE=532, OFFSET=533, + OF=534, OJ=535, OLD_PASSWORD=536, ONE=537, ONLINE=538, ONLY=539, OPEN=540, + OPTIMIZER_COSTS=541, OPTIONS=542, OWNER=543, PACK_KEYS=544, PAGE=545, + PAGE_COMPRESSED=546, PAGE_COMPRESSION_LEVEL=547, PARSER=548, PARTIAL=549, + PARTITIONING=550, PARTITIONS=551, PASSWORD=552, PASSWORD_LOCK_TIME=553, + PHASE=554, PLUGIN=555, PLUGIN_DIR=556, PLUGINS=557, PORT=558, PRECEDES=559, + PRECEDING=560, PREPARE=561, PRESERVE=562, PREV=563, PROCESSLIST=564, PROFILE=565, + PROFILES=566, PROXY=567, QUERY=568, QUICK=569, REBUILD=570, RECOVER=571, + RECURSIVE=572, REDO_BUFFER_SIZE=573, REDUNDANT=574, RELAY=575, RELAY_LOG_FILE=576, + RELAY_LOG_POS=577, RELAYLOG=578, REMOVE=579, REORGANIZE=580, REPAIR=581, + REPLICATE_DO_DB=582, REPLICATE_DO_TABLE=583, REPLICATE_IGNORE_DB=584, + REPLICATE_IGNORE_TABLE=585, REPLICATE_REWRITE_DB=586, REPLICATE_WILD_DO_TABLE=587, + REPLICATE_WILD_IGNORE_TABLE=588, REPLICATION=589, RESET=590, RESTART=591, + RESUME=592, RETURNED_SQLSTATE=593, RETURNING=594, RETURNS=595, REUSE=596, + ROLE=597, ROLLBACK=598, ROLLUP=599, ROTATE=600, ROW=601, ROWS=602, ROW_FORMAT=603, + RTREE=604, SAVEPOINT=605, SCHEDULE=606, SECURITY=607, SEQUENCE=608, SERVER=609, + SESSION=610, SHARE=611, SHARED=612, SIGNED=613, SIMPLE=614, SLAVE=615, + SLOW=616, SNAPSHOT=617, SOCKET=618, SOME=619, SONAME=620, SOUNDS=621, + SOURCE=622, SQL_AFTER_GTIDS=623, SQL_AFTER_MTS_GAPS=624, SQL_BEFORE_GTIDS=625, + SQL_BUFFER_RESULT=626, SQL_CACHE=627, SQL_NO_CACHE=628, SQL_THREAD=629, + START=630, STARTS=631, STATS_AUTO_RECALC=632, STATS_PERSISTENT=633, STATS_SAMPLE_PAGES=634, + STATUS=635, STOP=636, STORAGE=637, STORED=638, STRING=639, SUBCLASS_ORIGIN=640, + SUBJECT=641, SUBPARTITION=642, SUBPARTITIONS=643, SUSPEND=644, SWAPS=645, + SWITCHES=646, TABLE_NAME=647, TABLESPACE=648, TABLE_TYPE=649, TEMPORARY=650, + TEMPTABLE=651, THAN=652, TRADITIONAL=653, TRANSACTION=654, TRANSACTIONAL=655, + TRIGGERS=656, TRUNCATE=657, UNBOUNDED=658, UNDEFINED=659, UNDOFILE=660, + UNDO_BUFFER_SIZE=661, UNINSTALL=662, UNKNOWN=663, UNTIL=664, UPGRADE=665, + USER=666, USE_FRM=667, USER_RESOURCES=668, VALIDATION=669, VALUE=670, + VARIABLES=671, VIEW=672, VIRTUAL=673, VISIBLE=674, WAIT=675, WARNINGS=676, + WINDOW=677, WITHOUT=678, WORK=679, WRAPPER=680, X509=681, XA=682, XML=683, + YES=684, EUR=685, USA=686, JIS=687, ISO=688, INTERNAL=689, QUARTER=690, + MONTH=691, DAY=692, HOUR=693, MINUTE=694, WEEK=695, SECOND=696, MICROSECOND=697, + ADMIN=698, APPLICATION_PASSWORD_ADMIN=699, AUDIT_ABORT_EXEMPT=700, AUDIT_ADMIN=701, + AUTHENTICATION_POLICY_ADMIN=702, BACKUP_ADMIN=703, BINLOG_ADMIN=704, BINLOG_ENCRYPTION_ADMIN=705, + CLONE_ADMIN=706, CONNECTION_ADMIN=707, ENCRYPTION_KEY_ADMIN=708, EXECUTE=709, + FILE=710, FIREWALL_ADMIN=711, FIREWALL_EXEMPT=712, FIREWALL_USER=713, + FLUSH_OPTIMIZER_COSTS=714, FLUSH_STATUS=715, FLUSH_TABLES=716, FLUSH_USER_RESOURCES=717, + GROUP_REPLICATION_ADMIN=718, INNODB_REDO_LOG_ARCHIVE=719, INNODB_REDO_LOG_ENABLE=720, + INVOKE=721, LAMBDA=722, NDB_STORED_USER=723, PASSWORDLESS_USER_ADMIN=724, + PERSIST_RO_VARIABLES_ADMIN=725, PRIVILEGES=726, PROCESS=727, RELOAD=728, + REPLICATION_APPLIER=729, REPLICATION_SLAVE_ADMIN=730, RESOURCE_GROUP_ADMIN=731, + RESOURCE_GROUP_USER=732, ROLE_ADMIN=733, ROUTINE=734, S3=735, SERVICE_CONNECTION_ADMIN=736, + SESSION_VARIABLES_ADMIN=737, SET_USER_ID=738, SHOW_ROUTINE=739, SHUTDOWN=740, + SUPER=741, SYSTEM_VARIABLES_ADMIN=742, TABLES=743, TABLE_ENCRYPTION_ADMIN=744, + VERSION_TOKEN_ADMIN=745, XA_RECOVER_ADMIN=746, ARMSCII8=747, ASCII=748, + BIG5=749, CP1250=750, CP1251=751, CP1256=752, CP1257=753, CP850=754, CP852=755, + CP866=756, CP932=757, DEC8=758, EUCJPMS=759, EUCKR=760, GB18030=761, GB2312=762, + GBK=763, GEOSTD8=764, GREEK=765, HEBREW=766, HP8=767, KEYBCS2=768, KOI8R=769, + KOI8U=770, LATIN1=771, LATIN2=772, LATIN5=773, LATIN7=774, MACCE=775, + MACROMAN=776, SJIS=777, SWE7=778, TIS620=779, UCS2=780, UJIS=781, UTF16=782, + UTF16LE=783, UTF32=784, UTF8=785, UTF8MB3=786, UTF8MB4=787, ARCHIVE=788, + BLACKHOLE=789, CSV=790, FEDERATED=791, INNODB=792, MEMORY=793, MRG_MYISAM=794, + MYISAM=795, NDB=796, NDBCLUSTER=797, PERFORMANCE_SCHEMA=798, TOKUDB=799, + REPEATABLE=800, COMMITTED=801, UNCOMMITTED=802, SERIALIZABLE=803, GEOMETRYCOLLECTION=804, + GEOMCOLLECTION=805, GEOMETRY=806, LINESTRING=807, MULTILINESTRING=808, + MULTIPOINT=809, MULTIPOLYGON=810, POINT=811, POLYGON=812, ABS=813, ACOS=814, + ADDDATE=815, ADDTIME=816, AES_DECRYPT=817, AES_ENCRYPT=818, AREA=819, + ASBINARY=820, ASIN=821, ASTEXT=822, ASWKB=823, ASWKT=824, ASYMMETRIC_DECRYPT=825, + ASYMMETRIC_DERIVE=826, ASYMMETRIC_ENCRYPT=827, ASYMMETRIC_SIGN=828, ASYMMETRIC_VERIFY=829, + ATAN=830, ATAN2=831, BENCHMARK=832, BIN=833, BIT_COUNT=834, BIT_LENGTH=835, + BUFFER=836, CATALOG_NAME=837, CEIL=838, CEILING=839, CENTROID=840, CHARACTER_LENGTH=841, + CHARSET=842, CHAR_LENGTH=843, COERCIBILITY=844, COLLATION=845, COMPRESS=846, + CONCAT=847, CONCAT_WS=848, CONNECTION_ID=849, CONV=850, CONVERT_TZ=851, + COS=852, COT=853, CRC32=854, CREATE_ASYMMETRIC_PRIV_KEY=855, CREATE_ASYMMETRIC_PUB_KEY=856, + CREATE_DH_PARAMETERS=857, CREATE_DIGEST=858, CROSSES=859, DATEDIFF=860, + DATE_FORMAT=861, DAYNAME=862, DAYOFMONTH=863, DAYOFWEEK=864, DAYOFYEAR=865, + DECODE=866, DEGREES=867, DES_DECRYPT=868, DES_ENCRYPT=869, DIMENSION=870, + DISJOINT=871, ELT=872, ENCODE=873, ENCRYPT=874, ENDPOINT=875, ENGINE_ATTRIBUTE=876, + ENVELOPE=877, EQUALS=878, EXP=879, EXPORT_SET=880, EXTERIORRING=881, EXTRACTVALUE=882, + FIELD=883, FIND_IN_SET=884, FLOOR=885, FORMAT=886, FOUND_ROWS=887, FROM_BASE64=888, + FROM_DAYS=889, FROM_UNIXTIME=890, GEOMCOLLFROMTEXT=891, GEOMCOLLFROMWKB=892, + GEOMETRYCOLLECTIONFROMTEXT=893, GEOMETRYCOLLECTIONFROMWKB=894, GEOMETRYFROMTEXT=895, + GEOMETRYFROMWKB=896, GEOMETRYN=897, GEOMETRYTYPE=898, GEOMFROMTEXT=899, + GEOMFROMWKB=900, GET_FORMAT=901, GET_LOCK=902, GLENGTH=903, GREATEST=904, + GTID_SUBSET=905, GTID_SUBTRACT=906, HEX=907, IFNULL=908, INET6_ATON=909, + INET6_NTOA=910, INET_ATON=911, INET_NTOA=912, INSTR=913, INTERIORRINGN=914, + INTERSECTS=915, ISCLOSED=916, ISEMPTY=917, ISNULL=918, ISSIMPLE=919, IS_FREE_LOCK=920, + IS_IPV4=921, IS_IPV4_COMPAT=922, IS_IPV4_MAPPED=923, IS_IPV6=924, IS_USED_LOCK=925, + LAST_INSERT_ID=926, LCASE=927, LEAST=928, LENGTH=929, LINEFROMTEXT=930, + LINEFROMWKB=931, LINESTRINGFROMTEXT=932, LINESTRINGFROMWKB=933, LN=934, + LOAD_FILE=935, LOCATE=936, LOG=937, LOG10=938, LOG2=939, LOWER=940, LPAD=941, + LTRIM=942, MAKEDATE=943, MAKETIME=944, MAKE_SET=945, MASTER_POS_WAIT=946, + MBRCONTAINS=947, MBRDISJOINT=948, MBREQUAL=949, MBRINTERSECTS=950, MBROVERLAPS=951, + MBRTOUCHES=952, MBRWITHIN=953, MD5=954, MLINEFROMTEXT=955, MLINEFROMWKB=956, + MONTHNAME=957, MPOINTFROMTEXT=958, MPOINTFROMWKB=959, MPOLYFROMTEXT=960, + MPOLYFROMWKB=961, MULTILINESTRINGFROMTEXT=962, MULTILINESTRINGFROMWKB=963, + MULTIPOINTFROMTEXT=964, MULTIPOINTFROMWKB=965, MULTIPOLYGONFROMTEXT=966, + MULTIPOLYGONFROMWKB=967, NAME_CONST=968, NULLIF=969, NUMGEOMETRIES=970, + NUMINTERIORRINGS=971, NUMPOINTS=972, OCT=973, OCTET_LENGTH=974, ORD=975, + OVERLAPS=976, PERIOD_ADD=977, PERIOD_DIFF=978, PI=979, POINTFROMTEXT=980, + POINTFROMWKB=981, POINTN=982, POLYFROMTEXT=983, POLYFROMWKB=984, POLYGONFROMTEXT=985, + POLYGONFROMWKB=986, POW=987, POWER=988, QUOTE=989, RADIANS=990, RAND=991, + RANDOM=992, RANDOM_BYTES=993, RELEASE_LOCK=994, REVERSE=995, ROUND=996, + ROW_COUNT=997, RPAD=998, RTRIM=999, SEC_TO_TIME=1000, SECONDARY_ENGINE_ATTRIBUTE=1001, + SESSION_USER=1002, SHA=1003, SHA1=1004, SHA2=1005, SCHEMA_NAME=1006, SIGN=1007, + SIN=1008, SLEEP=1009, SOUNDEX=1010, SQL_THREAD_WAIT_AFTER_GTIDS=1011, + SQRT=1012, SRID=1013, STARTPOINT=1014, STRCMP=1015, STR_TO_DATE=1016, + ST_AREA=1017, ST_ASBINARY=1018, ST_ASTEXT=1019, ST_ASWKB=1020, ST_ASWKT=1021, + ST_BUFFER=1022, ST_CENTROID=1023, ST_CONTAINS=1024, ST_CROSSES=1025, ST_DIFFERENCE=1026, + ST_DIMENSION=1027, ST_DISJOINT=1028, ST_DISTANCE=1029, ST_ENDPOINT=1030, + ST_ENVELOPE=1031, ST_EQUALS=1032, ST_EXTERIORRING=1033, ST_GEOMCOLLFROMTEXT=1034, + ST_GEOMCOLLFROMTXT=1035, ST_GEOMCOLLFROMWKB=1036, ST_GEOMETRYCOLLECTIONFROMTEXT=1037, + ST_GEOMETRYCOLLECTIONFROMWKB=1038, ST_GEOMETRYFROMTEXT=1039, ST_GEOMETRYFROMWKB=1040, + ST_GEOMETRYN=1041, ST_GEOMETRYTYPE=1042, ST_GEOMFROMTEXT=1043, ST_GEOMFROMWKB=1044, + ST_INTERIORRINGN=1045, ST_INTERSECTION=1046, ST_INTERSECTS=1047, ST_ISCLOSED=1048, + ST_ISEMPTY=1049, ST_ISSIMPLE=1050, ST_LINEFROMTEXT=1051, ST_LINEFROMWKB=1052, + ST_LINESTRINGFROMTEXT=1053, ST_LINESTRINGFROMWKB=1054, ST_NUMGEOMETRIES=1055, + ST_NUMINTERIORRING=1056, ST_NUMINTERIORRINGS=1057, ST_NUMPOINTS=1058, + ST_OVERLAPS=1059, ST_POINTFROMTEXT=1060, ST_POINTFROMWKB=1061, ST_POINTN=1062, + ST_POLYFROMTEXT=1063, ST_POLYFROMWKB=1064, ST_POLYGONFROMTEXT=1065, ST_POLYGONFROMWKB=1066, + ST_SRID=1067, ST_STARTPOINT=1068, ST_SYMDIFFERENCE=1069, ST_TOUCHES=1070, + ST_UNION=1071, ST_WITHIN=1072, ST_X=1073, ST_Y=1074, SUBDATE=1075, SUBSTRING_INDEX=1076, + SUBTIME=1077, SYSTEM_USER=1078, TAN=1079, TIMEDIFF=1080, TIMESTAMPADD=1081, + TIMESTAMPDIFF=1082, TIME_FORMAT=1083, TIME_TO_SEC=1084, TOUCHES=1085, + TO_BASE64=1086, TO_DAYS=1087, TO_SECONDS=1088, TP_CONNECTION_ADMIN=1089, + UCASE=1090, UNCOMPRESS=1091, UNCOMPRESSED_LENGTH=1092, UNHEX=1093, UNIX_TIMESTAMP=1094, + UPDATEXML=1095, UPPER=1096, UUID=1097, UUID_SHORT=1098, VALIDATE_PASSWORD_STRENGTH=1099, + VERSION=1100, WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS=1101, WEEKDAY=1102, WEEKOFYEAR=1103, + WEIGHT_STRING=1104, WITHIN=1105, YEARWEEK=1106, Y_FUNCTION=1107, X_FUNCTION=1108, + VAR_ASSIGN=1109, PLUS_ASSIGN=1110, MINUS_ASSIGN=1111, MULT_ASSIGN=1112, + DIV_ASSIGN=1113, MOD_ASSIGN=1114, AND_ASSIGN=1115, XOR_ASSIGN=1116, OR_ASSIGN=1117, + STAR=1118, DIVIDE=1119, MODULE=1120, PLUS=1121, MINUS=1122, DIV=1123, + MOD=1124, EQUAL_SYMBOL=1125, GREATER_SYMBOL=1126, LESS_SYMBOL=1127, EXCLAMATION_SYMBOL=1128, + BIT_NOT_OP=1129, BIT_OR_OP=1130, BIT_AND_OP=1131, BIT_XOR_OP=1132, DOT=1133, + LR_BRACKET=1134, RR_BRACKET=1135, COMMA=1136, SEMI=1137, AT_SIGN=1138, + ZERO_DECIMAL=1139, ONE_DECIMAL=1140, TWO_DECIMAL=1141, SINGLE_QUOTE_SYMB=1142, + DOUBLE_QUOTE_SYMB=1143, REVERSE_QUOTE_SYMB=1144, COLON_SYMB=1145, CHARSET_REVERSE_QOUTE_STRING=1146, + FILESIZE_LITERAL=1147, START_NATIONAL_STRING_LITERAL=1148, STRING_LITERAL=1149, + DECIMAL_LITERAL=1150, HEXADECIMAL_LITERAL=1151, REAL_LITERAL=1152, NULL_SPEC_LITERAL=1153, + BIT_STRING=1154, STRING_CHARSET_NAME=1155, DOT_ID=1156, ID=1157, REVERSE_QUOTE_ID=1158, + HOST_IP_ADDRESS=1159, LOCAL_ID=1160, GLOBAL_ID=1161, ERROR_RECONGNIGION=1162; + public static final int + RULE_root = 0, RULE_sqlStatements = 1, RULE_sqlStatement = 2, RULE_emptyStatement_ = 3, + RULE_ddlStatement = 4, RULE_dmlStatement = 5, RULE_transactionStatement = 6, + RULE_replicationStatement = 7, RULE_preparedStatement = 8, RULE_compoundStatement = 9, + RULE_administrationStatement = 10, RULE_utilityStatement = 11, RULE_createDatabase = 12, + RULE_createEvent = 13, RULE_createIndex = 14, RULE_createLogfileGroup = 15, + RULE_createProcedure = 16, RULE_createFunction = 17, RULE_createRole = 18, + RULE_createServer = 19, RULE_createTable = 20, RULE_createTablespaceInnodb = 21, + RULE_createTablespaceNdb = 22, RULE_createTrigger = 23, RULE_withClause = 24, + RULE_commonTableExpressions = 25, RULE_cteName = 26, RULE_cteColumnName = 27, + RULE_createView = 28, RULE_createDatabaseOption = 29, RULE_charSet = 30, + RULE_currentUserExpression = 31, RULE_ownerStatement = 32, RULE_scheduleExpression = 33, + RULE_timestampValue = 34, RULE_intervalExpr = 35, RULE_intervalType = 36, + RULE_enableType = 37, RULE_indexType = 38, RULE_indexOption = 39, RULE_procedureParameter = 40, + RULE_functionParameter = 41, RULE_routineOption = 42, RULE_serverOption = 43, + RULE_createDefinitions = 44, RULE_createDefinition = 45, RULE_columnDefinition = 46, + RULE_columnConstraint = 47, RULE_tableConstraint = 48, RULE_referenceDefinition = 49, + RULE_referenceAction = 50, RULE_referenceControlType = 51, RULE_indexColumnDefinition = 52, + RULE_tableOption = 53, RULE_tableType = 54, RULE_tablespaceStorage = 55, + RULE_partitionDefinitions = 56, RULE_partitionFunctionDefinition = 57, + RULE_subpartitionFunctionDefinition = 58, RULE_partitionDefinition = 59, + RULE_partitionDefinerAtom = 60, RULE_partitionDefinerVector = 61, RULE_subpartitionDefinition = 62, + RULE_partitionOption = 63, RULE_alterDatabase = 64, RULE_alterEvent = 65, + RULE_alterFunction = 66, RULE_alterInstance = 67, RULE_alterLogfileGroup = 68, + RULE_alterProcedure = 69, RULE_alterServer = 70, RULE_alterTable = 71, + RULE_alterTablespace = 72, RULE_alterView = 73, RULE_alterSpecification = 74, + RULE_alterPartitionSpecification = 75, RULE_dropDatabase = 76, RULE_dropEvent = 77, + RULE_dropIndex = 78, RULE_dropLogfileGroup = 79, RULE_dropProcedure = 80, + RULE_dropFunction = 81, RULE_dropServer = 82, RULE_dropTable = 83, RULE_dropTablespace = 84, + RULE_dropTrigger = 85, RULE_dropView = 86, RULE_dropRole = 87, RULE_setRole = 88, + RULE_renameTable = 89, RULE_renameTableClause = 90, RULE_truncateTable = 91, + RULE_callStatement = 92, RULE_deleteStatement = 93, RULE_doStatement = 94, + RULE_handlerStatement = 95, RULE_insertStatement = 96, RULE_loadDataStatement = 97, + RULE_loadXmlStatement = 98, RULE_replaceStatement = 99, RULE_selectStatement = 100, + RULE_updateStatement = 101, RULE_valuesStatement = 102, RULE_insertStatementValue = 103, + RULE_updatedElement = 104, RULE_assignmentField = 105, RULE_lockClause = 106, + RULE_singleDeleteStatement = 107, RULE_multipleDeleteStatement = 108, + RULE_handlerOpenStatement = 109, RULE_handlerReadIndexStatement = 110, + RULE_handlerReadStatement = 111, RULE_handlerCloseStatement = 112, RULE_singleUpdateStatement = 113, + RULE_multipleUpdateStatement = 114, RULE_orderByClause = 115, RULE_orderByExpression = 116, + RULE_tableSources = 117, RULE_tableSource = 118, RULE_tableSourceItem = 119, + RULE_indexHint = 120, RULE_indexHintType = 121, RULE_joinPart = 122, RULE_joinSpec = 123, + RULE_queryExpression = 124, RULE_queryExpressionNointo = 125, RULE_querySpecification = 126, + RULE_querySpecificationNointo = 127, RULE_unionParenthesis = 128, RULE_unionStatement = 129, + RULE_lateralStatement = 130, RULE_jsonTable = 131, RULE_jsonColumnList = 132, + RULE_jsonColumn = 133, RULE_jsonOnEmpty = 134, RULE_jsonOnError = 135, + RULE_selectSpec = 136, RULE_selectElements = 137, RULE_selectElement = 138, + RULE_selectIntoExpression = 139, RULE_selectFieldsInto = 140, RULE_selectLinesInto = 141, + RULE_fromClause = 142, RULE_groupByClause = 143, RULE_havingClause = 144, + RULE_windowClause = 145, RULE_groupByItem = 146, RULE_limitClause = 147, + RULE_limitClauseAtom = 148, RULE_startTransaction = 149, RULE_beginWork = 150, + RULE_commitWork = 151, RULE_rollbackWork = 152, RULE_savepointStatement = 153, + RULE_rollbackStatement = 154, RULE_releaseStatement = 155, RULE_lockTables = 156, + RULE_unlockTables = 157, RULE_setAutocommitStatement = 158, RULE_setTransactionStatement = 159, + RULE_transactionMode = 160, RULE_lockTableElement = 161, RULE_lockAction = 162, + RULE_transactionOption = 163, RULE_transactionLevel = 164, RULE_changeMaster = 165, + RULE_changeReplicationFilter = 166, RULE_purgeBinaryLogs = 167, RULE_resetMaster = 168, + RULE_resetSlave = 169, RULE_startSlave = 170, RULE_stopSlave = 171, RULE_startGroupReplication = 172, + RULE_stopGroupReplication = 173, RULE_masterOption = 174, RULE_stringMasterOption = 175, + RULE_decimalMasterOption = 176, RULE_boolMasterOption = 177, RULE_channelOption = 178, + RULE_replicationFilter = 179, RULE_tablePair = 180, RULE_threadType = 181, + RULE_untilOption = 182, RULE_connectionOption = 183, RULE_gtuidSet = 184, + RULE_xaStartTransaction = 185, RULE_xaEndTransaction = 186, RULE_xaPrepareStatement = 187, + RULE_xaCommitWork = 188, RULE_xaRollbackWork = 189, RULE_xaRecoverWork = 190, + RULE_prepareStatement = 191, RULE_executeStatement = 192, RULE_deallocatePrepare = 193, + RULE_routineBody = 194, RULE_blockStatement = 195, RULE_caseStatement = 196, + RULE_ifStatement = 197, RULE_iterateStatement = 198, RULE_leaveStatement = 199, + RULE_loopStatement = 200, RULE_repeatStatement = 201, RULE_returnStatement = 202, + RULE_whileStatement = 203, RULE_cursorStatement = 204, RULE_declareVariable = 205, + RULE_declareCondition = 206, RULE_declareCursor = 207, RULE_declareHandler = 208, + RULE_handlerConditionValue = 209, RULE_procedureSqlStatement = 210, RULE_caseAlternative = 211, + RULE_elifAlternative = 212, RULE_alterUser = 213, RULE_createUser = 214, + RULE_dropUser = 215, RULE_grantStatement = 216, RULE_roleOption = 217, + RULE_grantProxy = 218, RULE_renameUser = 219, RULE_revokeStatement = 220, + RULE_revokeProxy = 221, RULE_setPasswordStatement = 222, RULE_userSpecification = 223, + RULE_userAuthOption = 224, RULE_authOptionClause = 225, RULE_authenticationRule = 226, + RULE_tlsOption = 227, RULE_userResourceOption = 228, RULE_userPasswordOption = 229, + RULE_userLockOption = 230, RULE_privelegeClause = 231, RULE_privilege = 232, + RULE_privilegeLevel = 233, RULE_renameUserClause = 234, RULE_analyzeTable = 235, + RULE_checkTable = 236, RULE_checksumTable = 237, RULE_optimizeTable = 238, + RULE_repairTable = 239, RULE_checkTableOption = 240, RULE_createUdfunction = 241, + RULE_installPlugin = 242, RULE_uninstallPlugin = 243, RULE_setStatement = 244, + RULE_showStatement = 245, RULE_variableClause = 246, RULE_showCommonEntity = 247, + RULE_showFilter = 248, RULE_showGlobalInfoClause = 249, RULE_showSchemaEntity = 250, + RULE_showProfileType = 251, RULE_binlogStatement = 252, RULE_cacheIndexStatement = 253, + RULE_flushStatement = 254, RULE_killStatement = 255, RULE_loadIndexIntoCache = 256, + RULE_resetStatement = 257, RULE_shutdownStatement = 258, RULE_tableIndexes = 259, + RULE_flushOption = 260, RULE_flushTableOption = 261, RULE_loadedTableIndexes = 262, + RULE_simpleDescribeStatement = 263, RULE_fullDescribeStatement = 264, + RULE_helpStatement = 265, RULE_useStatement = 266, RULE_signalStatement = 267, + RULE_resignalStatement = 268, RULE_signalConditionInformation = 269, RULE_withStatement = 270, + RULE_tableStatement = 271, RULE_diagnosticsStatement = 272, RULE_diagnosticsConditionInformationName = 273, + RULE_describeObjectClause = 274, RULE_fullId = 275, RULE_tableName = 276, + RULE_roleName = 277, RULE_fullColumnName = 278, RULE_indexColumnName = 279, + RULE_simpleUserName = 280, RULE_hostName = 281, RULE_userName = 282, RULE_mysqlVariable = 283, + RULE_charsetName = 284, RULE_collationName = 285, RULE_engineName = 286, + RULE_engineNameBase = 287, RULE_uuidSet = 288, RULE_xid = 289, RULE_xuidStringId = 290, + RULE_authPlugin = 291, RULE_uid = 292, RULE_simpleId = 293, RULE_dottedId = 294, + RULE_decimalLiteral = 295, RULE_fileSizeLiteral = 296, RULE_stringLiteral = 297, + RULE_booleanLiteral = 298, RULE_hexadecimalLiteral = 299, RULE_nullNotnull = 300, + RULE_constant = 301, RULE_dataType = 302, RULE_collectionOptions = 303, + RULE_convertedDataType = 304, RULE_lengthOneDimension = 305, RULE_lengthTwoDimension = 306, + RULE_lengthTwoOptionalDimension = 307, RULE_uidList = 308, RULE_fullColumnNameList = 309, + RULE_tables = 310, RULE_indexColumnNames = 311, RULE_expressions = 312, + RULE_expressionsWithDefaults = 313, RULE_constants = 314, RULE_simpleStrings = 315, + RULE_userVariables = 316, RULE_defaultValue = 317, RULE_currentTimestamp = 318, + RULE_expressionOrDefault = 319, RULE_ifExists = 320, RULE_ifNotExists = 321, + RULE_orReplace = 322, RULE_waitNowaitClause = 323, RULE_functionCall = 324, + RULE_specificFunction = 325, RULE_caseFuncAlternative = 326, RULE_levelsInWeightString = 327, + RULE_levelInWeightListElement = 328, RULE_aggregateWindowedFunction = 329, + RULE_nonAggregateWindowedFunction = 330, RULE_overClause = 331, RULE_windowSpec = 332, + RULE_windowName = 333, RULE_frameClause = 334, RULE_frameUnits = 335, + RULE_frameExtent = 336, RULE_frameBetween = 337, RULE_frameRange = 338, + RULE_partitionClause = 339, RULE_scalarFunctionName = 340, RULE_passwordFunctionClause = 341, + RULE_functionArgs = 342, RULE_functionArg = 343, RULE_expression = 344, + RULE_predicate = 345, RULE_expressionAtom = 346, RULE_unaryOperator = 347, + RULE_comparisonOperator = 348, RULE_logicalOperator = 349, RULE_bitOperator = 350, + RULE_multOperator = 351, RULE_addOperator = 352, RULE_jsonOperator = 353, + RULE_charsetNameBase = 354, RULE_transactionLevelBase = 355, RULE_privilegesBase = 356, + RULE_intervalTypeBase = 357, RULE_dataTypeBase = 358, RULE_keywordsCanBeId = 359, + RULE_functionNameBase = 360; + private static String[] makeRuleNames() { + return new String[] { + "root", "sqlStatements", "sqlStatement", "emptyStatement_", "ddlStatement", + "dmlStatement", "transactionStatement", "replicationStatement", "preparedStatement", + "compoundStatement", "administrationStatement", "utilityStatement", "createDatabase", + "createEvent", "createIndex", "createLogfileGroup", "createProcedure", + "createFunction", "createRole", "createServer", "createTable", "createTablespaceInnodb", + "createTablespaceNdb", "createTrigger", "withClause", "commonTableExpressions", + "cteName", "cteColumnName", "createView", "createDatabaseOption", "charSet", + "currentUserExpression", "ownerStatement", "scheduleExpression", "timestampValue", + "intervalExpr", "intervalType", "enableType", "indexType", "indexOption", + "procedureParameter", "functionParameter", "routineOption", "serverOption", + "createDefinitions", "createDefinition", "columnDefinition", "columnConstraint", + "tableConstraint", "referenceDefinition", "referenceAction", "referenceControlType", + "indexColumnDefinition", "tableOption", "tableType", "tablespaceStorage", + "partitionDefinitions", "partitionFunctionDefinition", "subpartitionFunctionDefinition", + "partitionDefinition", "partitionDefinerAtom", "partitionDefinerVector", + "subpartitionDefinition", "partitionOption", "alterDatabase", "alterEvent", + "alterFunction", "alterInstance", "alterLogfileGroup", "alterProcedure", + "alterServer", "alterTable", "alterTablespace", "alterView", "alterSpecification", + "alterPartitionSpecification", "dropDatabase", "dropEvent", "dropIndex", + "dropLogfileGroup", "dropProcedure", "dropFunction", "dropServer", "dropTable", + "dropTablespace", "dropTrigger", "dropView", "dropRole", "setRole", "renameTable", + "renameTableClause", "truncateTable", "callStatement", "deleteStatement", + "doStatement", "handlerStatement", "insertStatement", "loadDataStatement", + "loadXmlStatement", "replaceStatement", "selectStatement", "updateStatement", + "valuesStatement", "insertStatementValue", "updatedElement", "assignmentField", + "lockClause", "singleDeleteStatement", "multipleDeleteStatement", "handlerOpenStatement", + "handlerReadIndexStatement", "handlerReadStatement", "handlerCloseStatement", + "singleUpdateStatement", "multipleUpdateStatement", "orderByClause", + "orderByExpression", "tableSources", "tableSource", "tableSourceItem", + "indexHint", "indexHintType", "joinPart", "joinSpec", "queryExpression", + "queryExpressionNointo", "querySpecification", "querySpecificationNointo", + "unionParenthesis", "unionStatement", "lateralStatement", "jsonTable", + "jsonColumnList", "jsonColumn", "jsonOnEmpty", "jsonOnError", "selectSpec", + "selectElements", "selectElement", "selectIntoExpression", "selectFieldsInto", + "selectLinesInto", "fromClause", "groupByClause", "havingClause", "windowClause", + "groupByItem", "limitClause", "limitClauseAtom", "startTransaction", + "beginWork", "commitWork", "rollbackWork", "savepointStatement", "rollbackStatement", + "releaseStatement", "lockTables", "unlockTables", "setAutocommitStatement", + "setTransactionStatement", "transactionMode", "lockTableElement", "lockAction", + "transactionOption", "transactionLevel", "changeMaster", "changeReplicationFilter", + "purgeBinaryLogs", "resetMaster", "resetSlave", "startSlave", "stopSlave", + "startGroupReplication", "stopGroupReplication", "masterOption", "stringMasterOption", + "decimalMasterOption", "boolMasterOption", "channelOption", "replicationFilter", + "tablePair", "threadType", "untilOption", "connectionOption", "gtuidSet", + "xaStartTransaction", "xaEndTransaction", "xaPrepareStatement", "xaCommitWork", + "xaRollbackWork", "xaRecoverWork", "prepareStatement", "executeStatement", + "deallocatePrepare", "routineBody", "blockStatement", "caseStatement", + "ifStatement", "iterateStatement", "leaveStatement", "loopStatement", + "repeatStatement", "returnStatement", "whileStatement", "cursorStatement", + "declareVariable", "declareCondition", "declareCursor", "declareHandler", + "handlerConditionValue", "procedureSqlStatement", "caseAlternative", + "elifAlternative", "alterUser", "createUser", "dropUser", "grantStatement", + "roleOption", "grantProxy", "renameUser", "revokeStatement", "revokeProxy", + "setPasswordStatement", "userSpecification", "userAuthOption", "authOptionClause", + "authenticationRule", "tlsOption", "userResourceOption", "userPasswordOption", + "userLockOption", "privelegeClause", "privilege", "privilegeLevel", "renameUserClause", + "analyzeTable", "checkTable", "checksumTable", "optimizeTable", "repairTable", + "checkTableOption", "createUdfunction", "installPlugin", "uninstallPlugin", + "setStatement", "showStatement", "variableClause", "showCommonEntity", + "showFilter", "showGlobalInfoClause", "showSchemaEntity", "showProfileType", + "binlogStatement", "cacheIndexStatement", "flushStatement", "killStatement", + "loadIndexIntoCache", "resetStatement", "shutdownStatement", "tableIndexes", + "flushOption", "flushTableOption", "loadedTableIndexes", "simpleDescribeStatement", + "fullDescribeStatement", "helpStatement", "useStatement", "signalStatement", + "resignalStatement", "signalConditionInformation", "withStatement", "tableStatement", + "diagnosticsStatement", "diagnosticsConditionInformationName", "describeObjectClause", + "fullId", "tableName", "roleName", "fullColumnName", "indexColumnName", + "simpleUserName", "hostName", "userName", "mysqlVariable", "charsetName", + "collationName", "engineName", "engineNameBase", "uuidSet", "xid", "xuidStringId", + "authPlugin", "uid", "simpleId", "dottedId", "decimalLiteral", "fileSizeLiteral", + "stringLiteral", "booleanLiteral", "hexadecimalLiteral", "nullNotnull", + "constant", "dataType", "collectionOptions", "convertedDataType", "lengthOneDimension", + "lengthTwoDimension", "lengthTwoOptionalDimension", "uidList", "fullColumnNameList", + "tables", "indexColumnNames", "expressions", "expressionsWithDefaults", + "constants", "simpleStrings", "userVariables", "defaultValue", "currentTimestamp", + "expressionOrDefault", "ifExists", "ifNotExists", "orReplace", "waitNowaitClause", + "functionCall", "specificFunction", "caseFuncAlternative", "levelsInWeightString", + "levelInWeightListElement", "aggregateWindowedFunction", "nonAggregateWindowedFunction", + "overClause", "windowSpec", "windowName", "frameClause", "frameUnits", + "frameExtent", "frameBetween", "frameRange", "partitionClause", "scalarFunctionName", + "passwordFunctionClause", "functionArgs", "functionArg", "expression", + "predicate", "expressionAtom", "unaryOperator", "comparisonOperator", + "logicalOperator", "bitOperator", "multOperator", "addOperator", "jsonOperator", + "charsetNameBase", "transactionLevelBase", "privilegesBase", "intervalTypeBase", + "dataTypeBase", "keywordsCanBeId", "functionNameBase" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, null, null, "'ADD'", "'ALL'", "'ALTER'", "'ALWAYS'", + "'ANALYZE'", "'AND'", "'ARRAY'", "'AS'", "'ASC'", "'ATTRIBUTE'", "'BEFORE'", + "'BETWEEN'", "'BOTH'", "'BUCKETS'", "'BY'", "'CALL'", "'CASCADE'", "'CASE'", + "'CAST'", "'CHANGE'", "'CHARACTER'", "'CHECK'", "'COLLATE'", "'COLUMN'", + "'CONDITION'", "'CONSTRAINT'", "'CONTINUE'", "'CONVERT'", "'CREATE'", + "'CROSS'", "'CURRENT'", "'CURRENT_ROLE'", "'CURRENT_USER'", "'CURSOR'", + "'DATABASE'", "'DATABASES'", "'DECLARE'", "'DEFAULT'", "'DELAYED'", "'DELETE'", + "'DESC'", "'DESCRIBE'", "'DETERMINISTIC'", "'DIAGNOSTICS'", "'DISTINCT'", + "'DISTINCTROW'", "'DROP'", "'EACH'", "'ELSE'", "'ELSEIF'", "'EMPTY'", + "'ENCLOSED'", "'ENFORCED'", "'ESCAPED'", "'EXCEPT'", "'EXISTS'", "'EXIT'", + "'EXPLAIN'", "'FALSE'", "'FETCH'", "'FOR'", "'FORCE'", "'FOREIGN'", "'FROM'", + "'FULLTEXT'", "'GENERATED'", "'GET'", "'GRANT'", "'GROUP'", "'HAVING'", + "'HIGH_PRIORITY'", "'HISTOGRAM'", "'IF'", "'IGNORE'", "'IGNORED'", "'IN'", + "'INDEX'", "'INFILE'", "'INNER'", "'INOUT'", "'INSERT'", "'INTERVAL'", + "'INTO'", "'IS'", "'ITERATE'", "'JOIN'", "'KEY'", "'KEYS'", "'KILL'", + "'LATERAL'", "'LEADING'", "'LEAVE'", "'LEFT'", "'LIKE'", "'LIMIT'", "'LINEAR'", + "'LINES'", "'LOAD'", "'LOCK'", "'LOCKED'", "'LOOP'", "'LOW_PRIORITY'", + "'MASTER_BIND'", "'MASTER_SSL_VERIFY_SERVER_CERT'", "'MATCH'", "'MAXVALUE'", + "'MINVALUE'", "'MODIFIES'", "'NATURAL'", "'NOT'", "'NO_WRITE_TO_BINLOG'", + "'NULL'", "'NUMBER'", "'ON'", "'OPTIMIZE'", "'OPTION'", "'OPTIONAL'", + "'OPTIONALLY'", "'OR'", "'ORDER'", "'OUT'", "'OUTER'", "'OUTFILE'", "'OVER'", + "'PARTITION'", "'PRIMARY'", "'PROCEDURE'", "'PURGE'", "'RANGE'", "'READ'", + "'READS'", "'REFERENCES'", "'REGEXP'", "'RELEASE'", "'RENAME'", "'REPEAT'", + "'REPLACE'", "'REQUIRE'", "'RESIGNAL'", "'RESTRICT'", "'RETAIN'", "'RETURN'", + "'REVOKE'", "'RIGHT'", "'RLIKE'", "'SCHEMA'", "'SCHEMAS'", "'SELECT'", + "'SET'", "'SEPARATOR'", "'SHOW'", "'SIGNAL'", "'SKIP'", "'SKIP_QUERY_REWRITE'", + "'SPATIAL'", "'SQL'", "'SQLEXCEPTION'", "'SQLSTATE'", "'SQLWARNING'", + "'SQL_BIG_RESULT'", "'SQL_CALC_FOUND_ROWS'", "'SQL_SMALL_RESULT'", "'SSL'", + "'STACKED'", "'STARTING'", "'STATEMENT'", "'STRAIGHT_JOIN'", "'TABLE'", + "'TERMINATED'", "'THEN'", "'TO'", "'TRAILING'", "'TRIGGER'", "'TRUE'", + "'UNDO'", "'UNION'", "'UNIQUE'", "'UNLOCK'", "'UNSIGNED'", "'UPDATE'", + "'USAGE'", "'USE'", "'USING'", "'VALUES'", "'WHEN'", "'WHERE'", "'WHILE'", + "'WITH'", "'WRITE'", "'XOR'", "'ZEROFILL'", "'TINYINT'", "'SMALLINT'", + "'MEDIUMINT'", "'MIDDLEINT'", "'INT'", "'INT1'", "'INT2'", "'INT3'", + "'INT4'", "'INT8'", "'INTEGER'", "'BIGINT'", "'REAL'", "'DOUBLE'", "'PRECISION'", + "'FLOAT'", "'FLOAT4'", "'FLOAT8'", "'DECIMAL'", "'DEC'", "'NUMERIC'", + "'DATE'", "'TIME'", "'TIMESTAMP'", "'DATETIME'", "'YEAR'", "'CHAR'", + "'VARCHAR'", "'NVARCHAR'", "'NATIONAL'", "'BINARY'", "'VARBINARY'", "'TINYBLOB'", + "'BLOB'", "'MEDIUMBLOB'", "'LONG'", "'LONGBLOB'", "'TINYTEXT'", "'TEXT'", + "'MEDIUMTEXT'", "'LONGTEXT'", "'ENUM'", "'VARYING'", "'SERIAL'", "'YEAR_MONTH'", + "'DAY_HOUR'", "'DAY_MINUTE'", "'DAY_SECOND'", "'HOUR_MINUTE'", "'HOUR_SECOND'", + "'MINUTE_SECOND'", "'SECOND_MICROSECOND'", "'MINUTE_MICROSECOND'", "'HOUR_MICROSECOND'", + "'DAY_MICROSECOND'", "'JSON_ARRAY'", "'JSON_ARRAYAGG'", "'JSON_ARRAY_APPEND'", + "'JSON_ARRAY_INSERT'", "'JSON_CONTAINS'", "'JSON_CONTAINS_PATH'", "'JSON_DEPTH'", + "'JSON_EXTRACT'", "'JSON_INSERT'", "'JSON_KEYS'", "'JSON_LENGTH'", "'JSON_MERGE'", + "'JSON_MERGE_PATCH'", "'JSON_MERGE_PRESERVE'", "'JSON_OBJECT'", "'JSON_OBJECTAGG'", + "'JSON_OVERLAPS'", "'JSON_PRETTY'", "'JSON_QUOTE'", "'JSON_REMOVE'", + "'JSON_REPLACE'", "'JSON_SCHEMA_VALID'", "'JSON_SCHEMA_VALIDATION_REPORT'", + "'JSON_SEARCH'", "'JSON_SET'", "'JSON_STORAGE_FREE'", "'JSON_STORAGE_SIZE'", + "'JSON_TABLE'", "'JSON_TYPE'", "'JSON_UNQUOTE'", "'JSON_VALID'", "'JSON_VALUE'", + "'NESTED'", "'ORDINALITY'", "'PATH'", "'AVG'", "'BIT_AND'", "'BIT_OR'", + "'BIT_XOR'", "'COUNT'", "'CUME_DIST'", "'DENSE_RANK'", "'FIRST_VALUE'", + "'GROUP_CONCAT'", "'LAG'", "'LAST_VALUE'", "'LEAD'", "'MAX'", "'MIN'", + "'NTILE'", "'NTH_VALUE'", "'PERCENT_RANK'", "'RANK'", "'ROW_NUMBER'", + "'STD'", "'STDDEV'", "'STDDEV_POP'", "'STDDEV_SAMP'", "'SUM'", "'VAR_POP'", + "'VAR_SAMP'", "'VARIANCE'", "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'LOCALTIME'", "'CURDATE'", "'CURTIME'", "'DATE_ADD'", "'DATE_SUB'", + "'EXTRACT'", "'LOCALTIMESTAMP'", "'NOW'", "'POSITION'", "'SUBSTR'", "'SUBSTRING'", + "'SYSDATE'", "'TRIM'", "'UTC_DATE'", "'UTC_TIME'", "'UTC_TIMESTAMP'", + "'ACCOUNT'", "'ACTION'", "'AFTER'", "'AGGREGATE'", "'ALGORITHM'", "'ANY'", + "'AT'", "'AUTHORS'", "'AUTOCOMMIT'", "'AUTOEXTEND_SIZE'", "'AUTO_INCREMENT'", + "'AVG_ROW_LENGTH'", "'BEGIN'", "'BINLOG'", "'BIT'", "'BLOCK'", "'BOOL'", + "'BOOLEAN'", "'BTREE'", "'CACHE'", "'CASCADED'", "'CHAIN'", "'CHANGED'", + "'CHANNEL'", "'CHECKSUM'", "'PAGE_CHECKSUM'", "'CIPHER'", "'CLASS_ORIGIN'", + "'CLIENT'", "'CLOSE'", "'CLUSTERING'", "'COALESCE'", "'CODE'", "'COLUMNS'", + "'COLUMN_FORMAT'", "'COLUMN_NAME'", "'COMMENT'", "'COMMIT'", "'COMPACT'", + "'COMPLETION'", "'COMPRESSED'", "'COMPRESSION'", "'CONCURRENT'", "'CONNECT'", + "'CONNECTION'", "'CONSISTENT'", "'CONSTRAINT_CATALOG'", "'CONSTRAINT_SCHEMA'", + "'CONSTRAINT_NAME'", "'CONTAINS'", "'CONTEXT'", "'CONTRIBUTORS'", "'COPY'", + "'CPU'", "'CYCLE'", "'CURSOR_NAME'", "'DATA'", "'DATAFILE'", "'DEALLOCATE'", + "'DEFAULT_AUTH'", "'DEFINER'", "'DELAY_KEY_WRITE'", "'DES_KEY_FILE'", + "'DIRECTORY'", "'DISABLE'", "'DISCARD'", "'DISK'", "'DO'", "'DUMPFILE'", + "'DUPLICATE'", "'DYNAMIC'", "'ENABLE'", "'ENCRYPTED'", "'ENCRYPTION'", + "'ENCRYPTION_KEY_ID'", "'END'", "'ENDS'", "'ENGINE'", "'ENGINES'", "'ERROR'", + "'ERRORS'", "'ESCAPE'", "'EVEN'", "'EVENT'", "'EVENTS'", "'EVERY'", "'EXCHANGE'", + "'EXCLUSIVE'", "'EXPIRE'", "'EXPORT'", "'EXTENDED'", "'EXTENT_SIZE'", + "'FAILED_LOGIN_ATTEMPTS'", "'FAST'", "'FAULTS'", "'FIELDS'", "'FILE_BLOCK_SIZE'", + "'FILTER'", "'FIRST'", "'FIXED'", "'FLUSH'", "'FOLLOWING'", "'FOLLOWS'", + "'FOUND'", "'FULL'", "'FUNCTION'", "'GENERAL'", "'GLOBAL'", "'GRANTS'", + "'GROUP_REPLICATION'", "'HANDLER'", "'HASH'", "'HELP'", "'HISTORY'", + "'HOST'", "'HOSTS'", "'IDENTIFIED'", "'IGNORE_SERVER_IDS'", "'IMPORT'", + "'INCREMENT'", "'INDEXES'", "'INITIAL_SIZE'", "'INPLACE'", "'INSERT_METHOD'", + "'INSTALL'", "'INSTANCE'", "'INSTANT'", "'INVISIBLE'", "'INVOKER'", "'IO'", + "'IO_THREAD'", "'IPC'", "'ISOLATION'", "'ISSUER'", "'JSON'", "'KEY_BLOCK_SIZE'", + "'LANGUAGE'", "'LAST'", "'LEAVES'", "'LESS'", "'LEVEL'", "'LIST'", "'LOCAL'", + "'LOGFILE'", "'LOGS'", "'MASTER'", "'MASTER_AUTO_POSITION'", "'MASTER_CONNECT_RETRY'", + "'MASTER_DELAY'", "'MASTER_HEARTBEAT_PERIOD'", "'MASTER_HOST'", "'MASTER_LOG_FILE'", + "'MASTER_LOG_POS'", "'MASTER_PASSWORD'", "'MASTER_PORT'", "'MASTER_RETRY_COUNT'", + "'MASTER_SSL'", "'MASTER_SSL_CA'", "'MASTER_SSL_CAPATH'", "'MASTER_SSL_CERT'", + "'MASTER_SSL_CIPHER'", "'MASTER_SSL_CRL'", "'MASTER_SSL_CRLPATH'", "'MASTER_SSL_KEY'", + "'MASTER_TLS_VERSION'", "'MASTER_USER'", "'MAX_CONNECTIONS_PER_HOUR'", + "'MAX_QUERIES_PER_HOUR'", "'MAX_ROWS'", "'MAX_SIZE'", "'MAX_UPDATES_PER_HOUR'", + "'MAX_USER_CONNECTIONS'", "'MEDIUM'", "'MEMBER'", "'MERGE'", "'MESSAGE_TEXT'", + "'MID'", "'MIGRATE'", "'MIN_ROWS'", "'MODE'", "'MODIFY'", "'MUTEX'", + "'MYSQL'", "'MYSQL_ERRNO'", "'NAME'", "'NAMES'", "'NCHAR'", "'NEVER'", + "'NEXT'", "'NO'", "'NOCACHE'", "'NOCOPY'", "'NOCYCLE'", "'NOMAXVALUE'", + "'NOMINVALUE'", "'NOWAIT'", "'NODEGROUP'", "'NONE'", "'ODBC'", "'OFFLINE'", + "'OFFSET'", "'OF'", "'OJ'", "'OLD_PASSWORD'", "'ONE'", "'ONLINE'", "'ONLY'", + "'OPEN'", "'OPTIMIZER_COSTS'", "'OPTIONS'", "'OWNER'", "'PACK_KEYS'", + "'PAGE'", "'PAGE_COMPRESSED'", "'PAGE_COMPRESSION_LEVEL'", "'PARSER'", + "'PARTIAL'", "'PARTITIONING'", "'PARTITIONS'", "'PASSWORD'", "'PASSWORD_LOCK_TIME'", + "'PHASE'", "'PLUGIN'", "'PLUGIN_DIR'", "'PLUGINS'", "'PORT'", "'PRECEDES'", + "'PRECEDING'", "'PREPARE'", "'PRESERVE'", "'PREV'", "'PROCESSLIST'", + "'PROFILE'", "'PROFILES'", "'PROXY'", "'QUERY'", "'QUICK'", "'REBUILD'", + "'RECOVER'", "'RECURSIVE'", "'REDO_BUFFER_SIZE'", "'REDUNDANT'", "'RELAY'", + "'RELAY_LOG_FILE'", "'RELAY_LOG_POS'", "'RELAYLOG'", "'REMOVE'", "'REORGANIZE'", + "'REPAIR'", "'REPLICATE_DO_DB'", "'REPLICATE_DO_TABLE'", "'REPLICATE_IGNORE_DB'", + "'REPLICATE_IGNORE_TABLE'", "'REPLICATE_REWRITE_DB'", "'REPLICATE_WILD_DO_TABLE'", + "'REPLICATE_WILD_IGNORE_TABLE'", "'REPLICATION'", "'RESET'", "'RESTART'", + "'RESUME'", "'RETURNED_SQLSTATE'", "'RETURNING'", "'RETURNS'", "'REUSE'", + "'ROLE'", "'ROLLBACK'", "'ROLLUP'", "'ROTATE'", "'ROW'", "'ROWS'", "'ROW_FORMAT'", + "'RTREE'", "'SAVEPOINT'", "'SCHEDULE'", "'SECURITY'", "'SEQUENCE'", "'SERVER'", + "'SESSION'", "'SHARE'", "'SHARED'", "'SIGNED'", "'SIMPLE'", "'SLAVE'", + "'SLOW'", "'SNAPSHOT'", "'SOCKET'", "'SOME'", "'SONAME'", "'SOUNDS'", + "'SOURCE'", "'SQL_AFTER_GTIDS'", "'SQL_AFTER_MTS_GAPS'", "'SQL_BEFORE_GTIDS'", + "'SQL_BUFFER_RESULT'", "'SQL_CACHE'", "'SQL_NO_CACHE'", "'SQL_THREAD'", + "'START'", "'STARTS'", "'STATS_AUTO_RECALC'", "'STATS_PERSISTENT'", "'STATS_SAMPLE_PAGES'", + "'STATUS'", "'STOP'", "'STORAGE'", "'STORED'", "'STRING'", "'SUBCLASS_ORIGIN'", + "'SUBJECT'", "'SUBPARTITION'", "'SUBPARTITIONS'", "'SUSPEND'", "'SWAPS'", + "'SWITCHES'", "'TABLE_NAME'", "'TABLESPACE'", "'TABLE_TYPE'", "'TEMPORARY'", + "'TEMPTABLE'", "'THAN'", "'TRADITIONAL'", "'TRANSACTION'", "'TRANSACTIONAL'", + "'TRIGGERS'", "'TRUNCATE'", "'UNBOUNDED'", "'UNDEFINED'", "'UNDOFILE'", + "'UNDO_BUFFER_SIZE'", "'UNINSTALL'", "'UNKNOWN'", "'UNTIL'", "'UPGRADE'", + "'USER'", "'USE_FRM'", "'USER_RESOURCES'", "'VALIDATION'", "'VALUE'", + "'VARIABLES'", "'VIEW'", "'VIRTUAL'", "'VISIBLE'", "'WAIT'", "'WARNINGS'", + "'WINDOW'", "'WITHOUT'", "'WORK'", "'WRAPPER'", "'X509'", "'XA'", "'XML'", + "'YES'", "'EUR'", "'USA'", "'JIS'", "'ISO'", "'INTERNAL'", "'QUARTER'", + "'MONTH'", "'DAY'", "'HOUR'", "'MINUTE'", "'WEEK'", "'SECOND'", "'MICROSECOND'", + "'ADMIN'", "'APPLICATION_PASSWORD_ADMIN'", "'AUDIT_ABORT_EXEMPT'", "'AUDIT_ADMIN'", + "'AUTHENTICATION_POLICY_ADMIN'", "'BACKUP_ADMIN'", "'BINLOG_ADMIN'", + "'BINLOG_ENCRYPTION_ADMIN'", "'CLONE_ADMIN'", "'CONNECTION_ADMIN'", "'ENCRYPTION_KEY_ADMIN'", + "'EXECUTE'", "'FILE'", "'FIREWALL_ADMIN'", "'FIREWALL_EXEMPT'", "'FIREWALL_USER'", + "'FLUSH_OPTIMIZER_COSTS'", "'FLUSH_STATUS'", "'FLUSH_TABLES'", "'FLUSH_USER_RESOURCES'", + "'GROUP_REPLICATION_ADMIN'", "'INNODB_REDO_LOG_ARCHIVE'", "'INNODB_REDO_LOG_ENABLE'", + "'INVOKE'", "'LAMBDA'", "'NDB_STORED_USER'", "'PASSWORDLESS_USER_ADMIN'", + "'PERSIST_RO_VARIABLES_ADMIN'", "'PRIVILEGES'", "'PROCESS'", "'RELOAD'", + "'REPLICATION_APPLIER'", "'REPLICATION_SLAVE_ADMIN'", "'RESOURCE_GROUP_ADMIN'", + "'RESOURCE_GROUP_USER'", "'ROLE_ADMIN'", "'ROUTINE'", "'S3'", "'SERVICE_CONNECTION_ADMIN'", + null, "'SET_USER_ID'", "'SHOW_ROUTINE'", "'SHUTDOWN'", "'SUPER'", "'SYSTEM_VARIABLES_ADMIN'", + "'TABLES'", "'TABLE_ENCRYPTION_ADMIN'", "'VERSION_TOKEN_ADMIN'", "'XA_RECOVER_ADMIN'", + "'ARMSCII8'", "'ASCII'", "'BIG5'", "'CP1250'", "'CP1251'", "'CP1256'", + "'CP1257'", "'CP850'", "'CP852'", "'CP866'", "'CP932'", "'DEC8'", "'EUCJPMS'", + "'EUCKR'", "'GB18030'", "'GB2312'", "'GBK'", "'GEOSTD8'", "'GREEK'", + "'HEBREW'", "'HP8'", "'KEYBCS2'", "'KOI8R'", "'KOI8U'", "'LATIN1'", "'LATIN2'", + "'LATIN5'", "'LATIN7'", "'MACCE'", "'MACROMAN'", "'SJIS'", "'SWE7'", + "'TIS620'", "'UCS2'", "'UJIS'", "'UTF16'", "'UTF16LE'", "'UTF32'", "'UTF8'", + "'UTF8MB3'", "'UTF8MB4'", "'ARCHIVE'", "'BLACKHOLE'", "'CSV'", "'FEDERATED'", + "'INNODB'", "'MEMORY'", "'MRG_MYISAM'", "'MYISAM'", "'NDB'", "'NDBCLUSTER'", + "'PERFORMANCE_SCHEMA'", "'TOKUDB'", "'REPEATABLE'", "'COMMITTED'", "'UNCOMMITTED'", + "'SERIALIZABLE'", "'GEOMETRYCOLLECTION'", "'GEOMCOLLECTION'", "'GEOMETRY'", + "'LINESTRING'", "'MULTILINESTRING'", "'MULTIPOINT'", "'MULTIPOLYGON'", + "'POINT'", "'POLYGON'", "'ABS'", "'ACOS'", "'ADDDATE'", "'ADDTIME'", + "'AES_DECRYPT'", "'AES_ENCRYPT'", "'AREA'", "'ASBINARY'", "'ASIN'", "'ASTEXT'", + "'ASWKB'", "'ASWKT'", "'ASYMMETRIC_DECRYPT'", "'ASYMMETRIC_DERIVE'", + "'ASYMMETRIC_ENCRYPT'", "'ASYMMETRIC_SIGN'", "'ASYMMETRIC_VERIFY'", "'ATAN'", + "'ATAN2'", "'BENCHMARK'", "'BIN'", "'BIT_COUNT'", "'BIT_LENGTH'", "'BUFFER'", + "'CATALOG_NAME'", "'CEIL'", "'CEILING'", "'CENTROID'", "'CHARACTER_LENGTH'", + "'CHARSET'", "'CHAR_LENGTH'", "'COERCIBILITY'", "'COLLATION'", "'COMPRESS'", + "'CONCAT'", "'CONCAT_WS'", "'CONNECTION_ID'", "'CONV'", "'CONVERT_TZ'", + "'COS'", "'COT'", "'CRC32'", "'CREATE_ASYMMETRIC_PRIV_KEY'", "'CREATE_ASYMMETRIC_PUB_KEY'", + "'CREATE_DH_PARAMETERS'", "'CREATE_DIGEST'", "'CROSSES'", "'DATEDIFF'", + "'DATE_FORMAT'", "'DAYNAME'", "'DAYOFMONTH'", "'DAYOFWEEK'", "'DAYOFYEAR'", + "'DECODE'", "'DEGREES'", "'DES_DECRYPT'", "'DES_ENCRYPT'", "'DIMENSION'", + "'DISJOINT'", "'ELT'", "'ENCODE'", "'ENCRYPT'", "'ENDPOINT'", "'ENGINE_ATTRIBUTE'", + "'ENVELOPE'", "'EQUALS'", "'EXP'", "'EXPORT_SET'", "'EXTERIORRING'", + "'EXTRACTVALUE'", "'FIELD'", "'FIND_IN_SET'", "'FLOOR'", "'FORMAT'", + "'FOUND_ROWS'", "'FROM_BASE64'", "'FROM_DAYS'", "'FROM_UNIXTIME'", "'GEOMCOLLFROMTEXT'", + "'GEOMCOLLFROMWKB'", "'GEOMETRYCOLLECTIONFROMTEXT'", "'GEOMETRYCOLLECTIONFROMWKB'", + "'GEOMETRYFROMTEXT'", "'GEOMETRYFROMWKB'", "'GEOMETRYN'", "'GEOMETRYTYPE'", + "'GEOMFROMTEXT'", "'GEOMFROMWKB'", "'GET_FORMAT'", "'GET_LOCK'", "'GLENGTH'", + "'GREATEST'", "'GTID_SUBSET'", "'GTID_SUBTRACT'", "'HEX'", "'IFNULL'", + "'INET6_ATON'", "'INET6_NTOA'", "'INET_ATON'", "'INET_NTOA'", "'INSTR'", + "'INTERIORRINGN'", "'INTERSECTS'", "'ISCLOSED'", "'ISEMPTY'", "'ISNULL'", + "'ISSIMPLE'", "'IS_FREE_LOCK'", "'IS_IPV4'", "'IS_IPV4_COMPAT'", "'IS_IPV4_MAPPED'", + "'IS_IPV6'", "'IS_USED_LOCK'", "'LAST_INSERT_ID'", "'LCASE'", "'LEAST'", + "'LENGTH'", "'LINEFROMTEXT'", "'LINEFROMWKB'", "'LINESTRINGFROMTEXT'", + "'LINESTRINGFROMWKB'", "'LN'", "'LOAD_FILE'", "'LOCATE'", "'LOG'", "'LOG10'", + "'LOG2'", "'LOWER'", "'LPAD'", "'LTRIM'", "'MAKEDATE'", "'MAKETIME'", + "'MAKE_SET'", "'MASTER_POS_WAIT'", "'MBRCONTAINS'", "'MBRDISJOINT'", + "'MBREQUAL'", "'MBRINTERSECTS'", "'MBROVERLAPS'", "'MBRTOUCHES'", "'MBRWITHIN'", + "'MD5'", "'MLINEFROMTEXT'", "'MLINEFROMWKB'", "'MONTHNAME'", "'MPOINTFROMTEXT'", + "'MPOINTFROMWKB'", "'MPOLYFROMTEXT'", "'MPOLYFROMWKB'", "'MULTILINESTRINGFROMTEXT'", + "'MULTILINESTRINGFROMWKB'", "'MULTIPOINTFROMTEXT'", "'MULTIPOINTFROMWKB'", + "'MULTIPOLYGONFROMTEXT'", "'MULTIPOLYGONFROMWKB'", "'NAME_CONST'", "'NULLIF'", + "'NUMGEOMETRIES'", "'NUMINTERIORRINGS'", "'NUMPOINTS'", "'OCT'", "'OCTET_LENGTH'", + "'ORD'", "'OVERLAPS'", "'PERIOD_ADD'", "'PERIOD_DIFF'", "'PI'", "'POINTFROMTEXT'", + "'POINTFROMWKB'", "'POINTN'", "'POLYFROMTEXT'", "'POLYFROMWKB'", "'POLYGONFROMTEXT'", + "'POLYGONFROMWKB'", "'POW'", "'POWER'", "'QUOTE'", "'RADIANS'", "'RAND'", + "'RANDOM'", "'RANDOM_BYTES'", "'RELEASE_LOCK'", "'REVERSE'", "'ROUND'", + "'ROW_COUNT'", "'RPAD'", "'RTRIM'", "'SEC_TO_TIME'", "'SECONDARY_ENGINE_ATTRIBUTE'", + "'SESSION_USER'", "'SHA'", "'SHA1'", "'SHA2'", "'SCHEMA_NAME'", "'SIGN'", + "'SIN'", "'SLEEP'", "'SOUNDEX'", "'SQL_THREAD_WAIT_AFTER_GTIDS'", "'SQRT'", + "'SRID'", "'STARTPOINT'", "'STRCMP'", "'STR_TO_DATE'", "'ST_AREA'", "'ST_ASBINARY'", + "'ST_ASTEXT'", "'ST_ASWKB'", "'ST_ASWKT'", "'ST_BUFFER'", "'ST_CENTROID'", + "'ST_CONTAINS'", "'ST_CROSSES'", "'ST_DIFFERENCE'", "'ST_DIMENSION'", + "'ST_DISJOINT'", "'ST_DISTANCE'", "'ST_ENDPOINT'", "'ST_ENVELOPE'", "'ST_EQUALS'", + "'ST_EXTERIORRING'", "'ST_GEOMCOLLFROMTEXT'", "'ST_GEOMCOLLFROMTXT'", + "'ST_GEOMCOLLFROMWKB'", "'ST_GEOMETRYCOLLECTIONFROMTEXT'", "'ST_GEOMETRYCOLLECTIONFROMWKB'", + "'ST_GEOMETRYFROMTEXT'", "'ST_GEOMETRYFROMWKB'", "'ST_GEOMETRYN'", "'ST_GEOMETRYTYPE'", + "'ST_GEOMFROMTEXT'", "'ST_GEOMFROMWKB'", "'ST_INTERIORRINGN'", "'ST_INTERSECTION'", + "'ST_INTERSECTS'", "'ST_ISCLOSED'", "'ST_ISEMPTY'", "'ST_ISSIMPLE'", + "'ST_LINEFROMTEXT'", "'ST_LINEFROMWKB'", "'ST_LINESTRINGFROMTEXT'", "'ST_LINESTRINGFROMWKB'", + "'ST_NUMGEOMETRIES'", "'ST_NUMINTERIORRING'", "'ST_NUMINTERIORRINGS'", + "'ST_NUMPOINTS'", "'ST_OVERLAPS'", "'ST_POINTFROMTEXT'", "'ST_POINTFROMWKB'", + "'ST_POINTN'", "'ST_POLYFROMTEXT'", "'ST_POLYFROMWKB'", "'ST_POLYGONFROMTEXT'", + "'ST_POLYGONFROMWKB'", "'ST_SRID'", "'ST_STARTPOINT'", "'ST_SYMDIFFERENCE'", + "'ST_TOUCHES'", "'ST_UNION'", "'ST_WITHIN'", "'ST_X'", "'ST_Y'", "'SUBDATE'", + "'SUBSTRING_INDEX'", "'SUBTIME'", "'SYSTEM_USER'", "'TAN'", "'TIMEDIFF'", + "'TIMESTAMPADD'", "'TIMESTAMPDIFF'", "'TIME_FORMAT'", "'TIME_TO_SEC'", + "'TOUCHES'", "'TO_BASE64'", "'TO_DAYS'", "'TO_SECONDS'", "'TP_CONNECTION_ADMIN'", + "'UCASE'", "'UNCOMPRESS'", "'UNCOMPRESSED_LENGTH'", "'UNHEX'", "'UNIX_TIMESTAMP'", + "'UPDATEXML'", "'UPPER'", "'UUID'", "'UUID_SHORT'", "'VALIDATE_PASSWORD_STRENGTH'", + "'VERSION'", "'WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS'", "'WEEKDAY'", "'WEEKOFYEAR'", + "'WEIGHT_STRING'", "'WITHIN'", "'YEARWEEK'", "'Y'", "'X'", "':='", "'+='", + "'-='", "'*='", "'/='", "'%='", "'&='", "'^='", "'|='", "'*'", "'/'", + "'%'", "'+'", "'-'", "'DIV'", "'MOD'", "'='", "'>'", "'<'", "'!'", "'~'", + "'|'", "'&'", "'^'", "'.'", "'('", "')'", "','", "';'", "'@'", "'0'", + "'1'", "'2'", "'''", "'\"'", "'`'", "':'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "SPEL", "SPACE", "SPEC_MYSQL_COMMENT", "COMMENT_INPUT", "LINE_COMMENT", + "ADD", "ALL", "ALTER", "ALWAYS", "ANALYZE", "AND", "ARRAY", "AS", "ASC", + "ATTRIBUTE", "BEFORE", "BETWEEN", "BOTH", "BUCKETS", "BY", "CALL", "CASCADE", + "CASE", "CAST", "CHANGE", "CHARACTER", "CHECK", "COLLATE", "COLUMN", + "CONDITION", "CONSTRAINT", "CONTINUE", "CONVERT", "CREATE", "CROSS", + "CURRENT", "CURRENT_ROLE", "CURRENT_USER", "CURSOR", "DATABASE", "DATABASES", + "DECLARE", "DEFAULT", "DELAYED", "DELETE", "DESC", "DESCRIBE", "DETERMINISTIC", + "DIAGNOSTICS", "DISTINCT", "DISTINCTROW", "DROP", "EACH", "ELSE", "ELSEIF", + "EMPTY", "ENCLOSED", "ENFORCED", "ESCAPED", "EXCEPT", "EXISTS", "EXIT", + "EXPLAIN", "FALSE", "FETCH", "FOR", "FORCE", "FOREIGN", "FROM", "FULLTEXT", + "GENERATED", "GET", "GRANT", "GROUP", "HAVING", "HIGH_PRIORITY", "HISTOGRAM", + "IF", "IGNORE", "IGNORED", "IN", "INDEX", "INFILE", "INNER", "INOUT", + "INSERT", "INTERVAL", "INTO", "IS", "ITERATE", "JOIN", "KEY", "KEYS", + "KILL", "LATERAL", "LEADING", "LEAVE", "LEFT", "LIKE", "LIMIT", "LINEAR", + "LINES", "LOAD", "LOCK", "LOCKED", "LOOP", "LOW_PRIORITY", "MASTER_BIND", + "MASTER_SSL_VERIFY_SERVER_CERT", "MATCH", "MAXVALUE", "MINVALUE", "MODIFIES", + "NATURAL", "NOT", "NO_WRITE_TO_BINLOG", "NULL_LITERAL", "NUMBER", "ON", + "OPTIMIZE", "OPTION", "OPTIONAL", "OPTIONALLY", "OR", "ORDER", "OUT", + "OUTER", "OUTFILE", "OVER", "PARTITION", "PRIMARY", "PROCEDURE", "PURGE", + "RANGE", "READ", "READS", "REFERENCES", "REGEXP", "RELEASE", "RENAME", + "REPEAT", "REPLACE", "REQUIRE", "RESIGNAL", "RESTRICT", "RETAIN", "RETURN", + "REVOKE", "RIGHT", "RLIKE", "SCHEMA", "SCHEMAS", "SELECT", "SET", "SEPARATOR", + "SHOW", "SIGNAL", "SKIP_", "SKIP_QUERY_REWRITE", "SPATIAL", "SQL", "SQLEXCEPTION", + "SQLSTATE", "SQLWARNING", "SQL_BIG_RESULT", "SQL_CALC_FOUND_ROWS", "SQL_SMALL_RESULT", + "SSL", "STACKED", "STARTING", "STATEMENT", "STRAIGHT_JOIN", "TABLE", + "TERMINATED", "THEN", "TO", "TRAILING", "TRIGGER", "TRUE", "UNDO", "UNION", + "UNIQUE", "UNLOCK", "UNSIGNED", "UPDATE", "USAGE", "USE", "USING", "VALUES", + "WHEN", "WHERE", "WHILE", "WITH", "WRITE", "XOR", "ZEROFILL", "TINYINT", + "SMALLINT", "MEDIUMINT", "MIDDLEINT", "INT", "INT1", "INT2", "INT3", + "INT4", "INT8", "INTEGER", "BIGINT", "REAL", "DOUBLE", "PRECISION", "FLOAT", + "FLOAT4", "FLOAT8", "DECIMAL", "DEC", "NUMERIC", "DATE", "TIME", "TIMESTAMP", + "DATETIME", "YEAR", "CHAR", "VARCHAR", "NVARCHAR", "NATIONAL", "BINARY", + "VARBINARY", "TINYBLOB", "BLOB", "MEDIUMBLOB", "LONG", "LONGBLOB", "TINYTEXT", + "TEXT", "MEDIUMTEXT", "LONGTEXT", "ENUM", "VARYING", "SERIAL", "YEAR_MONTH", + "DAY_HOUR", "DAY_MINUTE", "DAY_SECOND", "HOUR_MINUTE", "HOUR_SECOND", + "MINUTE_SECOND", "SECOND_MICROSECOND", "MINUTE_MICROSECOND", "HOUR_MICROSECOND", + "DAY_MICROSECOND", "JSON_ARRAY", "JSON_ARRAYAGG", "JSON_ARRAY_APPEND", + "JSON_ARRAY_INSERT", "JSON_CONTAINS", "JSON_CONTAINS_PATH", "JSON_DEPTH", + "JSON_EXTRACT", "JSON_INSERT", "JSON_KEYS", "JSON_LENGTH", "JSON_MERGE", + "JSON_MERGE_PATCH", "JSON_MERGE_PRESERVE", "JSON_OBJECT", "JSON_OBJECTAGG", + "JSON_OVERLAPS", "JSON_PRETTY", "JSON_QUOTE", "JSON_REMOVE", "JSON_REPLACE", + "JSON_SCHEMA_VALID", "JSON_SCHEMA_VALIDATION_REPORT", "JSON_SEARCH", + "JSON_SET", "JSON_STORAGE_FREE", "JSON_STORAGE_SIZE", "JSON_TABLE", "JSON_TYPE", + "JSON_UNQUOTE", "JSON_VALID", "JSON_VALUE", "NESTED", "ORDINALITY", "PATH", + "AVG", "BIT_AND", "BIT_OR", "BIT_XOR", "COUNT", "CUME_DIST", "DENSE_RANK", + "FIRST_VALUE", "GROUP_CONCAT", "LAG", "LAST_VALUE", "LEAD", "MAX", "MIN", + "NTILE", "NTH_VALUE", "PERCENT_RANK", "RANK", "ROW_NUMBER", "STD", "STDDEV", + "STDDEV_POP", "STDDEV_SAMP", "SUM", "VAR_POP", "VAR_SAMP", "VARIANCE", + "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "LOCALTIME", "CURDATE", + "CURTIME", "DATE_ADD", "DATE_SUB", "EXTRACT", "LOCALTIMESTAMP", "NOW", + "POSITION", "SUBSTR", "SUBSTRING", "SYSDATE", "TRIM", "UTC_DATE", "UTC_TIME", + "UTC_TIMESTAMP", "ACCOUNT", "ACTION", "AFTER", "AGGREGATE", "ALGORITHM", + "ANY", "AT", "AUTHORS", "AUTOCOMMIT", "AUTOEXTEND_SIZE", "AUTO_INCREMENT", + "AVG_ROW_LENGTH", "BEGIN", "BINLOG", "BIT", "BLOCK", "BOOL", "BOOLEAN", + "BTREE", "CACHE", "CASCADED", "CHAIN", "CHANGED", "CHANNEL", "CHECKSUM", + "PAGE_CHECKSUM", "CIPHER", "CLASS_ORIGIN", "CLIENT", "CLOSE", "CLUSTERING", + "COALESCE", "CODE", "COLUMNS", "COLUMN_FORMAT", "COLUMN_NAME", "COMMENT", + "COMMIT", "COMPACT", "COMPLETION", "COMPRESSED", "COMPRESSION", "CONCURRENT", + "CONNECT", "CONNECTION", "CONSISTENT", "CONSTRAINT_CATALOG", "CONSTRAINT_SCHEMA", + "CONSTRAINT_NAME", "CONTAINS", "CONTEXT", "CONTRIBUTORS", "COPY", "CPU", + "CYCLE", "CURSOR_NAME", "DATA", "DATAFILE", "DEALLOCATE", "DEFAULT_AUTH", + "DEFINER", "DELAY_KEY_WRITE", "DES_KEY_FILE", "DIRECTORY", "DISABLE", + "DISCARD", "DISK", "DO", "DUMPFILE", "DUPLICATE", "DYNAMIC", "ENABLE", + "ENCRYPTED", "ENCRYPTION", "ENCRYPTION_KEY_ID", "END", "ENDS", "ENGINE", + "ENGINES", "ERROR", "ERRORS", "ESCAPE", "EVEN", "EVENT", "EVENTS", "EVERY", + "EXCHANGE", "EXCLUSIVE", "EXPIRE", "EXPORT", "EXTENDED", "EXTENT_SIZE", + "FAILED_LOGIN_ATTEMPTS", "FAST", "FAULTS", "FIELDS", "FILE_BLOCK_SIZE", + "FILTER", "FIRST", "FIXED", "FLUSH", "FOLLOWING", "FOLLOWS", "FOUND", + "FULL", "FUNCTION", "GENERAL", "GLOBAL", "GRANTS", "GROUP_REPLICATION", + "HANDLER", "HASH", "HELP", "HISTORY", "HOST", "HOSTS", "IDENTIFIED", + "IGNORE_SERVER_IDS", "IMPORT", "INCREMENT", "INDEXES", "INITIAL_SIZE", + "INPLACE", "INSERT_METHOD", "INSTALL", "INSTANCE", "INSTANT", "INVISIBLE", + "INVOKER", "IO", "IO_THREAD", "IPC", "ISOLATION", "ISSUER", "JSON", "KEY_BLOCK_SIZE", + "LANGUAGE", "LAST", "LEAVES", "LESS", "LEVEL", "LIST", "LOCAL", "LOGFILE", + "LOGS", "MASTER", "MASTER_AUTO_POSITION", "MASTER_CONNECT_RETRY", "MASTER_DELAY", + "MASTER_HEARTBEAT_PERIOD", "MASTER_HOST", "MASTER_LOG_FILE", "MASTER_LOG_POS", + "MASTER_PASSWORD", "MASTER_PORT", "MASTER_RETRY_COUNT", "MASTER_SSL", + "MASTER_SSL_CA", "MASTER_SSL_CAPATH", "MASTER_SSL_CERT", "MASTER_SSL_CIPHER", + "MASTER_SSL_CRL", "MASTER_SSL_CRLPATH", "MASTER_SSL_KEY", "MASTER_TLS_VERSION", + "MASTER_USER", "MAX_CONNECTIONS_PER_HOUR", "MAX_QUERIES_PER_HOUR", "MAX_ROWS", + "MAX_SIZE", "MAX_UPDATES_PER_HOUR", "MAX_USER_CONNECTIONS", "MEDIUM", + "MEMBER", "MERGE", "MESSAGE_TEXT", "MID", "MIGRATE", "MIN_ROWS", "MODE", + "MODIFY", "MUTEX", "MYSQL", "MYSQL_ERRNO", "NAME", "NAMES", "NCHAR", + "NEVER", "NEXT", "NO", "NOCACHE", "NOCOPY", "NOCYCLE", "NOMAXVALUE", + "NOMINVALUE", "NOWAIT", "NODEGROUP", "NONE", "ODBC", "OFFLINE", "OFFSET", + "OF", "OJ", "OLD_PASSWORD", "ONE", "ONLINE", "ONLY", "OPEN", "OPTIMIZER_COSTS", + "OPTIONS", "OWNER", "PACK_KEYS", "PAGE", "PAGE_COMPRESSED", "PAGE_COMPRESSION_LEVEL", + "PARSER", "PARTIAL", "PARTITIONING", "PARTITIONS", "PASSWORD", "PASSWORD_LOCK_TIME", + "PHASE", "PLUGIN", "PLUGIN_DIR", "PLUGINS", "PORT", "PRECEDES", "PRECEDING", + "PREPARE", "PRESERVE", "PREV", "PROCESSLIST", "PROFILE", "PROFILES", + "PROXY", "QUERY", "QUICK", "REBUILD", "RECOVER", "RECURSIVE", "REDO_BUFFER_SIZE", + "REDUNDANT", "RELAY", "RELAY_LOG_FILE", "RELAY_LOG_POS", "RELAYLOG", + "REMOVE", "REORGANIZE", "REPAIR", "REPLICATE_DO_DB", "REPLICATE_DO_TABLE", + "REPLICATE_IGNORE_DB", "REPLICATE_IGNORE_TABLE", "REPLICATE_REWRITE_DB", + "REPLICATE_WILD_DO_TABLE", "REPLICATE_WILD_IGNORE_TABLE", "REPLICATION", + "RESET", "RESTART", "RESUME", "RETURNED_SQLSTATE", "RETURNING", "RETURNS", + "REUSE", "ROLE", "ROLLBACK", "ROLLUP", "ROTATE", "ROW", "ROWS", "ROW_FORMAT", + "RTREE", "SAVEPOINT", "SCHEDULE", "SECURITY", "SEQUENCE", "SERVER", "SESSION", + "SHARE", "SHARED", "SIGNED", "SIMPLE", "SLAVE", "SLOW", "SNAPSHOT", "SOCKET", + "SOME", "SONAME", "SOUNDS", "SOURCE", "SQL_AFTER_GTIDS", "SQL_AFTER_MTS_GAPS", + "SQL_BEFORE_GTIDS", "SQL_BUFFER_RESULT", "SQL_CACHE", "SQL_NO_CACHE", + "SQL_THREAD", "START", "STARTS", "STATS_AUTO_RECALC", "STATS_PERSISTENT", + "STATS_SAMPLE_PAGES", "STATUS", "STOP", "STORAGE", "STORED", "STRING", + "SUBCLASS_ORIGIN", "SUBJECT", "SUBPARTITION", "SUBPARTITIONS", "SUSPEND", + "SWAPS", "SWITCHES", "TABLE_NAME", "TABLESPACE", "TABLE_TYPE", "TEMPORARY", + "TEMPTABLE", "THAN", "TRADITIONAL", "TRANSACTION", "TRANSACTIONAL", "TRIGGERS", + "TRUNCATE", "UNBOUNDED", "UNDEFINED", "UNDOFILE", "UNDO_BUFFER_SIZE", + "UNINSTALL", "UNKNOWN", "UNTIL", "UPGRADE", "USER", "USE_FRM", "USER_RESOURCES", + "VALIDATION", "VALUE", "VARIABLES", "VIEW", "VIRTUAL", "VISIBLE", "WAIT", + "WARNINGS", "WINDOW", "WITHOUT", "WORK", "WRAPPER", "X509", "XA", "XML", + "YES", "EUR", "USA", "JIS", "ISO", "INTERNAL", "QUARTER", "MONTH", "DAY", + "HOUR", "MINUTE", "WEEK", "SECOND", "MICROSECOND", "ADMIN", "APPLICATION_PASSWORD_ADMIN", + "AUDIT_ABORT_EXEMPT", "AUDIT_ADMIN", "AUTHENTICATION_POLICY_ADMIN", "BACKUP_ADMIN", + "BINLOG_ADMIN", "BINLOG_ENCRYPTION_ADMIN", "CLONE_ADMIN", "CONNECTION_ADMIN", + "ENCRYPTION_KEY_ADMIN", "EXECUTE", "FILE", "FIREWALL_ADMIN", "FIREWALL_EXEMPT", + "FIREWALL_USER", "FLUSH_OPTIMIZER_COSTS", "FLUSH_STATUS", "FLUSH_TABLES", + "FLUSH_USER_RESOURCES", "GROUP_REPLICATION_ADMIN", "INNODB_REDO_LOG_ARCHIVE", + "INNODB_REDO_LOG_ENABLE", "INVOKE", "LAMBDA", "NDB_STORED_USER", "PASSWORDLESS_USER_ADMIN", + "PERSIST_RO_VARIABLES_ADMIN", "PRIVILEGES", "PROCESS", "RELOAD", "REPLICATION_APPLIER", + "REPLICATION_SLAVE_ADMIN", "RESOURCE_GROUP_ADMIN", "RESOURCE_GROUP_USER", + "ROLE_ADMIN", "ROUTINE", "S3", "SERVICE_CONNECTION_ADMIN", "SESSION_VARIABLES_ADMIN", + "SET_USER_ID", "SHOW_ROUTINE", "SHUTDOWN", "SUPER", "SYSTEM_VARIABLES_ADMIN", + "TABLES", "TABLE_ENCRYPTION_ADMIN", "VERSION_TOKEN_ADMIN", "XA_RECOVER_ADMIN", + "ARMSCII8", "ASCII", "BIG5", "CP1250", "CP1251", "CP1256", "CP1257", + "CP850", "CP852", "CP866", "CP932", "DEC8", "EUCJPMS", "EUCKR", "GB18030", + "GB2312", "GBK", "GEOSTD8", "GREEK", "HEBREW", "HP8", "KEYBCS2", "KOI8R", + "KOI8U", "LATIN1", "LATIN2", "LATIN5", "LATIN7", "MACCE", "MACROMAN", + "SJIS", "SWE7", "TIS620", "UCS2", "UJIS", "UTF16", "UTF16LE", "UTF32", + "UTF8", "UTF8MB3", "UTF8MB4", "ARCHIVE", "BLACKHOLE", "CSV", "FEDERATED", + "INNODB", "MEMORY", "MRG_MYISAM", "MYISAM", "NDB", "NDBCLUSTER", "PERFORMANCE_SCHEMA", + "TOKUDB", "REPEATABLE", "COMMITTED", "UNCOMMITTED", "SERIALIZABLE", "GEOMETRYCOLLECTION", + "GEOMCOLLECTION", "GEOMETRY", "LINESTRING", "MULTILINESTRING", "MULTIPOINT", + "MULTIPOLYGON", "POINT", "POLYGON", "ABS", "ACOS", "ADDDATE", "ADDTIME", + "AES_DECRYPT", "AES_ENCRYPT", "AREA", "ASBINARY", "ASIN", "ASTEXT", "ASWKB", + "ASWKT", "ASYMMETRIC_DECRYPT", "ASYMMETRIC_DERIVE", "ASYMMETRIC_ENCRYPT", + "ASYMMETRIC_SIGN", "ASYMMETRIC_VERIFY", "ATAN", "ATAN2", "BENCHMARK", + "BIN", "BIT_COUNT", "BIT_LENGTH", "BUFFER", "CATALOG_NAME", "CEIL", "CEILING", + "CENTROID", "CHARACTER_LENGTH", "CHARSET", "CHAR_LENGTH", "COERCIBILITY", + "COLLATION", "COMPRESS", "CONCAT", "CONCAT_WS", "CONNECTION_ID", "CONV", + "CONVERT_TZ", "COS", "COT", "CRC32", "CREATE_ASYMMETRIC_PRIV_KEY", "CREATE_ASYMMETRIC_PUB_KEY", + "CREATE_DH_PARAMETERS", "CREATE_DIGEST", "CROSSES", "DATEDIFF", "DATE_FORMAT", + "DAYNAME", "DAYOFMONTH", "DAYOFWEEK", "DAYOFYEAR", "DECODE", "DEGREES", + "DES_DECRYPT", "DES_ENCRYPT", "DIMENSION", "DISJOINT", "ELT", "ENCODE", + "ENCRYPT", "ENDPOINT", "ENGINE_ATTRIBUTE", "ENVELOPE", "EQUALS", "EXP", + "EXPORT_SET", "EXTERIORRING", "EXTRACTVALUE", "FIELD", "FIND_IN_SET", + "FLOOR", "FORMAT", "FOUND_ROWS", "FROM_BASE64", "FROM_DAYS", "FROM_UNIXTIME", + "GEOMCOLLFROMTEXT", "GEOMCOLLFROMWKB", "GEOMETRYCOLLECTIONFROMTEXT", + "GEOMETRYCOLLECTIONFROMWKB", "GEOMETRYFROMTEXT", "GEOMETRYFROMWKB", "GEOMETRYN", + "GEOMETRYTYPE", "GEOMFROMTEXT", "GEOMFROMWKB", "GET_FORMAT", "GET_LOCK", + "GLENGTH", "GREATEST", "GTID_SUBSET", "GTID_SUBTRACT", "HEX", "IFNULL", + "INET6_ATON", "INET6_NTOA", "INET_ATON", "INET_NTOA", "INSTR", "INTERIORRINGN", + "INTERSECTS", "ISCLOSED", "ISEMPTY", "ISNULL", "ISSIMPLE", "IS_FREE_LOCK", + "IS_IPV4", "IS_IPV4_COMPAT", "IS_IPV4_MAPPED", "IS_IPV6", "IS_USED_LOCK", + "LAST_INSERT_ID", "LCASE", "LEAST", "LENGTH", "LINEFROMTEXT", "LINEFROMWKB", + "LINESTRINGFROMTEXT", "LINESTRINGFROMWKB", "LN", "LOAD_FILE", "LOCATE", + "LOG", "LOG10", "LOG2", "LOWER", "LPAD", "LTRIM", "MAKEDATE", "MAKETIME", + "MAKE_SET", "MASTER_POS_WAIT", "MBRCONTAINS", "MBRDISJOINT", "MBREQUAL", + "MBRINTERSECTS", "MBROVERLAPS", "MBRTOUCHES", "MBRWITHIN", "MD5", "MLINEFROMTEXT", + "MLINEFROMWKB", "MONTHNAME", "MPOINTFROMTEXT", "MPOINTFROMWKB", "MPOLYFROMTEXT", + "MPOLYFROMWKB", "MULTILINESTRINGFROMTEXT", "MULTILINESTRINGFROMWKB", + "MULTIPOINTFROMTEXT", "MULTIPOINTFROMWKB", "MULTIPOLYGONFROMTEXT", "MULTIPOLYGONFROMWKB", + "NAME_CONST", "NULLIF", "NUMGEOMETRIES", "NUMINTERIORRINGS", "NUMPOINTS", + "OCT", "OCTET_LENGTH", "ORD", "OVERLAPS", "PERIOD_ADD", "PERIOD_DIFF", + "PI", "POINTFROMTEXT", "POINTFROMWKB", "POINTN", "POLYFROMTEXT", "POLYFROMWKB", + "POLYGONFROMTEXT", "POLYGONFROMWKB", "POW", "POWER", "QUOTE", "RADIANS", + "RAND", "RANDOM", "RANDOM_BYTES", "RELEASE_LOCK", "REVERSE", "ROUND", + "ROW_COUNT", "RPAD", "RTRIM", "SEC_TO_TIME", "SECONDARY_ENGINE_ATTRIBUTE", + "SESSION_USER", "SHA", "SHA1", "SHA2", "SCHEMA_NAME", "SIGN", "SIN", + "SLEEP", "SOUNDEX", "SQL_THREAD_WAIT_AFTER_GTIDS", "SQRT", "SRID", "STARTPOINT", + "STRCMP", "STR_TO_DATE", "ST_AREA", "ST_ASBINARY", "ST_ASTEXT", "ST_ASWKB", + "ST_ASWKT", "ST_BUFFER", "ST_CENTROID", "ST_CONTAINS", "ST_CROSSES", + "ST_DIFFERENCE", "ST_DIMENSION", "ST_DISJOINT", "ST_DISTANCE", "ST_ENDPOINT", + "ST_ENVELOPE", "ST_EQUALS", "ST_EXTERIORRING", "ST_GEOMCOLLFROMTEXT", + "ST_GEOMCOLLFROMTXT", "ST_GEOMCOLLFROMWKB", "ST_GEOMETRYCOLLECTIONFROMTEXT", + "ST_GEOMETRYCOLLECTIONFROMWKB", "ST_GEOMETRYFROMTEXT", "ST_GEOMETRYFROMWKB", + "ST_GEOMETRYN", "ST_GEOMETRYTYPE", "ST_GEOMFROMTEXT", "ST_GEOMFROMWKB", + "ST_INTERIORRINGN", "ST_INTERSECTION", "ST_INTERSECTS", "ST_ISCLOSED", + "ST_ISEMPTY", "ST_ISSIMPLE", "ST_LINEFROMTEXT", "ST_LINEFROMWKB", "ST_LINESTRINGFROMTEXT", + "ST_LINESTRINGFROMWKB", "ST_NUMGEOMETRIES", "ST_NUMINTERIORRING", "ST_NUMINTERIORRINGS", + "ST_NUMPOINTS", "ST_OVERLAPS", "ST_POINTFROMTEXT", "ST_POINTFROMWKB", + "ST_POINTN", "ST_POLYFROMTEXT", "ST_POLYFROMWKB", "ST_POLYGONFROMTEXT", + "ST_POLYGONFROMWKB", "ST_SRID", "ST_STARTPOINT", "ST_SYMDIFFERENCE", + "ST_TOUCHES", "ST_UNION", "ST_WITHIN", "ST_X", "ST_Y", "SUBDATE", "SUBSTRING_INDEX", + "SUBTIME", "SYSTEM_USER", "TAN", "TIMEDIFF", "TIMESTAMPADD", "TIMESTAMPDIFF", + "TIME_FORMAT", "TIME_TO_SEC", "TOUCHES", "TO_BASE64", "TO_DAYS", "TO_SECONDS", + "TP_CONNECTION_ADMIN", "UCASE", "UNCOMPRESS", "UNCOMPRESSED_LENGTH", + "UNHEX", "UNIX_TIMESTAMP", "UPDATEXML", "UPPER", "UUID", "UUID_SHORT", + "VALIDATE_PASSWORD_STRENGTH", "VERSION", "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS", + "WEEKDAY", "WEEKOFYEAR", "WEIGHT_STRING", "WITHIN", "YEARWEEK", "Y_FUNCTION", + "X_FUNCTION", "VAR_ASSIGN", "PLUS_ASSIGN", "MINUS_ASSIGN", "MULT_ASSIGN", + "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", + "STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "DIV", "MOD", "EQUAL_SYMBOL", + "GREATER_SYMBOL", "LESS_SYMBOL", "EXCLAMATION_SYMBOL", "BIT_NOT_OP", + "BIT_OR_OP", "BIT_AND_OP", "BIT_XOR_OP", "DOT", "LR_BRACKET", "RR_BRACKET", + "COMMA", "SEMI", "AT_SIGN", "ZERO_DECIMAL", "ONE_DECIMAL", "TWO_DECIMAL", + "SINGLE_QUOTE_SYMB", "DOUBLE_QUOTE_SYMB", "REVERSE_QUOTE_SYMB", "COLON_SYMB", + "CHARSET_REVERSE_QOUTE_STRING", "FILESIZE_LITERAL", "START_NATIONAL_STRING_LITERAL", + "STRING_LITERAL", "DECIMAL_LITERAL", "HEXADECIMAL_LITERAL", "REAL_LITERAL", + "NULL_SPEC_LITERAL", "BIT_STRING", "STRING_CHARSET_NAME", "DOT_ID", "ID", + "REVERSE_QUOTE_ID", "HOST_IP_ADDRESS", "LOCAL_ID", "GLOBAL_ID", "ERROR_RECONGNIGION" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "MySqlParser.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public MySqlParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @SuppressWarnings("CheckReturnValue") + public static class RootContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(MySqlParser.EOF, 0); } + public SqlStatementsContext sqlStatements() { + return getRuleContext(SqlStatementsContext.class,0); + } + public List MINUS() { return getTokens(MySqlParser.MINUS); } + public TerminalNode MINUS(int i) { + return getToken(MySqlParser.MINUS, i); + } + public RootContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_root; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoot(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoot(this); + } + } + + public final RootContext root() throws RecognitionException { + RootContext _localctx = new RootContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_root); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(723); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -9218622129273043712L) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 2306124490637066243L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 19509751503569451L) != 0) || ((((_la - 345)) & ~0x3f) == 0 && ((1L << (_la - 345)) & 36099165796700291L) != 0) || ((((_la - 433)) & ~0x3f) == 0 && ((1L << (_la - 433)) & 16782337L) != 0) || ((((_la - 561)) & ~0x3f) == 0 && ((1L << (_la - 561)) & 17730162917377L) != 0) || ((((_la - 630)) & ~0x3f) == 0 && ((1L << (_la - 630)) & 4503604056555585L) != 0) || _la==EXECUTE || _la==SHUTDOWN || _la==LR_BRACKET || _la==SEMI) { + { + setState(722); + sqlStatements(); + } + } + + setState(727); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==MINUS) { + { + setState(725); + match(MINUS); + setState(726); + match(MINUS); + } + } + + setState(729); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SqlStatementsContext extends ParserRuleContext { + public List sqlStatement() { + return getRuleContexts(SqlStatementContext.class); + } + public SqlStatementContext sqlStatement(int i) { + return getRuleContext(SqlStatementContext.class,i); + } + public List emptyStatement_() { + return getRuleContexts(EmptyStatement_Context.class); + } + public EmptyStatement_Context emptyStatement_(int i) { + return getRuleContext(EmptyStatement_Context.class,i); + } + public List SEMI() { return getTokens(MySqlParser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(MySqlParser.SEMI, i); + } + public List MINUS() { return getTokens(MySqlParser.MINUS); } + public TerminalNode MINUS(int i) { + return getToken(MySqlParser.MINUS, i); + } + public SqlStatementsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sqlStatements; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSqlStatements(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSqlStatements(this); + } + } + + public final SqlStatementsContext sqlStatements() throws RecognitionException { + SqlStatementsContext _localctx = new SqlStatementsContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_sqlStatements); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(742); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,5,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(740); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALTER: + case ANALYZE: + case CALL: + case CHANGE: + case CHECK: + case CREATE: + case DELETE: + case DESC: + case DESCRIBE: + case DROP: + case EXPLAIN: + case GET: + case GRANT: + case INSERT: + case KILL: + case LOAD: + case LOCK: + case OPTIMIZE: + case PURGE: + case RELEASE: + case RENAME: + case REPLACE: + case RESIGNAL: + case REVOKE: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case BEGIN: + case BINLOG: + case CACHE: + case CHECKSUM: + case COMMIT: + case DEALLOCATE: + case DO: + case FLUSH: + case HANDLER: + case HELP: + case INSTALL: + case PREPARE: + case REPAIR: + case RESET: + case ROLLBACK: + case SAVEPOINT: + case START: + case STOP: + case TRUNCATE: + case UNINSTALL: + case XA: + case EXECUTE: + case SHUTDOWN: + case LR_BRACKET: + { + setState(731); + sqlStatement(); + setState(734); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==MINUS) { + { + setState(732); + match(MINUS); + setState(733); + match(MINUS); + } + } + + setState(737); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) { + case 1: + { + setState(736); + match(SEMI); + } + break; + } + } + break; + case SEMI: + { + setState(739); + emptyStatement_(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(744); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,5,_ctx); + } + setState(754); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALTER: + case ANALYZE: + case CALL: + case CHANGE: + case CHECK: + case CREATE: + case DELETE: + case DESC: + case DESCRIBE: + case DROP: + case EXPLAIN: + case GET: + case GRANT: + case INSERT: + case KILL: + case LOAD: + case LOCK: + case OPTIMIZE: + case PURGE: + case RELEASE: + case RENAME: + case REPLACE: + case RESIGNAL: + case REVOKE: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case BEGIN: + case BINLOG: + case CACHE: + case CHECKSUM: + case COMMIT: + case DEALLOCATE: + case DO: + case FLUSH: + case HANDLER: + case HELP: + case INSTALL: + case PREPARE: + case REPAIR: + case RESET: + case ROLLBACK: + case SAVEPOINT: + case START: + case STOP: + case TRUNCATE: + case UNINSTALL: + case XA: + case EXECUTE: + case SHUTDOWN: + case LR_BRACKET: + { + setState(745); + sqlStatement(); + setState(751); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) { + case 1: + { + setState(748); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==MINUS) { + { + setState(746); + match(MINUS); + setState(747); + match(MINUS); + } + } + + setState(750); + match(SEMI); + } + break; + } + } + break; + case SEMI: + { + setState(753); + emptyStatement_(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SqlStatementContext extends ParserRuleContext { + public DdlStatementContext ddlStatement() { + return getRuleContext(DdlStatementContext.class,0); + } + public DmlStatementContext dmlStatement() { + return getRuleContext(DmlStatementContext.class,0); + } + public TransactionStatementContext transactionStatement() { + return getRuleContext(TransactionStatementContext.class,0); + } + public ReplicationStatementContext replicationStatement() { + return getRuleContext(ReplicationStatementContext.class,0); + } + public PreparedStatementContext preparedStatement() { + return getRuleContext(PreparedStatementContext.class,0); + } + public AdministrationStatementContext administrationStatement() { + return getRuleContext(AdministrationStatementContext.class,0); + } + public UtilityStatementContext utilityStatement() { + return getRuleContext(UtilityStatementContext.class,0); + } + public SqlStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sqlStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSqlStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSqlStatement(this); + } + } + + public final SqlStatementContext sqlStatement() throws RecognitionException { + SqlStatementContext _localctx = new SqlStatementContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_sqlStatement); + try { + setState(763); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(756); + ddlStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(757); + dmlStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(758); + transactionStatement(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(759); + replicationStatement(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(760); + preparedStatement(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(761); + administrationStatement(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(762); + utilityStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EmptyStatement_Context extends ParserRuleContext { + public TerminalNode SEMI() { return getToken(MySqlParser.SEMI, 0); } + public EmptyStatement_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_emptyStatement_; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterEmptyStatement_(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitEmptyStatement_(this); + } + } + + public final EmptyStatement_Context emptyStatement_() throws RecognitionException { + EmptyStatement_Context _localctx = new EmptyStatement_Context(_ctx, getState()); + enterRule(_localctx, 6, RULE_emptyStatement_); + try { + enterOuterAlt(_localctx, 1); + { + setState(765); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DdlStatementContext extends ParserRuleContext { + public CreateDatabaseContext createDatabase() { + return getRuleContext(CreateDatabaseContext.class,0); + } + public CreateEventContext createEvent() { + return getRuleContext(CreateEventContext.class,0); + } + public CreateIndexContext createIndex() { + return getRuleContext(CreateIndexContext.class,0); + } + public CreateLogfileGroupContext createLogfileGroup() { + return getRuleContext(CreateLogfileGroupContext.class,0); + } + public CreateProcedureContext createProcedure() { + return getRuleContext(CreateProcedureContext.class,0); + } + public CreateFunctionContext createFunction() { + return getRuleContext(CreateFunctionContext.class,0); + } + public CreateServerContext createServer() { + return getRuleContext(CreateServerContext.class,0); + } + public CreateTableContext createTable() { + return getRuleContext(CreateTableContext.class,0); + } + public CreateTablespaceInnodbContext createTablespaceInnodb() { + return getRuleContext(CreateTablespaceInnodbContext.class,0); + } + public CreateTablespaceNdbContext createTablespaceNdb() { + return getRuleContext(CreateTablespaceNdbContext.class,0); + } + public CreateTriggerContext createTrigger() { + return getRuleContext(CreateTriggerContext.class,0); + } + public CreateViewContext createView() { + return getRuleContext(CreateViewContext.class,0); + } + public CreateRoleContext createRole() { + return getRuleContext(CreateRoleContext.class,0); + } + public AlterDatabaseContext alterDatabase() { + return getRuleContext(AlterDatabaseContext.class,0); + } + public AlterEventContext alterEvent() { + return getRuleContext(AlterEventContext.class,0); + } + public AlterFunctionContext alterFunction() { + return getRuleContext(AlterFunctionContext.class,0); + } + public AlterInstanceContext alterInstance() { + return getRuleContext(AlterInstanceContext.class,0); + } + public AlterLogfileGroupContext alterLogfileGroup() { + return getRuleContext(AlterLogfileGroupContext.class,0); + } + public AlterProcedureContext alterProcedure() { + return getRuleContext(AlterProcedureContext.class,0); + } + public AlterServerContext alterServer() { + return getRuleContext(AlterServerContext.class,0); + } + public AlterTableContext alterTable() { + return getRuleContext(AlterTableContext.class,0); + } + public AlterTablespaceContext alterTablespace() { + return getRuleContext(AlterTablespaceContext.class,0); + } + public AlterViewContext alterView() { + return getRuleContext(AlterViewContext.class,0); + } + public DropDatabaseContext dropDatabase() { + return getRuleContext(DropDatabaseContext.class,0); + } + public DropEventContext dropEvent() { + return getRuleContext(DropEventContext.class,0); + } + public DropIndexContext dropIndex() { + return getRuleContext(DropIndexContext.class,0); + } + public DropLogfileGroupContext dropLogfileGroup() { + return getRuleContext(DropLogfileGroupContext.class,0); + } + public DropProcedureContext dropProcedure() { + return getRuleContext(DropProcedureContext.class,0); + } + public DropFunctionContext dropFunction() { + return getRuleContext(DropFunctionContext.class,0); + } + public DropServerContext dropServer() { + return getRuleContext(DropServerContext.class,0); + } + public DropTableContext dropTable() { + return getRuleContext(DropTableContext.class,0); + } + public DropTablespaceContext dropTablespace() { + return getRuleContext(DropTablespaceContext.class,0); + } + public DropTriggerContext dropTrigger() { + return getRuleContext(DropTriggerContext.class,0); + } + public DropViewContext dropView() { + return getRuleContext(DropViewContext.class,0); + } + public DropRoleContext dropRole() { + return getRuleContext(DropRoleContext.class,0); + } + public SetRoleContext setRole() { + return getRuleContext(SetRoleContext.class,0); + } + public RenameTableContext renameTable() { + return getRuleContext(RenameTableContext.class,0); + } + public TruncateTableContext truncateTable() { + return getRuleContext(TruncateTableContext.class,0); + } + public DdlStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ddlStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDdlStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDdlStatement(this); + } + } + + public final DdlStatementContext ddlStatement() throws RecognitionException { + DdlStatementContext _localctx = new DdlStatementContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_ddlStatement); + try { + setState(805); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(767); + createDatabase(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(768); + createEvent(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(769); + createIndex(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(770); + createLogfileGroup(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(771); + createProcedure(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(772); + createFunction(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(773); + createServer(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(774); + createTable(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(775); + createTablespaceInnodb(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(776); + createTablespaceNdb(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(777); + createTrigger(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(778); + createView(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(779); + createRole(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(780); + alterDatabase(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(781); + alterEvent(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(782); + alterFunction(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(783); + alterInstance(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(784); + alterLogfileGroup(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(785); + alterProcedure(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(786); + alterServer(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(787); + alterTable(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(788); + alterTablespace(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(789); + alterView(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(790); + dropDatabase(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(791); + dropEvent(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(792); + dropIndex(); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(793); + dropLogfileGroup(); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(794); + dropProcedure(); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(795); + dropFunction(); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(796); + dropServer(); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(797); + dropTable(); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(798); + dropTablespace(); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(799); + dropTrigger(); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(800); + dropView(); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(801); + dropRole(); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(802); + setRole(); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(803); + renameTable(); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(804); + truncateTable(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DmlStatementContext extends ParserRuleContext { + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public InsertStatementContext insertStatement() { + return getRuleContext(InsertStatementContext.class,0); + } + public UpdateStatementContext updateStatement() { + return getRuleContext(UpdateStatementContext.class,0); + } + public DeleteStatementContext deleteStatement() { + return getRuleContext(DeleteStatementContext.class,0); + } + public ReplaceStatementContext replaceStatement() { + return getRuleContext(ReplaceStatementContext.class,0); + } + public CallStatementContext callStatement() { + return getRuleContext(CallStatementContext.class,0); + } + public LoadDataStatementContext loadDataStatement() { + return getRuleContext(LoadDataStatementContext.class,0); + } + public LoadXmlStatementContext loadXmlStatement() { + return getRuleContext(LoadXmlStatementContext.class,0); + } + public DoStatementContext doStatement() { + return getRuleContext(DoStatementContext.class,0); + } + public HandlerStatementContext handlerStatement() { + return getRuleContext(HandlerStatementContext.class,0); + } + public ValuesStatementContext valuesStatement() { + return getRuleContext(ValuesStatementContext.class,0); + } + public WithStatementContext withStatement() { + return getRuleContext(WithStatementContext.class,0); + } + public TableStatementContext tableStatement() { + return getRuleContext(TableStatementContext.class,0); + } + public DmlStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dmlStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDmlStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDmlStatement(this); + } + } + + public final DmlStatementContext dmlStatement() throws RecognitionException { + DmlStatementContext _localctx = new DmlStatementContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_dmlStatement); + try { + setState(820); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(807); + selectStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(808); + insertStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(809); + updateStatement(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(810); + deleteStatement(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(811); + replaceStatement(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(812); + callStatement(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(813); + loadDataStatement(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(814); + loadXmlStatement(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(815); + doStatement(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(816); + handlerStatement(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(817); + valuesStatement(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(818); + withStatement(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(819); + tableStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TransactionStatementContext extends ParserRuleContext { + public StartTransactionContext startTransaction() { + return getRuleContext(StartTransactionContext.class,0); + } + public BeginWorkContext beginWork() { + return getRuleContext(BeginWorkContext.class,0); + } + public CommitWorkContext commitWork() { + return getRuleContext(CommitWorkContext.class,0); + } + public RollbackWorkContext rollbackWork() { + return getRuleContext(RollbackWorkContext.class,0); + } + public SavepointStatementContext savepointStatement() { + return getRuleContext(SavepointStatementContext.class,0); + } + public RollbackStatementContext rollbackStatement() { + return getRuleContext(RollbackStatementContext.class,0); + } + public ReleaseStatementContext releaseStatement() { + return getRuleContext(ReleaseStatementContext.class,0); + } + public LockTablesContext lockTables() { + return getRuleContext(LockTablesContext.class,0); + } + public UnlockTablesContext unlockTables() { + return getRuleContext(UnlockTablesContext.class,0); + } + public TransactionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transactionStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTransactionStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTransactionStatement(this); + } + } + + public final TransactionStatementContext transactionStatement() throws RecognitionException { + TransactionStatementContext _localctx = new TransactionStatementContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_transactionStatement); + try { + setState(831); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(822); + startTransaction(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(823); + beginWork(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(824); + commitWork(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(825); + rollbackWork(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(826); + savepointStatement(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(827); + rollbackStatement(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(828); + releaseStatement(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(829); + lockTables(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(830); + unlockTables(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReplicationStatementContext extends ParserRuleContext { + public ChangeMasterContext changeMaster() { + return getRuleContext(ChangeMasterContext.class,0); + } + public ChangeReplicationFilterContext changeReplicationFilter() { + return getRuleContext(ChangeReplicationFilterContext.class,0); + } + public PurgeBinaryLogsContext purgeBinaryLogs() { + return getRuleContext(PurgeBinaryLogsContext.class,0); + } + public ResetMasterContext resetMaster() { + return getRuleContext(ResetMasterContext.class,0); + } + public ResetSlaveContext resetSlave() { + return getRuleContext(ResetSlaveContext.class,0); + } + public StartSlaveContext startSlave() { + return getRuleContext(StartSlaveContext.class,0); + } + public StopSlaveContext stopSlave() { + return getRuleContext(StopSlaveContext.class,0); + } + public StartGroupReplicationContext startGroupReplication() { + return getRuleContext(StartGroupReplicationContext.class,0); + } + public StopGroupReplicationContext stopGroupReplication() { + return getRuleContext(StopGroupReplicationContext.class,0); + } + public XaStartTransactionContext xaStartTransaction() { + return getRuleContext(XaStartTransactionContext.class,0); + } + public XaEndTransactionContext xaEndTransaction() { + return getRuleContext(XaEndTransactionContext.class,0); + } + public XaPrepareStatementContext xaPrepareStatement() { + return getRuleContext(XaPrepareStatementContext.class,0); + } + public XaCommitWorkContext xaCommitWork() { + return getRuleContext(XaCommitWorkContext.class,0); + } + public XaRollbackWorkContext xaRollbackWork() { + return getRuleContext(XaRollbackWorkContext.class,0); + } + public XaRecoverWorkContext xaRecoverWork() { + return getRuleContext(XaRecoverWorkContext.class,0); + } + public ReplicationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_replicationStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReplicationStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReplicationStatement(this); + } + } + + public final ReplicationStatementContext replicationStatement() throws RecognitionException { + ReplicationStatementContext _localctx = new ReplicationStatementContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_replicationStatement); + try { + setState(848); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(833); + changeMaster(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(834); + changeReplicationFilter(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(835); + purgeBinaryLogs(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(836); + resetMaster(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(837); + resetSlave(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(838); + startSlave(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(839); + stopSlave(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(840); + startGroupReplication(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(841); + stopGroupReplication(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(842); + xaStartTransaction(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(843); + xaEndTransaction(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(844); + xaPrepareStatement(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(845); + xaCommitWork(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(846); + xaRollbackWork(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(847); + xaRecoverWork(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PreparedStatementContext extends ParserRuleContext { + public PrepareStatementContext prepareStatement() { + return getRuleContext(PrepareStatementContext.class,0); + } + public ExecuteStatementContext executeStatement() { + return getRuleContext(ExecuteStatementContext.class,0); + } + public DeallocatePrepareContext deallocatePrepare() { + return getRuleContext(DeallocatePrepareContext.class,0); + } + public PreparedStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_preparedStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPreparedStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPreparedStatement(this); + } + } + + public final PreparedStatementContext preparedStatement() throws RecognitionException { + PreparedStatementContext _localctx = new PreparedStatementContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_preparedStatement); + try { + setState(853); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PREPARE: + enterOuterAlt(_localctx, 1); + { + setState(850); + prepareStatement(); + } + break; + case EXECUTE: + enterOuterAlt(_localctx, 2); + { + setState(851); + executeStatement(); + } + break; + case DROP: + case DEALLOCATE: + enterOuterAlt(_localctx, 3); + { + setState(852); + deallocatePrepare(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CompoundStatementContext extends ParserRuleContext { + public BlockStatementContext blockStatement() { + return getRuleContext(BlockStatementContext.class,0); + } + public CaseStatementContext caseStatement() { + return getRuleContext(CaseStatementContext.class,0); + } + public IfStatementContext ifStatement() { + return getRuleContext(IfStatementContext.class,0); + } + public LeaveStatementContext leaveStatement() { + return getRuleContext(LeaveStatementContext.class,0); + } + public LoopStatementContext loopStatement() { + return getRuleContext(LoopStatementContext.class,0); + } + public RepeatStatementContext repeatStatement() { + return getRuleContext(RepeatStatementContext.class,0); + } + public WhileStatementContext whileStatement() { + return getRuleContext(WhileStatementContext.class,0); + } + public IterateStatementContext iterateStatement() { + return getRuleContext(IterateStatementContext.class,0); + } + public ReturnStatementContext returnStatement() { + return getRuleContext(ReturnStatementContext.class,0); + } + public CursorStatementContext cursorStatement() { + return getRuleContext(CursorStatementContext.class,0); + } + public WithStatementContext withStatement() { + return getRuleContext(WithStatementContext.class,0); + } + public DmlStatementContext dmlStatement() { + return getRuleContext(DmlStatementContext.class,0); + } + public CompoundStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_compoundStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCompoundStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCompoundStatement(this); + } + } + + public final CompoundStatementContext compoundStatement() throws RecognitionException { + CompoundStatementContext _localctx = new CompoundStatementContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_compoundStatement); + try { + setState(868); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(855); + blockStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(856); + caseStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(857); + ifStatement(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(858); + leaveStatement(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(859); + loopStatement(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(860); + repeatStatement(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(861); + whileStatement(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(862); + iterateStatement(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(863); + returnStatement(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(864); + cursorStatement(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(865); + withStatement(); + setState(866); + dmlStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AdministrationStatementContext extends ParserRuleContext { + public AlterUserContext alterUser() { + return getRuleContext(AlterUserContext.class,0); + } + public CreateUserContext createUser() { + return getRuleContext(CreateUserContext.class,0); + } + public DropUserContext dropUser() { + return getRuleContext(DropUserContext.class,0); + } + public GrantStatementContext grantStatement() { + return getRuleContext(GrantStatementContext.class,0); + } + public GrantProxyContext grantProxy() { + return getRuleContext(GrantProxyContext.class,0); + } + public RenameUserContext renameUser() { + return getRuleContext(RenameUserContext.class,0); + } + public RevokeStatementContext revokeStatement() { + return getRuleContext(RevokeStatementContext.class,0); + } + public RevokeProxyContext revokeProxy() { + return getRuleContext(RevokeProxyContext.class,0); + } + public AnalyzeTableContext analyzeTable() { + return getRuleContext(AnalyzeTableContext.class,0); + } + public CheckTableContext checkTable() { + return getRuleContext(CheckTableContext.class,0); + } + public ChecksumTableContext checksumTable() { + return getRuleContext(ChecksumTableContext.class,0); + } + public OptimizeTableContext optimizeTable() { + return getRuleContext(OptimizeTableContext.class,0); + } + public RepairTableContext repairTable() { + return getRuleContext(RepairTableContext.class,0); + } + public CreateUdfunctionContext createUdfunction() { + return getRuleContext(CreateUdfunctionContext.class,0); + } + public InstallPluginContext installPlugin() { + return getRuleContext(InstallPluginContext.class,0); + } + public UninstallPluginContext uninstallPlugin() { + return getRuleContext(UninstallPluginContext.class,0); + } + public SetStatementContext setStatement() { + return getRuleContext(SetStatementContext.class,0); + } + public ShowStatementContext showStatement() { + return getRuleContext(ShowStatementContext.class,0); + } + public BinlogStatementContext binlogStatement() { + return getRuleContext(BinlogStatementContext.class,0); + } + public CacheIndexStatementContext cacheIndexStatement() { + return getRuleContext(CacheIndexStatementContext.class,0); + } + public FlushStatementContext flushStatement() { + return getRuleContext(FlushStatementContext.class,0); + } + public KillStatementContext killStatement() { + return getRuleContext(KillStatementContext.class,0); + } + public LoadIndexIntoCacheContext loadIndexIntoCache() { + return getRuleContext(LoadIndexIntoCacheContext.class,0); + } + public ResetStatementContext resetStatement() { + return getRuleContext(ResetStatementContext.class,0); + } + public ShutdownStatementContext shutdownStatement() { + return getRuleContext(ShutdownStatementContext.class,0); + } + public AdministrationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_administrationStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAdministrationStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAdministrationStatement(this); + } + } + + public final AdministrationStatementContext administrationStatement() throws RecognitionException { + AdministrationStatementContext _localctx = new AdministrationStatementContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_administrationStatement); + try { + setState(895); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(870); + alterUser(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(871); + createUser(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(872); + dropUser(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(873); + grantStatement(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(874); + grantProxy(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(875); + renameUser(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(876); + revokeStatement(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(877); + revokeProxy(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(878); + analyzeTable(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(879); + checkTable(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(880); + checksumTable(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(881); + optimizeTable(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(882); + repairTable(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(883); + createUdfunction(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(884); + installPlugin(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(885); + uninstallPlugin(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(886); + setStatement(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(887); + showStatement(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(888); + binlogStatement(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(889); + cacheIndexStatement(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(890); + flushStatement(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(891); + killStatement(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(892); + loadIndexIntoCache(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(893); + resetStatement(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(894); + shutdownStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UtilityStatementContext extends ParserRuleContext { + public SimpleDescribeStatementContext simpleDescribeStatement() { + return getRuleContext(SimpleDescribeStatementContext.class,0); + } + public FullDescribeStatementContext fullDescribeStatement() { + return getRuleContext(FullDescribeStatementContext.class,0); + } + public HelpStatementContext helpStatement() { + return getRuleContext(HelpStatementContext.class,0); + } + public UseStatementContext useStatement() { + return getRuleContext(UseStatementContext.class,0); + } + public SignalStatementContext signalStatement() { + return getRuleContext(SignalStatementContext.class,0); + } + public ResignalStatementContext resignalStatement() { + return getRuleContext(ResignalStatementContext.class,0); + } + public DiagnosticsStatementContext diagnosticsStatement() { + return getRuleContext(DiagnosticsStatementContext.class,0); + } + public UtilityStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_utilityStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUtilityStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUtilityStatement(this); + } + } + + public final UtilityStatementContext utilityStatement() throws RecognitionException { + UtilityStatementContext _localctx = new UtilityStatementContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_utilityStatement); + try { + setState(904); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(897); + simpleDescribeStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(898); + fullDescribeStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(899); + helpStatement(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(900); + useStatement(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(901); + signalStatement(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(902); + resignalStatement(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(903); + diagnosticsStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateDatabaseContext extends ParserRuleContext { + public Token dbFormat; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); } + public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public List createDatabaseOption() { + return getRuleContexts(CreateDatabaseOptionContext.class); + } + public CreateDatabaseOptionContext createDatabaseOption(int i) { + return getRuleContext(CreateDatabaseOptionContext.class,i); + } + public CreateDatabaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createDatabase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateDatabase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateDatabase(this); + } + } + + public final CreateDatabaseContext createDatabase() throws RecognitionException { + CreateDatabaseContext _localctx = new CreateDatabaseContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_createDatabase); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(906); + match(CREATE); + setState(907); + ((CreateDatabaseContext)_localctx).dbFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DATABASE || _la==SCHEMA) ) { + ((CreateDatabaseContext)_localctx).dbFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(909); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) { + case 1: + { + setState(908); + ifNotExists(); + } + break; + } + setState(911); + uid(); + setState(915); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 8796428566528L) != 0) || _la==READ || _la==CHAR || _la==ENCRYPTION || _la==CHARSET) { + { + { + setState(912); + createDatabaseOption(); + } + } + setState(917); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateEventContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode EVENT() { return getToken(MySqlParser.EVENT, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public List ON() { return getTokens(MySqlParser.ON); } + public TerminalNode ON(int i) { + return getToken(MySqlParser.ON, i); + } + public TerminalNode SCHEDULE() { return getToken(MySqlParser.SCHEDULE, 0); } + public ScheduleExpressionContext scheduleExpression() { + return getRuleContext(ScheduleExpressionContext.class,0); + } + public TerminalNode DO() { return getToken(MySqlParser.DO, 0); } + public RoutineBodyContext routineBody() { + return getRuleContext(RoutineBodyContext.class,0); + } + public OwnerStatementContext ownerStatement() { + return getRuleContext(OwnerStatementContext.class,0); + } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public TerminalNode COMPLETION() { return getToken(MySqlParser.COMPLETION, 0); } + public TerminalNode PRESERVE() { return getToken(MySqlParser.PRESERVE, 0); } + public EnableTypeContext enableType() { + return getRuleContext(EnableTypeContext.class,0); + } + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public CreateEventContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createEvent; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateEvent(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateEvent(this); + } + } + + public final CreateEventContext createEvent() throws RecognitionException { + CreateEventContext _localctx = new CreateEventContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_createEvent); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(918); + match(CREATE); + setState(920); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFINER) { + { + setState(919); + ownerStatement(); + } + } + + setState(922); + match(EVENT); + setState(924); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) { + case 1: + { + setState(923); + ifNotExists(); + } + break; + } + setState(926); + fullId(); + setState(927); + match(ON); + setState(928); + match(SCHEDULE); + setState(929); + scheduleExpression(); + setState(936); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ON) { + { + setState(930); + match(ON); + setState(931); + match(COMPLETION); + setState(933); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(932); + match(NOT); + } + } + + setState(935); + match(PRESERVE); + } + } + + setState(939); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DISABLE || _la==ENABLE) { + { + setState(938); + enableType(); + } + } + + setState(943); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMENT) { + { + setState(941); + match(COMMENT); + setState(942); + match(STRING_LITERAL); + } + } + + setState(945); + match(DO); + setState(946); + routineBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateIndexContext extends ParserRuleContext { + public Token intimeAction; + public Token indexCategory; + public Token algType; + public Token lockType; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public IndexTypeContext indexType() { + return getRuleContext(IndexTypeContext.class,0); + } + public List indexOption() { + return getRuleContexts(IndexOptionContext.class); + } + public IndexOptionContext indexOption(int i) { + return getRuleContext(IndexOptionContext.class,i); + } + public List ALGORITHM() { return getTokens(MySqlParser.ALGORITHM); } + public TerminalNode ALGORITHM(int i) { + return getToken(MySqlParser.ALGORITHM, i); + } + public List LOCK() { return getTokens(MySqlParser.LOCK); } + public TerminalNode LOCK(int i) { + return getToken(MySqlParser.LOCK, i); + } + public TerminalNode ONLINE() { return getToken(MySqlParser.ONLINE, 0); } + public TerminalNode OFFLINE() { return getToken(MySqlParser.OFFLINE, 0); } + public TerminalNode UNIQUE() { return getToken(MySqlParser.UNIQUE, 0); } + public TerminalNode FULLTEXT() { return getToken(MySqlParser.FULLTEXT, 0); } + public TerminalNode SPATIAL() { return getToken(MySqlParser.SPATIAL, 0); } + public List DEFAULT() { return getTokens(MySqlParser.DEFAULT); } + public TerminalNode DEFAULT(int i) { + return getToken(MySqlParser.DEFAULT, i); + } + public List INPLACE() { return getTokens(MySqlParser.INPLACE); } + public TerminalNode INPLACE(int i) { + return getToken(MySqlParser.INPLACE, i); + } + public List COPY() { return getTokens(MySqlParser.COPY); } + public TerminalNode COPY(int i) { + return getToken(MySqlParser.COPY, i); + } + public List NONE() { return getTokens(MySqlParser.NONE); } + public TerminalNode NONE(int i) { + return getToken(MySqlParser.NONE, i); + } + public List SHARED() { return getTokens(MySqlParser.SHARED); } + public TerminalNode SHARED(int i) { + return getToken(MySqlParser.SHARED, i); + } + public List EXCLUSIVE() { return getTokens(MySqlParser.EXCLUSIVE); } + public TerminalNode EXCLUSIVE(int i) { + return getToken(MySqlParser.EXCLUSIVE, i); + } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public CreateIndexContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createIndex; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateIndex(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateIndex(this); + } + } + + public final CreateIndexContext createIndex() throws RecognitionException { + CreateIndexContext _localctx = new CreateIndexContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_createIndex); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(948); + match(CREATE); + setState(950); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OFFLINE || _la==ONLINE) { + { + setState(949); + ((CreateIndexContext)_localctx).intimeAction = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==OFFLINE || _la==ONLINE) ) { + ((CreateIndexContext)_localctx).intimeAction = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(953); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FULLTEXT || _la==SPATIAL || _la==UNIQUE) { + { + setState(952); + ((CreateIndexContext)_localctx).indexCategory = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FULLTEXT || _la==SPATIAL || _la==UNIQUE) ) { + ((CreateIndexContext)_localctx).indexCategory = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(955); + match(INDEX); + setState(956); + uid(); + setState(958); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(957); + indexType(); + } + } + + setState(960); + match(ON); + setState(961); + tableName(); + setState(962); + indexColumnNames(); + setState(966); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,29,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(963); + indexOption(); + } + } + } + setState(968); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,29,_ctx); + } + setState(981); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,33,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(979); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALGORITHM: + { + setState(969); + match(ALGORITHM); + setState(971); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(970); + match(EQUAL_SYMBOL); + } + } + + setState(973); + ((CreateIndexContext)_localctx).algType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==COPY || _la==INPLACE) ) { + ((CreateIndexContext)_localctx).algType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case LOCK: + { + setState(974); + match(LOCK); + setState(976); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(975); + match(EQUAL_SYMBOL); + } + } + + setState(978); + ((CreateIndexContext)_localctx).lockType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==EXCLUSIVE || _la==NONE || _la==SHARED) ) { + ((CreateIndexContext)_localctx).lockType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(983); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,33,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateLogfileGroupContext extends ParserRuleContext { + public Token undoFile; + public FileSizeLiteralContext initSize; + public FileSizeLiteralContext undoSize; + public FileSizeLiteralContext redoSize; + public Token comment; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode LOGFILE() { return getToken(MySqlParser.LOGFILE, 0); } + public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode UNDOFILE() { return getToken(MySqlParser.UNDOFILE, 0); } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public List STRING_LITERAL() { return getTokens(MySqlParser.STRING_LITERAL); } + public TerminalNode STRING_LITERAL(int i) { + return getToken(MySqlParser.STRING_LITERAL, i); + } + public TerminalNode INITIAL_SIZE() { return getToken(MySqlParser.INITIAL_SIZE, 0); } + public TerminalNode UNDO_BUFFER_SIZE() { return getToken(MySqlParser.UNDO_BUFFER_SIZE, 0); } + public TerminalNode REDO_BUFFER_SIZE() { return getToken(MySqlParser.REDO_BUFFER_SIZE, 0); } + public TerminalNode NODEGROUP() { return getToken(MySqlParser.NODEGROUP, 0); } + public TerminalNode WAIT() { return getToken(MySqlParser.WAIT, 0); } + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public List fileSizeLiteral() { + return getRuleContexts(FileSizeLiteralContext.class); + } + public FileSizeLiteralContext fileSizeLiteral(int i) { + return getRuleContext(FileSizeLiteralContext.class,i); + } + public CreateLogfileGroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createLogfileGroup; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateLogfileGroup(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateLogfileGroup(this); + } + } + + public final CreateLogfileGroupContext createLogfileGroup() throws RecognitionException { + CreateLogfileGroupContext _localctx = new CreateLogfileGroupContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_createLogfileGroup); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(984); + match(CREATE); + setState(985); + match(LOGFILE); + setState(986); + match(GROUP); + setState(987); + uid(); + setState(988); + match(ADD); + setState(989); + match(UNDOFILE); + setState(990); + ((CreateLogfileGroupContext)_localctx).undoFile = match(STRING_LITERAL); + setState(996); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INITIAL_SIZE) { + { + setState(991); + match(INITIAL_SIZE); + setState(993); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(992); + match(EQUAL_SYMBOL); + } + } + + setState(995); + ((CreateLogfileGroupContext)_localctx).initSize = fileSizeLiteral(); + } + } + + setState(1003); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==UNDO_BUFFER_SIZE) { + { + setState(998); + match(UNDO_BUFFER_SIZE); + setState(1000); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(999); + match(EQUAL_SYMBOL); + } + } + + setState(1002); + ((CreateLogfileGroupContext)_localctx).undoSize = fileSizeLiteral(); + } + } + + setState(1010); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==REDO_BUFFER_SIZE) { + { + setState(1005); + match(REDO_BUFFER_SIZE); + setState(1007); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1006); + match(EQUAL_SYMBOL); + } + } + + setState(1009); + ((CreateLogfileGroupContext)_localctx).redoSize = fileSizeLiteral(); + } + } + + setState(1017); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NODEGROUP) { + { + setState(1012); + match(NODEGROUP); + setState(1014); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1013); + match(EQUAL_SYMBOL); + } + } + + setState(1016); + uid(); + } + } + + setState(1020); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WAIT) { + { + setState(1019); + match(WAIT); + } + } + + setState(1027); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMENT) { + { + setState(1022); + match(COMMENT); + setState(1024); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1023); + match(EQUAL_SYMBOL); + } + } + + setState(1026); + ((CreateLogfileGroupContext)_localctx).comment = match(STRING_LITERAL); + } + } + + setState(1029); + match(ENGINE); + setState(1031); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1030); + match(EQUAL_SYMBOL); + } + } + + setState(1033); + engineName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateProcedureContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public RoutineBodyContext routineBody() { + return getRuleContext(RoutineBodyContext.class,0); + } + public OwnerStatementContext ownerStatement() { + return getRuleContext(OwnerStatementContext.class,0); + } + public List procedureParameter() { + return getRuleContexts(ProcedureParameterContext.class); + } + public ProcedureParameterContext procedureParameter(int i) { + return getRuleContext(ProcedureParameterContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public List routineOption() { + return getRuleContexts(RoutineOptionContext.class); + } + public RoutineOptionContext routineOption(int i) { + return getRuleContext(RoutineOptionContext.class,i); + } + public CreateProcedureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createProcedure; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateProcedure(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateProcedure(this); + } + } + + public final CreateProcedureContext createProcedure() throws RecognitionException { + CreateProcedureContext _localctx = new CreateProcedureContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_createProcedure); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1035); + match(CREATE); + setState(1037); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFINER) { + { + setState(1036); + ownerStatement(); + } + } + + setState(1039); + match(PROCEDURE); + setState(1040); + fullId(); + setState(1041); + match(LR_BRACKET); + setState(1043); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 151169654698547409L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1042); + procedureParameter(); + } + } + + setState(1049); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1045); + match(COMMA); + setState(1046); + procedureParameter(); + } + } + setState(1051); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1052); + match(RR_BRACKET); + setState(1056); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,49,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1053); + routineOption(); + } + } + } + setState(1058); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,49,_ctx); + } + setState(1059); + routineBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateFunctionContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode RETURNS() { return getToken(MySqlParser.RETURNS, 0); } + public DataTypeContext dataType() { + return getRuleContext(DataTypeContext.class,0); + } + public RoutineBodyContext routineBody() { + return getRuleContext(RoutineBodyContext.class,0); + } + public ReturnStatementContext returnStatement() { + return getRuleContext(ReturnStatementContext.class,0); + } + public OwnerStatementContext ownerStatement() { + return getRuleContext(OwnerStatementContext.class,0); + } + public TerminalNode AGGREGATE() { return getToken(MySqlParser.AGGREGATE, 0); } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public List functionParameter() { + return getRuleContexts(FunctionParameterContext.class); + } + public FunctionParameterContext functionParameter(int i) { + return getRuleContext(FunctionParameterContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public List routineOption() { + return getRuleContexts(RoutineOptionContext.class); + } + public RoutineOptionContext routineOption(int i) { + return getRuleContext(RoutineOptionContext.class,i); + } + public CreateFunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createFunction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateFunction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateFunction(this); + } + } + + public final CreateFunctionContext createFunction() throws RecognitionException { + CreateFunctionContext _localctx = new CreateFunctionContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_createFunction); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1061); + match(CREATE); + setState(1063); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFINER) { + { + setState(1062); + ownerStatement(); + } + } + + setState(1066); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AGGREGATE) { + { + setState(1065); + match(AGGREGATE); + } + } + + setState(1068); + match(FUNCTION); + setState(1070); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { + case 1: + { + setState(1069); + ifNotExists(); + } + break; + } + setState(1072); + fullId(); + setState(1073); + match(LR_BRACKET); + setState(1075); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1074); + functionParameter(); + } + } + + setState(1081); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1077); + match(COMMA); + setState(1078); + functionParameter(); + } + } + setState(1083); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1084); + match(RR_BRACKET); + setState(1085); + match(RETURNS); + setState(1086); + dataType(); + setState(1090); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,55,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1087); + routineOption(); + } + } + } + setState(1092); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,55,_ctx); + } + setState(1095); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALTER: + case ANALYZE: + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CALL: + case CHANGE: + case CHECK: + case CONDITION: + case CREATE: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DELETE: + case DESC: + case DESCRIBE: + case DIAGNOSTICS: + case DROP: + case EMPTY: + case ENFORCED: + case EXCEPT: + case EXPLAIN: + case GET: + case GRANT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case KILL: + case LATERAL: + case LEFT: + case LOAD: + case LOCK: + case NUMBER: + case OPTIMIZE: + case OPTIONAL: + case ORDER: + case PRIMARY: + case PURGE: + case RELEASE: + case RENAME: + case REPEAT: + case REPLACE: + case RESIGNAL: + case REVOKE: + case RIGHT: + case SCHEMA: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case SKIP_QUERY_REWRITE: + case STACKED: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case LR_BRACKET: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(1093); + routineBody(); + } + break; + case RETURN: + { + setState(1094); + returnStatement(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateRoleContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode ROLE() { return getToken(MySqlParser.ROLE, 0); } + public List roleName() { + return getRuleContexts(RoleNameContext.class); + } + public RoleNameContext roleName(int i) { + return getRuleContext(RoleNameContext.class,i); + } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public CreateRoleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createRole; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateRole(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateRole(this); + } + } + + public final CreateRoleContext createRole() throws RecognitionException { + CreateRoleContext _localctx = new CreateRoleContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_createRole); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1097); + match(CREATE); + setState(1098); + match(ROLE); + setState(1100); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { + case 1: + { + setState(1099); + ifNotExists(); + } + break; + } + setState(1102); + roleName(); + setState(1107); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1103); + match(COMMA); + setState(1104); + roleName(); + } + } + setState(1109); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateServerContext extends ParserRuleContext { + public Token wrapperName; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode SERVER() { return getToken(MySqlParser.SERVER, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode FOREIGN() { return getToken(MySqlParser.FOREIGN, 0); } + public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); } + public TerminalNode WRAPPER() { return getToken(MySqlParser.WRAPPER, 0); } + public TerminalNode OPTIONS() { return getToken(MySqlParser.OPTIONS, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List serverOption() { + return getRuleContexts(ServerOptionContext.class); + } + public ServerOptionContext serverOption(int i) { + return getRuleContext(ServerOptionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode MYSQL() { return getToken(MySqlParser.MYSQL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public CreateServerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createServer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateServer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateServer(this); + } + } + + public final CreateServerContext createServer() throws RecognitionException { + CreateServerContext _localctx = new CreateServerContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_createServer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1110); + match(CREATE); + setState(1111); + match(SERVER); + setState(1112); + uid(); + setState(1113); + match(FOREIGN); + setState(1114); + match(DATA); + setState(1115); + match(WRAPPER); + setState(1116); + ((CreateServerContext)_localctx).wrapperName = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==MYSQL || _la==STRING_LITERAL) ) { + ((CreateServerContext)_localctx).wrapperName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1117); + match(OPTIONS); + setState(1118); + match(LR_BRACKET); + setState(1119); + serverOption(); + setState(1124); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1120); + match(COMMA); + setState(1121); + serverOption(); + } + } + setState(1126); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1127); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateTableContext extends ParserRuleContext { + public CreateTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createTable; } + + public CreateTableContext() { } + public void copyFrom(CreateTableContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CopyCreateTableContext extends CreateTableContext { + public TableNameContext parenthesisTable; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public List tableName() { + return getRuleContexts(TableNameContext.class); + } + public TableNameContext tableName(int i) { + return getRuleContext(TableNameContext.class,i); + } + public TerminalNode LIKE() { return getToken(MySqlParser.LIKE, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode TEMPORARY() { return getToken(MySqlParser.TEMPORARY, 0); } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public CopyCreateTableContext(CreateTableContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCopyCreateTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCopyCreateTable(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ColumnCreateTableContext extends CreateTableContext { + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public CreateDefinitionsContext createDefinitions() { + return getRuleContext(CreateDefinitionsContext.class,0); + } + public TerminalNode TEMPORARY() { return getToken(MySqlParser.TEMPORARY, 0); } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public List tableOption() { + return getRuleContexts(TableOptionContext.class); + } + public TableOptionContext tableOption(int i) { + return getRuleContext(TableOptionContext.class,i); + } + public PartitionDefinitionsContext partitionDefinitions() { + return getRuleContext(PartitionDefinitionsContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public ColumnCreateTableContext(CreateTableContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterColumnCreateTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitColumnCreateTable(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class QueryCreateTableContext extends CreateTableContext { + public Token keyViolate; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public TerminalNode TEMPORARY() { return getToken(MySqlParser.TEMPORARY, 0); } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public CreateDefinitionsContext createDefinitions() { + return getRuleContext(CreateDefinitionsContext.class,0); + } + public List tableOption() { + return getRuleContexts(TableOptionContext.class); + } + public TableOptionContext tableOption(int i) { + return getRuleContext(TableOptionContext.class,i); + } + public PartitionDefinitionsContext partitionDefinitions() { + return getRuleContext(PartitionDefinitionsContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); } + public TerminalNode REPLACE() { return getToken(MySqlParser.REPLACE, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public QueryCreateTableContext(CreateTableContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterQueryCreateTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitQueryCreateTable(this); + } + } + + public final CreateTableContext createTable() throws RecognitionException { + CreateTableContext _localctx = new CreateTableContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_createTable); + int _la; + try { + int _alt; + setState(1207); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) { + case 1: + _localctx = new CopyCreateTableContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1129); + match(CREATE); + setState(1131); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TEMPORARY) { + { + setState(1130); + match(TEMPORARY); + } + } + + setState(1133); + match(TABLE); + setState(1135); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) { + case 1: + { + setState(1134); + ifNotExists(); + } + break; + } + setState(1137); + tableName(); + setState(1145); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LIKE: + { + setState(1138); + match(LIKE); + setState(1139); + tableName(); + } + break; + case LR_BRACKET: + { + setState(1140); + match(LR_BRACKET); + setState(1141); + match(LIKE); + setState(1142); + ((CopyCreateTableContext)_localctx).parenthesisTable = tableName(); + setState(1143); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + _localctx = new QueryCreateTableContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1147); + match(CREATE); + setState(1149); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TEMPORARY) { + { + setState(1148); + match(TEMPORARY); + } + } + + setState(1151); + match(TABLE); + setState(1153); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { + case 1: + { + setState(1152); + ifNotExists(); + } + break; + } + setState(1155); + tableName(); + setState(1157); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { + case 1: + { + setState(1156); + createDefinitions(); + } + break; + } + setState(1169); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & 72057594038059013L) != 0) || _la==UNION || _la==CHAR || ((((_la - 342)) & ~0x3f) == 0 && ((1L << (_la - 342)) & 4644375904747527L) != 0) || ((((_la - 406)) & ~0x3f) == 0 && ((1L << (_la - 406)) & 4612811918334230547L) != 0) || ((((_la - 501)) & ~0x3f) == 0 && ((1L << (_la - 501)) & 2366149022974977L) != 0) || ((((_la - 603)) & ~0x3f) == 0 && ((1L << (_la - 603)) & 4609173815820289L) != 0) || _la==CHARSET || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE || _la==STRING_LITERAL) { + { + setState(1159); + tableOption(); + setState(1166); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & 72057594038059013L) != 0) || _la==UNION || _la==CHAR || ((((_la - 342)) & ~0x3f) == 0 && ((1L << (_la - 342)) & 4644375904747527L) != 0) || ((((_la - 406)) & ~0x3f) == 0 && ((1L << (_la - 406)) & 4612811918334230547L) != 0) || ((((_la - 501)) & ~0x3f) == 0 && ((1L << (_la - 501)) & 2366149022974977L) != 0) || ((((_la - 603)) & ~0x3f) == 0 && ((1L << (_la - 603)) & 4609173815820289L) != 0) || _la==CHARSET || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE || _la==COMMA || _la==STRING_LITERAL) { + { + { + setState(1161); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1160); + match(COMMA); + } + } + + setState(1163); + tableOption(); + } + } + setState(1168); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(1172); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(1171); + partitionDefinitions(); + } + } + + setState(1175); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE || _la==REPLACE) { + { + setState(1174); + ((QueryCreateTableContext)_localctx).keyViolate = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==IGNORE || _la==REPLACE) ) { + ((QueryCreateTableContext)_localctx).keyViolate = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1178); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(1177); + match(AS); + } + } + + setState(1180); + selectStatement(); + } + break; + case 3: + _localctx = new ColumnCreateTableContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1182); + match(CREATE); + setState(1184); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TEMPORARY) { + { + setState(1183); + match(TEMPORARY); + } + } + + setState(1186); + match(TABLE); + setState(1188); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { + case 1: + { + setState(1187); + ifNotExists(); + } + break; + } + setState(1190); + tableName(); + setState(1191); + createDefinitions(); + setState(1202); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) { + case 1: + { + setState(1192); + tableOption(); + setState(1199); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,75,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1194); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1193); + match(COMMA); + } + } + + setState(1196); + tableOption(); + } + } + } + setState(1201); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,75,_ctx); + } + } + break; + } + setState(1205); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(1204); + partitionDefinitions(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateTablespaceInnodbContext extends ParserRuleContext { + public Token datafile; + public FileSizeLiteralContext fileBlockSize; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode DATAFILE() { return getToken(MySqlParser.DATAFILE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode FILE_BLOCK_SIZE() { return getToken(MySqlParser.FILE_BLOCK_SIZE, 0); } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public FileSizeLiteralContext fileSizeLiteral() { + return getRuleContext(FileSizeLiteralContext.class,0); + } + public CreateTablespaceInnodbContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createTablespaceInnodb; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateTablespaceInnodb(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateTablespaceInnodb(this); + } + } + + public final CreateTablespaceInnodbContext createTablespaceInnodb() throws RecognitionException { + CreateTablespaceInnodbContext _localctx = new CreateTablespaceInnodbContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_createTablespaceInnodb); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1209); + match(CREATE); + setState(1210); + match(TABLESPACE); + setState(1211); + uid(); + setState(1212); + match(ADD); + setState(1213); + match(DATAFILE); + setState(1214); + ((CreateTablespaceInnodbContext)_localctx).datafile = match(STRING_LITERAL); + setState(1218); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FILE_BLOCK_SIZE) { + { + setState(1215); + match(FILE_BLOCK_SIZE); + setState(1216); + match(EQUAL_SYMBOL); + setState(1217); + ((CreateTablespaceInnodbContext)_localctx).fileBlockSize = fileSizeLiteral(); + } + } + + setState(1225); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENGINE) { + { + setState(1220); + match(ENGINE); + setState(1222); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1221); + match(EQUAL_SYMBOL); + } + } + + setState(1224); + engineName(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateTablespaceNdbContext extends ParserRuleContext { + public Token datafile; + public FileSizeLiteralContext extentSize; + public FileSizeLiteralContext initialSize; + public FileSizeLiteralContext autoextendSize; + public FileSizeLiteralContext maxSize; + public Token comment; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode DATAFILE() { return getToken(MySqlParser.DATAFILE, 0); } + public TerminalNode USE() { return getToken(MySqlParser.USE, 0); } + public TerminalNode LOGFILE() { return getToken(MySqlParser.LOGFILE, 0); } + public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public List STRING_LITERAL() { return getTokens(MySqlParser.STRING_LITERAL); } + public TerminalNode STRING_LITERAL(int i) { + return getToken(MySqlParser.STRING_LITERAL, i); + } + public TerminalNode EXTENT_SIZE() { return getToken(MySqlParser.EXTENT_SIZE, 0); } + public TerminalNode INITIAL_SIZE() { return getToken(MySqlParser.INITIAL_SIZE, 0); } + public TerminalNode AUTOEXTEND_SIZE() { return getToken(MySqlParser.AUTOEXTEND_SIZE, 0); } + public TerminalNode MAX_SIZE() { return getToken(MySqlParser.MAX_SIZE, 0); } + public TerminalNode NODEGROUP() { return getToken(MySqlParser.NODEGROUP, 0); } + public TerminalNode WAIT() { return getToken(MySqlParser.WAIT, 0); } + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public List fileSizeLiteral() { + return getRuleContexts(FileSizeLiteralContext.class); + } + public FileSizeLiteralContext fileSizeLiteral(int i) { + return getRuleContext(FileSizeLiteralContext.class,i); + } + public CreateTablespaceNdbContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createTablespaceNdb; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateTablespaceNdb(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateTablespaceNdb(this); + } + } + + public final CreateTablespaceNdbContext createTablespaceNdb() throws RecognitionException { + CreateTablespaceNdbContext _localctx = new CreateTablespaceNdbContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_createTablespaceNdb); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1227); + match(CREATE); + setState(1228); + match(TABLESPACE); + setState(1229); + uid(); + setState(1230); + match(ADD); + setState(1231); + match(DATAFILE); + setState(1232); + ((CreateTablespaceNdbContext)_localctx).datafile = match(STRING_LITERAL); + setState(1233); + match(USE); + setState(1234); + match(LOGFILE); + setState(1235); + match(GROUP); + setState(1236); + uid(); + setState(1242); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXTENT_SIZE) { + { + setState(1237); + match(EXTENT_SIZE); + setState(1239); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1238); + match(EQUAL_SYMBOL); + } + } + + setState(1241); + ((CreateTablespaceNdbContext)_localctx).extentSize = fileSizeLiteral(); + } + } + + setState(1249); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INITIAL_SIZE) { + { + setState(1244); + match(INITIAL_SIZE); + setState(1246); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1245); + match(EQUAL_SYMBOL); + } + } + + setState(1248); + ((CreateTablespaceNdbContext)_localctx).initialSize = fileSizeLiteral(); + } + } + + setState(1256); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AUTOEXTEND_SIZE) { + { + setState(1251); + match(AUTOEXTEND_SIZE); + setState(1253); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1252); + match(EQUAL_SYMBOL); + } + } + + setState(1255); + ((CreateTablespaceNdbContext)_localctx).autoextendSize = fileSizeLiteral(); + } + } + + setState(1263); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==MAX_SIZE) { + { + setState(1258); + match(MAX_SIZE); + setState(1260); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1259); + match(EQUAL_SYMBOL); + } + } + + setState(1262); + ((CreateTablespaceNdbContext)_localctx).maxSize = fileSizeLiteral(); + } + } + + setState(1270); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NODEGROUP) { + { + setState(1265); + match(NODEGROUP); + setState(1267); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1266); + match(EQUAL_SYMBOL); + } + } + + setState(1269); + uid(); + } + } + + setState(1273); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WAIT) { + { + setState(1272); + match(WAIT); + } + } + + setState(1280); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMENT) { + { + setState(1275); + match(COMMENT); + setState(1277); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1276); + match(EQUAL_SYMBOL); + } + } + + setState(1279); + ((CreateTablespaceNdbContext)_localctx).comment = match(STRING_LITERAL); + } + } + + setState(1282); + match(ENGINE); + setState(1284); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1283); + match(EQUAL_SYMBOL); + } + } + + setState(1286); + engineName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateTriggerContext extends ParserRuleContext { + public FullIdContext thisTrigger; + public Token triggerTime; + public Token triggerEvent; + public Token triggerPlace; + public FullIdContext otherTrigger; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode TRIGGER() { return getToken(MySqlParser.TRIGGER, 0); } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode EACH() { return getToken(MySqlParser.EACH, 0); } + public TerminalNode ROW() { return getToken(MySqlParser.ROW, 0); } + public RoutineBodyContext routineBody() { + return getRuleContext(RoutineBodyContext.class,0); + } + public List fullId() { + return getRuleContexts(FullIdContext.class); + } + public FullIdContext fullId(int i) { + return getRuleContext(FullIdContext.class,i); + } + public TerminalNode BEFORE() { return getToken(MySqlParser.BEFORE, 0); } + public TerminalNode AFTER() { return getToken(MySqlParser.AFTER, 0); } + public TerminalNode INSERT() { return getToken(MySqlParser.INSERT, 0); } + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public TerminalNode DELETE() { return getToken(MySqlParser.DELETE, 0); } + public OwnerStatementContext ownerStatement() { + return getRuleContext(OwnerStatementContext.class,0); + } + public TerminalNode FOLLOWS() { return getToken(MySqlParser.FOLLOWS, 0); } + public TerminalNode PRECEDES() { return getToken(MySqlParser.PRECEDES, 0); } + public CreateTriggerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createTrigger; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateTrigger(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateTrigger(this); + } + } + + public final CreateTriggerContext createTrigger() throws RecognitionException { + CreateTriggerContext _localctx = new CreateTriggerContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_createTrigger); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1288); + match(CREATE); + setState(1290); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFINER) { + { + setState(1289); + ownerStatement(); + } + } + + setState(1292); + match(TRIGGER); + setState(1293); + ((CreateTriggerContext)_localctx).thisTrigger = fullId(); + setState(1294); + ((CreateTriggerContext)_localctx).triggerTime = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==BEFORE || _la==AFTER) ) { + ((CreateTriggerContext)_localctx).triggerTime = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1295); + ((CreateTriggerContext)_localctx).triggerEvent = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DELETE || _la==INSERT || _la==UPDATE) ) { + ((CreateTriggerContext)_localctx).triggerEvent = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1296); + match(ON); + setState(1297); + tableName(); + setState(1298); + match(FOR); + setState(1299); + match(EACH); + setState(1300); + match(ROW); + setState(1303); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) { + case 1: + { + setState(1301); + ((CreateTriggerContext)_localctx).triggerPlace = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FOLLOWS || _la==PRECEDES) ) { + ((CreateTriggerContext)_localctx).triggerPlace = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1302); + ((CreateTriggerContext)_localctx).otherTrigger = fullId(); + } + break; + } + setState(1305); + routineBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WithClauseContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public CommonTableExpressionsContext commonTableExpressions() { + return getRuleContext(CommonTableExpressionsContext.class,0); + } + public TerminalNode RECURSIVE() { return getToken(MySqlParser.RECURSIVE, 0); } + public WithClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_withClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWithClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWithClause(this); + } + } + + public final WithClauseContext withClause() throws RecognitionException { + WithClauseContext _localctx = new WithClauseContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_withClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1307); + match(WITH); + setState(1309); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) { + case 1: + { + setState(1308); + match(RECURSIVE); + } + break; + } + setState(1311); + commonTableExpressions(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CommonTableExpressionsContext extends ParserRuleContext { + public CteNameContext cteName() { + return getRuleContext(CteNameContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public DmlStatementContext dmlStatement() { + return getRuleContext(DmlStatementContext.class,0); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public List cteColumnName() { + return getRuleContexts(CteColumnNameContext.class); + } + public CteColumnNameContext cteColumnName(int i) { + return getRuleContext(CteColumnNameContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public CommonTableExpressionsContext commonTableExpressions() { + return getRuleContext(CommonTableExpressionsContext.class,0); + } + public CommonTableExpressionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_commonTableExpressions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCommonTableExpressions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCommonTableExpressions(this); + } + } + + public final CommonTableExpressionsContext commonTableExpressions() throws RecognitionException { + CommonTableExpressionsContext _localctx = new CommonTableExpressionsContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_commonTableExpressions); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1313); + cteName(); + setState(1325); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(1314); + match(LR_BRACKET); + setState(1315); + cteColumnName(); + setState(1320); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1316); + match(COMMA); + setState(1317); + cteColumnName(); + } + } + setState(1322); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1323); + match(RR_BRACKET); + } + } + + setState(1327); + match(AS); + setState(1328); + match(LR_BRACKET); + setState(1329); + dmlStatement(); + setState(1330); + match(RR_BRACKET); + setState(1333); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) { + case 1: + { + setState(1331); + match(COMMA); + setState(1332); + commonTableExpressions(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CteNameContext extends ParserRuleContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public CteNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cteName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCteName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCteName(this); + } + } + + public final CteNameContext cteName() throws RecognitionException { + CteNameContext _localctx = new CteNameContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_cteName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1335); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CteColumnNameContext extends ParserRuleContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public CteColumnNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cteColumnName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCteColumnName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCteColumnName(this); + } + } + + public final CteColumnNameContext cteColumnName() throws RecognitionException { + CteColumnNameContext _localctx = new CteColumnNameContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_cteColumnName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1337); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateViewContext extends ParserRuleContext { + public Token algType; + public Token secContext; + public Token checkOption; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode VIEW() { return getToken(MySqlParser.VIEW, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public OrReplaceContext orReplace() { + return getRuleContext(OrReplaceContext.class,0); + } + public TerminalNode ALGORITHM() { return getToken(MySqlParser.ALGORITHM, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public OwnerStatementContext ownerStatement() { + return getRuleContext(OwnerStatementContext.class,0); + } + public TerminalNode SQL() { return getToken(MySqlParser.SQL, 0); } + public TerminalNode SECURITY() { return getToken(MySqlParser.SECURITY, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode UNDEFINED() { return getToken(MySqlParser.UNDEFINED, 0); } + public TerminalNode MERGE() { return getToken(MySqlParser.MERGE, 0); } + public TerminalNode TEMPTABLE() { return getToken(MySqlParser.TEMPTABLE, 0); } + public TerminalNode DEFINER() { return getToken(MySqlParser.DEFINER, 0); } + public TerminalNode INVOKER() { return getToken(MySqlParser.INVOKER, 0); } + public WithClauseContext withClause() { + return getRuleContext(WithClauseContext.class,0); + } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); } + public TerminalNode OPTION() { return getToken(MySqlParser.OPTION, 0); } + public TerminalNode CASCADED() { return getToken(MySqlParser.CASCADED, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public CreateViewContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createView; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateView(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateView(this); + } + } + + public final CreateViewContext createView() throws RecognitionException { + CreateViewContext _localctx = new CreateViewContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_createView); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1339); + match(CREATE); + setState(1341); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OR) { + { + setState(1340); + orReplace(); + } + } + + setState(1346); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALGORITHM) { + { + setState(1343); + match(ALGORITHM); + setState(1344); + match(EQUAL_SYMBOL); + setState(1345); + ((CreateViewContext)_localctx).algType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==MERGE || _la==TEMPTABLE || _la==UNDEFINED) ) { + ((CreateViewContext)_localctx).algType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1349); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFINER) { + { + setState(1348); + ownerStatement(); + } + } + + setState(1354); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SQL) { + { + setState(1351); + match(SQL); + setState(1352); + match(SECURITY); + setState(1353); + ((CreateViewContext)_localctx).secContext = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFINER || _la==INVOKER) ) { + ((CreateViewContext)_localctx).secContext = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1356); + match(VIEW); + setState(1357); + fullId(); + setState(1362); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(1358); + match(LR_BRACKET); + setState(1359); + uidList(); + setState(1360); + match(RR_BRACKET); + } + } + + setState(1364); + match(AS); + setState(1384); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) { + case 1: + { + setState(1365); + match(LR_BRACKET); + setState(1367); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(1366); + withClause(); + } + } + + setState(1369); + selectStatement(); + setState(1370); + match(RR_BRACKET); + } + break; + case 2: + { + setState(1373); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(1372); + withClause(); + } + } + + setState(1375); + selectStatement(); + setState(1382); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) { + case 1: + { + setState(1376); + match(WITH); + setState(1378); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADED || _la==LOCAL) { + { + setState(1377); + ((CreateViewContext)_localctx).checkOption = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CASCADED || _la==LOCAL) ) { + ((CreateViewContext)_localctx).checkOption = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1380); + match(CHECK); + setState(1381); + match(OPTION); + } + break; + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateDatabaseOptionContext extends ParserRuleContext { + public CharSetContext charSet() { + return getRuleContext(CharSetContext.class,0); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public List DEFAULT() { return getTokens(MySqlParser.DEFAULT); } + public TerminalNode DEFAULT(int i) { + return getToken(MySqlParser.DEFAULT, i); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public TerminalNode ENCRYPTION() { return getToken(MySqlParser.ENCRYPTION, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode READ() { return getToken(MySqlParser.READ, 0); } + public TerminalNode ONLY() { return getToken(MySqlParser.ONLY, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public CreateDatabaseOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createDatabaseOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateDatabaseOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateDatabaseOption(this); + } + } + + public final CreateDatabaseOptionContext createDatabaseOption() throws RecognitionException { + CreateDatabaseOptionContext _localctx = new CreateDatabaseOptionContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_createDatabaseOption); + int _la; + try { + setState(1419); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1387); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(1386); + match(DEFAULT); + } + } + + setState(1389); + charSet(); + setState(1391); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1390); + match(EQUAL_SYMBOL); + } + } + + setState(1395); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BINARY: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + { + setState(1393); + charsetName(); + } + break; + case DEFAULT: + { + setState(1394); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1398); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(1397); + match(DEFAULT); + } + } + + setState(1400); + match(COLLATE); + setState(1402); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1401); + match(EQUAL_SYMBOL); + } + } + + setState(1404); + collationName(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1406); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(1405); + match(DEFAULT); + } + } + + setState(1408); + match(ENCRYPTION); + setState(1410); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1409); + match(EQUAL_SYMBOL); + } + } + + setState(1412); + match(STRING_LITERAL); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1413); + match(READ); + setState(1414); + match(ONLY); + setState(1416); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1415); + match(EQUAL_SYMBOL); + } + } + + setState(1418); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CharSetContext extends ParserRuleContext { + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode CHARSET() { return getToken(MySqlParser.CHARSET, 0); } + public TerminalNode CHAR() { return getToken(MySqlParser.CHAR, 0); } + public CharSetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_charSet; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCharSet(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCharSet(this); + } + } + + public final CharSetContext charSet() throws RecognitionException { + CharSetContext _localctx = new CharSetContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_charSet); + try { + setState(1426); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CHARACTER: + enterOuterAlt(_localctx, 1); + { + setState(1421); + match(CHARACTER); + setState(1422); + match(SET); + } + break; + case CHARSET: + enterOuterAlt(_localctx, 2); + { + setState(1423); + match(CHARSET); + } + break; + case CHAR: + enterOuterAlt(_localctx, 3); + { + setState(1424); + match(CHAR); + setState(1425); + match(SET); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CurrentUserExpressionContext extends ParserRuleContext { + public TerminalNode CURRENT_USER() { return getToken(MySqlParser.CURRENT_USER, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public CurrentUserExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_currentUserExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCurrentUserExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCurrentUserExpression(this); + } + } + + public final CurrentUserExpressionContext currentUserExpression() throws RecognitionException { + CurrentUserExpressionContext _localctx = new CurrentUserExpressionContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_currentUserExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1428); + match(CURRENT_USER); + setState(1431); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) { + case 1: + { + setState(1429); + match(LR_BRACKET); + setState(1430); + match(RR_BRACKET); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OwnerStatementContext extends ParserRuleContext { + public TerminalNode DEFINER() { return getToken(MySqlParser.DEFINER, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public CurrentUserExpressionContext currentUserExpression() { + return getRuleContext(CurrentUserExpressionContext.class,0); + } + public OwnerStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ownerStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterOwnerStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitOwnerStatement(this); + } + } + + public final OwnerStatementContext ownerStatement() throws RecognitionException { + OwnerStatementContext _localctx = new OwnerStatementContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_ownerStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1433); + match(DEFINER); + setState(1434); + match(EQUAL_SYMBOL); + setState(1437); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) { + case 1: + { + setState(1435); + userName(); + } + break; + case 2: + { + setState(1436); + currentUserExpression(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ScheduleExpressionContext extends ParserRuleContext { + public ScheduleExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_scheduleExpression; } + + public ScheduleExpressionContext() { } + public void copyFrom(ScheduleExpressionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PreciseScheduleContext extends ScheduleExpressionContext { + public TerminalNode AT() { return getToken(MySqlParser.AT, 0); } + public TimestampValueContext timestampValue() { + return getRuleContext(TimestampValueContext.class,0); + } + public List intervalExpr() { + return getRuleContexts(IntervalExprContext.class); + } + public IntervalExprContext intervalExpr(int i) { + return getRuleContext(IntervalExprContext.class,i); + } + public PreciseScheduleContext(ScheduleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPreciseSchedule(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPreciseSchedule(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IntervalScheduleContext extends ScheduleExpressionContext { + public TimestampValueContext startTimestamp; + public IntervalExprContext intervalExpr; + public List startIntervals = new ArrayList(); + public TimestampValueContext endTimestamp; + public List endIntervals = new ArrayList(); + public TerminalNode EVERY() { return getToken(MySqlParser.EVERY, 0); } + public IntervalTypeContext intervalType() { + return getRuleContext(IntervalTypeContext.class,0); + } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode STARTS() { return getToken(MySqlParser.STARTS, 0); } + public TerminalNode ENDS() { return getToken(MySqlParser.ENDS, 0); } + public List timestampValue() { + return getRuleContexts(TimestampValueContext.class); + } + public TimestampValueContext timestampValue(int i) { + return getRuleContext(TimestampValueContext.class,i); + } + public List intervalExpr() { + return getRuleContexts(IntervalExprContext.class); + } + public IntervalExprContext intervalExpr(int i) { + return getRuleContext(IntervalExprContext.class,i); + } + public IntervalScheduleContext(ScheduleExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIntervalSchedule(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIntervalSchedule(this); + } + } + + public final ScheduleExpressionContext scheduleExpression() throws RecognitionException { + ScheduleExpressionContext _localctx = new ScheduleExpressionContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_scheduleExpression); + int _la; + try { + setState(1473); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT: + _localctx = new PreciseScheduleContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1439); + match(AT); + setState(1440); + timestampValue(); + setState(1444); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==PLUS) { + { + { + setState(1441); + intervalExpr(); + } + } + setState(1446); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case EVERY: + _localctx = new IntervalScheduleContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1447); + match(EVERY); + setState(1450); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { + case 1: + { + setState(1448); + decimalLiteral(); + } + break; + case 2: + { + setState(1449); + expression(0); + } + break; + } + setState(1452); + intervalType(); + setState(1461); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STARTS) { + { + setState(1453); + match(STARTS); + setState(1454); + ((IntervalScheduleContext)_localctx).startTimestamp = timestampValue(); + setState(1458); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==PLUS) { + { + { + setState(1455); + ((IntervalScheduleContext)_localctx).intervalExpr = intervalExpr(); + ((IntervalScheduleContext)_localctx).startIntervals.add(((IntervalScheduleContext)_localctx).intervalExpr); + } + } + setState(1460); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(1471); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENDS) { + { + setState(1463); + match(ENDS); + setState(1464); + ((IntervalScheduleContext)_localctx).endTimestamp = timestampValue(); + setState(1468); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==PLUS) { + { + { + setState(1465); + ((IntervalScheduleContext)_localctx).intervalExpr = intervalExpr(); + ((IntervalScheduleContext)_localctx).endIntervals.add(((IntervalScheduleContext)_localctx).intervalExpr); + } + } + setState(1470); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TimestampValueContext extends ParserRuleContext { + public TerminalNode CURRENT_TIMESTAMP() { return getToken(MySqlParser.CURRENT_TIMESTAMP, 0); } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TimestampValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_timestampValue; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTimestampValue(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTimestampValue(this); + } + } + + public final TimestampValueContext timestampValue() throws RecognitionException { + TimestampValueContext _localctx = new TimestampValueContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_timestampValue); + try { + setState(1479); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1475); + match(CURRENT_TIMESTAMP); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1476); + stringLiteral(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1477); + decimalLiteral(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1478); + expression(0); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IntervalExprContext extends ParserRuleContext { + public TerminalNode PLUS() { return getToken(MySqlParser.PLUS, 0); } + public TerminalNode INTERVAL() { return getToken(MySqlParser.INTERVAL, 0); } + public IntervalTypeContext intervalType() { + return getRuleContext(IntervalTypeContext.class,0); + } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public IntervalExprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_intervalExpr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIntervalExpr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIntervalExpr(this); + } + } + + public final IntervalExprContext intervalExpr() throws RecognitionException { + IntervalExprContext _localctx = new IntervalExprContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_intervalExpr); + try { + enterOuterAlt(_localctx, 1); + { + setState(1481); + match(PLUS); + setState(1482); + match(INTERVAL); + setState(1485); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { + case 1: + { + setState(1483); + decimalLiteral(); + } + break; + case 2: + { + setState(1484); + expression(0); + } + break; + } + setState(1487); + intervalType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IntervalTypeContext extends ParserRuleContext { + public IntervalTypeBaseContext intervalTypeBase() { + return getRuleContext(IntervalTypeBaseContext.class,0); + } + public TerminalNode YEAR() { return getToken(MySqlParser.YEAR, 0); } + public TerminalNode YEAR_MONTH() { return getToken(MySqlParser.YEAR_MONTH, 0); } + public TerminalNode DAY_HOUR() { return getToken(MySqlParser.DAY_HOUR, 0); } + public TerminalNode DAY_MINUTE() { return getToken(MySqlParser.DAY_MINUTE, 0); } + public TerminalNode DAY_SECOND() { return getToken(MySqlParser.DAY_SECOND, 0); } + public TerminalNode HOUR_MINUTE() { return getToken(MySqlParser.HOUR_MINUTE, 0); } + public TerminalNode HOUR_SECOND() { return getToken(MySqlParser.HOUR_SECOND, 0); } + public TerminalNode MINUTE_SECOND() { return getToken(MySqlParser.MINUTE_SECOND, 0); } + public TerminalNode SECOND_MICROSECOND() { return getToken(MySqlParser.SECOND_MICROSECOND, 0); } + public TerminalNode MINUTE_MICROSECOND() { return getToken(MySqlParser.MINUTE_MICROSECOND, 0); } + public TerminalNode HOUR_MICROSECOND() { return getToken(MySqlParser.HOUR_MICROSECOND, 0); } + public TerminalNode DAY_MICROSECOND() { return getToken(MySqlParser.DAY_MICROSECOND, 0); } + public IntervalTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_intervalType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIntervalType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIntervalType(this); + } + } + + public final IntervalTypeContext intervalType() throws RecognitionException { + IntervalTypeContext _localctx = new IntervalTypeContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_intervalType); + try { + setState(1502); + _errHandler.sync(this); + switch (_input.LA(1)) { + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + enterOuterAlt(_localctx, 1); + { + setState(1489); + intervalTypeBase(); + } + break; + case YEAR: + enterOuterAlt(_localctx, 2); + { + setState(1490); + match(YEAR); + } + break; + case YEAR_MONTH: + enterOuterAlt(_localctx, 3); + { + setState(1491); + match(YEAR_MONTH); + } + break; + case DAY_HOUR: + enterOuterAlt(_localctx, 4); + { + setState(1492); + match(DAY_HOUR); + } + break; + case DAY_MINUTE: + enterOuterAlt(_localctx, 5); + { + setState(1493); + match(DAY_MINUTE); + } + break; + case DAY_SECOND: + enterOuterAlt(_localctx, 6); + { + setState(1494); + match(DAY_SECOND); + } + break; + case HOUR_MINUTE: + enterOuterAlt(_localctx, 7); + { + setState(1495); + match(HOUR_MINUTE); + } + break; + case HOUR_SECOND: + enterOuterAlt(_localctx, 8); + { + setState(1496); + match(HOUR_SECOND); + } + break; + case MINUTE_SECOND: + enterOuterAlt(_localctx, 9); + { + setState(1497); + match(MINUTE_SECOND); + } + break; + case SECOND_MICROSECOND: + enterOuterAlt(_localctx, 10); + { + setState(1498); + match(SECOND_MICROSECOND); + } + break; + case MINUTE_MICROSECOND: + enterOuterAlt(_localctx, 11); + { + setState(1499); + match(MINUTE_MICROSECOND); + } + break; + case HOUR_MICROSECOND: + enterOuterAlt(_localctx, 12); + { + setState(1500); + match(HOUR_MICROSECOND); + } + break; + case DAY_MICROSECOND: + enterOuterAlt(_localctx, 13); + { + setState(1501); + match(DAY_MICROSECOND); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnableTypeContext extends ParserRuleContext { + public TerminalNode ENABLE() { return getToken(MySqlParser.ENABLE, 0); } + public TerminalNode DISABLE() { return getToken(MySqlParser.DISABLE, 0); } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TerminalNode SLAVE() { return getToken(MySqlParser.SLAVE, 0); } + public EnableTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enableType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterEnableType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitEnableType(this); + } + } + + public final EnableTypeContext enableType() throws RecognitionException { + EnableTypeContext _localctx = new EnableTypeContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_enableType); + try { + setState(1509); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1504); + match(ENABLE); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1505); + match(DISABLE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1506); + match(DISABLE); + setState(1507); + match(ON); + setState(1508); + match(SLAVE); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexTypeContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(MySqlParser.USING, 0); } + public TerminalNode BTREE() { return getToken(MySqlParser.BTREE, 0); } + public TerminalNode HASH() { return getToken(MySqlParser.HASH, 0); } + public IndexTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexType(this); + } + } + + public final IndexTypeContext indexType() throws RecognitionException { + IndexTypeContext _localctx = new IndexTypeContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_indexType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1511); + match(USING); + setState(1512); + _la = _input.LA(1); + if ( !(_la==BTREE || _la==HASH) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexOptionContext extends ParserRuleContext { + public TerminalNode KEY_BLOCK_SIZE() { return getToken(MySqlParser.KEY_BLOCK_SIZE, 0); } + public FileSizeLiteralContext fileSizeLiteral() { + return getRuleContext(FileSizeLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public IndexTypeContext indexType() { + return getRuleContext(IndexTypeContext.class,0); + } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public TerminalNode PARSER() { return getToken(MySqlParser.PARSER, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode VISIBLE() { return getToken(MySqlParser.VISIBLE, 0); } + public TerminalNode INVISIBLE() { return getToken(MySqlParser.INVISIBLE, 0); } + public TerminalNode ENGINE_ATTRIBUTE() { return getToken(MySqlParser.ENGINE_ATTRIBUTE, 0); } + public TerminalNode SECONDARY_ENGINE_ATTRIBUTE() { return getToken(MySqlParser.SECONDARY_ENGINE_ATTRIBUTE, 0); } + public IndexOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexOption(this); + } + } + + public final IndexOptionContext indexOption() throws RecognitionException { + IndexOptionContext _localctx = new IndexOptionContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_indexOption); + int _la; + try { + setState(1536); + _errHandler.sync(this); + switch (_input.LA(1)) { + case KEY_BLOCK_SIZE: + enterOuterAlt(_localctx, 1); + { + setState(1514); + match(KEY_BLOCK_SIZE); + setState(1516); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1515); + match(EQUAL_SYMBOL); + } + } + + setState(1518); + fileSizeLiteral(); + } + break; + case USING: + enterOuterAlt(_localctx, 2); + { + setState(1519); + indexType(); + } + break; + case WITH: + enterOuterAlt(_localctx, 3); + { + setState(1520); + match(WITH); + setState(1521); + match(PARSER); + setState(1522); + uid(); + } + break; + case COMMENT: + enterOuterAlt(_localctx, 4); + { + setState(1523); + match(COMMENT); + setState(1524); + match(STRING_LITERAL); + } + break; + case INVISIBLE: + case VISIBLE: + enterOuterAlt(_localctx, 5); + { + setState(1525); + _la = _input.LA(1); + if ( !(_la==INVISIBLE || _la==VISIBLE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case ENGINE_ATTRIBUTE: + enterOuterAlt(_localctx, 6); + { + setState(1526); + match(ENGINE_ATTRIBUTE); + setState(1528); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1527); + match(EQUAL_SYMBOL); + } + } + + setState(1530); + match(STRING_LITERAL); + } + break; + case SECONDARY_ENGINE_ATTRIBUTE: + enterOuterAlt(_localctx, 7); + { + setState(1531); + match(SECONDARY_ENGINE_ATTRIBUTE); + setState(1533); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1532); + match(EQUAL_SYMBOL); + } + } + + setState(1535); + match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ProcedureParameterContext extends ParserRuleContext { + public Token direction; + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public DataTypeContext dataType() { + return getRuleContext(DataTypeContext.class,0); + } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public TerminalNode OUT() { return getToken(MySqlParser.OUT, 0); } + public TerminalNode INOUT() { return getToken(MySqlParser.INOUT, 0); } + public ProcedureParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_procedureParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterProcedureParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitProcedureParameter(this); + } + } + + public final ProcedureParameterContext procedureParameter() throws RecognitionException { + ProcedureParameterContext _localctx = new ProcedureParameterContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_procedureParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1539); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & 35184372088849L) != 0)) { + { + setState(1538); + ((ProcedureParameterContext)_localctx).direction = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & 35184372088849L) != 0)) ) { + ((ProcedureParameterContext)_localctx).direction = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1541); + uid(); + setState(1542); + dataType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionParameterContext extends ParserRuleContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public DataTypeContext dataType() { + return getRuleContext(DataTypeContext.class,0); + } + public FunctionParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFunctionParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFunctionParameter(this); + } + } + + public final FunctionParameterContext functionParameter() throws RecognitionException { + FunctionParameterContext _localctx = new FunctionParameterContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_functionParameter); + try { + enterOuterAlt(_localctx, 1); + { + setState(1544); + uid(); + setState(1545); + dataType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RoutineOptionContext extends ParserRuleContext { + public RoutineOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_routineOption; } + + public RoutineOptionContext() { } + public void copyFrom(RoutineOptionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RoutineBehaviorContext extends RoutineOptionContext { + public TerminalNode DETERMINISTIC() { return getToken(MySqlParser.DETERMINISTIC, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public RoutineBehaviorContext(RoutineOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineBehavior(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineBehavior(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RoutineLanguageContext extends RoutineOptionContext { + public TerminalNode LANGUAGE() { return getToken(MySqlParser.LANGUAGE, 0); } + public TerminalNode SQL() { return getToken(MySqlParser.SQL, 0); } + public RoutineLanguageContext(RoutineOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineLanguage(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineLanguage(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RoutineCommentContext extends RoutineOptionContext { + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public RoutineCommentContext(RoutineOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineComment(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineComment(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RoutineSecurityContext extends RoutineOptionContext { + public Token context; + public TerminalNode SQL() { return getToken(MySqlParser.SQL, 0); } + public TerminalNode SECURITY() { return getToken(MySqlParser.SECURITY, 0); } + public TerminalNode DEFINER() { return getToken(MySqlParser.DEFINER, 0); } + public TerminalNode INVOKER() { return getToken(MySqlParser.INVOKER, 0); } + public RoutineSecurityContext(RoutineOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineSecurity(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineSecurity(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RoutineDataContext extends RoutineOptionContext { + public TerminalNode CONTAINS() { return getToken(MySqlParser.CONTAINS, 0); } + public TerminalNode SQL() { return getToken(MySqlParser.SQL, 0); } + public TerminalNode NO() { return getToken(MySqlParser.NO, 0); } + public TerminalNode READS() { return getToken(MySqlParser.READS, 0); } + public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); } + public TerminalNode MODIFIES() { return getToken(MySqlParser.MODIFIES, 0); } + public RoutineDataContext(RoutineOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineData(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineData(this); + } + } + + public final RoutineOptionContext routineOption() throws RecognitionException { + RoutineOptionContext _localctx = new RoutineOptionContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_routineOption); + int _la; + try { + setState(1570); + _errHandler.sync(this); + switch (_input.LA(1)) { + case COMMENT: + _localctx = new RoutineCommentContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1547); + match(COMMENT); + setState(1548); + match(STRING_LITERAL); + } + break; + case LANGUAGE: + _localctx = new RoutineLanguageContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1549); + match(LANGUAGE); + setState(1550); + match(SQL); + } + break; + case DETERMINISTIC: + case NOT: + _localctx = new RoutineBehaviorContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1552); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(1551); + match(NOT); + } + } + + setState(1554); + match(DETERMINISTIC); + } + break; + case MODIFIES: + case READS: + case CONTAINS: + case NO: + _localctx = new RoutineDataContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(1565); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CONTAINS: + { + setState(1555); + match(CONTAINS); + setState(1556); + match(SQL); + } + break; + case NO: + { + setState(1557); + match(NO); + setState(1558); + match(SQL); + } + break; + case READS: + { + setState(1559); + match(READS); + setState(1560); + match(SQL); + setState(1561); + match(DATA); + } + break; + case MODIFIES: + { + setState(1562); + match(MODIFIES); + setState(1563); + match(SQL); + setState(1564); + match(DATA); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case SQL: + _localctx = new RoutineSecurityContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(1567); + match(SQL); + setState(1568); + match(SECURITY); + setState(1569); + ((RoutineSecurityContext)_localctx).context = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFINER || _la==INVOKER) ) { + ((RoutineSecurityContext)_localctx).context = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ServerOptionContext extends ParserRuleContext { + public TerminalNode HOST() { return getToken(MySqlParser.HOST, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public TerminalNode SOCKET() { return getToken(MySqlParser.SOCKET, 0); } + public TerminalNode OWNER() { return getToken(MySqlParser.OWNER, 0); } + public TerminalNode PORT() { return getToken(MySqlParser.PORT, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public ServerOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_serverOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterServerOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitServerOption(this); + } + } + + public final ServerOptionContext serverOption() throws RecognitionException { + ServerOptionContext _localctx = new ServerOptionContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_serverOption); + try { + setState(1586); + _errHandler.sync(this); + switch (_input.LA(1)) { + case HOST: + enterOuterAlt(_localctx, 1); + { + setState(1572); + match(HOST); + setState(1573); + match(STRING_LITERAL); + } + break; + case DATABASE: + enterOuterAlt(_localctx, 2); + { + setState(1574); + match(DATABASE); + setState(1575); + match(STRING_LITERAL); + } + break; + case USER: + enterOuterAlt(_localctx, 3); + { + setState(1576); + match(USER); + setState(1577); + match(STRING_LITERAL); + } + break; + case PASSWORD: + enterOuterAlt(_localctx, 4); + { + setState(1578); + match(PASSWORD); + setState(1579); + match(STRING_LITERAL); + } + break; + case SOCKET: + enterOuterAlt(_localctx, 5); + { + setState(1580); + match(SOCKET); + setState(1581); + match(STRING_LITERAL); + } + break; + case OWNER: + enterOuterAlt(_localctx, 6); + { + setState(1582); + match(OWNER); + setState(1583); + match(STRING_LITERAL); + } + break; + case PORT: + enterOuterAlt(_localctx, 7); + { + setState(1584); + match(PORT); + setState(1585); + decimalLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateDefinitionsContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List createDefinition() { + return getRuleContexts(CreateDefinitionContext.class); + } + public CreateDefinitionContext createDefinition(int i) { + return getRuleContext(CreateDefinitionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public CreateDefinitionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createDefinitions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateDefinitions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateDefinitions(this); + } + } + + public final CreateDefinitionsContext createDefinitions() throws RecognitionException { + CreateDefinitionsContext _localctx = new CreateDefinitionsContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_createDefinitions); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1588); + match(LR_BRACKET); + setState(1589); + createDefinition(); + setState(1594); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1590); + match(COMMA); + setState(1591); + createDefinition(); + } + } + setState(1596); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1597); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateDefinitionContext extends ParserRuleContext { + public CreateDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createDefinition; } + + public CreateDefinitionContext() { } + public void copyFrom(CreateDefinitionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ColumnDeclarationContext extends CreateDefinitionContext { + public FullColumnNameContext fullColumnName() { + return getRuleContext(FullColumnNameContext.class,0); + } + public ColumnDefinitionContext columnDefinition() { + return getRuleContext(ColumnDefinitionContext.class,0); + } + public ColumnDeclarationContext(CreateDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterColumnDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitColumnDeclaration(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ConstraintDeclarationContext extends CreateDefinitionContext { + public TableConstraintContext tableConstraint() { + return getRuleContext(TableConstraintContext.class,0); + } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public TerminalNode ENFORCED() { return getToken(MySqlParser.ENFORCED, 0); } + public ConstraintDeclarationContext(CreateDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterConstraintDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitConstraintDeclaration(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IndexDeclarationContext extends CreateDefinitionContext { + public IndexColumnDefinitionContext indexColumnDefinition() { + return getRuleContext(IndexColumnDefinitionContext.class,0); + } + public IndexDeclarationContext(CreateDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexDeclaration(this); + } + } + + public final CreateDefinitionContext createDefinition() throws RecognitionException { + CreateDefinitionContext _localctx = new CreateDefinitionContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_createDefinition); + int _la; + try { + setState(1610); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) { + case 1: + _localctx = new ColumnDeclarationContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1599); + fullColumnName(); + setState(1600); + columnDefinition(); + } + break; + case 2: + _localctx = new ConstraintDeclarationContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1602); + tableConstraint(); + setState(1604); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(1603); + match(NOT); + } + } + + setState(1607); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENFORCED) { + { + setState(1606); + match(ENFORCED); + } + } + + } + break; + case 3: + _localctx = new IndexDeclarationContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1609); + indexColumnDefinition(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColumnDefinitionContext extends ParserRuleContext { + public DataTypeContext dataType() { + return getRuleContext(DataTypeContext.class,0); + } + public List columnConstraint() { + return getRuleContexts(ColumnConstraintContext.class); + } + public ColumnConstraintContext columnConstraint(int i) { + return getRuleContext(ColumnConstraintContext.class,i); + } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public TerminalNode ENFORCED() { return getToken(MySqlParser.ENFORCED, 0); } + public ColumnDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_columnDefinition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterColumnDefinition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitColumnDefinition(this); + } + } + + public final ColumnDefinitionContext columnDefinition() throws RecognitionException { + ColumnDefinitionContext _localctx = new ColumnDefinitionContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_columnDefinition); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1612); + dataType(); + setState(1616); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,148,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1613); + columnConstraint(); + } + } + } + setState(1618); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,148,_ctx); + } + setState(1620); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(1619); + match(NOT); + } + } + + setState(1623); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENFORCED) { + { + setState(1622); + match(ENFORCED); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColumnConstraintContext extends ParserRuleContext { + public ColumnConstraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_columnConstraint; } + + public ColumnConstraintContext() { } + public void copyFrom(ColumnConstraintContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class StorageColumnConstraintContext extends ColumnConstraintContext { + public Token storageval; + public TerminalNode STORAGE() { return getToken(MySqlParser.STORAGE, 0); } + public TerminalNode DISK() { return getToken(MySqlParser.DISK, 0); } + public TerminalNode MEMORY() { return getToken(MySqlParser.MEMORY, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public StorageColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStorageColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStorageColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class VisibilityColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode VISIBLE() { return getToken(MySqlParser.VISIBLE, 0); } + public VisibilityColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterVisibilityColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitVisibilityColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AutoIncrementColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode AUTO_INCREMENT() { return getToken(MySqlParser.AUTO_INCREMENT, 0); } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public CurrentTimestampContext currentTimestamp() { + return getRuleContext(CurrentTimestampContext.class,0); + } + public AutoIncrementColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAutoIncrementColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAutoIncrementColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CommentColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public CommentColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCommentColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCommentColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UniqueKeyColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode UNIQUE() { return getToken(MySqlParser.UNIQUE, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public UniqueKeyColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUniqueKeyColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUniqueKeyColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SerialDefaultColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode SERIAL() { return getToken(MySqlParser.SERIAL, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode VALUE() { return getToken(MySqlParser.VALUE, 0); } + public SerialDefaultColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSerialDefaultColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSerialDefaultColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class GeneratedColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode GENERATED() { return getToken(MySqlParser.GENERATED, 0); } + public TerminalNode ALWAYS() { return getToken(MySqlParser.ALWAYS, 0); } + public TerminalNode VIRTUAL() { return getToken(MySqlParser.VIRTUAL, 0); } + public TerminalNode STORED() { return getToken(MySqlParser.STORED, 0); } + public GeneratedColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGeneratedColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGeneratedColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class FormatColumnConstraintContext extends ColumnConstraintContext { + public Token colformat; + public TerminalNode COLUMN_FORMAT() { return getToken(MySqlParser.COLUMN_FORMAT, 0); } + public TerminalNode FIXED() { return getToken(MySqlParser.FIXED, 0); } + public TerminalNode DYNAMIC() { return getToken(MySqlParser.DYNAMIC, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public FormatColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFormatColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFormatColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CollateColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public CollateColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCollateColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCollateColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PrimaryKeyColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public TerminalNode PRIMARY() { return getToken(MySqlParser.PRIMARY, 0); } + public PrimaryKeyColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPrimaryKeyColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPrimaryKeyColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CheckColumnConstraintContext extends ColumnConstraintContext { + public UidContext name; + public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public CheckColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCheckColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCheckColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NullColumnConstraintContext extends ColumnConstraintContext { + public NullNotnullContext nullNotnull() { + return getRuleContext(NullNotnullContext.class,0); + } + public NullColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNullColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNullColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DefaultColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public DefaultValueContext defaultValue() { + return getRuleContext(DefaultValueContext.class,0); + } + public DefaultColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDefaultColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDefaultColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ReferenceColumnConstraintContext extends ColumnConstraintContext { + public ReferenceDefinitionContext referenceDefinition() { + return getRuleContext(ReferenceDefinitionContext.class,0); + } + public ReferenceColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReferenceColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReferenceColumnConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class InvisibilityColumnConstraintContext extends ColumnConstraintContext { + public TerminalNode INVISIBLE() { return getToken(MySqlParser.INVISIBLE, 0); } + public InvisibilityColumnConstraintContext(ColumnConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterInvisibilityColumnConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitInvisibilityColumnConstraint(this); + } + } + + public final ColumnConstraintContext columnConstraint() throws RecognitionException { + ColumnConstraintContext _localctx = new ColumnConstraintContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_columnConstraint); + int _la; + try { + setState(1678); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOT: + case NULL_LITERAL: + case NULL_SPEC_LITERAL: + _localctx = new NullColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1625); + nullNotnull(); + } + break; + case DEFAULT: + _localctx = new DefaultColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1626); + match(DEFAULT); + setState(1627); + defaultValue(); + } + break; + case VISIBLE: + _localctx = new VisibilityColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1628); + match(VISIBLE); + } + break; + case INVISIBLE: + _localctx = new InvisibilityColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(1629); + match(INVISIBLE); + } + break; + case ON: + case AUTO_INCREMENT: + _localctx = new AutoIncrementColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(1634); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AUTO_INCREMENT: + { + setState(1630); + match(AUTO_INCREMENT); + } + break; + case ON: + { + setState(1631); + match(ON); + setState(1632); + match(UPDATE); + setState(1633); + currentTimestamp(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case KEY: + case PRIMARY: + _localctx = new PrimaryKeyColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(1637); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PRIMARY) { + { + setState(1636); + match(PRIMARY); + } + } + + setState(1639); + match(KEY); + } + break; + case UNIQUE: + _localctx = new UniqueKeyColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(1640); + match(UNIQUE); + setState(1642); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) { + case 1: + { + setState(1641); + match(KEY); + } + break; + } + } + break; + case COMMENT: + _localctx = new CommentColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(1644); + match(COMMENT); + setState(1645); + match(STRING_LITERAL); + } + break; + case COLUMN_FORMAT: + _localctx = new FormatColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(1646); + match(COLUMN_FORMAT); + setState(1647); + ((FormatColumnConstraintContext)_localctx).colformat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==DYNAMIC || _la==FIXED) ) { + ((FormatColumnConstraintContext)_localctx).colformat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case STORAGE: + _localctx = new StorageColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(1648); + match(STORAGE); + setState(1649); + ((StorageColumnConstraintContext)_localctx).storageval = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==DISK || _la==MEMORY) ) { + ((StorageColumnConstraintContext)_localctx).storageval = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case REFERENCES: + _localctx = new ReferenceColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(1650); + referenceDefinition(); + } + break; + case COLLATE: + _localctx = new CollateColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(1651); + match(COLLATE); + setState(1652); + collationName(); + } + break; + case AS: + case GENERATED: + _localctx = new GeneratedColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(1655); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==GENERATED) { + { + setState(1653); + match(GENERATED); + setState(1654); + match(ALWAYS); + } + } + + setState(1657); + match(AS); + setState(1658); + match(LR_BRACKET); + setState(1659); + expression(0); + setState(1660); + match(RR_BRACKET); + setState(1662); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STORED || _la==VIRTUAL) { + { + setState(1661); + _la = _input.LA(1); + if ( !(_la==STORED || _la==VIRTUAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + break; + case SERIAL: + _localctx = new SerialDefaultColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(1664); + match(SERIAL); + setState(1665); + match(DEFAULT); + setState(1666); + match(VALUE); + } + break; + case CHECK: + case CONSTRAINT: + _localctx = new CheckColumnConstraintContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(1671); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(1667); + match(CONSTRAINT); + setState(1669); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1668); + ((CheckColumnConstraintContext)_localctx).name = uid(); + } + } + + } + } + + setState(1673); + match(CHECK); + setState(1674); + match(LR_BRACKET); + setState(1675); + expression(0); + setState(1676); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableConstraintContext extends ParserRuleContext { + public TableConstraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableConstraint; } + + public TableConstraintContext() { } + public void copyFrom(TableConstraintContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UniqueKeyTableConstraintContext extends TableConstraintContext { + public UidContext name; + public Token indexFormat; + public UidContext index; + public TerminalNode UNIQUE() { return getToken(MySqlParser.UNIQUE, 0); } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public IndexTypeContext indexType() { + return getRuleContext(IndexTypeContext.class,0); + } + public List indexOption() { + return getRuleContexts(IndexOptionContext.class); + } + public IndexOptionContext indexOption(int i) { + return getRuleContext(IndexOptionContext.class,i); + } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public UniqueKeyTableConstraintContext(TableConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUniqueKeyTableConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUniqueKeyTableConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CheckTableConstraintContext extends TableConstraintContext { + public UidContext name; + public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public CheckTableConstraintContext(TableConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCheckTableConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCheckTableConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PrimaryKeyTableConstraintContext extends TableConstraintContext { + public UidContext name; + public UidContext index; + public TerminalNode PRIMARY() { return getToken(MySqlParser.PRIMARY, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public IndexTypeContext indexType() { + return getRuleContext(IndexTypeContext.class,0); + } + public List indexOption() { + return getRuleContexts(IndexOptionContext.class); + } + public IndexOptionContext indexOption(int i) { + return getRuleContext(IndexOptionContext.class,i); + } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public PrimaryKeyTableConstraintContext(TableConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPrimaryKeyTableConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPrimaryKeyTableConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ForeignKeyTableConstraintContext extends TableConstraintContext { + public UidContext name; + public UidContext index; + public TerminalNode FOREIGN() { return getToken(MySqlParser.FOREIGN, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public ReferenceDefinitionContext referenceDefinition() { + return getRuleContext(ReferenceDefinitionContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public ForeignKeyTableConstraintContext(TableConstraintContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterForeignKeyTableConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitForeignKeyTableConstraint(this); + } + } + + public final TableConstraintContext tableConstraint() throws RecognitionException { + TableConstraintContext _localctx = new TableConstraintContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_tableConstraint); + int _la; + try { + setState(1749); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { + case 1: + _localctx = new PrimaryKeyTableConstraintContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1684); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(1680); + match(CONSTRAINT); + setState(1682); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { + case 1: + { + setState(1681); + ((PrimaryKeyTableConstraintContext)_localctx).name = uid(); + } + break; + } + } + } + + setState(1686); + match(PRIMARY); + setState(1687); + match(KEY); + setState(1689); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1688); + ((PrimaryKeyTableConstraintContext)_localctx).index = uid(); + } + } + + setState(1692); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(1691); + indexType(); + } + } + + setState(1694); + indexColumnNames(); + setState(1698); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==USING || _la==WITH || _la==COMMENT || _la==INVISIBLE || _la==KEY_BLOCK_SIZE || _la==VISIBLE || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE) { + { + { + setState(1695); + indexOption(); + } + } + setState(1700); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + _localctx = new UniqueKeyTableConstraintContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1705); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(1701); + match(CONSTRAINT); + setState(1703); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1702); + ((UniqueKeyTableConstraintContext)_localctx).name = uid(); + } + } + + } + } + + setState(1707); + match(UNIQUE); + setState(1709); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INDEX || _la==KEY) { + { + setState(1708); + ((UniqueKeyTableConstraintContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((UniqueKeyTableConstraintContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1712); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1711); + ((UniqueKeyTableConstraintContext)_localctx).index = uid(); + } + } + + setState(1715); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(1714); + indexType(); + } + } + + setState(1717); + indexColumnNames(); + setState(1721); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==USING || _la==WITH || _la==COMMENT || _la==INVISIBLE || _la==KEY_BLOCK_SIZE || _la==VISIBLE || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE) { + { + { + setState(1718); + indexOption(); + } + } + setState(1723); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 3: + _localctx = new ForeignKeyTableConstraintContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1728); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(1724); + match(CONSTRAINT); + setState(1726); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1725); + ((ForeignKeyTableConstraintContext)_localctx).name = uid(); + } + } + + } + } + + setState(1730); + match(FOREIGN); + setState(1731); + match(KEY); + setState(1733); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1732); + ((ForeignKeyTableConstraintContext)_localctx).index = uid(); + } + } + + setState(1735); + indexColumnNames(); + setState(1736); + referenceDefinition(); + } + break; + case 4: + _localctx = new CheckTableConstraintContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(1742); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(1738); + match(CONSTRAINT); + setState(1740); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1739); + ((CheckTableConstraintContext)_localctx).name = uid(); + } + } + + } + } + + setState(1744); + match(CHECK); + setState(1745); + match(LR_BRACKET); + setState(1746); + expression(0); + setState(1747); + match(RR_BRACKET); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReferenceDefinitionContext extends ParserRuleContext { + public Token matchType; + public TerminalNode REFERENCES() { return getToken(MySqlParser.REFERENCES, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public TerminalNode MATCH() { return getToken(MySqlParser.MATCH, 0); } + public ReferenceActionContext referenceAction() { + return getRuleContext(ReferenceActionContext.class,0); + } + public TerminalNode FULL() { return getToken(MySqlParser.FULL, 0); } + public TerminalNode PARTIAL() { return getToken(MySqlParser.PARTIAL, 0); } + public TerminalNode SIMPLE() { return getToken(MySqlParser.SIMPLE, 0); } + public ReferenceDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_referenceDefinition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReferenceDefinition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReferenceDefinition(this); + } + } + + public final ReferenceDefinitionContext referenceDefinition() throws RecognitionException { + ReferenceDefinitionContext _localctx = new ReferenceDefinitionContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_referenceDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1751); + match(REFERENCES); + setState(1752); + tableName(); + setState(1754); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) { + case 1: + { + setState(1753); + indexColumnNames(); + } + break; + } + setState(1758); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==MATCH) { + { + setState(1756); + match(MATCH); + setState(1757); + ((ReferenceDefinitionContext)_localctx).matchType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FULL || _la==PARTIAL || _la==SIMPLE) ) { + ((ReferenceDefinitionContext)_localctx).matchType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1761); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) { + case 1: + { + setState(1760); + referenceAction(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReferenceActionContext extends ParserRuleContext { + public ReferenceControlTypeContext onDelete; + public ReferenceControlTypeContext onUpdate; + public List ON() { return getTokens(MySqlParser.ON); } + public TerminalNode ON(int i) { + return getToken(MySqlParser.ON, i); + } + public TerminalNode DELETE() { return getToken(MySqlParser.DELETE, 0); } + public List referenceControlType() { + return getRuleContexts(ReferenceControlTypeContext.class); + } + public ReferenceControlTypeContext referenceControlType(int i) { + return getRuleContext(ReferenceControlTypeContext.class,i); + } + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public ReferenceActionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_referenceAction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReferenceAction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReferenceAction(this); + } + } + + public final ReferenceActionContext referenceAction() throws RecognitionException { + ReferenceActionContext _localctx = new ReferenceActionContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_referenceAction); + try { + setState(1779); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1763); + match(ON); + setState(1764); + match(DELETE); + setState(1765); + ((ReferenceActionContext)_localctx).onDelete = referenceControlType(); + setState(1769); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) { + case 1: + { + setState(1766); + match(ON); + setState(1767); + match(UPDATE); + setState(1768); + ((ReferenceActionContext)_localctx).onUpdate = referenceControlType(); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1771); + match(ON); + setState(1772); + match(UPDATE); + setState(1773); + ((ReferenceActionContext)_localctx).onUpdate = referenceControlType(); + setState(1777); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) { + case 1: + { + setState(1774); + match(ON); + setState(1775); + match(DELETE); + setState(1776); + ((ReferenceActionContext)_localctx).onDelete = referenceControlType(); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReferenceControlTypeContext extends ParserRuleContext { + public TerminalNode RESTRICT() { return getToken(MySqlParser.RESTRICT, 0); } + public TerminalNode CASCADE() { return getToken(MySqlParser.CASCADE, 0); } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode NULL_LITERAL() { return getToken(MySqlParser.NULL_LITERAL, 0); } + public TerminalNode NO() { return getToken(MySqlParser.NO, 0); } + public TerminalNode ACTION() { return getToken(MySqlParser.ACTION, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public ReferenceControlTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_referenceControlType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReferenceControlType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReferenceControlType(this); + } + } + + public final ReferenceControlTypeContext referenceControlType() throws RecognitionException { + ReferenceControlTypeContext _localctx = new ReferenceControlTypeContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_referenceControlType); + try { + setState(1789); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1781); + match(RESTRICT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1782); + match(CASCADE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1783); + match(SET); + setState(1784); + match(NULL_LITERAL); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1785); + match(NO); + setState(1786); + match(ACTION); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1787); + match(SET); + setState(1788); + match(DEFAULT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexColumnDefinitionContext extends ParserRuleContext { + public IndexColumnDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexColumnDefinition; } + + public IndexColumnDefinitionContext() { } + public void copyFrom(IndexColumnDefinitionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SpecialIndexDeclarationContext extends IndexColumnDefinitionContext { + public Token indexFormat; + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public TerminalNode FULLTEXT() { return getToken(MySqlParser.FULLTEXT, 0); } + public TerminalNode SPATIAL() { return getToken(MySqlParser.SPATIAL, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List indexOption() { + return getRuleContexts(IndexOptionContext.class); + } + public IndexOptionContext indexOption(int i) { + return getRuleContext(IndexOptionContext.class,i); + } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public SpecialIndexDeclarationContext(IndexColumnDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSpecialIndexDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSpecialIndexDeclaration(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SimpleIndexDeclarationContext extends IndexColumnDefinitionContext { + public Token indexFormat; + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public IndexTypeContext indexType() { + return getRuleContext(IndexTypeContext.class,0); + } + public List indexOption() { + return getRuleContexts(IndexOptionContext.class); + } + public IndexOptionContext indexOption(int i) { + return getRuleContext(IndexOptionContext.class,i); + } + public SimpleIndexDeclarationContext(IndexColumnDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleIndexDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleIndexDeclaration(this); + } + } + + public final IndexColumnDefinitionContext indexColumnDefinition() throws RecognitionException { + IndexColumnDefinitionContext _localctx = new IndexColumnDefinitionContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_indexColumnDefinition); + int _la; + try { + setState(1819); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INDEX: + case KEY: + _localctx = new SimpleIndexDeclarationContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1791); + ((SimpleIndexDeclarationContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((SimpleIndexDeclarationContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1793); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1792); + uid(); + } + } + + setState(1796); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(1795); + indexType(); + } + } + + setState(1798); + indexColumnNames(); + setState(1802); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==USING || _la==WITH || _la==COMMENT || _la==INVISIBLE || _la==KEY_BLOCK_SIZE || _la==VISIBLE || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE) { + { + { + setState(1799); + indexOption(); + } + } + setState(1804); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case FULLTEXT: + case SPATIAL: + _localctx = new SpecialIndexDeclarationContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1805); + _la = _input.LA(1); + if ( !(_la==FULLTEXT || _la==SPATIAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1807); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INDEX || _la==KEY) { + { + setState(1806); + ((SpecialIndexDeclarationContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((SpecialIndexDeclarationContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(1810); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(1809); + uid(); + } + } + + setState(1812); + indexColumnNames(); + setState(1816); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==USING || _la==WITH || _la==COMMENT || _la==INVISIBLE || _la==KEY_BLOCK_SIZE || _la==VISIBLE || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE) { + { + { + setState(1813); + indexOption(); + } + } + setState(1818); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableOptionContext extends ParserRuleContext { + public TableOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableOption; } + + public TableOptionContext() { } + public void copyFrom(TableOptionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionEngineContext extends TableOptionContext { + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public TableOptionEngineContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionEngine(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionEngine(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionMaxRowsContext extends TableOptionContext { + public TerminalNode MAX_ROWS() { return getToken(MySqlParser.MAX_ROWS, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionMaxRowsContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionMaxRows(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionMaxRows(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionCollateContext extends TableOptionContext { + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionCollateContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionCollate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionCollate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionPersistentContext extends TableOptionContext { + public Token extBoolValue; + public TerminalNode STATS_PERSISTENT() { return getToken(MySqlParser.STATS_PERSISTENT, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionPersistentContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPersistent(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPersistent(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionTablespaceContext extends TableOptionContext { + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TablespaceStorageContext tablespaceStorage() { + return getRuleContext(TablespaceStorageContext.class,0); + } + public TableOptionTablespaceContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionTablespace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionTablespace(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionAutoextendSizeContext extends TableOptionContext { + public TerminalNode AUTOEXTEND_SIZE() { return getToken(MySqlParser.AUTOEXTEND_SIZE, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionAutoextendSizeContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionAutoextendSize(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionAutoextendSize(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionPageCompressedContext extends TableOptionContext { + public TerminalNode PAGE_COMPRESSED() { return getToken(MySqlParser.PAGE_COMPRESSED, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionPageCompressedContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPageCompressed(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPageCompressed(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionStartTransactionContext extends TableOptionContext { + public TerminalNode START() { return getToken(MySqlParser.START, 0); } + public TerminalNode TRANSACTION() { return getToken(MySqlParser.TRANSACTION, 0); } + public TableOptionStartTransactionContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionStartTransaction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionStartTransaction(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionPackKeysContext extends TableOptionContext { + public Token extBoolValue; + public TerminalNode PACK_KEYS() { return getToken(MySqlParser.PACK_KEYS, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionPackKeysContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPackKeys(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPackKeys(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionPasswordContext extends TableOptionContext { + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionPasswordContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPassword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPassword(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionUnionContext extends TableOptionContext { + public TerminalNode UNION() { return getToken(MySqlParser.UNION, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionUnionContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionUnion(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionUnion(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionSamplePageContext extends TableOptionContext { + public TerminalNode STATS_SAMPLE_PAGES() { return getToken(MySqlParser.STATS_SAMPLE_PAGES, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionSamplePageContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionSamplePage(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionSamplePage(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionCharsetContext extends TableOptionContext { + public CharSetContext charSet() { + return getRuleContext(CharSetContext.class,0); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public List DEFAULT() { return getTokens(MySqlParser.DEFAULT); } + public TerminalNode DEFAULT(int i) { + return getToken(MySqlParser.DEFAULT, i); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionCharsetContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionCharset(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionCharset(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionIndexDirectoryContext extends TableOptionContext { + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionIndexDirectoryContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionIndexDirectory(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionIndexDirectory(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionTableTypeContext extends TableOptionContext { + public TerminalNode TABLE_TYPE() { return getToken(MySqlParser.TABLE_TYPE, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableTypeContext tableType() { + return getRuleContext(TableTypeContext.class,0); + } + public TableOptionTableTypeContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionTableType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionTableType(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionKeyBlockSizeContext extends TableOptionContext { + public TerminalNode KEY_BLOCK_SIZE() { return getToken(MySqlParser.KEY_BLOCK_SIZE, 0); } + public FileSizeLiteralContext fileSizeLiteral() { + return getRuleContext(FileSizeLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionKeyBlockSizeContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionKeyBlockSize(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionKeyBlockSize(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionEncryptionContext extends TableOptionContext { + public TerminalNode ENCRYPTION() { return getToken(MySqlParser.ENCRYPTION, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionEncryptionContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionEncryption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionEncryption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionDataDirectoryContext extends TableOptionContext { + public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionDataDirectoryContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionDataDirectory(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionDataDirectory(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionRecalculationContext extends TableOptionContext { + public Token extBoolValue; + public TerminalNode STATS_AUTO_RECALC() { return getToken(MySqlParser.STATS_AUTO_RECALC, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionRecalculationContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionRecalculation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionRecalculation(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionAutoIncrementContext extends TableOptionContext { + public TerminalNode AUTO_INCREMENT() { return getToken(MySqlParser.AUTO_INCREMENT, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionAutoIncrementContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionAutoIncrement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionAutoIncrement(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionEncryptionKeyIdContext extends TableOptionContext { + public TerminalNode ENCRYPTION_KEY_ID() { return getToken(MySqlParser.ENCRYPTION_KEY_ID, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionEncryptionKeyIdContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionEncryptionKeyId(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionEncryptionKeyId(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionChecksumContext extends TableOptionContext { + public Token boolValue; + public TerminalNode CHECKSUM() { return getToken(MySqlParser.CHECKSUM, 0); } + public TerminalNode PAGE_CHECKSUM() { return getToken(MySqlParser.PAGE_CHECKSUM, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionChecksumContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionChecksum(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionChecksum(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionDelayContext extends TableOptionContext { + public Token boolValue; + public TerminalNode DELAY_KEY_WRITE() { return getToken(MySqlParser.DELAY_KEY_WRITE, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionDelayContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionDelay(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionDelay(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionConnectionContext extends TableOptionContext { + public TerminalNode CONNECTION() { return getToken(MySqlParser.CONNECTION, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionConnectionContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionConnection(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionConnection(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionTransactionalContext extends TableOptionContext { + public TerminalNode TRANSACTIONAL() { return getToken(MySqlParser.TRANSACTIONAL, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionTransactionalContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionTransactional(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionTransactional(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionPageCompressionLevelContext extends TableOptionContext { + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode PAGE_COMPRESSION_LEVEL() { return getToken(MySqlParser.PAGE_COMPRESSION_LEVEL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionPageCompressionLevelContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionPageCompressionLevel(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionPageCompressionLevel(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionSecondaryEngineAttributeContext extends TableOptionContext { + public TerminalNode SECONDARY_ENGINE_ATTRIBUTE() { return getToken(MySqlParser.SECONDARY_ENGINE_ATTRIBUTE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionSecondaryEngineAttributeContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionSecondaryEngineAttribute(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionSecondaryEngineAttribute(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionCommentContext extends TableOptionContext { + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionCommentContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionComment(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionComment(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionAverageContext extends TableOptionContext { + public TerminalNode AVG_ROW_LENGTH() { return getToken(MySqlParser.AVG_ROW_LENGTH, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionAverageContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionAverage(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionAverage(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionRowFormatContext extends TableOptionContext { + public Token rowFormat; + public TerminalNode ROW_FORMAT() { return getToken(MySqlParser.ROW_FORMAT, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode DYNAMIC() { return getToken(MySqlParser.DYNAMIC, 0); } + public TerminalNode FIXED() { return getToken(MySqlParser.FIXED, 0); } + public TerminalNode COMPRESSED() { return getToken(MySqlParser.COMPRESSED, 0); } + public TerminalNode REDUNDANT() { return getToken(MySqlParser.REDUNDANT, 0); } + public TerminalNode COMPACT() { return getToken(MySqlParser.COMPACT, 0); } + public TerminalNode ID() { return getToken(MySqlParser.ID, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionRowFormatContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionRowFormat(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionRowFormat(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionCompressionContext extends TableOptionContext { + public TerminalNode COMPRESSION() { return getToken(MySqlParser.COMPRESSION, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode ID() { return getToken(MySqlParser.ID, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionCompressionContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionCompression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionCompression(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionInsertMethodContext extends TableOptionContext { + public Token insertMethod; + public TerminalNode INSERT_METHOD() { return getToken(MySqlParser.INSERT_METHOD, 0); } + public TerminalNode NO() { return getToken(MySqlParser.NO, 0); } + public TerminalNode FIRST() { return getToken(MySqlParser.FIRST, 0); } + public TerminalNode LAST() { return getToken(MySqlParser.LAST, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionInsertMethodContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionInsertMethod(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionInsertMethod(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionEngineAttributeContext extends TableOptionContext { + public TerminalNode ENGINE_ATTRIBUTE() { return getToken(MySqlParser.ENGINE_ATTRIBUTE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionEngineAttributeContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionEngineAttribute(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionEngineAttribute(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableOptionMinRowsContext extends TableOptionContext { + public TerminalNode MIN_ROWS() { return getToken(MySqlParser.MIN_ROWS, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TableOptionMinRowsContext(TableOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableOptionMinRows(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableOptionMinRows(this); + } + } + + public final TableOptionContext tableOption() throws RecognitionException { + TableOptionContext _localctx = new TableOptionContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_tableOption); + int _la; + try { + setState(2006); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) { + case 1: + _localctx = new TableOptionEngineContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(1821); + match(ENGINE); + setState(1823); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1822); + match(EQUAL_SYMBOL); + } + } + + setState(1826); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) { + case 1: + { + setState(1825); + engineName(); + } + break; + } + } + break; + case 2: + _localctx = new TableOptionEngineAttributeContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(1828); + match(ENGINE_ATTRIBUTE); + setState(1830); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1829); + match(EQUAL_SYMBOL); + } + } + + setState(1832); + match(STRING_LITERAL); + } + break; + case 3: + _localctx = new TableOptionAutoextendSizeContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(1833); + match(AUTOEXTEND_SIZE); + setState(1835); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1834); + match(EQUAL_SYMBOL); + } + } + + setState(1837); + decimalLiteral(); + } + break; + case 4: + _localctx = new TableOptionAutoIncrementContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(1838); + match(AUTO_INCREMENT); + setState(1840); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1839); + match(EQUAL_SYMBOL); + } + } + + setState(1842); + decimalLiteral(); + } + break; + case 5: + _localctx = new TableOptionAverageContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(1843); + match(AVG_ROW_LENGTH); + setState(1845); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1844); + match(EQUAL_SYMBOL); + } + } + + setState(1847); + decimalLiteral(); + } + break; + case 6: + _localctx = new TableOptionCharsetContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(1849); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(1848); + match(DEFAULT); + } + } + + setState(1851); + charSet(); + setState(1853); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1852); + match(EQUAL_SYMBOL); + } + } + + setState(1857); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BINARY: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + { + setState(1855); + charsetName(); + } + break; + case DEFAULT: + { + setState(1856); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 7: + _localctx = new TableOptionChecksumContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(1859); + _la = _input.LA(1); + if ( !(_la==CHECKSUM || _la==PAGE_CHECKSUM) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1861); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1860); + match(EQUAL_SYMBOL); + } + } + + setState(1863); + ((TableOptionChecksumContext)_localctx).boolValue = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + ((TableOptionChecksumContext)_localctx).boolValue = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 8: + _localctx = new TableOptionCollateContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(1865); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(1864); + match(DEFAULT); + } + } + + setState(1867); + match(COLLATE); + setState(1869); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1868); + match(EQUAL_SYMBOL); + } + } + + setState(1871); + collationName(); + } + break; + case 9: + _localctx = new TableOptionCommentContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(1872); + match(COMMENT); + setState(1874); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1873); + match(EQUAL_SYMBOL); + } + } + + setState(1876); + match(STRING_LITERAL); + } + break; + case 10: + _localctx = new TableOptionCompressionContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(1877); + match(COMPRESSION); + setState(1879); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1878); + match(EQUAL_SYMBOL); + } + } + + setState(1881); + _la = _input.LA(1); + if ( !(_la==STRING_LITERAL || _la==ID) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 11: + _localctx = new TableOptionConnectionContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(1882); + match(CONNECTION); + setState(1884); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1883); + match(EQUAL_SYMBOL); + } + } + + setState(1886); + match(STRING_LITERAL); + } + break; + case 12: + _localctx = new TableOptionDataDirectoryContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(1887); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==DATA) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1888); + match(DIRECTORY); + setState(1890); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1889); + match(EQUAL_SYMBOL); + } + } + + setState(1892); + match(STRING_LITERAL); + } + break; + case 13: + _localctx = new TableOptionDelayContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(1893); + match(DELAY_KEY_WRITE); + setState(1895); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1894); + match(EQUAL_SYMBOL); + } + } + + setState(1897); + ((TableOptionDelayContext)_localctx).boolValue = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + ((TableOptionDelayContext)_localctx).boolValue = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 14: + _localctx = new TableOptionEncryptionContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(1898); + match(ENCRYPTION); + setState(1900); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1899); + match(EQUAL_SYMBOL); + } + } + + setState(1902); + match(STRING_LITERAL); + } + break; + case 15: + _localctx = new TableOptionPageCompressedContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(1903); + _la = _input.LA(1); + if ( !(_la==PAGE_COMPRESSED || _la==STRING_LITERAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1905); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1904); + match(EQUAL_SYMBOL); + } + } + + setState(1907); + _la = _input.LA(1); + if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 16: + _localctx = new TableOptionPageCompressionLevelContext(_localctx); + enterOuterAlt(_localctx, 16); + { + setState(1908); + _la = _input.LA(1); + if ( !(_la==PAGE_COMPRESSION_LEVEL || _la==STRING_LITERAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1910); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1909); + match(EQUAL_SYMBOL); + } + } + + setState(1912); + decimalLiteral(); + } + break; + case 17: + _localctx = new TableOptionEncryptionKeyIdContext(_localctx); + enterOuterAlt(_localctx, 17); + { + setState(1913); + match(ENCRYPTION_KEY_ID); + setState(1915); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1914); + match(EQUAL_SYMBOL); + } + } + + setState(1917); + decimalLiteral(); + } + break; + case 18: + _localctx = new TableOptionIndexDirectoryContext(_localctx); + enterOuterAlt(_localctx, 18); + { + setState(1918); + match(INDEX); + setState(1919); + match(DIRECTORY); + setState(1921); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1920); + match(EQUAL_SYMBOL); + } + } + + setState(1923); + match(STRING_LITERAL); + } + break; + case 19: + _localctx = new TableOptionInsertMethodContext(_localctx); + enterOuterAlt(_localctx, 19); + { + setState(1924); + match(INSERT_METHOD); + setState(1926); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1925); + match(EQUAL_SYMBOL); + } + } + + setState(1928); + ((TableOptionInsertMethodContext)_localctx).insertMethod = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FIRST || _la==LAST || _la==NO) ) { + ((TableOptionInsertMethodContext)_localctx).insertMethod = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 20: + _localctx = new TableOptionKeyBlockSizeContext(_localctx); + enterOuterAlt(_localctx, 20); + { + setState(1929); + match(KEY_BLOCK_SIZE); + setState(1931); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1930); + match(EQUAL_SYMBOL); + } + } + + setState(1933); + fileSizeLiteral(); + } + break; + case 21: + _localctx = new TableOptionMaxRowsContext(_localctx); + enterOuterAlt(_localctx, 21); + { + setState(1934); + match(MAX_ROWS); + setState(1936); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1935); + match(EQUAL_SYMBOL); + } + } + + setState(1938); + decimalLiteral(); + } + break; + case 22: + _localctx = new TableOptionMinRowsContext(_localctx); + enterOuterAlt(_localctx, 22); + { + setState(1939); + match(MIN_ROWS); + setState(1941); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1940); + match(EQUAL_SYMBOL); + } + } + + setState(1943); + decimalLiteral(); + } + break; + case 23: + _localctx = new TableOptionPackKeysContext(_localctx); + enterOuterAlt(_localctx, 23); + { + setState(1944); + match(PACK_KEYS); + setState(1946); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1945); + match(EQUAL_SYMBOL); + } + } + + setState(1948); + ((TableOptionPackKeysContext)_localctx).extBoolValue = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + ((TableOptionPackKeysContext)_localctx).extBoolValue = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 24: + _localctx = new TableOptionPasswordContext(_localctx); + enterOuterAlt(_localctx, 24); + { + setState(1949); + match(PASSWORD); + setState(1951); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1950); + match(EQUAL_SYMBOL); + } + } + + setState(1953); + match(STRING_LITERAL); + } + break; + case 25: + _localctx = new TableOptionRowFormatContext(_localctx); + enterOuterAlt(_localctx, 25); + { + setState(1954); + match(ROW_FORMAT); + setState(1956); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1955); + match(EQUAL_SYMBOL); + } + } + + setState(1958); + ((TableOptionRowFormatContext)_localctx).rowFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || ((((_la - 371)) & ~0x3f) == 0 && ((1L << (_la - 371)) & 2305843013508661253L) != 0) || _la==REDUNDANT || _la==ID) ) { + ((TableOptionRowFormatContext)_localctx).rowFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 26: + _localctx = new TableOptionStartTransactionContext(_localctx); + enterOuterAlt(_localctx, 26); + { + setState(1959); + match(START); + setState(1960); + match(TRANSACTION); + } + break; + case 27: + _localctx = new TableOptionSecondaryEngineAttributeContext(_localctx); + enterOuterAlt(_localctx, 27); + { + setState(1961); + match(SECONDARY_ENGINE_ATTRIBUTE); + setState(1963); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1962); + match(EQUAL_SYMBOL); + } + } + + setState(1965); + match(STRING_LITERAL); + } + break; + case 28: + _localctx = new TableOptionRecalculationContext(_localctx); + enterOuterAlt(_localctx, 28); + { + setState(1966); + match(STATS_AUTO_RECALC); + setState(1968); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1967); + match(EQUAL_SYMBOL); + } + } + + setState(1970); + ((TableOptionRecalculationContext)_localctx).extBoolValue = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + ((TableOptionRecalculationContext)_localctx).extBoolValue = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 29: + _localctx = new TableOptionPersistentContext(_localctx); + enterOuterAlt(_localctx, 29); + { + setState(1971); + match(STATS_PERSISTENT); + setState(1973); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1972); + match(EQUAL_SYMBOL); + } + } + + setState(1975); + ((TableOptionPersistentContext)_localctx).extBoolValue = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + ((TableOptionPersistentContext)_localctx).extBoolValue = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 30: + _localctx = new TableOptionSamplePageContext(_localctx); + enterOuterAlt(_localctx, 30); + { + setState(1976); + match(STATS_SAMPLE_PAGES); + setState(1978); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1977); + match(EQUAL_SYMBOL); + } + } + + setState(1982); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEFAULT: + { + setState(1980); + match(DEFAULT); + } + break; + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + { + setState(1981); + decimalLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 31: + _localctx = new TableOptionTablespaceContext(_localctx); + enterOuterAlt(_localctx, 31); + { + setState(1984); + match(TABLESPACE); + setState(1985); + uid(); + setState(1987); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,224,_ctx) ) { + case 1: + { + setState(1986); + tablespaceStorage(); + } + break; + } + } + break; + case 32: + _localctx = new TableOptionTableTypeContext(_localctx); + enterOuterAlt(_localctx, 32); + { + setState(1989); + match(TABLE_TYPE); + setState(1990); + match(EQUAL_SYMBOL); + setState(1991); + tableType(); + } + break; + case 33: + _localctx = new TableOptionTablespaceContext(_localctx); + enterOuterAlt(_localctx, 33); + { + setState(1992); + tablespaceStorage(); + } + break; + case 34: + _localctx = new TableOptionTransactionalContext(_localctx); + enterOuterAlt(_localctx, 34); + { + setState(1993); + match(TRANSACTIONAL); + setState(1995); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1994); + match(EQUAL_SYMBOL); + } + } + + setState(1997); + _la = _input.LA(1); + if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 35: + _localctx = new TableOptionUnionContext(_localctx); + enterOuterAlt(_localctx, 35); + { + setState(1998); + match(UNION); + setState(2000); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(1999); + match(EQUAL_SYMBOL); + } + } + + setState(2002); + match(LR_BRACKET); + setState(2003); + tables(); + setState(2004); + match(RR_BRACKET); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableTypeContext extends ParserRuleContext { + public TerminalNode MYSQL() { return getToken(MySqlParser.MYSQL, 0); } + public TerminalNode ODBC() { return getToken(MySqlParser.ODBC, 0); } + public TableTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableType(this); + } + } + + public final TableTypeContext tableType() throws RecognitionException { + TableTypeContext _localctx = new TableTypeContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_tableType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2008); + _la = _input.LA(1); + if ( !(_la==MYSQL || _la==ODBC) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TablespaceStorageContext extends ParserRuleContext { + public TerminalNode STORAGE() { return getToken(MySqlParser.STORAGE, 0); } + public TerminalNode DISK() { return getToken(MySqlParser.DISK, 0); } + public TerminalNode MEMORY() { return getToken(MySqlParser.MEMORY, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TablespaceStorageContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tablespaceStorage; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTablespaceStorage(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTablespaceStorage(this); + } + } + + public final TablespaceStorageContext tablespaceStorage() throws RecognitionException { + TablespaceStorageContext _localctx = new TablespaceStorageContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_tablespaceStorage); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2010); + match(STORAGE); + setState(2011); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==DISK || _la==MEMORY) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PartitionDefinitionsContext extends ParserRuleContext { + public DecimalLiteralContext count; + public DecimalLiteralContext subCount; + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public List BY() { return getTokens(MySqlParser.BY); } + public TerminalNode BY(int i) { + return getToken(MySqlParser.BY, i); + } + public PartitionFunctionDefinitionContext partitionFunctionDefinition() { + return getRuleContext(PartitionFunctionDefinitionContext.class,0); + } + public TerminalNode PARTITIONS() { return getToken(MySqlParser.PARTITIONS, 0); } + public TerminalNode SUBPARTITION() { return getToken(MySqlParser.SUBPARTITION, 0); } + public SubpartitionFunctionDefinitionContext subpartitionFunctionDefinition() { + return getRuleContext(SubpartitionFunctionDefinitionContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List partitionDefinition() { + return getRuleContexts(PartitionDefinitionContext.class); + } + public PartitionDefinitionContext partitionDefinition(int i) { + return getRuleContext(PartitionDefinitionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public TerminalNode SUBPARTITIONS() { return getToken(MySqlParser.SUBPARTITIONS, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public PartitionDefinitionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_partitionDefinitions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionDefinitions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionDefinitions(this); + } + } + + public final PartitionDefinitionsContext partitionDefinitions() throws RecognitionException { + PartitionDefinitionsContext _localctx = new PartitionDefinitionsContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_partitionDefinitions); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2013); + match(PARTITION); + setState(2014); + match(BY); + setState(2015); + partitionFunctionDefinition(); + setState(2018); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITIONS) { + { + setState(2016); + match(PARTITIONS); + setState(2017); + ((PartitionDefinitionsContext)_localctx).count = decimalLiteral(); + } + } + + setState(2027); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SUBPARTITION) { + { + setState(2020); + match(SUBPARTITION); + setState(2021); + match(BY); + setState(2022); + subpartitionFunctionDefinition(); + setState(2025); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SUBPARTITIONS) { + { + setState(2023); + match(SUBPARTITIONS); + setState(2024); + ((PartitionDefinitionsContext)_localctx).subCount = decimalLiteral(); + } + } + + } + } + + setState(2040); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) { + case 1: + { + setState(2029); + match(LR_BRACKET); + setState(2030); + partitionDefinition(); + setState(2035); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2031); + match(COMMA); + setState(2032); + partitionDefinition(); + } + } + setState(2037); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2038); + match(RR_BRACKET); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PartitionFunctionDefinitionContext extends ParserRuleContext { + public PartitionFunctionDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_partitionFunctionDefinition; } + + public PartitionFunctionDefinitionContext() { } + public void copyFrom(PartitionFunctionDefinitionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionFunctionKeyContext extends PartitionFunctionDefinitionContext { + public Token algType; + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode LINEAR() { return getToken(MySqlParser.LINEAR, 0); } + public TerminalNode ALGORITHM() { return getToken(MySqlParser.ALGORITHM, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode TWO_DECIMAL() { return getToken(MySqlParser.TWO_DECIMAL, 0); } + public PartitionFunctionKeyContext(PartitionFunctionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionFunctionKey(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionFunctionKey(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionFunctionHashContext extends PartitionFunctionDefinitionContext { + public TerminalNode HASH() { return getToken(MySqlParser.HASH, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode LINEAR() { return getToken(MySqlParser.LINEAR, 0); } + public PartitionFunctionHashContext(PartitionFunctionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionFunctionHash(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionFunctionHash(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionFunctionListContext extends PartitionFunctionDefinitionContext { + public TerminalNode LIST() { return getToken(MySqlParser.LIST, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public PartitionFunctionListContext(PartitionFunctionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionFunctionList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionFunctionList(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionFunctionRangeContext extends PartitionFunctionDefinitionContext { + public TerminalNode RANGE() { return getToken(MySqlParser.RANGE, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public PartitionFunctionRangeContext(PartitionFunctionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionFunctionRange(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionFunctionRange(this); + } + } + + public final PartitionFunctionDefinitionContext partitionFunctionDefinition() throws RecognitionException { + PartitionFunctionDefinitionContext _localctx = new PartitionFunctionDefinitionContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_partitionFunctionDefinition); + int _la; + try { + setState(2088); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,239,_ctx) ) { + case 1: + _localctx = new PartitionFunctionHashContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(2043); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LINEAR) { + { + setState(2042); + match(LINEAR); + } + } + + setState(2045); + match(HASH); + setState(2046); + match(LR_BRACKET); + setState(2047); + expression(0); + setState(2048); + match(RR_BRACKET); + } + break; + case 2: + _localctx = new PartitionFunctionKeyContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(2051); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LINEAR) { + { + setState(2050); + match(LINEAR); + } + } + + setState(2053); + match(KEY); + setState(2057); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALGORITHM) { + { + setState(2054); + match(ALGORITHM); + setState(2055); + match(EQUAL_SYMBOL); + setState(2056); + ((PartitionFunctionKeyContext)_localctx).algType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ONE_DECIMAL || _la==TWO_DECIMAL) ) { + ((PartitionFunctionKeyContext)_localctx).algType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2059); + match(LR_BRACKET); + setState(2061); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2060); + uidList(); + } + } + + setState(2063); + match(RR_BRACKET); + } + break; + case 3: + _localctx = new PartitionFunctionRangeContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(2064); + match(RANGE); + setState(2074); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LR_BRACKET: + { + setState(2065); + match(LR_BRACKET); + setState(2066); + expression(0); + setState(2067); + match(RR_BRACKET); + } + break; + case COLUMNS: + { + setState(2069); + match(COLUMNS); + setState(2070); + match(LR_BRACKET); + setState(2071); + uidList(); + setState(2072); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 4: + _localctx = new PartitionFunctionListContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(2076); + match(LIST); + setState(2086); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LR_BRACKET: + { + setState(2077); + match(LR_BRACKET); + setState(2078); + expression(0); + setState(2079); + match(RR_BRACKET); + } + break; + case COLUMNS: + { + setState(2081); + match(COLUMNS); + setState(2082); + match(LR_BRACKET); + setState(2083); + uidList(); + setState(2084); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SubpartitionFunctionDefinitionContext extends ParserRuleContext { + public SubpartitionFunctionDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_subpartitionFunctionDefinition; } + + public SubpartitionFunctionDefinitionContext() { } + public void copyFrom(SubpartitionFunctionDefinitionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SubPartitionFunctionHashContext extends SubpartitionFunctionDefinitionContext { + public TerminalNode HASH() { return getToken(MySqlParser.HASH, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode LINEAR() { return getToken(MySqlParser.LINEAR, 0); } + public SubPartitionFunctionHashContext(SubpartitionFunctionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubPartitionFunctionHash(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubPartitionFunctionHash(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SubPartitionFunctionKeyContext extends SubpartitionFunctionDefinitionContext { + public Token algType; + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode LINEAR() { return getToken(MySqlParser.LINEAR, 0); } + public TerminalNode ALGORITHM() { return getToken(MySqlParser.ALGORITHM, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode TWO_DECIMAL() { return getToken(MySqlParser.TWO_DECIMAL, 0); } + public SubPartitionFunctionKeyContext(SubpartitionFunctionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubPartitionFunctionKey(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubPartitionFunctionKey(this); + } + } + + public final SubpartitionFunctionDefinitionContext subpartitionFunctionDefinition() throws RecognitionException { + SubpartitionFunctionDefinitionContext _localctx = new SubpartitionFunctionDefinitionContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_subpartitionFunctionDefinition); + int _la; + try { + setState(2111); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,243,_ctx) ) { + case 1: + _localctx = new SubPartitionFunctionHashContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(2091); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LINEAR) { + { + setState(2090); + match(LINEAR); + } + } + + setState(2093); + match(HASH); + setState(2094); + match(LR_BRACKET); + setState(2095); + expression(0); + setState(2096); + match(RR_BRACKET); + } + break; + case 2: + _localctx = new SubPartitionFunctionKeyContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(2099); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LINEAR) { + { + setState(2098); + match(LINEAR); + } + } + + setState(2101); + match(KEY); + setState(2105); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALGORITHM) { + { + setState(2102); + match(ALGORITHM); + setState(2103); + match(EQUAL_SYMBOL); + setState(2104); + ((SubPartitionFunctionKeyContext)_localctx).algType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ONE_DECIMAL || _la==TWO_DECIMAL) ) { + ((SubPartitionFunctionKeyContext)_localctx).algType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2107); + match(LR_BRACKET); + setState(2108); + uidList(); + setState(2109); + match(RR_BRACKET); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PartitionDefinitionContext extends ParserRuleContext { + public PartitionDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_partitionDefinition; } + + public PartitionDefinitionContext() { } + public void copyFrom(PartitionDefinitionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionComparisonContext extends PartitionDefinitionContext { + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode VALUES() { return getToken(MySqlParser.VALUES, 0); } + public TerminalNode LESS() { return getToken(MySqlParser.LESS, 0); } + public TerminalNode THAN() { return getToken(MySqlParser.THAN, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List partitionDefinerAtom() { + return getRuleContexts(PartitionDefinerAtomContext.class); + } + public PartitionDefinerAtomContext partitionDefinerAtom(int i) { + return getRuleContext(PartitionDefinerAtomContext.class,i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public List partitionOption() { + return getRuleContexts(PartitionOptionContext.class); + } + public PartitionOptionContext partitionOption(int i) { + return getRuleContext(PartitionOptionContext.class,i); + } + public List subpartitionDefinition() { + return getRuleContexts(SubpartitionDefinitionContext.class); + } + public SubpartitionDefinitionContext subpartitionDefinition(int i) { + return getRuleContext(SubpartitionDefinitionContext.class,i); + } + public PartitionComparisonContext(PartitionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionComparison(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionComparison(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionListAtomContext extends PartitionDefinitionContext { + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode VALUES() { return getToken(MySqlParser.VALUES, 0); } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List partitionDefinerAtom() { + return getRuleContexts(PartitionDefinerAtomContext.class); + } + public PartitionDefinerAtomContext partitionDefinerAtom(int i) { + return getRuleContext(PartitionDefinerAtomContext.class,i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public List partitionOption() { + return getRuleContexts(PartitionOptionContext.class); + } + public PartitionOptionContext partitionOption(int i) { + return getRuleContext(PartitionOptionContext.class,i); + } + public List subpartitionDefinition() { + return getRuleContexts(SubpartitionDefinitionContext.class); + } + public SubpartitionDefinitionContext subpartitionDefinition(int i) { + return getRuleContext(SubpartitionDefinitionContext.class,i); + } + public PartitionListAtomContext(PartitionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionListAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionListAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionListVectorContext extends PartitionDefinitionContext { + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode VALUES() { return getToken(MySqlParser.VALUES, 0); } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List partitionDefinerVector() { + return getRuleContexts(PartitionDefinerVectorContext.class); + } + public PartitionDefinerVectorContext partitionDefinerVector(int i) { + return getRuleContext(PartitionDefinerVectorContext.class,i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public List partitionOption() { + return getRuleContexts(PartitionOptionContext.class); + } + public PartitionOptionContext partitionOption(int i) { + return getRuleContext(PartitionOptionContext.class,i); + } + public List subpartitionDefinition() { + return getRuleContexts(SubpartitionDefinitionContext.class); + } + public SubpartitionDefinitionContext subpartitionDefinition(int i) { + return getRuleContext(SubpartitionDefinitionContext.class,i); + } + public PartitionListVectorContext(PartitionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionListVector(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionListVector(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionSimpleContext extends PartitionDefinitionContext { + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List partitionOption() { + return getRuleContexts(PartitionOptionContext.class); + } + public PartitionOptionContext partitionOption(int i) { + return getRuleContext(PartitionOptionContext.class,i); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List subpartitionDefinition() { + return getRuleContexts(SubpartitionDefinitionContext.class); + } + public SubpartitionDefinitionContext subpartitionDefinition(int i) { + return getRuleContext(SubpartitionDefinitionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public PartitionSimpleContext(PartitionDefinitionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionSimple(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionSimple(this); + } + } + + public final PartitionDefinitionContext partitionDefinition() throws RecognitionException { + PartitionDefinitionContext _localctx = new PartitionDefinitionContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_partitionDefinition); + int _la; + try { + setState(2259); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) { + case 1: + _localctx = new PartitionComparisonContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(2113); + match(PARTITION); + setState(2114); + uid(); + setState(2115); + match(VALUES); + setState(2116); + match(LESS); + setState(2117); + match(THAN); + setState(2118); + match(LR_BRACKET); + setState(2119); + partitionDefinerAtom(); + setState(2124); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2120); + match(COMMA); + setState(2121); + partitionDefinerAtom(); + } + } + setState(2126); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2127); + match(RR_BRACKET); + setState(2131); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DEFAULT || _la==INDEX || ((((_la - 369)) & ~0x3f) == 0 && ((1L << (_la - 369)) & 2199024304129L) != 0) || ((((_la - 501)) & ~0x3f) == 0 && ((1L << (_la - 501)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) { + { + { + setState(2128); + partitionOption(); + } + } + setState(2133); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2145); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(2134); + match(LR_BRACKET); + setState(2135); + subpartitionDefinition(); + setState(2140); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2136); + match(COMMA); + setState(2137); + subpartitionDefinition(); + } + } + setState(2142); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2143); + match(RR_BRACKET); + } + } + + } + break; + case 2: + _localctx = new PartitionComparisonContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(2147); + match(PARTITION); + setState(2148); + uid(); + setState(2149); + match(VALUES); + setState(2150); + match(LESS); + setState(2151); + match(THAN); + setState(2152); + partitionDefinerAtom(); + setState(2156); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DEFAULT || _la==INDEX || ((((_la - 369)) & ~0x3f) == 0 && ((1L << (_la - 369)) & 2199024304129L) != 0) || ((((_la - 501)) & ~0x3f) == 0 && ((1L << (_la - 501)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) { + { + { + setState(2153); + partitionOption(); + } + } + setState(2158); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2170); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(2159); + match(LR_BRACKET); + setState(2160); + subpartitionDefinition(); + setState(2165); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2161); + match(COMMA); + setState(2162); + subpartitionDefinition(); + } + } + setState(2167); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2168); + match(RR_BRACKET); + } + } + + } + break; + case 3: + _localctx = new PartitionListAtomContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(2172); + match(PARTITION); + setState(2173); + uid(); + setState(2174); + match(VALUES); + setState(2175); + match(IN); + setState(2176); + match(LR_BRACKET); + setState(2177); + partitionDefinerAtom(); + setState(2182); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2178); + match(COMMA); + setState(2179); + partitionDefinerAtom(); + } + } + setState(2184); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2185); + match(RR_BRACKET); + setState(2189); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DEFAULT || _la==INDEX || ((((_la - 369)) & ~0x3f) == 0 && ((1L << (_la - 369)) & 2199024304129L) != 0) || ((((_la - 501)) & ~0x3f) == 0 && ((1L << (_la - 501)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) { + { + { + setState(2186); + partitionOption(); + } + } + setState(2191); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2203); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(2192); + match(LR_BRACKET); + setState(2193); + subpartitionDefinition(); + setState(2198); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2194); + match(COMMA); + setState(2195); + subpartitionDefinition(); + } + } + setState(2200); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2201); + match(RR_BRACKET); + } + } + + } + break; + case 4: + _localctx = new PartitionListVectorContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(2205); + match(PARTITION); + setState(2206); + uid(); + setState(2207); + match(VALUES); + setState(2208); + match(IN); + setState(2209); + match(LR_BRACKET); + setState(2210); + partitionDefinerVector(); + setState(2215); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2211); + match(COMMA); + setState(2212); + partitionDefinerVector(); + } + } + setState(2217); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2218); + match(RR_BRACKET); + setState(2222); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DEFAULT || _la==INDEX || ((((_la - 369)) & ~0x3f) == 0 && ((1L << (_la - 369)) & 2199024304129L) != 0) || ((((_la - 501)) & ~0x3f) == 0 && ((1L << (_la - 501)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) { + { + { + setState(2219); + partitionOption(); + } + } + setState(2224); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2236); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(2225); + match(LR_BRACKET); + setState(2226); + subpartitionDefinition(); + setState(2231); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2227); + match(COMMA); + setState(2228); + subpartitionDefinition(); + } + } + setState(2233); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2234); + match(RR_BRACKET); + } + } + + } + break; + case 5: + _localctx = new PartitionSimpleContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(2238); + match(PARTITION); + setState(2239); + uid(); + setState(2243); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DEFAULT || _la==INDEX || ((((_la - 369)) & ~0x3f) == 0 && ((1L << (_la - 369)) & 2199024304129L) != 0) || ((((_la - 501)) & ~0x3f) == 0 && ((1L << (_la - 501)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) { + { + { + setState(2240); + partitionOption(); + } + } + setState(2245); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2257); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(2246); + match(LR_BRACKET); + setState(2247); + subpartitionDefinition(); + setState(2252); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2248); + match(COMMA); + setState(2249); + subpartitionDefinition(); + } + } + setState(2254); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2255); + match(RR_BRACKET); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PartitionDefinerAtomContext extends ParserRuleContext { + public ConstantContext constant() { + return getRuleContext(ConstantContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode MAXVALUE() { return getToken(MySqlParser.MAXVALUE, 0); } + public PartitionDefinerAtomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_partitionDefinerAtom; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionDefinerAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionDefinerAtom(this); + } + } + + public final PartitionDefinerAtomContext partitionDefinerAtom() throws RecognitionException { + PartitionDefinerAtomContext _localctx = new PartitionDefinerAtomContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_partitionDefinerAtom); + try { + setState(2264); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,263,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2261); + constant(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2262); + expression(0); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2263); + match(MAXVALUE); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PartitionDefinerVectorContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List partitionDefinerAtom() { + return getRuleContexts(PartitionDefinerAtomContext.class); + } + public PartitionDefinerAtomContext partitionDefinerAtom(int i) { + return getRuleContext(PartitionDefinerAtomContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public PartitionDefinerVectorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_partitionDefinerVector; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionDefinerVector(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionDefinerVector(this); + } + } + + public final PartitionDefinerVectorContext partitionDefinerVector() throws RecognitionException { + PartitionDefinerVectorContext _localctx = new PartitionDefinerVectorContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_partitionDefinerVector); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2266); + match(LR_BRACKET); + setState(2267); + partitionDefinerAtom(); + setState(2270); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2268); + match(COMMA); + setState(2269); + partitionDefinerAtom(); + } + } + setState(2272); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==COMMA ); + setState(2274); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SubpartitionDefinitionContext extends ParserRuleContext { + public TerminalNode SUBPARTITION() { return getToken(MySqlParser.SUBPARTITION, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List partitionOption() { + return getRuleContexts(PartitionOptionContext.class); + } + public PartitionOptionContext partitionOption(int i) { + return getRuleContext(PartitionOptionContext.class,i); + } + public SubpartitionDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_subpartitionDefinition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubpartitionDefinition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubpartitionDefinition(this); + } + } + + public final SubpartitionDefinitionContext subpartitionDefinition() throws RecognitionException { + SubpartitionDefinitionContext _localctx = new SubpartitionDefinitionContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_subpartitionDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2276); + match(SUBPARTITION); + setState(2277); + uid(); + setState(2281); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DEFAULT || _la==INDEX || ((((_la - 369)) & ~0x3f) == 0 && ((1L << (_la - 369)) & 2199024304129L) != 0) || ((((_la - 501)) & ~0x3f) == 0 && ((1L << (_la - 501)) & 268436481L) != 0) || _la==STORAGE || _la==TABLESPACE) { + { + { + setState(2278); + partitionOption(); + } + } + setState(2283); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PartitionOptionContext extends ParserRuleContext { + public PartitionOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_partitionOption; } + + public PartitionOptionContext() { } + public void copyFrom(PartitionOptionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionOptionCommentContext extends PartitionOptionContext { + public Token comment; + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public PartitionOptionCommentContext(PartitionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionComment(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionComment(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionOptionNodeGroupContext extends PartitionOptionContext { + public UidContext nodegroup; + public TerminalNode NODEGROUP() { return getToken(MySqlParser.NODEGROUP, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public PartitionOptionNodeGroupContext(PartitionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionNodeGroup(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionNodeGroup(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionOptionIndexDirectoryContext extends PartitionOptionContext { + public Token indexDirectory; + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public PartitionOptionIndexDirectoryContext(PartitionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionIndexDirectory(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionIndexDirectory(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionOptionMaxRowsContext extends PartitionOptionContext { + public DecimalLiteralContext maxRows; + public TerminalNode MAX_ROWS() { return getToken(MySqlParser.MAX_ROWS, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public PartitionOptionMaxRowsContext(PartitionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionMaxRows(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionMaxRows(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionOptionTablespaceContext extends PartitionOptionContext { + public UidContext tablespace; + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public PartitionOptionTablespaceContext(PartitionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionTablespace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionTablespace(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionOptionEngineContext extends PartitionOptionContext { + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode STORAGE() { return getToken(MySqlParser.STORAGE, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public PartitionOptionEngineContext(PartitionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionEngine(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionEngine(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionOptionMinRowsContext extends PartitionOptionContext { + public DecimalLiteralContext minRows; + public TerminalNode MIN_ROWS() { return getToken(MySqlParser.MIN_ROWS, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public PartitionOptionMinRowsContext(PartitionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionMinRows(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionMinRows(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PartitionOptionDataDirectoryContext extends PartitionOptionContext { + public Token dataDirectory; + public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); } + public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public PartitionOptionDataDirectoryContext(PartitionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionOptionDataDirectory(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionOptionDataDirectory(this); + } + } + + public final PartitionOptionContext partitionOption() throws RecognitionException { + PartitionOptionContext _localctx = new PartitionOptionContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_partitionOption); + int _la; + try { + setState(2332); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEFAULT: + case ENGINE: + case STORAGE: + _localctx = new PartitionOptionEngineContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(2285); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(2284); + match(DEFAULT); + } + } + + setState(2288); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STORAGE) { + { + setState(2287); + match(STORAGE); + } + } + + setState(2290); + match(ENGINE); + setState(2292); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2291); + match(EQUAL_SYMBOL); + } + } + + setState(2294); + engineName(); + } + break; + case COMMENT: + _localctx = new PartitionOptionCommentContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(2295); + match(COMMENT); + setState(2297); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2296); + match(EQUAL_SYMBOL); + } + } + + setState(2299); + ((PartitionOptionCommentContext)_localctx).comment = match(STRING_LITERAL); + } + break; + case DATA: + _localctx = new PartitionOptionDataDirectoryContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(2300); + match(DATA); + setState(2301); + match(DIRECTORY); + setState(2303); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2302); + match(EQUAL_SYMBOL); + } + } + + setState(2305); + ((PartitionOptionDataDirectoryContext)_localctx).dataDirectory = match(STRING_LITERAL); + } + break; + case INDEX: + _localctx = new PartitionOptionIndexDirectoryContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(2306); + match(INDEX); + setState(2307); + match(DIRECTORY); + setState(2309); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2308); + match(EQUAL_SYMBOL); + } + } + + setState(2311); + ((PartitionOptionIndexDirectoryContext)_localctx).indexDirectory = match(STRING_LITERAL); + } + break; + case MAX_ROWS: + _localctx = new PartitionOptionMaxRowsContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(2312); + match(MAX_ROWS); + setState(2314); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2313); + match(EQUAL_SYMBOL); + } + } + + setState(2316); + ((PartitionOptionMaxRowsContext)_localctx).maxRows = decimalLiteral(); + } + break; + case MIN_ROWS: + _localctx = new PartitionOptionMinRowsContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(2317); + match(MIN_ROWS); + setState(2319); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2318); + match(EQUAL_SYMBOL); + } + } + + setState(2321); + ((PartitionOptionMinRowsContext)_localctx).minRows = decimalLiteral(); + } + break; + case TABLESPACE: + _localctx = new PartitionOptionTablespaceContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(2322); + match(TABLESPACE); + setState(2324); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2323); + match(EQUAL_SYMBOL); + } + } + + setState(2326); + ((PartitionOptionTablespaceContext)_localctx).tablespace = uid(); + } + break; + case NODEGROUP: + _localctx = new PartitionOptionNodeGroupContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(2327); + match(NODEGROUP); + setState(2329); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2328); + match(EQUAL_SYMBOL); + } + } + + setState(2331); + ((PartitionOptionNodeGroupContext)_localctx).nodegroup = uid(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterDatabaseContext extends ParserRuleContext { + public AlterDatabaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterDatabase; } + + public AlterDatabaseContext() { } + public void copyFrom(AlterDatabaseContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterUpgradeNameContext extends AlterDatabaseContext { + public Token dbFormat; + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode UPGRADE() { return getToken(MySqlParser.UPGRADE, 0); } + public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); } + public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); } + public TerminalNode NAME() { return getToken(MySqlParser.NAME, 0); } + public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); } + public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); } + public AlterUpgradeNameContext(AlterDatabaseContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterUpgradeName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterUpgradeName(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterSimpleDatabaseContext extends AlterDatabaseContext { + public Token dbFormat; + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); } + public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List createDatabaseOption() { + return getRuleContexts(CreateDatabaseOptionContext.class); + } + public CreateDatabaseOptionContext createDatabaseOption(int i) { + return getRuleContext(CreateDatabaseOptionContext.class,i); + } + public AlterSimpleDatabaseContext(AlterDatabaseContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterSimpleDatabase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterSimpleDatabase(this); + } + } + + public final AlterDatabaseContext alterDatabase() throws RecognitionException { + AlterDatabaseContext _localctx = new AlterDatabaseContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_alterDatabase); + int _la; + try { + setState(2352); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,279,_ctx) ) { + case 1: + _localctx = new AlterSimpleDatabaseContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(2334); + match(ALTER); + setState(2335); + ((AlterSimpleDatabaseContext)_localctx).dbFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DATABASE || _la==SCHEMA) ) { + ((AlterSimpleDatabaseContext)_localctx).dbFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2337); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,277,_ctx) ) { + case 1: + { + setState(2336); + uid(); + } + break; + } + setState(2340); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(2339); + createDatabaseOption(); + } + } + setState(2342); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 8796428566528L) != 0) || _la==READ || _la==CHAR || _la==ENCRYPTION || _la==CHARSET ); + } + break; + case 2: + _localctx = new AlterUpgradeNameContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(2344); + match(ALTER); + setState(2345); + ((AlterUpgradeNameContext)_localctx).dbFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DATABASE || _la==SCHEMA) ) { + ((AlterUpgradeNameContext)_localctx).dbFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2346); + uid(); + setState(2347); + match(UPGRADE); + setState(2348); + match(DATA); + setState(2349); + match(DIRECTORY); + setState(2350); + match(NAME); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterEventContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode EVENT() { return getToken(MySqlParser.EVENT, 0); } + public List fullId() { + return getRuleContexts(FullIdContext.class); + } + public FullIdContext fullId(int i) { + return getRuleContext(FullIdContext.class,i); + } + public OwnerStatementContext ownerStatement() { + return getRuleContext(OwnerStatementContext.class,0); + } + public List ON() { return getTokens(MySqlParser.ON); } + public TerminalNode ON(int i) { + return getToken(MySqlParser.ON, i); + } + public TerminalNode SCHEDULE() { return getToken(MySqlParser.SCHEDULE, 0); } + public ScheduleExpressionContext scheduleExpression() { + return getRuleContext(ScheduleExpressionContext.class,0); + } + public TerminalNode COMPLETION() { return getToken(MySqlParser.COMPLETION, 0); } + public TerminalNode PRESERVE() { return getToken(MySqlParser.PRESERVE, 0); } + public TerminalNode RENAME() { return getToken(MySqlParser.RENAME, 0); } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public EnableTypeContext enableType() { + return getRuleContext(EnableTypeContext.class,0); + } + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode DO() { return getToken(MySqlParser.DO, 0); } + public RoutineBodyContext routineBody() { + return getRuleContext(RoutineBodyContext.class,0); + } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public AlterEventContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterEvent; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterEvent(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterEvent(this); + } + } + + public final AlterEventContext alterEvent() throws RecognitionException { + AlterEventContext _localctx = new AlterEventContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_alterEvent); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2354); + match(ALTER); + setState(2356); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFINER) { + { + setState(2355); + ownerStatement(); + } + } + + setState(2358); + match(EVENT); + setState(2359); + fullId(); + setState(2363); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,281,_ctx) ) { + case 1: + { + setState(2360); + match(ON); + setState(2361); + match(SCHEDULE); + setState(2362); + scheduleExpression(); + } + break; + } + setState(2371); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ON) { + { + setState(2365); + match(ON); + setState(2366); + match(COMPLETION); + setState(2368); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(2367); + match(NOT); + } + } + + setState(2370); + match(PRESERVE); + } + } + + setState(2376); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,284,_ctx) ) { + case 1: + { + setState(2373); + match(RENAME); + setState(2374); + match(TO); + setState(2375); + fullId(); + } + break; + } + setState(2379); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DISABLE || _la==ENABLE) { + { + setState(2378); + enableType(); + } + } + + setState(2383); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMENT) { + { + setState(2381); + match(COMMENT); + setState(2382); + match(STRING_LITERAL); + } + } + + setState(2387); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) { + case 1: + { + setState(2385); + match(DO); + setState(2386); + routineBody(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterFunctionContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public List routineOption() { + return getRuleContexts(RoutineOptionContext.class); + } + public RoutineOptionContext routineOption(int i) { + return getRuleContext(RoutineOptionContext.class,i); + } + public AlterFunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterFunction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterFunction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterFunction(this); + } + } + + public final AlterFunctionContext alterFunction() throws RecognitionException { + AlterFunctionContext _localctx = new AlterFunctionContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_alterFunction); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2389); + match(ALTER); + setState(2390); + match(FUNCTION); + setState(2391); + fullId(); + setState(2395); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DETERMINISTIC || ((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & 281474985099269L) != 0) || _la==COMMENT || _la==CONTAINS || _la==LANGUAGE || _la==NO) { + { + { + setState(2392); + routineOption(); + } + } + setState(2397); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterInstanceContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode INSTANCE() { return getToken(MySqlParser.INSTANCE, 0); } + public TerminalNode ROTATE() { return getToken(MySqlParser.ROTATE, 0); } + public TerminalNode INNODB() { return getToken(MySqlParser.INNODB, 0); } + public TerminalNode MASTER() { return getToken(MySqlParser.MASTER, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public AlterInstanceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterInstance; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterInstance(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterInstance(this); + } + } + + public final AlterInstanceContext alterInstance() throws RecognitionException { + AlterInstanceContext _localctx = new AlterInstanceContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_alterInstance); + try { + enterOuterAlt(_localctx, 1); + { + setState(2398); + match(ALTER); + setState(2399); + match(INSTANCE); + setState(2400); + match(ROTATE); + setState(2401); + match(INNODB); + setState(2402); + match(MASTER); + setState(2403); + match(KEY); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterLogfileGroupContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode LOGFILE() { return getToken(MySqlParser.LOGFILE, 0); } + public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode UNDOFILE() { return getToken(MySqlParser.UNDOFILE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public TerminalNode INITIAL_SIZE() { return getToken(MySqlParser.INITIAL_SIZE, 0); } + public FileSizeLiteralContext fileSizeLiteral() { + return getRuleContext(FileSizeLiteralContext.class,0); + } + public TerminalNode WAIT() { return getToken(MySqlParser.WAIT, 0); } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public AlterLogfileGroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterLogfileGroup; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterLogfileGroup(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterLogfileGroup(this); + } + } + + public final AlterLogfileGroupContext alterLogfileGroup() throws RecognitionException { + AlterLogfileGroupContext _localctx = new AlterLogfileGroupContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_alterLogfileGroup); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2405); + match(ALTER); + setState(2406); + match(LOGFILE); + setState(2407); + match(GROUP); + setState(2408); + uid(); + setState(2409); + match(ADD); + setState(2410); + match(UNDOFILE); + setState(2411); + match(STRING_LITERAL); + setState(2417); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INITIAL_SIZE) { + { + setState(2412); + match(INITIAL_SIZE); + setState(2414); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2413); + match(EQUAL_SYMBOL); + } + } + + setState(2416); + fileSizeLiteral(); + } + } + + setState(2420); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WAIT) { + { + setState(2419); + match(WAIT); + } + } + + setState(2422); + match(ENGINE); + setState(2424); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2423); + match(EQUAL_SYMBOL); + } + } + + setState(2426); + engineName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterProcedureContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public List routineOption() { + return getRuleContexts(RoutineOptionContext.class); + } + public RoutineOptionContext routineOption(int i) { + return getRuleContext(RoutineOptionContext.class,i); + } + public AlterProcedureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterProcedure; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterProcedure(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterProcedure(this); + } + } + + public final AlterProcedureContext alterProcedure() throws RecognitionException { + AlterProcedureContext _localctx = new AlterProcedureContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_alterProcedure); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2428); + match(ALTER); + setState(2429); + match(PROCEDURE); + setState(2430); + fullId(); + setState(2434); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DETERMINISTIC || ((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & 281474985099269L) != 0) || _la==COMMENT || _la==CONTAINS || _la==LANGUAGE || _la==NO) { + { + { + setState(2431); + routineOption(); + } + } + setState(2436); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterServerContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode SERVER() { return getToken(MySqlParser.SERVER, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode OPTIONS() { return getToken(MySqlParser.OPTIONS, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List serverOption() { + return getRuleContexts(ServerOptionContext.class); + } + public ServerOptionContext serverOption(int i) { + return getRuleContext(ServerOptionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AlterServerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterServer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterServer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterServer(this); + } + } + + public final AlterServerContext alterServer() throws RecognitionException { + AlterServerContext _localctx = new AlterServerContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_alterServer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2437); + match(ALTER); + setState(2438); + match(SERVER); + setState(2439); + uid(); + setState(2440); + match(OPTIONS); + setState(2441); + match(LR_BRACKET); + setState(2442); + serverOption(); + setState(2447); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2443); + match(COMMA); + setState(2444); + serverOption(); + } + } + setState(2449); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2450); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterTableContext extends ParserRuleContext { + public Token intimeAction; + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); } + public WaitNowaitClauseContext waitNowaitClause() { + return getRuleContext(WaitNowaitClauseContext.class,0); + } + public List alterSpecification() { + return getRuleContexts(AlterSpecificationContext.class); + } + public AlterSpecificationContext alterSpecification(int i) { + return getRuleContext(AlterSpecificationContext.class,i); + } + public PartitionDefinitionsContext partitionDefinitions() { + return getRuleContext(PartitionDefinitionsContext.class,0); + } + public TerminalNode ONLINE() { return getToken(MySqlParser.ONLINE, 0); } + public TerminalNode OFFLINE() { return getToken(MySqlParser.OFFLINE, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AlterTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterTable(this); + } + } + + public final AlterTableContext alterTable() throws RecognitionException { + AlterTableContext _localctx = new AlterTableContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_alterTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2452); + match(ALTER); + setState(2454); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OFFLINE || _la==ONLINE) { + { + setState(2453); + ((AlterTableContext)_localctx).intimeAction = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==OFFLINE || _la==ONLINE) ) { + ((AlterTableContext)_localctx).intimeAction = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2457); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE) { + { + setState(2456); + match(IGNORE); + } + } + + setState(2459); + match(TABLE); + setState(2460); + tableName(); + setState(2462); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOWAIT || _la==WAIT) { + { + setState(2461); + waitNowaitClause(); + } + } + + setState(2472); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,299,_ctx) ) { + case 1: + { + setState(2464); + alterSpecification(); + setState(2469); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2465); + match(COMMA); + setState(2466); + alterSpecification(); + } + } + setState(2471); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + setState(2475); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(2474); + partitionDefinitions(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterTablespaceContext extends ParserRuleContext { + public Token objectAction; + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode DATAFILE() { return getToken(MySqlParser.DATAFILE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode INITIAL_SIZE() { return getToken(MySqlParser.INITIAL_SIZE, 0); } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public FileSizeLiteralContext fileSizeLiteral() { + return getRuleContext(FileSizeLiteralContext.class,0); + } + public TerminalNode WAIT() { return getToken(MySqlParser.WAIT, 0); } + public AlterTablespaceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterTablespace; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterTablespace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterTablespace(this); + } + } + + public final AlterTablespaceContext alterTablespace() throws RecognitionException { + AlterTablespaceContext _localctx = new AlterTablespaceContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_alterTablespace); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2477); + match(ALTER); + setState(2478); + match(TABLESPACE); + setState(2479); + uid(); + setState(2480); + ((AlterTablespaceContext)_localctx).objectAction = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ADD || _la==DROP) ) { + ((AlterTablespaceContext)_localctx).objectAction = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2481); + match(DATAFILE); + setState(2482); + match(STRING_LITERAL); + setState(2486); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INITIAL_SIZE) { + { + setState(2483); + match(INITIAL_SIZE); + setState(2484); + match(EQUAL_SYMBOL); + setState(2485); + fileSizeLiteral(); + } + } + + setState(2489); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WAIT) { + { + setState(2488); + match(WAIT); + } + } + + setState(2491); + match(ENGINE); + setState(2493); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2492); + match(EQUAL_SYMBOL); + } + } + + setState(2495); + engineName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterViewContext extends ParserRuleContext { + public Token algType; + public Token secContext; + public Token checkOpt; + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode VIEW() { return getToken(MySqlParser.VIEW, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public TerminalNode ALGORITHM() { return getToken(MySqlParser.ALGORITHM, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public OwnerStatementContext ownerStatement() { + return getRuleContext(OwnerStatementContext.class,0); + } + public TerminalNode SQL() { return getToken(MySqlParser.SQL, 0); } + public TerminalNode SECURITY() { return getToken(MySqlParser.SECURITY, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); } + public TerminalNode OPTION() { return getToken(MySqlParser.OPTION, 0); } + public TerminalNode UNDEFINED() { return getToken(MySqlParser.UNDEFINED, 0); } + public TerminalNode MERGE() { return getToken(MySqlParser.MERGE, 0); } + public TerminalNode TEMPTABLE() { return getToken(MySqlParser.TEMPTABLE, 0); } + public TerminalNode DEFINER() { return getToken(MySqlParser.DEFINER, 0); } + public TerminalNode INVOKER() { return getToken(MySqlParser.INVOKER, 0); } + public TerminalNode CASCADED() { return getToken(MySqlParser.CASCADED, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public AlterViewContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterView; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterView(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterView(this); + } + } + + public final AlterViewContext alterView() throws RecognitionException { + AlterViewContext _localctx = new AlterViewContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_alterView); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2497); + match(ALTER); + setState(2501); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALGORITHM) { + { + setState(2498); + match(ALGORITHM); + setState(2499); + match(EQUAL_SYMBOL); + setState(2500); + ((AlterViewContext)_localctx).algType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==MERGE || _la==TEMPTABLE || _la==UNDEFINED) ) { + ((AlterViewContext)_localctx).algType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2504); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFINER) { + { + setState(2503); + ownerStatement(); + } + } + + setState(2509); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SQL) { + { + setState(2506); + match(SQL); + setState(2507); + match(SECURITY); + setState(2508); + ((AlterViewContext)_localctx).secContext = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFINER || _la==INVOKER) ) { + ((AlterViewContext)_localctx).secContext = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2511); + match(VIEW); + setState(2512); + fullId(); + setState(2517); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(2513); + match(LR_BRACKET); + setState(2514); + uidList(); + setState(2515); + match(RR_BRACKET); + } + } + + setState(2519); + match(AS); + setState(2520); + selectStatement(); + setState(2527); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,309,_ctx) ) { + case 1: + { + setState(2521); + match(WITH); + setState(2523); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADED || _la==LOCAL) { + { + setState(2522); + ((AlterViewContext)_localctx).checkOpt = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CASCADED || _la==LOCAL) ) { + ((AlterViewContext)_localctx).checkOpt = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2525); + match(CHECK); + setState(2526); + match(OPTION); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterSpecificationContext extends ParserRuleContext { + public AlterSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterSpecification; } + + public AlterSpecificationContext() { } + public void copyFrom(AlterSpecificationContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAlterColumnDefaultContext extends AlterSpecificationContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode COLUMN() { return getToken(MySqlParser.COLUMN, 0); } + public TerminalNode VISIBLE() { return getToken(MySqlParser.VISIBLE, 0); } + public TerminalNode INVISIBLE() { return getToken(MySqlParser.INVISIBLE, 0); } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public AlterByAlterColumnDefaultContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAlterColumnDefault(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAlterColumnDefault(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDisableKeysContext extends AlterSpecificationContext { + public TerminalNode DISABLE() { return getToken(MySqlParser.DISABLE, 0); } + public TerminalNode KEYS() { return getToken(MySqlParser.KEYS, 0); } + public AlterByDisableKeysContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDisableKeys(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDisableKeys(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDefaultCharsetContext extends AlterSpecificationContext { + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public AlterByDefaultCharsetContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDefaultCharset(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDefaultCharset(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByRenameColumnContext extends AlterSpecificationContext { + public UidContext oldColumn; + public UidContext newColumn; + public TerminalNode RENAME() { return getToken(MySqlParser.RENAME, 0); } + public TerminalNode COLUMN() { return getToken(MySqlParser.COLUMN, 0); } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public AlterByRenameColumnContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByRenameColumn(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByRenameColumn(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByConvertCharsetContext extends AlterSpecificationContext { + public TerminalNode CONVERT() { return getToken(MySqlParser.CONVERT, 0); } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode CHARSET() { return getToken(MySqlParser.CHARSET, 0); } + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public AlterByConvertCharsetContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByConvertCharset(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByConvertCharset(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddForeignKeyContext extends AlterSpecificationContext { + public UidContext name; + public UidContext indexName; + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode FOREIGN() { return getToken(MySqlParser.FOREIGN, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public ReferenceDefinitionContext referenceDefinition() { + return getRuleContext(ReferenceDefinitionContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public AlterByAddForeignKeyContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddForeignKey(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddForeignKey(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByRenameIndexContext extends AlterSpecificationContext { + public Token indexFormat; + public TerminalNode RENAME() { return getToken(MySqlParser.RENAME, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public AlterByRenameIndexContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByRenameIndex(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByRenameIndex(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByRenameContext extends AlterSpecificationContext { + public Token renameFormat; + public TerminalNode RENAME() { return getToken(MySqlParser.RENAME, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public AlterByRenameContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByRename(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByRename(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByImportTablespaceContext extends AlterSpecificationContext { + public TerminalNode IMPORT() { return getToken(MySqlParser.IMPORT, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public AlterByImportTablespaceContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByImportTablespace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByImportTablespace(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddDefinitionsContext extends AlterSpecificationContext { + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List createDefinition() { + return getRuleContexts(CreateDefinitionContext.class); + } + public CreateDefinitionContext createDefinition(int i) { + return getRuleContext(CreateDefinitionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode COLUMN() { return getToken(MySqlParser.COLUMN, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AlterByAddDefinitionsContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddDefinitions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddDefinitions(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAlterCheckTableConstraintContext extends AlterSpecificationContext { + public UidContext name; + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public TerminalNode ENFORCED() { return getToken(MySqlParser.ENFORCED, 0); } + public AlterByAlterCheckTableConstraintContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAlterCheckTableConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAlterCheckTableConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDropConstraintCheckContext extends AlterSpecificationContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); } + public AlterByDropConstraintCheckContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDropConstraintCheck(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDropConstraintCheck(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddColumnsContext extends AlterSpecificationContext { + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public List columnDefinition() { + return getRuleContexts(ColumnDefinitionContext.class); + } + public ColumnDefinitionContext columnDefinition(int i) { + return getRuleContext(ColumnDefinitionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode COLUMN() { return getToken(MySqlParser.COLUMN, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AlterByAddColumnsContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddColumns(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddColumns(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAlterIndexVisibilityContext extends AlterSpecificationContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode VISIBLE() { return getToken(MySqlParser.VISIBLE, 0); } + public TerminalNode INVISIBLE() { return getToken(MySqlParser.INVISIBLE, 0); } + public AlterByAlterIndexVisibilityContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAlterIndexVisibility(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAlterIndexVisibility(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDropForeignKeyContext extends AlterSpecificationContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode FOREIGN() { return getToken(MySqlParser.FOREIGN, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public AlterByDropForeignKeyContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDropForeignKey(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDropForeignKey(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddCheckTableConstraintContext extends AlterSpecificationContext { + public UidContext name; + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public TerminalNode ENFORCED() { return getToken(MySqlParser.ENFORCED, 0); } + public AlterByAddCheckTableConstraintContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddCheckTableConstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddCheckTableConstraint(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterPartitionContext extends AlterSpecificationContext { + public AlterPartitionSpecificationContext alterPartitionSpecification() { + return getRuleContext(AlterPartitionSpecificationContext.class,0); + } + public AlterPartitionContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterPartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterPartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddIndexContext extends AlterSpecificationContext { + public Token indexFormat; + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public IndexTypeContext indexType() { + return getRuleContext(IndexTypeContext.class,0); + } + public List indexOption() { + return getRuleContexts(IndexOptionContext.class); + } + public IndexOptionContext indexOption(int i) { + return getRuleContext(IndexOptionContext.class,i); + } + public AlterByAddIndexContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddIndex(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddIndex(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDropColumnContext extends AlterSpecificationContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode COLUMN() { return getToken(MySqlParser.COLUMN, 0); } + public TerminalNode RESTRICT() { return getToken(MySqlParser.RESTRICT, 0); } + public AlterByDropColumnContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDropColumn(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDropColumn(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByChangeDefaultContext extends AlterSpecificationContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public DefaultValueContext defaultValue() { + return getRuleContext(DefaultValueContext.class,0); + } + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode COLUMN() { return getToken(MySqlParser.COLUMN, 0); } + public AlterByChangeDefaultContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByChangeDefault(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByChangeDefault(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByForceContext extends AlterSpecificationContext { + public TerminalNode FORCE() { return getToken(MySqlParser.FORCE, 0); } + public AlterByForceContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByForce(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByForce(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddSpecialIndexContext extends AlterSpecificationContext { + public Token keyType; + public Token indexFormat; + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public TerminalNode FULLTEXT() { return getToken(MySqlParser.FULLTEXT, 0); } + public TerminalNode SPATIAL() { return getToken(MySqlParser.SPATIAL, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List indexOption() { + return getRuleContexts(IndexOptionContext.class); + } + public IndexOptionContext indexOption(int i) { + return getRuleContext(IndexOptionContext.class,i); + } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public AlterByAddSpecialIndexContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddSpecialIndex(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddSpecialIndex(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByModifyColumnContext extends AlterSpecificationContext { + public TerminalNode MODIFY() { return getToken(MySqlParser.MODIFY, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public ColumnDefinitionContext columnDefinition() { + return getRuleContext(ColumnDefinitionContext.class,0); + } + public TerminalNode COLUMN() { return getToken(MySqlParser.COLUMN, 0); } + public TerminalNode FIRST() { return getToken(MySqlParser.FIRST, 0); } + public TerminalNode AFTER() { return getToken(MySqlParser.AFTER, 0); } + public AlterByModifyColumnContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByModifyColumn(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByModifyColumn(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByTableOptionContext extends AlterSpecificationContext { + public List tableOption() { + return getRuleContexts(TableOptionContext.class); + } + public TableOptionContext tableOption(int i) { + return getRuleContext(TableOptionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AlterByTableOptionContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByTableOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByTableOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDropPrimaryKeyContext extends AlterSpecificationContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode PRIMARY() { return getToken(MySqlParser.PRIMARY, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public AlterByDropPrimaryKeyContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDropPrimaryKey(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDropPrimaryKey(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByLockContext extends AlterSpecificationContext { + public Token lockType; + public TerminalNode LOCK() { return getToken(MySqlParser.LOCK, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode NONE() { return getToken(MySqlParser.NONE, 0); } + public TerminalNode SHARED() { return getToken(MySqlParser.SHARED, 0); } + public TerminalNode EXCLUSIVE() { return getToken(MySqlParser.EXCLUSIVE, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public AlterByLockContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByLock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByLock(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDiscardTablespaceContext extends AlterSpecificationContext { + public TerminalNode DISCARD() { return getToken(MySqlParser.DISCARD, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public AlterByDiscardTablespaceContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDiscardTablespace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDiscardTablespace(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByValidateContext extends AlterSpecificationContext { + public Token validationFormat; + public TerminalNode VALIDATION() { return getToken(MySqlParser.VALIDATION, 0); } + public TerminalNode WITHOUT() { return getToken(MySqlParser.WITHOUT, 0); } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public AlterByValidateContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByValidate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByValidate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddPrimaryKeyContext extends AlterSpecificationContext { + public UidContext name; + public UidContext index; + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode PRIMARY() { return getToken(MySqlParser.PRIMARY, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public IndexTypeContext indexType() { + return getRuleContext(IndexTypeContext.class,0); + } + public List indexOption() { + return getRuleContexts(IndexOptionContext.class); + } + public IndexOptionContext indexOption(int i) { + return getRuleContext(IndexOptionContext.class,i); + } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public AlterByAddPrimaryKeyContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddPrimaryKey(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddPrimaryKey(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByEnableKeysContext extends AlterSpecificationContext { + public TerminalNode ENABLE() { return getToken(MySqlParser.ENABLE, 0); } + public TerminalNode KEYS() { return getToken(MySqlParser.KEYS, 0); } + public AlterByEnableKeysContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByEnableKeys(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByEnableKeys(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterBySetAlgorithmContext extends AlterSpecificationContext { + public Token algType; + public TerminalNode ALGORITHM() { return getToken(MySqlParser.ALGORITHM, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode INSTANT() { return getToken(MySqlParser.INSTANT, 0); } + public TerminalNode INPLACE() { return getToken(MySqlParser.INPLACE, 0); } + public TerminalNode COPY() { return getToken(MySqlParser.COPY, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public AlterBySetAlgorithmContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterBySetAlgorithm(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterBySetAlgorithm(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByChangeColumnContext extends AlterSpecificationContext { + public UidContext oldColumn; + public UidContext newColumn; + public UidContext afterColumn; + public TerminalNode CHANGE() { return getToken(MySqlParser.CHANGE, 0); } + public ColumnDefinitionContext columnDefinition() { + return getRuleContext(ColumnDefinitionContext.class,0); + } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode COLUMN() { return getToken(MySqlParser.COLUMN, 0); } + public TerminalNode FIRST() { return getToken(MySqlParser.FIRST, 0); } + public TerminalNode AFTER() { return getToken(MySqlParser.AFTER, 0); } + public AlterByChangeColumnContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByChangeColumn(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByChangeColumn(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddUniqueKeyContext extends AlterSpecificationContext { + public UidContext name; + public Token indexFormat; + public UidContext indexName; + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode UNIQUE() { return getToken(MySqlParser.UNIQUE, 0); } + public IndexColumnNamesContext indexColumnNames() { + return getRuleContext(IndexColumnNamesContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(MySqlParser.CONSTRAINT, 0); } + public IndexTypeContext indexType() { + return getRuleContext(IndexTypeContext.class,0); + } + public List indexOption() { + return getRuleContexts(IndexOptionContext.class); + } + public IndexOptionContext indexOption(int i) { + return getRuleContext(IndexOptionContext.class,i); + } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public AlterByAddUniqueKeyContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddUniqueKey(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddUniqueKey(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDropIndexContext extends AlterSpecificationContext { + public Token indexFormat; + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public AlterByDropIndexContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDropIndex(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDropIndex(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddColumnContext extends AlterSpecificationContext { + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public ColumnDefinitionContext columnDefinition() { + return getRuleContext(ColumnDefinitionContext.class,0); + } + public TerminalNode COLUMN() { return getToken(MySqlParser.COLUMN, 0); } + public TerminalNode FIRST() { return getToken(MySqlParser.FIRST, 0); } + public TerminalNode AFTER() { return getToken(MySqlParser.AFTER, 0); } + public AlterByAddColumnContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddColumn(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddColumn(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByOrderContext extends AlterSpecificationContext { + public TerminalNode ORDER() { return getToken(MySqlParser.ORDER, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public AlterByOrderContext(AlterSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByOrder(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByOrder(this); + } + } + + public final AlterSpecificationContext alterSpecification() throws RecognitionException { + AlterSpecificationContext _localctx = new AlterSpecificationContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_alterSpecification); + int _la; + try { + int _alt; + setState(2880); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,369,_ctx) ) { + case 1: + _localctx = new AlterByTableOptionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(2529); + tableOption(); + setState(2536); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,311,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2531); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2530); + match(COMMA); + } + } + + setState(2533); + tableOption(); + } + } + } + setState(2538); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,311,_ctx); + } + } + break; + case 2: + _localctx = new AlterByAddColumnContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(2539); + match(ADD); + setState(2541); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(2540); + match(COLUMN); + } + } + + setState(2543); + uid(); + setState(2544); + columnDefinition(); + setState(2548); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FIRST: + { + setState(2545); + match(FIRST); + } + break; + case AFTER: + { + setState(2546); + match(AFTER); + setState(2547); + uid(); + } + break; + case EOF: + case ALTER: + case ANALYZE: + case CALL: + case CHANGE: + case CHECK: + case CREATE: + case DELETE: + case DESC: + case DESCRIBE: + case DROP: + case EXPLAIN: + case GET: + case GRANT: + case INSERT: + case KILL: + case LOAD: + case LOCK: + case OPTIMIZE: + case PARTITION: + case PURGE: + case RELEASE: + case RENAME: + case REPLACE: + case RESIGNAL: + case REVOKE: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case BEGIN: + case BINLOG: + case CACHE: + case CHECKSUM: + case COMMIT: + case DEALLOCATE: + case DO: + case FLUSH: + case HANDLER: + case HELP: + case INSTALL: + case PREPARE: + case REPAIR: + case RESET: + case ROLLBACK: + case SAVEPOINT: + case START: + case STOP: + case TRUNCATE: + case UNINSTALL: + case XA: + case EXECUTE: + case SHUTDOWN: + case MINUS: + case LR_BRACKET: + case COMMA: + case SEMI: + break; + default: + break; + } + } + break; + case 3: + _localctx = new AlterByAddColumnsContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(2550); + match(ADD); + setState(2552); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(2551); + match(COLUMN); + } + } + + setState(2554); + match(LR_BRACKET); + setState(2555); + uid(); + setState(2556); + columnDefinition(); + setState(2563); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2557); + match(COMMA); + setState(2558); + uid(); + setState(2559); + columnDefinition(); + } + } + setState(2565); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2566); + match(RR_BRACKET); + } + break; + case 4: + _localctx = new AlterByAddIndexContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(2568); + match(ADD); + setState(2569); + ((AlterByAddIndexContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((AlterByAddIndexContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2571); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2570); + uid(); + } + } + + setState(2574); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(2573); + indexType(); + } + } + + setState(2576); + indexColumnNames(); + setState(2580); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,318,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2577); + indexOption(); + } + } + } + setState(2582); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,318,_ctx); + } + } + break; + case 5: + _localctx = new AlterByAddPrimaryKeyContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(2583); + match(ADD); + setState(2588); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(2584); + match(CONSTRAINT); + setState(2586); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,319,_ctx) ) { + case 1: + { + setState(2585); + ((AlterByAddPrimaryKeyContext)_localctx).name = uid(); + } + break; + } + } + } + + setState(2590); + match(PRIMARY); + setState(2591); + match(KEY); + setState(2593); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2592); + ((AlterByAddPrimaryKeyContext)_localctx).index = uid(); + } + } + + setState(2596); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(2595); + indexType(); + } + } + + setState(2598); + indexColumnNames(); + setState(2602); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,323,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2599); + indexOption(); + } + } + } + setState(2604); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,323,_ctx); + } + } + break; + case 6: + _localctx = new AlterByAddUniqueKeyContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(2605); + match(ADD); + setState(2610); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(2606); + match(CONSTRAINT); + setState(2608); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2607); + ((AlterByAddUniqueKeyContext)_localctx).name = uid(); + } + } + + } + } + + setState(2612); + match(UNIQUE); + setState(2614); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INDEX || _la==KEY) { + { + setState(2613); + ((AlterByAddUniqueKeyContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((AlterByAddUniqueKeyContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2617); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2616); + ((AlterByAddUniqueKeyContext)_localctx).indexName = uid(); + } + } + + setState(2620); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(2619); + indexType(); + } + } + + setState(2622); + indexColumnNames(); + setState(2626); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,329,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2623); + indexOption(); + } + } + } + setState(2628); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,329,_ctx); + } + } + break; + case 7: + _localctx = new AlterByAddSpecialIndexContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(2629); + match(ADD); + setState(2630); + ((AlterByAddSpecialIndexContext)_localctx).keyType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FULLTEXT || _la==SPATIAL) ) { + ((AlterByAddSpecialIndexContext)_localctx).keyType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2632); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INDEX || _la==KEY) { + { + setState(2631); + ((AlterByAddSpecialIndexContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((AlterByAddSpecialIndexContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2635); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2634); + uid(); + } + } + + setState(2637); + indexColumnNames(); + setState(2641); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,332,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2638); + indexOption(); + } + } + } + setState(2643); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,332,_ctx); + } + } + break; + case 8: + _localctx = new AlterByAddForeignKeyContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(2644); + match(ADD); + setState(2649); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(2645); + match(CONSTRAINT); + setState(2647); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2646); + ((AlterByAddForeignKeyContext)_localctx).name = uid(); + } + } + + } + } + + setState(2651); + match(FOREIGN); + setState(2652); + match(KEY); + setState(2654); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2653); + ((AlterByAddForeignKeyContext)_localctx).indexName = uid(); + } + } + + setState(2656); + indexColumnNames(); + setState(2657); + referenceDefinition(); + } + break; + case 9: + _localctx = new AlterByAddCheckTableConstraintContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(2659); + match(ADD); + setState(2664); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(2660); + match(CONSTRAINT); + setState(2662); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2661); + ((AlterByAddCheckTableConstraintContext)_localctx).name = uid(); + } + } + + } + } + + setState(2666); + match(CHECK); + setState(2673); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,338,_ctx) ) { + case 1: + { + setState(2667); + uid(); + } + break; + case 2: + { + setState(2668); + stringLiteral(); + } + break; + case 3: + { + setState(2669); + match(LR_BRACKET); + setState(2670); + expression(0); + setState(2671); + match(RR_BRACKET); + } + break; + } + setState(2676); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(2675); + match(NOT); + } + } + + setState(2679); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENFORCED) { + { + setState(2678); + match(ENFORCED); + } + } + + } + break; + case 10: + _localctx = new AlterByAlterCheckTableConstraintContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(2681); + match(ALTER); + setState(2686); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(2682); + match(CONSTRAINT); + setState(2684); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2683); + ((AlterByAlterCheckTableConstraintContext)_localctx).name = uid(); + } + } + + } + } + + setState(2688); + match(CHECK); + setState(2695); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,343,_ctx) ) { + case 1: + { + setState(2689); + uid(); + } + break; + case 2: + { + setState(2690); + stringLiteral(); + } + break; + case 3: + { + setState(2691); + match(LR_BRACKET); + setState(2692); + expression(0); + setState(2693); + match(RR_BRACKET); + } + break; + } + setState(2698); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(2697); + match(NOT); + } + } + + setState(2701); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENFORCED) { + { + setState(2700); + match(ENFORCED); + } + } + + } + break; + case 11: + _localctx = new AlterByAddCheckTableConstraintContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(2703); + match(ADD); + setState(2708); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(2704); + match(CONSTRAINT); + setState(2706); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(2705); + ((AlterByAddCheckTableConstraintContext)_localctx).name = uid(); + } + } + + } + } + + setState(2710); + match(CHECK); + setState(2711); + match(LR_BRACKET); + setState(2712); + expression(0); + setState(2713); + match(RR_BRACKET); + } + break; + case 12: + _localctx = new AlterBySetAlgorithmContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(2715); + match(ALGORITHM); + setState(2717); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2716); + match(EQUAL_SYMBOL); + } + } + + setState(2719); + ((AlterBySetAlgorithmContext)_localctx).algType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==COPY || _la==INPLACE || _la==INSTANT) ) { + ((AlterBySetAlgorithmContext)_localctx).algType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 13: + _localctx = new AlterByChangeDefaultContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(2720); + match(ALTER); + setState(2722); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(2721); + match(COLUMN); + } + } + + setState(2724); + uid(); + setState(2730); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SET: + { + setState(2725); + match(SET); + setState(2726); + match(DEFAULT); + setState(2727); + defaultValue(); + } + break; + case DROP: + { + setState(2728); + match(DROP); + setState(2729); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 14: + _localctx = new AlterByChangeColumnContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(2732); + match(CHANGE); + setState(2734); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(2733); + match(COLUMN); + } + } + + setState(2736); + ((AlterByChangeColumnContext)_localctx).oldColumn = uid(); + setState(2737); + ((AlterByChangeColumnContext)_localctx).newColumn = uid(); + setState(2738); + columnDefinition(); + setState(2742); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FIRST: + { + setState(2739); + match(FIRST); + } + break; + case AFTER: + { + setState(2740); + match(AFTER); + setState(2741); + ((AlterByChangeColumnContext)_localctx).afterColumn = uid(); + } + break; + case EOF: + case ALTER: + case ANALYZE: + case CALL: + case CHANGE: + case CHECK: + case CREATE: + case DELETE: + case DESC: + case DESCRIBE: + case DROP: + case EXPLAIN: + case GET: + case GRANT: + case INSERT: + case KILL: + case LOAD: + case LOCK: + case OPTIMIZE: + case PARTITION: + case PURGE: + case RELEASE: + case RENAME: + case REPLACE: + case RESIGNAL: + case REVOKE: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case BEGIN: + case BINLOG: + case CACHE: + case CHECKSUM: + case COMMIT: + case DEALLOCATE: + case DO: + case FLUSH: + case HANDLER: + case HELP: + case INSTALL: + case PREPARE: + case REPAIR: + case RESET: + case ROLLBACK: + case SAVEPOINT: + case START: + case STOP: + case TRUNCATE: + case UNINSTALL: + case XA: + case EXECUTE: + case SHUTDOWN: + case MINUS: + case LR_BRACKET: + case COMMA: + case SEMI: + break; + default: + break; + } + } + break; + case 15: + _localctx = new AlterByRenameColumnContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(2744); + match(RENAME); + setState(2745); + match(COLUMN); + setState(2746); + ((AlterByRenameColumnContext)_localctx).oldColumn = uid(); + setState(2747); + match(TO); + setState(2748); + ((AlterByRenameColumnContext)_localctx).newColumn = uid(); + } + break; + case 16: + _localctx = new AlterByLockContext(_localctx); + enterOuterAlt(_localctx, 16); + { + setState(2750); + match(LOCK); + setState(2752); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(2751); + match(EQUAL_SYMBOL); + } + } + + setState(2754); + ((AlterByLockContext)_localctx).lockType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==EXCLUSIVE || _la==NONE || _la==SHARED) ) { + ((AlterByLockContext)_localctx).lockType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 17: + _localctx = new AlterByModifyColumnContext(_localctx); + enterOuterAlt(_localctx, 17); + { + setState(2755); + match(MODIFY); + setState(2757); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(2756); + match(COLUMN); + } + } + + setState(2759); + uid(); + setState(2760); + columnDefinition(); + setState(2764); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FIRST: + { + setState(2761); + match(FIRST); + } + break; + case AFTER: + { + setState(2762); + match(AFTER); + setState(2763); + uid(); + } + break; + case EOF: + case ALTER: + case ANALYZE: + case CALL: + case CHANGE: + case CHECK: + case CREATE: + case DELETE: + case DESC: + case DESCRIBE: + case DROP: + case EXPLAIN: + case GET: + case GRANT: + case INSERT: + case KILL: + case LOAD: + case LOCK: + case OPTIMIZE: + case PARTITION: + case PURGE: + case RELEASE: + case RENAME: + case REPLACE: + case RESIGNAL: + case REVOKE: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case BEGIN: + case BINLOG: + case CACHE: + case CHECKSUM: + case COMMIT: + case DEALLOCATE: + case DO: + case FLUSH: + case HANDLER: + case HELP: + case INSTALL: + case PREPARE: + case REPAIR: + case RESET: + case ROLLBACK: + case SAVEPOINT: + case START: + case STOP: + case TRUNCATE: + case UNINSTALL: + case XA: + case EXECUTE: + case SHUTDOWN: + case MINUS: + case LR_BRACKET: + case COMMA: + case SEMI: + break; + default: + break; + } + } + break; + case 18: + _localctx = new AlterByDropColumnContext(_localctx); + enterOuterAlt(_localctx, 18); + { + setState(2766); + match(DROP); + setState(2768); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(2767); + match(COLUMN); + } + } + + setState(2770); + uid(); + setState(2772); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==RESTRICT) { + { + setState(2771); + match(RESTRICT); + } + } + + } + break; + case 19: + _localctx = new AlterByDropConstraintCheckContext(_localctx); + enterOuterAlt(_localctx, 19); + { + setState(2774); + match(DROP); + setState(2775); + _la = _input.LA(1); + if ( !(_la==CHECK || _la==CONSTRAINT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2776); + uid(); + } + break; + case 20: + _localctx = new AlterByDropPrimaryKeyContext(_localctx); + enterOuterAlt(_localctx, 20); + { + setState(2777); + match(DROP); + setState(2778); + match(PRIMARY); + setState(2779); + match(KEY); + } + break; + case 21: + _localctx = new AlterByDropIndexContext(_localctx); + enterOuterAlt(_localctx, 21); + { + setState(2780); + match(DROP); + setState(2781); + ((AlterByDropIndexContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((AlterByDropIndexContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2782); + uid(); + } + break; + case 22: + _localctx = new AlterByRenameIndexContext(_localctx); + enterOuterAlt(_localctx, 22); + { + setState(2783); + match(RENAME); + setState(2784); + ((AlterByRenameIndexContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((AlterByRenameIndexContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2785); + uid(); + setState(2786); + match(TO); + setState(2787); + uid(); + } + break; + case 23: + _localctx = new AlterByAlterColumnDefaultContext(_localctx); + enterOuterAlt(_localctx, 23); + { + setState(2789); + match(ALTER); + setState(2791); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(2790); + match(COLUMN); + } + } + + setState(2793); + uid(); + setState(2807); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,360,_ctx) ) { + case 1: + { + setState(2794); + match(SET); + setState(2795); + match(DEFAULT); + setState(2801); + _errHandler.sync(this); + switch (_input.LA(1)) { + case START_NATIONAL_STRING_LITERAL: + case STRING_LITERAL: + case STRING_CHARSET_NAME: + { + setState(2796); + stringLiteral(); + } + break; + case LR_BRACKET: + { + setState(2797); + match(LR_BRACKET); + setState(2798); + expression(0); + setState(2799); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + { + setState(2803); + match(SET); + setState(2804); + _la = _input.LA(1); + if ( !(_la==INVISIBLE || _la==VISIBLE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 3: + { + setState(2805); + match(DROP); + setState(2806); + match(DEFAULT); + } + break; + } + } + break; + case 24: + _localctx = new AlterByAlterIndexVisibilityContext(_localctx); + enterOuterAlt(_localctx, 24); + { + setState(2809); + match(ALTER); + setState(2810); + match(INDEX); + setState(2811); + uid(); + setState(2812); + _la = _input.LA(1); + if ( !(_la==INVISIBLE || _la==VISIBLE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 25: + _localctx = new AlterByDropForeignKeyContext(_localctx); + enterOuterAlt(_localctx, 25); + { + setState(2814); + match(DROP); + setState(2815); + match(FOREIGN); + setState(2816); + match(KEY); + setState(2817); + uid(); + } + break; + case 26: + _localctx = new AlterByDisableKeysContext(_localctx); + enterOuterAlt(_localctx, 26); + { + setState(2818); + match(DISABLE); + setState(2819); + match(KEYS); + } + break; + case 27: + _localctx = new AlterByEnableKeysContext(_localctx); + enterOuterAlt(_localctx, 27); + { + setState(2820); + match(ENABLE); + setState(2821); + match(KEYS); + } + break; + case 28: + _localctx = new AlterByRenameContext(_localctx); + enterOuterAlt(_localctx, 28); + { + setState(2822); + match(RENAME); + setState(2824); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS || _la==TO) { + { + setState(2823); + ((AlterByRenameContext)_localctx).renameFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==AS || _la==TO) ) { + ((AlterByRenameContext)_localctx).renameFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2828); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,362,_ctx) ) { + case 1: + { + setState(2826); + uid(); + } + break; + case 2: + { + setState(2827); + fullId(); + } + break; + } + } + break; + case 29: + _localctx = new AlterByOrderContext(_localctx); + enterOuterAlt(_localctx, 29); + { + setState(2830); + match(ORDER); + setState(2831); + match(BY); + setState(2832); + uidList(); + } + break; + case 30: + _localctx = new AlterByConvertCharsetContext(_localctx); + enterOuterAlt(_localctx, 30); + { + setState(2833); + match(CONVERT); + setState(2834); + match(TO); + setState(2838); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CHARSET: + { + setState(2835); + match(CHARSET); + } + break; + case CHARACTER: + { + setState(2836); + match(CHARACTER); + setState(2837); + match(SET); + } + break; + default: + throw new NoViableAltException(this); + } + setState(2840); + charsetName(); + setState(2843); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLLATE) { + { + setState(2841); + match(COLLATE); + setState(2842); + collationName(); + } + } + + } + break; + case 31: + _localctx = new AlterByDefaultCharsetContext(_localctx); + enterOuterAlt(_localctx, 31); + { + setState(2846); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(2845); + match(DEFAULT); + } + } + + setState(2848); + match(CHARACTER); + setState(2849); + match(SET); + setState(2850); + match(EQUAL_SYMBOL); + setState(2851); + charsetName(); + setState(2855); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLLATE) { + { + setState(2852); + match(COLLATE); + setState(2853); + match(EQUAL_SYMBOL); + setState(2854); + collationName(); + } + } + + } + break; + case 32: + _localctx = new AlterByDiscardTablespaceContext(_localctx); + enterOuterAlt(_localctx, 32); + { + setState(2857); + match(DISCARD); + setState(2858); + match(TABLESPACE); + } + break; + case 33: + _localctx = new AlterByImportTablespaceContext(_localctx); + enterOuterAlt(_localctx, 33); + { + setState(2859); + match(IMPORT); + setState(2860); + match(TABLESPACE); + } + break; + case 34: + _localctx = new AlterByForceContext(_localctx); + enterOuterAlt(_localctx, 34); + { + setState(2861); + match(FORCE); + } + break; + case 35: + _localctx = new AlterByValidateContext(_localctx); + enterOuterAlt(_localctx, 35); + { + setState(2862); + ((AlterByValidateContext)_localctx).validationFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==WITH || _la==WITHOUT) ) { + ((AlterByValidateContext)_localctx).validationFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2863); + match(VALIDATION); + } + break; + case 36: + _localctx = new AlterByAddDefinitionsContext(_localctx); + enterOuterAlt(_localctx, 36); + { + setState(2864); + match(ADD); + setState(2866); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(2865); + match(COLUMN); + } + } + + setState(2868); + match(LR_BRACKET); + setState(2869); + createDefinition(); + setState(2874); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2870); + match(COMMA); + setState(2871); + createDefinition(); + } + } + setState(2876); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2877); + match(RR_BRACKET); + } + break; + case 37: + _localctx = new AlterPartitionContext(_localctx); + enterOuterAlt(_localctx, 37); + { + setState(2879); + alterPartitionSpecification(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterPartitionSpecificationContext extends ParserRuleContext { + public AlterPartitionSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterPartitionSpecification; } + + public AlterPartitionSpecificationContext() { } + public void copyFrom(AlterPartitionSpecificationContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByImportPartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode IMPORT() { return getToken(MySqlParser.IMPORT, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public AlterByImportPartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByImportPartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByImportPartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDropPartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public AlterByDropPartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDropPartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDropPartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByDiscardPartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode DISCARD() { return getToken(MySqlParser.DISCARD, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public AlterByDiscardPartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByDiscardPartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByDiscardPartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAddPartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode ADD() { return getToken(MySqlParser.ADD, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List partitionDefinition() { + return getRuleContexts(PartitionDefinitionContext.class); + } + public PartitionDefinitionContext partitionDefinition(int i) { + return getRuleContext(PartitionDefinitionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AlterByAddPartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAddPartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAddPartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByRemovePartitioningContext extends AlterPartitionSpecificationContext { + public TerminalNode REMOVE() { return getToken(MySqlParser.REMOVE, 0); } + public TerminalNode PARTITIONING() { return getToken(MySqlParser.PARTITIONING, 0); } + public AlterByRemovePartitioningContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByRemovePartitioning(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByRemovePartitioning(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByOptimizePartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode OPTIMIZE() { return getToken(MySqlParser.OPTIMIZE, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public AlterByOptimizePartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByOptimizePartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByOptimizePartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByCheckPartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public AlterByCheckPartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByCheckPartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByCheckPartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByCoalescePartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode COALESCE() { return getToken(MySqlParser.COALESCE, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public AlterByCoalescePartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByCoalescePartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByCoalescePartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByReorganizePartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode REORGANIZE() { return getToken(MySqlParser.REORGANIZE, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List partitionDefinition() { + return getRuleContexts(PartitionDefinitionContext.class); + } + public PartitionDefinitionContext partitionDefinition(int i) { + return getRuleContext(PartitionDefinitionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AlterByReorganizePartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByReorganizePartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByReorganizePartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByAnalyzePartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode ANALYZE() { return getToken(MySqlParser.ANALYZE, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public AlterByAnalyzePartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByAnalyzePartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByAnalyzePartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByRebuildPartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode REBUILD() { return getToken(MySqlParser.REBUILD, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public AlterByRebuildPartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByRebuildPartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByRebuildPartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByUpgradePartitioningContext extends AlterPartitionSpecificationContext { + public TerminalNode UPGRADE() { return getToken(MySqlParser.UPGRADE, 0); } + public TerminalNode PARTITIONING() { return getToken(MySqlParser.PARTITIONING, 0); } + public AlterByUpgradePartitioningContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByUpgradePartitioning(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByUpgradePartitioning(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByTruncatePartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode TRUNCATE() { return getToken(MySqlParser.TRUNCATE, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public AlterByTruncatePartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByTruncatePartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByTruncatePartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByRepairPartitionContext extends AlterPartitionSpecificationContext { + public TerminalNode REPAIR() { return getToken(MySqlParser.REPAIR, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public AlterByRepairPartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByRepairPartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByRepairPartition(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterByExchangePartitionContext extends AlterPartitionSpecificationContext { + public Token validationFormat; + public TerminalNode EXCHANGE() { return getToken(MySqlParser.EXCHANGE, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List WITH() { return getTokens(MySqlParser.WITH); } + public TerminalNode WITH(int i) { + return getToken(MySqlParser.WITH, i); + } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode VALIDATION() { return getToken(MySqlParser.VALIDATION, 0); } + public TerminalNode WITHOUT() { return getToken(MySqlParser.WITHOUT, 0); } + public AlterByExchangePartitionContext(AlterPartitionSpecificationContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterByExchangePartition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterByExchangePartition(this); + } + } + + public final AlterPartitionSpecificationContext alterPartitionSpecification() throws RecognitionException { + AlterPartitionSpecificationContext _localctx = new AlterPartitionSpecificationContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_alterPartitionSpecification); + int _la; + try { + setState(2980); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + _localctx = new AlterByAddPartitionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(2882); + match(ADD); + setState(2883); + match(PARTITION); + setState(2884); + match(LR_BRACKET); + setState(2885); + partitionDefinition(); + setState(2890); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2886); + match(COMMA); + setState(2887); + partitionDefinition(); + } + } + setState(2892); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2893); + match(RR_BRACKET); + } + break; + case DROP: + _localctx = new AlterByDropPartitionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(2895); + match(DROP); + setState(2896); + match(PARTITION); + setState(2897); + uidList(); + } + break; + case DISCARD: + _localctx = new AlterByDiscardPartitionContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(2898); + match(DISCARD); + setState(2899); + match(PARTITION); + setState(2902); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(2900); + uidList(); + } + break; + case ALL: + { + setState(2901); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(2904); + match(TABLESPACE); + } + break; + case IMPORT: + _localctx = new AlterByImportPartitionContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(2905); + match(IMPORT); + setState(2906); + match(PARTITION); + setState(2909); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(2907); + uidList(); + } + break; + case ALL: + { + setState(2908); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(2911); + match(TABLESPACE); + } + break; + case TRUNCATE: + _localctx = new AlterByTruncatePartitionContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(2912); + match(TRUNCATE); + setState(2913); + match(PARTITION); + setState(2916); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(2914); + uidList(); + } + break; + case ALL: + { + setState(2915); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case COALESCE: + _localctx = new AlterByCoalescePartitionContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(2918); + match(COALESCE); + setState(2919); + match(PARTITION); + setState(2920); + decimalLiteral(); + } + break; + case REORGANIZE: + _localctx = new AlterByReorganizePartitionContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(2921); + match(REORGANIZE); + setState(2922); + match(PARTITION); + setState(2923); + uidList(); + setState(2924); + match(INTO); + setState(2925); + match(LR_BRACKET); + setState(2926); + partitionDefinition(); + setState(2931); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2927); + match(COMMA); + setState(2928); + partitionDefinition(); + } + } + setState(2933); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2934); + match(RR_BRACKET); + } + break; + case EXCHANGE: + _localctx = new AlterByExchangePartitionContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(2936); + match(EXCHANGE); + setState(2937); + match(PARTITION); + setState(2938); + uid(); + setState(2939); + match(WITH); + setState(2940); + match(TABLE); + setState(2941); + tableName(); + setState(2944); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,375,_ctx) ) { + case 1: + { + setState(2942); + ((AlterByExchangePartitionContext)_localctx).validationFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==WITH || _la==WITHOUT) ) { + ((AlterByExchangePartitionContext)_localctx).validationFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2943); + match(VALIDATION); + } + break; + } + } + break; + case ANALYZE: + _localctx = new AlterByAnalyzePartitionContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(2946); + match(ANALYZE); + setState(2947); + match(PARTITION); + setState(2950); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(2948); + uidList(); + } + break; + case ALL: + { + setState(2949); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case CHECK: + _localctx = new AlterByCheckPartitionContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(2952); + match(CHECK); + setState(2953); + match(PARTITION); + setState(2956); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(2954); + uidList(); + } + break; + case ALL: + { + setState(2955); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case OPTIMIZE: + _localctx = new AlterByOptimizePartitionContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(2958); + match(OPTIMIZE); + setState(2959); + match(PARTITION); + setState(2962); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(2960); + uidList(); + } + break; + case ALL: + { + setState(2961); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case REBUILD: + _localctx = new AlterByRebuildPartitionContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(2964); + match(REBUILD); + setState(2965); + match(PARTITION); + setState(2968); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(2966); + uidList(); + } + break; + case ALL: + { + setState(2967); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case REPAIR: + _localctx = new AlterByRepairPartitionContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(2970); + match(REPAIR); + setState(2971); + match(PARTITION); + setState(2974); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(2972); + uidList(); + } + break; + case ALL: + { + setState(2973); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case REMOVE: + _localctx = new AlterByRemovePartitioningContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(2976); + match(REMOVE); + setState(2977); + match(PARTITIONING); + } + break; + case UPGRADE: + _localctx = new AlterByUpgradePartitioningContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(2978); + match(UPGRADE); + setState(2979); + match(PARTITIONING); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropDatabaseContext extends ParserRuleContext { + public Token dbFormat; + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); } + public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public DropDatabaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropDatabase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropDatabase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropDatabase(this); + } + } + + public final DropDatabaseContext dropDatabase() throws RecognitionException { + DropDatabaseContext _localctx = new DropDatabaseContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_dropDatabase); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2982); + match(DROP); + setState(2983); + ((DropDatabaseContext)_localctx).dbFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DATABASE || _la==SCHEMA) ) { + ((DropDatabaseContext)_localctx).dbFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2985); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,382,_ctx) ) { + case 1: + { + setState(2984); + ifExists(); + } + break; + } + setState(2987); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropEventContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode EVENT() { return getToken(MySqlParser.EVENT, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public DropEventContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropEvent; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropEvent(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropEvent(this); + } + } + + public final DropEventContext dropEvent() throws RecognitionException { + DropEventContext _localctx = new DropEventContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_dropEvent); + try { + enterOuterAlt(_localctx, 1); + { + setState(2989); + match(DROP); + setState(2990); + match(EVENT); + setState(2992); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,383,_ctx) ) { + case 1: + { + setState(2991); + ifExists(); + } + break; + } + setState(2994); + fullId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropIndexContext extends ParserRuleContext { + public Token intimeAction; + public Token algType; + public Token lockType; + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public List ALGORITHM() { return getTokens(MySqlParser.ALGORITHM); } + public TerminalNode ALGORITHM(int i) { + return getToken(MySqlParser.ALGORITHM, i); + } + public List LOCK() { return getTokens(MySqlParser.LOCK); } + public TerminalNode LOCK(int i) { + return getToken(MySqlParser.LOCK, i); + } + public TerminalNode ONLINE() { return getToken(MySqlParser.ONLINE, 0); } + public TerminalNode OFFLINE() { return getToken(MySqlParser.OFFLINE, 0); } + public List DEFAULT() { return getTokens(MySqlParser.DEFAULT); } + public TerminalNode DEFAULT(int i) { + return getToken(MySqlParser.DEFAULT, i); + } + public List INPLACE() { return getTokens(MySqlParser.INPLACE); } + public TerminalNode INPLACE(int i) { + return getToken(MySqlParser.INPLACE, i); + } + public List COPY() { return getTokens(MySqlParser.COPY); } + public TerminalNode COPY(int i) { + return getToken(MySqlParser.COPY, i); + } + public List NONE() { return getTokens(MySqlParser.NONE); } + public TerminalNode NONE(int i) { + return getToken(MySqlParser.NONE, i); + } + public List SHARED() { return getTokens(MySqlParser.SHARED); } + public TerminalNode SHARED(int i) { + return getToken(MySqlParser.SHARED, i); + } + public List EXCLUSIVE() { return getTokens(MySqlParser.EXCLUSIVE); } + public TerminalNode EXCLUSIVE(int i) { + return getToken(MySqlParser.EXCLUSIVE, i); + } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public DropIndexContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropIndex; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropIndex(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropIndex(this); + } + } + + public final DropIndexContext dropIndex() throws RecognitionException { + DropIndexContext _localctx = new DropIndexContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_dropIndex); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2996); + match(DROP); + setState(2997); + match(INDEX); + setState(2999); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,384,_ctx) ) { + case 1: + { + setState(2998); + ((DropIndexContext)_localctx).intimeAction = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==OFFLINE || _la==ONLINE) ) { + ((DropIndexContext)_localctx).intimeAction = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(3001); + uid(); + setState(3002); + match(ON); + setState(3003); + tableName(); + setState(3016); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,388,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(3014); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALGORITHM: + { + setState(3004); + match(ALGORITHM); + setState(3006); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(3005); + match(EQUAL_SYMBOL); + } + } + + setState(3008); + ((DropIndexContext)_localctx).algType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==COPY || _la==INPLACE) ) { + ((DropIndexContext)_localctx).algType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case LOCK: + { + setState(3009); + match(LOCK); + setState(3011); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(3010); + match(EQUAL_SYMBOL); + } + } + + setState(3013); + ((DropIndexContext)_localctx).lockType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==EXCLUSIVE || _la==NONE || _la==SHARED) ) { + ((DropIndexContext)_localctx).lockType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(3018); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,388,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropLogfileGroupContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode LOGFILE() { return getToken(MySqlParser.LOGFILE, 0); } + public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public DropLogfileGroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropLogfileGroup; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropLogfileGroup(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropLogfileGroup(this); + } + } + + public final DropLogfileGroupContext dropLogfileGroup() throws RecognitionException { + DropLogfileGroupContext _localctx = new DropLogfileGroupContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_dropLogfileGroup); + try { + enterOuterAlt(_localctx, 1); + { + setState(3019); + match(DROP); + setState(3020); + match(LOGFILE); + setState(3021); + match(GROUP); + setState(3022); + uid(); + setState(3023); + match(ENGINE); + setState(3024); + match(EQUAL_SYMBOL); + setState(3025); + engineName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropProcedureContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public DropProcedureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropProcedure; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropProcedure(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropProcedure(this); + } + } + + public final DropProcedureContext dropProcedure() throws RecognitionException { + DropProcedureContext _localctx = new DropProcedureContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_dropProcedure); + try { + enterOuterAlt(_localctx, 1); + { + setState(3027); + match(DROP); + setState(3028); + match(PROCEDURE); + setState(3030); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,389,_ctx) ) { + case 1: + { + setState(3029); + ifExists(); + } + break; + } + setState(3032); + fullId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropFunctionContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public DropFunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropFunction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropFunction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropFunction(this); + } + } + + public final DropFunctionContext dropFunction() throws RecognitionException { + DropFunctionContext _localctx = new DropFunctionContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_dropFunction); + try { + enterOuterAlt(_localctx, 1); + { + setState(3034); + match(DROP); + setState(3035); + match(FUNCTION); + setState(3037); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,390,_ctx) ) { + case 1: + { + setState(3036); + ifExists(); + } + break; + } + setState(3039); + fullId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropServerContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode SERVER() { return getToken(MySqlParser.SERVER, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public DropServerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropServer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropServer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropServer(this); + } + } + + public final DropServerContext dropServer() throws RecognitionException { + DropServerContext _localctx = new DropServerContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_dropServer); + try { + enterOuterAlt(_localctx, 1); + { + setState(3041); + match(DROP); + setState(3042); + match(SERVER); + setState(3044); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,391,_ctx) ) { + case 1: + { + setState(3043); + ifExists(); + } + break; + } + setState(3046); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropTableContext extends ParserRuleContext { + public Token dropType; + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public TerminalNode TEMPORARY() { return getToken(MySqlParser.TEMPORARY, 0); } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public TerminalNode RESTRICT() { return getToken(MySqlParser.RESTRICT, 0); } + public TerminalNode CASCADE() { return getToken(MySqlParser.CASCADE, 0); } + public DropTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropTable(this); + } + } + + public final DropTableContext dropTable() throws RecognitionException { + DropTableContext _localctx = new DropTableContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_dropTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3048); + match(DROP); + setState(3050); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TEMPORARY) { + { + setState(3049); + match(TEMPORARY); + } + } + + setState(3052); + match(TABLE); + setState(3054); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,393,_ctx) ) { + case 1: + { + setState(3053); + ifExists(); + } + break; + } + setState(3056); + tables(); + setState(3058); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3057); + ((DropTableContext)_localctx).dropType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CASCADE || _la==RESTRICT) ) { + ((DropTableContext)_localctx).dropType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropTablespaceContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public DropTablespaceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropTablespace; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropTablespace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropTablespace(this); + } + } + + public final DropTablespaceContext dropTablespace() throws RecognitionException { + DropTablespaceContext _localctx = new DropTablespaceContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_dropTablespace); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3060); + match(DROP); + setState(3061); + match(TABLESPACE); + setState(3062); + uid(); + setState(3068); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENGINE) { + { + setState(3063); + match(ENGINE); + setState(3065); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL_SYMBOL) { + { + setState(3064); + match(EQUAL_SYMBOL); + } + } + + setState(3067); + engineName(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropTriggerContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode TRIGGER() { return getToken(MySqlParser.TRIGGER, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public DropTriggerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropTrigger; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropTrigger(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropTrigger(this); + } + } + + public final DropTriggerContext dropTrigger() throws RecognitionException { + DropTriggerContext _localctx = new DropTriggerContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_dropTrigger); + try { + enterOuterAlt(_localctx, 1); + { + setState(3070); + match(DROP); + setState(3071); + match(TRIGGER); + setState(3073); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,397,_ctx) ) { + case 1: + { + setState(3072); + ifExists(); + } + break; + } + setState(3075); + fullId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropViewContext extends ParserRuleContext { + public Token dropType; + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode VIEW() { return getToken(MySqlParser.VIEW, 0); } + public List fullId() { + return getRuleContexts(FullIdContext.class); + } + public FullIdContext fullId(int i) { + return getRuleContext(FullIdContext.class,i); + } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode RESTRICT() { return getToken(MySqlParser.RESTRICT, 0); } + public TerminalNode CASCADE() { return getToken(MySqlParser.CASCADE, 0); } + public DropViewContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropView; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropView(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropView(this); + } + } + + public final DropViewContext dropView() throws RecognitionException { + DropViewContext _localctx = new DropViewContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_dropView); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3077); + match(DROP); + setState(3078); + match(VIEW); + setState(3080); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,398,_ctx) ) { + case 1: + { + setState(3079); + ifExists(); + } + break; + } + setState(3082); + fullId(); + setState(3087); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3083); + match(COMMA); + setState(3084); + fullId(); + } + } + setState(3089); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3091); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3090); + ((DropViewContext)_localctx).dropType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CASCADE || _la==RESTRICT) ) { + ((DropViewContext)_localctx).dropType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropRoleContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode ROLE() { return getToken(MySqlParser.ROLE, 0); } + public List roleName() { + return getRuleContexts(RoleNameContext.class); + } + public RoleNameContext roleName(int i) { + return getRuleContext(RoleNameContext.class,i); + } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public DropRoleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropRole; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropRole(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropRole(this); + } + } + + public final DropRoleContext dropRole() throws RecognitionException { + DropRoleContext _localctx = new DropRoleContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_dropRole); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3093); + match(DROP); + setState(3094); + match(ROLE); + setState(3096); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,401,_ctx) ) { + case 1: + { + setState(3095); + ifExists(); + } + break; + } + setState(3098); + roleName(); + setState(3103); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3099); + match(COMMA); + setState(3100); + roleName(); + } + } + setState(3105); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetRoleContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode ROLE() { return getToken(MySqlParser.ROLE, 0); } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public TerminalNode NONE() { return getToken(MySqlParser.NONE, 0); } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public List roleName() { + return getRuleContexts(RoleNameContext.class); + } + public RoleNameContext roleName(int i) { + return getRuleContext(RoleNameContext.class,i); + } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public RoleOptionContext roleOption() { + return getRuleContext(RoleOptionContext.class,0); + } + public SetRoleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_setRole; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetRole(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetRole(this); + } + } + + public final SetRoleContext setRole() throws RecognitionException { + SetRoleContext _localctx = new SetRoleContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_setRole); + int _la; + try { + setState(3139); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,408,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3106); + match(SET); + setState(3107); + match(DEFAULT); + setState(3108); + match(ROLE); + setState(3119); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,404,_ctx) ) { + case 1: + { + setState(3109); + match(NONE); + } + break; + case 2: + { + setState(3110); + match(ALL); + } + break; + case 3: + { + setState(3111); + roleName(); + setState(3116); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3112); + match(COMMA); + setState(3113); + roleName(); + } + } + setState(3118); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + setState(3121); + match(TO); + setState(3124); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,405,_ctx) ) { + case 1: + { + setState(3122); + userName(); + } + break; + case 2: + { + setState(3123); + uid(); + } + break; + } + setState(3133); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3126); + match(COMMA); + setState(3129); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,406,_ctx) ) { + case 1: + { + setState(3127); + userName(); + } + break; + case 2: + { + setState(3128); + uid(); + } + break; + } + } + } + setState(3135); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3136); + match(SET); + setState(3137); + match(ROLE); + setState(3138); + roleOption(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RenameTableContext extends ParserRuleContext { + public TerminalNode RENAME() { return getToken(MySqlParser.RENAME, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public List renameTableClause() { + return getRuleContexts(RenameTableClauseContext.class); + } + public RenameTableClauseContext renameTableClause(int i) { + return getRuleContext(RenameTableClauseContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public RenameTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_renameTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRenameTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRenameTable(this); + } + } + + public final RenameTableContext renameTable() throws RecognitionException { + RenameTableContext _localctx = new RenameTableContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_renameTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3141); + match(RENAME); + setState(3142); + match(TABLE); + setState(3143); + renameTableClause(); + setState(3148); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3144); + match(COMMA); + setState(3145); + renameTableClause(); + } + } + setState(3150); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RenameTableClauseContext extends ParserRuleContext { + public List tableName() { + return getRuleContexts(TableNameContext.class); + } + public TableNameContext tableName(int i) { + return getRuleContext(TableNameContext.class,i); + } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public RenameTableClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_renameTableClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRenameTableClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRenameTableClause(this); + } + } + + public final RenameTableClauseContext renameTableClause() throws RecognitionException { + RenameTableClauseContext _localctx = new RenameTableClauseContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_renameTableClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(3151); + tableName(); + setState(3152); + match(TO); + setState(3153); + tableName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TruncateTableContext extends ParserRuleContext { + public TerminalNode TRUNCATE() { return getToken(MySqlParser.TRUNCATE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TruncateTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_truncateTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTruncateTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTruncateTable(this); + } + } + + public final TruncateTableContext truncateTable() throws RecognitionException { + TruncateTableContext _localctx = new TruncateTableContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_truncateTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3155); + match(TRUNCATE); + setState(3157); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TABLE) { + { + setState(3156); + match(TABLE); + } + } + + setState(3159); + tableName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CallStatementContext extends ParserRuleContext { + public TerminalNode CALL() { return getToken(MySqlParser.CALL, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public ConstantsContext constants() { + return getRuleContext(ConstantsContext.class,0); + } + public ExpressionsContext expressions() { + return getRuleContext(ExpressionsContext.class,0); + } + public CallStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_callStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCallStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCallStatement(this); + } + } + + public final CallStatementContext callStatement() throws RecognitionException { + CallStatementContext _localctx = new CallStatementContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_callStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(3161); + match(CALL); + setState(3162); + fullId(); + setState(3169); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,412,_ctx) ) { + case 1: + { + setState(3163); + match(LR_BRACKET); + setState(3166); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,411,_ctx) ) { + case 1: + { + setState(3164); + constants(); + } + break; + case 2: + { + setState(3165); + expressions(); + } + break; + } + setState(3168); + match(RR_BRACKET); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeleteStatementContext extends ParserRuleContext { + public SingleDeleteStatementContext singleDeleteStatement() { + return getRuleContext(SingleDeleteStatementContext.class,0); + } + public MultipleDeleteStatementContext multipleDeleteStatement() { + return getRuleContext(MultipleDeleteStatementContext.class,0); + } + public DeleteStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_deleteStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDeleteStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDeleteStatement(this); + } + } + + public final DeleteStatementContext deleteStatement() throws RecognitionException { + DeleteStatementContext _localctx = new DeleteStatementContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_deleteStatement); + try { + setState(3173); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,413,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3171); + singleDeleteStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3172); + multipleDeleteStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DoStatementContext extends ParserRuleContext { + public TerminalNode DO() { return getToken(MySqlParser.DO, 0); } + public ExpressionsContext expressions() { + return getRuleContext(ExpressionsContext.class,0); + } + public DoStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_doStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDoStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDoStatement(this); + } + } + + public final DoStatementContext doStatement() throws RecognitionException { + DoStatementContext _localctx = new DoStatementContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_doStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(3175); + match(DO); + setState(3176); + expressions(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HandlerStatementContext extends ParserRuleContext { + public HandlerOpenStatementContext handlerOpenStatement() { + return getRuleContext(HandlerOpenStatementContext.class,0); + } + public HandlerReadIndexStatementContext handlerReadIndexStatement() { + return getRuleContext(HandlerReadIndexStatementContext.class,0); + } + public HandlerReadStatementContext handlerReadStatement() { + return getRuleContext(HandlerReadStatementContext.class,0); + } + public HandlerCloseStatementContext handlerCloseStatement() { + return getRuleContext(HandlerCloseStatementContext.class,0); + } + public HandlerStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_handlerStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerStatement(this); + } + } + + public final HandlerStatementContext handlerStatement() throws RecognitionException { + HandlerStatementContext _localctx = new HandlerStatementContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_handlerStatement); + try { + setState(3182); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,414,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3178); + handlerOpenStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3179); + handlerReadIndexStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3180); + handlerReadStatement(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(3181); + handlerCloseStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InsertStatementContext extends ParserRuleContext { + public Token priority; + public UidListContext partitions; + public FullColumnNameListContext columns; + public UpdatedElementContext setFirst; + public UpdatedElementContext updatedElement; + public List setElements = new ArrayList(); + public UpdatedElementContext duplicatedFirst; + public List duplicatedElements = new ArrayList(); + public TerminalNode INSERT() { return getToken(MySqlParser.INSERT, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public InsertStatementValueContext insertStatementValue() { + return getRuleContext(InsertStatementValueContext.class,0); + } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); } + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public List updatedElement() { + return getRuleContexts(UpdatedElementContext.class); + } + public UpdatedElementContext updatedElement(int i) { + return getRuleContext(UpdatedElementContext.class,i); + } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TerminalNode DUPLICATE() { return getToken(MySqlParser.DUPLICATE, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public TerminalNode LOW_PRIORITY() { return getToken(MySqlParser.LOW_PRIORITY, 0); } + public TerminalNode DELAYED() { return getToken(MySqlParser.DELAYED, 0); } + public TerminalNode HIGH_PRIORITY() { return getToken(MySqlParser.HIGH_PRIORITY, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public FullColumnNameListContext fullColumnNameList() { + return getRuleContext(FullColumnNameListContext.class,0); + } + public InsertStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_insertStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterInsertStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitInsertStatement(this); + } + } + + public final InsertStatementContext insertStatement() throws RecognitionException { + InsertStatementContext _localctx = new InsertStatementContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_insertStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3184); + match(INSERT); + setState(3186); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & -9223372032559808511L) != 0)) { + { + setState(3185); + ((InsertStatementContext)_localctx).priority = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & -9223372032559808511L) != 0)) ) { + ((InsertStatementContext)_localctx).priority = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3189); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE) { + { + setState(3188); + match(IGNORE); + } + } + + setState(3192); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTO) { + { + setState(3191); + match(INTO); + } + } + + setState(3194); + tableName(); + setState(3201); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(3195); + match(PARTITION); + setState(3196); + match(LR_BRACKET); + setState(3198); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(3197); + ((InsertStatementContext)_localctx).partitions = uidList(); + } + } + + setState(3200); + match(RR_BRACKET); + } + } + + setState(3226); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + case VALUES: + case VALUE: + case LR_BRACKET: + { + setState(3208); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,421,_ctx) ) { + case 1: + { + setState(3203); + match(LR_BRACKET); + setState(3205); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,420,_ctx) ) { + case 1: + { + setState(3204); + ((InsertStatementContext)_localctx).columns = fullColumnNameList(); + } + break; + } + setState(3207); + match(RR_BRACKET); + } + break; + } + setState(3210); + insertStatementValue(); + setState(3215); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,423,_ctx) ) { + case 1: + { + setState(3212); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(3211); + match(AS); + } + } + + setState(3214); + uid(); + } + break; + } + } + break; + case SET: + { + setState(3217); + match(SET); + setState(3218); + ((InsertStatementContext)_localctx).setFirst = updatedElement(); + setState(3223); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3219); + match(COMMA); + setState(3220); + ((InsertStatementContext)_localctx).updatedElement = updatedElement(); + ((InsertStatementContext)_localctx).setElements.add(((InsertStatementContext)_localctx).updatedElement); + } + } + setState(3225); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3240); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ON) { + { + setState(3228); + match(ON); + setState(3229); + match(DUPLICATE); + setState(3230); + match(KEY); + setState(3231); + match(UPDATE); + setState(3232); + ((InsertStatementContext)_localctx).duplicatedFirst = updatedElement(); + setState(3237); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3233); + match(COMMA); + setState(3234); + ((InsertStatementContext)_localctx).updatedElement = updatedElement(); + ((InsertStatementContext)_localctx).duplicatedElements.add(((InsertStatementContext)_localctx).updatedElement); + } + } + setState(3239); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LoadDataStatementContext extends ParserRuleContext { + public Token priority; + public Token filename; + public Token violation; + public CharsetNameContext charset; + public Token fieldsFormat; + public Token linesFormat; + public TerminalNode LOAD() { return getToken(MySqlParser.LOAD, 0); } + public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); } + public TerminalNode INFILE() { return getToken(MySqlParser.INFILE, 0); } + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public List SET() { return getTokens(MySqlParser.SET); } + public TerminalNode SET(int i) { + return getToken(MySqlParser.SET, i); + } + public List LINES() { return getTokens(MySqlParser.LINES); } + public TerminalNode LINES(int i) { + return getToken(MySqlParser.LINES, i); + } + public List IGNORE() { return getTokens(MySqlParser.IGNORE); } + public TerminalNode IGNORE(int i) { + return getToken(MySqlParser.IGNORE, i); + } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public List assignmentField() { + return getRuleContexts(AssignmentFieldContext.class); + } + public AssignmentFieldContext assignmentField(int i) { + return getRuleContext(AssignmentFieldContext.class,i); + } + public List updatedElement() { + return getRuleContexts(UpdatedElementContext.class); + } + public UpdatedElementContext updatedElement(int i) { + return getRuleContext(UpdatedElementContext.class,i); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode LOW_PRIORITY() { return getToken(MySqlParser.LOW_PRIORITY, 0); } + public TerminalNode CONCURRENT() { return getToken(MySqlParser.CONCURRENT, 0); } + public TerminalNode REPLACE() { return getToken(MySqlParser.REPLACE, 0); } + public TerminalNode FIELDS() { return getToken(MySqlParser.FIELDS, 0); } + public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); } + public TerminalNode ROWS() { return getToken(MySqlParser.ROWS, 0); } + public List selectFieldsInto() { + return getRuleContexts(SelectFieldsIntoContext.class); + } + public SelectFieldsIntoContext selectFieldsInto(int i) { + return getRuleContext(SelectFieldsIntoContext.class,i); + } + public List selectLinesInto() { + return getRuleContexts(SelectLinesIntoContext.class); + } + public SelectLinesIntoContext selectLinesInto(int i) { + return getRuleContext(SelectLinesIntoContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public LoadDataStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_loadDataStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLoadDataStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLoadDataStatement(this); + } + } + + public final LoadDataStatementContext loadDataStatement() throws RecognitionException { + LoadDataStatementContext _localctx = new LoadDataStatementContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_loadDataStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3242); + match(LOAD); + setState(3243); + match(DATA); + setState(3245); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOW_PRIORITY || _la==CONCURRENT) { + { + setState(3244); + ((LoadDataStatementContext)_localctx).priority = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==LOW_PRIORITY || _la==CONCURRENT) ) { + ((LoadDataStatementContext)_localctx).priority = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3248); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOCAL) { + { + setState(3247); + match(LOCAL); + } + } + + setState(3250); + match(INFILE); + setState(3251); + ((LoadDataStatementContext)_localctx).filename = match(STRING_LITERAL); + setState(3253); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE || _la==REPLACE) { + { + setState(3252); + ((LoadDataStatementContext)_localctx).violation = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==IGNORE || _la==REPLACE) ) { + ((LoadDataStatementContext)_localctx).violation = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3255); + match(INTO); + setState(3256); + match(TABLE); + setState(3257); + tableName(); + setState(3263); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(3258); + match(PARTITION); + setState(3259); + match(LR_BRACKET); + setState(3260); + uidList(); + setState(3261); + match(RR_BRACKET); + } + } + + setState(3268); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CHARACTER) { + { + setState(3265); + match(CHARACTER); + setState(3266); + match(SET); + setState(3267); + ((LoadDataStatementContext)_localctx).charset = charsetName(); + } + } + + setState(3276); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMNS || _la==FIELDS) { + { + setState(3270); + ((LoadDataStatementContext)_localctx).fieldsFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==COLUMNS || _la==FIELDS) ) { + ((LoadDataStatementContext)_localctx).fieldsFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3272); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(3271); + selectFieldsInto(); + } + } + setState(3274); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==ENCLOSED || _la==ESCAPED || _la==OPTIONALLY || _la==TERMINATED ); + } + } + + setState(3284); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LINES) { + { + setState(3278); + match(LINES); + setState(3280); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(3279); + selectLinesInto(); + } + } + setState(3282); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==STARTING || _la==TERMINATED ); + } + } + + setState(3290); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE) { + { + setState(3286); + match(IGNORE); + setState(3287); + decimalLiteral(); + setState(3288); + ((LoadDataStatementContext)_localctx).linesFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==LINES || _la==ROWS) ) { + ((LoadDataStatementContext)_localctx).linesFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3303); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,439,_ctx) ) { + case 1: + { + setState(3292); + match(LR_BRACKET); + setState(3293); + assignmentField(); + setState(3298); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3294); + match(COMMA); + setState(3295); + assignmentField(); + } + } + setState(3300); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3301); + match(RR_BRACKET); + } + break; + } + setState(3314); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,441,_ctx) ) { + case 1: + { + setState(3305); + match(SET); + setState(3306); + updatedElement(); + setState(3311); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3307); + match(COMMA); + setState(3308); + updatedElement(); + } + } + setState(3313); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LoadXmlStatementContext extends ParserRuleContext { + public Token priority; + public Token filename; + public Token violation; + public CharsetNameContext charset; + public Token tag; + public Token linesFormat; + public TerminalNode LOAD() { return getToken(MySqlParser.LOAD, 0); } + public TerminalNode XML() { return getToken(MySqlParser.XML, 0); } + public TerminalNode INFILE() { return getToken(MySqlParser.INFILE, 0); } + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public List STRING_LITERAL() { return getTokens(MySqlParser.STRING_LITERAL); } + public TerminalNode STRING_LITERAL(int i) { + return getToken(MySqlParser.STRING_LITERAL, i); + } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public List SET() { return getTokens(MySqlParser.SET); } + public TerminalNode SET(int i) { + return getToken(MySqlParser.SET, i); + } + public List ROWS() { return getTokens(MySqlParser.ROWS); } + public TerminalNode ROWS(int i) { + return getToken(MySqlParser.ROWS, i); + } + public TerminalNode IDENTIFIED() { return getToken(MySqlParser.IDENTIFIED, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public TerminalNode LESS_SYMBOL() { return getToken(MySqlParser.LESS_SYMBOL, 0); } + public TerminalNode GREATER_SYMBOL() { return getToken(MySqlParser.GREATER_SYMBOL, 0); } + public List IGNORE() { return getTokens(MySqlParser.IGNORE); } + public TerminalNode IGNORE(int i) { + return getToken(MySqlParser.IGNORE, i); + } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List assignmentField() { + return getRuleContexts(AssignmentFieldContext.class); + } + public AssignmentFieldContext assignmentField(int i) { + return getRuleContext(AssignmentFieldContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List updatedElement() { + return getRuleContexts(UpdatedElementContext.class); + } + public UpdatedElementContext updatedElement(int i) { + return getRuleContext(UpdatedElementContext.class,i); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode LOW_PRIORITY() { return getToken(MySqlParser.LOW_PRIORITY, 0); } + public TerminalNode CONCURRENT() { return getToken(MySqlParser.CONCURRENT, 0); } + public TerminalNode REPLACE() { return getToken(MySqlParser.REPLACE, 0); } + public TerminalNode LINES() { return getToken(MySqlParser.LINES, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public LoadXmlStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_loadXmlStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLoadXmlStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLoadXmlStatement(this); + } + } + + public final LoadXmlStatementContext loadXmlStatement() throws RecognitionException { + LoadXmlStatementContext _localctx = new LoadXmlStatementContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_loadXmlStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3316); + match(LOAD); + setState(3317); + match(XML); + setState(3319); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOW_PRIORITY || _la==CONCURRENT) { + { + setState(3318); + ((LoadXmlStatementContext)_localctx).priority = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==LOW_PRIORITY || _la==CONCURRENT) ) { + ((LoadXmlStatementContext)_localctx).priority = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3322); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOCAL) { + { + setState(3321); + match(LOCAL); + } + } + + setState(3324); + match(INFILE); + setState(3325); + ((LoadXmlStatementContext)_localctx).filename = match(STRING_LITERAL); + setState(3327); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE || _la==REPLACE) { + { + setState(3326); + ((LoadXmlStatementContext)_localctx).violation = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==IGNORE || _la==REPLACE) ) { + ((LoadXmlStatementContext)_localctx).violation = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3329); + match(INTO); + setState(3330); + match(TABLE); + setState(3331); + tableName(); + setState(3335); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CHARACTER) { + { + setState(3332); + match(CHARACTER); + setState(3333); + match(SET); + setState(3334); + ((LoadXmlStatementContext)_localctx).charset = charsetName(); + } + } + + setState(3343); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ROWS) { + { + setState(3337); + match(ROWS); + setState(3338); + match(IDENTIFIED); + setState(3339); + match(BY); + setState(3340); + match(LESS_SYMBOL); + setState(3341); + ((LoadXmlStatementContext)_localctx).tag = match(STRING_LITERAL); + setState(3342); + match(GREATER_SYMBOL); + } + } + + setState(3349); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE) { + { + setState(3345); + match(IGNORE); + setState(3346); + decimalLiteral(); + setState(3347); + ((LoadXmlStatementContext)_localctx).linesFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==LINES || _la==ROWS) ) { + ((LoadXmlStatementContext)_localctx).linesFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3362); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,449,_ctx) ) { + case 1: + { + setState(3351); + match(LR_BRACKET); + setState(3352); + assignmentField(); + setState(3357); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3353); + match(COMMA); + setState(3354); + assignmentField(); + } + } + setState(3359); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3360); + match(RR_BRACKET); + } + break; + } + setState(3373); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,451,_ctx) ) { + case 1: + { + setState(3364); + match(SET); + setState(3365); + updatedElement(); + setState(3370); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3366); + match(COMMA); + setState(3367); + updatedElement(); + } + } + setState(3372); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReplaceStatementContext extends ParserRuleContext { + public Token priority; + public UidListContext partitions; + public UidListContext columns; + public UpdatedElementContext setFirst; + public UpdatedElementContext updatedElement; + public List setElements = new ArrayList(); + public TerminalNode REPLACE() { return getToken(MySqlParser.REPLACE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public InsertStatementValueContext insertStatementValue() { + return getRuleContext(InsertStatementValueContext.class,0); + } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public List updatedElement() { + return getRuleContexts(UpdatedElementContext.class); + } + public UpdatedElementContext updatedElement(int i) { + return getRuleContext(UpdatedElementContext.class,i); + } + public List uidList() { + return getRuleContexts(UidListContext.class); + } + public UidListContext uidList(int i) { + return getRuleContext(UidListContext.class,i); + } + public TerminalNode LOW_PRIORITY() { return getToken(MySqlParser.LOW_PRIORITY, 0); } + public TerminalNode DELAYED() { return getToken(MySqlParser.DELAYED, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public ReplaceStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_replaceStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReplaceStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReplaceStatement(this); + } + } + + public final ReplaceStatementContext replaceStatement() throws RecognitionException { + ReplaceStatementContext _localctx = new ReplaceStatementContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_replaceStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3375); + match(REPLACE); + setState(3377); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DELAYED || _la==LOW_PRIORITY) { + { + setState(3376); + ((ReplaceStatementContext)_localctx).priority = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DELAYED || _la==LOW_PRIORITY) ) { + ((ReplaceStatementContext)_localctx).priority = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3380); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTO) { + { + setState(3379); + match(INTO); + } + } + + setState(3382); + tableName(); + setState(3388); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(3383); + match(PARTITION); + setState(3384); + match(LR_BRACKET); + setState(3385); + ((ReplaceStatementContext)_localctx).partitions = uidList(); + setState(3386); + match(RR_BRACKET); + } + } + + setState(3406); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + case VALUES: + case VALUE: + case LR_BRACKET: + { + setState(3394); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,455,_ctx) ) { + case 1: + { + setState(3390); + match(LR_BRACKET); + setState(3391); + ((ReplaceStatementContext)_localctx).columns = uidList(); + setState(3392); + match(RR_BRACKET); + } + break; + } + setState(3396); + insertStatementValue(); + } + break; + case SET: + { + setState(3397); + match(SET); + setState(3398); + ((ReplaceStatementContext)_localctx).setFirst = updatedElement(); + setState(3403); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3399); + match(COMMA); + setState(3400); + ((ReplaceStatementContext)_localctx).updatedElement = updatedElement(); + ((ReplaceStatementContext)_localctx).setElements.add(((ReplaceStatementContext)_localctx).updatedElement); + } + } + setState(3405); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SelectStatementContext extends ParserRuleContext { + public SelectStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_selectStatement; } + + public SelectStatementContext() { } + public void copyFrom(SelectStatementContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UnionSelectContext extends SelectStatementContext { + public Token unionType; + public QuerySpecificationNointoContext querySpecificationNointo() { + return getRuleContext(QuerySpecificationNointoContext.class,0); + } + public QueryExpressionNointoContext queryExpressionNointo() { + return getRuleContext(QueryExpressionNointoContext.class,0); + } + public List unionStatement() { + return getRuleContexts(UnionStatementContext.class); + } + public UnionStatementContext unionStatement(int i) { + return getRuleContext(UnionStatementContext.class,i); + } + public TerminalNode UNION() { return getToken(MySqlParser.UNION, 0); } + public OrderByClauseContext orderByClause() { + return getRuleContext(OrderByClauseContext.class,0); + } + public LimitClauseContext limitClause() { + return getRuleContext(LimitClauseContext.class,0); + } + public LockClauseContext lockClause() { + return getRuleContext(LockClauseContext.class,0); + } + public QuerySpecificationContext querySpecification() { + return getRuleContext(QuerySpecificationContext.class,0); + } + public QueryExpressionContext queryExpression() { + return getRuleContext(QueryExpressionContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode DISTINCT() { return getToken(MySqlParser.DISTINCT, 0); } + public UnionSelectContext(SelectStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUnionSelect(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUnionSelect(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UnionParenthesisSelectContext extends SelectStatementContext { + public Token unionType; + public QueryExpressionNointoContext queryExpressionNointo() { + return getRuleContext(QueryExpressionNointoContext.class,0); + } + public List unionParenthesis() { + return getRuleContexts(UnionParenthesisContext.class); + } + public UnionParenthesisContext unionParenthesis(int i) { + return getRuleContext(UnionParenthesisContext.class,i); + } + public TerminalNode UNION() { return getToken(MySqlParser.UNION, 0); } + public QueryExpressionContext queryExpression() { + return getRuleContext(QueryExpressionContext.class,0); + } + public OrderByClauseContext orderByClause() { + return getRuleContext(OrderByClauseContext.class,0); + } + public LimitClauseContext limitClause() { + return getRuleContext(LimitClauseContext.class,0); + } + public LockClauseContext lockClause() { + return getRuleContext(LockClauseContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode DISTINCT() { return getToken(MySqlParser.DISTINCT, 0); } + public UnionParenthesisSelectContext(SelectStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUnionParenthesisSelect(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUnionParenthesisSelect(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SimpleSelectContext extends SelectStatementContext { + public QuerySpecificationContext querySpecification() { + return getRuleContext(QuerySpecificationContext.class,0); + } + public LockClauseContext lockClause() { + return getRuleContext(LockClauseContext.class,0); + } + public SimpleSelectContext(SelectStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleSelect(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleSelect(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ParenthesisSelectContext extends SelectStatementContext { + public QueryExpressionContext queryExpression() { + return getRuleContext(QueryExpressionContext.class,0); + } + public LockClauseContext lockClause() { + return getRuleContext(LockClauseContext.class,0); + } + public ParenthesisSelectContext(SelectStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterParenthesisSelect(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitParenthesisSelect(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class WithLateralStatementContext extends SelectStatementContext { + public QuerySpecificationNointoContext querySpecificationNointo() { + return getRuleContext(QuerySpecificationNointoContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public List lateralStatement() { + return getRuleContexts(LateralStatementContext.class); + } + public LateralStatementContext lateralStatement(int i) { + return getRuleContext(LateralStatementContext.class,i); + } + public WithLateralStatementContext(SelectStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWithLateralStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWithLateralStatement(this); + } + } + + public final SelectStatementContext selectStatement() throws RecognitionException { + SelectStatementContext _localctx = new SelectStatementContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_selectStatement); + int _la; + try { + int _alt; + setState(3473); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,475,_ctx) ) { + case 1: + _localctx = new SimpleSelectContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(3408); + querySpecification(); + setState(3410); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,458,_ctx) ) { + case 1: + { + setState(3409); + lockClause(); + } + break; + } + } + break; + case 2: + _localctx = new ParenthesisSelectContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(3412); + queryExpression(); + setState(3414); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,459,_ctx) ) { + case 1: + { + setState(3413); + lockClause(); + } + break; + } + } + break; + case 3: + _localctx = new UnionSelectContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(3418); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + { + setState(3416); + querySpecificationNointo(); + } + break; + case LR_BRACKET: + { + setState(3417); + queryExpressionNointo(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(3421); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(3420); + unionStatement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3423); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,461,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(3433); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==UNION) { + { + setState(3425); + match(UNION); + setState(3427); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALL || _la==DISTINCT) { + { + setState(3426); + ((UnionSelectContext)_localctx).unionType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ALL || _la==DISTINCT) ) { + ((UnionSelectContext)_localctx).unionType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3431); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + { + setState(3429); + querySpecification(); + } + break; + case LR_BRACKET: + { + setState(3430); + queryExpression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + + setState(3436); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,465,_ctx) ) { + case 1: + { + setState(3435); + orderByClause(); + } + break; + } + setState(3439); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(3438); + limitClause(); + } + } + + setState(3442); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,467,_ctx) ) { + case 1: + { + setState(3441); + lockClause(); + } + break; + } + } + break; + case 4: + _localctx = new UnionParenthesisSelectContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(3444); + queryExpressionNointo(); + setState(3446); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(3445); + unionParenthesis(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3448); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,468,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(3455); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==UNION) { + { + setState(3450); + match(UNION); + setState(3452); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALL || _la==DISTINCT) { + { + setState(3451); + ((UnionParenthesisSelectContext)_localctx).unionType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ALL || _la==DISTINCT) ) { + ((UnionParenthesisSelectContext)_localctx).unionType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3454); + queryExpression(); + } + } + + setState(3458); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,471,_ctx) ) { + case 1: + { + setState(3457); + orderByClause(); + } + break; + } + setState(3461); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(3460); + limitClause(); + } + } + + setState(3464); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,473,_ctx) ) { + case 1: + { + setState(3463); + lockClause(); + } + break; + } + } + break; + case 5: + _localctx = new WithLateralStatementContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(3466); + querySpecificationNointo(); + setState(3469); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(3467); + match(COMMA); + setState(3468); + lateralStatement(); + } + } + setState(3471); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==COMMA ); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UpdateStatementContext extends ParserRuleContext { + public SingleUpdateStatementContext singleUpdateStatement() { + return getRuleContext(SingleUpdateStatementContext.class,0); + } + public MultipleUpdateStatementContext multipleUpdateStatement() { + return getRuleContext(MultipleUpdateStatementContext.class,0); + } + public UpdateStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_updateStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUpdateStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUpdateStatement(this); + } + } + + public final UpdateStatementContext updateStatement() throws RecognitionException { + UpdateStatementContext _localctx = new UpdateStatementContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_updateStatement); + try { + setState(3477); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,476,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3475); + singleUpdateStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3476); + multipleUpdateStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ValuesStatementContext extends ParserRuleContext { + public TerminalNode VALUES() { return getToken(MySqlParser.VALUES, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public List expressionsWithDefaults() { + return getRuleContexts(ExpressionsWithDefaultsContext.class); + } + public ExpressionsWithDefaultsContext expressionsWithDefaults(int i) { + return getRuleContext(ExpressionsWithDefaultsContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public ValuesStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_valuesStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterValuesStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitValuesStatement(this); + } + } + + public final ValuesStatementContext valuesStatement() throws RecognitionException { + ValuesStatementContext _localctx = new ValuesStatementContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_valuesStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3479); + match(VALUES); + setState(3480); + match(LR_BRACKET); + setState(3482); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,477,_ctx) ) { + case 1: + { + setState(3481); + expressionsWithDefaults(); + } + break; + } + setState(3484); + match(RR_BRACKET); + setState(3493); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3485); + match(COMMA); + setState(3486); + match(LR_BRACKET); + setState(3488); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,478,_ctx) ) { + case 1: + { + setState(3487); + expressionsWithDefaults(); + } + break; + } + setState(3490); + match(RR_BRACKET); + } + } + setState(3495); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InsertStatementValueContext extends ParserRuleContext { + public Token insertFormat; + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public TerminalNode VALUES() { return getToken(MySqlParser.VALUES, 0); } + public TerminalNode VALUE() { return getToken(MySqlParser.VALUE, 0); } + public List expressionsWithDefaults() { + return getRuleContexts(ExpressionsWithDefaultsContext.class); + } + public ExpressionsWithDefaultsContext expressionsWithDefaults(int i) { + return getRuleContext(ExpressionsWithDefaultsContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public InsertStatementValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_insertStatementValue; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterInsertStatementValue(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitInsertStatementValue(this); + } + } + + public final InsertStatementValueContext insertStatementValue() throws RecognitionException { + InsertStatementValueContext _localctx = new InsertStatementValueContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_insertStatementValue); + int _la; + try { + setState(3514); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + case LR_BRACKET: + enterOuterAlt(_localctx, 1); + { + setState(3496); + selectStatement(); + } + break; + case VALUES: + case VALUE: + enterOuterAlt(_localctx, 2); + { + setState(3497); + ((InsertStatementValueContext)_localctx).insertFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==VALUES || _la==VALUE) ) { + ((InsertStatementValueContext)_localctx).insertFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3498); + match(LR_BRACKET); + setState(3500); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,480,_ctx) ) { + case 1: + { + setState(3499); + expressionsWithDefaults(); + } + break; + } + setState(3502); + match(RR_BRACKET); + setState(3511); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3503); + match(COMMA); + setState(3504); + match(LR_BRACKET); + setState(3506); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,481,_ctx) ) { + case 1: + { + setState(3505); + expressionsWithDefaults(); + } + break; + } + setState(3508); + match(RR_BRACKET); + } + } + setState(3513); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UpdatedElementContext extends ParserRuleContext { + public FullColumnNameContext fullColumnName() { + return getRuleContext(FullColumnNameContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public UpdatedElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_updatedElement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUpdatedElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUpdatedElement(this); + } + } + + public final UpdatedElementContext updatedElement() throws RecognitionException { + UpdatedElementContext _localctx = new UpdatedElementContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_updatedElement); + try { + enterOuterAlt(_localctx, 1); + { + setState(3516); + fullColumnName(); + setState(3517); + match(EQUAL_SYMBOL); + setState(3520); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,484,_ctx) ) { + case 1: + { + setState(3518); + expression(0); + } + break; + case 2: + { + setState(3519); + match(DEFAULT); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssignmentFieldContext extends ParserRuleContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode LOCAL_ID() { return getToken(MySqlParser.LOCAL_ID, 0); } + public AssignmentFieldContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentField; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAssignmentField(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAssignmentField(this); + } + } + + public final AssignmentFieldContext assignmentField() throws RecognitionException { + AssignmentFieldContext _localctx = new AssignmentFieldContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_assignmentField); + try { + setState(3524); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + enterOuterAlt(_localctx, 1); + { + setState(3522); + uid(); + } + break; + case LOCAL_ID: + enterOuterAlt(_localctx, 2); + { + setState(3523); + match(LOCAL_ID); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LockClauseContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public TerminalNode LOCK() { return getToken(MySqlParser.LOCK, 0); } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public TerminalNode SHARE() { return getToken(MySqlParser.SHARE, 0); } + public TerminalNode MODE() { return getToken(MySqlParser.MODE, 0); } + public LockClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lockClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLockClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLockClause(this); + } + } + + public final LockClauseContext lockClause() throws RecognitionException { + LockClauseContext _localctx = new LockClauseContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_lockClause); + try { + setState(3532); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + setState(3526); + match(FOR); + setState(3527); + match(UPDATE); + } + break; + case LOCK: + enterOuterAlt(_localctx, 2); + { + setState(3528); + match(LOCK); + setState(3529); + match(IN); + setState(3530); + match(SHARE); + setState(3531); + match(MODE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SingleDeleteStatementContext extends ParserRuleContext { + public Token priority; + public TerminalNode DELETE() { return getToken(MySqlParser.DELETE, 0); } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode QUICK() { return getToken(MySqlParser.QUICK, 0); } + public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode WHERE() { return getToken(MySqlParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public OrderByClauseContext orderByClause() { + return getRuleContext(OrderByClauseContext.class,0); + } + public TerminalNode LIMIT() { return getToken(MySqlParser.LIMIT, 0); } + public LimitClauseAtomContext limitClauseAtom() { + return getRuleContext(LimitClauseAtomContext.class,0); + } + public TerminalNode LOW_PRIORITY() { return getToken(MySqlParser.LOW_PRIORITY, 0); } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public SingleDeleteStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_singleDeleteStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSingleDeleteStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSingleDeleteStatement(this); + } + } + + public final SingleDeleteStatementContext singleDeleteStatement() throws RecognitionException { + SingleDeleteStatementContext _localctx = new SingleDeleteStatementContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_singleDeleteStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3534); + match(DELETE); + setState(3536); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOW_PRIORITY) { + { + setState(3535); + ((SingleDeleteStatementContext)_localctx).priority = match(LOW_PRIORITY); + } + } + + setState(3539); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==QUICK) { + { + setState(3538); + match(QUICK); + } + } + + setState(3542); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE) { + { + setState(3541); + match(IGNORE); + } + } + + setState(3544); + match(FROM); + setState(3545); + tableName(); + setState(3550); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,491,_ctx) ) { + case 1: + { + setState(3547); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(3546); + match(AS); + } + } + + setState(3549); + uid(); + } + break; + } + setState(3557); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(3552); + match(PARTITION); + setState(3553); + match(LR_BRACKET); + setState(3554); + uidList(); + setState(3555); + match(RR_BRACKET); + } + } + + setState(3561); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(3559); + match(WHERE); + setState(3560); + expression(0); + } + } + + setState(3564); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ORDER) { + { + setState(3563); + orderByClause(); + } + } + + setState(3568); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(3566); + match(LIMIT); + setState(3567); + limitClauseAtom(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultipleDeleteStatementContext extends ParserRuleContext { + public Token priority; + public TerminalNode DELETE() { return getToken(MySqlParser.DELETE, 0); } + public List tableName() { + return getRuleContexts(TableNameContext.class); + } + public TableNameContext tableName(int i) { + return getRuleContext(TableNameContext.class,i); + } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TableSourcesContext tableSources() { + return getRuleContext(TableSourcesContext.class,0); + } + public TerminalNode USING() { return getToken(MySqlParser.USING, 0); } + public TerminalNode QUICK() { return getToken(MySqlParser.QUICK, 0); } + public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); } + public TerminalNode WHERE() { return getToken(MySqlParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode LOW_PRIORITY() { return getToken(MySqlParser.LOW_PRIORITY, 0); } + public List DOT() { return getTokens(MySqlParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(MySqlParser.DOT, i); + } + public List STAR() { return getTokens(MySqlParser.STAR); } + public TerminalNode STAR(int i) { + return getToken(MySqlParser.STAR, i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public MultipleDeleteStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_multipleDeleteStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMultipleDeleteStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMultipleDeleteStatement(this); + } + } + + public final MultipleDeleteStatementContext multipleDeleteStatement() throws RecognitionException { + MultipleDeleteStatementContext _localctx = new MultipleDeleteStatementContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_multipleDeleteStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3570); + match(DELETE); + setState(3572); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOW_PRIORITY) { + { + setState(3571); + ((MultipleDeleteStatementContext)_localctx).priority = match(LOW_PRIORITY); + } + } + + setState(3575); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,497,_ctx) ) { + case 1: + { + setState(3574); + match(QUICK); + } + break; + } + setState(3578); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE) { + { + setState(3577); + match(IGNORE); + } + } + + setState(3619); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(3580); + tableName(); + setState(3583); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DOT) { + { + setState(3581); + match(DOT); + setState(3582); + match(STAR); + } + } + + setState(3593); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3585); + match(COMMA); + setState(3586); + tableName(); + setState(3589); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DOT) { + { + setState(3587); + match(DOT); + setState(3588); + match(STAR); + } + } + + } + } + setState(3595); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3596); + match(FROM); + setState(3597); + tableSources(); + } + break; + case FROM: + { + setState(3599); + match(FROM); + setState(3600); + tableName(); + setState(3603); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DOT) { + { + setState(3601); + match(DOT); + setState(3602); + match(STAR); + } + } + + setState(3613); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3605); + match(COMMA); + setState(3606); + tableName(); + setState(3609); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DOT) { + { + setState(3607); + match(DOT); + setState(3608); + match(STAR); + } + } + + } + } + setState(3615); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3616); + match(USING); + setState(3617); + tableSources(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(3623); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(3621); + match(WHERE); + setState(3622); + expression(0); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HandlerOpenStatementContext extends ParserRuleContext { + public TerminalNode HANDLER() { return getToken(MySqlParser.HANDLER, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode OPEN() { return getToken(MySqlParser.OPEN, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public HandlerOpenStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_handlerOpenStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerOpenStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerOpenStatement(this); + } + } + + public final HandlerOpenStatementContext handlerOpenStatement() throws RecognitionException { + HandlerOpenStatementContext _localctx = new HandlerOpenStatementContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_handlerOpenStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3625); + match(HANDLER); + setState(3626); + tableName(); + setState(3627); + match(OPEN); + setState(3632); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,508,_ctx) ) { + case 1: + { + setState(3629); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(3628); + match(AS); + } + } + + setState(3631); + uid(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HandlerReadIndexStatementContext extends ParserRuleContext { + public UidContext index; + public Token moveOrder; + public TerminalNode HANDLER() { return getToken(MySqlParser.HANDLER, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode READ() { return getToken(MySqlParser.READ, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public ComparisonOperatorContext comparisonOperator() { + return getRuleContext(ComparisonOperatorContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ConstantsContext constants() { + return getRuleContext(ConstantsContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode WHERE() { return getToken(MySqlParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode LIMIT() { return getToken(MySqlParser.LIMIT, 0); } + public LimitClauseAtomContext limitClauseAtom() { + return getRuleContext(LimitClauseAtomContext.class,0); + } + public TerminalNode FIRST() { return getToken(MySqlParser.FIRST, 0); } + public TerminalNode NEXT() { return getToken(MySqlParser.NEXT, 0); } + public TerminalNode PREV() { return getToken(MySqlParser.PREV, 0); } + public TerminalNode LAST() { return getToken(MySqlParser.LAST, 0); } + public HandlerReadIndexStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_handlerReadIndexStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerReadIndexStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerReadIndexStatement(this); + } + } + + public final HandlerReadIndexStatementContext handlerReadIndexStatement() throws RecognitionException { + HandlerReadIndexStatementContext _localctx = new HandlerReadIndexStatementContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_handlerReadIndexStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3634); + match(HANDLER); + setState(3635); + tableName(); + setState(3636); + match(READ); + setState(3637); + ((HandlerReadIndexStatementContext)_localctx).index = uid(); + setState(3644); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EQUAL_SYMBOL: + case GREATER_SYMBOL: + case LESS_SYMBOL: + case EXCLAMATION_SYMBOL: + { + setState(3638); + comparisonOperator(); + setState(3639); + match(LR_BRACKET); + setState(3640); + constants(); + setState(3641); + match(RR_BRACKET); + } + break; + case FIRST: + case LAST: + case NEXT: + case PREV: + { + setState(3643); + ((HandlerReadIndexStatementContext)_localctx).moveOrder = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FIRST || _la==LAST || _la==NEXT || _la==PREV) ) { + ((HandlerReadIndexStatementContext)_localctx).moveOrder = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3648); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(3646); + match(WHERE); + setState(3647); + expression(0); + } + } + + setState(3652); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(3650); + match(LIMIT); + setState(3651); + limitClauseAtom(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HandlerReadStatementContext extends ParserRuleContext { + public Token moveOrder; + public TerminalNode HANDLER() { return getToken(MySqlParser.HANDLER, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode READ() { return getToken(MySqlParser.READ, 0); } + public TerminalNode FIRST() { return getToken(MySqlParser.FIRST, 0); } + public TerminalNode NEXT() { return getToken(MySqlParser.NEXT, 0); } + public TerminalNode WHERE() { return getToken(MySqlParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode LIMIT() { return getToken(MySqlParser.LIMIT, 0); } + public LimitClauseAtomContext limitClauseAtom() { + return getRuleContext(LimitClauseAtomContext.class,0); + } + public HandlerReadStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_handlerReadStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerReadStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerReadStatement(this); + } + } + + public final HandlerReadStatementContext handlerReadStatement() throws RecognitionException { + HandlerReadStatementContext _localctx = new HandlerReadStatementContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_handlerReadStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3654); + match(HANDLER); + setState(3655); + tableName(); + setState(3656); + match(READ); + setState(3657); + ((HandlerReadStatementContext)_localctx).moveOrder = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FIRST || _la==NEXT) ) { + ((HandlerReadStatementContext)_localctx).moveOrder = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3660); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(3658); + match(WHERE); + setState(3659); + expression(0); + } + } + + setState(3664); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(3662); + match(LIMIT); + setState(3663); + limitClauseAtom(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HandlerCloseStatementContext extends ParserRuleContext { + public TerminalNode HANDLER() { return getToken(MySqlParser.HANDLER, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode CLOSE() { return getToken(MySqlParser.CLOSE, 0); } + public HandlerCloseStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_handlerCloseStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerCloseStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerCloseStatement(this); + } + } + + public final HandlerCloseStatementContext handlerCloseStatement() throws RecognitionException { + HandlerCloseStatementContext _localctx = new HandlerCloseStatementContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_handlerCloseStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(3666); + match(HANDLER); + setState(3667); + tableName(); + setState(3668); + match(CLOSE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SingleUpdateStatementContext extends ParserRuleContext { + public Token priority; + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public List updatedElement() { + return getRuleContexts(UpdatedElementContext.class); + } + public UpdatedElementContext updatedElement(int i) { + return getRuleContext(UpdatedElementContext.class,i); + } + public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode WHERE() { return getToken(MySqlParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public OrderByClauseContext orderByClause() { + return getRuleContext(OrderByClauseContext.class,0); + } + public LimitClauseContext limitClause() { + return getRuleContext(LimitClauseContext.class,0); + } + public TerminalNode LOW_PRIORITY() { return getToken(MySqlParser.LOW_PRIORITY, 0); } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public SingleUpdateStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_singleUpdateStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSingleUpdateStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSingleUpdateStatement(this); + } + } + + public final SingleUpdateStatementContext singleUpdateStatement() throws RecognitionException { + SingleUpdateStatementContext _localctx = new SingleUpdateStatementContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_singleUpdateStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3670); + match(UPDATE); + setState(3672); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOW_PRIORITY) { + { + setState(3671); + ((SingleUpdateStatementContext)_localctx).priority = match(LOW_PRIORITY); + } + } + + setState(3675); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE) { + { + setState(3674); + match(IGNORE); + } + } + + setState(3677); + tableName(); + setState(3682); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026252800L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(3679); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(3678); + match(AS); + } + } + + setState(3681); + uid(); + } + } + + setState(3684); + match(SET); + setState(3685); + updatedElement(); + setState(3690); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3686); + match(COMMA); + setState(3687); + updatedElement(); + } + } + setState(3692); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3695); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(3693); + match(WHERE); + setState(3694); + expression(0); + } + } + + setState(3698); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ORDER) { + { + setState(3697); + orderByClause(); + } + } + + setState(3701); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(3700); + limitClause(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultipleUpdateStatementContext extends ParserRuleContext { + public Token priority; + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public TableSourcesContext tableSources() { + return getRuleContext(TableSourcesContext.class,0); + } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public List updatedElement() { + return getRuleContexts(UpdatedElementContext.class); + } + public UpdatedElementContext updatedElement(int i) { + return getRuleContext(UpdatedElementContext.class,i); + } + public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode WHERE() { return getToken(MySqlParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode LOW_PRIORITY() { return getToken(MySqlParser.LOW_PRIORITY, 0); } + public MultipleUpdateStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_multipleUpdateStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMultipleUpdateStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMultipleUpdateStatement(this); + } + } + + public final MultipleUpdateStatementContext multipleUpdateStatement() throws RecognitionException { + MultipleUpdateStatementContext _localctx = new MultipleUpdateStatementContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_multipleUpdateStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3703); + match(UPDATE); + setState(3705); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOW_PRIORITY) { + { + setState(3704); + ((MultipleUpdateStatementContext)_localctx).priority = match(LOW_PRIORITY); + } + } + + setState(3708); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE) { + { + setState(3707); + match(IGNORE); + } + } + + setState(3710); + tableSources(); + setState(3711); + match(SET); + setState(3712); + updatedElement(); + setState(3717); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3713); + match(COMMA); + setState(3714); + updatedElement(); + } + } + setState(3719); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3722); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(3720); + match(WHERE); + setState(3721); + expression(0); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OrderByClauseContext extends ParserRuleContext { + public TerminalNode ORDER() { return getToken(MySqlParser.ORDER, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public List orderByExpression() { + return getRuleContexts(OrderByExpressionContext.class); + } + public OrderByExpressionContext orderByExpression(int i) { + return getRuleContext(OrderByExpressionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public OrderByClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_orderByClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterOrderByClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitOrderByClause(this); + } + } + + public final OrderByClauseContext orderByClause() throws RecognitionException { + OrderByClauseContext _localctx = new OrderByClauseContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_orderByClause); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3724); + match(ORDER); + setState(3725); + match(BY); + setState(3726); + orderByExpression(); + setState(3731); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,526,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3727); + match(COMMA); + setState(3728); + orderByExpression(); + } + } + } + setState(3733); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,526,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OrderByExpressionContext extends ParserRuleContext { + public Token order; + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode ASC() { return getToken(MySqlParser.ASC, 0); } + public TerminalNode DESC() { return getToken(MySqlParser.DESC, 0); } + public OrderByExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_orderByExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterOrderByExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitOrderByExpression(this); + } + } + + public final OrderByExpressionContext orderByExpression() throws RecognitionException { + OrderByExpressionContext _localctx = new OrderByExpressionContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_orderByExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3734); + expression(0); + setState(3736); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,527,_ctx) ) { + case 1: + { + setState(3735); + ((OrderByExpressionContext)_localctx).order = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ASC || _la==DESC) ) { + ((OrderByExpressionContext)_localctx).order = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableSourcesContext extends ParserRuleContext { + public List tableSource() { + return getRuleContexts(TableSourceContext.class); + } + public TableSourceContext tableSource(int i) { + return getRuleContext(TableSourceContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TableSourcesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableSources; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableSources(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableSources(this); + } + } + + public final TableSourcesContext tableSources() throws RecognitionException { + TableSourcesContext _localctx = new TableSourcesContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_tableSources); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3738); + tableSource(); + setState(3743); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,528,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3739); + match(COMMA); + setState(3740); + tableSource(); + } + } + } + setState(3745); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,528,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableSourceContext extends ParserRuleContext { + public TableSourceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableSource; } + + public TableSourceContext() { } + public void copyFrom(TableSourceContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableJsonContext extends TableSourceContext { + public JsonTableContext jsonTable() { + return getRuleContext(JsonTableContext.class,0); + } + public TableJsonContext(TableSourceContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableJson(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableJson(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableSourceNestedContext extends TableSourceContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TableSourceItemContext tableSourceItem() { + return getRuleContext(TableSourceItemContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List joinPart() { + return getRuleContexts(JoinPartContext.class); + } + public JoinPartContext joinPart(int i) { + return getRuleContext(JoinPartContext.class,i); + } + public TableSourceNestedContext(TableSourceContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableSourceNested(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableSourceNested(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableSourceBaseContext extends TableSourceContext { + public TableSourceItemContext tableSourceItem() { + return getRuleContext(TableSourceItemContext.class,0); + } + public List joinPart() { + return getRuleContexts(JoinPartContext.class); + } + public JoinPartContext joinPart(int i) { + return getRuleContext(JoinPartContext.class,i); + } + public TableSourceBaseContext(TableSourceContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableSourceBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableSourceBase(this); + } + } + + public final TableSourceContext tableSource() throws RecognitionException { + TableSourceContext _localctx = new TableSourceContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_tableSource); + int _la; + try { + int _alt; + setState(3764); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,531,_ctx) ) { + case 1: + _localctx = new TableSourceBaseContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(3746); + tableSourceItem(); + setState(3750); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,529,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3747); + joinPart(); + } + } + } + setState(3752); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,529,_ctx); + } + } + break; + case 2: + _localctx = new TableSourceNestedContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(3753); + match(LR_BRACKET); + setState(3754); + tableSourceItem(); + setState(3758); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 35)) & ~0x3f) == 0 && ((1L << (_la - 35)) & -9150751492863426559L) != 0) || ((((_la - 114)) & ~0x3f) == 0 && ((1L << (_la - 114)) & 288230410511450113L) != 0)) { + { + { + setState(3755); + joinPart(); + } + } + setState(3760); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3761); + match(RR_BRACKET); + } + break; + case 3: + _localctx = new TableJsonContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(3763); + jsonTable(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableSourceItemContext extends ParserRuleContext { + public TableSourceItemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableSourceItem; } + + public TableSourceItemContext() { } + public void copyFrom(TableSourceItemContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SubqueryTableItemContext extends TableSourceItemContext { + public SelectStatementContext parenthesisSubquery; + public UidContext alias; + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public SubqueryTableItemContext(TableSourceItemContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubqueryTableItem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubqueryTableItem(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AtomTableItemContext extends TableSourceItemContext { + public UidContext alias; + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List indexHint() { + return getRuleContexts(IndexHintContext.class); + } + public IndexHintContext indexHint(int i) { + return getRuleContext(IndexHintContext.class,i); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AtomTableItemContext(TableSourceItemContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAtomTableItem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAtomTableItem(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableSourcesItemContext extends TableSourceItemContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TableSourcesContext tableSources() { + return getRuleContext(TableSourcesContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TableSourcesItemContext(TableSourceItemContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableSourcesItem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableSourcesItem(this); + } + } + + public final TableSourceItemContext tableSourceItem() throws RecognitionException { + TableSourceItemContext _localctx = new TableSourceItemContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_tableSourceItem); + int _la; + try { + int _alt; + setState(3806); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,539,_ctx) ) { + case 1: + _localctx = new AtomTableItemContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(3766); + tableName(); + setState(3772); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(3767); + match(PARTITION); + setState(3768); + match(LR_BRACKET); + setState(3769); + uidList(); + setState(3770); + match(RR_BRACKET); + } + } + + setState(3778); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,534,_ctx) ) { + case 1: + { + setState(3775); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(3774); + match(AS); + } + } + + setState(3777); + ((AtomTableItemContext)_localctx).alias = uid(); + } + break; + } + setState(3788); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,536,_ctx) ) { + case 1: + { + setState(3780); + indexHint(); + setState(3785); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,535,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3781); + match(COMMA); + setState(3782); + indexHint(); + } + } + } + setState(3787); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,535,_ctx); + } + } + break; + } + } + break; + case 2: + _localctx = new SubqueryTableItemContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(3795); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,537,_ctx) ) { + case 1: + { + setState(3790); + selectStatement(); + } + break; + case 2: + { + setState(3791); + match(LR_BRACKET); + setState(3792); + ((SubqueryTableItemContext)_localctx).parenthesisSubquery = selectStatement(); + setState(3793); + match(RR_BRACKET); + } + break; + } + setState(3798); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(3797); + match(AS); + } + } + + setState(3800); + ((SubqueryTableItemContext)_localctx).alias = uid(); + } + break; + case 3: + _localctx = new TableSourcesItemContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(3802); + match(LR_BRACKET); + setState(3803); + tableSources(); + setState(3804); + match(RR_BRACKET); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexHintContext extends ParserRuleContext { + public Token indexHintAction; + public Token keyFormat; + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode USE() { return getToken(MySqlParser.USE, 0); } + public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); } + public TerminalNode FORCE() { return getToken(MySqlParser.FORCE, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public IndexHintTypeContext indexHintType() { + return getRuleContext(IndexHintTypeContext.class,0); + } + public IndexHintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexHint; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexHint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexHint(this); + } + } + + public final IndexHintContext indexHint() throws RecognitionException { + IndexHintContext _localctx = new IndexHintContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_indexHint); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3808); + ((IndexHintContext)_localctx).indexHintAction = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FORCE || _la==IGNORE || _la==USE) ) { + ((IndexHintContext)_localctx).indexHintAction = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3809); + ((IndexHintContext)_localctx).keyFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((IndexHintContext)_localctx).keyFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3812); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(3810); + match(FOR); + setState(3811); + indexHintType(); + } + } + + setState(3814); + match(LR_BRACKET); + setState(3815); + uidList(); + setState(3816); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexHintTypeContext extends ParserRuleContext { + public TerminalNode JOIN() { return getToken(MySqlParser.JOIN, 0); } + public TerminalNode ORDER() { return getToken(MySqlParser.ORDER, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); } + public IndexHintTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexHintType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexHintType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexHintType(this); + } + } + + public final IndexHintTypeContext indexHintType() throws RecognitionException { + IndexHintTypeContext _localctx = new IndexHintTypeContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_indexHintType); + try { + setState(3823); + _errHandler.sync(this); + switch (_input.LA(1)) { + case JOIN: + enterOuterAlt(_localctx, 1); + { + setState(3818); + match(JOIN); + } + break; + case ORDER: + enterOuterAlt(_localctx, 2); + { + setState(3819); + match(ORDER); + setState(3820); + match(BY); + } + break; + case GROUP: + enterOuterAlt(_localctx, 3); + { + setState(3821); + match(GROUP); + setState(3822); + match(BY); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class JoinPartContext extends ParserRuleContext { + public JoinPartContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_joinPart; } + + public JoinPartContext() { } + public void copyFrom(JoinPartContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class InnerJoinContext extends JoinPartContext { + public TerminalNode JOIN() { return getToken(MySqlParser.JOIN, 0); } + public TableSourceItemContext tableSourceItem() { + return getRuleContext(TableSourceItemContext.class,0); + } + public TerminalNode LATERAL() { return getToken(MySqlParser.LATERAL, 0); } + public List joinSpec() { + return getRuleContexts(JoinSpecContext.class); + } + public JoinSpecContext joinSpec(int i) { + return getRuleContext(JoinSpecContext.class,i); + } + public TerminalNode INNER() { return getToken(MySqlParser.INNER, 0); } + public TerminalNode CROSS() { return getToken(MySqlParser.CROSS, 0); } + public InnerJoinContext(JoinPartContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterInnerJoin(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitInnerJoin(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NaturalJoinContext extends JoinPartContext { + public TerminalNode NATURAL() { return getToken(MySqlParser.NATURAL, 0); } + public TerminalNode JOIN() { return getToken(MySqlParser.JOIN, 0); } + public TableSourceItemContext tableSourceItem() { + return getRuleContext(TableSourceItemContext.class,0); + } + public TerminalNode LEFT() { return getToken(MySqlParser.LEFT, 0); } + public TerminalNode RIGHT() { return getToken(MySqlParser.RIGHT, 0); } + public TerminalNode OUTER() { return getToken(MySqlParser.OUTER, 0); } + public NaturalJoinContext(JoinPartContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNaturalJoin(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNaturalJoin(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class OuterJoinContext extends JoinPartContext { + public TerminalNode JOIN() { return getToken(MySqlParser.JOIN, 0); } + public TableSourceItemContext tableSourceItem() { + return getRuleContext(TableSourceItemContext.class,0); + } + public TerminalNode LEFT() { return getToken(MySqlParser.LEFT, 0); } + public TerminalNode RIGHT() { return getToken(MySqlParser.RIGHT, 0); } + public TerminalNode OUTER() { return getToken(MySqlParser.OUTER, 0); } + public TerminalNode LATERAL() { return getToken(MySqlParser.LATERAL, 0); } + public List joinSpec() { + return getRuleContexts(JoinSpecContext.class); + } + public JoinSpecContext joinSpec(int i) { + return getRuleContext(JoinSpecContext.class,i); + } + public OuterJoinContext(JoinPartContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterOuterJoin(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitOuterJoin(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class StraightJoinContext extends JoinPartContext { + public TerminalNode STRAIGHT_JOIN() { return getToken(MySqlParser.STRAIGHT_JOIN, 0); } + public TableSourceItemContext tableSourceItem() { + return getRuleContext(TableSourceItemContext.class,0); + } + public List ON() { return getTokens(MySqlParser.ON); } + public TerminalNode ON(int i) { + return getToken(MySqlParser.ON, i); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public StraightJoinContext(JoinPartContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStraightJoin(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStraightJoin(this); + } + } + + public final JoinPartContext joinPart() throws RecognitionException { + JoinPartContext _localctx = new JoinPartContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_joinPart); + int _la; + try { + int _alt; + setState(3872); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CROSS: + case INNER: + case JOIN: + _localctx = new InnerJoinContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(3826); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CROSS || _la==INNER) { + { + setState(3825); + _la = _input.LA(1); + if ( !(_la==CROSS || _la==INNER) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3828); + match(JOIN); + setState(3830); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,543,_ctx) ) { + case 1: + { + setState(3829); + match(LATERAL); + } + break; + } + setState(3832); + tableSourceItem(); + setState(3836); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,544,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3833); + joinSpec(); + } + } + } + setState(3838); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,544,_ctx); + } + } + break; + case STRAIGHT_JOIN: + _localctx = new StraightJoinContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(3839); + match(STRAIGHT_JOIN); + setState(3840); + tableSourceItem(); + setState(3845); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,545,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3841); + match(ON); + setState(3842); + expression(0); + } + } + } + setState(3847); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,545,_ctx); + } + } + break; + case LEFT: + case RIGHT: + _localctx = new OuterJoinContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(3848); + _la = _input.LA(1); + if ( !(_la==LEFT || _la==RIGHT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3850); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OUTER) { + { + setState(3849); + match(OUTER); + } + } + + setState(3852); + match(JOIN); + setState(3854); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,547,_ctx) ) { + case 1: + { + setState(3853); + match(LATERAL); + } + break; + } + setState(3856); + tableSourceItem(); + setState(3860); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,548,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3857); + joinSpec(); + } + } + } + setState(3862); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,548,_ctx); + } + } + break; + case NATURAL: + _localctx = new NaturalJoinContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(3863); + match(NATURAL); + setState(3868); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LEFT || _la==RIGHT) { + { + setState(3864); + _la = _input.LA(1); + if ( !(_la==LEFT || _la==RIGHT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3866); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OUTER) { + { + setState(3865); + match(OUTER); + } + } + + } + } + + setState(3870); + match(JOIN); + setState(3871); + tableSourceItem(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class JoinSpecContext extends ParserRuleContext { + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode USING() { return getToken(MySqlParser.USING, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public JoinSpecContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_joinSpec; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJoinSpec(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJoinSpec(this); + } + } + + public final JoinSpecContext joinSpec() throws RecognitionException { + JoinSpecContext _localctx = new JoinSpecContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_joinSpec); + try { + setState(3881); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ON: + enterOuterAlt(_localctx, 1); + { + { + setState(3874); + match(ON); + setState(3875); + expression(0); + } + } + break; + case USING: + enterOuterAlt(_localctx, 2); + { + setState(3876); + match(USING); + setState(3877); + match(LR_BRACKET); + setState(3878); + uidList(); + setState(3879); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class QueryExpressionContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public QuerySpecificationContext querySpecification() { + return getRuleContext(QuerySpecificationContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public QueryExpressionContext queryExpression() { + return getRuleContext(QueryExpressionContext.class,0); + } + public QueryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_queryExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterQueryExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitQueryExpression(this); + } + } + + public final QueryExpressionContext queryExpression() throws RecognitionException { + QueryExpressionContext _localctx = new QueryExpressionContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_queryExpression); + try { + setState(3891); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,553,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3883); + match(LR_BRACKET); + setState(3884); + querySpecification(); + setState(3885); + match(RR_BRACKET); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3887); + match(LR_BRACKET); + setState(3888); + queryExpression(); + setState(3889); + match(RR_BRACKET); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class QueryExpressionNointoContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public QuerySpecificationNointoContext querySpecificationNointo() { + return getRuleContext(QuerySpecificationNointoContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public QueryExpressionNointoContext queryExpressionNointo() { + return getRuleContext(QueryExpressionNointoContext.class,0); + } + public QueryExpressionNointoContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_queryExpressionNointo; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterQueryExpressionNointo(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitQueryExpressionNointo(this); + } + } + + public final QueryExpressionNointoContext queryExpressionNointo() throws RecognitionException { + QueryExpressionNointoContext _localctx = new QueryExpressionNointoContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_queryExpressionNointo); + try { + setState(3901); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,554,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3893); + match(LR_BRACKET); + setState(3894); + querySpecificationNointo(); + setState(3895); + match(RR_BRACKET); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3897); + match(LR_BRACKET); + setState(3898); + queryExpressionNointo(); + setState(3899); + match(RR_BRACKET); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class QuerySpecificationContext extends ParserRuleContext { + public TerminalNode SELECT() { return getToken(MySqlParser.SELECT, 0); } + public SelectElementsContext selectElements() { + return getRuleContext(SelectElementsContext.class,0); + } + public FromClauseContext fromClause() { + return getRuleContext(FromClauseContext.class,0); + } + public List selectSpec() { + return getRuleContexts(SelectSpecContext.class); + } + public SelectSpecContext selectSpec(int i) { + return getRuleContext(SelectSpecContext.class,i); + } + public SelectIntoExpressionContext selectIntoExpression() { + return getRuleContext(SelectIntoExpressionContext.class,0); + } + public GroupByClauseContext groupByClause() { + return getRuleContext(GroupByClauseContext.class,0); + } + public HavingClauseContext havingClause() { + return getRuleContext(HavingClauseContext.class,0); + } + public WindowClauseContext windowClause() { + return getRuleContext(WindowClauseContext.class,0); + } + public OrderByClauseContext orderByClause() { + return getRuleContext(OrderByClauseContext.class,0); + } + public LimitClauseContext limitClause() { + return getRuleContext(LimitClauseContext.class,0); + } + public QuerySpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_querySpecification; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterQuerySpecification(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitQuerySpecification(this); + } + } + + public final QuerySpecificationContext querySpecification() throws RecognitionException { + QuerySpecificationContext _localctx = new QuerySpecificationContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_querySpecification); + int _la; + try { + int _alt; + setState(3957); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,569,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3903); + match(SELECT); + setState(3907); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,555,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3904); + selectSpec(); + } + } + } + setState(3909); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,555,_ctx); + } + setState(3910); + selectElements(); + setState(3912); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTO) { + { + setState(3911); + selectIntoExpression(); + } + } + + setState(3914); + fromClause(); + setState(3916); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,557,_ctx) ) { + case 1: + { + setState(3915); + groupByClause(); + } + break; + } + setState(3919); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==HAVING) { + { + setState(3918); + havingClause(); + } + } + + setState(3922); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WINDOW) { + { + setState(3921); + windowClause(); + } + } + + setState(3925); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,560,_ctx) ) { + case 1: + { + setState(3924); + orderByClause(); + } + break; + } + setState(3928); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,561,_ctx) ) { + case 1: + { + setState(3927); + limitClause(); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3930); + match(SELECT); + setState(3934); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,562,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3931); + selectSpec(); + } + } + } + setState(3936); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,562,_ctx); + } + setState(3937); + selectElements(); + setState(3938); + fromClause(); + setState(3940); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,563,_ctx) ) { + case 1: + { + setState(3939); + groupByClause(); + } + break; + } + setState(3943); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==HAVING) { + { + setState(3942); + havingClause(); + } + } + + setState(3946); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WINDOW) { + { + setState(3945); + windowClause(); + } + } + + setState(3949); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,566,_ctx) ) { + case 1: + { + setState(3948); + orderByClause(); + } + break; + } + setState(3952); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,567,_ctx) ) { + case 1: + { + setState(3951); + limitClause(); + } + break; + } + setState(3955); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTO) { + { + setState(3954); + selectIntoExpression(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class QuerySpecificationNointoContext extends ParserRuleContext { + public TerminalNode SELECT() { return getToken(MySqlParser.SELECT, 0); } + public SelectElementsContext selectElements() { + return getRuleContext(SelectElementsContext.class,0); + } + public FromClauseContext fromClause() { + return getRuleContext(FromClauseContext.class,0); + } + public List selectSpec() { + return getRuleContexts(SelectSpecContext.class); + } + public SelectSpecContext selectSpec(int i) { + return getRuleContext(SelectSpecContext.class,i); + } + public GroupByClauseContext groupByClause() { + return getRuleContext(GroupByClauseContext.class,0); + } + public HavingClauseContext havingClause() { + return getRuleContext(HavingClauseContext.class,0); + } + public WindowClauseContext windowClause() { + return getRuleContext(WindowClauseContext.class,0); + } + public OrderByClauseContext orderByClause() { + return getRuleContext(OrderByClauseContext.class,0); + } + public LimitClauseContext limitClause() { + return getRuleContext(LimitClauseContext.class,0); + } + public UnionStatementContext unionStatement() { + return getRuleContext(UnionStatementContext.class,0); + } + public QuerySpecificationNointoContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_querySpecificationNointo; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterQuerySpecificationNointo(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitQuerySpecificationNointo(this); + } + } + + public final QuerySpecificationNointoContext querySpecificationNointo() throws RecognitionException { + QuerySpecificationNointoContext _localctx = new QuerySpecificationNointoContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_querySpecificationNointo); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3959); + match(SELECT); + setState(3963); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,570,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(3960); + selectSpec(); + } + } + } + setState(3965); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,570,_ctx); + } + setState(3966); + selectElements(); + setState(3967); + fromClause(); + setState(3969); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,571,_ctx) ) { + case 1: + { + setState(3968); + groupByClause(); + } + break; + } + setState(3972); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==HAVING) { + { + setState(3971); + havingClause(); + } + } + + setState(3975); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WINDOW) { + { + setState(3974); + windowClause(); + } + } + + setState(3978); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,574,_ctx) ) { + case 1: + { + setState(3977); + orderByClause(); + } + break; + } + setState(3981); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,575,_ctx) ) { + case 1: + { + setState(3980); + limitClause(); + } + break; + } + setState(3984); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,576,_ctx) ) { + case 1: + { + setState(3983); + unionStatement(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UnionParenthesisContext extends ParserRuleContext { + public Token unionType; + public TerminalNode UNION() { return getToken(MySqlParser.UNION, 0); } + public QueryExpressionNointoContext queryExpressionNointo() { + return getRuleContext(QueryExpressionNointoContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode DISTINCT() { return getToken(MySqlParser.DISTINCT, 0); } + public UnionParenthesisContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unionParenthesis; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUnionParenthesis(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUnionParenthesis(this); + } + } + + public final UnionParenthesisContext unionParenthesis() throws RecognitionException { + UnionParenthesisContext _localctx = new UnionParenthesisContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_unionParenthesis); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3986); + match(UNION); + setState(3988); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALL || _la==DISTINCT) { + { + setState(3987); + ((UnionParenthesisContext)_localctx).unionType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ALL || _la==DISTINCT) ) { + ((UnionParenthesisContext)_localctx).unionType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3990); + queryExpressionNointo(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UnionStatementContext extends ParserRuleContext { + public Token unionType; + public TerminalNode UNION() { return getToken(MySqlParser.UNION, 0); } + public QuerySpecificationNointoContext querySpecificationNointo() { + return getRuleContext(QuerySpecificationNointoContext.class,0); + } + public QueryExpressionNointoContext queryExpressionNointo() { + return getRuleContext(QueryExpressionNointoContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode DISTINCT() { return getToken(MySqlParser.DISTINCT, 0); } + public UnionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unionStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUnionStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUnionStatement(this); + } + } + + public final UnionStatementContext unionStatement() throws RecognitionException { + UnionStatementContext _localctx = new UnionStatementContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_unionStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3992); + match(UNION); + setState(3994); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALL || _la==DISTINCT) { + { + setState(3993); + ((UnionStatementContext)_localctx).unionType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ALL || _la==DISTINCT) ) { + ((UnionStatementContext)_localctx).unionType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(3998); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + { + setState(3996); + querySpecificationNointo(); + } + break; + case LR_BRACKET: + { + setState(3997); + queryExpressionNointo(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LateralStatementContext extends ParserRuleContext { + public TerminalNode LATERAL() { return getToken(MySqlParser.LATERAL, 0); } + public QuerySpecificationNointoContext querySpecificationNointo() { + return getRuleContext(QuerySpecificationNointoContext.class,0); + } + public QueryExpressionNointoContext queryExpressionNointo() { + return getRuleContext(QueryExpressionNointoContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public LateralStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lateralStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLateralStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLateralStatement(this); + } + } + + public final LateralStatementContext lateralStatement() throws RecognitionException { + LateralStatementContext _localctx = new LateralStatementContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_lateralStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4000); + match(LATERAL); + setState(4015); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,583,_ctx) ) { + case 1: + { + setState(4001); + querySpecificationNointo(); + } + break; + case 2: + { + setState(4002); + queryExpressionNointo(); + } + break; + case 3: + { + { + setState(4003); + match(LR_BRACKET); + setState(4006); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + { + setState(4004); + querySpecificationNointo(); + } + break; + case LR_BRACKET: + { + setState(4005); + queryExpressionNointo(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(4008); + match(RR_BRACKET); + setState(4013); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,582,_ctx) ) { + case 1: + { + setState(4010); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(4009); + match(AS); + } + } + + setState(4012); + uid(); + } + break; + } + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class JsonTableContext extends ParserRuleContext { + public TerminalNode JSON_TABLE() { return getToken(MySqlParser.JSON_TABLE, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List STRING_LITERAL() { return getTokens(MySqlParser.STRING_LITERAL); } + public TerminalNode STRING_LITERAL(int i) { + return getToken(MySqlParser.STRING_LITERAL, i); + } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); } + public JsonColumnListContext jsonColumnList() { + return getRuleContext(JsonColumnListContext.class,0); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public JsonTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_jsonTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJsonTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJsonTable(this); + } + } + + public final JsonTableContext jsonTable() throws RecognitionException { + JsonTableContext _localctx = new JsonTableContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_jsonTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4017); + match(JSON_TABLE); + setState(4018); + match(LR_BRACKET); + setState(4019); + match(STRING_LITERAL); + setState(4020); + match(COMMA); + setState(4021); + match(STRING_LITERAL); + setState(4022); + match(COLUMNS); + setState(4023); + match(LR_BRACKET); + setState(4024); + jsonColumnList(); + setState(4025); + match(RR_BRACKET); + setState(4026); + match(RR_BRACKET); + setState(4031); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,585,_ctx) ) { + case 1: + { + setState(4028); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(4027); + match(AS); + } + } + + setState(4030); + uid(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class JsonColumnListContext extends ParserRuleContext { + public List jsonColumn() { + return getRuleContexts(JsonColumnContext.class); + } + public JsonColumnContext jsonColumn(int i) { + return getRuleContext(JsonColumnContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public JsonColumnListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_jsonColumnList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJsonColumnList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJsonColumnList(this); + } + } + + public final JsonColumnListContext jsonColumnList() throws RecognitionException { + JsonColumnListContext _localctx = new JsonColumnListContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_jsonColumnList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4033); + jsonColumn(); + setState(4038); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4034); + match(COMMA); + setState(4035); + jsonColumn(); + } + } + setState(4040); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class JsonColumnContext extends ParserRuleContext { + public FullColumnNameContext fullColumnName() { + return getRuleContext(FullColumnNameContext.class,0); + } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode ORDINALITY() { return getToken(MySqlParser.ORDINALITY, 0); } + public DataTypeContext dataType() { + return getRuleContext(DataTypeContext.class,0); + } + public TerminalNode PATH() { return getToken(MySqlParser.PATH, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode EXISTS() { return getToken(MySqlParser.EXISTS, 0); } + public JsonOnEmptyContext jsonOnEmpty() { + return getRuleContext(JsonOnEmptyContext.class,0); + } + public JsonOnErrorContext jsonOnError() { + return getRuleContext(JsonOnErrorContext.class,0); + } + public TerminalNode NESTED() { return getToken(MySqlParser.NESTED, 0); } + public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public JsonColumnListContext jsonColumnList() { + return getRuleContext(JsonColumnListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public JsonColumnContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_jsonColumn; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJsonColumn(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJsonColumn(this); + } + } + + public final JsonColumnContext jsonColumn() throws RecognitionException { + JsonColumnContext _localctx = new JsonColumnContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_jsonColumn); + int _la; + try { + setState(4070); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,592,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4041); + fullColumnName(); + setState(4058); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + { + setState(4042); + match(FOR); + setState(4043); + match(ORDINALITY); + } + break; + case CHARACTER: + case SET: + case TINYINT: + case SMALLINT: + case MEDIUMINT: + case MIDDLEINT: + case INT: + case INT1: + case INT2: + case INT3: + case INT4: + case INT8: + case INTEGER: + case BIGINT: + case REAL: + case DOUBLE: + case FLOAT: + case FLOAT4: + case FLOAT8: + case DECIMAL: + case DEC: + case NUMERIC: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case CHAR: + case VARCHAR: + case NVARCHAR: + case NATIONAL: + case BINARY: + case VARBINARY: + case TINYBLOB: + case BLOB: + case MEDIUMBLOB: + case LONG: + case LONGBLOB: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + case ENUM: + case SERIAL: + case BIT: + case BOOL: + case BOOLEAN: + case FIXED: + case JSON: + case NCHAR: + case GEOMETRYCOLLECTION: + case GEOMCOLLECTION: + case GEOMETRY: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + { + setState(4044); + dataType(); + setState(4056); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PATH: + { + setState(4045); + match(PATH); + setState(4046); + match(STRING_LITERAL); + setState(4048); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,587,_ctx) ) { + case 1: + { + setState(4047); + jsonOnEmpty(); + } + break; + } + setState(4051); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT || _la==NULL_LITERAL || _la==ERROR) { + { + setState(4050); + jsonOnError(); + } + } + + } + break; + case EXISTS: + { + setState(4053); + match(EXISTS); + setState(4054); + match(PATH); + setState(4055); + match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4060); + match(NESTED); + setState(4062); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PATH) { + { + setState(4061); + match(PATH); + } + } + + setState(4064); + match(STRING_LITERAL); + setState(4065); + match(COLUMNS); + setState(4066); + match(LR_BRACKET); + setState(4067); + jsonColumnList(); + setState(4068); + match(RR_BRACKET); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class JsonOnEmptyContext extends ParserRuleContext { + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TerminalNode EMPTY() { return getToken(MySqlParser.EMPTY, 0); } + public TerminalNode NULL_LITERAL() { return getToken(MySqlParser.NULL_LITERAL, 0); } + public TerminalNode ERROR() { return getToken(MySqlParser.ERROR, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public DefaultValueContext defaultValue() { + return getRuleContext(DefaultValueContext.class,0); + } + public JsonOnEmptyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_jsonOnEmpty; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJsonOnEmpty(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJsonOnEmpty(this); + } + } + + public final JsonOnEmptyContext jsonOnEmpty() throws RecognitionException { + JsonOnEmptyContext _localctx = new JsonOnEmptyContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_jsonOnEmpty); + try { + enterOuterAlt(_localctx, 1); + { + setState(4076); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NULL_LITERAL: + { + setState(4072); + match(NULL_LITERAL); + } + break; + case ERROR: + { + setState(4073); + match(ERROR); + } + break; + case DEFAULT: + { + setState(4074); + match(DEFAULT); + setState(4075); + defaultValue(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(4078); + match(ON); + setState(4079); + match(EMPTY); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class JsonOnErrorContext extends ParserRuleContext { + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public List ERROR() { return getTokens(MySqlParser.ERROR); } + public TerminalNode ERROR(int i) { + return getToken(MySqlParser.ERROR, i); + } + public TerminalNode NULL_LITERAL() { return getToken(MySqlParser.NULL_LITERAL, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public DefaultValueContext defaultValue() { + return getRuleContext(DefaultValueContext.class,0); + } + public JsonOnErrorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_jsonOnError; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJsonOnError(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJsonOnError(this); + } + } + + public final JsonOnErrorContext jsonOnError() throws RecognitionException { + JsonOnErrorContext _localctx = new JsonOnErrorContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_jsonOnError); + try { + enterOuterAlt(_localctx, 1); + { + setState(4085); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NULL_LITERAL: + { + setState(4081); + match(NULL_LITERAL); + } + break; + case ERROR: + { + setState(4082); + match(ERROR); + } + break; + case DEFAULT: + { + setState(4083); + match(DEFAULT); + setState(4084); + defaultValue(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(4087); + match(ON); + setState(4088); + match(ERROR); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SelectSpecContext extends ParserRuleContext { + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode DISTINCT() { return getToken(MySqlParser.DISTINCT, 0); } + public TerminalNode DISTINCTROW() { return getToken(MySqlParser.DISTINCTROW, 0); } + public TerminalNode HIGH_PRIORITY() { return getToken(MySqlParser.HIGH_PRIORITY, 0); } + public TerminalNode STRAIGHT_JOIN() { return getToken(MySqlParser.STRAIGHT_JOIN, 0); } + public TerminalNode SQL_SMALL_RESULT() { return getToken(MySqlParser.SQL_SMALL_RESULT, 0); } + public TerminalNode SQL_BIG_RESULT() { return getToken(MySqlParser.SQL_BIG_RESULT, 0); } + public TerminalNode SQL_BUFFER_RESULT() { return getToken(MySqlParser.SQL_BUFFER_RESULT, 0); } + public TerminalNode SQL_CACHE() { return getToken(MySqlParser.SQL_CACHE, 0); } + public TerminalNode SQL_NO_CACHE() { return getToken(MySqlParser.SQL_NO_CACHE, 0); } + public TerminalNode SQL_CALC_FOUND_ROWS() { return getToken(MySqlParser.SQL_CALC_FOUND_ROWS, 0); } + public SelectSpecContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_selectSpec; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectSpec(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectSpec(this); + } + } + + public final SelectSpecContext selectSpec() throws RecognitionException { + SelectSpecContext _localctx = new SelectSpecContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_selectSpec); + int _la; + try { + setState(4098); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALL: + case DISTINCT: + case DISTINCTROW: + enterOuterAlt(_localctx, 1); + { + setState(4090); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 3377699720528000L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case HIGH_PRIORITY: + enterOuterAlt(_localctx, 2); + { + setState(4091); + match(HIGH_PRIORITY); + } + break; + case STRAIGHT_JOIN: + enterOuterAlt(_localctx, 3); + { + setState(4092); + match(STRAIGHT_JOIN); + } + break; + case SQL_SMALL_RESULT: + enterOuterAlt(_localctx, 4); + { + setState(4093); + match(SQL_SMALL_RESULT); + } + break; + case SQL_BIG_RESULT: + enterOuterAlt(_localctx, 5); + { + setState(4094); + match(SQL_BIG_RESULT); + } + break; + case SQL_BUFFER_RESULT: + enterOuterAlt(_localctx, 6); + { + setState(4095); + match(SQL_BUFFER_RESULT); + } + break; + case SQL_CACHE: + case SQL_NO_CACHE: + enterOuterAlt(_localctx, 7); + { + setState(4096); + _la = _input.LA(1); + if ( !(_la==SQL_CACHE || _la==SQL_NO_CACHE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case SQL_CALC_FOUND_ROWS: + enterOuterAlt(_localctx, 8); + { + setState(4097); + match(SQL_CALC_FOUND_ROWS); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SelectElementsContext extends ParserRuleContext { + public Token star; + public List selectElement() { + return getRuleContexts(SelectElementContext.class); + } + public SelectElementContext selectElement(int i) { + return getRuleContext(SelectElementContext.class,i); + } + public TerminalNode STAR() { return getToken(MySqlParser.STAR, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public SelectElementsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_selectElements; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectElements(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectElements(this); + } + } + + public final SelectElementsContext selectElements() throws RecognitionException { + SelectElementsContext _localctx = new SelectElementsContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_selectElements); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4102); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,596,_ctx) ) { + case 1: + { + setState(4100); + ((SelectElementsContext)_localctx).star = match(STAR); + } + break; + case 2: + { + setState(4101); + selectElement(); + } + break; + } + setState(4108); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,597,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4104); + match(COMMA); + setState(4105); + selectElement(); + } + } + } + setState(4110); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,597,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SelectElementContext extends ParserRuleContext { + public SelectElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_selectElement; } + + public SelectElementContext() { } + public void copyFrom(SelectElementContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SelectExpressionElementContext extends SelectElementContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode LOCAL_ID() { return getToken(MySqlParser.LOCAL_ID, 0); } + public TerminalNode VAR_ASSIGN() { return getToken(MySqlParser.VAR_ASSIGN, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public SelectExpressionElementContext(SelectElementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectExpressionElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectExpressionElement(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SelectFunctionElementContext extends SelectElementContext { + public FunctionCallContext functionCall() { + return getRuleContext(FunctionCallContext.class,0); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public SelectFunctionElementContext(SelectElementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectFunctionElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectFunctionElement(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SelectStarElementContext extends SelectElementContext { + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode DOT() { return getToken(MySqlParser.DOT, 0); } + public TerminalNode STAR() { return getToken(MySqlParser.STAR, 0); } + public SelectStarElementContext(SelectElementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectStarElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectStarElement(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SelectColumnElementContext extends SelectElementContext { + public FullColumnNameContext fullColumnName() { + return getRuleContext(FullColumnNameContext.class,0); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public SelectColumnElementContext(SelectElementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectColumnElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectColumnElement(this); + } + } + + public final SelectElementContext selectElement() throws RecognitionException { + SelectElementContext _localctx = new SelectElementContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_selectElement); + int _la; + try { + setState(4140); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,605,_ctx) ) { + case 1: + _localctx = new SelectStarElementContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(4111); + fullId(); + setState(4112); + match(DOT); + setState(4113); + match(STAR); + } + break; + case 2: + _localctx = new SelectColumnElementContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(4115); + fullColumnName(); + setState(4120); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,599,_ctx) ) { + case 1: + { + setState(4117); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(4116); + match(AS); + } + } + + setState(4119); + uid(); + } + break; + } + } + break; + case 3: + _localctx = new SelectFunctionElementContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(4122); + functionCall(); + setState(4127); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,601,_ctx) ) { + case 1: + { + setState(4124); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(4123); + match(AS); + } + } + + setState(4126); + uid(); + } + break; + } + } + break; + case 4: + _localctx = new SelectExpressionElementContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(4131); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,602,_ctx) ) { + case 1: + { + setState(4129); + match(LOCAL_ID); + setState(4130); + match(VAR_ASSIGN); + } + break; + } + setState(4133); + expression(0); + setState(4138); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,604,_ctx) ) { + case 1: + { + setState(4135); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(4134); + match(AS); + } + } + + setState(4137); + uid(); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SelectIntoExpressionContext extends ParserRuleContext { + public SelectIntoExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_selectIntoExpression; } + + public SelectIntoExpressionContext() { } + public void copyFrom(SelectIntoExpressionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SelectIntoVariablesContext extends SelectIntoExpressionContext { + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public List assignmentField() { + return getRuleContexts(AssignmentFieldContext.class); + } + public AssignmentFieldContext assignmentField(int i) { + return getRuleContext(AssignmentFieldContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public SelectIntoVariablesContext(SelectIntoExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectIntoVariables(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectIntoVariables(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SelectIntoTextFileContext extends SelectIntoExpressionContext { + public Token filename; + public CharsetNameContext charset; + public Token fieldsFormat; + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public TerminalNode OUTFILE() { return getToken(MySqlParser.OUTFILE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode LINES() { return getToken(MySqlParser.LINES, 0); } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode FIELDS() { return getToken(MySqlParser.FIELDS, 0); } + public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); } + public List selectFieldsInto() { + return getRuleContexts(SelectFieldsIntoContext.class); + } + public SelectFieldsIntoContext selectFieldsInto(int i) { + return getRuleContext(SelectFieldsIntoContext.class,i); + } + public List selectLinesInto() { + return getRuleContexts(SelectLinesIntoContext.class); + } + public SelectLinesIntoContext selectLinesInto(int i) { + return getRuleContext(SelectLinesIntoContext.class,i); + } + public SelectIntoTextFileContext(SelectIntoExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectIntoTextFile(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectIntoTextFile(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SelectIntoDumpFileContext extends SelectIntoExpressionContext { + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public TerminalNode DUMPFILE() { return getToken(MySqlParser.DUMPFILE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public SelectIntoDumpFileContext(SelectIntoExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectIntoDumpFile(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectIntoDumpFile(this); + } + } + + public final SelectIntoExpressionContext selectIntoExpression() throws RecognitionException { + SelectIntoExpressionContext _localctx = new SelectIntoExpressionContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_selectIntoExpression); + int _la; + try { + setState(4178); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,612,_ctx) ) { + case 1: + _localctx = new SelectIntoVariablesContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(4142); + match(INTO); + setState(4143); + assignmentField(); + setState(4148); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4144); + match(COMMA); + setState(4145); + assignmentField(); + } + } + setState(4150); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + _localctx = new SelectIntoDumpFileContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(4151); + match(INTO); + setState(4152); + match(DUMPFILE); + setState(4153); + match(STRING_LITERAL); + } + break; + case 3: + _localctx = new SelectIntoTextFileContext(_localctx); + enterOuterAlt(_localctx, 3); + { + { + setState(4154); + match(INTO); + setState(4155); + match(OUTFILE); + setState(4156); + ((SelectIntoTextFileContext)_localctx).filename = match(STRING_LITERAL); + setState(4160); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CHARACTER) { + { + setState(4157); + match(CHARACTER); + setState(4158); + match(SET); + setState(4159); + ((SelectIntoTextFileContext)_localctx).charset = charsetName(); + } + } + + setState(4168); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,609,_ctx) ) { + case 1: + { + setState(4162); + ((SelectIntoTextFileContext)_localctx).fieldsFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==COLUMNS || _la==FIELDS) ) { + ((SelectIntoTextFileContext)_localctx).fieldsFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4164); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(4163); + selectFieldsInto(); + } + } + setState(4166); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==ENCLOSED || _la==ESCAPED || _la==OPTIONALLY || _la==TERMINATED ); + } + break; + } + setState(4176); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LINES) { + { + setState(4170); + match(LINES); + setState(4172); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(4171); + selectLinesInto(); + } + } + setState(4174); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==STARTING || _la==TERMINATED ); + } + } + + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SelectFieldsIntoContext extends ParserRuleContext { + public Token terminationField; + public Token enclosion; + public Token escaping; + public TerminalNode TERMINATED() { return getToken(MySqlParser.TERMINATED, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode ENCLOSED() { return getToken(MySqlParser.ENCLOSED, 0); } + public TerminalNode OPTIONALLY() { return getToken(MySqlParser.OPTIONALLY, 0); } + public TerminalNode ESCAPED() { return getToken(MySqlParser.ESCAPED, 0); } + public SelectFieldsIntoContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_selectFieldsInto; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectFieldsInto(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectFieldsInto(this); + } + } + + public final SelectFieldsIntoContext selectFieldsInto() throws RecognitionException { + SelectFieldsIntoContext _localctx = new SelectFieldsIntoContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_selectFieldsInto); + int _la; + try { + setState(4192); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TERMINATED: + enterOuterAlt(_localctx, 1); + { + setState(4180); + match(TERMINATED); + setState(4181); + match(BY); + setState(4182); + ((SelectFieldsIntoContext)_localctx).terminationField = match(STRING_LITERAL); + } + break; + case ENCLOSED: + case OPTIONALLY: + enterOuterAlt(_localctx, 2); + { + setState(4184); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPTIONALLY) { + { + setState(4183); + match(OPTIONALLY); + } + } + + setState(4186); + match(ENCLOSED); + setState(4187); + match(BY); + setState(4188); + ((SelectFieldsIntoContext)_localctx).enclosion = match(STRING_LITERAL); + } + break; + case ESCAPED: + enterOuterAlt(_localctx, 3); + { + setState(4189); + match(ESCAPED); + setState(4190); + match(BY); + setState(4191); + ((SelectFieldsIntoContext)_localctx).escaping = match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SelectLinesIntoContext extends ParserRuleContext { + public Token starting; + public Token terminationLine; + public TerminalNode STARTING() { return getToken(MySqlParser.STARTING, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode TERMINATED() { return getToken(MySqlParser.TERMINATED, 0); } + public SelectLinesIntoContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_selectLinesInto; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSelectLinesInto(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSelectLinesInto(this); + } + } + + public final SelectLinesIntoContext selectLinesInto() throws RecognitionException { + SelectLinesIntoContext _localctx = new SelectLinesIntoContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_selectLinesInto); + try { + setState(4200); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STARTING: + enterOuterAlt(_localctx, 1); + { + setState(4194); + match(STARTING); + setState(4195); + match(BY); + setState(4196); + ((SelectLinesIntoContext)_localctx).starting = match(STRING_LITERAL); + } + break; + case TERMINATED: + enterOuterAlt(_localctx, 2); + { + setState(4197); + match(TERMINATED); + setState(4198); + match(BY); + setState(4199); + ((SelectLinesIntoContext)_localctx).terminationLine = match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FromClauseContext extends ParserRuleContext { + public ExpressionContext whereExpr; + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TableSourcesContext tableSources() { + return getRuleContext(TableSourcesContext.class,0); + } + public TerminalNode WHERE() { return getToken(MySqlParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public FromClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fromClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFromClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFromClause(this); + } + } + + public final FromClauseContext fromClause() throws RecognitionException { + FromClauseContext _localctx = new FromClauseContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_fromClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4204); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM) { + { + setState(4202); + match(FROM); + setState(4203); + tableSources(); + } + } + + setState(4208); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(4206); + match(WHERE); + setState(4207); + ((FromClauseContext)_localctx).whereExpr = expression(0); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GroupByClauseContext extends ParserRuleContext { + public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public List groupByItem() { + return getRuleContexts(GroupByItemContext.class); + } + public GroupByItemContext groupByItem(int i) { + return getRuleContext(GroupByItemContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public TerminalNode ROLLUP() { return getToken(MySqlParser.ROLLUP, 0); } + public GroupByClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_groupByClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGroupByClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGroupByClause(this); + } + } + + public final GroupByClauseContext groupByClause() throws RecognitionException { + GroupByClauseContext _localctx = new GroupByClauseContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_groupByClause); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4210); + match(GROUP); + setState(4211); + match(BY); + setState(4212); + groupByItem(); + setState(4217); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,618,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4213); + match(COMMA); + setState(4214); + groupByItem(); + } + } + } + setState(4219); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,618,_ctx); + } + setState(4222); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,619,_ctx) ) { + case 1: + { + setState(4220); + match(WITH); + setState(4221); + match(ROLLUP); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HavingClauseContext extends ParserRuleContext { + public ExpressionContext havingExpr; + public TerminalNode HAVING() { return getToken(MySqlParser.HAVING, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public HavingClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_havingClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHavingClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHavingClause(this); + } + } + + public final HavingClauseContext havingClause() throws RecognitionException { + HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_havingClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(4224); + match(HAVING); + setState(4225); + ((HavingClauseContext)_localctx).havingExpr = expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WindowClauseContext extends ParserRuleContext { + public TerminalNode WINDOW() { return getToken(MySqlParser.WINDOW, 0); } + public List windowName() { + return getRuleContexts(WindowNameContext.class); + } + public WindowNameContext windowName(int i) { + return getRuleContext(WindowNameContext.class,i); + } + public List AS() { return getTokens(MySqlParser.AS); } + public TerminalNode AS(int i) { + return getToken(MySqlParser.AS, i); + } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List windowSpec() { + return getRuleContexts(WindowSpecContext.class); + } + public WindowSpecContext windowSpec(int i) { + return getRuleContext(WindowSpecContext.class,i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public WindowClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_windowClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWindowClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWindowClause(this); + } + } + + public final WindowClauseContext windowClause() throws RecognitionException { + WindowClauseContext _localctx = new WindowClauseContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_windowClause); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4227); + match(WINDOW); + setState(4228); + windowName(); + setState(4229); + match(AS); + setState(4230); + match(LR_BRACKET); + setState(4231); + windowSpec(); + setState(4232); + match(RR_BRACKET); + setState(4242); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,620,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4233); + match(COMMA); + setState(4234); + windowName(); + setState(4235); + match(AS); + setState(4236); + match(LR_BRACKET); + setState(4237); + windowSpec(); + setState(4238); + match(RR_BRACKET); + } + } + } + setState(4244); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,620,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GroupByItemContext extends ParserRuleContext { + public Token order; + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode ASC() { return getToken(MySqlParser.ASC, 0); } + public TerminalNode DESC() { return getToken(MySqlParser.DESC, 0); } + public GroupByItemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_groupByItem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGroupByItem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGroupByItem(this); + } + } + + public final GroupByItemContext groupByItem() throws RecognitionException { + GroupByItemContext _localctx = new GroupByItemContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_groupByItem); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4245); + expression(0); + setState(4247); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,621,_ctx) ) { + case 1: + { + setState(4246); + ((GroupByItemContext)_localctx).order = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ASC || _la==DESC) ) { + ((GroupByItemContext)_localctx).order = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LimitClauseContext extends ParserRuleContext { + public LimitClauseAtomContext offset; + public LimitClauseAtomContext limit; + public TerminalNode LIMIT() { return getToken(MySqlParser.LIMIT, 0); } + public TerminalNode OFFSET() { return getToken(MySqlParser.OFFSET, 0); } + public List limitClauseAtom() { + return getRuleContexts(LimitClauseAtomContext.class); + } + public LimitClauseAtomContext limitClauseAtom(int i) { + return getRuleContext(LimitClauseAtomContext.class,i); + } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public LimitClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_limitClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLimitClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLimitClause(this); + } + } + + public final LimitClauseContext limitClause() throws RecognitionException { + LimitClauseContext _localctx = new LimitClauseContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_limitClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(4249); + match(LIMIT); + setState(4260); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,623,_ctx) ) { + case 1: + { + setState(4253); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,622,_ctx) ) { + case 1: + { + setState(4250); + ((LimitClauseContext)_localctx).offset = limitClauseAtom(); + setState(4251); + match(COMMA); + } + break; + } + setState(4255); + ((LimitClauseContext)_localctx).limit = limitClauseAtom(); + } + break; + case 2: + { + setState(4256); + ((LimitClauseContext)_localctx).limit = limitClauseAtom(); + setState(4257); + match(OFFSET); + setState(4258); + ((LimitClauseContext)_localctx).offset = limitClauseAtom(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LimitClauseAtomContext extends ParserRuleContext { + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public MysqlVariableContext mysqlVariable() { + return getRuleContext(MysqlVariableContext.class,0); + } + public SimpleIdContext simpleId() { + return getRuleContext(SimpleIdContext.class,0); + } + public LimitClauseAtomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_limitClauseAtom; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLimitClauseAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLimitClauseAtom(this); + } + } + + public final LimitClauseAtomContext limitClauseAtom() throws RecognitionException { + LimitClauseAtomContext _localctx = new LimitClauseAtomContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_limitClauseAtom); + try { + setState(4265); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + enterOuterAlt(_localctx, 1); + { + setState(4262); + decimalLiteral(); + } + break; + case LOCAL_ID: + case GLOBAL_ID: + enterOuterAlt(_localctx, 2); + { + setState(4263); + mysqlVariable(); + } + break; + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case ID: + enterOuterAlt(_localctx, 3); + { + setState(4264); + simpleId(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StartTransactionContext extends ParserRuleContext { + public TerminalNode START() { return getToken(MySqlParser.START, 0); } + public TerminalNode TRANSACTION() { return getToken(MySqlParser.TRANSACTION, 0); } + public List transactionMode() { + return getRuleContexts(TransactionModeContext.class); + } + public TransactionModeContext transactionMode(int i) { + return getRuleContext(TransactionModeContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public StartTransactionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_startTransaction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStartTransaction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStartTransaction(this); + } + } + + public final StartTransactionContext startTransaction() throws RecognitionException { + StartTransactionContext _localctx = new StartTransactionContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_startTransaction); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4267); + match(START); + setState(4268); + match(TRANSACTION); + setState(4277); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,626,_ctx) ) { + case 1: + { + setState(4269); + transactionMode(); + setState(4274); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4270); + match(COMMA); + setState(4271); + transactionMode(); + } + } + setState(4276); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BeginWorkContext extends ParserRuleContext { + public TerminalNode BEGIN() { return getToken(MySqlParser.BEGIN, 0); } + public TerminalNode WORK() { return getToken(MySqlParser.WORK, 0); } + public BeginWorkContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_beginWork; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBeginWork(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBeginWork(this); + } + } + + public final BeginWorkContext beginWork() throws RecognitionException { + BeginWorkContext _localctx = new BeginWorkContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_beginWork); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4279); + match(BEGIN); + setState(4281); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WORK) { + { + setState(4280); + match(WORK); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CommitWorkContext extends ParserRuleContext { + public Token nochain; + public Token norelease; + public TerminalNode COMMIT() { return getToken(MySqlParser.COMMIT, 0); } + public TerminalNode WORK() { return getToken(MySqlParser.WORK, 0); } + public TerminalNode AND() { return getToken(MySqlParser.AND, 0); } + public TerminalNode CHAIN() { return getToken(MySqlParser.CHAIN, 0); } + public TerminalNode RELEASE() { return getToken(MySqlParser.RELEASE, 0); } + public List NO() { return getTokens(MySqlParser.NO); } + public TerminalNode NO(int i) { + return getToken(MySqlParser.NO, i); + } + public CommitWorkContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_commitWork; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCommitWork(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCommitWork(this); + } + } + + public final CommitWorkContext commitWork() throws RecognitionException { + CommitWorkContext _localctx = new CommitWorkContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_commitWork); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4283); + match(COMMIT); + setState(4285); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WORK) { + { + setState(4284); + match(WORK); + } + } + + setState(4292); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AND) { + { + setState(4287); + match(AND); + setState(4289); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(4288); + ((CommitWorkContext)_localctx).nochain = match(NO); + } + } + + setState(4291); + match(CHAIN); + } + } + + setState(4298); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,632,_ctx) ) { + case 1: + { + setState(4295); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(4294); + ((CommitWorkContext)_localctx).norelease = match(NO); + } + } + + setState(4297); + match(RELEASE); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RollbackWorkContext extends ParserRuleContext { + public Token nochain; + public Token norelease; + public TerminalNode ROLLBACK() { return getToken(MySqlParser.ROLLBACK, 0); } + public TerminalNode WORK() { return getToken(MySqlParser.WORK, 0); } + public TerminalNode AND() { return getToken(MySqlParser.AND, 0); } + public TerminalNode CHAIN() { return getToken(MySqlParser.CHAIN, 0); } + public TerminalNode RELEASE() { return getToken(MySqlParser.RELEASE, 0); } + public List NO() { return getTokens(MySqlParser.NO); } + public TerminalNode NO(int i) { + return getToken(MySqlParser.NO, i); + } + public RollbackWorkContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rollbackWork; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRollbackWork(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRollbackWork(this); + } + } + + public final RollbackWorkContext rollbackWork() throws RecognitionException { + RollbackWorkContext _localctx = new RollbackWorkContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_rollbackWork); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4300); + match(ROLLBACK); + setState(4302); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WORK) { + { + setState(4301); + match(WORK); + } + } + + setState(4309); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AND) { + { + setState(4304); + match(AND); + setState(4306); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(4305); + ((RollbackWorkContext)_localctx).nochain = match(NO); + } + } + + setState(4308); + match(CHAIN); + } + } + + setState(4315); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,637,_ctx) ) { + case 1: + { + setState(4312); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(4311); + ((RollbackWorkContext)_localctx).norelease = match(NO); + } + } + + setState(4314); + match(RELEASE); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SavepointStatementContext extends ParserRuleContext { + public TerminalNode SAVEPOINT() { return getToken(MySqlParser.SAVEPOINT, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public SavepointStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_savepointStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSavepointStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSavepointStatement(this); + } + } + + public final SavepointStatementContext savepointStatement() throws RecognitionException { + SavepointStatementContext _localctx = new SavepointStatementContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_savepointStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(4317); + match(SAVEPOINT); + setState(4318); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RollbackStatementContext extends ParserRuleContext { + public TerminalNode ROLLBACK() { return getToken(MySqlParser.ROLLBACK, 0); } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode WORK() { return getToken(MySqlParser.WORK, 0); } + public TerminalNode SAVEPOINT() { return getToken(MySqlParser.SAVEPOINT, 0); } + public RollbackStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rollbackStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRollbackStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRollbackStatement(this); + } + } + + public final RollbackStatementContext rollbackStatement() throws RecognitionException { + RollbackStatementContext _localctx = new RollbackStatementContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_rollbackStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4320); + match(ROLLBACK); + setState(4322); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WORK) { + { + setState(4321); + match(WORK); + } + } + + setState(4324); + match(TO); + setState(4326); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,639,_ctx) ) { + case 1: + { + setState(4325); + match(SAVEPOINT); + } + break; + } + setState(4328); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReleaseStatementContext extends ParserRuleContext { + public TerminalNode RELEASE() { return getToken(MySqlParser.RELEASE, 0); } + public TerminalNode SAVEPOINT() { return getToken(MySqlParser.SAVEPOINT, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public ReleaseStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_releaseStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReleaseStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReleaseStatement(this); + } + } + + public final ReleaseStatementContext releaseStatement() throws RecognitionException { + ReleaseStatementContext _localctx = new ReleaseStatementContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_releaseStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(4330); + match(RELEASE); + setState(4331); + match(SAVEPOINT); + setState(4332); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LockTablesContext extends ParserRuleContext { + public TerminalNode LOCK() { return getToken(MySqlParser.LOCK, 0); } + public List lockTableElement() { + return getRuleContexts(LockTableElementContext.class); + } + public LockTableElementContext lockTableElement(int i) { + return getRuleContext(LockTableElementContext.class,i); + } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public WaitNowaitClauseContext waitNowaitClause() { + return getRuleContext(WaitNowaitClauseContext.class,0); + } + public LockTablesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lockTables; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLockTables(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLockTables(this); + } + } + + public final LockTablesContext lockTables() throws RecognitionException { + LockTablesContext _localctx = new LockTablesContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_lockTables); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4334); + match(LOCK); + setState(4335); + _la = _input.LA(1); + if ( !(_la==TABLE || _la==TABLES) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4336); + lockTableElement(); + setState(4341); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4337); + match(COMMA); + setState(4338); + lockTableElement(); + } + } + setState(4343); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4345); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOWAIT || _la==WAIT) { + { + setState(4344); + waitNowaitClause(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UnlockTablesContext extends ParserRuleContext { + public TerminalNode UNLOCK() { return getToken(MySqlParser.UNLOCK, 0); } + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public UnlockTablesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unlockTables; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUnlockTables(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUnlockTables(this); + } + } + + public final UnlockTablesContext unlockTables() throws RecognitionException { + UnlockTablesContext _localctx = new UnlockTablesContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_unlockTables); + try { + enterOuterAlt(_localctx, 1); + { + setState(4347); + match(UNLOCK); + setState(4348); + match(TABLES); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetAutocommitStatementContext extends ParserRuleContext { + public Token autocommitValue; + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode AUTOCOMMIT() { return getToken(MySqlParser.AUTOCOMMIT, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public SetAutocommitStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_setAutocommitStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetAutocommitStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetAutocommitStatement(this); + } + } + + public final SetAutocommitStatementContext setAutocommitStatement() throws RecognitionException { + SetAutocommitStatementContext _localctx = new SetAutocommitStatementContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_setAutocommitStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4350); + match(SET); + setState(4351); + match(AUTOCOMMIT); + setState(4352); + match(EQUAL_SYMBOL); + setState(4353); + ((SetAutocommitStatementContext)_localctx).autocommitValue = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + ((SetAutocommitStatementContext)_localctx).autocommitValue = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetTransactionStatementContext extends ParserRuleContext { + public Token transactionContext; + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode TRANSACTION() { return getToken(MySqlParser.TRANSACTION, 0); } + public List transactionOption() { + return getRuleContexts(TransactionOptionContext.class); + } + public TransactionOptionContext transactionOption(int i) { + return getRuleContext(TransactionOptionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode GLOBAL() { return getToken(MySqlParser.GLOBAL, 0); } + public TerminalNode SESSION() { return getToken(MySqlParser.SESSION, 0); } + public SetTransactionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_setTransactionStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetTransactionStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetTransactionStatement(this); + } + } + + public final SetTransactionStatementContext setTransactionStatement() throws RecognitionException { + SetTransactionStatementContext _localctx = new SetTransactionStatementContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_setTransactionStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4355); + match(SET); + setState(4357); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==GLOBAL || _la==SESSION) { + { + setState(4356); + ((SetTransactionStatementContext)_localctx).transactionContext = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==GLOBAL || _la==SESSION) ) { + ((SetTransactionStatementContext)_localctx).transactionContext = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(4359); + match(TRANSACTION); + setState(4360); + transactionOption(); + setState(4365); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4361); + match(COMMA); + setState(4362); + transactionOption(); + } + } + setState(4367); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TransactionModeContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public TerminalNode CONSISTENT() { return getToken(MySqlParser.CONSISTENT, 0); } + public TerminalNode SNAPSHOT() { return getToken(MySqlParser.SNAPSHOT, 0); } + public TerminalNode READ() { return getToken(MySqlParser.READ, 0); } + public TerminalNode WRITE() { return getToken(MySqlParser.WRITE, 0); } + public TerminalNode ONLY() { return getToken(MySqlParser.ONLY, 0); } + public TransactionModeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transactionMode; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTransactionMode(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTransactionMode(this); + } + } + + public final TransactionModeContext transactionMode() throws RecognitionException { + TransactionModeContext _localctx = new TransactionModeContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_transactionMode); + try { + setState(4375); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,644,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4368); + match(WITH); + setState(4369); + match(CONSISTENT); + setState(4370); + match(SNAPSHOT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4371); + match(READ); + setState(4372); + match(WRITE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4373); + match(READ); + setState(4374); + match(ONLY); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LockTableElementContext extends ParserRuleContext { + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public LockActionContext lockAction() { + return getRuleContext(LockActionContext.class,0); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public LockTableElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lockTableElement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLockTableElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLockTableElement(this); + } + } + + public final LockTableElementContext lockTableElement() throws RecognitionException { + LockTableElementContext _localctx = new LockTableElementContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_lockTableElement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4377); + tableName(); + setState(4382); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026252800L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(4379); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(4378); + match(AS); + } + } + + setState(4381); + uid(); + } + } + + setState(4384); + lockAction(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LockActionContext extends ParserRuleContext { + public TerminalNode READ() { return getToken(MySqlParser.READ, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public TerminalNode WRITE() { return getToken(MySqlParser.WRITE, 0); } + public TerminalNode LOW_PRIORITY() { return getToken(MySqlParser.LOW_PRIORITY, 0); } + public LockActionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lockAction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLockAction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLockAction(this); + } + } + + public final LockActionContext lockAction() throws RecognitionException { + LockActionContext _localctx = new LockActionContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_lockAction); + int _la; + try { + setState(4394); + _errHandler.sync(this); + switch (_input.LA(1)) { + case READ: + enterOuterAlt(_localctx, 1); + { + setState(4386); + match(READ); + setState(4388); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOCAL) { + { + setState(4387); + match(LOCAL); + } + } + + } + break; + case LOW_PRIORITY: + case WRITE: + enterOuterAlt(_localctx, 2); + { + setState(4391); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOW_PRIORITY) { + { + setState(4390); + match(LOW_PRIORITY); + } + } + + setState(4393); + match(WRITE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TransactionOptionContext extends ParserRuleContext { + public TerminalNode ISOLATION() { return getToken(MySqlParser.ISOLATION, 0); } + public TerminalNode LEVEL() { return getToken(MySqlParser.LEVEL, 0); } + public TransactionLevelContext transactionLevel() { + return getRuleContext(TransactionLevelContext.class,0); + } + public TerminalNode READ() { return getToken(MySqlParser.READ, 0); } + public TerminalNode WRITE() { return getToken(MySqlParser.WRITE, 0); } + public TerminalNode ONLY() { return getToken(MySqlParser.ONLY, 0); } + public TransactionOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transactionOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTransactionOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTransactionOption(this); + } + } + + public final TransactionOptionContext transactionOption() throws RecognitionException { + TransactionOptionContext _localctx = new TransactionOptionContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_transactionOption); + try { + setState(4403); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,650,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4396); + match(ISOLATION); + setState(4397); + match(LEVEL); + setState(4398); + transactionLevel(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4399); + match(READ); + setState(4400); + match(WRITE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4401); + match(READ); + setState(4402); + match(ONLY); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TransactionLevelContext extends ParserRuleContext { + public TerminalNode REPEATABLE() { return getToken(MySqlParser.REPEATABLE, 0); } + public TerminalNode READ() { return getToken(MySqlParser.READ, 0); } + public TerminalNode COMMITTED() { return getToken(MySqlParser.COMMITTED, 0); } + public TerminalNode UNCOMMITTED() { return getToken(MySqlParser.UNCOMMITTED, 0); } + public TerminalNode SERIALIZABLE() { return getToken(MySqlParser.SERIALIZABLE, 0); } + public TransactionLevelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transactionLevel; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTransactionLevel(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTransactionLevel(this); + } + } + + public final TransactionLevelContext transactionLevel() throws RecognitionException { + TransactionLevelContext _localctx = new TransactionLevelContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_transactionLevel); + try { + setState(4412); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,651,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4405); + match(REPEATABLE); + setState(4406); + match(READ); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4407); + match(READ); + setState(4408); + match(COMMITTED); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4409); + match(READ); + setState(4410); + match(UNCOMMITTED); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4411); + match(SERIALIZABLE); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ChangeMasterContext extends ParserRuleContext { + public TerminalNode CHANGE() { return getToken(MySqlParser.CHANGE, 0); } + public TerminalNode MASTER() { return getToken(MySqlParser.MASTER, 0); } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public List masterOption() { + return getRuleContexts(MasterOptionContext.class); + } + public MasterOptionContext masterOption(int i) { + return getRuleContext(MasterOptionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public ChannelOptionContext channelOption() { + return getRuleContext(ChannelOptionContext.class,0); + } + public ChangeMasterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_changeMaster; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterChangeMaster(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitChangeMaster(this); + } + } + + public final ChangeMasterContext changeMaster() throws RecognitionException { + ChangeMasterContext _localctx = new ChangeMasterContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_changeMaster); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4414); + match(CHANGE); + setState(4415); + match(MASTER); + setState(4416); + match(TO); + setState(4417); + masterOption(); + setState(4422); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4418); + match(COMMA); + setState(4419); + masterOption(); + } + } + setState(4424); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4426); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(4425); + channelOption(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ChangeReplicationFilterContext extends ParserRuleContext { + public TerminalNode CHANGE() { return getToken(MySqlParser.CHANGE, 0); } + public TerminalNode REPLICATION() { return getToken(MySqlParser.REPLICATION, 0); } + public TerminalNode FILTER() { return getToken(MySqlParser.FILTER, 0); } + public List replicationFilter() { + return getRuleContexts(ReplicationFilterContext.class); + } + public ReplicationFilterContext replicationFilter(int i) { + return getRuleContext(ReplicationFilterContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public ChangeReplicationFilterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_changeReplicationFilter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterChangeReplicationFilter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitChangeReplicationFilter(this); + } + } + + public final ChangeReplicationFilterContext changeReplicationFilter() throws RecognitionException { + ChangeReplicationFilterContext _localctx = new ChangeReplicationFilterContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_changeReplicationFilter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4428); + match(CHANGE); + setState(4429); + match(REPLICATION); + setState(4430); + match(FILTER); + setState(4431); + replicationFilter(); + setState(4436); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4432); + match(COMMA); + setState(4433); + replicationFilter(); + } + } + setState(4438); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PurgeBinaryLogsContext extends ParserRuleContext { + public Token purgeFormat; + public Token fileName; + public Token timeValue; + public TerminalNode PURGE() { return getToken(MySqlParser.PURGE, 0); } + public TerminalNode LOGS() { return getToken(MySqlParser.LOGS, 0); } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public TerminalNode MASTER() { return getToken(MySqlParser.MASTER, 0); } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public TerminalNode BEFORE() { return getToken(MySqlParser.BEFORE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public PurgeBinaryLogsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_purgeBinaryLogs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPurgeBinaryLogs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPurgeBinaryLogs(this); + } + } + + public final PurgeBinaryLogsContext purgeBinaryLogs() throws RecognitionException { + PurgeBinaryLogsContext _localctx = new PurgeBinaryLogsContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_purgeBinaryLogs); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4439); + match(PURGE); + setState(4440); + ((PurgeBinaryLogsContext)_localctx).purgeFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==BINARY || _la==MASTER) ) { + ((PurgeBinaryLogsContext)_localctx).purgeFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4441); + match(LOGS); + setState(4446); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TO: + { + setState(4442); + match(TO); + setState(4443); + ((PurgeBinaryLogsContext)_localctx).fileName = match(STRING_LITERAL); + } + break; + case BEFORE: + { + setState(4444); + match(BEFORE); + setState(4445); + ((PurgeBinaryLogsContext)_localctx).timeValue = match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ResetMasterContext extends ParserRuleContext { + public TerminalNode RESET() { return getToken(MySqlParser.RESET, 0); } + public TerminalNode MASTER() { return getToken(MySqlParser.MASTER, 0); } + public ResetMasterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resetMaster; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterResetMaster(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitResetMaster(this); + } + } + + public final ResetMasterContext resetMaster() throws RecognitionException { + ResetMasterContext _localctx = new ResetMasterContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_resetMaster); + try { + enterOuterAlt(_localctx, 1); + { + setState(4448); + match(RESET); + setState(4449); + match(MASTER); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ResetSlaveContext extends ParserRuleContext { + public TerminalNode RESET() { return getToken(MySqlParser.RESET, 0); } + public TerminalNode SLAVE() { return getToken(MySqlParser.SLAVE, 0); } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public ChannelOptionContext channelOption() { + return getRuleContext(ChannelOptionContext.class,0); + } + public ResetSlaveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resetSlave; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterResetSlave(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitResetSlave(this); + } + } + + public final ResetSlaveContext resetSlave() throws RecognitionException { + ResetSlaveContext _localctx = new ResetSlaveContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_resetSlave); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4451); + match(RESET); + setState(4452); + match(SLAVE); + setState(4454); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALL) { + { + setState(4453); + match(ALL); + } + } + + setState(4457); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(4456); + channelOption(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StartSlaveContext extends ParserRuleContext { + public TerminalNode START() { return getToken(MySqlParser.START, 0); } + public TerminalNode SLAVE() { return getToken(MySqlParser.SLAVE, 0); } + public List threadType() { + return getRuleContexts(ThreadTypeContext.class); + } + public ThreadTypeContext threadType(int i) { + return getRuleContext(ThreadTypeContext.class,i); + } + public TerminalNode UNTIL() { return getToken(MySqlParser.UNTIL, 0); } + public UntilOptionContext untilOption() { + return getRuleContext(UntilOptionContext.class,0); + } + public List connectionOption() { + return getRuleContexts(ConnectionOptionContext.class); + } + public ConnectionOptionContext connectionOption(int i) { + return getRuleContext(ConnectionOptionContext.class,i); + } + public ChannelOptionContext channelOption() { + return getRuleContext(ChannelOptionContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public StartSlaveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_startSlave; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStartSlave(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStartSlave(this); + } + } + + public final StartSlaveContext startSlave() throws RecognitionException { + StartSlaveContext _localctx = new StartSlaveContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_startSlave); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4459); + match(START); + setState(4460); + match(SLAVE); + setState(4469); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IO_THREAD || _la==SQL_THREAD) { + { + setState(4461); + threadType(); + setState(4466); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4462); + match(COMMA); + setState(4463); + threadType(); + } + } + setState(4468); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(4473); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==UNTIL) { + { + setState(4471); + match(UNTIL); + setState(4472); + untilOption(); + } + } + + setState(4478); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DEFAULT_AUTH || _la==PASSWORD || _la==PLUGIN_DIR || _la==USER) { + { + { + setState(4475); + connectionOption(); + } + } + setState(4480); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4482); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(4481); + channelOption(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StopSlaveContext extends ParserRuleContext { + public TerminalNode STOP() { return getToken(MySqlParser.STOP, 0); } + public TerminalNode SLAVE() { return getToken(MySqlParser.SLAVE, 0); } + public List threadType() { + return getRuleContexts(ThreadTypeContext.class); + } + public ThreadTypeContext threadType(int i) { + return getRuleContext(ThreadTypeContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public StopSlaveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stopSlave; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStopSlave(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStopSlave(this); + } + } + + public final StopSlaveContext stopSlave() throws RecognitionException { + StopSlaveContext _localctx = new StopSlaveContext(_ctx, getState()); + enterRule(_localctx, 342, RULE_stopSlave); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4484); + match(STOP); + setState(4485); + match(SLAVE); + setState(4494); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IO_THREAD || _la==SQL_THREAD) { + { + setState(4486); + threadType(); + setState(4491); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4487); + match(COMMA); + setState(4488); + threadType(); + } + } + setState(4493); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StartGroupReplicationContext extends ParserRuleContext { + public TerminalNode START() { return getToken(MySqlParser.START, 0); } + public TerminalNode GROUP_REPLICATION() { return getToken(MySqlParser.GROUP_REPLICATION, 0); } + public StartGroupReplicationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_startGroupReplication; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStartGroupReplication(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStartGroupReplication(this); + } + } + + public final StartGroupReplicationContext startGroupReplication() throws RecognitionException { + StartGroupReplicationContext _localctx = new StartGroupReplicationContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_startGroupReplication); + try { + enterOuterAlt(_localctx, 1); + { + setState(4496); + match(START); + setState(4497); + match(GROUP_REPLICATION); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StopGroupReplicationContext extends ParserRuleContext { + public TerminalNode STOP() { return getToken(MySqlParser.STOP, 0); } + public TerminalNode GROUP_REPLICATION() { return getToken(MySqlParser.GROUP_REPLICATION, 0); } + public StopGroupReplicationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stopGroupReplication; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStopGroupReplication(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStopGroupReplication(this); + } + } + + public final StopGroupReplicationContext stopGroupReplication() throws RecognitionException { + StopGroupReplicationContext _localctx = new StopGroupReplicationContext(_ctx, getState()); + enterRule(_localctx, 346, RULE_stopGroupReplication); + try { + enterOuterAlt(_localctx, 1); + { + setState(4499); + match(STOP); + setState(4500); + match(GROUP_REPLICATION); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MasterOptionContext extends ParserRuleContext { + public MasterOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_masterOption; } + + public MasterOptionContext() { } + public void copyFrom(MasterOptionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MasterStringOptionContext extends MasterOptionContext { + public StringMasterOptionContext stringMasterOption() { + return getRuleContext(StringMasterOptionContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public MasterStringOptionContext(MasterOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMasterStringOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMasterStringOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MasterRealOptionContext extends MasterOptionContext { + public TerminalNode MASTER_HEARTBEAT_PERIOD() { return getToken(MySqlParser.MASTER_HEARTBEAT_PERIOD, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode REAL_LITERAL() { return getToken(MySqlParser.REAL_LITERAL, 0); } + public MasterRealOptionContext(MasterOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMasterRealOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMasterRealOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MasterBoolOptionContext extends MasterOptionContext { + public Token boolVal; + public BoolMasterOptionContext boolMasterOption() { + return getRuleContext(BoolMasterOptionContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public MasterBoolOptionContext(MasterOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMasterBoolOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMasterBoolOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MasterUidListOptionContext extends MasterOptionContext { + public TerminalNode IGNORE_SERVER_IDS() { return getToken(MySqlParser.IGNORE_SERVER_IDS, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public MasterUidListOptionContext(MasterOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMasterUidListOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMasterUidListOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MasterDecimalOptionContext extends MasterOptionContext { + public DecimalMasterOptionContext decimalMasterOption() { + return getRuleContext(DecimalMasterOptionContext.class,0); + } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public MasterDecimalOptionContext(MasterOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMasterDecimalOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMasterDecimalOption(this); + } + } + + public final MasterOptionContext masterOption() throws RecognitionException { + MasterOptionContext _localctx = new MasterOptionContext(_ctx, getState()); + enterRule(_localctx, 348, RULE_masterOption); + int _la; + try { + setState(4531); + _errHandler.sync(this); + switch (_input.LA(1)) { + case MASTER_BIND: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_PASSWORD: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case RELAY_LOG_FILE: + _localctx = new MasterStringOptionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(4502); + stringMasterOption(); + setState(4503); + match(EQUAL_SYMBOL); + setState(4504); + match(STRING_LITERAL); + } + break; + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_LOG_POS: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case RELAY_LOG_POS: + _localctx = new MasterDecimalOptionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(4506); + decimalMasterOption(); + setState(4507); + match(EQUAL_SYMBOL); + setState(4508); + decimalLiteral(); + } + break; + case MASTER_SSL_VERIFY_SERVER_CERT: + case MASTER_AUTO_POSITION: + case MASTER_SSL: + _localctx = new MasterBoolOptionContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(4510); + boolMasterOption(); + setState(4511); + match(EQUAL_SYMBOL); + setState(4512); + ((MasterBoolOptionContext)_localctx).boolVal = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ZERO_DECIMAL || _la==ONE_DECIMAL) ) { + ((MasterBoolOptionContext)_localctx).boolVal = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case MASTER_HEARTBEAT_PERIOD: + _localctx = new MasterRealOptionContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(4514); + match(MASTER_HEARTBEAT_PERIOD); + setState(4515); + match(EQUAL_SYMBOL); + setState(4516); + match(REAL_LITERAL); + } + break; + case IGNORE_SERVER_IDS: + _localctx = new MasterUidListOptionContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(4517); + match(IGNORE_SERVER_IDS); + setState(4518); + match(EQUAL_SYMBOL); + setState(4519); + match(LR_BRACKET); + setState(4528); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(4520); + uid(); + setState(4525); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4521); + match(COMMA); + setState(4522); + uid(); + } + } + setState(4527); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(4530); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StringMasterOptionContext extends ParserRuleContext { + public TerminalNode MASTER_BIND() { return getToken(MySqlParser.MASTER_BIND, 0); } + public TerminalNode MASTER_HOST() { return getToken(MySqlParser.MASTER_HOST, 0); } + public TerminalNode MASTER_USER() { return getToken(MySqlParser.MASTER_USER, 0); } + public TerminalNode MASTER_PASSWORD() { return getToken(MySqlParser.MASTER_PASSWORD, 0); } + public TerminalNode MASTER_LOG_FILE() { return getToken(MySqlParser.MASTER_LOG_FILE, 0); } + public TerminalNode RELAY_LOG_FILE() { return getToken(MySqlParser.RELAY_LOG_FILE, 0); } + public TerminalNode MASTER_SSL_CA() { return getToken(MySqlParser.MASTER_SSL_CA, 0); } + public TerminalNode MASTER_SSL_CAPATH() { return getToken(MySqlParser.MASTER_SSL_CAPATH, 0); } + public TerminalNode MASTER_SSL_CERT() { return getToken(MySqlParser.MASTER_SSL_CERT, 0); } + public TerminalNode MASTER_SSL_CRL() { return getToken(MySqlParser.MASTER_SSL_CRL, 0); } + public TerminalNode MASTER_SSL_CRLPATH() { return getToken(MySqlParser.MASTER_SSL_CRLPATH, 0); } + public TerminalNode MASTER_SSL_KEY() { return getToken(MySqlParser.MASTER_SSL_KEY, 0); } + public TerminalNode MASTER_SSL_CIPHER() { return getToken(MySqlParser.MASTER_SSL_CIPHER, 0); } + public TerminalNode MASTER_TLS_VERSION() { return getToken(MySqlParser.MASTER_TLS_VERSION, 0); } + public StringMasterOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stringMasterOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStringMasterOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStringMasterOption(this); + } + } + + public final StringMasterOptionContext stringMasterOption() throws RecognitionException { + StringMasterOptionContext _localctx = new StringMasterOptionContext(_ctx, getState()); + enterRule(_localctx, 350, RULE_stringMasterOption); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4533); + _la = _input.LA(1); + if ( !(_la==MASTER_BIND || ((((_la - 483)) & ~0x3f) == 0 && ((1L << (_la - 483)) & 65419L) != 0) || _la==RELAY_LOG_FILE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DecimalMasterOptionContext extends ParserRuleContext { + public TerminalNode MASTER_PORT() { return getToken(MySqlParser.MASTER_PORT, 0); } + public TerminalNode MASTER_CONNECT_RETRY() { return getToken(MySqlParser.MASTER_CONNECT_RETRY, 0); } + public TerminalNode MASTER_RETRY_COUNT() { return getToken(MySqlParser.MASTER_RETRY_COUNT, 0); } + public TerminalNode MASTER_DELAY() { return getToken(MySqlParser.MASTER_DELAY, 0); } + public TerminalNode MASTER_LOG_POS() { return getToken(MySqlParser.MASTER_LOG_POS, 0); } + public TerminalNode RELAY_LOG_POS() { return getToken(MySqlParser.RELAY_LOG_POS, 0); } + public DecimalMasterOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decimalMasterOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDecimalMasterOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDecimalMasterOption(this); + } + } + + public final DecimalMasterOptionContext decimalMasterOption() throws RecognitionException { + DecimalMasterOptionContext _localctx = new DecimalMasterOptionContext(_ctx, getState()); + enterRule(_localctx, 352, RULE_decimalMasterOption); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4535); + _la = _input.LA(1); + if ( !(((((_la - 480)) & ~0x3f) == 0 && ((1L << (_la - 480)) & 419L) != 0) || _la==RELAY_LOG_POS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BoolMasterOptionContext extends ParserRuleContext { + public TerminalNode MASTER_AUTO_POSITION() { return getToken(MySqlParser.MASTER_AUTO_POSITION, 0); } + public TerminalNode MASTER_SSL() { return getToken(MySqlParser.MASTER_SSL, 0); } + public TerminalNode MASTER_SSL_VERIFY_SERVER_CERT() { return getToken(MySqlParser.MASTER_SSL_VERIFY_SERVER_CERT, 0); } + public BoolMasterOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_boolMasterOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBoolMasterOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBoolMasterOption(this); + } + } + + public final BoolMasterOptionContext boolMasterOption() throws RecognitionException { + BoolMasterOptionContext _localctx = new BoolMasterOptionContext(_ctx, getState()); + enterRule(_localctx, 354, RULE_boolMasterOption); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4537); + _la = _input.LA(1); + if ( !(_la==MASTER_SSL_VERIFY_SERVER_CERT || _la==MASTER_AUTO_POSITION || _la==MASTER_SSL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ChannelOptionContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode CHANNEL() { return getToken(MySqlParser.CHANNEL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public ChannelOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_channelOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterChannelOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitChannelOption(this); + } + } + + public final ChannelOptionContext channelOption() throws RecognitionException { + ChannelOptionContext _localctx = new ChannelOptionContext(_ctx, getState()); + enterRule(_localctx, 356, RULE_channelOption); + try { + enterOuterAlt(_localctx, 1); + { + setState(4539); + match(FOR); + setState(4540); + match(CHANNEL); + setState(4541); + match(STRING_LITERAL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReplicationFilterContext extends ParserRuleContext { + public ReplicationFilterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_replicationFilter; } + + public ReplicationFilterContext() { } + public void copyFrom(ReplicationFilterContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class WildIgnoreTableReplicationContext extends ReplicationFilterContext { + public TerminalNode REPLICATE_WILD_IGNORE_TABLE() { return getToken(MySqlParser.REPLICATE_WILD_IGNORE_TABLE, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public SimpleStringsContext simpleStrings() { + return getRuleContext(SimpleStringsContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public WildIgnoreTableReplicationContext(ReplicationFilterContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWildIgnoreTableReplication(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWildIgnoreTableReplication(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DoTableReplicationContext extends ReplicationFilterContext { + public TerminalNode REPLICATE_DO_TABLE() { return getToken(MySqlParser.REPLICATE_DO_TABLE, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public DoTableReplicationContext(ReplicationFilterContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDoTableReplication(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDoTableReplication(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IgnoreTableReplicationContext extends ReplicationFilterContext { + public TerminalNode REPLICATE_IGNORE_TABLE() { return getToken(MySqlParser.REPLICATE_IGNORE_TABLE, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public IgnoreTableReplicationContext(ReplicationFilterContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIgnoreTableReplication(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIgnoreTableReplication(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RewriteDbReplicationContext extends ReplicationFilterContext { + public TerminalNode REPLICATE_REWRITE_DB() { return getToken(MySqlParser.REPLICATE_REWRITE_DB, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List tablePair() { + return getRuleContexts(TablePairContext.class); + } + public TablePairContext tablePair(int i) { + return getRuleContext(TablePairContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public RewriteDbReplicationContext(ReplicationFilterContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRewriteDbReplication(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRewriteDbReplication(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DoDbReplicationContext extends ReplicationFilterContext { + public TerminalNode REPLICATE_DO_DB() { return getToken(MySqlParser.REPLICATE_DO_DB, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public DoDbReplicationContext(ReplicationFilterContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDoDbReplication(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDoDbReplication(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IgnoreDbReplicationContext extends ReplicationFilterContext { + public TerminalNode REPLICATE_IGNORE_DB() { return getToken(MySqlParser.REPLICATE_IGNORE_DB, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public IgnoreDbReplicationContext(ReplicationFilterContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIgnoreDbReplication(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIgnoreDbReplication(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class WildDoTableReplicationContext extends ReplicationFilterContext { + public TerminalNode REPLICATE_WILD_DO_TABLE() { return getToken(MySqlParser.REPLICATE_WILD_DO_TABLE, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public SimpleStringsContext simpleStrings() { + return getRuleContext(SimpleStringsContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public WildDoTableReplicationContext(ReplicationFilterContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWildDoTableReplication(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWildDoTableReplication(this); + } + } + + public final ReplicationFilterContext replicationFilter() throws RecognitionException { + ReplicationFilterContext _localctx = new ReplicationFilterContext(_ctx, getState()); + enterRule(_localctx, 358, RULE_replicationFilter); + int _la; + try { + setState(4592); + _errHandler.sync(this); + switch (_input.LA(1)) { + case REPLICATE_DO_DB: + _localctx = new DoDbReplicationContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(4543); + match(REPLICATE_DO_DB); + setState(4544); + match(EQUAL_SYMBOL); + setState(4545); + match(LR_BRACKET); + setState(4546); + uidList(); + setState(4547); + match(RR_BRACKET); + } + break; + case REPLICATE_IGNORE_DB: + _localctx = new IgnoreDbReplicationContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(4549); + match(REPLICATE_IGNORE_DB); + setState(4550); + match(EQUAL_SYMBOL); + setState(4551); + match(LR_BRACKET); + setState(4552); + uidList(); + setState(4553); + match(RR_BRACKET); + } + break; + case REPLICATE_DO_TABLE: + _localctx = new DoTableReplicationContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(4555); + match(REPLICATE_DO_TABLE); + setState(4556); + match(EQUAL_SYMBOL); + setState(4557); + match(LR_BRACKET); + setState(4558); + tables(); + setState(4559); + match(RR_BRACKET); + } + break; + case REPLICATE_IGNORE_TABLE: + _localctx = new IgnoreTableReplicationContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(4561); + match(REPLICATE_IGNORE_TABLE); + setState(4562); + match(EQUAL_SYMBOL); + setState(4563); + match(LR_BRACKET); + setState(4564); + tables(); + setState(4565); + match(RR_BRACKET); + } + break; + case REPLICATE_WILD_DO_TABLE: + _localctx = new WildDoTableReplicationContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(4567); + match(REPLICATE_WILD_DO_TABLE); + setState(4568); + match(EQUAL_SYMBOL); + setState(4569); + match(LR_BRACKET); + setState(4570); + simpleStrings(); + setState(4571); + match(RR_BRACKET); + } + break; + case REPLICATE_WILD_IGNORE_TABLE: + _localctx = new WildIgnoreTableReplicationContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(4573); + match(REPLICATE_WILD_IGNORE_TABLE); + setState(4574); + match(EQUAL_SYMBOL); + setState(4575); + match(LR_BRACKET); + setState(4576); + simpleStrings(); + setState(4577); + match(RR_BRACKET); + } + break; + case REPLICATE_REWRITE_DB: + _localctx = new RewriteDbReplicationContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(4579); + match(REPLICATE_REWRITE_DB); + setState(4580); + match(EQUAL_SYMBOL); + setState(4581); + match(LR_BRACKET); + setState(4582); + tablePair(); + setState(4587); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4583); + match(COMMA); + setState(4584); + tablePair(); + } + } + setState(4589); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4590); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TablePairContext extends ParserRuleContext { + public TableNameContext firstTable; + public TableNameContext secondTable; + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List tableName() { + return getRuleContexts(TableNameContext.class); + } + public TableNameContext tableName(int i) { + return getRuleContext(TableNameContext.class,i); + } + public TablePairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tablePair; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTablePair(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTablePair(this); + } + } + + public final TablePairContext tablePair() throws RecognitionException { + TablePairContext _localctx = new TablePairContext(_ctx, getState()); + enterRule(_localctx, 360, RULE_tablePair); + try { + enterOuterAlt(_localctx, 1); + { + setState(4594); + match(LR_BRACKET); + setState(4595); + ((TablePairContext)_localctx).firstTable = tableName(); + setState(4596); + match(COMMA); + setState(4597); + ((TablePairContext)_localctx).secondTable = tableName(); + setState(4598); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ThreadTypeContext extends ParserRuleContext { + public TerminalNode IO_THREAD() { return getToken(MySqlParser.IO_THREAD, 0); } + public TerminalNode SQL_THREAD() { return getToken(MySqlParser.SQL_THREAD, 0); } + public ThreadTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_threadType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterThreadType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitThreadType(this); + } + } + + public final ThreadTypeContext threadType() throws RecognitionException { + ThreadTypeContext _localctx = new ThreadTypeContext(_ctx, getState()); + enterRule(_localctx, 362, RULE_threadType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4600); + _la = _input.LA(1); + if ( !(_la==IO_THREAD || _la==SQL_THREAD) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UntilOptionContext extends ParserRuleContext { + public UntilOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_untilOption; } + + public UntilOptionContext() { } + public void copyFrom(UntilOptionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class GtidsUntilOptionContext extends UntilOptionContext { + public Token gtids; + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public GtuidSetContext gtuidSet() { + return getRuleContext(GtuidSetContext.class,0); + } + public TerminalNode SQL_BEFORE_GTIDS() { return getToken(MySqlParser.SQL_BEFORE_GTIDS, 0); } + public TerminalNode SQL_AFTER_GTIDS() { return getToken(MySqlParser.SQL_AFTER_GTIDS, 0); } + public GtidsUntilOptionContext(UntilOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGtidsUntilOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGtidsUntilOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SqlGapsUntilOptionContext extends UntilOptionContext { + public TerminalNode SQL_AFTER_MTS_GAPS() { return getToken(MySqlParser.SQL_AFTER_MTS_GAPS, 0); } + public SqlGapsUntilOptionContext(UntilOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSqlGapsUntilOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSqlGapsUntilOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MasterLogUntilOptionContext extends UntilOptionContext { + public TerminalNode MASTER_LOG_FILE() { return getToken(MySqlParser.MASTER_LOG_FILE, 0); } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public TerminalNode MASTER_LOG_POS() { return getToken(MySqlParser.MASTER_LOG_POS, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public MasterLogUntilOptionContext(UntilOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMasterLogUntilOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMasterLogUntilOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RelayLogUntilOptionContext extends UntilOptionContext { + public TerminalNode RELAY_LOG_FILE() { return getToken(MySqlParser.RELAY_LOG_FILE, 0); } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public TerminalNode RELAY_LOG_POS() { return getToken(MySqlParser.RELAY_LOG_POS, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public RelayLogUntilOptionContext(UntilOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRelayLogUntilOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRelayLogUntilOption(this); + } + } + + public final UntilOptionContext untilOption() throws RecognitionException { + UntilOptionContext _localctx = new UntilOptionContext(_ctx, getState()); + enterRule(_localctx, 364, RULE_untilOption); + int _la; + try { + setState(4620); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SQL_AFTER_GTIDS: + case SQL_BEFORE_GTIDS: + _localctx = new GtidsUntilOptionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(4602); + ((GtidsUntilOptionContext)_localctx).gtids = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==SQL_AFTER_GTIDS || _la==SQL_BEFORE_GTIDS) ) { + ((GtidsUntilOptionContext)_localctx).gtids = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4603); + match(EQUAL_SYMBOL); + setState(4604); + gtuidSet(); + } + break; + case MASTER_LOG_FILE: + _localctx = new MasterLogUntilOptionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(4605); + match(MASTER_LOG_FILE); + setState(4606); + match(EQUAL_SYMBOL); + setState(4607); + match(STRING_LITERAL); + setState(4608); + match(COMMA); + setState(4609); + match(MASTER_LOG_POS); + setState(4610); + match(EQUAL_SYMBOL); + setState(4611); + decimalLiteral(); + } + break; + case RELAY_LOG_FILE: + _localctx = new RelayLogUntilOptionContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(4612); + match(RELAY_LOG_FILE); + setState(4613); + match(EQUAL_SYMBOL); + setState(4614); + match(STRING_LITERAL); + setState(4615); + match(COMMA); + setState(4616); + match(RELAY_LOG_POS); + setState(4617); + match(EQUAL_SYMBOL); + setState(4618); + decimalLiteral(); + } + break; + case SQL_AFTER_MTS_GAPS: + _localctx = new SqlGapsUntilOptionContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(4619); + match(SQL_AFTER_MTS_GAPS); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConnectionOptionContext extends ParserRuleContext { + public ConnectionOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_connectionOption; } + + public ConnectionOptionContext() { } + public void copyFrom(ConnectionOptionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PluginDirConnectionOptionContext extends ConnectionOptionContext { + public Token conOptPluginDir; + public TerminalNode PLUGIN_DIR() { return getToken(MySqlParser.PLUGIN_DIR, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public PluginDirConnectionOptionContext(ConnectionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPluginDirConnectionOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPluginDirConnectionOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UserConnectionOptionContext extends ConnectionOptionContext { + public Token conOptUser; + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public UserConnectionOptionContext(ConnectionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUserConnectionOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUserConnectionOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DefaultAuthConnectionOptionContext extends ConnectionOptionContext { + public Token conOptDefAuth; + public TerminalNode DEFAULT_AUTH() { return getToken(MySqlParser.DEFAULT_AUTH, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public DefaultAuthConnectionOptionContext(ConnectionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDefaultAuthConnectionOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDefaultAuthConnectionOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PasswordConnectionOptionContext extends ConnectionOptionContext { + public Token conOptPassword; + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public PasswordConnectionOptionContext(ConnectionOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPasswordConnectionOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPasswordConnectionOption(this); + } + } + + public final ConnectionOptionContext connectionOption() throws RecognitionException { + ConnectionOptionContext _localctx = new ConnectionOptionContext(_ctx, getState()); + enterRule(_localctx, 366, RULE_connectionOption); + try { + setState(4634); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USER: + _localctx = new UserConnectionOptionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(4622); + match(USER); + setState(4623); + match(EQUAL_SYMBOL); + setState(4624); + ((UserConnectionOptionContext)_localctx).conOptUser = match(STRING_LITERAL); + } + break; + case PASSWORD: + _localctx = new PasswordConnectionOptionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(4625); + match(PASSWORD); + setState(4626); + match(EQUAL_SYMBOL); + setState(4627); + ((PasswordConnectionOptionContext)_localctx).conOptPassword = match(STRING_LITERAL); + } + break; + case DEFAULT_AUTH: + _localctx = new DefaultAuthConnectionOptionContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(4628); + match(DEFAULT_AUTH); + setState(4629); + match(EQUAL_SYMBOL); + setState(4630); + ((DefaultAuthConnectionOptionContext)_localctx).conOptDefAuth = match(STRING_LITERAL); + } + break; + case PLUGIN_DIR: + _localctx = new PluginDirConnectionOptionContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(4631); + match(PLUGIN_DIR); + setState(4632); + match(EQUAL_SYMBOL); + setState(4633); + ((PluginDirConnectionOptionContext)_localctx).conOptPluginDir = match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GtuidSetContext extends ParserRuleContext { + public List uuidSet() { + return getRuleContexts(UuidSetContext.class); + } + public UuidSetContext uuidSet(int i) { + return getRuleContext(UuidSetContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public GtuidSetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_gtuidSet; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGtuidSet(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGtuidSet(this); + } + } + + public final GtuidSetContext gtuidSet() throws RecognitionException { + GtuidSetContext _localctx = new GtuidSetContext(_ctx, getState()); + enterRule(_localctx, 368, RULE_gtuidSet); + int _la; + try { + setState(4645); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + enterOuterAlt(_localctx, 1); + { + setState(4636); + uuidSet(); + setState(4641); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4637); + match(COMMA); + setState(4638); + uuidSet(); + } + } + setState(4643); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case STRING_LITERAL: + enterOuterAlt(_localctx, 2); + { + setState(4644); + match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XaStartTransactionContext extends ParserRuleContext { + public Token xaStart; + public Token xaAction; + public TerminalNode XA() { return getToken(MySqlParser.XA, 0); } + public XidContext xid() { + return getRuleContext(XidContext.class,0); + } + public TerminalNode START() { return getToken(MySqlParser.START, 0); } + public TerminalNode BEGIN() { return getToken(MySqlParser.BEGIN, 0); } + public TerminalNode JOIN() { return getToken(MySqlParser.JOIN, 0); } + public TerminalNode RESUME() { return getToken(MySqlParser.RESUME, 0); } + public XaStartTransactionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xaStartTransaction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterXaStartTransaction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitXaStartTransaction(this); + } + } + + public final XaStartTransactionContext xaStartTransaction() throws RecognitionException { + XaStartTransactionContext _localctx = new XaStartTransactionContext(_ctx, getState()); + enterRule(_localctx, 370, RULE_xaStartTransaction); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4647); + match(XA); + setState(4648); + ((XaStartTransactionContext)_localctx).xaStart = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==BEGIN || _la==START) ) { + ((XaStartTransactionContext)_localctx).xaStart = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4649); + xid(); + setState(4651); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==JOIN || _la==RESUME) { + { + setState(4650); + ((XaStartTransactionContext)_localctx).xaAction = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==JOIN || _la==RESUME) ) { + ((XaStartTransactionContext)_localctx).xaAction = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XaEndTransactionContext extends ParserRuleContext { + public TerminalNode XA() { return getToken(MySqlParser.XA, 0); } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public XidContext xid() { + return getRuleContext(XidContext.class,0); + } + public TerminalNode SUSPEND() { return getToken(MySqlParser.SUSPEND, 0); } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode MIGRATE() { return getToken(MySqlParser.MIGRATE, 0); } + public XaEndTransactionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xaEndTransaction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterXaEndTransaction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitXaEndTransaction(this); + } + } + + public final XaEndTransactionContext xaEndTransaction() throws RecognitionException { + XaEndTransactionContext _localctx = new XaEndTransactionContext(_ctx, getState()); + enterRule(_localctx, 372, RULE_xaEndTransaction); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4653); + match(XA); + setState(4654); + match(END); + setState(4655); + xid(); + setState(4661); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SUSPEND) { + { + setState(4656); + match(SUSPEND); + setState(4659); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(4657); + match(FOR); + setState(4658); + match(MIGRATE); + } + } + + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XaPrepareStatementContext extends ParserRuleContext { + public TerminalNode XA() { return getToken(MySqlParser.XA, 0); } + public TerminalNode PREPARE() { return getToken(MySqlParser.PREPARE, 0); } + public XidContext xid() { + return getRuleContext(XidContext.class,0); + } + public XaPrepareStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xaPrepareStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterXaPrepareStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitXaPrepareStatement(this); + } + } + + public final XaPrepareStatementContext xaPrepareStatement() throws RecognitionException { + XaPrepareStatementContext _localctx = new XaPrepareStatementContext(_ctx, getState()); + enterRule(_localctx, 374, RULE_xaPrepareStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(4663); + match(XA); + setState(4664); + match(PREPARE); + setState(4665); + xid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XaCommitWorkContext extends ParserRuleContext { + public TerminalNode XA() { return getToken(MySqlParser.XA, 0); } + public TerminalNode COMMIT() { return getToken(MySqlParser.COMMIT, 0); } + public XidContext xid() { + return getRuleContext(XidContext.class,0); + } + public TerminalNode ONE() { return getToken(MySqlParser.ONE, 0); } + public TerminalNode PHASE() { return getToken(MySqlParser.PHASE, 0); } + public XaCommitWorkContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xaCommitWork; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterXaCommitWork(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitXaCommitWork(this); + } + } + + public final XaCommitWorkContext xaCommitWork() throws RecognitionException { + XaCommitWorkContext _localctx = new XaCommitWorkContext(_ctx, getState()); + enterRule(_localctx, 376, RULE_xaCommitWork); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4667); + match(XA); + setState(4668); + match(COMMIT); + setState(4669); + xid(); + setState(4672); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONE) { + { + setState(4670); + match(ONE); + setState(4671); + match(PHASE); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XaRollbackWorkContext extends ParserRuleContext { + public TerminalNode XA() { return getToken(MySqlParser.XA, 0); } + public TerminalNode ROLLBACK() { return getToken(MySqlParser.ROLLBACK, 0); } + public XidContext xid() { + return getRuleContext(XidContext.class,0); + } + public XaRollbackWorkContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xaRollbackWork; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterXaRollbackWork(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitXaRollbackWork(this); + } + } + + public final XaRollbackWorkContext xaRollbackWork() throws RecognitionException { + XaRollbackWorkContext _localctx = new XaRollbackWorkContext(_ctx, getState()); + enterRule(_localctx, 378, RULE_xaRollbackWork); + try { + enterOuterAlt(_localctx, 1); + { + setState(4674); + match(XA); + setState(4675); + match(ROLLBACK); + setState(4676); + xid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XaRecoverWorkContext extends ParserRuleContext { + public TerminalNode XA() { return getToken(MySqlParser.XA, 0); } + public TerminalNode RECOVER() { return getToken(MySqlParser.RECOVER, 0); } + public TerminalNode CONVERT() { return getToken(MySqlParser.CONVERT, 0); } + public XidContext xid() { + return getRuleContext(XidContext.class,0); + } + public XaRecoverWorkContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xaRecoverWork; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterXaRecoverWork(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitXaRecoverWork(this); + } + } + + public final XaRecoverWorkContext xaRecoverWork() throws RecognitionException { + XaRecoverWorkContext _localctx = new XaRecoverWorkContext(_ctx, getState()); + enterRule(_localctx, 380, RULE_xaRecoverWork); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4678); + match(XA); + setState(4679); + match(RECOVER); + setState(4682); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONVERT) { + { + setState(4680); + match(CONVERT); + setState(4681); + xid(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrepareStatementContext extends ParserRuleContext { + public Token query; + public Token variable; + public TerminalNode PREPARE() { return getToken(MySqlParser.PREPARE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode LOCAL_ID() { return getToken(MySqlParser.LOCAL_ID, 0); } + public PrepareStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_prepareStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPrepareStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPrepareStatement(this); + } + } + + public final PrepareStatementContext prepareStatement() throws RecognitionException { + PrepareStatementContext _localctx = new PrepareStatementContext(_ctx, getState()); + enterRule(_localctx, 382, RULE_prepareStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(4684); + match(PREPARE); + setState(4685); + uid(); + setState(4686); + match(FROM); + setState(4689); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING_LITERAL: + { + setState(4687); + ((PrepareStatementContext)_localctx).query = match(STRING_LITERAL); + } + break; + case LOCAL_ID: + { + setState(4688); + ((PrepareStatementContext)_localctx).variable = match(LOCAL_ID); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExecuteStatementContext extends ParserRuleContext { + public TerminalNode EXECUTE() { return getToken(MySqlParser.EXECUTE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode USING() { return getToken(MySqlParser.USING, 0); } + public UserVariablesContext userVariables() { + return getRuleContext(UserVariablesContext.class,0); + } + public ExecuteStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_executeStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterExecuteStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitExecuteStatement(this); + } + } + + public final ExecuteStatementContext executeStatement() throws RecognitionException { + ExecuteStatementContext _localctx = new ExecuteStatementContext(_ctx, getState()); + enterRule(_localctx, 384, RULE_executeStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4691); + match(EXECUTE); + setState(4692); + uid(); + setState(4695); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(4693); + match(USING); + setState(4694); + userVariables(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeallocatePrepareContext extends ParserRuleContext { + public Token dropFormat; + public TerminalNode PREPARE() { return getToken(MySqlParser.PREPARE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode DEALLOCATE() { return getToken(MySqlParser.DEALLOCATE, 0); } + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public DeallocatePrepareContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_deallocatePrepare; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDeallocatePrepare(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDeallocatePrepare(this); + } + } + + public final DeallocatePrepareContext deallocatePrepare() throws RecognitionException { + DeallocatePrepareContext _localctx = new DeallocatePrepareContext(_ctx, getState()); + enterRule(_localctx, 386, RULE_deallocatePrepare); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4697); + ((DeallocatePrepareContext)_localctx).dropFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DROP || _la==DEALLOCATE) ) { + ((DeallocatePrepareContext)_localctx).dropFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4698); + match(PREPARE); + setState(4699); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RoutineBodyContext extends ParserRuleContext { + public BlockStatementContext blockStatement() { + return getRuleContext(BlockStatementContext.class,0); + } + public SqlStatementContext sqlStatement() { + return getRuleContext(SqlStatementContext.class,0); + } + public RoutineBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_routineBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoutineBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoutineBody(this); + } + } + + public final RoutineBodyContext routineBody() throws RecognitionException { + RoutineBodyContext _localctx = new RoutineBodyContext(_ctx, getState()); + enterRule(_localctx, 388, RULE_routineBody); + try { + setState(4703); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,681,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4701); + blockStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4702); + sqlStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BlockStatementContext extends ParserRuleContext { + public TerminalNode BEGIN() { return getToken(MySqlParser.BEGIN, 0); } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode COLON_SYMB() { return getToken(MySqlParser.COLON_SYMB, 0); } + public List declareVariable() { + return getRuleContexts(DeclareVariableContext.class); + } + public DeclareVariableContext declareVariable(int i) { + return getRuleContext(DeclareVariableContext.class,i); + } + public List SEMI() { return getTokens(MySqlParser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(MySqlParser.SEMI, i); + } + public List declareCondition() { + return getRuleContexts(DeclareConditionContext.class); + } + public DeclareConditionContext declareCondition(int i) { + return getRuleContext(DeclareConditionContext.class,i); + } + public List declareCursor() { + return getRuleContexts(DeclareCursorContext.class); + } + public DeclareCursorContext declareCursor(int i) { + return getRuleContext(DeclareCursorContext.class,i); + } + public List declareHandler() { + return getRuleContexts(DeclareHandlerContext.class); + } + public DeclareHandlerContext declareHandler(int i) { + return getRuleContext(DeclareHandlerContext.class,i); + } + public List procedureSqlStatement() { + return getRuleContexts(ProcedureSqlStatementContext.class); + } + public ProcedureSqlStatementContext procedureSqlStatement(int i) { + return getRuleContext(ProcedureSqlStatementContext.class,i); + } + public BlockStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_blockStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBlockStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBlockStatement(this); + } + } + + public final BlockStatementContext blockStatement() throws RecognitionException { + BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState()); + enterRule(_localctx, 390, RULE_blockStatement); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4708); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,682,_ctx) ) { + case 1: + { + setState(4705); + uid(); + setState(4706); + match(COLON_SYMB); + } + break; + } + setState(4710); + match(BEGIN); + setState(4716); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,683,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4711); + declareVariable(); + setState(4712); + match(SEMI); + } + } + } + setState(4718); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,683,_ctx); + } + setState(4724); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,684,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4719); + declareCondition(); + setState(4720); + match(SEMI); + } + } + } + setState(4726); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,684,_ctx); + } + setState(4732); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,685,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4727); + declareCursor(); + setState(4728); + match(SEMI); + } + } + } + setState(4734); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,685,_ctx); + } + setState(4740); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DECLARE) { + { + { + setState(4735); + declareHandler(); + setState(4736); + match(SEMI); + } + } + setState(4742); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4746); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,687,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4743); + procedureSqlStatement(); + } + } + } + setState(4748); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,687,_ctx); + } + setState(4749); + match(END); + setState(4751); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,688,_ctx) ) { + case 1: + { + setState(4750); + uid(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CaseStatementContext extends ParserRuleContext { + public List CASE() { return getTokens(MySqlParser.CASE); } + public TerminalNode CASE(int i) { + return getToken(MySqlParser.CASE, i); + } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List caseAlternative() { + return getRuleContexts(CaseAlternativeContext.class); + } + public CaseAlternativeContext caseAlternative(int i) { + return getRuleContext(CaseAlternativeContext.class,i); + } + public TerminalNode ELSE() { return getToken(MySqlParser.ELSE, 0); } + public List procedureSqlStatement() { + return getRuleContexts(ProcedureSqlStatementContext.class); + } + public ProcedureSqlStatementContext procedureSqlStatement(int i) { + return getRuleContext(ProcedureSqlStatementContext.class,i); + } + public CaseStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_caseStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCaseStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCaseStatement(this); + } + } + + public final CaseStatementContext caseStatement() throws RecognitionException { + CaseStatementContext _localctx = new CaseStatementContext(_ctx, getState()); + enterRule(_localctx, 392, RULE_caseStatement); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4753); + match(CASE); + setState(4756); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,689,_ctx) ) { + case 1: + { + setState(4754); + uid(); + } + break; + case 2: + { + setState(4755); + expression(0); + } + break; + } + setState(4759); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(4758); + caseAlternative(); + } + } + setState(4761); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==WHEN ); + setState(4769); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(4763); + match(ELSE); + setState(4765); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4764); + procedureSqlStatement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4767); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,691,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + + setState(4771); + match(END); + setState(4772); + match(CASE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IfStatementContext extends ParserRuleContext { + public ProcedureSqlStatementContext procedureSqlStatement; + public List thenStatements = new ArrayList(); + public List elseStatements = new ArrayList(); + public List IF() { return getTokens(MySqlParser.IF); } + public TerminalNode IF(int i) { + return getToken(MySqlParser.IF, i); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode THEN() { return getToken(MySqlParser.THEN, 0); } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public List elifAlternative() { + return getRuleContexts(ElifAlternativeContext.class); + } + public ElifAlternativeContext elifAlternative(int i) { + return getRuleContext(ElifAlternativeContext.class,i); + } + public TerminalNode ELSE() { return getToken(MySqlParser.ELSE, 0); } + public List procedureSqlStatement() { + return getRuleContexts(ProcedureSqlStatementContext.class); + } + public ProcedureSqlStatementContext procedureSqlStatement(int i) { + return getRuleContext(ProcedureSqlStatementContext.class,i); + } + public IfStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIfStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIfStatement(this); + } + } + + public final IfStatementContext ifStatement() throws RecognitionException { + IfStatementContext _localctx = new IfStatementContext(_ctx, getState()); + enterRule(_localctx, 394, RULE_ifStatement); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4774); + match(IF); + setState(4775); + expression(0); + setState(4776); + match(THEN); + setState(4778); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4777); + ((IfStatementContext)_localctx).procedureSqlStatement = procedureSqlStatement(); + ((IfStatementContext)_localctx).thenStatements.add(((IfStatementContext)_localctx).procedureSqlStatement); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4780); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,693,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(4785); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ELSEIF) { + { + { + setState(4782); + elifAlternative(); + } + } + setState(4787); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4794); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(4788); + match(ELSE); + setState(4790); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4789); + ((IfStatementContext)_localctx).procedureSqlStatement = procedureSqlStatement(); + ((IfStatementContext)_localctx).elseStatements.add(((IfStatementContext)_localctx).procedureSqlStatement); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4792); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,695,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + + setState(4796); + match(END); + setState(4797); + match(IF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IterateStatementContext extends ParserRuleContext { + public TerminalNode ITERATE() { return getToken(MySqlParser.ITERATE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public IterateStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_iterateStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIterateStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIterateStatement(this); + } + } + + public final IterateStatementContext iterateStatement() throws RecognitionException { + IterateStatementContext _localctx = new IterateStatementContext(_ctx, getState()); + enterRule(_localctx, 396, RULE_iterateStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(4799); + match(ITERATE); + setState(4800); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LeaveStatementContext extends ParserRuleContext { + public TerminalNode LEAVE() { return getToken(MySqlParser.LEAVE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public LeaveStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_leaveStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLeaveStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLeaveStatement(this); + } + } + + public final LeaveStatementContext leaveStatement() throws RecognitionException { + LeaveStatementContext _localctx = new LeaveStatementContext(_ctx, getState()); + enterRule(_localctx, 398, RULE_leaveStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(4802); + match(LEAVE); + setState(4803); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LoopStatementContext extends ParserRuleContext { + public List LOOP() { return getTokens(MySqlParser.LOOP); } + public TerminalNode LOOP(int i) { + return getToken(MySqlParser.LOOP, i); + } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode COLON_SYMB() { return getToken(MySqlParser.COLON_SYMB, 0); } + public List procedureSqlStatement() { + return getRuleContexts(ProcedureSqlStatementContext.class); + } + public ProcedureSqlStatementContext procedureSqlStatement(int i) { + return getRuleContext(ProcedureSqlStatementContext.class,i); + } + public LoopStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_loopStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLoopStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLoopStatement(this); + } + } + + public final LoopStatementContext loopStatement() throws RecognitionException { + LoopStatementContext _localctx = new LoopStatementContext(_ctx, getState()); + enterRule(_localctx, 400, RULE_loopStatement); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4808); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(4805); + uid(); + setState(4806); + match(COLON_SYMB); + } + } + + setState(4810); + match(LOOP); + setState(4812); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4811); + procedureSqlStatement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4814); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,698,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(4816); + match(END); + setState(4817); + match(LOOP); + setState(4819); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(4818); + uid(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RepeatStatementContext extends ParserRuleContext { + public List REPEAT() { return getTokens(MySqlParser.REPEAT); } + public TerminalNode REPEAT(int i) { + return getToken(MySqlParser.REPEAT, i); + } + public TerminalNode UNTIL() { return getToken(MySqlParser.UNTIL, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode COLON_SYMB() { return getToken(MySqlParser.COLON_SYMB, 0); } + public List procedureSqlStatement() { + return getRuleContexts(ProcedureSqlStatementContext.class); + } + public ProcedureSqlStatementContext procedureSqlStatement(int i) { + return getRuleContext(ProcedureSqlStatementContext.class,i); + } + public RepeatStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_repeatStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRepeatStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRepeatStatement(this); + } + } + + public final RepeatStatementContext repeatStatement() throws RecognitionException { + RepeatStatementContext _localctx = new RepeatStatementContext(_ctx, getState()); + enterRule(_localctx, 402, RULE_repeatStatement); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4824); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,700,_ctx) ) { + case 1: + { + setState(4821); + uid(); + setState(4822); + match(COLON_SYMB); + } + break; + } + setState(4826); + match(REPEAT); + setState(4828); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4827); + procedureSqlStatement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4830); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,701,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(4832); + match(UNTIL); + setState(4833); + expression(0); + setState(4834); + match(END); + setState(4835); + match(REPEAT); + setState(4837); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(4836); + uid(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReturnStatementContext extends ParserRuleContext { + public TerminalNode RETURN() { return getToken(MySqlParser.RETURN, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ReturnStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returnStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterReturnStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitReturnStatement(this); + } + } + + public final ReturnStatementContext returnStatement() throws RecognitionException { + ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState()); + enterRule(_localctx, 404, RULE_returnStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(4839); + match(RETURN); + setState(4840); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WhileStatementContext extends ParserRuleContext { + public List WHILE() { return getTokens(MySqlParser.WHILE); } + public TerminalNode WHILE(int i) { + return getToken(MySqlParser.WHILE, i); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode DO() { return getToken(MySqlParser.DO, 0); } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode COLON_SYMB() { return getToken(MySqlParser.COLON_SYMB, 0); } + public List procedureSqlStatement() { + return getRuleContexts(ProcedureSqlStatementContext.class); + } + public ProcedureSqlStatementContext procedureSqlStatement(int i) { + return getRuleContext(ProcedureSqlStatementContext.class,i); + } + public WhileStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_whileStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWhileStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWhileStatement(this); + } + } + + public final WhileStatementContext whileStatement() throws RecognitionException { + WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); + enterRule(_localctx, 406, RULE_whileStatement); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4845); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(4842); + uid(); + setState(4843); + match(COLON_SYMB); + } + } + + setState(4847); + match(WHILE); + setState(4848); + expression(0); + setState(4849); + match(DO); + setState(4851); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4850); + procedureSqlStatement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4853); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,704,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(4855); + match(END); + setState(4856); + match(WHILE); + setState(4858); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513782665026244608L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055071174737L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & 268698883L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17174494689L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & -1099511627777L) != 0) || ((((_la - 346)) & ~0x3f) == 0 && ((1L << (_la - 346)) & -2882305960540372993L) != 0) || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & -4398063288321L) != 0) || ((((_la - 474)) & ~0x3f) == 0 && ((1L << (_la - 474)) & -16325548649218049L) != 0) || ((((_la - 538)) & ~0x3f) == 0 && ((1L << (_la - 538)) & -9007199258936065L) != 0) || ((((_la - 602)) & ~0x3f) == 0 && ((1L << (_la - 602)) & -68719476801L) != 0) || ((((_la - 666)) & ~0x3f) == 0 && ((1L << (_la - 666)) & -22236531750340609L) != 0) || ((((_la - 730)) & ~0x3f) == 0 && ((1L << (_la - 730)) & -65L) != 0) || ((((_la - 794)) & ~0x3f) == 0 && ((1L << (_la - 794)) & -6145L) != 0) || ((((_la - 858)) & ~0x3f) == 0 && ((1L << (_la - 858)) & -1L) != 0) || ((((_la - 922)) & ~0x3f) == 0 && ((1L << (_la - 922)) & -1L) != 0) || ((((_la - 986)) & ~0x3f) == 0 && ((1L << (_la - 986)) & -1L) != 0) || ((((_la - 1050)) & ~0x3f) == 0 && ((1L << (_la - 1050)) & 576460752303423487L) != 0) || ((((_la - 1124)) & ~0x3f) == 0 && ((1L << (_la - 1124)) & 8627683329L) != 0)) { + { + setState(4857); + uid(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CursorStatementContext extends ParserRuleContext { + public CursorStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cursorStatement; } + + public CursorStatementContext() { } + public void copyFrom(CursorStatementContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CloseCursorContext extends CursorStatementContext { + public TerminalNode CLOSE() { return getToken(MySqlParser.CLOSE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public CloseCursorContext(CursorStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCloseCursor(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCloseCursor(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class OpenCursorContext extends CursorStatementContext { + public TerminalNode OPEN() { return getToken(MySqlParser.OPEN, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public OpenCursorContext(CursorStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterOpenCursor(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitOpenCursor(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class FetchCursorContext extends CursorStatementContext { + public TerminalNode FETCH() { return getToken(MySqlParser.FETCH, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TerminalNode NEXT() { return getToken(MySqlParser.NEXT, 0); } + public FetchCursorContext(CursorStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFetchCursor(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFetchCursor(this); + } + } + + public final CursorStatementContext cursorStatement() throws RecognitionException { + CursorStatementContext _localctx = new CursorStatementContext(_ctx, getState()); + enterRule(_localctx, 408, RULE_cursorStatement); + int _la; + try { + setState(4875); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLOSE: + _localctx = new CloseCursorContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(4860); + match(CLOSE); + setState(4861); + uid(); + } + break; + case FETCH: + _localctx = new FetchCursorContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(4862); + match(FETCH); + setState(4867); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,707,_ctx) ) { + case 1: + { + setState(4864); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NEXT) { + { + setState(4863); + match(NEXT); + } + } + + setState(4866); + match(FROM); + } + break; + } + setState(4869); + uid(); + setState(4870); + match(INTO); + setState(4871); + uidList(); + } + break; + case OPEN: + _localctx = new OpenCursorContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(4873); + match(OPEN); + setState(4874); + uid(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeclareVariableContext extends ParserRuleContext { + public TerminalNode DECLARE() { return getToken(MySqlParser.DECLARE, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public DataTypeContext dataType() { + return getRuleContext(DataTypeContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public DeclareVariableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declareVariable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDeclareVariable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDeclareVariable(this); + } + } + + public final DeclareVariableContext declareVariable() throws RecognitionException { + DeclareVariableContext _localctx = new DeclareVariableContext(_ctx, getState()); + enterRule(_localctx, 410, RULE_declareVariable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4877); + match(DECLARE); + setState(4878); + uidList(); + setState(4879); + dataType(); + setState(4882); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(4880); + match(DEFAULT); + setState(4881); + expression(0); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeclareConditionContext extends ParserRuleContext { + public TerminalNode DECLARE() { return getToken(MySqlParser.DECLARE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode CONDITION() { return getToken(MySqlParser.CONDITION, 0); } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode SQLSTATE() { return getToken(MySqlParser.SQLSTATE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode VALUE() { return getToken(MySqlParser.VALUE, 0); } + public DeclareConditionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declareCondition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDeclareCondition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDeclareCondition(this); + } + } + + public final DeclareConditionContext declareCondition() throws RecognitionException { + DeclareConditionContext _localctx = new DeclareConditionContext(_ctx, getState()); + enterRule(_localctx, 412, RULE_declareCondition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4884); + match(DECLARE); + setState(4885); + uid(); + setState(4886); + match(CONDITION); + setState(4887); + match(FOR); + setState(4894); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + { + setState(4888); + decimalLiteral(); + } + break; + case SQLSTATE: + { + setState(4889); + match(SQLSTATE); + setState(4891); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VALUE) { + { + setState(4890); + match(VALUE); + } + } + + setState(4893); + match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeclareCursorContext extends ParserRuleContext { + public TerminalNode DECLARE() { return getToken(MySqlParser.DECLARE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode CURSOR() { return getToken(MySqlParser.CURSOR, 0); } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public DeclareCursorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declareCursor; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDeclareCursor(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDeclareCursor(this); + } + } + + public final DeclareCursorContext declareCursor() throws RecognitionException { + DeclareCursorContext _localctx = new DeclareCursorContext(_ctx, getState()); + enterRule(_localctx, 414, RULE_declareCursor); + try { + enterOuterAlt(_localctx, 1); + { + setState(4896); + match(DECLARE); + setState(4897); + uid(); + setState(4898); + match(CURSOR); + setState(4899); + match(FOR); + setState(4900); + selectStatement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeclareHandlerContext extends ParserRuleContext { + public Token handlerAction; + public TerminalNode DECLARE() { return getToken(MySqlParser.DECLARE, 0); } + public TerminalNode HANDLER() { return getToken(MySqlParser.HANDLER, 0); } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public List handlerConditionValue() { + return getRuleContexts(HandlerConditionValueContext.class); + } + public HandlerConditionValueContext handlerConditionValue(int i) { + return getRuleContext(HandlerConditionValueContext.class,i); + } + public RoutineBodyContext routineBody() { + return getRuleContext(RoutineBodyContext.class,0); + } + public TerminalNode CONTINUE() { return getToken(MySqlParser.CONTINUE, 0); } + public TerminalNode EXIT() { return getToken(MySqlParser.EXIT, 0); } + public TerminalNode UNDO() { return getToken(MySqlParser.UNDO, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public DeclareHandlerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declareHandler; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDeclareHandler(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDeclareHandler(this); + } + } + + public final DeclareHandlerContext declareHandler() throws RecognitionException { + DeclareHandlerContext _localctx = new DeclareHandlerContext(_ctx, getState()); + enterRule(_localctx, 416, RULE_declareHandler); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4902); + match(DECLARE); + setState(4903); + ((DeclareHandlerContext)_localctx).handlerAction = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CONTINUE || _la==EXIT || _la==UNDO) ) { + ((DeclareHandlerContext)_localctx).handlerAction = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4904); + match(HANDLER); + setState(4905); + match(FOR); + setState(4906); + handlerConditionValue(); + setState(4911); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4907); + match(COMMA); + setState(4908); + handlerConditionValue(); + } + } + setState(4913); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4914); + routineBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HandlerConditionValueContext extends ParserRuleContext { + public HandlerConditionValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_handlerConditionValue; } + + public HandlerConditionValueContext() { } + public void copyFrom(HandlerConditionValueContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class HandlerConditionWarningContext extends HandlerConditionValueContext { + public TerminalNode SQLWARNING() { return getToken(MySqlParser.SQLWARNING, 0); } + public HandlerConditionWarningContext(HandlerConditionValueContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerConditionWarning(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerConditionWarning(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class HandlerConditionCodeContext extends HandlerConditionValueContext { + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public HandlerConditionCodeContext(HandlerConditionValueContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerConditionCode(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerConditionCode(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class HandlerConditionNotfoundContext extends HandlerConditionValueContext { + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public TerminalNode FOUND() { return getToken(MySqlParser.FOUND, 0); } + public HandlerConditionNotfoundContext(HandlerConditionValueContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerConditionNotfound(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerConditionNotfound(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class HandlerConditionStateContext extends HandlerConditionValueContext { + public TerminalNode SQLSTATE() { return getToken(MySqlParser.SQLSTATE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode VALUE() { return getToken(MySqlParser.VALUE, 0); } + public HandlerConditionStateContext(HandlerConditionValueContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerConditionState(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerConditionState(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class HandlerConditionExceptionContext extends HandlerConditionValueContext { + public TerminalNode SQLEXCEPTION() { return getToken(MySqlParser.SQLEXCEPTION, 0); } + public HandlerConditionExceptionContext(HandlerConditionValueContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerConditionException(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerConditionException(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class HandlerConditionNameContext extends HandlerConditionValueContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public HandlerConditionNameContext(HandlerConditionValueContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHandlerConditionName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHandlerConditionName(this); + } + } + + public final HandlerConditionValueContext handlerConditionValue() throws RecognitionException { + HandlerConditionValueContext _localctx = new HandlerConditionValueContext(_ctx, getState()); + enterRule(_localctx, 418, RULE_handlerConditionValue); + int _la; + try { + setState(4927); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + _localctx = new HandlerConditionCodeContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(4916); + decimalLiteral(); + } + break; + case SQLSTATE: + _localctx = new HandlerConditionStateContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(4917); + match(SQLSTATE); + setState(4919); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VALUE) { + { + setState(4918); + match(VALUE); + } + } + + setState(4921); + match(STRING_LITERAL); + } + break; + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + _localctx = new HandlerConditionNameContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(4922); + uid(); + } + break; + case SQLWARNING: + _localctx = new HandlerConditionWarningContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(4923); + match(SQLWARNING); + } + break; + case NOT: + _localctx = new HandlerConditionNotfoundContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(4924); + match(NOT); + setState(4925); + match(FOUND); + } + break; + case SQLEXCEPTION: + _localctx = new HandlerConditionExceptionContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(4926); + match(SQLEXCEPTION); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ProcedureSqlStatementContext extends ParserRuleContext { + public TerminalNode SEMI() { return getToken(MySqlParser.SEMI, 0); } + public CompoundStatementContext compoundStatement() { + return getRuleContext(CompoundStatementContext.class,0); + } + public SqlStatementContext sqlStatement() { + return getRuleContext(SqlStatementContext.class,0); + } + public ProcedureSqlStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_procedureSqlStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterProcedureSqlStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitProcedureSqlStatement(this); + } + } + + public final ProcedureSqlStatementContext procedureSqlStatement() throws RecognitionException { + ProcedureSqlStatementContext _localctx = new ProcedureSqlStatementContext(_ctx, getState()); + enterRule(_localctx, 420, RULE_procedureSqlStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(4931); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,715,_ctx) ) { + case 1: + { + setState(4929); + compoundStatement(); + } + break; + case 2: + { + setState(4930); + sqlStatement(); + } + break; + } + setState(4933); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CaseAlternativeContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(MySqlParser.WHEN, 0); } + public TerminalNode THEN() { return getToken(MySqlParser.THEN, 0); } + public ConstantContext constant() { + return getRuleContext(ConstantContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List procedureSqlStatement() { + return getRuleContexts(ProcedureSqlStatementContext.class); + } + public ProcedureSqlStatementContext procedureSqlStatement(int i) { + return getRuleContext(ProcedureSqlStatementContext.class,i); + } + public CaseAlternativeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_caseAlternative; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCaseAlternative(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCaseAlternative(this); + } + } + + public final CaseAlternativeContext caseAlternative() throws RecognitionException { + CaseAlternativeContext _localctx = new CaseAlternativeContext(_ctx, getState()); + enterRule(_localctx, 422, RULE_caseAlternative); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4935); + match(WHEN); + setState(4938); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,716,_ctx) ) { + case 1: + { + setState(4936); + constant(); + } + break; + case 2: + { + setState(4937); + expression(0); + } + break; + } + setState(4940); + match(THEN); + setState(4942); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4941); + procedureSqlStatement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4944); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,717,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ElifAlternativeContext extends ParserRuleContext { + public TerminalNode ELSEIF() { return getToken(MySqlParser.ELSEIF, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode THEN() { return getToken(MySqlParser.THEN, 0); } + public List procedureSqlStatement() { + return getRuleContexts(ProcedureSqlStatementContext.class); + } + public ProcedureSqlStatementContext procedureSqlStatement(int i) { + return getRuleContext(ProcedureSqlStatementContext.class,i); + } + public ElifAlternativeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elifAlternative; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterElifAlternative(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitElifAlternative(this); + } + } + + public final ElifAlternativeContext elifAlternative() throws RecognitionException { + ElifAlternativeContext _localctx = new ElifAlternativeContext(_ctx, getState()); + enterRule(_localctx, 424, RULE_elifAlternative); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4946); + match(ELSEIF); + setState(4947); + expression(0); + setState(4948); + match(THEN); + setState(4950); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4949); + procedureSqlStatement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4952); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,718,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterUserContext extends ParserRuleContext { + public AlterUserContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterUser; } + + public AlterUserContext() { } + public void copyFrom(AlterUserContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterUserMysqlV80Context extends AlterUserContext { + public Token tlsNone; + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public List userAuthOption() { + return getRuleContexts(UserAuthOptionContext.class); + } + public UserAuthOptionContext userAuthOption(int i) { + return getRuleContext(UserAuthOptionContext.class,i); + } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode REQUIRE() { return getToken(MySqlParser.REQUIRE, 0); } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public List userPasswordOption() { + return getRuleContexts(UserPasswordOptionContext.class); + } + public UserPasswordOptionContext userPasswordOption(int i) { + return getRuleContext(UserPasswordOptionContext.class,i); + } + public List userLockOption() { + return getRuleContexts(UserLockOptionContext.class); + } + public UserLockOptionContext userLockOption(int i) { + return getRuleContext(UserLockOptionContext.class,i); + } + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode ATTRIBUTE() { return getToken(MySqlParser.ATTRIBUTE, 0); } + public List tlsOption() { + return getRuleContexts(TlsOptionContext.class); + } + public TlsOptionContext tlsOption(int i) { + return getRuleContext(TlsOptionContext.class,i); + } + public TerminalNode NONE() { return getToken(MySqlParser.NONE, 0); } + public List userResourceOption() { + return getRuleContexts(UserResourceOptionContext.class); + } + public UserResourceOptionContext userResourceOption(int i) { + return getRuleContext(UserResourceOptionContext.class,i); + } + public List AND() { return getTokens(MySqlParser.AND); } + public TerminalNode AND(int i) { + return getToken(MySqlParser.AND, i); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode ROLE() { return getToken(MySqlParser.ROLE, 0); } + public RoleOptionContext roleOption() { + return getRuleContext(RoleOptionContext.class,0); + } + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public AlterUserMysqlV80Context(AlterUserContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterUserMysqlV80(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterUserMysqlV80(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AlterUserMysqlV56Context extends AlterUserContext { + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public List userSpecification() { + return getRuleContexts(UserSpecificationContext.class); + } + public UserSpecificationContext userSpecification(int i) { + return getRuleContext(UserSpecificationContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AlterUserMysqlV56Context(AlterUserContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAlterUserMysqlV56(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAlterUserMysqlV56(this); + } + } + + public final AlterUserContext alterUser() throws RecognitionException { + AlterUserContext _localctx = new AlterUserContext(_ctx, getState()); + enterRule(_localctx, 426, RULE_alterUser); + int _la; + try { + setState(5027); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,733,_ctx) ) { + case 1: + _localctx = new AlterUserMysqlV56Context(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(4954); + match(ALTER); + setState(4955); + match(USER); + setState(4956); + userSpecification(); + setState(4961); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4957); + match(COMMA); + setState(4958); + userSpecification(); + } + } + setState(4963); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + _localctx = new AlterUserMysqlV80Context(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(4964); + match(ALTER); + setState(4965); + match(USER); + setState(4967); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(4966); + ifExists(); + } + } + + setState(4969); + userAuthOption(); + setState(4974); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4970); + match(COMMA); + setState(4971); + userAuthOption(); + } + } + setState(4976); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4991); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==REQUIRE) { + { + setState(4977); + match(REQUIRE); + setState(4989); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NONE: + { + setState(4978); + ((AlterUserMysqlV80Context)_localctx).tlsNone = match(NONE); + } + break; + case SSL: + case CIPHER: + case ISSUER: + case SUBJECT: + case X509: + { + setState(4979); + tlsOption(); + setState(4986); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AND || _la==SSL || _la==CIPHER || _la==ISSUER || _la==SUBJECT || _la==X509) { + { + { + setState(4981); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AND) { + { + setState(4980); + match(AND); + } + } + + setState(4983); + tlsOption(); + } + } + setState(4988); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + + setState(4999); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,727,_ctx) ) { + case 1: + { + setState(4993); + match(WITH); + setState(4995); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(4994); + userResourceOption(); + } + } + setState(4997); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( ((((_la - 499)) & ~0x3f) == 0 && ((1L << (_la - 499)) & 51L) != 0) ); + } + break; + } + setState(5005); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ACCOUNT || _la==FAILED_LOGIN_ATTEMPTS || _la==PASSWORD || _la==PASSWORD_LOCK_TIME) { + { + setState(5003); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FAILED_LOGIN_ATTEMPTS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + { + setState(5001); + userPasswordOption(); + } + break; + case ACCOUNT: + { + setState(5002); + userLockOption(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(5007); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5012); + _errHandler.sync(this); + switch (_input.LA(1)) { + case COMMENT: + { + setState(5008); + match(COMMENT); + setState(5009); + match(STRING_LITERAL); + } + break; + case ATTRIBUTE: + { + setState(5010); + match(ATTRIBUTE); + setState(5011); + match(STRING_LITERAL); + } + break; + case EOF: + case ALTER: + case ANALYZE: + case CALL: + case CHANGE: + case CHECK: + case CREATE: + case DELETE: + case DESC: + case DESCRIBE: + case DROP: + case EXPLAIN: + case GET: + case GRANT: + case INSERT: + case KILL: + case LOAD: + case LOCK: + case OPTIMIZE: + case PURGE: + case RELEASE: + case RENAME: + case REPLACE: + case RESIGNAL: + case REVOKE: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case BEGIN: + case BINLOG: + case CACHE: + case CHECKSUM: + case COMMIT: + case DEALLOCATE: + case DO: + case FLUSH: + case HANDLER: + case HELP: + case INSTALL: + case PREPARE: + case REPAIR: + case RESET: + case ROLLBACK: + case SAVEPOINT: + case START: + case STOP: + case TRUNCATE: + case UNINSTALL: + case XA: + case EXECUTE: + case SHUTDOWN: + case MINUS: + case LR_BRACKET: + case SEMI: + break; + default: + break; + } + } + break; + case 3: + _localctx = new AlterUserMysqlV80Context(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(5014); + match(ALTER); + setState(5015); + match(USER); + setState(5017); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,731,_ctx) ) { + case 1: + { + setState(5016); + ifExists(); + } + break; + } + setState(5021); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,732,_ctx) ) { + case 1: + { + setState(5019); + userName(); + } + break; + case 2: + { + setState(5020); + uid(); + } + break; + } + setState(5023); + match(DEFAULT); + setState(5024); + match(ROLE); + setState(5025); + roleOption(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateUserContext extends ParserRuleContext { + public CreateUserContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createUser; } + + public CreateUserContext() { } + public void copyFrom(CreateUserContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CreateUserMysqlV56Context extends CreateUserContext { + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public List userAuthOption() { + return getRuleContexts(UserAuthOptionContext.class); + } + public UserAuthOptionContext userAuthOption(int i) { + return getRuleContext(UserAuthOptionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public CreateUserMysqlV56Context(CreateUserContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateUserMysqlV56(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateUserMysqlV56(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CreateUserMysqlV80Context extends CreateUserContext { + public Token tlsNone; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public List userAuthOption() { + return getRuleContexts(UserAuthOptionContext.class); + } + public UserAuthOptionContext userAuthOption(int i) { + return getRuleContext(UserAuthOptionContext.class,i); + } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode ROLE() { return getToken(MySqlParser.ROLE, 0); } + public RoleOptionContext roleOption() { + return getRuleContext(RoleOptionContext.class,0); + } + public TerminalNode REQUIRE() { return getToken(MySqlParser.REQUIRE, 0); } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public List userPasswordOption() { + return getRuleContexts(UserPasswordOptionContext.class); + } + public UserPasswordOptionContext userPasswordOption(int i) { + return getRuleContext(UserPasswordOptionContext.class,i); + } + public List userLockOption() { + return getRuleContexts(UserLockOptionContext.class); + } + public UserLockOptionContext userLockOption(int i) { + return getRuleContext(UserLockOptionContext.class,i); + } + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode ATTRIBUTE() { return getToken(MySqlParser.ATTRIBUTE, 0); } + public List tlsOption() { + return getRuleContexts(TlsOptionContext.class); + } + public TlsOptionContext tlsOption(int i) { + return getRuleContext(TlsOptionContext.class,i); + } + public TerminalNode NONE() { return getToken(MySqlParser.NONE, 0); } + public List userResourceOption() { + return getRuleContexts(UserResourceOptionContext.class); + } + public UserResourceOptionContext userResourceOption(int i) { + return getRuleContext(UserResourceOptionContext.class,i); + } + public List AND() { return getTokens(MySqlParser.AND); } + public TerminalNode AND(int i) { + return getToken(MySqlParser.AND, i); + } + public CreateUserMysqlV80Context(CreateUserContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateUserMysqlV80(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateUserMysqlV80(this); + } + } + + public final CreateUserContext createUser() throws RecognitionException { + CreateUserContext _localctx = new CreateUserContext(_ctx, getState()); + enterRule(_localctx, 428, RULE_createUser); + int _la; + try { + setState(5094); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,747,_ctx) ) { + case 1: + _localctx = new CreateUserMysqlV56Context(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(5029); + match(CREATE); + setState(5030); + match(USER); + setState(5031); + userAuthOption(); + setState(5036); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5032); + match(COMMA); + setState(5033); + userAuthOption(); + } + } + setState(5038); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + _localctx = new CreateUserMysqlV80Context(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(5039); + match(CREATE); + setState(5040); + match(USER); + setState(5042); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(5041); + ifNotExists(); + } + } + + setState(5044); + userAuthOption(); + setState(5049); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5045); + match(COMMA); + setState(5046); + userAuthOption(); + } + } + setState(5051); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5055); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(5052); + match(DEFAULT); + setState(5053); + match(ROLE); + setState(5054); + roleOption(); + } + } + + setState(5071); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==REQUIRE) { + { + setState(5057); + match(REQUIRE); + setState(5069); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NONE: + { + setState(5058); + ((CreateUserMysqlV80Context)_localctx).tlsNone = match(NONE); + } + break; + case SSL: + case CIPHER: + case ISSUER: + case SUBJECT: + case X509: + { + setState(5059); + tlsOption(); + setState(5066); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AND || _la==SSL || _la==CIPHER || _la==ISSUER || _la==SUBJECT || _la==X509) { + { + { + setState(5061); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AND) { + { + setState(5060); + match(AND); + } + } + + setState(5063); + tlsOption(); + } + } + setState(5068); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + + setState(5079); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,743,_ctx) ) { + case 1: + { + setState(5073); + match(WITH); + setState(5075); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(5074); + userResourceOption(); + } + } + setState(5077); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( ((((_la - 499)) & ~0x3f) == 0 && ((1L << (_la - 499)) & 51L) != 0) ); + } + break; + } + setState(5085); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ACCOUNT || _la==FAILED_LOGIN_ATTEMPTS || _la==PASSWORD || _la==PASSWORD_LOCK_TIME) { + { + setState(5083); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FAILED_LOGIN_ATTEMPTS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + { + setState(5081); + userPasswordOption(); + } + break; + case ACCOUNT: + { + setState(5082); + userLockOption(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(5087); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5092); + _errHandler.sync(this); + switch (_input.LA(1)) { + case COMMENT: + { + setState(5088); + match(COMMENT); + setState(5089); + match(STRING_LITERAL); + } + break; + case ATTRIBUTE: + { + setState(5090); + match(ATTRIBUTE); + setState(5091); + match(STRING_LITERAL); + } + break; + case EOF: + case ALTER: + case ANALYZE: + case CALL: + case CHANGE: + case CHECK: + case CREATE: + case DELETE: + case DESC: + case DESCRIBE: + case DROP: + case EXPLAIN: + case GET: + case GRANT: + case INSERT: + case KILL: + case LOAD: + case LOCK: + case OPTIMIZE: + case PURGE: + case RELEASE: + case RENAME: + case REPLACE: + case RESIGNAL: + case REVOKE: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case BEGIN: + case BINLOG: + case CACHE: + case CHECKSUM: + case COMMIT: + case DEALLOCATE: + case DO: + case FLUSH: + case HANDLER: + case HELP: + case INSTALL: + case PREPARE: + case REPAIR: + case RESET: + case ROLLBACK: + case SAVEPOINT: + case START: + case STOP: + case TRUNCATE: + case UNINSTALL: + case XA: + case EXECUTE: + case SHUTDOWN: + case MINUS: + case LR_BRACKET: + case SEMI: + break; + default: + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropUserContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public IfExistsContext ifExists() { + return getRuleContext(IfExistsContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public DropUserContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropUser; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDropUser(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDropUser(this); + } + } + + public final DropUserContext dropUser() throws RecognitionException { + DropUserContext _localctx = new DropUserContext(_ctx, getState()); + enterRule(_localctx, 430, RULE_dropUser); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5096); + match(DROP); + setState(5097); + match(USER); + setState(5099); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(5098); + ifExists(); + } + } + + setState(5101); + userName(); + setState(5106); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5102); + match(COMMA); + setState(5103); + userName(); + } + } + setState(5108); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GrantStatementContext extends ParserRuleContext { + public Token privilegeObject; + public Token tlsNone; + public List GRANT() { return getTokens(MySqlParser.GRANT); } + public TerminalNode GRANT(int i) { + return getToken(MySqlParser.GRANT, i); + } + public List privelegeClause() { + return getRuleContexts(PrivelegeClauseContext.class); + } + public PrivelegeClauseContext privelegeClause(int i) { + return getRuleContext(PrivelegeClauseContext.class,i); + } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public PrivilegeLevelContext privilegeLevel() { + return getRuleContext(PrivilegeLevelContext.class,0); + } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public List userAuthOption() { + return getRuleContexts(UserAuthOptionContext.class); + } + public UserAuthOptionContext userAuthOption(int i) { + return getRuleContext(UserAuthOptionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode REQUIRE() { return getToken(MySqlParser.REQUIRE, 0); } + public List WITH() { return getTokens(MySqlParser.WITH); } + public TerminalNode WITH(int i) { + return getToken(MySqlParser.WITH, i); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public TerminalNode ROLE() { return getToken(MySqlParser.ROLE, 0); } + public RoleOptionContext roleOption() { + return getRuleContext(RoleOptionContext.class,0); + } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); } + public List tlsOption() { + return getRuleContexts(TlsOptionContext.class); + } + public TlsOptionContext tlsOption(int i) { + return getRuleContext(TlsOptionContext.class,i); + } + public TerminalNode NONE() { return getToken(MySqlParser.NONE, 0); } + public List OPTION() { return getTokens(MySqlParser.OPTION); } + public TerminalNode OPTION(int i) { + return getToken(MySqlParser.OPTION, i); + } + public List userResourceOption() { + return getRuleContexts(UserResourceOptionContext.class); + } + public UserResourceOptionContext userResourceOption(int i) { + return getRuleContext(UserResourceOptionContext.class,i); + } + public List AND() { return getTokens(MySqlParser.AND); } + public TerminalNode AND(int i) { + return getToken(MySqlParser.AND, i); + } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode ADMIN() { return getToken(MySqlParser.ADMIN, 0); } + public GrantStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_grantStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGrantStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGrantStatement(this); + } + } + + public final GrantStatementContext grantStatement() throws RecognitionException { + GrantStatementContext _localctx = new GrantStatementContext(_ctx, getState()); + enterRule(_localctx, 432, RULE_grantStatement); + int _la; + try { + int _alt; + setState(5202); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,768,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5109); + match(GRANT); + setState(5110); + privelegeClause(); + setState(5115); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5111); + match(COMMA); + setState(5112); + privelegeClause(); + } + } + setState(5117); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5118); + match(ON); + setState(5120); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,751,_ctx) ) { + case 1: + { + setState(5119); + ((GrantStatementContext)_localctx).privilegeObject = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==PROCEDURE || _la==TABLE || _la==FUNCTION) ) { + ((GrantStatementContext)_localctx).privilegeObject = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(5122); + privilegeLevel(); + setState(5123); + match(TO); + setState(5124); + userAuthOption(); + setState(5129); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5125); + match(COMMA); + setState(5126); + userAuthOption(); + } + } + setState(5131); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5146); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==REQUIRE) { + { + setState(5132); + match(REQUIRE); + setState(5144); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NONE: + { + setState(5133); + ((GrantStatementContext)_localctx).tlsNone = match(NONE); + } + break; + case SSL: + case CIPHER: + case ISSUER: + case SUBJECT: + case X509: + { + setState(5134); + tlsOption(); + setState(5141); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AND || _la==SSL || _la==CIPHER || _la==ISSUER || _la==SUBJECT || _la==X509) { + { + { + setState(5136); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AND) { + { + setState(5135); + match(AND); + } + } + + setState(5138); + tlsOption(); + } + } + setState(5143); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + + setState(5157); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,759,_ctx) ) { + case 1: + { + setState(5148); + match(WITH); + setState(5154); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,758,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(5152); + _errHandler.sync(this); + switch (_input.LA(1)) { + case GRANT: + { + setState(5149); + match(GRANT); + setState(5150); + match(OPTION); + } + break; + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + { + setState(5151); + userResourceOption(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(5156); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,758,_ctx); + } + } + break; + } + setState(5165); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(5159); + match(AS); + setState(5160); + userName(); + setState(5161); + match(WITH); + setState(5162); + match(ROLE); + setState(5163); + roleOption(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5167); + match(GRANT); + setState(5170); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,761,_ctx) ) { + case 1: + { + setState(5168); + userName(); + } + break; + case 2: + { + setState(5169); + uid(); + } + break; + } + setState(5179); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5172); + match(COMMA); + setState(5175); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,762,_ctx) ) { + case 1: + { + setState(5173); + userName(); + } + break; + case 2: + { + setState(5174); + uid(); + } + break; + } + } + } + setState(5181); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5182); + match(TO); + setState(5185); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,764,_ctx) ) { + case 1: + { + setState(5183); + userName(); + } + break; + case 2: + { + setState(5184); + uid(); + } + break; + } + setState(5194); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5187); + match(COMMA); + setState(5190); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,765,_ctx) ) { + case 1: + { + setState(5188); + userName(); + } + break; + case 2: + { + setState(5189); + uid(); + } + break; + } + } + } + setState(5196); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5200); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,767,_ctx) ) { + case 1: + { + setState(5197); + match(WITH); + setState(5198); + match(ADMIN); + setState(5199); + match(OPTION); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RoleOptionContext extends ParserRuleContext { + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode NONE() { return getToken(MySqlParser.NONE, 0); } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode EXCEPT() { return getToken(MySqlParser.EXCEPT, 0); } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public RoleOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_roleOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoleOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoleOption(this); + } + } + + public final RoleOptionContext roleOption() throws RecognitionException { + RoleOptionContext _localctx = new RoleOptionContext(_ctx, getState()); + enterRule(_localctx, 434, RULE_roleOption); + int _la; + try { + setState(5226); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,772,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5204); + match(DEFAULT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5205); + match(NONE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5206); + match(ALL); + setState(5216); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXCEPT) { + { + setState(5207); + match(EXCEPT); + setState(5208); + userName(); + setState(5213); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5209); + match(COMMA); + setState(5210); + userName(); + } + } + setState(5215); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5218); + userName(); + setState(5223); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5219); + match(COMMA); + setState(5220); + userName(); + } + } + setState(5225); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GrantProxyContext extends ParserRuleContext { + public UserNameContext fromFirst; + public UserNameContext toFirst; + public UserNameContext userName; + public List toOther = new ArrayList(); + public List GRANT() { return getTokens(MySqlParser.GRANT); } + public TerminalNode GRANT(int i) { + return getToken(MySqlParser.GRANT, i); + } + public TerminalNode PROXY() { return getToken(MySqlParser.PROXY, 0); } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public TerminalNode OPTION() { return getToken(MySqlParser.OPTION, 0); } + public GrantProxyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_grantProxy; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGrantProxy(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGrantProxy(this); + } + } + + public final GrantProxyContext grantProxy() throws RecognitionException { + GrantProxyContext _localctx = new GrantProxyContext(_ctx, getState()); + enterRule(_localctx, 436, RULE_grantProxy); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5228); + match(GRANT); + setState(5229); + match(PROXY); + setState(5230); + match(ON); + setState(5231); + ((GrantProxyContext)_localctx).fromFirst = userName(); + setState(5232); + match(TO); + setState(5233); + ((GrantProxyContext)_localctx).toFirst = userName(); + setState(5238); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5234); + match(COMMA); + setState(5235); + ((GrantProxyContext)_localctx).userName = userName(); + ((GrantProxyContext)_localctx).toOther.add(((GrantProxyContext)_localctx).userName); + } + } + setState(5240); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5244); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,774,_ctx) ) { + case 1: + { + setState(5241); + match(WITH); + setState(5242); + match(GRANT); + setState(5243); + match(OPTION); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RenameUserContext extends ParserRuleContext { + public TerminalNode RENAME() { return getToken(MySqlParser.RENAME, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public List renameUserClause() { + return getRuleContexts(RenameUserClauseContext.class); + } + public RenameUserClauseContext renameUserClause(int i) { + return getRuleContext(RenameUserClauseContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public RenameUserContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_renameUser; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRenameUser(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRenameUser(this); + } + } + + public final RenameUserContext renameUser() throws RecognitionException { + RenameUserContext _localctx = new RenameUserContext(_ctx, getState()); + enterRule(_localctx, 438, RULE_renameUser); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5246); + match(RENAME); + setState(5247); + match(USER); + setState(5248); + renameUserClause(); + setState(5253); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5249); + match(COMMA); + setState(5250); + renameUserClause(); + } + } + setState(5255); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RevokeStatementContext extends ParserRuleContext { + public RevokeStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_revokeStatement; } + + public RevokeStatementContext() { } + public void copyFrom(RevokeStatementContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DetailRevokeContext extends RevokeStatementContext { + public Token privilegeObject; + public TerminalNode REVOKE() { return getToken(MySqlParser.REVOKE, 0); } + public List privelegeClause() { + return getRuleContexts(PrivelegeClauseContext.class); + } + public PrivelegeClauseContext privelegeClause(int i) { + return getRuleContext(PrivelegeClauseContext.class,i); + } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public PrivilegeLevelContext privilegeLevel() { + return getRuleContext(PrivilegeLevelContext.class,0); + } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); } + public DetailRevokeContext(RevokeStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDetailRevoke(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDetailRevoke(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RoleRevokeContext extends RevokeStatementContext { + public TerminalNode REVOKE() { return getToken(MySqlParser.REVOKE, 0); } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public RoleRevokeContext(RevokeStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoleRevoke(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoleRevoke(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShortRevokeContext extends RevokeStatementContext { + public TerminalNode REVOKE() { return getToken(MySqlParser.REVOKE, 0); } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode GRANT() { return getToken(MySqlParser.GRANT, 0); } + public TerminalNode OPTION() { return getToken(MySqlParser.OPTION, 0); } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public TerminalNode PRIVILEGES() { return getToken(MySqlParser.PRIVILEGES, 0); } + public ShortRevokeContext(RevokeStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShortRevoke(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShortRevoke(this); + } + } + + public final RevokeStatementContext revokeStatement() throws RecognitionException { + RevokeStatementContext _localctx = new RevokeStatementContext(_ctx, getState()); + enterRule(_localctx, 440, RULE_revokeStatement); + int _la; + try { + setState(5326); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,787,_ctx) ) { + case 1: + _localctx = new DetailRevokeContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(5256); + match(REVOKE); + setState(5257); + privelegeClause(); + setState(5262); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5258); + match(COMMA); + setState(5259); + privelegeClause(); + } + } + setState(5264); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5265); + match(ON); + setState(5267); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,777,_ctx) ) { + case 1: + { + setState(5266); + ((DetailRevokeContext)_localctx).privilegeObject = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==PROCEDURE || _la==TABLE || _la==FUNCTION) ) { + ((DetailRevokeContext)_localctx).privilegeObject = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(5269); + privilegeLevel(); + setState(5270); + match(FROM); + setState(5271); + userName(); + setState(5276); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5272); + match(COMMA); + setState(5273); + userName(); + } + } + setState(5278); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + _localctx = new ShortRevokeContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(5279); + match(REVOKE); + setState(5280); + match(ALL); + setState(5282); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PRIVILEGES) { + { + setState(5281); + match(PRIVILEGES); + } + } + + setState(5284); + match(COMMA); + setState(5285); + match(GRANT); + setState(5286); + match(OPTION); + setState(5287); + match(FROM); + setState(5288); + userName(); + setState(5293); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5289); + match(COMMA); + setState(5290); + userName(); + } + } + setState(5295); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 3: + _localctx = new RoleRevokeContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(5296); + match(REVOKE); + setState(5299); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,781,_ctx) ) { + case 1: + { + setState(5297); + userName(); + } + break; + case 2: + { + setState(5298); + uid(); + } + break; + } + setState(5308); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5301); + match(COMMA); + setState(5304); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,782,_ctx) ) { + case 1: + { + setState(5302); + userName(); + } + break; + case 2: + { + setState(5303); + uid(); + } + break; + } + } + } + setState(5310); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5311); + match(FROM); + setState(5314); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,784,_ctx) ) { + case 1: + { + setState(5312); + userName(); + } + break; + case 2: + { + setState(5313); + uid(); + } + break; + } + setState(5323); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5316); + match(COMMA); + setState(5319); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,785,_ctx) ) { + case 1: + { + setState(5317); + userName(); + } + break; + case 2: + { + setState(5318); + uid(); + } + break; + } + } + } + setState(5325); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RevokeProxyContext extends ParserRuleContext { + public UserNameContext onUser; + public UserNameContext fromFirst; + public UserNameContext userName; + public List fromOther = new ArrayList(); + public TerminalNode REVOKE() { return getToken(MySqlParser.REVOKE, 0); } + public TerminalNode PROXY() { return getToken(MySqlParser.PROXY, 0); } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public RevokeProxyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_revokeProxy; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRevokeProxy(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRevokeProxy(this); + } + } + + public final RevokeProxyContext revokeProxy() throws RecognitionException { + RevokeProxyContext _localctx = new RevokeProxyContext(_ctx, getState()); + enterRule(_localctx, 442, RULE_revokeProxy); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5328); + match(REVOKE); + setState(5329); + match(PROXY); + setState(5330); + match(ON); + setState(5331); + ((RevokeProxyContext)_localctx).onUser = userName(); + setState(5332); + match(FROM); + setState(5333); + ((RevokeProxyContext)_localctx).fromFirst = userName(); + setState(5338); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5334); + match(COMMA); + setState(5335); + ((RevokeProxyContext)_localctx).userName = userName(); + ((RevokeProxyContext)_localctx).fromOther.add(((RevokeProxyContext)_localctx).userName); + } + } + setState(5340); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetPasswordStatementContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public PasswordFunctionClauseContext passwordFunctionClause() { + return getRuleContext(PasswordFunctionClauseContext.class,0); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public SetPasswordStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_setPasswordStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetPasswordStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetPasswordStatement(this); + } + } + + public final SetPasswordStatementContext setPasswordStatement() throws RecognitionException { + SetPasswordStatementContext _localctx = new SetPasswordStatementContext(_ctx, getState()); + enterRule(_localctx, 444, RULE_setPasswordStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5341); + match(SET); + setState(5342); + match(PASSWORD); + setState(5345); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(5343); + match(FOR); + setState(5344); + userName(); + } + } + + setState(5347); + match(EQUAL_SYMBOL); + setState(5350); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OLD_PASSWORD: + case PASSWORD: + { + setState(5348); + passwordFunctionClause(); + } + break; + case STRING_LITERAL: + { + setState(5349); + match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UserSpecificationContext extends ParserRuleContext { + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public UserPasswordOptionContext userPasswordOption() { + return getRuleContext(UserPasswordOptionContext.class,0); + } + public UserSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_userSpecification; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUserSpecification(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUserSpecification(this); + } + } + + public final UserSpecificationContext userSpecification() throws RecognitionException { + UserSpecificationContext _localctx = new UserSpecificationContext(_ctx, getState()); + enterRule(_localctx, 446, RULE_userSpecification); + try { + enterOuterAlt(_localctx, 1); + { + setState(5352); + userName(); + setState(5353); + userPasswordOption(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UserAuthOptionContext extends ParserRuleContext { + public UserAuthOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_userAuthOption; } + + public UserAuthOptionContext() { } + public void copyFrom(UserAuthOptionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SimpleAuthOptionContext extends UserAuthOptionContext { + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public SimpleAuthOptionContext(UserAuthOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleAuthOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleAuthOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ModuleAuthOptionContext extends UserAuthOptionContext { + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public TerminalNode IDENTIFIED() { return getToken(MySqlParser.IDENTIFIED, 0); } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public AuthenticationRuleContext authenticationRule() { + return getRuleContext(AuthenticationRuleContext.class,0); + } + public ModuleAuthOptionContext(UserAuthOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterModuleAuthOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitModuleAuthOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RandomAuthOptionContext extends UserAuthOptionContext { + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public TerminalNode IDENTIFIED() { return getToken(MySqlParser.IDENTIFIED, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public TerminalNode RANDOM() { return getToken(MySqlParser.RANDOM, 0); } + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public AuthOptionClauseContext authOptionClause() { + return getRuleContext(AuthOptionClauseContext.class,0); + } + public RandomAuthOptionContext(UserAuthOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRandomAuthOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRandomAuthOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class StringAuthOptionContext extends UserAuthOptionContext { + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public TerminalNode IDENTIFIED() { return getToken(MySqlParser.IDENTIFIED, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public AuthOptionClauseContext authOptionClause() { + return getRuleContext(AuthOptionClauseContext.class,0); + } + public StringAuthOptionContext(UserAuthOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStringAuthOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStringAuthOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class HashAuthOptionContext extends UserAuthOptionContext { + public Token hashed; + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public TerminalNode IDENTIFIED() { return getToken(MySqlParser.IDENTIFIED, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public HashAuthOptionContext(UserAuthOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHashAuthOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHashAuthOption(this); + } + } + + public final UserAuthOptionContext userAuthOption() throws RecognitionException { + UserAuthOptionContext _localctx = new UserAuthOptionContext(_ctx, getState()); + enterRule(_localctx, 448, RULE_userAuthOption); + try { + setState(5380); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,791,_ctx) ) { + case 1: + _localctx = new HashAuthOptionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(5355); + userName(); + setState(5356); + match(IDENTIFIED); + setState(5357); + match(BY); + setState(5358); + match(PASSWORD); + setState(5359); + ((HashAuthOptionContext)_localctx).hashed = match(STRING_LITERAL); + } + break; + case 2: + _localctx = new RandomAuthOptionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(5361); + userName(); + setState(5362); + match(IDENTIFIED); + setState(5363); + match(BY); + setState(5364); + match(RANDOM); + setState(5365); + match(PASSWORD); + setState(5366); + authOptionClause(); + } + break; + case 3: + _localctx = new StringAuthOptionContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(5368); + userName(); + setState(5369); + match(IDENTIFIED); + setState(5370); + match(BY); + setState(5371); + match(STRING_LITERAL); + setState(5372); + authOptionClause(); + } + break; + case 4: + _localctx = new ModuleAuthOptionContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(5374); + userName(); + setState(5375); + match(IDENTIFIED); + setState(5376); + match(WITH); + setState(5377); + authenticationRule(); + } + break; + case 5: + _localctx = new SimpleAuthOptionContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(5379); + userName(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AuthOptionClauseContext extends ParserRuleContext { + public TerminalNode REPLACE() { return getToken(MySqlParser.REPLACE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode RETAIN() { return getToken(MySqlParser.RETAIN, 0); } + public TerminalNode CURRENT() { return getToken(MySqlParser.CURRENT, 0); } + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public AuthOptionClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_authOptionClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAuthOptionClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAuthOptionClause(this); + } + } + + public final AuthOptionClauseContext authOptionClause() throws RecognitionException { + AuthOptionClauseContext _localctx = new AuthOptionClauseContext(_ctx, getState()); + enterRule(_localctx, 450, RULE_authOptionClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5384); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,792,_ctx) ) { + case 1: + { + setState(5382); + match(REPLACE); + setState(5383); + match(STRING_LITERAL); + } + break; + } + setState(5389); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==RETAIN) { + { + setState(5386); + match(RETAIN); + setState(5387); + match(CURRENT); + setState(5388); + match(PASSWORD); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AuthenticationRuleContext extends ParserRuleContext { + public AuthenticationRuleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_authenticationRule; } + + public AuthenticationRuleContext() { } + public void copyFrom(AuthenticationRuleContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PasswordModuleOptionContext extends AuthenticationRuleContext { + public AuthPluginContext authPlugin() { + return getRuleContext(AuthPluginContext.class,0); + } + public TerminalNode USING() { return getToken(MySqlParser.USING, 0); } + public PasswordFunctionClauseContext passwordFunctionClause() { + return getRuleContext(PasswordFunctionClauseContext.class,0); + } + public PasswordModuleOptionContext(AuthenticationRuleContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPasswordModuleOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPasswordModuleOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ModuleContext extends AuthenticationRuleContext { + public AuthPluginContext authPlugin() { + return getRuleContext(AuthPluginContext.class,0); + } + public AuthOptionClauseContext authOptionClause() { + return getRuleContext(AuthOptionClauseContext.class,0); + } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public TerminalNode USING() { return getToken(MySqlParser.USING, 0); } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode RANDOM() { return getToken(MySqlParser.RANDOM, 0); } + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public ModuleContext(AuthenticationRuleContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterModule(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitModule(this); + } + } + + public final AuthenticationRuleContext authenticationRule() throws RecognitionException { + AuthenticationRuleContext _localctx = new AuthenticationRuleContext(_ctx, getState()); + enterRule(_localctx, 452, RULE_authenticationRule); + int _la; + try { + setState(5405); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,796,_ctx) ) { + case 1: + _localctx = new ModuleContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(5391); + authPlugin(); + setState(5399); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,795,_ctx) ) { + case 1: + { + setState(5392); + _la = _input.LA(1); + if ( !(_la==AS || _la==BY || _la==USING) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5396); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING_LITERAL: + { + setState(5393); + match(STRING_LITERAL); + } + break; + case RANDOM: + { + setState(5394); + match(RANDOM); + setState(5395); + match(PASSWORD); + } + break; + default: + throw new NoViableAltException(this); + } + setState(5398); + authOptionClause(); + } + break; + } + } + break; + case 2: + _localctx = new PasswordModuleOptionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(5401); + authPlugin(); + setState(5402); + match(USING); + setState(5403); + passwordFunctionClause(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TlsOptionContext extends ParserRuleContext { + public TerminalNode SSL() { return getToken(MySqlParser.SSL, 0); } + public TerminalNode X509() { return getToken(MySqlParser.X509, 0); } + public TerminalNode CIPHER() { return getToken(MySqlParser.CIPHER, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode ISSUER() { return getToken(MySqlParser.ISSUER, 0); } + public TerminalNode SUBJECT() { return getToken(MySqlParser.SUBJECT, 0); } + public TlsOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tlsOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTlsOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTlsOption(this); + } + } + + public final TlsOptionContext tlsOption() throws RecognitionException { + TlsOptionContext _localctx = new TlsOptionContext(_ctx, getState()); + enterRule(_localctx, 454, RULE_tlsOption); + try { + setState(5415); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SSL: + enterOuterAlt(_localctx, 1); + { + setState(5407); + match(SSL); + } + break; + case X509: + enterOuterAlt(_localctx, 2); + { + setState(5408); + match(X509); + } + break; + case CIPHER: + enterOuterAlt(_localctx, 3); + { + setState(5409); + match(CIPHER); + setState(5410); + match(STRING_LITERAL); + } + break; + case ISSUER: + enterOuterAlt(_localctx, 4); + { + setState(5411); + match(ISSUER); + setState(5412); + match(STRING_LITERAL); + } + break; + case SUBJECT: + enterOuterAlt(_localctx, 5); + { + setState(5413); + match(SUBJECT); + setState(5414); + match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UserResourceOptionContext extends ParserRuleContext { + public TerminalNode MAX_QUERIES_PER_HOUR() { return getToken(MySqlParser.MAX_QUERIES_PER_HOUR, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode MAX_UPDATES_PER_HOUR() { return getToken(MySqlParser.MAX_UPDATES_PER_HOUR, 0); } + public TerminalNode MAX_CONNECTIONS_PER_HOUR() { return getToken(MySqlParser.MAX_CONNECTIONS_PER_HOUR, 0); } + public TerminalNode MAX_USER_CONNECTIONS() { return getToken(MySqlParser.MAX_USER_CONNECTIONS, 0); } + public UserResourceOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_userResourceOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUserResourceOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUserResourceOption(this); + } + } + + public final UserResourceOptionContext userResourceOption() throws RecognitionException { + UserResourceOptionContext _localctx = new UserResourceOptionContext(_ctx, getState()); + enterRule(_localctx, 456, RULE_userResourceOption); + try { + setState(5425); + _errHandler.sync(this); + switch (_input.LA(1)) { + case MAX_QUERIES_PER_HOUR: + enterOuterAlt(_localctx, 1); + { + setState(5417); + match(MAX_QUERIES_PER_HOUR); + setState(5418); + decimalLiteral(); + } + break; + case MAX_UPDATES_PER_HOUR: + enterOuterAlt(_localctx, 2); + { + setState(5419); + match(MAX_UPDATES_PER_HOUR); + setState(5420); + decimalLiteral(); + } + break; + case MAX_CONNECTIONS_PER_HOUR: + enterOuterAlt(_localctx, 3); + { + setState(5421); + match(MAX_CONNECTIONS_PER_HOUR); + setState(5422); + decimalLiteral(); + } + break; + case MAX_USER_CONNECTIONS: + enterOuterAlt(_localctx, 4); + { + setState(5423); + match(MAX_USER_CONNECTIONS); + setState(5424); + decimalLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UserPasswordOptionContext extends ParserRuleContext { + public Token expireType; + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public TerminalNode EXPIRE() { return getToken(MySqlParser.EXPIRE, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode DAY() { return getToken(MySqlParser.DAY, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode NEVER() { return getToken(MySqlParser.NEVER, 0); } + public TerminalNode INTERVAL() { return getToken(MySqlParser.INTERVAL, 0); } + public TerminalNode HISTORY() { return getToken(MySqlParser.HISTORY, 0); } + public TerminalNode REUSE() { return getToken(MySqlParser.REUSE, 0); } + public TerminalNode REQUIRE() { return getToken(MySqlParser.REQUIRE, 0); } + public TerminalNode CURRENT() { return getToken(MySqlParser.CURRENT, 0); } + public TerminalNode OPTIONAL() { return getToken(MySqlParser.OPTIONAL, 0); } + public TerminalNode FAILED_LOGIN_ATTEMPTS() { return getToken(MySqlParser.FAILED_LOGIN_ATTEMPTS, 0); } + public TerminalNode PASSWORD_LOCK_TIME() { return getToken(MySqlParser.PASSWORD_LOCK_TIME, 0); } + public TerminalNode UNBOUNDED() { return getToken(MySqlParser.UNBOUNDED, 0); } + public UserPasswordOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_userPasswordOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUserPasswordOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUserPasswordOption(this); + } + } + + public final UserPasswordOptionContext userPasswordOption() throws RecognitionException { + UserPasswordOptionContext _localctx = new UserPasswordOptionContext(_ctx, getState()); + enterRule(_localctx, 458, RULE_userPasswordOption); + int _la; + try { + setState(5465); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,804,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5427); + match(PASSWORD); + setState(5428); + match(EXPIRE); + setState(5435); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEFAULT: + { + setState(5429); + ((UserPasswordOptionContext)_localctx).expireType = match(DEFAULT); + } + break; + case NEVER: + { + setState(5430); + ((UserPasswordOptionContext)_localctx).expireType = match(NEVER); + } + break; + case INTERVAL: + { + setState(5431); + ((UserPasswordOptionContext)_localctx).expireType = match(INTERVAL); + setState(5432); + decimalLiteral(); + setState(5433); + match(DAY); + } + break; + case EOF: + case ALTER: + case ANALYZE: + case ATTRIBUTE: + case CALL: + case CHANGE: + case CHECK: + case CREATE: + case DELETE: + case DESC: + case DESCRIBE: + case DROP: + case EXPLAIN: + case GET: + case GRANT: + case INSERT: + case KILL: + case LOAD: + case LOCK: + case OPTIMIZE: + case PURGE: + case RELEASE: + case RENAME: + case REPLACE: + case RESIGNAL: + case REVOKE: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case ACCOUNT: + case BEGIN: + case BINLOG: + case CACHE: + case CHECKSUM: + case COMMENT: + case COMMIT: + case DEALLOCATE: + case DO: + case FAILED_LOGIN_ATTEMPTS: + case FLUSH: + case HANDLER: + case HELP: + case INSTALL: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PREPARE: + case REPAIR: + case RESET: + case ROLLBACK: + case SAVEPOINT: + case START: + case STOP: + case TRUNCATE: + case UNINSTALL: + case XA: + case EXECUTE: + case SHUTDOWN: + case MINUS: + case LR_BRACKET: + case COMMA: + case SEMI: + break; + default: + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5437); + match(PASSWORD); + setState(5438); + match(HISTORY); + setState(5441); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEFAULT: + { + setState(5439); + match(DEFAULT); + } + break; + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + { + setState(5440); + decimalLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5443); + match(PASSWORD); + setState(5444); + match(REUSE); + setState(5445); + match(INTERVAL); + setState(5450); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEFAULT: + { + setState(5446); + match(DEFAULT); + } + break; + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + { + setState(5447); + decimalLiteral(); + setState(5448); + match(DAY); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5452); + match(PASSWORD); + setState(5453); + match(REQUIRE); + setState(5454); + match(CURRENT); + setState(5456); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT || _la==OPTIONAL) { + { + setState(5455); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==OPTIONAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(5458); + match(FAILED_LOGIN_ATTEMPTS); + setState(5459); + decimalLiteral(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(5460); + match(PASSWORD_LOCK_TIME); + setState(5463); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + { + setState(5461); + decimalLiteral(); + } + break; + case UNBOUNDED: + { + setState(5462); + match(UNBOUNDED); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UserLockOptionContext extends ParserRuleContext { + public Token lockType; + public TerminalNode ACCOUNT() { return getToken(MySqlParser.ACCOUNT, 0); } + public TerminalNode LOCK() { return getToken(MySqlParser.LOCK, 0); } + public TerminalNode UNLOCK() { return getToken(MySqlParser.UNLOCK, 0); } + public UserLockOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_userLockOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUserLockOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUserLockOption(this); + } + } + + public final UserLockOptionContext userLockOption() throws RecognitionException { + UserLockOptionContext _localctx = new UserLockOptionContext(_ctx, getState()); + enterRule(_localctx, 460, RULE_userLockOption); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5467); + match(ACCOUNT); + setState(5468); + ((UserLockOptionContext)_localctx).lockType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==LOCK || _la==UNLOCK) ) { + ((UserLockOptionContext)_localctx).lockType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrivelegeClauseContext extends ParserRuleContext { + public PrivilegeContext privilege() { + return getRuleContext(PrivilegeContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public PrivelegeClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_privelegeClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPrivelegeClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPrivelegeClause(this); + } + } + + public final PrivelegeClauseContext privelegeClause() throws RecognitionException { + PrivelegeClauseContext _localctx = new PrivelegeClauseContext(_ctx, getState()); + enterRule(_localctx, 462, RULE_privelegeClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5470); + privilege(); + setState(5475); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(5471); + match(LR_BRACKET); + setState(5472); + uidList(); + setState(5473); + match(RR_BRACKET); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrivilegeContext extends ParserRuleContext { + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode PRIVILEGES() { return getToken(MySqlParser.PRIVILEGES, 0); } + public TerminalNode ALTER() { return getToken(MySqlParser.ALTER, 0); } + public TerminalNode ROUTINE() { return getToken(MySqlParser.ROUTINE, 0); } + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode TEMPORARY() { return getToken(MySqlParser.TEMPORARY, 0); } + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public TerminalNode VIEW() { return getToken(MySqlParser.VIEW, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public TerminalNode ROLE() { return getToken(MySqlParser.ROLE, 0); } + public TerminalNode DELETE() { return getToken(MySqlParser.DELETE, 0); } + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode EVENT() { return getToken(MySqlParser.EVENT, 0); } + public TerminalNode EXECUTE() { return getToken(MySqlParser.EXECUTE, 0); } + public TerminalNode FILE() { return getToken(MySqlParser.FILE, 0); } + public TerminalNode GRANT() { return getToken(MySqlParser.GRANT, 0); } + public TerminalNode OPTION() { return getToken(MySqlParser.OPTION, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode INSERT() { return getToken(MySqlParser.INSERT, 0); } + public TerminalNode LOCK() { return getToken(MySqlParser.LOCK, 0); } + public TerminalNode PROCESS() { return getToken(MySqlParser.PROCESS, 0); } + public TerminalNode PROXY() { return getToken(MySqlParser.PROXY, 0); } + public TerminalNode REFERENCES() { return getToken(MySqlParser.REFERENCES, 0); } + public TerminalNode RELOAD() { return getToken(MySqlParser.RELOAD, 0); } + public TerminalNode REPLICATION() { return getToken(MySqlParser.REPLICATION, 0); } + public TerminalNode CLIENT() { return getToken(MySqlParser.CLIENT, 0); } + public TerminalNode SLAVE() { return getToken(MySqlParser.SLAVE, 0); } + public TerminalNode SELECT() { return getToken(MySqlParser.SELECT, 0); } + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode DATABASES() { return getToken(MySqlParser.DATABASES, 0); } + public TerminalNode SHUTDOWN() { return getToken(MySqlParser.SHUTDOWN, 0); } + public TerminalNode SUPER() { return getToken(MySqlParser.SUPER, 0); } + public TerminalNode TRIGGER() { return getToken(MySqlParser.TRIGGER, 0); } + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public TerminalNode USAGE() { return getToken(MySqlParser.USAGE, 0); } + public TerminalNode APPLICATION_PASSWORD_ADMIN() { return getToken(MySqlParser.APPLICATION_PASSWORD_ADMIN, 0); } + public TerminalNode AUDIT_ABORT_EXEMPT() { return getToken(MySqlParser.AUDIT_ABORT_EXEMPT, 0); } + public TerminalNode AUDIT_ADMIN() { return getToken(MySqlParser.AUDIT_ADMIN, 0); } + public TerminalNode AUTHENTICATION_POLICY_ADMIN() { return getToken(MySqlParser.AUTHENTICATION_POLICY_ADMIN, 0); } + public TerminalNode BACKUP_ADMIN() { return getToken(MySqlParser.BACKUP_ADMIN, 0); } + public TerminalNode BINLOG_ADMIN() { return getToken(MySqlParser.BINLOG_ADMIN, 0); } + public TerminalNode BINLOG_ENCRYPTION_ADMIN() { return getToken(MySqlParser.BINLOG_ENCRYPTION_ADMIN, 0); } + public TerminalNode CLONE_ADMIN() { return getToken(MySqlParser.CLONE_ADMIN, 0); } + public TerminalNode CONNECTION_ADMIN() { return getToken(MySqlParser.CONNECTION_ADMIN, 0); } + public TerminalNode ENCRYPTION_KEY_ADMIN() { return getToken(MySqlParser.ENCRYPTION_KEY_ADMIN, 0); } + public TerminalNode FIREWALL_ADMIN() { return getToken(MySqlParser.FIREWALL_ADMIN, 0); } + public TerminalNode FIREWALL_EXEMPT() { return getToken(MySqlParser.FIREWALL_EXEMPT, 0); } + public TerminalNode FIREWALL_USER() { return getToken(MySqlParser.FIREWALL_USER, 0); } + public TerminalNode FLUSH_OPTIMIZER_COSTS() { return getToken(MySqlParser.FLUSH_OPTIMIZER_COSTS, 0); } + public TerminalNode FLUSH_STATUS() { return getToken(MySqlParser.FLUSH_STATUS, 0); } + public TerminalNode FLUSH_TABLES() { return getToken(MySqlParser.FLUSH_TABLES, 0); } + public TerminalNode FLUSH_USER_RESOURCES() { return getToken(MySqlParser.FLUSH_USER_RESOURCES, 0); } + public TerminalNode GROUP_REPLICATION_ADMIN() { return getToken(MySqlParser.GROUP_REPLICATION_ADMIN, 0); } + public TerminalNode INNODB_REDO_LOG_ARCHIVE() { return getToken(MySqlParser.INNODB_REDO_LOG_ARCHIVE, 0); } + public TerminalNode INNODB_REDO_LOG_ENABLE() { return getToken(MySqlParser.INNODB_REDO_LOG_ENABLE, 0); } + public TerminalNode NDB_STORED_USER() { return getToken(MySqlParser.NDB_STORED_USER, 0); } + public TerminalNode PASSWORDLESS_USER_ADMIN() { return getToken(MySqlParser.PASSWORDLESS_USER_ADMIN, 0); } + public TerminalNode PERSIST_RO_VARIABLES_ADMIN() { return getToken(MySqlParser.PERSIST_RO_VARIABLES_ADMIN, 0); } + public TerminalNode REPLICATION_APPLIER() { return getToken(MySqlParser.REPLICATION_APPLIER, 0); } + public TerminalNode REPLICATION_SLAVE_ADMIN() { return getToken(MySqlParser.REPLICATION_SLAVE_ADMIN, 0); } + public TerminalNode RESOURCE_GROUP_ADMIN() { return getToken(MySqlParser.RESOURCE_GROUP_ADMIN, 0); } + public TerminalNode RESOURCE_GROUP_USER() { return getToken(MySqlParser.RESOURCE_GROUP_USER, 0); } + public TerminalNode ROLE_ADMIN() { return getToken(MySqlParser.ROLE_ADMIN, 0); } + public TerminalNode SERVICE_CONNECTION_ADMIN() { return getToken(MySqlParser.SERVICE_CONNECTION_ADMIN, 0); } + public TerminalNode SESSION_VARIABLES_ADMIN() { return getToken(MySqlParser.SESSION_VARIABLES_ADMIN, 0); } + public TerminalNode SET_USER_ID() { return getToken(MySqlParser.SET_USER_ID, 0); } + public TerminalNode SKIP_QUERY_REWRITE() { return getToken(MySqlParser.SKIP_QUERY_REWRITE, 0); } + public TerminalNode SHOW_ROUTINE() { return getToken(MySqlParser.SHOW_ROUTINE, 0); } + public TerminalNode SYSTEM_USER() { return getToken(MySqlParser.SYSTEM_USER, 0); } + public TerminalNode SYSTEM_VARIABLES_ADMIN() { return getToken(MySqlParser.SYSTEM_VARIABLES_ADMIN, 0); } + public TerminalNode TABLE_ENCRYPTION_ADMIN() { return getToken(MySqlParser.TABLE_ENCRYPTION_ADMIN, 0); } + public TerminalNode TP_CONNECTION_ADMIN() { return getToken(MySqlParser.TP_CONNECTION_ADMIN, 0); } + public TerminalNode VERSION_TOKEN_ADMIN() { return getToken(MySqlParser.VERSION_TOKEN_ADMIN, 0); } + public TerminalNode XA_RECOVER_ADMIN() { return getToken(MySqlParser.XA_RECOVER_ADMIN, 0); } + public TerminalNode LOAD() { return getToken(MySqlParser.LOAD, 0); } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TerminalNode S3() { return getToken(MySqlParser.S3, 0); } + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public TerminalNode INVOKE() { return getToken(MySqlParser.INVOKE, 0); } + public TerminalNode LAMBDA() { return getToken(MySqlParser.LAMBDA, 0); } + public PrivilegeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_privilege; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPrivilege(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPrivilege(this); + } + } + + public final PrivilegeContext privilege() throws RecognitionException { + PrivilegeContext _localctx = new PrivilegeContext(_ctx, getState()); + enterRule(_localctx, 464, RULE_privilege); + int _la; + try { + setState(5570); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,810,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5477); + match(ALL); + setState(5479); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PRIVILEGES) { + { + setState(5478); + match(PRIVILEGES); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5481); + match(ALTER); + setState(5483); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ROUTINE) { + { + setState(5482); + match(ROUTINE); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5485); + match(CREATE); + setState(5493); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TEMPORARY: + { + setState(5486); + match(TEMPORARY); + setState(5487); + match(TABLES); + } + break; + case ROUTINE: + { + setState(5488); + match(ROUTINE); + } + break; + case VIEW: + { + setState(5489); + match(VIEW); + } + break; + case USER: + { + setState(5490); + match(USER); + } + break; + case TABLESPACE: + { + setState(5491); + match(TABLESPACE); + } + break; + case ROLE: + { + setState(5492); + match(ROLE); + } + break; + case ON: + case LR_BRACKET: + case COMMA: + break; + default: + break; + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5495); + match(DELETE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(5496); + match(DROP); + setState(5498); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ROLE) { + { + setState(5497); + match(ROLE); + } + } + + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(5500); + match(EVENT); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(5501); + match(EXECUTE); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(5502); + match(FILE); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(5503); + match(GRANT); + setState(5504); + match(OPTION); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(5505); + match(INDEX); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(5506); + match(INSERT); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(5507); + match(LOCK); + setState(5508); + match(TABLES); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(5509); + match(PROCESS); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(5510); + match(PROXY); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(5511); + match(REFERENCES); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(5512); + match(RELOAD); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(5513); + match(REPLICATION); + setState(5514); + _la = _input.LA(1); + if ( !(_la==CLIENT || _la==SLAVE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(5515); + match(SELECT); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(5516); + match(SHOW); + setState(5517); + _la = _input.LA(1); + if ( !(_la==DATABASES || _la==VIEW) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(5518); + match(SHUTDOWN); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(5519); + match(SUPER); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(5520); + match(TRIGGER); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(5521); + match(UPDATE); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(5522); + match(USAGE); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(5523); + match(APPLICATION_PASSWORD_ADMIN); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(5524); + match(AUDIT_ABORT_EXEMPT); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(5525); + match(AUDIT_ADMIN); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(5526); + match(AUTHENTICATION_POLICY_ADMIN); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(5527); + match(BACKUP_ADMIN); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(5528); + match(BINLOG_ADMIN); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(5529); + match(BINLOG_ENCRYPTION_ADMIN); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(5530); + match(CLONE_ADMIN); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(5531); + match(CONNECTION_ADMIN); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(5532); + match(ENCRYPTION_KEY_ADMIN); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(5533); + match(FIREWALL_ADMIN); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(5534); + match(FIREWALL_EXEMPT); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(5535); + match(FIREWALL_USER); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(5536); + match(FLUSH_OPTIMIZER_COSTS); + } + break; + case 39: + enterOuterAlt(_localctx, 39); + { + setState(5537); + match(FLUSH_STATUS); + } + break; + case 40: + enterOuterAlt(_localctx, 40); + { + setState(5538); + match(FLUSH_TABLES); + } + break; + case 41: + enterOuterAlt(_localctx, 41); + { + setState(5539); + match(FLUSH_USER_RESOURCES); + } + break; + case 42: + enterOuterAlt(_localctx, 42); + { + setState(5540); + match(GROUP_REPLICATION_ADMIN); + } + break; + case 43: + enterOuterAlt(_localctx, 43); + { + setState(5541); + match(INNODB_REDO_LOG_ARCHIVE); + } + break; + case 44: + enterOuterAlt(_localctx, 44); + { + setState(5542); + match(INNODB_REDO_LOG_ENABLE); + } + break; + case 45: + enterOuterAlt(_localctx, 45); + { + setState(5543); + match(NDB_STORED_USER); + } + break; + case 46: + enterOuterAlt(_localctx, 46); + { + setState(5544); + match(PASSWORDLESS_USER_ADMIN); + } + break; + case 47: + enterOuterAlt(_localctx, 47); + { + setState(5545); + match(PERSIST_RO_VARIABLES_ADMIN); + } + break; + case 48: + enterOuterAlt(_localctx, 48); + { + setState(5546); + match(REPLICATION_APPLIER); + } + break; + case 49: + enterOuterAlt(_localctx, 49); + { + setState(5547); + match(REPLICATION_SLAVE_ADMIN); + } + break; + case 50: + enterOuterAlt(_localctx, 50); + { + setState(5548); + match(RESOURCE_GROUP_ADMIN); + } + break; + case 51: + enterOuterAlt(_localctx, 51); + { + setState(5549); + match(RESOURCE_GROUP_USER); + } + break; + case 52: + enterOuterAlt(_localctx, 52); + { + setState(5550); + match(ROLE_ADMIN); + } + break; + case 53: + enterOuterAlt(_localctx, 53); + { + setState(5551); + match(SERVICE_CONNECTION_ADMIN); + } + break; + case 54: + enterOuterAlt(_localctx, 54); + { + setState(5552); + match(SESSION_VARIABLES_ADMIN); + } + break; + case 55: + enterOuterAlt(_localctx, 55); + { + setState(5553); + match(SET_USER_ID); + } + break; + case 56: + enterOuterAlt(_localctx, 56); + { + setState(5554); + match(SKIP_QUERY_REWRITE); + } + break; + case 57: + enterOuterAlt(_localctx, 57); + { + setState(5555); + match(SHOW_ROUTINE); + } + break; + case 58: + enterOuterAlt(_localctx, 58); + { + setState(5556); + match(SYSTEM_USER); + } + break; + case 59: + enterOuterAlt(_localctx, 59); + { + setState(5557); + match(SYSTEM_VARIABLES_ADMIN); + } + break; + case 60: + enterOuterAlt(_localctx, 60); + { + setState(5558); + match(TABLE_ENCRYPTION_ADMIN); + } + break; + case 61: + enterOuterAlt(_localctx, 61); + { + setState(5559); + match(TP_CONNECTION_ADMIN); + } + break; + case 62: + enterOuterAlt(_localctx, 62); + { + setState(5560); + match(VERSION_TOKEN_ADMIN); + } + break; + case 63: + enterOuterAlt(_localctx, 63); + { + setState(5561); + match(XA_RECOVER_ADMIN); + } + break; + case 64: + enterOuterAlt(_localctx, 64); + { + setState(5562); + match(LOAD); + setState(5563); + match(FROM); + setState(5564); + match(S3); + } + break; + case 65: + enterOuterAlt(_localctx, 65); + { + setState(5565); + match(SELECT); + setState(5566); + match(INTO); + setState(5567); + match(S3); + } + break; + case 66: + enterOuterAlt(_localctx, 66); + { + setState(5568); + match(INVOKE); + setState(5569); + match(LAMBDA); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrivilegeLevelContext extends ParserRuleContext { + public PrivilegeLevelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_privilegeLevel; } + + public PrivilegeLevelContext() { } + public void copyFrom(PrivilegeLevelContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DefiniteSchemaPrivLevelContext extends PrivilegeLevelContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode DOT() { return getToken(MySqlParser.DOT, 0); } + public TerminalNode STAR() { return getToken(MySqlParser.STAR, 0); } + public DefiniteSchemaPrivLevelContext(PrivilegeLevelContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDefiniteSchemaPrivLevel(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDefiniteSchemaPrivLevel(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DefiniteFullTablePrivLevel2Context extends PrivilegeLevelContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public DottedIdContext dottedId() { + return getRuleContext(DottedIdContext.class,0); + } + public DefiniteFullTablePrivLevel2Context(PrivilegeLevelContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDefiniteFullTablePrivLevel2(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDefiniteFullTablePrivLevel2(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DefiniteFullTablePrivLevelContext extends PrivilegeLevelContext { + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode DOT() { return getToken(MySqlParser.DOT, 0); } + public DefiniteFullTablePrivLevelContext(PrivilegeLevelContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDefiniteFullTablePrivLevel(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDefiniteFullTablePrivLevel(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class GlobalPrivLevelContext extends PrivilegeLevelContext { + public List STAR() { return getTokens(MySqlParser.STAR); } + public TerminalNode STAR(int i) { + return getToken(MySqlParser.STAR, i); + } + public TerminalNode DOT() { return getToken(MySqlParser.DOT, 0); } + public GlobalPrivLevelContext(PrivilegeLevelContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGlobalPrivLevel(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGlobalPrivLevel(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DefiniteTablePrivLevelContext extends PrivilegeLevelContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public DefiniteTablePrivLevelContext(PrivilegeLevelContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDefiniteTablePrivLevel(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDefiniteTablePrivLevel(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CurrentSchemaPriviLevelContext extends PrivilegeLevelContext { + public TerminalNode STAR() { return getToken(MySqlParser.STAR, 0); } + public CurrentSchemaPriviLevelContext(PrivilegeLevelContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCurrentSchemaPriviLevel(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCurrentSchemaPriviLevel(this); + } + } + + public final PrivilegeLevelContext privilegeLevel() throws RecognitionException { + PrivilegeLevelContext _localctx = new PrivilegeLevelContext(_ctx, getState()); + enterRule(_localctx, 466, RULE_privilegeLevel); + try { + setState(5588); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,811,_ctx) ) { + case 1: + _localctx = new CurrentSchemaPriviLevelContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(5572); + match(STAR); + } + break; + case 2: + _localctx = new GlobalPrivLevelContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(5573); + match(STAR); + setState(5574); + match(DOT); + setState(5575); + match(STAR); + } + break; + case 3: + _localctx = new DefiniteSchemaPrivLevelContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(5576); + uid(); + setState(5577); + match(DOT); + setState(5578); + match(STAR); + } + break; + case 4: + _localctx = new DefiniteFullTablePrivLevelContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(5580); + uid(); + setState(5581); + match(DOT); + setState(5582); + uid(); + } + break; + case 5: + _localctx = new DefiniteFullTablePrivLevel2Context(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(5584); + uid(); + setState(5585); + dottedId(); + } + break; + case 6: + _localctx = new DefiniteTablePrivLevelContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(5587); + uid(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RenameUserClauseContext extends ParserRuleContext { + public UserNameContext fromFirst; + public UserNameContext toFirst; + public TerminalNode TO() { return getToken(MySqlParser.TO, 0); } + public List userName() { + return getRuleContexts(UserNameContext.class); + } + public UserNameContext userName(int i) { + return getRuleContext(UserNameContext.class,i); + } + public RenameUserClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_renameUserClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRenameUserClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRenameUserClause(this); + } + } + + public final RenameUserClauseContext renameUserClause() throws RecognitionException { + RenameUserClauseContext _localctx = new RenameUserClauseContext(_ctx, getState()); + enterRule(_localctx, 468, RULE_renameUserClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(5590); + ((RenameUserClauseContext)_localctx).fromFirst = userName(); + setState(5591); + match(TO); + setState(5592); + ((RenameUserClauseContext)_localctx).toFirst = userName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnalyzeTableContext extends ParserRuleContext { + public Token actionOption; + public TerminalNode ANALYZE() { return getToken(MySqlParser.ANALYZE, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public List HISTOGRAM() { return getTokens(MySqlParser.HISTOGRAM); } + public TerminalNode HISTOGRAM(int i) { + return getToken(MySqlParser.HISTOGRAM, i); + } + public List ON() { return getTokens(MySqlParser.ON); } + public TerminalNode ON(int i) { + return getToken(MySqlParser.ON, i); + } + public List fullColumnName() { + return getRuleContexts(FullColumnNameContext.class); + } + public FullColumnNameContext fullColumnName(int i) { + return getRuleContext(FullColumnNameContext.class,i); + } + public TerminalNode DROP() { return getToken(MySqlParser.DROP, 0); } + public TerminalNode NO_WRITE_TO_BINLOG() { return getToken(MySqlParser.NO_WRITE_TO_BINLOG, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode BUCKETS() { return getToken(MySqlParser.BUCKETS, 0); } + public AnalyzeTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_analyzeTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAnalyzeTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAnalyzeTable(this); + } + } + + public final AnalyzeTableContext analyzeTable() throws RecognitionException { + AnalyzeTableContext _localctx = new AnalyzeTableContext(_ctx, getState()); + enterRule(_localctx, 470, RULE_analyzeTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5594); + match(ANALYZE); + setState(5596); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO_WRITE_TO_BINLOG || _la==LOCAL) { + { + setState(5595); + ((AnalyzeTableContext)_localctx).actionOption = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==NO_WRITE_TO_BINLOG || _la==LOCAL) ) { + ((AnalyzeTableContext)_localctx).actionOption = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(5598); + _la = _input.LA(1); + if ( !(_la==TABLE || _la==TABLES) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5599); + tables(); + setState(5617); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,815,_ctx) ) { + case 1: + { + setState(5600); + match(UPDATE); + setState(5601); + match(HISTOGRAM); + setState(5602); + match(ON); + setState(5603); + fullColumnName(); + setState(5608); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5604); + match(COMMA); + setState(5605); + fullColumnName(); + } + } + setState(5610); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5615); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,814,_ctx) ) { + case 1: + { + setState(5611); + match(WITH); + setState(5612); + decimalLiteral(); + setState(5613); + match(BUCKETS); + } + break; + } + } + break; + } + setState(5630); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,817,_ctx) ) { + case 1: + { + setState(5619); + match(DROP); + setState(5620); + match(HISTOGRAM); + setState(5621); + match(ON); + setState(5622); + fullColumnName(); + setState(5627); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5623); + match(COMMA); + setState(5624); + fullColumnName(); + } + } + setState(5629); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CheckTableContext extends ParserRuleContext { + public TerminalNode CHECK() { return getToken(MySqlParser.CHECK, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public List checkTableOption() { + return getRuleContexts(CheckTableOptionContext.class); + } + public CheckTableOptionContext checkTableOption(int i) { + return getRuleContext(CheckTableOptionContext.class,i); + } + public CheckTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_checkTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCheckTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCheckTable(this); + } + } + + public final CheckTableContext checkTable() throws RecognitionException { + CheckTableContext _localctx = new CheckTableContext(_ctx, getState()); + enterRule(_localctx, 472, RULE_checkTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5632); + match(CHECK); + setState(5633); + match(TABLE); + setState(5634); + tables(); + setState(5638); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FOR || _la==CHANGED || _la==EXTENDED || _la==FAST || _la==MEDIUM || _la==QUICK) { + { + { + setState(5635); + checkTableOption(); + } + } + setState(5640); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ChecksumTableContext extends ParserRuleContext { + public Token actionOption; + public TerminalNode CHECKSUM() { return getToken(MySqlParser.CHECKSUM, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public TerminalNode QUICK() { return getToken(MySqlParser.QUICK, 0); } + public TerminalNode EXTENDED() { return getToken(MySqlParser.EXTENDED, 0); } + public ChecksumTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_checksumTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterChecksumTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitChecksumTable(this); + } + } + + public final ChecksumTableContext checksumTable() throws RecognitionException { + ChecksumTableContext _localctx = new ChecksumTableContext(_ctx, getState()); + enterRule(_localctx, 474, RULE_checksumTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5641); + match(CHECKSUM); + setState(5642); + match(TABLE); + setState(5643); + tables(); + setState(5645); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXTENDED || _la==QUICK) { + { + setState(5644); + ((ChecksumTableContext)_localctx).actionOption = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==EXTENDED || _la==QUICK) ) { + ((ChecksumTableContext)_localctx).actionOption = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptimizeTableContext extends ParserRuleContext { + public Token actionOption; + public TerminalNode OPTIMIZE() { return getToken(MySqlParser.OPTIMIZE, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public TerminalNode NO_WRITE_TO_BINLOG() { return getToken(MySqlParser.NO_WRITE_TO_BINLOG, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public OptimizeTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optimizeTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterOptimizeTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitOptimizeTable(this); + } + } + + public final OptimizeTableContext optimizeTable() throws RecognitionException { + OptimizeTableContext _localctx = new OptimizeTableContext(_ctx, getState()); + enterRule(_localctx, 476, RULE_optimizeTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5647); + match(OPTIMIZE); + setState(5649); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO_WRITE_TO_BINLOG || _la==LOCAL) { + { + setState(5648); + ((OptimizeTableContext)_localctx).actionOption = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==NO_WRITE_TO_BINLOG || _la==LOCAL) ) { + ((OptimizeTableContext)_localctx).actionOption = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(5651); + _la = _input.LA(1); + if ( !(_la==TABLE || _la==TABLES) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5652); + tables(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RepairTableContext extends ParserRuleContext { + public Token actionOption; + public TerminalNode REPAIR() { return getToken(MySqlParser.REPAIR, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public TerminalNode QUICK() { return getToken(MySqlParser.QUICK, 0); } + public TerminalNode EXTENDED() { return getToken(MySqlParser.EXTENDED, 0); } + public TerminalNode USE_FRM() { return getToken(MySqlParser.USE_FRM, 0); } + public TerminalNode NO_WRITE_TO_BINLOG() { return getToken(MySqlParser.NO_WRITE_TO_BINLOG, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public RepairTableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_repairTable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRepairTable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRepairTable(this); + } + } + + public final RepairTableContext repairTable() throws RecognitionException { + RepairTableContext _localctx = new RepairTableContext(_ctx, getState()); + enterRule(_localctx, 478, RULE_repairTable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5654); + match(REPAIR); + setState(5656); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO_WRITE_TO_BINLOG || _la==LOCAL) { + { + setState(5655); + ((RepairTableContext)_localctx).actionOption = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==NO_WRITE_TO_BINLOG || _la==LOCAL) ) { + ((RepairTableContext)_localctx).actionOption = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(5658); + match(TABLE); + setState(5659); + tables(); + setState(5661); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==QUICK) { + { + setState(5660); + match(QUICK); + } + } + + setState(5664); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXTENDED) { + { + setState(5663); + match(EXTENDED); + } + } + + setState(5667); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USE_FRM) { + { + setState(5666); + match(USE_FRM); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CheckTableOptionContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode UPGRADE() { return getToken(MySqlParser.UPGRADE, 0); } + public TerminalNode QUICK() { return getToken(MySqlParser.QUICK, 0); } + public TerminalNode FAST() { return getToken(MySqlParser.FAST, 0); } + public TerminalNode MEDIUM() { return getToken(MySqlParser.MEDIUM, 0); } + public TerminalNode EXTENDED() { return getToken(MySqlParser.EXTENDED, 0); } + public TerminalNode CHANGED() { return getToken(MySqlParser.CHANGED, 0); } + public CheckTableOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_checkTableOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCheckTableOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCheckTableOption(this); + } + } + + public final CheckTableOptionContext checkTableOption() throws RecognitionException { + CheckTableOptionContext _localctx = new CheckTableOptionContext(_ctx, getState()); + enterRule(_localctx, 480, RULE_checkTableOption); + try { + setState(5676); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + setState(5669); + match(FOR); + setState(5670); + match(UPGRADE); + } + break; + case QUICK: + enterOuterAlt(_localctx, 2); + { + setState(5671); + match(QUICK); + } + break; + case FAST: + enterOuterAlt(_localctx, 3); + { + setState(5672); + match(FAST); + } + break; + case MEDIUM: + enterOuterAlt(_localctx, 4); + { + setState(5673); + match(MEDIUM); + } + break; + case EXTENDED: + enterOuterAlt(_localctx, 5); + { + setState(5674); + match(EXTENDED); + } + break; + case CHANGED: + enterOuterAlt(_localctx, 6); + { + setState(5675); + match(CHANGED); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateUdfunctionContext extends ParserRuleContext { + public Token returnType; + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode RETURNS() { return getToken(MySqlParser.RETURNS, 0); } + public TerminalNode SONAME() { return getToken(MySqlParser.SONAME, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode STRING() { return getToken(MySqlParser.STRING, 0); } + public TerminalNode INTEGER() { return getToken(MySqlParser.INTEGER, 0); } + public TerminalNode REAL() { return getToken(MySqlParser.REAL, 0); } + public TerminalNode DECIMAL() { return getToken(MySqlParser.DECIMAL, 0); } + public TerminalNode AGGREGATE() { return getToken(MySqlParser.AGGREGATE, 0); } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public CreateUdfunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createUdfunction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCreateUdfunction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCreateUdfunction(this); + } + } + + public final CreateUdfunctionContext createUdfunction() throws RecognitionException { + CreateUdfunctionContext _localctx = new CreateUdfunctionContext(_ctx, getState()); + enterRule(_localctx, 482, RULE_createUdfunction); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5678); + match(CREATE); + setState(5680); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AGGREGATE) { + { + setState(5679); + match(AGGREGATE); + } + } + + setState(5682); + match(FUNCTION); + setState(5684); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,827,_ctx) ) { + case 1: + { + setState(5683); + ifNotExists(); + } + break; + } + setState(5686); + uid(); + setState(5687); + match(RETURNS); + setState(5688); + ((CreateUdfunctionContext)_localctx).returnType = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 207)) & ~0x3f) == 0 && ((1L << (_la - 207)) & 261L) != 0) || _la==STRING) ) { + ((CreateUdfunctionContext)_localctx).returnType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5689); + match(SONAME); + setState(5690); + match(STRING_LITERAL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InstallPluginContext extends ParserRuleContext { + public TerminalNode INSTALL() { return getToken(MySqlParser.INSTALL, 0); } + public TerminalNode PLUGIN() { return getToken(MySqlParser.PLUGIN, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode SONAME() { return getToken(MySqlParser.SONAME, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public InstallPluginContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_installPlugin; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterInstallPlugin(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitInstallPlugin(this); + } + } + + public final InstallPluginContext installPlugin() throws RecognitionException { + InstallPluginContext _localctx = new InstallPluginContext(_ctx, getState()); + enterRule(_localctx, 484, RULE_installPlugin); + try { + enterOuterAlt(_localctx, 1); + { + setState(5692); + match(INSTALL); + setState(5693); + match(PLUGIN); + setState(5694); + uid(); + setState(5695); + match(SONAME); + setState(5696); + match(STRING_LITERAL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UninstallPluginContext extends ParserRuleContext { + public TerminalNode UNINSTALL() { return getToken(MySqlParser.UNINSTALL, 0); } + public TerminalNode PLUGIN() { return getToken(MySqlParser.PLUGIN, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public UninstallPluginContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_uninstallPlugin; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUninstallPlugin(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUninstallPlugin(this); + } + } + + public final UninstallPluginContext uninstallPlugin() throws RecognitionException { + UninstallPluginContext _localctx = new UninstallPluginContext(_ctx, getState()); + enterRule(_localctx, 486, RULE_uninstallPlugin); + try { + enterOuterAlt(_localctx, 1); + { + setState(5698); + match(UNINSTALL); + setState(5699); + match(PLUGIN); + setState(5700); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetStatementContext extends ParserRuleContext { + public SetStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_setStatement; } + + public SetStatementContext() { } + public void copyFrom(SetStatementContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SetTransactionContext extends SetStatementContext { + public SetTransactionStatementContext setTransactionStatement() { + return getRuleContext(SetTransactionStatementContext.class,0); + } + public SetTransactionContext(SetStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetTransaction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetTransaction(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SetCharsetContext extends SetStatementContext { + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public CharSetContext charSet() { + return getRuleContext(CharSetContext.class,0); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public SetCharsetContext(SetStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetCharset(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetCharset(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SetNamesContext extends SetStatementContext { + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode NAMES() { return getToken(MySqlParser.NAMES, 0); } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public SetNamesContext(SetStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetNames(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetNames(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SetPasswordContext extends SetStatementContext { + public SetPasswordStatementContext setPasswordStatement() { + return getRuleContext(SetPasswordStatementContext.class,0); + } + public SetPasswordContext(SetStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetPassword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetPassword(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SetAutocommitContext extends SetStatementContext { + public SetAutocommitStatementContext setAutocommitStatement() { + return getRuleContext(SetAutocommitStatementContext.class,0); + } + public SetAutocommitContext(SetStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetAutocommit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetAutocommit(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SetNewValueInsideTriggerContext extends SetStatementContext { + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public List fullId() { + return getRuleContexts(FullIdContext.class); + } + public FullIdContext fullId(int i) { + return getRuleContext(FullIdContext.class,i); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public List VAR_ASSIGN() { return getTokens(MySqlParser.VAR_ASSIGN); } + public TerminalNode VAR_ASSIGN(int i) { + return getToken(MySqlParser.VAR_ASSIGN, i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public SetNewValueInsideTriggerContext(SetStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetNewValueInsideTrigger(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetNewValueInsideTrigger(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SetVariableContext extends SetStatementContext { + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public List variableClause() { + return getRuleContexts(VariableClauseContext.class); + } + public VariableClauseContext variableClause(int i) { + return getRuleContext(VariableClauseContext.class,i); + } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public List VAR_ASSIGN() { return getTokens(MySqlParser.VAR_ASSIGN); } + public TerminalNode VAR_ASSIGN(int i) { + return getToken(MySqlParser.VAR_ASSIGN, i); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List ON() { return getTokens(MySqlParser.ON); } + public TerminalNode ON(int i) { + return getToken(MySqlParser.ON, i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public SetVariableContext(SetStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSetVariable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSetVariable(this); + } + } + + public final SetStatementContext setStatement() throws RecognitionException { + SetStatementContext _localctx = new SetStatementContext(_ctx, getState()); + enterRule(_localctx, 488, RULE_setStatement); + int _la; + try { + setState(5754); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,835,_ctx) ) { + case 1: + _localctx = new SetVariableContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(5702); + match(SET); + setState(5703); + variableClause(); + setState(5704); + _la = _input.LA(1); + if ( !(_la==VAR_ASSIGN || _la==EQUAL_SYMBOL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5707); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,828,_ctx) ) { + case 1: + { + setState(5705); + expression(0); + } + break; + case 2: + { + setState(5706); + match(ON); + } + break; + } + setState(5718); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5709); + match(COMMA); + setState(5710); + variableClause(); + setState(5711); + _la = _input.LA(1); + if ( !(_la==VAR_ASSIGN || _la==EQUAL_SYMBOL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5714); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,829,_ctx) ) { + case 1: + { + setState(5712); + expression(0); + } + break; + case 2: + { + setState(5713); + match(ON); + } + break; + } + } + } + setState(5720); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + _localctx = new SetCharsetContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(5721); + match(SET); + setState(5722); + charSet(); + setState(5725); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BINARY: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + { + setState(5723); + charsetName(); + } + break; + case DEFAULT: + { + setState(5724); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + _localctx = new SetNamesContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(5727); + match(SET); + setState(5728); + match(NAMES); + setState(5735); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BINARY: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + { + setState(5729); + charsetName(); + setState(5732); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLLATE) { + { + setState(5730); + match(COLLATE); + setState(5731); + collationName(); + } + } + + } + break; + case DEFAULT: + { + setState(5734); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 4: + _localctx = new SetPasswordContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(5737); + setPasswordStatement(); + } + break; + case 5: + _localctx = new SetTransactionContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(5738); + setTransactionStatement(); + } + break; + case 6: + _localctx = new SetAutocommitContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(5739); + setAutocommitStatement(); + } + break; + case 7: + _localctx = new SetNewValueInsideTriggerContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(5740); + match(SET); + setState(5741); + fullId(); + setState(5742); + _la = _input.LA(1); + if ( !(_la==VAR_ASSIGN || _la==EQUAL_SYMBOL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5743); + expression(0); + setState(5751); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5744); + match(COMMA); + setState(5745); + fullId(); + setState(5746); + _la = _input.LA(1); + if ( !(_la==VAR_ASSIGN || _la==EQUAL_SYMBOL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5747); + expression(0); + } + } + setState(5753); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ShowStatementContext extends ParserRuleContext { + public ShowStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_showStatement; } + + public ShowStatementContext() { } + public void copyFrom(ShowStatementContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowOpenTablesContext extends ShowStatementContext { + public Token schemaFormat; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode OPEN() { return getToken(MySqlParser.OPEN, 0); } + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public ShowFilterContext showFilter() { + return getRuleContext(ShowFilterContext.class,0); + } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public ShowOpenTablesContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowOpenTables(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowOpenTables(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowGlobalInfoContext extends ShowStatementContext { + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public ShowGlobalInfoClauseContext showGlobalInfoClause() { + return getRuleContext(ShowGlobalInfoClauseContext.class,0); + } + public ShowGlobalInfoContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowGlobalInfo(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowGlobalInfo(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowCreateFullIdObjectContext extends ShowStatementContext { + public Token namedEntity; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode EVENT() { return getToken(MySqlParser.EVENT, 0); } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TerminalNode TRIGGER() { return getToken(MySqlParser.TRIGGER, 0); } + public TerminalNode VIEW() { return getToken(MySqlParser.VIEW, 0); } + public ShowCreateFullIdObjectContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowCreateFullIdObject(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowCreateFullIdObject(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowCreateUserContext extends ShowStatementContext { + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public ShowCreateUserContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowCreateUser(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowCreateUser(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowErrorsContext extends ShowStatementContext { + public Token errorFormat; + public DecimalLiteralContext offset; + public DecimalLiteralContext rowCount; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode ERRORS() { return getToken(MySqlParser.ERRORS, 0); } + public TerminalNode WARNINGS() { return getToken(MySqlParser.WARNINGS, 0); } + public TerminalNode LIMIT() { return getToken(MySqlParser.LIMIT, 0); } + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public ShowErrorsContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowErrors(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowErrors(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowCountErrorsContext extends ShowStatementContext { + public Token errorFormat; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode COUNT() { return getToken(MySqlParser.COUNT, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode STAR() { return getToken(MySqlParser.STAR, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode ERRORS() { return getToken(MySqlParser.ERRORS, 0); } + public TerminalNode WARNINGS() { return getToken(MySqlParser.WARNINGS, 0); } + public ShowCountErrorsContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowCountErrors(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowCountErrors(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowObjectFilterContext extends ShowStatementContext { + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public ShowCommonEntityContext showCommonEntity() { + return getRuleContext(ShowCommonEntityContext.class,0); + } + public ShowFilterContext showFilter() { + return getRuleContext(ShowFilterContext.class,0); + } + public ShowObjectFilterContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowObjectFilter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowObjectFilter(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowCreateDbContext extends ShowStatementContext { + public Token schemaFormat; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode CREATE() { return getToken(MySqlParser.CREATE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); } + public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); } + public IfNotExistsContext ifNotExists() { + return getRuleContext(IfNotExistsContext.class,0); + } + public ShowCreateDbContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowCreateDb(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowCreateDb(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowEngineContext extends ShowStatementContext { + public Token engineOption; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public EngineNameContext engineName() { + return getRuleContext(EngineNameContext.class,0); + } + public TerminalNode STATUS() { return getToken(MySqlParser.STATUS, 0); } + public TerminalNode MUTEX() { return getToken(MySqlParser.MUTEX, 0); } + public ShowEngineContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowEngine(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowEngine(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowSchemaFilterContext extends ShowStatementContext { + public Token schemaFormat; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public ShowSchemaEntityContext showSchemaEntity() { + return getRuleContext(ShowSchemaEntityContext.class,0); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public ShowFilterContext showFilter() { + return getRuleContext(ShowFilterContext.class,0); + } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public ShowSchemaFilterContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowSchemaFilter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowSchemaFilter(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowIndexesContext extends ShowStatementContext { + public Token indexFormat; + public Token tableFormat; + public Token schemaFormat; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode INDEXES() { return getToken(MySqlParser.INDEXES, 0); } + public TerminalNode KEYS() { return getToken(MySqlParser.KEYS, 0); } + public List FROM() { return getTokens(MySqlParser.FROM); } + public TerminalNode FROM(int i) { + return getToken(MySqlParser.FROM, i); + } + public List IN() { return getTokens(MySqlParser.IN); } + public TerminalNode IN(int i) { + return getToken(MySqlParser.IN, i); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode WHERE() { return getToken(MySqlParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ShowIndexesContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowIndexes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowIndexes(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowLogEventsContext extends ShowStatementContext { + public Token logFormat; + public Token filename; + public DecimalLiteralContext fromPosition; + public DecimalLiteralContext offset; + public DecimalLiteralContext rowCount; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode EVENTS() { return getToken(MySqlParser.EVENTS, 0); } + public TerminalNode BINLOG() { return getToken(MySqlParser.BINLOG, 0); } + public TerminalNode RELAYLOG() { return getToken(MySqlParser.RELAYLOG, 0); } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TerminalNode LIMIT() { return getToken(MySqlParser.LIMIT, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public ShowLogEventsContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowLogEvents(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowLogEvents(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowMasterLogsContext extends ShowStatementContext { + public Token logFormat; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode LOGS() { return getToken(MySqlParser.LOGS, 0); } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public TerminalNode MASTER() { return getToken(MySqlParser.MASTER, 0); } + public ShowMasterLogsContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowMasterLogs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowMasterLogs(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowGrantsContext extends ShowStatementContext { + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode GRANTS() { return getToken(MySqlParser.GRANTS, 0); } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public ShowGrantsContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowGrants(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowGrants(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowSlaveStatusContext extends ShowStatementContext { + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode SLAVE() { return getToken(MySqlParser.SLAVE, 0); } + public TerminalNode STATUS() { return getToken(MySqlParser.STATUS, 0); } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode CHANNEL() { return getToken(MySqlParser.CHANNEL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public ShowSlaveStatusContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowSlaveStatus(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowSlaveStatus(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowRoutineContext extends ShowStatementContext { + public Token routine; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode CODE() { return getToken(MySqlParser.CODE, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); } + public ShowRoutineContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowRoutine(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowRoutine(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowProfileContext extends ShowStatementContext { + public DecimalLiteralContext queryCount; + public DecimalLiteralContext offset; + public DecimalLiteralContext rowCount; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TerminalNode PROFILE() { return getToken(MySqlParser.PROFILE, 0); } + public List showProfileType() { + return getRuleContexts(ShowProfileTypeContext.class); + } + public ShowProfileTypeContext showProfileType(int i) { + return getRuleContext(ShowProfileTypeContext.class,i); + } + public TerminalNode LIMIT() { return getToken(MySqlParser.LIMIT, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode QUERY() { return getToken(MySqlParser.QUERY, 0); } + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public ShowProfileContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowProfile(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowProfile(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ShowColumnsContext extends ShowStatementContext { + public Token columnsFormat; + public Token tableFormat; + public Token schemaFormat; + public TerminalNode SHOW() { return getToken(MySqlParser.SHOW, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); } + public TerminalNode FIELDS() { return getToken(MySqlParser.FIELDS, 0); } + public List FROM() { return getTokens(MySqlParser.FROM); } + public TerminalNode FROM(int i) { + return getToken(MySqlParser.FROM, i); + } + public List IN() { return getTokens(MySqlParser.IN); } + public TerminalNode IN(int i) { + return getToken(MySqlParser.IN, i); + } + public TerminalNode FULL() { return getToken(MySqlParser.FULL, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public ShowFilterContext showFilter() { + return getRuleContext(ShowFilterContext.class,0); + } + public ShowColumnsContext(ShowStatementContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowColumns(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowColumns(this); + } + } + + public final ShowStatementContext showStatement() throws RecognitionException { + ShowStatementContext _localctx = new ShowStatementContext(_ctx, getState()); + enterRule(_localctx, 490, RULE_showStatement); + int _la; + try { + setState(5909); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,858,_ctx) ) { + case 1: + _localctx = new ShowMasterLogsContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(5756); + match(SHOW); + setState(5757); + ((ShowMasterLogsContext)_localctx).logFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==BINARY || _la==MASTER) ) { + ((ShowMasterLogsContext)_localctx).logFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5758); + match(LOGS); + } + break; + case 2: + _localctx = new ShowLogEventsContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(5759); + match(SHOW); + setState(5760); + ((ShowLogEventsContext)_localctx).logFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==BINLOG || _la==RELAYLOG) ) { + ((ShowLogEventsContext)_localctx).logFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5761); + match(EVENTS); + setState(5764); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN) { + { + setState(5762); + match(IN); + setState(5763); + ((ShowLogEventsContext)_localctx).filename = match(STRING_LITERAL); + } + } + + setState(5768); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM) { + { + setState(5766); + match(FROM); + setState(5767); + ((ShowLogEventsContext)_localctx).fromPosition = decimalLiteral(); + } + } + + setState(5777); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(5770); + match(LIMIT); + setState(5774); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,838,_ctx) ) { + case 1: + { + setState(5771); + ((ShowLogEventsContext)_localctx).offset = decimalLiteral(); + setState(5772); + match(COMMA); + } + break; + } + setState(5776); + ((ShowLogEventsContext)_localctx).rowCount = decimalLiteral(); + } + } + + } + break; + case 3: + _localctx = new ShowObjectFilterContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(5779); + match(SHOW); + setState(5780); + showCommonEntity(); + setState(5782); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIKE || _la==WHERE) { + { + setState(5781); + showFilter(); + } + } + + } + break; + case 4: + _localctx = new ShowColumnsContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(5784); + match(SHOW); + setState(5786); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FULL) { + { + setState(5785); + match(FULL); + } + } + + setState(5788); + ((ShowColumnsContext)_localctx).columnsFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==COLUMNS || _la==FIELDS) ) { + ((ShowColumnsContext)_localctx).columnsFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5789); + ((ShowColumnsContext)_localctx).tableFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FROM || _la==IN) ) { + ((ShowColumnsContext)_localctx).tableFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5790); + tableName(); + setState(5793); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM || _la==IN) { + { + setState(5791); + ((ShowColumnsContext)_localctx).schemaFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FROM || _la==IN) ) { + ((ShowColumnsContext)_localctx).schemaFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5792); + uid(); + } + } + + setState(5796); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIKE || _la==WHERE) { + { + setState(5795); + showFilter(); + } + } + + } + break; + case 5: + _localctx = new ShowCreateDbContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(5798); + match(SHOW); + setState(5799); + match(CREATE); + setState(5800); + ((ShowCreateDbContext)_localctx).schemaFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DATABASE || _la==SCHEMA) ) { + ((ShowCreateDbContext)_localctx).schemaFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5802); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,844,_ctx) ) { + case 1: + { + setState(5801); + ifNotExists(); + } + break; + } + setState(5804); + uid(); + } + break; + case 6: + _localctx = new ShowCreateFullIdObjectContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(5805); + match(SHOW); + setState(5806); + match(CREATE); + setState(5807); + ((ShowCreateFullIdObjectContext)_localctx).namedEntity = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & 72567767433217L) != 0) || _la==EVENT || _la==FUNCTION || _la==VIEW) ) { + ((ShowCreateFullIdObjectContext)_localctx).namedEntity = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5808); + fullId(); + } + break; + case 7: + _localctx = new ShowCreateUserContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(5809); + match(SHOW); + setState(5810); + match(CREATE); + setState(5811); + match(USER); + setState(5812); + userName(); + } + break; + case 8: + _localctx = new ShowEngineContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(5813); + match(SHOW); + setState(5814); + match(ENGINE); + setState(5815); + engineName(); + setState(5816); + ((ShowEngineContext)_localctx).engineOption = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==MUTEX || _la==STATUS) ) { + ((ShowEngineContext)_localctx).engineOption = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 9: + _localctx = new ShowGlobalInfoContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(5818); + match(SHOW); + setState(5819); + showGlobalInfoClause(); + } + break; + case 10: + _localctx = new ShowErrorsContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(5820); + match(SHOW); + setState(5821); + ((ShowErrorsContext)_localctx).errorFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ERRORS || _la==WARNINGS) ) { + ((ShowErrorsContext)_localctx).errorFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5829); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(5822); + match(LIMIT); + setState(5826); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,845,_ctx) ) { + case 1: + { + setState(5823); + ((ShowErrorsContext)_localctx).offset = decimalLiteral(); + setState(5824); + match(COMMA); + } + break; + } + setState(5828); + ((ShowErrorsContext)_localctx).rowCount = decimalLiteral(); + } + } + + } + break; + case 11: + _localctx = new ShowCountErrorsContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(5831); + match(SHOW); + setState(5832); + match(COUNT); + setState(5833); + match(LR_BRACKET); + setState(5834); + match(STAR); + setState(5835); + match(RR_BRACKET); + setState(5836); + ((ShowCountErrorsContext)_localctx).errorFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ERRORS || _la==WARNINGS) ) { + ((ShowCountErrorsContext)_localctx).errorFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 12: + _localctx = new ShowSchemaFilterContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(5837); + match(SHOW); + setState(5838); + showSchemaEntity(); + setState(5841); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM || _la==IN) { + { + setState(5839); + ((ShowSchemaFilterContext)_localctx).schemaFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FROM || _la==IN) ) { + ((ShowSchemaFilterContext)_localctx).schemaFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5840); + uid(); + } + } + + setState(5844); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIKE || _la==WHERE) { + { + setState(5843); + showFilter(); + } + } + + } + break; + case 13: + _localctx = new ShowRoutineContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(5846); + match(SHOW); + setState(5847); + ((ShowRoutineContext)_localctx).routine = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==PROCEDURE || _la==FUNCTION) ) { + ((ShowRoutineContext)_localctx).routine = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5848); + match(CODE); + setState(5849); + fullId(); + } + break; + case 14: + _localctx = new ShowGrantsContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(5850); + match(SHOW); + setState(5851); + match(GRANTS); + setState(5854); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(5852); + match(FOR); + setState(5853); + userName(); + } + } + + } + break; + case 15: + _localctx = new ShowIndexesContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(5856); + match(SHOW); + setState(5857); + ((ShowIndexesContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEYS || _la==INDEXES) ) { + ((ShowIndexesContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5858); + ((ShowIndexesContext)_localctx).tableFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FROM || _la==IN) ) { + ((ShowIndexesContext)_localctx).tableFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5859); + tableName(); + setState(5862); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM || _la==IN) { + { + setState(5860); + ((ShowIndexesContext)_localctx).schemaFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FROM || _la==IN) ) { + ((ShowIndexesContext)_localctx).schemaFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5861); + uid(); + } + } + + setState(5866); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(5864); + match(WHERE); + setState(5865); + expression(0); + } + } + + } + break; + case 16: + _localctx = new ShowOpenTablesContext(_localctx); + enterOuterAlt(_localctx, 16); + { + setState(5868); + match(SHOW); + setState(5869); + match(OPEN); + setState(5870); + match(TABLES); + setState(5873); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM || _la==IN) { + { + setState(5871); + ((ShowOpenTablesContext)_localctx).schemaFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FROM || _la==IN) ) { + ((ShowOpenTablesContext)_localctx).schemaFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5872); + uid(); + } + } + + setState(5876); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIKE || _la==WHERE) { + { + setState(5875); + showFilter(); + } + } + + } + break; + case 17: + _localctx = new ShowProfileContext(_localctx); + enterOuterAlt(_localctx, 17); + { + setState(5878); + match(SHOW); + setState(5879); + match(PROFILE); + setState(5880); + showProfileType(); + setState(5885); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5881); + match(COMMA); + setState(5882); + showProfileType(); + } + } + setState(5887); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5891); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(5888); + match(FOR); + setState(5889); + match(QUERY); + setState(5890); + ((ShowProfileContext)_localctx).queryCount = decimalLiteral(); + } + } + + { + setState(5893); + match(LIMIT); + setState(5897); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,856,_ctx) ) { + case 1: + { + setState(5894); + ((ShowProfileContext)_localctx).offset = decimalLiteral(); + setState(5895); + match(COMMA); + } + break; + } + setState(5899); + ((ShowProfileContext)_localctx).rowCount = decimalLiteral(); + } + } + break; + case 18: + _localctx = new ShowSlaveStatusContext(_localctx); + enterOuterAlt(_localctx, 18); + { + setState(5901); + match(SHOW); + setState(5902); + match(SLAVE); + setState(5903); + match(STATUS); + setState(5907); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(5904); + match(FOR); + setState(5905); + match(CHANNEL); + setState(5906); + match(STRING_LITERAL); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableClauseContext extends ParserRuleContext { + public TerminalNode LOCAL_ID() { return getToken(MySqlParser.LOCAL_ID, 0); } + public TerminalNode GLOBAL_ID() { return getToken(MySqlParser.GLOBAL_ID, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode GLOBAL() { return getToken(MySqlParser.GLOBAL, 0); } + public TerminalNode SESSION() { return getToken(MySqlParser.SESSION, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public List AT_SIGN() { return getTokens(MySqlParser.AT_SIGN); } + public TerminalNode AT_SIGN(int i) { + return getToken(MySqlParser.AT_SIGN, i); + } + public VariableClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterVariableClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitVariableClause(this); + } + } + + public final VariableClauseContext variableClause() throws RecognitionException { + VariableClauseContext _localctx = new VariableClauseContext(_ctx, getState()); + enterRule(_localctx, 492, RULE_variableClause); + int _la; + try { + setState(5921); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LOCAL_ID: + enterOuterAlt(_localctx, 1); + { + setState(5911); + match(LOCAL_ID); + } + break; + case GLOBAL_ID: + enterOuterAlt(_localctx, 2); + { + setState(5912); + match(GLOBAL_ID); + } + break; + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case AT_SIGN: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + enterOuterAlt(_localctx, 3); + { + setState(5918); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,860,_ctx) ) { + case 1: + { + setState(5915); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AT_SIGN) { + { + setState(5913); + match(AT_SIGN); + setState(5914); + match(AT_SIGN); + } + } + + setState(5917); + _la = _input.LA(1); + if ( !(_la==GLOBAL || _la==LOCAL || _la==SESSION) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(5920); + uid(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ShowCommonEntityContext extends ParserRuleContext { + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode COLLATION() { return getToken(MySqlParser.COLLATION, 0); } + public TerminalNode DATABASES() { return getToken(MySqlParser.DATABASES, 0); } + public TerminalNode SCHEMAS() { return getToken(MySqlParser.SCHEMAS, 0); } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public TerminalNode STATUS() { return getToken(MySqlParser.STATUS, 0); } + public TerminalNode PROCEDURE() { return getToken(MySqlParser.PROCEDURE, 0); } + public TerminalNode VARIABLES() { return getToken(MySqlParser.VARIABLES, 0); } + public TerminalNode GLOBAL() { return getToken(MySqlParser.GLOBAL, 0); } + public TerminalNode SESSION() { return getToken(MySqlParser.SESSION, 0); } + public ShowCommonEntityContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_showCommonEntity; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowCommonEntity(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowCommonEntity(this); + } + } + + public final ShowCommonEntityContext showCommonEntity() throws RecognitionException { + ShowCommonEntityContext _localctx = new ShowCommonEntityContext(_ctx, getState()); + enterRule(_localctx, 494, RULE_showCommonEntity); + int _la; + try { + setState(5936); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CHARACTER: + enterOuterAlt(_localctx, 1); + { + setState(5923); + match(CHARACTER); + setState(5924); + match(SET); + } + break; + case COLLATION: + enterOuterAlt(_localctx, 2); + { + setState(5925); + match(COLLATION); + } + break; + case DATABASES: + enterOuterAlt(_localctx, 3); + { + setState(5926); + match(DATABASES); + } + break; + case SCHEMAS: + enterOuterAlt(_localctx, 4); + { + setState(5927); + match(SCHEMAS); + } + break; + case FUNCTION: + enterOuterAlt(_localctx, 5); + { + setState(5928); + match(FUNCTION); + setState(5929); + match(STATUS); + } + break; + case PROCEDURE: + enterOuterAlt(_localctx, 6); + { + setState(5930); + match(PROCEDURE); + setState(5931); + match(STATUS); + } + break; + case GLOBAL: + case SESSION: + case STATUS: + case VARIABLES: + enterOuterAlt(_localctx, 7); + { + setState(5933); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==GLOBAL || _la==SESSION) { + { + setState(5932); + _la = _input.LA(1); + if ( !(_la==GLOBAL || _la==SESSION) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(5935); + _la = _input.LA(1); + if ( !(_la==STATUS || _la==VARIABLES) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ShowFilterContext extends ParserRuleContext { + public TerminalNode LIKE() { return getToken(MySqlParser.LIKE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode WHERE() { return getToken(MySqlParser.WHERE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ShowFilterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_showFilter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowFilter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowFilter(this); + } + } + + public final ShowFilterContext showFilter() throws RecognitionException { + ShowFilterContext _localctx = new ShowFilterContext(_ctx, getState()); + enterRule(_localctx, 496, RULE_showFilter); + try { + setState(5942); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LIKE: + enterOuterAlt(_localctx, 1); + { + setState(5938); + match(LIKE); + setState(5939); + match(STRING_LITERAL); + } + break; + case WHERE: + enterOuterAlt(_localctx, 2); + { + setState(5940); + match(WHERE); + setState(5941); + expression(0); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ShowGlobalInfoClauseContext extends ParserRuleContext { + public TerminalNode ENGINES() { return getToken(MySqlParser.ENGINES, 0); } + public TerminalNode STORAGE() { return getToken(MySqlParser.STORAGE, 0); } + public TerminalNode MASTER() { return getToken(MySqlParser.MASTER, 0); } + public TerminalNode STATUS() { return getToken(MySqlParser.STATUS, 0); } + public TerminalNode PLUGINS() { return getToken(MySqlParser.PLUGINS, 0); } + public TerminalNode PRIVILEGES() { return getToken(MySqlParser.PRIVILEGES, 0); } + public TerminalNode PROCESSLIST() { return getToken(MySqlParser.PROCESSLIST, 0); } + public TerminalNode FULL() { return getToken(MySqlParser.FULL, 0); } + public TerminalNode PROFILES() { return getToken(MySqlParser.PROFILES, 0); } + public TerminalNode SLAVE() { return getToken(MySqlParser.SLAVE, 0); } + public TerminalNode HOSTS() { return getToken(MySqlParser.HOSTS, 0); } + public TerminalNode AUTHORS() { return getToken(MySqlParser.AUTHORS, 0); } + public TerminalNode CONTRIBUTORS() { return getToken(MySqlParser.CONTRIBUTORS, 0); } + public ShowGlobalInfoClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_showGlobalInfoClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowGlobalInfoClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowGlobalInfoClause(this); + } + } + + public final ShowGlobalInfoClauseContext showGlobalInfoClause() throws RecognitionException { + ShowGlobalInfoClauseContext _localctx = new ShowGlobalInfoClauseContext(_ctx, getState()); + enterRule(_localctx, 498, RULE_showGlobalInfoClause); + int _la; + try { + setState(5961); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ENGINES: + case STORAGE: + enterOuterAlt(_localctx, 1); + { + setState(5945); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STORAGE) { + { + setState(5944); + match(STORAGE); + } + } + + setState(5947); + match(ENGINES); + } + break; + case MASTER: + enterOuterAlt(_localctx, 2); + { + setState(5948); + match(MASTER); + setState(5949); + match(STATUS); + } + break; + case PLUGINS: + enterOuterAlt(_localctx, 3); + { + setState(5950); + match(PLUGINS); + } + break; + case PRIVILEGES: + enterOuterAlt(_localctx, 4); + { + setState(5951); + match(PRIVILEGES); + } + break; + case FULL: + case PROCESSLIST: + enterOuterAlt(_localctx, 5); + { + setState(5953); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FULL) { + { + setState(5952); + match(FULL); + } + } + + setState(5955); + match(PROCESSLIST); + } + break; + case PROFILES: + enterOuterAlt(_localctx, 6); + { + setState(5956); + match(PROFILES); + } + break; + case SLAVE: + enterOuterAlt(_localctx, 7); + { + setState(5957); + match(SLAVE); + setState(5958); + match(HOSTS); + } + break; + case AUTHORS: + enterOuterAlt(_localctx, 8); + { + setState(5959); + match(AUTHORS); + } + break; + case CONTRIBUTORS: + enterOuterAlt(_localctx, 9); + { + setState(5960); + match(CONTRIBUTORS); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ShowSchemaEntityContext extends ParserRuleContext { + public TerminalNode EVENTS() { return getToken(MySqlParser.EVENTS, 0); } + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TerminalNode STATUS() { return getToken(MySqlParser.STATUS, 0); } + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public TerminalNode FULL() { return getToken(MySqlParser.FULL, 0); } + public TerminalNode TRIGGERS() { return getToken(MySqlParser.TRIGGERS, 0); } + public ShowSchemaEntityContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_showSchemaEntity; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowSchemaEntity(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowSchemaEntity(this); + } + } + + public final ShowSchemaEntityContext showSchemaEntity() throws RecognitionException { + ShowSchemaEntityContext _localctx = new ShowSchemaEntityContext(_ctx, getState()); + enterRule(_localctx, 500, RULE_showSchemaEntity); + int _la; + try { + setState(5971); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EVENTS: + enterOuterAlt(_localctx, 1); + { + setState(5963); + match(EVENTS); + } + break; + case TABLE: + enterOuterAlt(_localctx, 2); + { + setState(5964); + match(TABLE); + setState(5965); + match(STATUS); + } + break; + case FULL: + case TABLES: + enterOuterAlt(_localctx, 3); + { + setState(5967); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FULL) { + { + setState(5966); + match(FULL); + } + } + + setState(5969); + match(TABLES); + } + break; + case TRIGGERS: + enterOuterAlt(_localctx, 4); + { + setState(5970); + match(TRIGGERS); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ShowProfileTypeContext extends ParserRuleContext { + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode BLOCK() { return getToken(MySqlParser.BLOCK, 0); } + public TerminalNode IO() { return getToken(MySqlParser.IO, 0); } + public TerminalNode CONTEXT() { return getToken(MySqlParser.CONTEXT, 0); } + public TerminalNode SWITCHES() { return getToken(MySqlParser.SWITCHES, 0); } + public TerminalNode CPU() { return getToken(MySqlParser.CPU, 0); } + public TerminalNode IPC() { return getToken(MySqlParser.IPC, 0); } + public TerminalNode MEMORY() { return getToken(MySqlParser.MEMORY, 0); } + public TerminalNode PAGE() { return getToken(MySqlParser.PAGE, 0); } + public TerminalNode FAULTS() { return getToken(MySqlParser.FAULTS, 0); } + public TerminalNode SOURCE() { return getToken(MySqlParser.SOURCE, 0); } + public TerminalNode SWAPS() { return getToken(MySqlParser.SWAPS, 0); } + public ShowProfileTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_showProfileType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShowProfileType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShowProfileType(this); + } + } + + public final ShowProfileTypeContext showProfileType() throws RecognitionException { + ShowProfileTypeContext _localctx = new ShowProfileTypeContext(_ctx, getState()); + enterRule(_localctx, 502, RULE_showProfileType); + try { + setState(5985); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALL: + enterOuterAlt(_localctx, 1); + { + setState(5973); + match(ALL); + } + break; + case BLOCK: + enterOuterAlt(_localctx, 2); + { + setState(5974); + match(BLOCK); + setState(5975); + match(IO); + } + break; + case CONTEXT: + enterOuterAlt(_localctx, 3); + { + setState(5976); + match(CONTEXT); + setState(5977); + match(SWITCHES); + } + break; + case CPU: + enterOuterAlt(_localctx, 4); + { + setState(5978); + match(CPU); + } + break; + case IPC: + enterOuterAlt(_localctx, 5); + { + setState(5979); + match(IPC); + } + break; + case MEMORY: + enterOuterAlt(_localctx, 6); + { + setState(5980); + match(MEMORY); + } + break; + case PAGE: + enterOuterAlt(_localctx, 7); + { + setState(5981); + match(PAGE); + setState(5982); + match(FAULTS); + } + break; + case SOURCE: + enterOuterAlt(_localctx, 8); + { + setState(5983); + match(SOURCE); + } + break; + case SWAPS: + enterOuterAlt(_localctx, 9); + { + setState(5984); + match(SWAPS); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BinlogStatementContext extends ParserRuleContext { + public TerminalNode BINLOG() { return getToken(MySqlParser.BINLOG, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public BinlogStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_binlogStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBinlogStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBinlogStatement(this); + } + } + + public final BinlogStatementContext binlogStatement() throws RecognitionException { + BinlogStatementContext _localctx = new BinlogStatementContext(_ctx, getState()); + enterRule(_localctx, 504, RULE_binlogStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(5987); + match(BINLOG); + setState(5988); + match(STRING_LITERAL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CacheIndexStatementContext extends ParserRuleContext { + public UidContext schema; + public TerminalNode CACHE() { return getToken(MySqlParser.CACHE, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public List tableIndexes() { + return getRuleContexts(TableIndexesContext.class); + } + public TableIndexesContext tableIndexes(int i) { + return getRuleContext(TableIndexesContext.class,i); + } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public CacheIndexStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cacheIndexStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCacheIndexStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCacheIndexStatement(this); + } + } + + public final CacheIndexStatementContext cacheIndexStatement() throws RecognitionException { + CacheIndexStatementContext _localctx = new CacheIndexStatementContext(_ctx, getState()); + enterRule(_localctx, 506, RULE_cacheIndexStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5990); + match(CACHE); + setState(5991); + match(INDEX); + setState(5992); + tableIndexes(); + setState(5997); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5993); + match(COMMA); + setState(5994); + tableIndexes(); + } + } + setState(5999); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(6007); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(6000); + match(PARTITION); + setState(6001); + match(LR_BRACKET); + setState(6004); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(6002); + uidList(); + } + break; + case ALL: + { + setState(6003); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(6006); + match(RR_BRACKET); + } + } + + setState(6009); + match(IN); + setState(6010); + ((CacheIndexStatementContext)_localctx).schema = uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FlushStatementContext extends ParserRuleContext { + public Token flushFormat; + public TerminalNode FLUSH() { return getToken(MySqlParser.FLUSH, 0); } + public List flushOption() { + return getRuleContexts(FlushOptionContext.class); + } + public FlushOptionContext flushOption(int i) { + return getRuleContext(FlushOptionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode NO_WRITE_TO_BINLOG() { return getToken(MySqlParser.NO_WRITE_TO_BINLOG, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public FlushStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_flushStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFlushStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFlushStatement(this); + } + } + + public final FlushStatementContext flushStatement() throws RecognitionException { + FlushStatementContext _localctx = new FlushStatementContext(_ctx, getState()); + enterRule(_localctx, 508, RULE_flushStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6012); + match(FLUSH); + setState(6014); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO_WRITE_TO_BINLOG || _la==LOCAL) { + { + setState(6013); + ((FlushStatementContext)_localctx).flushFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==NO_WRITE_TO_BINLOG || _la==LOCAL) ) { + ((FlushStatementContext)_localctx).flushFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(6016); + flushOption(); + setState(6021); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6017); + match(COMMA); + setState(6018); + flushOption(); + } + } + setState(6023); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class KillStatementContext extends ParserRuleContext { + public Token connectionFormat; + public TerminalNode KILL() { return getToken(MySqlParser.KILL, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CONNECTION() { return getToken(MySqlParser.CONNECTION, 0); } + public TerminalNode QUERY() { return getToken(MySqlParser.QUERY, 0); } + public KillStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_killStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterKillStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitKillStatement(this); + } + } + + public final KillStatementContext killStatement() throws RecognitionException { + KillStatementContext _localctx = new KillStatementContext(_ctx, getState()); + enterRule(_localctx, 510, RULE_killStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6024); + match(KILL); + setState(6026); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,876,_ctx) ) { + case 1: + { + setState(6025); + ((KillStatementContext)_localctx).connectionFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CONNECTION || _la==QUERY) ) { + ((KillStatementContext)_localctx).connectionFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(6028); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LoadIndexIntoCacheContext extends ParserRuleContext { + public TerminalNode LOAD() { return getToken(MySqlParser.LOAD, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode INTO() { return getToken(MySqlParser.INTO, 0); } + public TerminalNode CACHE() { return getToken(MySqlParser.CACHE, 0); } + public List loadedTableIndexes() { + return getRuleContexts(LoadedTableIndexesContext.class); + } + public LoadedTableIndexesContext loadedTableIndexes(int i) { + return getRuleContext(LoadedTableIndexesContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public LoadIndexIntoCacheContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_loadIndexIntoCache; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLoadIndexIntoCache(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLoadIndexIntoCache(this); + } + } + + public final LoadIndexIntoCacheContext loadIndexIntoCache() throws RecognitionException { + LoadIndexIntoCacheContext _localctx = new LoadIndexIntoCacheContext(_ctx, getState()); + enterRule(_localctx, 512, RULE_loadIndexIntoCache); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6030); + match(LOAD); + setState(6031); + match(INDEX); + setState(6032); + match(INTO); + setState(6033); + match(CACHE); + setState(6034); + loadedTableIndexes(); + setState(6039); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6035); + match(COMMA); + setState(6036); + loadedTableIndexes(); + } + } + setState(6041); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ResetStatementContext extends ParserRuleContext { + public TerminalNode RESET() { return getToken(MySqlParser.RESET, 0); } + public TerminalNode QUERY() { return getToken(MySqlParser.QUERY, 0); } + public TerminalNode CACHE() { return getToken(MySqlParser.CACHE, 0); } + public ResetStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resetStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterResetStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitResetStatement(this); + } + } + + public final ResetStatementContext resetStatement() throws RecognitionException { + ResetStatementContext _localctx = new ResetStatementContext(_ctx, getState()); + enterRule(_localctx, 514, RULE_resetStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(6042); + match(RESET); + setState(6043); + match(QUERY); + setState(6044); + match(CACHE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ShutdownStatementContext extends ParserRuleContext { + public TerminalNode SHUTDOWN() { return getToken(MySqlParser.SHUTDOWN, 0); } + public ShutdownStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_shutdownStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterShutdownStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitShutdownStatement(this); + } + } + + public final ShutdownStatementContext shutdownStatement() throws RecognitionException { + ShutdownStatementContext _localctx = new ShutdownStatementContext(_ctx, getState()); + enterRule(_localctx, 516, RULE_shutdownStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(6046); + match(SHUTDOWN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableIndexesContext extends ParserRuleContext { + public Token indexFormat; + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public UidListContext uidList() { + return getRuleContext(UidListContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public TableIndexesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableIndexes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableIndexes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableIndexes(this); + } + } + + public final TableIndexesContext tableIndexes() throws RecognitionException { + TableIndexesContext _localctx = new TableIndexesContext(_ctx, getState()); + enterRule(_localctx, 518, RULE_tableIndexes); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6048); + tableName(); + setState(6056); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INDEX || _la==KEY || _la==LR_BRACKET) { + { + setState(6050); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INDEX || _la==KEY) { + { + setState(6049); + ((TableIndexesContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((TableIndexesContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(6052); + match(LR_BRACKET); + setState(6053); + uidList(); + setState(6054); + match(RR_BRACKET); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FlushOptionContext extends ParserRuleContext { + public FlushOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_flushOption; } + + public FlushOptionContext() { } + public void copyFrom(FlushOptionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TableFlushOptionContext extends FlushOptionContext { + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public TablesContext tables() { + return getRuleContext(TablesContext.class,0); + } + public FlushTableOptionContext flushTableOption() { + return getRuleContext(FlushTableOptionContext.class,0); + } + public TableFlushOptionContext(FlushOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableFlushOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableFlushOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ChannelFlushOptionContext extends FlushOptionContext { + public TerminalNode RELAY() { return getToken(MySqlParser.RELAY, 0); } + public TerminalNode LOGS() { return getToken(MySqlParser.LOGS, 0); } + public ChannelOptionContext channelOption() { + return getRuleContext(ChannelOptionContext.class,0); + } + public ChannelFlushOptionContext(FlushOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterChannelFlushOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitChannelFlushOption(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SimpleFlushOptionContext extends FlushOptionContext { + public TerminalNode DES_KEY_FILE() { return getToken(MySqlParser.DES_KEY_FILE, 0); } + public TerminalNode HOSTS() { return getToken(MySqlParser.HOSTS, 0); } + public TerminalNode LOGS() { return getToken(MySqlParser.LOGS, 0); } + public TerminalNode OPTIMIZER_COSTS() { return getToken(MySqlParser.OPTIMIZER_COSTS, 0); } + public TerminalNode PRIVILEGES() { return getToken(MySqlParser.PRIVILEGES, 0); } + public TerminalNode QUERY() { return getToken(MySqlParser.QUERY, 0); } + public TerminalNode CACHE() { return getToken(MySqlParser.CACHE, 0); } + public TerminalNode STATUS() { return getToken(MySqlParser.STATUS, 0); } + public TerminalNode USER_RESOURCES() { return getToken(MySqlParser.USER_RESOURCES, 0); } + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public TerminalNode READ() { return getToken(MySqlParser.READ, 0); } + public TerminalNode LOCK() { return getToken(MySqlParser.LOCK, 0); } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public TerminalNode ERROR() { return getToken(MySqlParser.ERROR, 0); } + public TerminalNode GENERAL() { return getToken(MySqlParser.GENERAL, 0); } + public TerminalNode RELAY() { return getToken(MySqlParser.RELAY, 0); } + public TerminalNode SLOW() { return getToken(MySqlParser.SLOW, 0); } + public SimpleFlushOptionContext(FlushOptionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleFlushOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleFlushOption(this); + } + } + + public final FlushOptionContext flushOption() throws RecognitionException { + FlushOptionContext _localctx = new FlushOptionContext(_ctx, getState()); + enterRule(_localctx, 520, RULE_flushOption); + int _la; + try { + setState(6090); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,886,_ctx) ) { + case 1: + _localctx = new SimpleFlushOptionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(6076); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DES_KEY_FILE: + { + setState(6058); + match(DES_KEY_FILE); + } + break; + case HOSTS: + { + setState(6059); + match(HOSTS); + } + break; + case BINARY: + case ENGINE: + case ERROR: + case GENERAL: + case LOGS: + case RELAY: + case SLOW: + { + setState(6061); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==BINARY || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & 536870917L) != 0) || _la==RELAY || _la==SLOW) { + { + setState(6060); + _la = _input.LA(1); + if ( !(_la==BINARY || ((((_la - 410)) & ~0x3f) == 0 && ((1L << (_la - 410)) & 536870917L) != 0) || _la==RELAY || _la==SLOW) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(6063); + match(LOGS); + } + break; + case OPTIMIZER_COSTS: + { + setState(6064); + match(OPTIMIZER_COSTS); + } + break; + case PRIVILEGES: + { + setState(6065); + match(PRIVILEGES); + } + break; + case QUERY: + { + setState(6066); + match(QUERY); + setState(6067); + match(CACHE); + } + break; + case STATUS: + { + setState(6068); + match(STATUS); + } + break; + case USER_RESOURCES: + { + setState(6069); + match(USER_RESOURCES); + } + break; + case TABLES: + { + setState(6070); + match(TABLES); + setState(6074); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,881,_ctx) ) { + case 1: + { + setState(6071); + match(WITH); + setState(6072); + match(READ); + setState(6073); + match(LOCK); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + _localctx = new ChannelFlushOptionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(6078); + match(RELAY); + setState(6079); + match(LOGS); + setState(6081); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(6080); + channelOption(); + } + } + + } + break; + case 3: + _localctx = new TableFlushOptionContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(6083); + _la = _input.LA(1); + if ( !(_la==TABLE || _la==TABLES) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6085); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,884,_ctx) ) { + case 1: + { + setState(6084); + tables(); + } + break; + } + setState(6088); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,885,_ctx) ) { + case 1: + { + setState(6087); + flushTableOption(); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FlushTableOptionContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public TerminalNode READ() { return getToken(MySqlParser.READ, 0); } + public TerminalNode LOCK() { return getToken(MySqlParser.LOCK, 0); } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode EXPORT() { return getToken(MySqlParser.EXPORT, 0); } + public FlushTableOptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_flushTableOption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFlushTableOption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFlushTableOption(this); + } + } + + public final FlushTableOptionContext flushTableOption() throws RecognitionException { + FlushTableOptionContext _localctx = new FlushTableOptionContext(_ctx, getState()); + enterRule(_localctx, 522, RULE_flushTableOption); + try { + setState(6097); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WITH: + enterOuterAlt(_localctx, 1); + { + setState(6092); + match(WITH); + setState(6093); + match(READ); + setState(6094); + match(LOCK); + } + break; + case FOR: + enterOuterAlt(_localctx, 2); + { + setState(6095); + match(FOR); + setState(6096); + match(EXPORT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LoadedTableIndexesContext extends ParserRuleContext { + public UidListContext partitionList; + public Token indexFormat; + public UidListContext indexList; + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public TerminalNode IGNORE() { return getToken(MySqlParser.IGNORE, 0); } + public TerminalNode LEAVES() { return getToken(MySqlParser.LEAVES, 0); } + public List uidList() { + return getRuleContexts(UidListContext.class); + } + public UidListContext uidList(int i) { + return getRuleContext(UidListContext.class,i); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode INDEX() { return getToken(MySqlParser.INDEX, 0); } + public TerminalNode KEY() { return getToken(MySqlParser.KEY, 0); } + public LoadedTableIndexesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_loadedTableIndexes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLoadedTableIndexes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLoadedTableIndexes(this); + } + } + + public final LoadedTableIndexesContext loadedTableIndexes() throws RecognitionException { + LoadedTableIndexesContext _localctx = new LoadedTableIndexesContext(_ctx, getState()); + enterRule(_localctx, 524, RULE_loadedTableIndexes); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6099); + tableName(); + setState(6107); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(6100); + match(PARTITION); + setState(6101); + match(LR_BRACKET); + setState(6104); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(6102); + ((LoadedTableIndexesContext)_localctx).partitionList = uidList(); + } + break; + case ALL: + { + setState(6103); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(6106); + match(RR_BRACKET); + } + } + + setState(6116); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,891,_ctx) ) { + case 1: + { + setState(6110); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INDEX || _la==KEY) { + { + setState(6109); + ((LoadedTableIndexesContext)_localctx).indexFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INDEX || _la==KEY) ) { + ((LoadedTableIndexesContext)_localctx).indexFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(6112); + match(LR_BRACKET); + setState(6113); + ((LoadedTableIndexesContext)_localctx).indexList = uidList(); + setState(6114); + match(RR_BRACKET); + } + break; + } + setState(6120); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IGNORE) { + { + setState(6118); + match(IGNORE); + setState(6119); + match(LEAVES); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SimpleDescribeStatementContext extends ParserRuleContext { + public Token command; + public UidContext column; + public Token pattern; + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public TerminalNode EXPLAIN() { return getToken(MySqlParser.EXPLAIN, 0); } + public TerminalNode DESCRIBE() { return getToken(MySqlParser.DESCRIBE, 0); } + public TerminalNode DESC() { return getToken(MySqlParser.DESC, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public SimpleDescribeStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleDescribeStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleDescribeStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleDescribeStatement(this); + } + } + + public final SimpleDescribeStatementContext simpleDescribeStatement() throws RecognitionException { + SimpleDescribeStatementContext _localctx = new SimpleDescribeStatementContext(_ctx, getState()); + enterRule(_localctx, 526, RULE_simpleDescribeStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6122); + ((SimpleDescribeStatementContext)_localctx).command = _input.LT(1); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -9223160930622242816L) != 0)) ) { + ((SimpleDescribeStatementContext)_localctx).command = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6123); + tableName(); + setState(6126); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,893,_ctx) ) { + case 1: + { + setState(6124); + ((SimpleDescribeStatementContext)_localctx).column = uid(); + } + break; + case 2: + { + setState(6125); + ((SimpleDescribeStatementContext)_localctx).pattern = match(STRING_LITERAL); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FullDescribeStatementContext extends ParserRuleContext { + public Token command; + public Token formatType; + public Token formatValue; + public DescribeObjectClauseContext describeObjectClause() { + return getRuleContext(DescribeObjectClauseContext.class,0); + } + public TerminalNode EXPLAIN() { return getToken(MySqlParser.EXPLAIN, 0); } + public TerminalNode DESCRIBE() { return getToken(MySqlParser.DESCRIBE, 0); } + public TerminalNode DESC() { return getToken(MySqlParser.DESC, 0); } + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode EXTENDED() { return getToken(MySqlParser.EXTENDED, 0); } + public TerminalNode PARTITIONS() { return getToken(MySqlParser.PARTITIONS, 0); } + public TerminalNode FORMAT() { return getToken(MySqlParser.FORMAT, 0); } + public TerminalNode TRADITIONAL() { return getToken(MySqlParser.TRADITIONAL, 0); } + public TerminalNode JSON() { return getToken(MySqlParser.JSON, 0); } + public FullDescribeStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fullDescribeStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFullDescribeStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFullDescribeStatement(this); + } + } + + public final FullDescribeStatementContext fullDescribeStatement() throws RecognitionException { + FullDescribeStatementContext _localctx = new FullDescribeStatementContext(_ctx, getState()); + enterRule(_localctx, 528, RULE_fullDescribeStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6128); + ((FullDescribeStatementContext)_localctx).command = _input.LT(1); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -9223160930622242816L) != 0)) ) { + ((FullDescribeStatementContext)_localctx).command = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6132); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXTENDED || _la==PARTITIONS || _la==FORMAT) { + { + setState(6129); + ((FullDescribeStatementContext)_localctx).formatType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==EXTENDED || _la==PARTITIONS || _la==FORMAT) ) { + ((FullDescribeStatementContext)_localctx).formatType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6130); + match(EQUAL_SYMBOL); + setState(6131); + ((FullDescribeStatementContext)_localctx).formatValue = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==JSON || _la==TRADITIONAL) ) { + ((FullDescribeStatementContext)_localctx).formatValue = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(6134); + describeObjectClause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HelpStatementContext extends ParserRuleContext { + public TerminalNode HELP() { return getToken(MySqlParser.HELP, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public HelpStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_helpStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHelpStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHelpStatement(this); + } + } + + public final HelpStatementContext helpStatement() throws RecognitionException { + HelpStatementContext _localctx = new HelpStatementContext(_ctx, getState()); + enterRule(_localctx, 530, RULE_helpStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(6136); + match(HELP); + setState(6137); + match(STRING_LITERAL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UseStatementContext extends ParserRuleContext { + public TerminalNode USE() { return getToken(MySqlParser.USE, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public UseStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_useStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUseStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUseStatement(this); + } + } + + public final UseStatementContext useStatement() throws RecognitionException { + UseStatementContext _localctx = new UseStatementContext(_ctx, getState()); + enterRule(_localctx, 532, RULE_useStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(6139); + match(USE); + setState(6140); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SignalStatementContext extends ParserRuleContext { + public TerminalNode SIGNAL() { return getToken(MySqlParser.SIGNAL, 0); } + public TerminalNode ID() { return getToken(MySqlParser.ID, 0); } + public TerminalNode REVERSE_QUOTE_ID() { return getToken(MySqlParser.REVERSE_QUOTE_ID, 0); } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public List signalConditionInformation() { + return getRuleContexts(SignalConditionInformationContext.class); + } + public SignalConditionInformationContext signalConditionInformation(int i) { + return getRuleContext(SignalConditionInformationContext.class,i); + } + public TerminalNode SQLSTATE() { return getToken(MySqlParser.SQLSTATE, 0); } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode VALUE() { return getToken(MySqlParser.VALUE, 0); } + public SignalStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_signalStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSignalStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSignalStatement(this); + } + } + + public final SignalStatementContext signalStatement() throws RecognitionException { + SignalStatementContext _localctx = new SignalStatementContext(_ctx, getState()); + enterRule(_localctx, 534, RULE_signalStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6142); + match(SIGNAL); + setState(6150); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SQLSTATE: + { + { + setState(6143); + match(SQLSTATE); + setState(6145); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VALUE) { + { + setState(6144); + match(VALUE); + } + } + + setState(6147); + stringLiteral(); + } + } + break; + case ID: + { + setState(6148); + match(ID); + } + break; + case REVERSE_QUOTE_ID: + { + setState(6149); + match(REVERSE_QUOTE_ID); + } + break; + default: + throw new NoViableAltException(this); + } + setState(6161); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,898,_ctx) ) { + case 1: + { + setState(6152); + match(SET); + setState(6153); + signalConditionInformation(); + setState(6158); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6154); + match(COMMA); + setState(6155); + signalConditionInformation(); + } + } + setState(6160); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ResignalStatementContext extends ParserRuleContext { + public TerminalNode RESIGNAL() { return getToken(MySqlParser.RESIGNAL, 0); } + public TerminalNode ID() { return getToken(MySqlParser.ID, 0); } + public TerminalNode REVERSE_QUOTE_ID() { return getToken(MySqlParser.REVERSE_QUOTE_ID, 0); } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public List signalConditionInformation() { + return getRuleContexts(SignalConditionInformationContext.class); + } + public SignalConditionInformationContext signalConditionInformation(int i) { + return getRuleContext(SignalConditionInformationContext.class,i); + } + public TerminalNode SQLSTATE() { return getToken(MySqlParser.SQLSTATE, 0); } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TerminalNode VALUE() { return getToken(MySqlParser.VALUE, 0); } + public ResignalStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resignalStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterResignalStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitResignalStatement(this); + } + } + + public final ResignalStatementContext resignalStatement() throws RecognitionException { + ResignalStatementContext _localctx = new ResignalStatementContext(_ctx, getState()); + enterRule(_localctx, 536, RULE_resignalStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6163); + match(RESIGNAL); + setState(6171); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SQLSTATE: + { + { + setState(6164); + match(SQLSTATE); + setState(6166); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VALUE) { + { + setState(6165); + match(VALUE); + } + } + + setState(6168); + stringLiteral(); + } + } + break; + case ID: + { + setState(6169); + match(ID); + } + break; + case REVERSE_QUOTE_ID: + { + setState(6170); + match(REVERSE_QUOTE_ID); + } + break; + case EOF: + case ALTER: + case ANALYZE: + case CALL: + case CHANGE: + case CHECK: + case CREATE: + case DELETE: + case DESC: + case DESCRIBE: + case DROP: + case EXPLAIN: + case GET: + case GRANT: + case INSERT: + case KILL: + case LOAD: + case LOCK: + case OPTIMIZE: + case PURGE: + case RELEASE: + case RENAME: + case REPLACE: + case RESIGNAL: + case REVOKE: + case SELECT: + case SET: + case SHOW: + case SIGNAL: + case TABLE: + case UNLOCK: + case UPDATE: + case USE: + case VALUES: + case WITH: + case BEGIN: + case BINLOG: + case CACHE: + case CHECKSUM: + case COMMIT: + case DEALLOCATE: + case DO: + case FLUSH: + case HANDLER: + case HELP: + case INSTALL: + case PREPARE: + case REPAIR: + case RESET: + case ROLLBACK: + case SAVEPOINT: + case START: + case STOP: + case TRUNCATE: + case UNINSTALL: + case XA: + case EXECUTE: + case SHUTDOWN: + case MINUS: + case LR_BRACKET: + case SEMI: + break; + default: + break; + } + setState(6182); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,902,_ctx) ) { + case 1: + { + setState(6173); + match(SET); + setState(6174); + signalConditionInformation(); + setState(6179); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6175); + match(COMMA); + setState(6176); + signalConditionInformation(); + } + } + setState(6181); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SignalConditionInformationContext extends ParserRuleContext { + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode CLASS_ORIGIN() { return getToken(MySqlParser.CLASS_ORIGIN, 0); } + public TerminalNode SUBCLASS_ORIGIN() { return getToken(MySqlParser.SUBCLASS_ORIGIN, 0); } + public TerminalNode MESSAGE_TEXT() { return getToken(MySqlParser.MESSAGE_TEXT, 0); } + public TerminalNode MYSQL_ERRNO() { return getToken(MySqlParser.MYSQL_ERRNO, 0); } + public TerminalNode CONSTRAINT_CATALOG() { return getToken(MySqlParser.CONSTRAINT_CATALOG, 0); } + public TerminalNode CONSTRAINT_SCHEMA() { return getToken(MySqlParser.CONSTRAINT_SCHEMA, 0); } + public TerminalNode CONSTRAINT_NAME() { return getToken(MySqlParser.CONSTRAINT_NAME, 0); } + public TerminalNode CATALOG_NAME() { return getToken(MySqlParser.CATALOG_NAME, 0); } + public TerminalNode SCHEMA_NAME() { return getToken(MySqlParser.SCHEMA_NAME, 0); } + public TerminalNode TABLE_NAME() { return getToken(MySqlParser.TABLE_NAME, 0); } + public TerminalNode COLUMN_NAME() { return getToken(MySqlParser.COLUMN_NAME, 0); } + public TerminalNode CURSOR_NAME() { return getToken(MySqlParser.CURSOR_NAME, 0); } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public TerminalNode DECIMAL_LITERAL() { return getToken(MySqlParser.DECIMAL_LITERAL, 0); } + public MysqlVariableContext mysqlVariable() { + return getRuleContext(MysqlVariableContext.class,0); + } + public SimpleIdContext simpleId() { + return getRuleContext(SimpleIdContext.class,0); + } + public SignalConditionInformationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_signalConditionInformation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSignalConditionInformation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSignalConditionInformation(this); + } + } + + public final SignalConditionInformationContext signalConditionInformation() throws RecognitionException { + SignalConditionInformationContext _localctx = new SignalConditionInformationContext(_ctx, getState()); + enterRule(_localctx, 538, RULE_signalConditionInformation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6184); + _la = _input.LA(1); + if ( !(((((_la - 360)) & ~0x3f) == 0 && ((1L << (_la - 360)) & 272105729L) != 0) || _la==MESSAGE_TEXT || _la==MYSQL_ERRNO || _la==SUBCLASS_ORIGIN || _la==TABLE_NAME || _la==CATALOG_NAME || _la==SCHEMA_NAME) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6185); + match(EQUAL_SYMBOL); + setState(6190); + _errHandler.sync(this); + switch (_input.LA(1)) { + case START_NATIONAL_STRING_LITERAL: + case STRING_LITERAL: + case STRING_CHARSET_NAME: + { + setState(6186); + stringLiteral(); + } + break; + case DECIMAL_LITERAL: + { + setState(6187); + match(DECIMAL_LITERAL); + } + break; + case LOCAL_ID: + case GLOBAL_ID: + { + setState(6188); + mysqlVariable(); + } + break; + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case ID: + { + setState(6189); + simpleId(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WithStatementContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(MySqlParser.WITH, 0); } + public List commonTableExpressions() { + return getRuleContexts(CommonTableExpressionsContext.class); + } + public CommonTableExpressionsContext commonTableExpressions(int i) { + return getRuleContext(CommonTableExpressionsContext.class,i); + } + public TerminalNode RECURSIVE() { return getToken(MySqlParser.RECURSIVE, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public WithStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_withStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWithStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWithStatement(this); + } + } + + public final WithStatementContext withStatement() throws RecognitionException { + WithStatementContext _localctx = new WithStatementContext(_ctx, getState()); + enterRule(_localctx, 540, RULE_withStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6192); + match(WITH); + setState(6194); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,904,_ctx) ) { + case 1: + { + setState(6193); + match(RECURSIVE); + } + break; + } + setState(6196); + commonTableExpressions(); + setState(6201); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6197); + match(COMMA); + setState(6198); + commonTableExpressions(); + } + } + setState(6203); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableStatementContext extends ParserRuleContext { + public TerminalNode TABLE() { return getToken(MySqlParser.TABLE, 0); } + public TableNameContext tableName() { + return getRuleContext(TableNameContext.class,0); + } + public OrderByClauseContext orderByClause() { + return getRuleContext(OrderByClauseContext.class,0); + } + public LimitClauseContext limitClause() { + return getRuleContext(LimitClauseContext.class,0); + } + public TableStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableStatement(this); + } + } + + public final TableStatementContext tableStatement() throws RecognitionException { + TableStatementContext _localctx = new TableStatementContext(_ctx, getState()); + enterRule(_localctx, 542, RULE_tableStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6204); + match(TABLE); + setState(6205); + tableName(); + setState(6207); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ORDER) { + { + setState(6206); + orderByClause(); + } + } + + setState(6210); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(6209); + limitClause(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DiagnosticsStatementContext extends ParserRuleContext { + public TerminalNode GET() { return getToken(MySqlParser.GET, 0); } + public TerminalNode DIAGNOSTICS() { return getToken(MySqlParser.DIAGNOSTICS, 0); } + public TerminalNode CURRENT() { return getToken(MySqlParser.CURRENT, 0); } + public TerminalNode STACKED() { return getToken(MySqlParser.STACKED, 0); } + public List variableClause() { + return getRuleContexts(VariableClauseContext.class); + } + public VariableClauseContext variableClause(int i) { + return getRuleContext(VariableClauseContext.class,i); + } + public List EQUAL_SYMBOL() { return getTokens(MySqlParser.EQUAL_SYMBOL); } + public TerminalNode EQUAL_SYMBOL(int i) { + return getToken(MySqlParser.EQUAL_SYMBOL, i); + } + public TerminalNode CONDITION() { return getToken(MySqlParser.CONDITION, 0); } + public List diagnosticsConditionInformationName() { + return getRuleContexts(DiagnosticsConditionInformationNameContext.class); + } + public DiagnosticsConditionInformationNameContext diagnosticsConditionInformationName(int i) { + return getRuleContext(DiagnosticsConditionInformationNameContext.class,i); + } + public List NUMBER() { return getTokens(MySqlParser.NUMBER); } + public TerminalNode NUMBER(int i) { + return getToken(MySqlParser.NUMBER, i); + } + public List ROW_COUNT() { return getTokens(MySqlParser.ROW_COUNT); } + public TerminalNode ROW_COUNT(int i) { + return getToken(MySqlParser.ROW_COUNT, i); + } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public DiagnosticsStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_diagnosticsStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDiagnosticsStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDiagnosticsStatement(this); + } + } + + public final DiagnosticsStatementContext diagnosticsStatement() throws RecognitionException { + DiagnosticsStatementContext _localctx = new DiagnosticsStatementContext(_ctx, getState()); + enterRule(_localctx, 544, RULE_diagnosticsStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6212); + match(GET); + setState(6214); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CURRENT || _la==STACKED) { + { + setState(6213); + _la = _input.LA(1); + if ( !(_la==CURRENT || _la==STACKED) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(6216); + match(DIAGNOSTICS); + setState(6248); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,912,_ctx) ) { + case 1: + { + { + setState(6217); + variableClause(); + setState(6218); + match(EQUAL_SYMBOL); + setState(6219); + _la = _input.LA(1); + if ( !(_la==NUMBER || _la==ROW_COUNT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6227); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6220); + match(COMMA); + setState(6221); + variableClause(); + setState(6222); + match(EQUAL_SYMBOL); + setState(6223); + _la = _input.LA(1); + if ( !(_la==NUMBER || _la==ROW_COUNT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + setState(6229); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + break; + case 2: + { + { + setState(6230); + match(CONDITION); + setState(6233); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + { + setState(6231); + decimalLiteral(); + } + break; + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case AT_SIGN: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + case LOCAL_ID: + case GLOBAL_ID: + { + setState(6232); + variableClause(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(6235); + variableClause(); + setState(6236); + match(EQUAL_SYMBOL); + setState(6237); + diagnosticsConditionInformationName(); + setState(6245); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6238); + match(COMMA); + setState(6239); + variableClause(); + setState(6240); + match(EQUAL_SYMBOL); + setState(6241); + diagnosticsConditionInformationName(); + } + } + setState(6247); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DiagnosticsConditionInformationNameContext extends ParserRuleContext { + public TerminalNode CLASS_ORIGIN() { return getToken(MySqlParser.CLASS_ORIGIN, 0); } + public TerminalNode SUBCLASS_ORIGIN() { return getToken(MySqlParser.SUBCLASS_ORIGIN, 0); } + public TerminalNode RETURNED_SQLSTATE() { return getToken(MySqlParser.RETURNED_SQLSTATE, 0); } + public TerminalNode MESSAGE_TEXT() { return getToken(MySqlParser.MESSAGE_TEXT, 0); } + public TerminalNode MYSQL_ERRNO() { return getToken(MySqlParser.MYSQL_ERRNO, 0); } + public TerminalNode CONSTRAINT_CATALOG() { return getToken(MySqlParser.CONSTRAINT_CATALOG, 0); } + public TerminalNode CONSTRAINT_SCHEMA() { return getToken(MySqlParser.CONSTRAINT_SCHEMA, 0); } + public TerminalNode CONSTRAINT_NAME() { return getToken(MySqlParser.CONSTRAINT_NAME, 0); } + public TerminalNode CATALOG_NAME() { return getToken(MySqlParser.CATALOG_NAME, 0); } + public TerminalNode SCHEMA_NAME() { return getToken(MySqlParser.SCHEMA_NAME, 0); } + public TerminalNode TABLE_NAME() { return getToken(MySqlParser.TABLE_NAME, 0); } + public TerminalNode COLUMN_NAME() { return getToken(MySqlParser.COLUMN_NAME, 0); } + public TerminalNode CURSOR_NAME() { return getToken(MySqlParser.CURSOR_NAME, 0); } + public DiagnosticsConditionInformationNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_diagnosticsConditionInformationName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDiagnosticsConditionInformationName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDiagnosticsConditionInformationName(this); + } + } + + public final DiagnosticsConditionInformationNameContext diagnosticsConditionInformationName() throws RecognitionException { + DiagnosticsConditionInformationNameContext _localctx = new DiagnosticsConditionInformationNameContext(_ctx, getState()); + enterRule(_localctx, 546, RULE_diagnosticsConditionInformationName); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6250); + _la = _input.LA(1); + if ( !(((((_la - 360)) & ~0x3f) == 0 && ((1L << (_la - 360)) & 272105729L) != 0) || _la==MESSAGE_TEXT || _la==MYSQL_ERRNO || ((((_la - 593)) & ~0x3f) == 0 && ((1L << (_la - 593)) & 18155135997837313L) != 0) || _la==CATALOG_NAME || _la==SCHEMA_NAME) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DescribeObjectClauseContext extends ParserRuleContext { + public DescribeObjectClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_describeObjectClause; } + + public DescribeObjectClauseContext() { } + public void copyFrom(DescribeObjectClauseContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DescribeStatementsContext extends DescribeObjectClauseContext { + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public DeleteStatementContext deleteStatement() { + return getRuleContext(DeleteStatementContext.class,0); + } + public InsertStatementContext insertStatement() { + return getRuleContext(InsertStatementContext.class,0); + } + public ReplaceStatementContext replaceStatement() { + return getRuleContext(ReplaceStatementContext.class,0); + } + public UpdateStatementContext updateStatement() { + return getRuleContext(UpdateStatementContext.class,0); + } + public DescribeStatementsContext(DescribeObjectClauseContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDescribeStatements(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDescribeStatements(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DescribeConnectionContext extends DescribeObjectClauseContext { + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public TerminalNode CONNECTION() { return getToken(MySqlParser.CONNECTION, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public DescribeConnectionContext(DescribeObjectClauseContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDescribeConnection(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDescribeConnection(this); + } + } + + public final DescribeObjectClauseContext describeObjectClause() throws RecognitionException { + DescribeObjectClauseContext _localctx = new DescribeObjectClauseContext(_ctx, getState()); + enterRule(_localctx, 548, RULE_describeObjectClause); + try { + setState(6262); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DELETE: + case INSERT: + case REPLACE: + case SELECT: + case UPDATE: + case LR_BRACKET: + _localctx = new DescribeStatementsContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(6257); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + case LR_BRACKET: + { + setState(6252); + selectStatement(); + } + break; + case DELETE: + { + setState(6253); + deleteStatement(); + } + break; + case INSERT: + { + setState(6254); + insertStatement(); + } + break; + case REPLACE: + { + setState(6255); + replaceStatement(); + } + break; + case UPDATE: + { + setState(6256); + updateStatement(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case FOR: + _localctx = new DescribeConnectionContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(6259); + match(FOR); + setState(6260); + match(CONNECTION); + setState(6261); + uid(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FullIdContext extends ParserRuleContext { + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public TerminalNode DOT_ID() { return getToken(MySqlParser.DOT_ID, 0); } + public TerminalNode DOT() { return getToken(MySqlParser.DOT, 0); } + public FullIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fullId; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFullId(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFullId(this); + } + } + + public final FullIdContext fullId() throws RecognitionException { + FullIdContext _localctx = new FullIdContext(_ctx, getState()); + enterRule(_localctx, 550, RULE_fullId); + try { + enterOuterAlt(_localctx, 1); + { + setState(6264); + uid(); + setState(6268); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,915,_ctx) ) { + case 1: + { + setState(6265); + match(DOT_ID); + } + break; + case 2: + { + setState(6266); + match(DOT); + setState(6267); + uid(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableNameContext extends ParserRuleContext { + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TableNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTableName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTableName(this); + } + } + + public final TableNameContext tableName() throws RecognitionException { + TableNameContext _localctx = new TableNameContext(_ctx, getState()); + enterRule(_localctx, 552, RULE_tableName); + try { + enterOuterAlt(_localctx, 1); + { + setState(6270); + fullId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RoleNameContext extends ParserRuleContext { + public UserNameContext userName() { + return getRuleContext(UserNameContext.class,0); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public RoleNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_roleName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRoleName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRoleName(this); + } + } + + public final RoleNameContext roleName() throws RecognitionException { + RoleNameContext _localctx = new RoleNameContext(_ctx, getState()); + enterRule(_localctx, 554, RULE_roleName); + try { + setState(6274); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,916,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6272); + userName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6273); + uid(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FullColumnNameContext extends ParserRuleContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public List dottedId() { + return getRuleContexts(DottedIdContext.class); + } + public DottedIdContext dottedId(int i) { + return getRuleContext(DottedIdContext.class,i); + } + public FullColumnNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fullColumnName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFullColumnName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFullColumnName(this); + } + } + + public final FullColumnNameContext fullColumnName() throws RecognitionException { + FullColumnNameContext _localctx = new FullColumnNameContext(_ctx, getState()); + enterRule(_localctx, 556, RULE_fullColumnName); + try { + setState(6290); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,921,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6276); + uid(); + setState(6281); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,918,_ctx) ) { + case 1: + { + setState(6277); + dottedId(); + setState(6279); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,917,_ctx) ) { + case 1: + { + setState(6278); + dottedId(); + } + break; + } + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6284); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,919,_ctx) ) { + case 1: + { + setState(6283); + matchWildcard(); + } + break; + } + setState(6286); + dottedId(); + setState(6288); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,920,_ctx) ) { + case 1: + { + setState(6287); + dottedId(); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexColumnNameContext extends ParserRuleContext { + public Token sortType; + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode ASC() { return getToken(MySqlParser.ASC, 0); } + public TerminalNode DESC() { return getToken(MySqlParser.DESC, 0); } + public IndexColumnNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexColumnName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexColumnName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexColumnName(this); + } + } + + public final IndexColumnNameContext indexColumnName() throws RecognitionException { + IndexColumnNameContext _localctx = new IndexColumnNameContext(_ctx, getState()); + enterRule(_localctx, 558, RULE_indexColumnName); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6303); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,924,_ctx) ) { + case 1: + { + setState(6294); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,922,_ctx) ) { + case 1: + { + setState(6292); + uid(); + } + break; + case 2: + { + setState(6293); + match(STRING_LITERAL); + } + break; + } + setState(6300); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(6296); + match(LR_BRACKET); + setState(6297); + decimalLiteral(); + setState(6298); + match(RR_BRACKET); + } + } + + } + break; + case 2: + { + setState(6302); + expression(0); + } + break; + } + setState(6306); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASC || _la==DESC) { + { + setState(6305); + ((IndexColumnNameContext)_localctx).sortType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ASC || _la==DESC) ) { + ((IndexColumnNameContext)_localctx).sortType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SimpleUserNameContext extends ParserRuleContext { + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode ID() { return getToken(MySqlParser.ID, 0); } + public TerminalNode ADMIN() { return getToken(MySqlParser.ADMIN, 0); } + public KeywordsCanBeIdContext keywordsCanBeId() { + return getRuleContext(KeywordsCanBeIdContext.class,0); + } + public SimpleUserNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleUserName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleUserName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleUserName(this); + } + } + + public final SimpleUserNameContext simpleUserName() throws RecognitionException { + SimpleUserNameContext _localctx = new SimpleUserNameContext(_ctx, getState()); + enterRule(_localctx, 560, RULE_simpleUserName); + try { + setState(6312); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,926,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6308); + match(STRING_LITERAL); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6309); + match(ID); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6310); + match(ADMIN); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6311); + keywordsCanBeId(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HostNameContext extends ParserRuleContext { + public TerminalNode LOCAL_ID() { return getToken(MySqlParser.LOCAL_ID, 0); } + public TerminalNode HOST_IP_ADDRESS() { return getToken(MySqlParser.HOST_IP_ADDRESS, 0); } + public TerminalNode AT_SIGN() { return getToken(MySqlParser.AT_SIGN, 0); } + public HostNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hostName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHostName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHostName(this); + } + } + + public final HostNameContext hostName() throws RecognitionException { + HostNameContext _localctx = new HostNameContext(_ctx, getState()); + enterRule(_localctx, 562, RULE_hostName); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6314); + _la = _input.LA(1); + if ( !(((((_la - 1138)) & ~0x3f) == 0 && ((1L << (_la - 1138)) & 6291457L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UserNameContext extends ParserRuleContext { + public SimpleUserNameContext simpleUserName() { + return getRuleContext(SimpleUserNameContext.class,0); + } + public HostNameContext hostName() { + return getRuleContext(HostNameContext.class,0); + } + public CurrentUserExpressionContext currentUserExpression() { + return getRuleContext(CurrentUserExpressionContext.class,0); + } + public UserNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_userName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUserName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUserName(this); + } + } + + public final UserNameContext userName() throws RecognitionException { + UserNameContext _localctx = new UserNameContext(_ctx, getState()); + enterRule(_localctx, 564, RULE_userName); + try { + setState(6321); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,927,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6316); + simpleUserName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6317); + simpleUserName(); + setState(6318); + hostName(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6320); + currentUserExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MysqlVariableContext extends ParserRuleContext { + public TerminalNode LOCAL_ID() { return getToken(MySqlParser.LOCAL_ID, 0); } + public TerminalNode GLOBAL_ID() { return getToken(MySqlParser.GLOBAL_ID, 0); } + public MysqlVariableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mysqlVariable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMysqlVariable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMysqlVariable(this); + } + } + + public final MysqlVariableContext mysqlVariable() throws RecognitionException { + MysqlVariableContext _localctx = new MysqlVariableContext(_ctx, getState()); + enterRule(_localctx, 566, RULE_mysqlVariable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6323); + _la = _input.LA(1); + if ( !(_la==LOCAL_ID || _la==GLOBAL_ID) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CharsetNameContext extends ParserRuleContext { + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public CharsetNameBaseContext charsetNameBase() { + return getRuleContext(CharsetNameBaseContext.class,0); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode CHARSET_REVERSE_QOUTE_STRING() { return getToken(MySqlParser.CHARSET_REVERSE_QOUTE_STRING, 0); } + public CharsetNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_charsetName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCharsetName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCharsetName(this); + } + } + + public final CharsetNameContext charsetName() throws RecognitionException { + CharsetNameContext _localctx = new CharsetNameContext(_ctx, getState()); + enterRule(_localctx, 568, RULE_charsetName); + try { + setState(6329); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,928,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6325); + match(BINARY); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6326); + charsetNameBase(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6327); + match(STRING_LITERAL); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6328); + match(CHARSET_REVERSE_QOUTE_STRING); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CollationNameContext extends ParserRuleContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public CollationNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_collationName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCollationName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCollationName(this); + } + } + + public final CollationNameContext collationName() throws RecognitionException { + CollationNameContext _localctx = new CollationNameContext(_ctx, getState()); + enterRule(_localctx, 570, RULE_collationName); + try { + setState(6333); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,929,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6331); + uid(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6332); + match(STRING_LITERAL); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EngineNameContext extends ParserRuleContext { + public EngineNameBaseContext engineNameBase() { + return getRuleContext(EngineNameBaseContext.class,0); + } + public TerminalNode ID() { return getToken(MySqlParser.ID, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public EngineNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_engineName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterEngineName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitEngineName(this); + } + } + + public final EngineNameContext engineName() throws RecognitionException { + EngineNameContext _localctx = new EngineNameContext(_ctx, getState()); + enterRule(_localctx, 572, RULE_engineName); + try { + setState(6338); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CONNECT: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + enterOuterAlt(_localctx, 1); + { + setState(6335); + engineNameBase(); + } + break; + case ID: + enterOuterAlt(_localctx, 2); + { + setState(6336); + match(ID); + } + break; + case STRING_LITERAL: + enterOuterAlt(_localctx, 3); + { + setState(6337); + match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EngineNameBaseContext extends ParserRuleContext { + public TerminalNode ARCHIVE() { return getToken(MySqlParser.ARCHIVE, 0); } + public TerminalNode BLACKHOLE() { return getToken(MySqlParser.BLACKHOLE, 0); } + public TerminalNode CONNECT() { return getToken(MySqlParser.CONNECT, 0); } + public TerminalNode CSV() { return getToken(MySqlParser.CSV, 0); } + public TerminalNode FEDERATED() { return getToken(MySqlParser.FEDERATED, 0); } + public TerminalNode INNODB() { return getToken(MySqlParser.INNODB, 0); } + public TerminalNode MEMORY() { return getToken(MySqlParser.MEMORY, 0); } + public TerminalNode MRG_MYISAM() { return getToken(MySqlParser.MRG_MYISAM, 0); } + public TerminalNode MYISAM() { return getToken(MySqlParser.MYISAM, 0); } + public TerminalNode NDB() { return getToken(MySqlParser.NDB, 0); } + public TerminalNode NDBCLUSTER() { return getToken(MySqlParser.NDBCLUSTER, 0); } + public TerminalNode PERFORMANCE_SCHEMA() { return getToken(MySqlParser.PERFORMANCE_SCHEMA, 0); } + public TerminalNode TOKUDB() { return getToken(MySqlParser.TOKUDB, 0); } + public EngineNameBaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_engineNameBase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterEngineNameBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitEngineNameBase(this); + } + } + + public final EngineNameBaseContext engineNameBase() throws RecognitionException { + EngineNameBaseContext _localctx = new EngineNameBaseContext(_ctx, getState()); + enterRule(_localctx, 574, RULE_engineNameBase); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6340); + _la = _input.LA(1); + if ( !(_la==CONNECT || ((((_la - 788)) & ~0x3f) == 0 && ((1L << (_la - 788)) & 4095L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UuidSetContext extends ParserRuleContext { + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public List MINUS() { return getTokens(MySqlParser.MINUS); } + public TerminalNode MINUS(int i) { + return getToken(MySqlParser.MINUS, i); + } + public List COLON_SYMB() { return getTokens(MySqlParser.COLON_SYMB); } + public TerminalNode COLON_SYMB(int i) { + return getToken(MySqlParser.COLON_SYMB, i); + } + public UuidSetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_uuidSet; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUuidSet(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUuidSet(this); + } + } + + public final UuidSetContext uuidSet() throws RecognitionException { + UuidSetContext _localctx = new UuidSetContext(_ctx, getState()); + enterRule(_localctx, 576, RULE_uuidSet); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6342); + decimalLiteral(); + setState(6343); + match(MINUS); + setState(6344); + decimalLiteral(); + setState(6345); + match(MINUS); + setState(6346); + decimalLiteral(); + setState(6347); + match(MINUS); + setState(6348); + decimalLiteral(); + setState(6349); + match(MINUS); + setState(6350); + decimalLiteral(); + setState(6356); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(6351); + match(COLON_SYMB); + setState(6352); + decimalLiteral(); + setState(6353); + match(MINUS); + setState(6354); + decimalLiteral(); + } + } + setState(6358); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==COLON_SYMB ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XidContext extends ParserRuleContext { + public XuidStringIdContext globalTableUid; + public XuidStringIdContext qualifier; + public DecimalLiteralContext idFormat; + public List xuidStringId() { + return getRuleContexts(XuidStringIdContext.class); + } + public XuidStringIdContext xuidStringId(int i) { + return getRuleContext(XuidStringIdContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public XidContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xid; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterXid(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitXid(this); + } + } + + public final XidContext xid() throws RecognitionException { + XidContext _localctx = new XidContext(_ctx, getState()); + enterRule(_localctx, 578, RULE_xid); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6360); + ((XidContext)_localctx).globalTableUid = xuidStringId(); + setState(6367); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(6361); + match(COMMA); + setState(6362); + ((XidContext)_localctx).qualifier = xuidStringId(); + setState(6365); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(6363); + match(COMMA); + setState(6364); + ((XidContext)_localctx).idFormat = decimalLiteral(); + } + } + + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XuidStringIdContext extends ParserRuleContext { + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public TerminalNode BIT_STRING() { return getToken(MySqlParser.BIT_STRING, 0); } + public List HEXADECIMAL_LITERAL() { return getTokens(MySqlParser.HEXADECIMAL_LITERAL); } + public TerminalNode HEXADECIMAL_LITERAL(int i) { + return getToken(MySqlParser.HEXADECIMAL_LITERAL, i); + } + public XuidStringIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xuidStringId; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterXuidStringId(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitXuidStringId(this); + } + } + + public final XuidStringIdContext xuidStringId() throws RecognitionException { + XuidStringIdContext _localctx = new XuidStringIdContext(_ctx, getState()); + enterRule(_localctx, 580, RULE_xuidStringId); + int _la; + try { + setState(6376); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING_LITERAL: + enterOuterAlt(_localctx, 1); + { + setState(6369); + match(STRING_LITERAL); + } + break; + case BIT_STRING: + enterOuterAlt(_localctx, 2); + { + setState(6370); + match(BIT_STRING); + } + break; + case HEXADECIMAL_LITERAL: + enterOuterAlt(_localctx, 3); + { + setState(6372); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(6371); + match(HEXADECIMAL_LITERAL); + } + } + setState(6374); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==HEXADECIMAL_LITERAL ); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AuthPluginContext extends ParserRuleContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public AuthPluginContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_authPlugin; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAuthPlugin(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAuthPlugin(this); + } + } + + public final AuthPluginContext authPlugin() throws RecognitionException { + AuthPluginContext _localctx = new AuthPluginContext(_ctx, getState()); + enterRule(_localctx, 582, RULE_authPlugin); + try { + setState(6380); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,936,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6378); + uid(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6379); + match(STRING_LITERAL); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UidContext extends ParserRuleContext { + public SimpleIdContext simpleId() { + return getRuleContext(SimpleIdContext.class,0); + } + public TerminalNode CHARSET_REVERSE_QOUTE_STRING() { return getToken(MySqlParser.CHARSET_REVERSE_QOUTE_STRING, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public UidContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_uid; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUid(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUid(this); + } + } + + public final UidContext uid() throws RecognitionException { + UidContext _localctx = new UidContext(_ctx, getState()); + enterRule(_localctx, 584, RULE_uid); + try { + setState(6385); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case ID: + enterOuterAlt(_localctx, 1); + { + setState(6382); + simpleId(); + } + break; + case CHARSET_REVERSE_QOUTE_STRING: + enterOuterAlt(_localctx, 2); + { + setState(6383); + match(CHARSET_REVERSE_QOUTE_STRING); + } + break; + case STRING_LITERAL: + enterOuterAlt(_localctx, 3); + { + setState(6384); + match(STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SimpleIdContext extends ParserRuleContext { + public TerminalNode ID() { return getToken(MySqlParser.ID, 0); } + public CharsetNameBaseContext charsetNameBase() { + return getRuleContext(CharsetNameBaseContext.class,0); + } + public TransactionLevelBaseContext transactionLevelBase() { + return getRuleContext(TransactionLevelBaseContext.class,0); + } + public EngineNameBaseContext engineNameBase() { + return getRuleContext(EngineNameBaseContext.class,0); + } + public PrivilegesBaseContext privilegesBase() { + return getRuleContext(PrivilegesBaseContext.class,0); + } + public IntervalTypeBaseContext intervalTypeBase() { + return getRuleContext(IntervalTypeBaseContext.class,0); + } + public DataTypeBaseContext dataTypeBase() { + return getRuleContext(DataTypeBaseContext.class,0); + } + public KeywordsCanBeIdContext keywordsCanBeId() { + return getRuleContext(KeywordsCanBeIdContext.class,0); + } + public ScalarFunctionNameContext scalarFunctionName() { + return getRuleContext(ScalarFunctionNameContext.class,0); + } + public SimpleIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleId; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleId(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleId(this); + } + } + + public final SimpleIdContext simpleId() throws RecognitionException { + SimpleIdContext _localctx = new SimpleIdContext(_ctx, getState()); + enterRule(_localctx, 586, RULE_simpleId); + try { + setState(6396); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,938,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6387); + match(ID); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6388); + charsetNameBase(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6389); + transactionLevelBase(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6390); + engineNameBase(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(6391); + privilegesBase(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(6392); + intervalTypeBase(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(6393); + dataTypeBase(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(6394); + keywordsCanBeId(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(6395); + scalarFunctionName(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DottedIdContext extends ParserRuleContext { + public TerminalNode DOT_ID() { return getToken(MySqlParser.DOT_ID, 0); } + public TerminalNode DOT() { return getToken(MySqlParser.DOT, 0); } + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public DottedIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dottedId; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDottedId(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDottedId(this); + } + } + + public final DottedIdContext dottedId() throws RecognitionException { + DottedIdContext _localctx = new DottedIdContext(_ctx, getState()); + enterRule(_localctx, 588, RULE_dottedId); + try { + setState(6401); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT_ID: + enterOuterAlt(_localctx, 1); + { + setState(6398); + match(DOT_ID); + } + break; + case DOT: + enterOuterAlt(_localctx, 2); + { + setState(6399); + match(DOT); + setState(6400); + uid(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DecimalLiteralContext extends ParserRuleContext { + public TerminalNode DECIMAL_LITERAL() { return getToken(MySqlParser.DECIMAL_LITERAL, 0); } + public TerminalNode ZERO_DECIMAL() { return getToken(MySqlParser.ZERO_DECIMAL, 0); } + public TerminalNode ONE_DECIMAL() { return getToken(MySqlParser.ONE_DECIMAL, 0); } + public TerminalNode TWO_DECIMAL() { return getToken(MySqlParser.TWO_DECIMAL, 0); } + public TerminalNode REAL_LITERAL() { return getToken(MySqlParser.REAL_LITERAL, 0); } + public DecimalLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decimalLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDecimalLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDecimalLiteral(this); + } + } + + public final DecimalLiteralContext decimalLiteral() throws RecognitionException { + DecimalLiteralContext _localctx = new DecimalLiteralContext(_ctx, getState()); + enterRule(_localctx, 590, RULE_decimalLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6403); + _la = _input.LA(1); + if ( !(((((_la - 1139)) & ~0x3f) == 0 && ((1L << (_la - 1139)) & 10247L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FileSizeLiteralContext extends ParserRuleContext { + public TerminalNode FILESIZE_LITERAL() { return getToken(MySqlParser.FILESIZE_LITERAL, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public FileSizeLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fileSizeLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFileSizeLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFileSizeLiteral(this); + } + } + + public final FileSizeLiteralContext fileSizeLiteral() throws RecognitionException { + FileSizeLiteralContext _localctx = new FileSizeLiteralContext(_ctx, getState()); + enterRule(_localctx, 592, RULE_fileSizeLiteral); + try { + setState(6407); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FILESIZE_LITERAL: + enterOuterAlt(_localctx, 1); + { + setState(6405); + match(FILESIZE_LITERAL); + } + break; + case ZERO_DECIMAL: + case ONE_DECIMAL: + case TWO_DECIMAL: + case DECIMAL_LITERAL: + case REAL_LITERAL: + enterOuterAlt(_localctx, 2); + { + setState(6406); + decimalLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StringLiteralContext extends ParserRuleContext { + public List STRING_LITERAL() { return getTokens(MySqlParser.STRING_LITERAL); } + public TerminalNode STRING_LITERAL(int i) { + return getToken(MySqlParser.STRING_LITERAL, i); + } + public TerminalNode START_NATIONAL_STRING_LITERAL() { return getToken(MySqlParser.START_NATIONAL_STRING_LITERAL, 0); } + public TerminalNode STRING_CHARSET_NAME() { return getToken(MySqlParser.STRING_CHARSET_NAME, 0); } + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public StringLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stringLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStringLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStringLiteral(this); + } + } + + public final StringLiteralContext stringLiteral() throws RecognitionException { + StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState()); + enterRule(_localctx, 594, RULE_stringLiteral); + int _la; + try { + int _alt; + setState(6432); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,947,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6414); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING_LITERAL: + case STRING_CHARSET_NAME: + { + setState(6410); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STRING_CHARSET_NAME) { + { + setState(6409); + match(STRING_CHARSET_NAME); + } + } + + setState(6412); + match(STRING_LITERAL); + } + break; + case START_NATIONAL_STRING_LITERAL: + { + setState(6413); + match(START_NATIONAL_STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(6417); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(6416); + match(STRING_LITERAL); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(6419); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,943,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6426); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING_LITERAL: + case STRING_CHARSET_NAME: + { + setState(6422); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STRING_CHARSET_NAME) { + { + setState(6421); + match(STRING_CHARSET_NAME); + } + } + + setState(6424); + match(STRING_LITERAL); + } + break; + case START_NATIONAL_STRING_LITERAL: + { + setState(6425); + match(START_NATIONAL_STRING_LITERAL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(6430); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,946,_ctx) ) { + case 1: + { + setState(6428); + match(COLLATE); + setState(6429); + collationName(); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BooleanLiteralContext extends ParserRuleContext { + public TerminalNode TRUE() { return getToken(MySqlParser.TRUE, 0); } + public TerminalNode FALSE() { return getToken(MySqlParser.FALSE, 0); } + public BooleanLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_booleanLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBooleanLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBooleanLiteral(this); + } + } + + public final BooleanLiteralContext booleanLiteral() throws RecognitionException { + BooleanLiteralContext _localctx = new BooleanLiteralContext(_ctx, getState()); + enterRule(_localctx, 596, RULE_booleanLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6434); + _la = _input.LA(1); + if ( !(_la==FALSE || _la==TRUE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HexadecimalLiteralContext extends ParserRuleContext { + public TerminalNode HEXADECIMAL_LITERAL() { return getToken(MySqlParser.HEXADECIMAL_LITERAL, 0); } + public TerminalNode STRING_CHARSET_NAME() { return getToken(MySqlParser.STRING_CHARSET_NAME, 0); } + public HexadecimalLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hexadecimalLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterHexadecimalLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitHexadecimalLiteral(this); + } + } + + public final HexadecimalLiteralContext hexadecimalLiteral() throws RecognitionException { + HexadecimalLiteralContext _localctx = new HexadecimalLiteralContext(_ctx, getState()); + enterRule(_localctx, 598, RULE_hexadecimalLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6437); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STRING_CHARSET_NAME) { + { + setState(6436); + match(STRING_CHARSET_NAME); + } + } + + setState(6439); + match(HEXADECIMAL_LITERAL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NullNotnullContext extends ParserRuleContext { + public TerminalNode NULL_LITERAL() { return getToken(MySqlParser.NULL_LITERAL, 0); } + public TerminalNode NULL_SPEC_LITERAL() { return getToken(MySqlParser.NULL_SPEC_LITERAL, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public NullNotnullContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nullNotnull; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNullNotnull(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNullNotnull(this); + } + } + + public final NullNotnullContext nullNotnull() throws RecognitionException { + NullNotnullContext _localctx = new NullNotnullContext(_ctx, getState()); + enterRule(_localctx, 600, RULE_nullNotnull); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6442); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(6441); + match(NOT); + } + } + + setState(6444); + _la = _input.LA(1); + if ( !(_la==NULL_LITERAL || _la==NULL_SPEC_LITERAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstantContext extends ParserRuleContext { + public Token nullLiteral; + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode MINUS() { return getToken(MySqlParser.MINUS, 0); } + public HexadecimalLiteralContext hexadecimalLiteral() { + return getRuleContext(HexadecimalLiteralContext.class,0); + } + public BooleanLiteralContext booleanLiteral() { + return getRuleContext(BooleanLiteralContext.class,0); + } + public TerminalNode REAL_LITERAL() { return getToken(MySqlParser.REAL_LITERAL, 0); } + public TerminalNode BIT_STRING() { return getToken(MySqlParser.BIT_STRING, 0); } + public TerminalNode NULL_LITERAL() { return getToken(MySqlParser.NULL_LITERAL, 0); } + public TerminalNode NULL_SPEC_LITERAL() { return getToken(MySqlParser.NULL_SPEC_LITERAL, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public ConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constant; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterConstant(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitConstant(this); + } + } + + public final ConstantContext constant() throws RecognitionException { + ConstantContext _localctx = new ConstantContext(_ctx, getState()); + enterRule(_localctx, 602, RULE_constant); + int _la; + try { + setState(6458); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,951,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6446); + stringLiteral(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6447); + decimalLiteral(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6448); + match(MINUS); + setState(6449); + decimalLiteral(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6450); + hexadecimalLiteral(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(6451); + booleanLiteral(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(6452); + match(REAL_LITERAL); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(6453); + match(BIT_STRING); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(6455); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(6454); + match(NOT); + } + } + + setState(6457); + ((ConstantContext)_localctx).nullLiteral = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==NULL_LITERAL || _la==NULL_SPEC_LITERAL) ) { + ((ConstantContext)_localctx).nullLiteral = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DataTypeContext extends ParserRuleContext { + public DataTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dataType; } + + public DataTypeContext() { } + public void copyFrom(DataTypeContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SpatialDataTypeContext extends DataTypeContext { + public Token typeName; + public TerminalNode GEOMETRYCOLLECTION() { return getToken(MySqlParser.GEOMETRYCOLLECTION, 0); } + public TerminalNode GEOMCOLLECTION() { return getToken(MySqlParser.GEOMCOLLECTION, 0); } + public TerminalNode LINESTRING() { return getToken(MySqlParser.LINESTRING, 0); } + public TerminalNode MULTILINESTRING() { return getToken(MySqlParser.MULTILINESTRING, 0); } + public TerminalNode MULTIPOINT() { return getToken(MySqlParser.MULTIPOINT, 0); } + public TerminalNode MULTIPOLYGON() { return getToken(MySqlParser.MULTIPOLYGON, 0); } + public TerminalNode POINT() { return getToken(MySqlParser.POINT, 0); } + public TerminalNode POLYGON() { return getToken(MySqlParser.POLYGON, 0); } + public TerminalNode JSON() { return getToken(MySqlParser.JSON, 0); } + public TerminalNode GEOMETRY() { return getToken(MySqlParser.GEOMETRY, 0); } + public TerminalNode SRID() { return getToken(MySqlParser.SRID, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public SpatialDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSpatialDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSpatialDataType(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class LongVarbinaryDataTypeContext extends DataTypeContext { + public TerminalNode LONG() { return getToken(MySqlParser.LONG, 0); } + public TerminalNode VARBINARY() { return getToken(MySqlParser.VARBINARY, 0); } + public LongVarbinaryDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLongVarbinaryDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLongVarbinaryDataType(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CollectionDataTypeContext extends DataTypeContext { + public Token typeName; + public CollectionOptionsContext collectionOptions() { + return getRuleContext(CollectionOptionsContext.class,0); + } + public TerminalNode ENUM() { return getToken(MySqlParser.ENUM, 0); } + public TerminalNode SET() { return getToken(MySqlParser.SET, 0); } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public CharSetContext charSet() { + return getRuleContext(CharSetContext.class,0); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public CollectionDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCollectionDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCollectionDataType(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NationalVaryingStringDataTypeContext extends DataTypeContext { + public Token typeName; + public TerminalNode NATIONAL() { return getToken(MySqlParser.NATIONAL, 0); } + public TerminalNode VARYING() { return getToken(MySqlParser.VARYING, 0); } + public TerminalNode CHAR() { return getToken(MySqlParser.CHAR, 0); } + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public LengthOneDimensionContext lengthOneDimension() { + return getRuleContext(LengthOneDimensionContext.class,0); + } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public NationalVaryingStringDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNationalVaryingStringDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNationalVaryingStringDataType(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DimensionDataTypeContext extends DataTypeContext { + public Token typeName; + public TerminalNode TINYINT() { return getToken(MySqlParser.TINYINT, 0); } + public TerminalNode SMALLINT() { return getToken(MySqlParser.SMALLINT, 0); } + public TerminalNode MEDIUMINT() { return getToken(MySqlParser.MEDIUMINT, 0); } + public TerminalNode INT() { return getToken(MySqlParser.INT, 0); } + public TerminalNode INTEGER() { return getToken(MySqlParser.INTEGER, 0); } + public TerminalNode BIGINT() { return getToken(MySqlParser.BIGINT, 0); } + public TerminalNode MIDDLEINT() { return getToken(MySqlParser.MIDDLEINT, 0); } + public TerminalNode INT1() { return getToken(MySqlParser.INT1, 0); } + public TerminalNode INT2() { return getToken(MySqlParser.INT2, 0); } + public TerminalNode INT3() { return getToken(MySqlParser.INT3, 0); } + public TerminalNode INT4() { return getToken(MySqlParser.INT4, 0); } + public TerminalNode INT8() { return getToken(MySqlParser.INT8, 0); } + public LengthOneDimensionContext lengthOneDimension() { + return getRuleContext(LengthOneDimensionContext.class,0); + } + public List SIGNED() { return getTokens(MySqlParser.SIGNED); } + public TerminalNode SIGNED(int i) { + return getToken(MySqlParser.SIGNED, i); + } + public List UNSIGNED() { return getTokens(MySqlParser.UNSIGNED); } + public TerminalNode UNSIGNED(int i) { + return getToken(MySqlParser.UNSIGNED, i); + } + public List ZEROFILL() { return getTokens(MySqlParser.ZEROFILL); } + public TerminalNode ZEROFILL(int i) { + return getToken(MySqlParser.ZEROFILL, i); + } + public TerminalNode REAL() { return getToken(MySqlParser.REAL, 0); } + public LengthTwoDimensionContext lengthTwoDimension() { + return getRuleContext(LengthTwoDimensionContext.class,0); + } + public TerminalNode DOUBLE() { return getToken(MySqlParser.DOUBLE, 0); } + public TerminalNode PRECISION() { return getToken(MySqlParser.PRECISION, 0); } + public TerminalNode DECIMAL() { return getToken(MySqlParser.DECIMAL, 0); } + public TerminalNode DEC() { return getToken(MySqlParser.DEC, 0); } + public TerminalNode FIXED() { return getToken(MySqlParser.FIXED, 0); } + public TerminalNode NUMERIC() { return getToken(MySqlParser.NUMERIC, 0); } + public TerminalNode FLOAT() { return getToken(MySqlParser.FLOAT, 0); } + public TerminalNode FLOAT4() { return getToken(MySqlParser.FLOAT4, 0); } + public TerminalNode FLOAT8() { return getToken(MySqlParser.FLOAT8, 0); } + public LengthTwoOptionalDimensionContext lengthTwoOptionalDimension() { + return getRuleContext(LengthTwoOptionalDimensionContext.class,0); + } + public TerminalNode BIT() { return getToken(MySqlParser.BIT, 0); } + public TerminalNode TIME() { return getToken(MySqlParser.TIME, 0); } + public TerminalNode TIMESTAMP() { return getToken(MySqlParser.TIMESTAMP, 0); } + public TerminalNode DATETIME() { return getToken(MySqlParser.DATETIME, 0); } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public TerminalNode VARBINARY() { return getToken(MySqlParser.VARBINARY, 0); } + public TerminalNode BLOB() { return getToken(MySqlParser.BLOB, 0); } + public TerminalNode YEAR() { return getToken(MySqlParser.YEAR, 0); } + public DimensionDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDimensionDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDimensionDataType(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class StringDataTypeContext extends DataTypeContext { + public Token typeName; + public TerminalNode CHAR() { return getToken(MySqlParser.CHAR, 0); } + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public TerminalNode VARCHAR() { return getToken(MySqlParser.VARCHAR, 0); } + public TerminalNode TINYTEXT() { return getToken(MySqlParser.TINYTEXT, 0); } + public TerminalNode TEXT() { return getToken(MySqlParser.TEXT, 0); } + public TerminalNode MEDIUMTEXT() { return getToken(MySqlParser.MEDIUMTEXT, 0); } + public TerminalNode LONGTEXT() { return getToken(MySqlParser.LONGTEXT, 0); } + public TerminalNode NCHAR() { return getToken(MySqlParser.NCHAR, 0); } + public TerminalNode NVARCHAR() { return getToken(MySqlParser.NVARCHAR, 0); } + public TerminalNode LONG() { return getToken(MySqlParser.LONG, 0); } + public TerminalNode VARYING() { return getToken(MySqlParser.VARYING, 0); } + public LengthOneDimensionContext lengthOneDimension() { + return getRuleContext(LengthOneDimensionContext.class,0); + } + public List BINARY() { return getTokens(MySqlParser.BINARY); } + public TerminalNode BINARY(int i) { + return getToken(MySqlParser.BINARY, i); + } + public CharSetContext charSet() { + return getRuleContext(CharSetContext.class,0); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public StringDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterStringDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitStringDataType(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class LongVarcharDataTypeContext extends DataTypeContext { + public Token typeName; + public TerminalNode LONG() { return getToken(MySqlParser.LONG, 0); } + public TerminalNode VARCHAR() { return getToken(MySqlParser.VARCHAR, 0); } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public CharSetContext charSet() { + return getRuleContext(CharSetContext.class,0); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public LongVarcharDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLongVarcharDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLongVarcharDataType(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NationalStringDataTypeContext extends DataTypeContext { + public Token typeName; + public TerminalNode NATIONAL() { return getToken(MySqlParser.NATIONAL, 0); } + public TerminalNode VARCHAR() { return getToken(MySqlParser.VARCHAR, 0); } + public TerminalNode CHARACTER() { return getToken(MySqlParser.CHARACTER, 0); } + public TerminalNode CHAR() { return getToken(MySqlParser.CHAR, 0); } + public LengthOneDimensionContext lengthOneDimension() { + return getRuleContext(LengthOneDimensionContext.class,0); + } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public TerminalNode NCHAR() { return getToken(MySqlParser.NCHAR, 0); } + public NationalStringDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNationalStringDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNationalStringDataType(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SimpleDataTypeContext extends DataTypeContext { + public Token typeName; + public TerminalNode DATE() { return getToken(MySqlParser.DATE, 0); } + public TerminalNode TINYBLOB() { return getToken(MySqlParser.TINYBLOB, 0); } + public TerminalNode MEDIUMBLOB() { return getToken(MySqlParser.MEDIUMBLOB, 0); } + public TerminalNode LONGBLOB() { return getToken(MySqlParser.LONGBLOB, 0); } + public TerminalNode BOOL() { return getToken(MySqlParser.BOOL, 0); } + public TerminalNode BOOLEAN() { return getToken(MySqlParser.BOOLEAN, 0); } + public TerminalNode SERIAL() { return getToken(MySqlParser.SERIAL, 0); } + public SimpleDataTypeContext(DataTypeContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleDataType(this); + } + } + + public final DataTypeContext dataType() throws RecognitionException { + DataTypeContext _localctx = new DataTypeContext(_ctx, getState()); + enterRule(_localctx, 604, RULE_dataType); + int _la; + try { + int _alt; + setState(6586); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,980,_ctx) ) { + case 1: + _localctx = new StringDataTypeContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(6460); + ((StringDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CHARACTER || ((((_la - 223)) & ~0x3f) == 0 && ((1L << (_la - 223)) & 31239L) != 0) || _la==NCHAR) ) { + ((StringDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6462); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VARYING) { + { + setState(6461); + match(VARYING); + } + } + + setState(6465); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,953,_ctx) ) { + case 1: + { + setState(6464); + lengthOneDimension(); + } + break; + } + setState(6468); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,954,_ctx) ) { + case 1: + { + setState(6467); + match(BINARY); + } + break; + } + setState(6473); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,955,_ctx) ) { + case 1: + { + setState(6470); + charSet(); + setState(6471); + charsetName(); + } + break; + } + setState(6478); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,956,_ctx) ) { + case 1: + { + setState(6475); + match(COLLATE); + setState(6476); + collationName(); + } + break; + case 2: + { + setState(6477); + match(BINARY); + } + break; + } + } + break; + case 2: + _localctx = new NationalVaryingStringDataTypeContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(6480); + match(NATIONAL); + setState(6481); + ((NationalVaryingStringDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CHARACTER || _la==CHAR) ) { + ((NationalVaryingStringDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6482); + match(VARYING); + setState(6484); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,957,_ctx) ) { + case 1: + { + setState(6483); + lengthOneDimension(); + } + break; + } + setState(6487); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,958,_ctx) ) { + case 1: + { + setState(6486); + match(BINARY); + } + break; + } + } + break; + case 3: + _localctx = new NationalStringDataTypeContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(6489); + match(NATIONAL); + setState(6490); + ((NationalStringDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CHARACTER || _la==CHAR || _la==VARCHAR) ) { + ((NationalStringDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6492); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,959,_ctx) ) { + case 1: + { + setState(6491); + lengthOneDimension(); + } + break; + } + setState(6495); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,960,_ctx) ) { + case 1: + { + setState(6494); + match(BINARY); + } + break; + } + } + break; + case 4: + _localctx = new NationalStringDataTypeContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(6497); + match(NCHAR); + setState(6498); + ((NationalStringDataTypeContext)_localctx).typeName = match(VARCHAR); + setState(6500); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,961,_ctx) ) { + case 1: + { + setState(6499); + lengthOneDimension(); + } + break; + } + setState(6503); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,962,_ctx) ) { + case 1: + { + setState(6502); + match(BINARY); + } + break; + } + } + break; + case 5: + _localctx = new DimensionDataTypeContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(6505); + ((DimensionDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 197)) & ~0x3f) == 0 && ((1L << (_la - 197)) & 4095L) != 0)) ) { + ((DimensionDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6507); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,963,_ctx) ) { + case 1: + { + setState(6506); + lengthOneDimension(); + } + break; + } + setState(6512); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,964,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(6509); + _la = _input.LA(1); + if ( !(_la==UNSIGNED || _la==ZEROFILL || _la==SIGNED) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + } + setState(6514); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,964,_ctx); + } + } + break; + case 6: + _localctx = new DimensionDataTypeContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(6515); + ((DimensionDataTypeContext)_localctx).typeName = match(REAL); + setState(6517); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,965,_ctx) ) { + case 1: + { + setState(6516); + lengthTwoDimension(); + } + break; + } + setState(6522); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,966,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(6519); + _la = _input.LA(1); + if ( !(_la==UNSIGNED || _la==ZEROFILL || _la==SIGNED) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + } + setState(6524); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,966,_ctx); + } + } + break; + case 7: + _localctx = new DimensionDataTypeContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(6525); + ((DimensionDataTypeContext)_localctx).typeName = match(DOUBLE); + setState(6527); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PRECISION) { + { + setState(6526); + match(PRECISION); + } + } + + setState(6530); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,968,_ctx) ) { + case 1: + { + setState(6529); + lengthTwoDimension(); + } + break; + } + setState(6535); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,969,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(6532); + _la = _input.LA(1); + if ( !(_la==UNSIGNED || _la==ZEROFILL || _la==SIGNED) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + } + setState(6537); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,969,_ctx); + } + } + break; + case 8: + _localctx = new DimensionDataTypeContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(6538); + ((DimensionDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 212)) & ~0x3f) == 0 && ((1L << (_la - 212)) & 63L) != 0) || _la==FIXED) ) { + ((DimensionDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6540); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,970,_ctx) ) { + case 1: + { + setState(6539); + lengthTwoOptionalDimension(); + } + break; + } + setState(6545); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,971,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(6542); + _la = _input.LA(1); + if ( !(_la==UNSIGNED || _la==ZEROFILL || _la==SIGNED) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + } + setState(6547); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,971,_ctx); + } + } + break; + case 9: + _localctx = new SimpleDataTypeContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(6548); + ((SimpleDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & 4237313L) != 0) || _la==BOOL || _la==BOOLEAN) ) { + ((SimpleDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 10: + _localctx = new DimensionDataTypeContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(6549); + ((DimensionDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 219)) & ~0x3f) == 0 && ((1L << (_la - 219)) & 2831L) != 0) || _la==BIT) ) { + ((DimensionDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6551); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,972,_ctx) ) { + case 1: + { + setState(6550); + lengthOneDimension(); + } + break; + } + } + break; + case 11: + _localctx = new CollectionDataTypeContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(6553); + ((CollectionDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==SET || _la==ENUM) ) { + ((CollectionDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6554); + collectionOptions(); + setState(6556); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,973,_ctx) ) { + case 1: + { + setState(6555); + match(BINARY); + } + break; + } + setState(6561); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,974,_ctx) ) { + case 1: + { + setState(6558); + charSet(); + setState(6559); + charsetName(); + } + break; + } + } + break; + case 12: + _localctx = new SpatialDataTypeContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(6563); + ((SpatialDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==JSON || ((((_la - 804)) & ~0x3f) == 0 && ((1L << (_la - 804)) & 511L) != 0)) ) { + ((SpatialDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6566); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,975,_ctx) ) { + case 1: + { + setState(6564); + match(SRID); + setState(6565); + decimalLiteral(); + } + break; + } + } + break; + case 13: + _localctx = new LongVarcharDataTypeContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(6568); + ((LongVarcharDataTypeContext)_localctx).typeName = match(LONG); + setState(6570); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VARCHAR) { + { + setState(6569); + match(VARCHAR); + } + } + + setState(6573); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,977,_ctx) ) { + case 1: + { + setState(6572); + match(BINARY); + } + break; + } + setState(6578); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,978,_ctx) ) { + case 1: + { + setState(6575); + charSet(); + setState(6576); + charsetName(); + } + break; + } + setState(6582); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,979,_ctx) ) { + case 1: + { + setState(6580); + match(COLLATE); + setState(6581); + collationName(); + } + break; + } + } + break; + case 14: + _localctx = new LongVarbinaryDataTypeContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(6584); + match(LONG); + setState(6585); + match(VARBINARY); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CollectionOptionsContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List STRING_LITERAL() { return getTokens(MySqlParser.STRING_LITERAL); } + public TerminalNode STRING_LITERAL(int i) { + return getToken(MySqlParser.STRING_LITERAL, i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public CollectionOptionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_collectionOptions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCollectionOptions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCollectionOptions(this); + } + } + + public final CollectionOptionsContext collectionOptions() throws RecognitionException { + CollectionOptionsContext _localctx = new CollectionOptionsContext(_ctx, getState()); + enterRule(_localctx, 606, RULE_collectionOptions); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6588); + match(LR_BRACKET); + setState(6589); + match(STRING_LITERAL); + setState(6594); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6590); + match(COMMA); + setState(6591); + match(STRING_LITERAL); + } + } + setState(6596); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(6597); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConvertedDataTypeContext extends ParserRuleContext { + public Token typeName; + public TerminalNode CHAR() { return getToken(MySqlParser.CHAR, 0); } + public TerminalNode SIGNED() { return getToken(MySqlParser.SIGNED, 0); } + public TerminalNode UNSIGNED() { return getToken(MySqlParser.UNSIGNED, 0); } + public TerminalNode ARRAY() { return getToken(MySqlParser.ARRAY, 0); } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public TerminalNode NCHAR() { return getToken(MySqlParser.NCHAR, 0); } + public TerminalNode FLOAT() { return getToken(MySqlParser.FLOAT, 0); } + public TerminalNode DATE() { return getToken(MySqlParser.DATE, 0); } + public TerminalNode DATETIME() { return getToken(MySqlParser.DATETIME, 0); } + public TerminalNode TIME() { return getToken(MySqlParser.TIME, 0); } + public TerminalNode YEAR() { return getToken(MySqlParser.YEAR, 0); } + public TerminalNode JSON() { return getToken(MySqlParser.JSON, 0); } + public TerminalNode INT() { return getToken(MySqlParser.INT, 0); } + public TerminalNode INTEGER() { return getToken(MySqlParser.INTEGER, 0); } + public TerminalNode DOUBLE() { return getToken(MySqlParser.DOUBLE, 0); } + public TerminalNode DECIMAL() { return getToken(MySqlParser.DECIMAL, 0); } + public TerminalNode DEC() { return getToken(MySqlParser.DEC, 0); } + public LengthOneDimensionContext lengthOneDimension() { + return getRuleContext(LengthOneDimensionContext.class,0); + } + public CharSetContext charSet() { + return getRuleContext(CharSetContext.class,0); + } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public LengthTwoOptionalDimensionContext lengthTwoOptionalDimension() { + return getRuleContext(LengthTwoOptionalDimensionContext.class,0); + } + public ConvertedDataTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_convertedDataType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterConvertedDataType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitConvertedDataType(this); + } + } + + public final ConvertedDataTypeContext convertedDataType() throws RecognitionException { + ConvertedDataTypeContext _localctx = new ConvertedDataTypeContext(_ctx, getState()); + enterRule(_localctx, 608, RULE_convertedDataType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6621); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FLOAT: + case BINARY: + case NCHAR: + { + setState(6599); + ((ConvertedDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FLOAT || _la==BINARY || _la==NCHAR) ) { + ((ConvertedDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6601); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(6600); + lengthOneDimension(); + } + } + + } + break; + case CHAR: + { + setState(6603); + ((ConvertedDataTypeContext)_localctx).typeName = match(CHAR); + setState(6605); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(6604); + lengthOneDimension(); + } + } + + setState(6610); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CHARACTER || _la==CHAR || _la==CHARSET) { + { + setState(6607); + charSet(); + setState(6608); + charsetName(); + } + } + + } + break; + case INT: + case INTEGER: + case DOUBLE: + case DATE: + case TIME: + case DATETIME: + case YEAR: + case JSON: + { + setState(6612); + ((ConvertedDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 201)) & ~0x3f) == 0 && ((1L << (_la - 201)) & 3539521L) != 0) || _la==JSON) ) { + ((ConvertedDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case DECIMAL: + case DEC: + { + setState(6613); + ((ConvertedDataTypeContext)_localctx).typeName = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==DECIMAL || _la==DEC) ) { + ((ConvertedDataTypeContext)_localctx).typeName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6615); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LR_BRACKET) { + { + setState(6614); + lengthTwoOptionalDimension(); + } + } + + } + break; + case UNSIGNED: + case SIGNED: + { + setState(6617); + _la = _input.LA(1); + if ( !(_la==UNSIGNED || _la==SIGNED) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6619); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INT || _la==INTEGER) { + { + setState(6618); + _la = _input.LA(1); + if ( !(_la==INT || _la==INTEGER) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + setState(6624); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ARRAY) { + { + setState(6623); + match(ARRAY); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LengthOneDimensionContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public LengthOneDimensionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lengthOneDimension; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLengthOneDimension(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLengthOneDimension(this); + } + } + + public final LengthOneDimensionContext lengthOneDimension() throws RecognitionException { + LengthOneDimensionContext _localctx = new LengthOneDimensionContext(_ctx, getState()); + enterRule(_localctx, 610, RULE_lengthOneDimension); + try { + enterOuterAlt(_localctx, 1); + { + setState(6626); + match(LR_BRACKET); + setState(6627); + decimalLiteral(); + setState(6628); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LengthTwoDimensionContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public LengthTwoDimensionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lengthTwoDimension; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLengthTwoDimension(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLengthTwoDimension(this); + } + } + + public final LengthTwoDimensionContext lengthTwoDimension() throws RecognitionException { + LengthTwoDimensionContext _localctx = new LengthTwoDimensionContext(_ctx, getState()); + enterRule(_localctx, 612, RULE_lengthTwoDimension); + try { + enterOuterAlt(_localctx, 1); + { + setState(6630); + match(LR_BRACKET); + setState(6631); + decimalLiteral(); + setState(6632); + match(COMMA); + setState(6633); + decimalLiteral(); + setState(6634); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LengthTwoOptionalDimensionContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public LengthTwoOptionalDimensionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lengthTwoOptionalDimension; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLengthTwoOptionalDimension(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLengthTwoOptionalDimension(this); + } + } + + public final LengthTwoOptionalDimensionContext lengthTwoOptionalDimension() throws RecognitionException { + LengthTwoOptionalDimensionContext _localctx = new LengthTwoOptionalDimensionContext(_ctx, getState()); + enterRule(_localctx, 614, RULE_lengthTwoOptionalDimension); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6636); + match(LR_BRACKET); + setState(6637); + decimalLiteral(); + setState(6640); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(6638); + match(COMMA); + setState(6639); + decimalLiteral(); + } + } + + setState(6642); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UidListContext extends ParserRuleContext { + public List uid() { + return getRuleContexts(UidContext.class); + } + public UidContext uid(int i) { + return getRuleContext(UidContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public UidListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_uidList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUidList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUidList(this); + } + } + + public final UidListContext uidList() throws RecognitionException { + UidListContext _localctx = new UidListContext(_ctx, getState()); + enterRule(_localctx, 616, RULE_uidList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(6644); + uid(); + setState(6649); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,990,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(6645); + match(COMMA); + setState(6646); + uid(); + } + } + } + setState(6651); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,990,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FullColumnNameListContext extends ParserRuleContext { + public List fullColumnName() { + return getRuleContexts(FullColumnNameContext.class); + } + public FullColumnNameContext fullColumnName(int i) { + return getRuleContext(FullColumnNameContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public FullColumnNameListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fullColumnNameList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFullColumnNameList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFullColumnNameList(this); + } + } + + public final FullColumnNameListContext fullColumnNameList() throws RecognitionException { + FullColumnNameListContext _localctx = new FullColumnNameListContext(_ctx, getState()); + enterRule(_localctx, 618, RULE_fullColumnNameList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6652); + fullColumnName(); + setState(6657); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6653); + match(COMMA); + setState(6654); + fullColumnName(); + } + } + setState(6659); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TablesContext extends ParserRuleContext { + public List tableName() { + return getRuleContexts(TableNameContext.class); + } + public TableNameContext tableName(int i) { + return getRuleContext(TableNameContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public TablesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tables; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTables(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTables(this); + } + } + + public final TablesContext tables() throws RecognitionException { + TablesContext _localctx = new TablesContext(_ctx, getState()); + enterRule(_localctx, 620, RULE_tables); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(6660); + tableName(); + setState(6665); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,992,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(6661); + match(COMMA); + setState(6662); + tableName(); + } + } + } + setState(6667); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,992,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexColumnNamesContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List indexColumnName() { + return getRuleContexts(IndexColumnNameContext.class); + } + public IndexColumnNameContext indexColumnName(int i) { + return getRuleContext(IndexColumnNameContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public IndexColumnNamesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexColumnNames; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIndexColumnNames(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIndexColumnNames(this); + } + } + + public final IndexColumnNamesContext indexColumnNames() throws RecognitionException { + IndexColumnNamesContext _localctx = new IndexColumnNamesContext(_ctx, getState()); + enterRule(_localctx, 622, RULE_indexColumnNames); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6668); + match(LR_BRACKET); + setState(6669); + indexColumnName(); + setState(6674); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6670); + match(COMMA); + setState(6671); + indexColumnName(); + } + } + setState(6676); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(6677); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionsContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public ExpressionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterExpressions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitExpressions(this); + } + } + + public final ExpressionsContext expressions() throws RecognitionException { + ExpressionsContext _localctx = new ExpressionsContext(_ctx, getState()); + enterRule(_localctx, 624, RULE_expressions); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6679); + expression(0); + setState(6684); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6680); + match(COMMA); + setState(6681); + expression(0); + } + } + setState(6686); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionsWithDefaultsContext extends ParserRuleContext { + public List expressionOrDefault() { + return getRuleContexts(ExpressionOrDefaultContext.class); + } + public ExpressionOrDefaultContext expressionOrDefault(int i) { + return getRuleContext(ExpressionOrDefaultContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public ExpressionsWithDefaultsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionsWithDefaults; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterExpressionsWithDefaults(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitExpressionsWithDefaults(this); + } + } + + public final ExpressionsWithDefaultsContext expressionsWithDefaults() throws RecognitionException { + ExpressionsWithDefaultsContext _localctx = new ExpressionsWithDefaultsContext(_ctx, getState()); + enterRule(_localctx, 626, RULE_expressionsWithDefaults); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6687); + expressionOrDefault(); + setState(6692); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6688); + match(COMMA); + setState(6689); + expressionOrDefault(); + } + } + setState(6694); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstantsContext extends ParserRuleContext { + public List constant() { + return getRuleContexts(ConstantContext.class); + } + public ConstantContext constant(int i) { + return getRuleContext(ConstantContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public ConstantsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constants; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterConstants(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitConstants(this); + } + } + + public final ConstantsContext constants() throws RecognitionException { + ConstantsContext _localctx = new ConstantsContext(_ctx, getState()); + enterRule(_localctx, 628, RULE_constants); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6695); + constant(); + setState(6700); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6696); + match(COMMA); + setState(6697); + constant(); + } + } + setState(6702); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SimpleStringsContext extends ParserRuleContext { + public List STRING_LITERAL() { return getTokens(MySqlParser.STRING_LITERAL); } + public TerminalNode STRING_LITERAL(int i) { + return getToken(MySqlParser.STRING_LITERAL, i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public SimpleStringsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleStrings; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleStrings(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleStrings(this); + } + } + + public final SimpleStringsContext simpleStrings() throws RecognitionException { + SimpleStringsContext _localctx = new SimpleStringsContext(_ctx, getState()); + enterRule(_localctx, 630, RULE_simpleStrings); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6703); + match(STRING_LITERAL); + setState(6708); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6704); + match(COMMA); + setState(6705); + match(STRING_LITERAL); + } + } + setState(6710); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UserVariablesContext extends ParserRuleContext { + public List LOCAL_ID() { return getTokens(MySqlParser.LOCAL_ID); } + public TerminalNode LOCAL_ID(int i) { + return getToken(MySqlParser.LOCAL_ID, i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public UserVariablesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_userVariables; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUserVariables(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUserVariables(this); + } + } + + public final UserVariablesContext userVariables() throws RecognitionException { + UserVariablesContext _localctx = new UserVariablesContext(_ctx, getState()); + enterRule(_localctx, 632, RULE_userVariables); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6711); + match(LOCAL_ID); + setState(6716); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6712); + match(COMMA); + setState(6713); + match(LOCAL_ID); + } + } + setState(6718); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DefaultValueContext extends ParserRuleContext { + public TerminalNode NULL_LITERAL() { return getToken(MySqlParser.NULL_LITERAL, 0); } + public TerminalNode CAST() { return getToken(MySqlParser.CAST, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public ConvertedDataTypeContext convertedDataType() { + return getRuleContext(ConvertedDataTypeContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public ConstantContext constant() { + return getRuleContext(ConstantContext.class,0); + } + public UnaryOperatorContext unaryOperator() { + return getRuleContext(UnaryOperatorContext.class,0); + } + public List currentTimestamp() { + return getRuleContexts(CurrentTimestampContext.class); + } + public CurrentTimestampContext currentTimestamp(int i) { + return getRuleContext(CurrentTimestampContext.class,i); + } + public TerminalNode ON() { return getToken(MySqlParser.ON, 0); } + public TerminalNode UPDATE() { return getToken(MySqlParser.UPDATE, 0); } + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public DefaultValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_defaultValue; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDefaultValue(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDefaultValue(this); + } + } + + public final DefaultValueContext defaultValue() throws RecognitionException { + DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState()); + enterRule(_localctx, 634, RULE_defaultValue); + try { + setState(6745); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1001,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6719); + match(NULL_LITERAL); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6720); + match(CAST); + setState(6721); + match(LR_BRACKET); + setState(6722); + expression(0); + setState(6723); + match(AS); + setState(6724); + convertedDataType(); + setState(6725); + match(RR_BRACKET); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6728); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,999,_ctx) ) { + case 1: + { + setState(6727); + unaryOperator(); + } + break; + } + setState(6730); + constant(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6731); + currentTimestamp(); + setState(6735); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1000,_ctx) ) { + case 1: + { + setState(6732); + match(ON); + setState(6733); + match(UPDATE); + setState(6734); + currentTimestamp(); + } + break; + } + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(6737); + match(LR_BRACKET); + setState(6738); + expression(0); + setState(6739); + match(RR_BRACKET); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(6741); + match(LR_BRACKET); + setState(6742); + fullId(); + setState(6743); + match(RR_BRACKET); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CurrentTimestampContext extends ParserRuleContext { + public TerminalNode NOW() { return getToken(MySqlParser.NOW, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode CURRENT_TIMESTAMP() { return getToken(MySqlParser.CURRENT_TIMESTAMP, 0); } + public TerminalNode LOCALTIME() { return getToken(MySqlParser.LOCALTIME, 0); } + public TerminalNode LOCALTIMESTAMP() { return getToken(MySqlParser.LOCALTIMESTAMP, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public CurrentTimestampContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_currentTimestamp; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCurrentTimestamp(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCurrentTimestamp(this); + } + } + + public final CurrentTimestampContext currentTimestamp() throws RecognitionException { + CurrentTimestampContext _localctx = new CurrentTimestampContext(_ctx, getState()); + enterRule(_localctx, 636, RULE_currentTimestamp); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6761); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CURRENT_TIMESTAMP: + case LOCALTIME: + case LOCALTIMESTAMP: + { + setState(6747); + _la = _input.LA(1); + if ( !(((((_la - 316)) & ~0x3f) == 0 && ((1L << (_la - 316)) & 131L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6753); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1003,_ctx) ) { + case 1: + { + setState(6748); + match(LR_BRACKET); + setState(6750); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 1139)) & ~0x3f) == 0 && ((1L << (_la - 1139)) & 10247L) != 0)) { + { + setState(6749); + decimalLiteral(); + } + } + + setState(6752); + match(RR_BRACKET); + } + break; + } + } + break; + case NOW: + { + setState(6755); + match(NOW); + setState(6756); + match(LR_BRACKET); + setState(6758); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 1139)) & ~0x3f) == 0 && ((1L << (_la - 1139)) & 10247L) != 0)) { + { + setState(6757); + decimalLiteral(); + } + } + + setState(6760); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionOrDefaultContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public ExpressionOrDefaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionOrDefault; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterExpressionOrDefault(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitExpressionOrDefault(this); + } + } + + public final ExpressionOrDefaultContext expressionOrDefault() throws RecognitionException { + ExpressionOrDefaultContext _localctx = new ExpressionOrDefaultContext(_ctx, getState()); + enterRule(_localctx, 638, RULE_expressionOrDefault); + try { + setState(6765); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1006,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6763); + expression(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6764); + match(DEFAULT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IfExistsContext extends ParserRuleContext { + public TerminalNode IF() { return getToken(MySqlParser.IF, 0); } + public TerminalNode EXISTS() { return getToken(MySqlParser.EXISTS, 0); } + public IfExistsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifExists; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIfExists(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIfExists(this); + } + } + + public final IfExistsContext ifExists() throws RecognitionException { + IfExistsContext _localctx = new IfExistsContext(_ctx, getState()); + enterRule(_localctx, 640, RULE_ifExists); + try { + enterOuterAlt(_localctx, 1); + { + setState(6767); + match(IF); + setState(6768); + match(EXISTS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IfNotExistsContext extends ParserRuleContext { + public TerminalNode IF() { return getToken(MySqlParser.IF, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(MySqlParser.EXISTS, 0); } + public IfNotExistsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifNotExists; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIfNotExists(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIfNotExists(this); + } + } + + public final IfNotExistsContext ifNotExists() throws RecognitionException { + IfNotExistsContext _localctx = new IfNotExistsContext(_ctx, getState()); + enterRule(_localctx, 642, RULE_ifNotExists); + try { + enterOuterAlt(_localctx, 1); + { + setState(6770); + match(IF); + setState(6771); + match(NOT); + setState(6772); + match(EXISTS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OrReplaceContext extends ParserRuleContext { + public TerminalNode OR() { return getToken(MySqlParser.OR, 0); } + public TerminalNode REPLACE() { return getToken(MySqlParser.REPLACE, 0); } + public OrReplaceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_orReplace; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterOrReplace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitOrReplace(this); + } + } + + public final OrReplaceContext orReplace() throws RecognitionException { + OrReplaceContext _localctx = new OrReplaceContext(_ctx, getState()); + enterRule(_localctx, 644, RULE_orReplace); + try { + enterOuterAlt(_localctx, 1); + { + setState(6774); + match(OR); + setState(6775); + match(REPLACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WaitNowaitClauseContext extends ParserRuleContext { + public TerminalNode WAIT() { return getToken(MySqlParser.WAIT, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode NOWAIT() { return getToken(MySqlParser.NOWAIT, 0); } + public WaitNowaitClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_waitNowaitClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWaitNowaitClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWaitNowaitClause(this); + } + } + + public final WaitNowaitClauseContext waitNowaitClause() throws RecognitionException { + WaitNowaitClauseContext _localctx = new WaitNowaitClauseContext(_ctx, getState()); + enterRule(_localctx, 646, RULE_waitNowaitClause); + try { + setState(6780); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WAIT: + enterOuterAlt(_localctx, 1); + { + setState(6777); + match(WAIT); + setState(6778); + decimalLiteral(); + } + break; + case NOWAIT: + enterOuterAlt(_localctx, 2); + { + setState(6779); + match(NOWAIT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionCallContext extends ParserRuleContext { + public FunctionCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionCall; } + + public FunctionCallContext() { } + public void copyFrom(FunctionCallContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SpecificFunctionCallContext extends FunctionCallContext { + public SpecificFunctionContext specificFunction() { + return getRuleContext(SpecificFunctionContext.class,0); + } + public SpecificFunctionCallContext(FunctionCallContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSpecificFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSpecificFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PasswordFunctionCallContext extends FunctionCallContext { + public PasswordFunctionClauseContext passwordFunctionClause() { + return getRuleContext(PasswordFunctionClauseContext.class,0); + } + public PasswordFunctionCallContext(FunctionCallContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPasswordFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPasswordFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UdfFunctionCallContext extends FunctionCallContext { + public FullIdContext fullId() { + return getRuleContext(FullIdContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public FunctionArgsContext functionArgs() { + return getRuleContext(FunctionArgsContext.class,0); + } + public UdfFunctionCallContext(FunctionCallContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUdfFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUdfFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NonAggregateFunctionCallContext extends FunctionCallContext { + public NonAggregateWindowedFunctionContext nonAggregateWindowedFunction() { + return getRuleContext(NonAggregateWindowedFunctionContext.class,0); + } + public NonAggregateFunctionCallContext(FunctionCallContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNonAggregateFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNonAggregateFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class AggregateFunctionCallContext extends FunctionCallContext { + public AggregateWindowedFunctionContext aggregateWindowedFunction() { + return getRuleContext(AggregateWindowedFunctionContext.class,0); + } + public AggregateFunctionCallContext(FunctionCallContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAggregateFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAggregateFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ScalarFunctionCallContext extends FunctionCallContext { + public ScalarFunctionNameContext scalarFunctionName() { + return getRuleContext(ScalarFunctionNameContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public FunctionArgsContext functionArgs() { + return getRuleContext(FunctionArgsContext.class,0); + } + public ScalarFunctionCallContext(FunctionCallContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterScalarFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitScalarFunctionCall(this); + } + } + + public final FunctionCallContext functionCall() throws RecognitionException { + FunctionCallContext _localctx = new FunctionCallContext(_ctx, getState()); + enterRule(_localctx, 648, RULE_functionCall); + try { + setState(6800); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1010,_ctx) ) { + case 1: + _localctx = new SpecificFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(6782); + specificFunction(); + } + break; + case 2: + _localctx = new AggregateFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(6783); + aggregateWindowedFunction(); + } + break; + case 3: + _localctx = new NonAggregateFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(6784); + nonAggregateWindowedFunction(); + } + break; + case 4: + _localctx = new ScalarFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(6785); + scalarFunctionName(); + setState(6786); + match(LR_BRACKET); + setState(6788); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1008,_ctx) ) { + case 1: + { + setState(6787); + functionArgs(); + } + break; + } + setState(6790); + match(RR_BRACKET); + } + break; + case 5: + _localctx = new UdfFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(6792); + fullId(); + setState(6793); + match(LR_BRACKET); + setState(6795); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1009,_ctx) ) { + case 1: + { + setState(6794); + functionArgs(); + } + break; + } + setState(6797); + match(RR_BRACKET); + } + break; + case 6: + _localctx = new PasswordFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(6799); + passwordFunctionClause(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SpecificFunctionContext extends ParserRuleContext { + public SpecificFunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_specificFunction; } + + public SpecificFunctionContext() { } + public void copyFrom(SpecificFunctionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PositionFunctionCallContext extends SpecificFunctionContext { + public StringLiteralContext positionString; + public ExpressionContext positionExpression; + public StringLiteralContext inString; + public ExpressionContext inExpression; + public TerminalNode POSITION() { return getToken(MySqlParser.POSITION, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List stringLiteral() { + return getRuleContexts(StringLiteralContext.class); + } + public StringLiteralContext stringLiteral(int i) { + return getRuleContext(StringLiteralContext.class,i); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public PositionFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPositionFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPositionFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class TrimFunctionCallContext extends SpecificFunctionContext { + public Token positioinForm; + public StringLiteralContext sourceString; + public ExpressionContext sourceExpression; + public StringLiteralContext fromString; + public ExpressionContext fromExpression; + public TerminalNode TRIM() { return getToken(MySqlParser.TRIM, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode BOTH() { return getToken(MySqlParser.BOTH, 0); } + public TerminalNode LEADING() { return getToken(MySqlParser.LEADING, 0); } + public TerminalNode TRAILING() { return getToken(MySqlParser.TRAILING, 0); } + public List stringLiteral() { + return getRuleContexts(StringLiteralContext.class); + } + public StringLiteralContext stringLiteral(int i) { + return getRuleContext(StringLiteralContext.class,i); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TrimFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTrimFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTrimFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class JsonValueFunctionCallContext extends SpecificFunctionContext { + public TerminalNode JSON_VALUE() { return getToken(MySqlParser.JSON_VALUE, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode RETURNING() { return getToken(MySqlParser.RETURNING, 0); } + public ConvertedDataTypeContext convertedDataType() { + return getRuleContext(ConvertedDataTypeContext.class,0); + } + public JsonOnEmptyContext jsonOnEmpty() { + return getRuleContext(JsonOnEmptyContext.class,0); + } + public JsonOnErrorContext jsonOnError() { + return getRuleContext(JsonOnErrorContext.class,0); + } + public JsonValueFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJsonValueFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJsonValueFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CaseFunctionCallContext extends SpecificFunctionContext { + public FunctionArgContext elseArg; + public TerminalNode CASE() { return getToken(MySqlParser.CASE, 0); } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public List caseFuncAlternative() { + return getRuleContexts(CaseFuncAlternativeContext.class); + } + public CaseFuncAlternativeContext caseFuncAlternative(int i) { + return getRuleContext(CaseFuncAlternativeContext.class,i); + } + public TerminalNode ELSE() { return getToken(MySqlParser.ELSE, 0); } + public FunctionArgContext functionArg() { + return getRuleContext(FunctionArgContext.class,0); + } + public CaseFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCaseFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCaseFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ExtractFunctionCallContext extends SpecificFunctionContext { + public StringLiteralContext sourceString; + public ExpressionContext sourceExpression; + public TerminalNode EXTRACT() { return getToken(MySqlParser.EXTRACT, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public IntervalTypeContext intervalType() { + return getRuleContext(IntervalTypeContext.class,0); + } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ExtractFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterExtractFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitExtractFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class DataTypeFunctionCallContext extends SpecificFunctionContext { + public Token separator; + public TerminalNode CONVERT() { return getToken(MySqlParser.CONVERT, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ConvertedDataTypeContext convertedDataType() { + return getRuleContext(ConvertedDataTypeContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public TerminalNode USING() { return getToken(MySqlParser.USING, 0); } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public TerminalNode CAST() { return getToken(MySqlParser.CAST, 0); } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public DataTypeFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDataTypeFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDataTypeFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ValuesFunctionCallContext extends SpecificFunctionContext { + public TerminalNode VALUES() { return getToken(MySqlParser.VALUES, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public FullColumnNameContext fullColumnName() { + return getRuleContext(FullColumnNameContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public ValuesFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterValuesFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitValuesFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CaseExpressionFunctionCallContext extends SpecificFunctionContext { + public FunctionArgContext elseArg; + public TerminalNode CASE() { return getToken(MySqlParser.CASE, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public List caseFuncAlternative() { + return getRuleContexts(CaseFuncAlternativeContext.class); + } + public CaseFuncAlternativeContext caseFuncAlternative(int i) { + return getRuleContext(CaseFuncAlternativeContext.class,i); + } + public TerminalNode ELSE() { return getToken(MySqlParser.ELSE, 0); } + public FunctionArgContext functionArg() { + return getRuleContext(FunctionArgContext.class,0); + } + public CaseExpressionFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCaseExpressionFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCaseExpressionFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CurrentUserContext extends SpecificFunctionContext { + public CurrentUserExpressionContext currentUserExpression() { + return getRuleContext(CurrentUserExpressionContext.class,0); + } + public CurrentUserContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCurrentUser(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCurrentUser(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SimpleFunctionCallContext extends SpecificFunctionContext { + public TerminalNode CURRENT_DATE() { return getToken(MySqlParser.CURRENT_DATE, 0); } + public TerminalNode CURRENT_TIME() { return getToken(MySqlParser.CURRENT_TIME, 0); } + public TerminalNode CURRENT_TIMESTAMP() { return getToken(MySqlParser.CURRENT_TIMESTAMP, 0); } + public TerminalNode LOCALTIME() { return getToken(MySqlParser.LOCALTIME, 0); } + public TerminalNode UTC_TIMESTAMP() { return getToken(MySqlParser.UTC_TIMESTAMP, 0); } + public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public SimpleFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSimpleFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSimpleFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CharFunctionCallContext extends SpecificFunctionContext { + public TerminalNode CHAR() { return getToken(MySqlParser.CHAR, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public FunctionArgsContext functionArgs() { + return getRuleContext(FunctionArgsContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode USING() { return getToken(MySqlParser.USING, 0); } + public CharsetNameContext charsetName() { + return getRuleContext(CharsetNameContext.class,0); + } + public CharFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCharFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCharFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class WeightFunctionCallContext extends SpecificFunctionContext { + public Token stringFormat; + public TerminalNode WEIGHT_STRING() { return getToken(MySqlParser.WEIGHT_STRING, 0); } + public List LR_BRACKET() { return getTokens(MySqlParser.LR_BRACKET); } + public TerminalNode LR_BRACKET(int i) { + return getToken(MySqlParser.LR_BRACKET, i); + } + public List RR_BRACKET() { return getTokens(MySqlParser.RR_BRACKET); } + public TerminalNode RR_BRACKET(int i) { + return getToken(MySqlParser.RR_BRACKET, i); + } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode AS() { return getToken(MySqlParser.AS, 0); } + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public LevelsInWeightStringContext levelsInWeightString() { + return getRuleContext(LevelsInWeightStringContext.class,0); + } + public TerminalNode CHAR() { return getToken(MySqlParser.CHAR, 0); } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public WeightFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWeightFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWeightFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class GetFormatFunctionCallContext extends SpecificFunctionContext { + public Token datetimeFormat; + public TerminalNode GET_FORMAT() { return getToken(MySqlParser.GET_FORMAT, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode COMMA() { return getToken(MySqlParser.COMMA, 0); } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode DATE() { return getToken(MySqlParser.DATE, 0); } + public TerminalNode TIME() { return getToken(MySqlParser.TIME, 0); } + public TerminalNode DATETIME() { return getToken(MySqlParser.DATETIME, 0); } + public GetFormatFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterGetFormatFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitGetFormatFunctionCall(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SubstrFunctionCallContext extends SpecificFunctionContext { + public StringLiteralContext sourceString; + public ExpressionContext sourceExpression; + public DecimalLiteralContext fromDecimal; + public ExpressionContext fromExpression; + public DecimalLiteralContext forDecimal; + public ExpressionContext forExpression; + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode FROM() { return getToken(MySqlParser.FROM, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode SUBSTR() { return getToken(MySqlParser.SUBSTR, 0); } + public TerminalNode SUBSTRING() { return getToken(MySqlParser.SUBSTRING, 0); } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public TerminalNode FOR() { return getToken(MySqlParser.FOR, 0); } + public SubstrFunctionCallContext(SpecificFunctionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubstrFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubstrFunctionCall(this); + } + } + + public final SpecificFunctionContext specificFunction() throws RecognitionException { + SpecificFunctionContext _localctx = new SpecificFunctionContext(_ctx, getState()); + enterRule(_localctx, 650, RULE_specificFunction); + int _la; + try { + setState(6981); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1034,_ctx) ) { + case 1: + _localctx = new SimpleFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(6802); + _la = _input.LA(1); + if ( !(_la==SCHEMA || ((((_la - 314)) & ~0x3f) == 0 && ((1L << (_la - 314)) & 262159L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6805); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1011,_ctx) ) { + case 1: + { + setState(6803); + match(LR_BRACKET); + setState(6804); + match(RR_BRACKET); + } + break; + } + } + break; + case 2: + _localctx = new CurrentUserContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(6807); + currentUserExpression(); + } + break; + case 3: + _localctx = new DataTypeFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(6808); + match(CONVERT); + setState(6809); + match(LR_BRACKET); + setState(6810); + expression(0); + setState(6811); + ((DataTypeFunctionCallContext)_localctx).separator = match(COMMA); + setState(6812); + convertedDataType(); + setState(6813); + match(RR_BRACKET); + } + break; + case 4: + _localctx = new DataTypeFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(6815); + match(CONVERT); + setState(6816); + match(LR_BRACKET); + setState(6817); + expression(0); + setState(6818); + match(USING); + setState(6819); + charsetName(); + setState(6820); + match(RR_BRACKET); + } + break; + case 5: + _localctx = new DataTypeFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(6822); + match(CAST); + setState(6823); + match(LR_BRACKET); + setState(6824); + expression(0); + setState(6825); + match(AS); + setState(6826); + convertedDataType(); + setState(6827); + match(RR_BRACKET); + } + break; + case 6: + _localctx = new ValuesFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(6829); + match(VALUES); + setState(6830); + match(LR_BRACKET); + setState(6831); + fullColumnName(); + setState(6832); + match(RR_BRACKET); + } + break; + case 7: + _localctx = new CaseExpressionFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(6834); + match(CASE); + setState(6835); + expression(0); + setState(6837); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(6836); + caseFuncAlternative(); + } + } + setState(6839); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==WHEN ); + setState(6843); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(6841); + match(ELSE); + setState(6842); + ((CaseExpressionFunctionCallContext)_localctx).elseArg = functionArg(); + } + } + + setState(6845); + match(END); + } + break; + case 8: + _localctx = new CaseFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(6847); + match(CASE); + setState(6849); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(6848); + caseFuncAlternative(); + } + } + setState(6851); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==WHEN ); + setState(6855); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(6853); + match(ELSE); + setState(6854); + ((CaseFunctionCallContext)_localctx).elseArg = functionArg(); + } + } + + setState(6857); + match(END); + } + break; + case 9: + _localctx = new CharFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(6859); + match(CHAR); + setState(6860); + match(LR_BRACKET); + setState(6861); + functionArgs(); + setState(6864); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(6862); + match(USING); + setState(6863); + charsetName(); + } + } + + setState(6866); + match(RR_BRACKET); + } + break; + case 10: + _localctx = new PositionFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(6868); + match(POSITION); + setState(6869); + match(LR_BRACKET); + setState(6872); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1017,_ctx) ) { + case 1: + { + setState(6870); + ((PositionFunctionCallContext)_localctx).positionString = stringLiteral(); + } + break; + case 2: + { + setState(6871); + ((PositionFunctionCallContext)_localctx).positionExpression = expression(0); + } + break; + } + setState(6874); + match(IN); + setState(6877); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1018,_ctx) ) { + case 1: + { + setState(6875); + ((PositionFunctionCallContext)_localctx).inString = stringLiteral(); + } + break; + case 2: + { + setState(6876); + ((PositionFunctionCallContext)_localctx).inExpression = expression(0); + } + break; + } + setState(6879); + match(RR_BRACKET); + } + break; + case 11: + _localctx = new SubstrFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(6881); + _la = _input.LA(1); + if ( !(_la==SUBSTR || _la==SUBSTRING) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6882); + match(LR_BRACKET); + setState(6885); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1019,_ctx) ) { + case 1: + { + setState(6883); + ((SubstrFunctionCallContext)_localctx).sourceString = stringLiteral(); + } + break; + case 2: + { + setState(6884); + ((SubstrFunctionCallContext)_localctx).sourceExpression = expression(0); + } + break; + } + setState(6887); + match(FROM); + setState(6890); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1020,_ctx) ) { + case 1: + { + setState(6888); + ((SubstrFunctionCallContext)_localctx).fromDecimal = decimalLiteral(); + } + break; + case 2: + { + setState(6889); + ((SubstrFunctionCallContext)_localctx).fromExpression = expression(0); + } + break; + } + setState(6897); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(6892); + match(FOR); + setState(6895); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1021,_ctx) ) { + case 1: + { + setState(6893); + ((SubstrFunctionCallContext)_localctx).forDecimal = decimalLiteral(); + } + break; + case 2: + { + setState(6894); + ((SubstrFunctionCallContext)_localctx).forExpression = expression(0); + } + break; + } + } + } + + setState(6899); + match(RR_BRACKET); + } + break; + case 12: + _localctx = new TrimFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(6901); + match(TRIM); + setState(6902); + match(LR_BRACKET); + setState(6903); + ((TrimFunctionCallContext)_localctx).positioinForm = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==BOTH || _la==LEADING || _la==TRAILING) ) { + ((TrimFunctionCallContext)_localctx).positioinForm = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6906); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1023,_ctx) ) { + case 1: + { + setState(6904); + ((TrimFunctionCallContext)_localctx).sourceString = stringLiteral(); + } + break; + case 2: + { + setState(6905); + ((TrimFunctionCallContext)_localctx).sourceExpression = expression(0); + } + break; + } + setState(6908); + match(FROM); + setState(6911); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1024,_ctx) ) { + case 1: + { + setState(6909); + ((TrimFunctionCallContext)_localctx).fromString = stringLiteral(); + } + break; + case 2: + { + setState(6910); + ((TrimFunctionCallContext)_localctx).fromExpression = expression(0); + } + break; + } + setState(6913); + match(RR_BRACKET); + } + break; + case 13: + _localctx = new TrimFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(6915); + match(TRIM); + setState(6916); + match(LR_BRACKET); + setState(6919); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1025,_ctx) ) { + case 1: + { + setState(6917); + ((TrimFunctionCallContext)_localctx).sourceString = stringLiteral(); + } + break; + case 2: + { + setState(6918); + ((TrimFunctionCallContext)_localctx).sourceExpression = expression(0); + } + break; + } + setState(6921); + match(FROM); + setState(6924); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1026,_ctx) ) { + case 1: + { + setState(6922); + ((TrimFunctionCallContext)_localctx).fromString = stringLiteral(); + } + break; + case 2: + { + setState(6923); + ((TrimFunctionCallContext)_localctx).fromExpression = expression(0); + } + break; + } + setState(6926); + match(RR_BRACKET); + } + break; + case 14: + _localctx = new WeightFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(6928); + match(WEIGHT_STRING); + setState(6929); + match(LR_BRACKET); + setState(6932); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1027,_ctx) ) { + case 1: + { + setState(6930); + stringLiteral(); + } + break; + case 2: + { + setState(6931); + expression(0); + } + break; + } + setState(6940); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(6934); + match(AS); + setState(6935); + ((WeightFunctionCallContext)_localctx).stringFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==CHAR || _la==BINARY) ) { + ((WeightFunctionCallContext)_localctx).stringFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6936); + match(LR_BRACKET); + setState(6937); + decimalLiteral(); + setState(6938); + match(RR_BRACKET); + } + } + + setState(6943); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LEVEL) { + { + setState(6942); + levelsInWeightString(); + } + } + + setState(6945); + match(RR_BRACKET); + } + break; + case 15: + _localctx = new ExtractFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(6947); + match(EXTRACT); + setState(6948); + match(LR_BRACKET); + setState(6949); + intervalType(); + setState(6950); + match(FROM); + setState(6953); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1030,_ctx) ) { + case 1: + { + setState(6951); + ((ExtractFunctionCallContext)_localctx).sourceString = stringLiteral(); + } + break; + case 2: + { + setState(6952); + ((ExtractFunctionCallContext)_localctx).sourceExpression = expression(0); + } + break; + } + setState(6955); + match(RR_BRACKET); + } + break; + case 16: + _localctx = new GetFormatFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 16); + { + setState(6957); + match(GET_FORMAT); + setState(6958); + match(LR_BRACKET); + setState(6959); + ((GetFormatFunctionCallContext)_localctx).datetimeFormat = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & 11L) != 0)) ) { + ((GetFormatFunctionCallContext)_localctx).datetimeFormat = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(6960); + match(COMMA); + setState(6961); + stringLiteral(); + setState(6962); + match(RR_BRACKET); + } + break; + case 17: + _localctx = new JsonValueFunctionCallContext(_localctx); + enterOuterAlt(_localctx, 17); + { + setState(6964); + match(JSON_VALUE); + setState(6965); + match(LR_BRACKET); + setState(6966); + expression(0); + setState(6967); + match(COMMA); + setState(6968); + expression(0); + setState(6971); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==RETURNING) { + { + setState(6969); + match(RETURNING); + setState(6970); + convertedDataType(); + } + } + + setState(6974); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1032,_ctx) ) { + case 1: + { + setState(6973); + jsonOnEmpty(); + } + break; + } + setState(6977); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT || _la==NULL_LITERAL || _la==ERROR) { + { + setState(6976); + jsonOnError(); + } + } + + setState(6979); + match(RR_BRACKET); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CaseFuncAlternativeContext extends ParserRuleContext { + public FunctionArgContext condition; + public FunctionArgContext consequent; + public TerminalNode WHEN() { return getToken(MySqlParser.WHEN, 0); } + public TerminalNode THEN() { return getToken(MySqlParser.THEN, 0); } + public List functionArg() { + return getRuleContexts(FunctionArgContext.class); + } + public FunctionArgContext functionArg(int i) { + return getRuleContext(FunctionArgContext.class,i); + } + public CaseFuncAlternativeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_caseFuncAlternative; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCaseFuncAlternative(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCaseFuncAlternative(this); + } + } + + public final CaseFuncAlternativeContext caseFuncAlternative() throws RecognitionException { + CaseFuncAlternativeContext _localctx = new CaseFuncAlternativeContext(_ctx, getState()); + enterRule(_localctx, 652, RULE_caseFuncAlternative); + try { + enterOuterAlt(_localctx, 1); + { + setState(6983); + match(WHEN); + setState(6984); + ((CaseFuncAlternativeContext)_localctx).condition = functionArg(); + setState(6985); + match(THEN); + setState(6986); + ((CaseFuncAlternativeContext)_localctx).consequent = functionArg(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LevelsInWeightStringContext extends ParserRuleContext { + public LevelsInWeightStringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_levelsInWeightString; } + + public LevelsInWeightStringContext() { } + public void copyFrom(LevelsInWeightStringContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class LevelWeightRangeContext extends LevelsInWeightStringContext { + public DecimalLiteralContext firstLevel; + public DecimalLiteralContext lastLevel; + public TerminalNode LEVEL() { return getToken(MySqlParser.LEVEL, 0); } + public TerminalNode MINUS() { return getToken(MySqlParser.MINUS, 0); } + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public LevelWeightRangeContext(LevelsInWeightStringContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLevelWeightRange(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLevelWeightRange(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class LevelWeightListContext extends LevelsInWeightStringContext { + public TerminalNode LEVEL() { return getToken(MySqlParser.LEVEL, 0); } + public List levelInWeightListElement() { + return getRuleContexts(LevelInWeightListElementContext.class); + } + public LevelInWeightListElementContext levelInWeightListElement(int i) { + return getRuleContext(LevelInWeightListElementContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public LevelWeightListContext(LevelsInWeightStringContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLevelWeightList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLevelWeightList(this); + } + } + + public final LevelsInWeightStringContext levelsInWeightString() throws RecognitionException { + LevelsInWeightStringContext _localctx = new LevelsInWeightStringContext(_ctx, getState()); + enterRule(_localctx, 654, RULE_levelsInWeightString); + int _la; + try { + setState(7002); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1036,_ctx) ) { + case 1: + _localctx = new LevelWeightListContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(6988); + match(LEVEL); + setState(6989); + levelInWeightListElement(); + setState(6994); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6990); + match(COMMA); + setState(6991); + levelInWeightListElement(); + } + } + setState(6996); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + _localctx = new LevelWeightRangeContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(6997); + match(LEVEL); + setState(6998); + ((LevelWeightRangeContext)_localctx).firstLevel = decimalLiteral(); + setState(6999); + match(MINUS); + setState(7000); + ((LevelWeightRangeContext)_localctx).lastLevel = decimalLiteral(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LevelInWeightListElementContext extends ParserRuleContext { + public Token orderType; + public DecimalLiteralContext decimalLiteral() { + return getRuleContext(DecimalLiteralContext.class,0); + } + public TerminalNode ASC() { return getToken(MySqlParser.ASC, 0); } + public TerminalNode DESC() { return getToken(MySqlParser.DESC, 0); } + public TerminalNode REVERSE() { return getToken(MySqlParser.REVERSE, 0); } + public LevelInWeightListElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_levelInWeightListElement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLevelInWeightListElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLevelInWeightListElement(this); + } + } + + public final LevelInWeightListElementContext levelInWeightListElement() throws RecognitionException { + LevelInWeightListElementContext _localctx = new LevelInWeightListElementContext(_ctx, getState()); + enterRule(_localctx, 656, RULE_levelInWeightListElement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7004); + decimalLiteral(); + setState(7006); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASC || _la==DESC || _la==REVERSE) { + { + setState(7005); + ((LevelInWeightListElementContext)_localctx).orderType = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ASC || _la==DESC || _la==REVERSE) ) { + ((LevelInWeightListElementContext)_localctx).orderType = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AggregateWindowedFunctionContext extends ParserRuleContext { + public Token aggregator; + public Token starArg; + public Token separator; + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public FunctionArgContext functionArg() { + return getRuleContext(FunctionArgContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode AVG() { return getToken(MySqlParser.AVG, 0); } + public TerminalNode MAX() { return getToken(MySqlParser.MAX, 0); } + public TerminalNode MIN() { return getToken(MySqlParser.MIN, 0); } + public TerminalNode SUM() { return getToken(MySqlParser.SUM, 0); } + public OverClauseContext overClause() { + return getRuleContext(OverClauseContext.class,0); + } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode DISTINCT() { return getToken(MySqlParser.DISTINCT, 0); } + public TerminalNode COUNT() { return getToken(MySqlParser.COUNT, 0); } + public FunctionArgsContext functionArgs() { + return getRuleContext(FunctionArgsContext.class,0); + } + public TerminalNode STAR() { return getToken(MySqlParser.STAR, 0); } + public TerminalNode BIT_AND() { return getToken(MySqlParser.BIT_AND, 0); } + public TerminalNode BIT_OR() { return getToken(MySqlParser.BIT_OR, 0); } + public TerminalNode BIT_XOR() { return getToken(MySqlParser.BIT_XOR, 0); } + public TerminalNode STD() { return getToken(MySqlParser.STD, 0); } + public TerminalNode STDDEV() { return getToken(MySqlParser.STDDEV, 0); } + public TerminalNode STDDEV_POP() { return getToken(MySqlParser.STDDEV_POP, 0); } + public TerminalNode STDDEV_SAMP() { return getToken(MySqlParser.STDDEV_SAMP, 0); } + public TerminalNode VAR_POP() { return getToken(MySqlParser.VAR_POP, 0); } + public TerminalNode VAR_SAMP() { return getToken(MySqlParser.VAR_SAMP, 0); } + public TerminalNode VARIANCE() { return getToken(MySqlParser.VARIANCE, 0); } + public TerminalNode GROUP_CONCAT() { return getToken(MySqlParser.GROUP_CONCAT, 0); } + public TerminalNode ORDER() { return getToken(MySqlParser.ORDER, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public List orderByExpression() { + return getRuleContexts(OrderByExpressionContext.class); + } + public OrderByExpressionContext orderByExpression(int i) { + return getRuleContext(OrderByExpressionContext.class,i); + } + public TerminalNode SEPARATOR() { return getToken(MySqlParser.SEPARATOR, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public AggregateWindowedFunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_aggregateWindowedFunction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAggregateWindowedFunction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAggregateWindowedFunction(this); + } + } + + public final AggregateWindowedFunctionContext aggregateWindowedFunction() throws RecognitionException { + AggregateWindowedFunctionContext _localctx = new AggregateWindowedFunctionContext(_ctx, getState()); + enterRule(_localctx, 658, RULE_aggregateWindowedFunction); + int _la; + try { + setState(7067); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AVG: + case MAX: + case MIN: + case SUM: + enterOuterAlt(_localctx, 1); + { + setState(7008); + _la = _input.LA(1); + if ( !(((((_la - 287)) & ~0x3f) == 0 && ((1L << (_la - 287)) & 8400897L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7009); + match(LR_BRACKET); + setState(7011); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1038,_ctx) ) { + case 1: + { + setState(7010); + ((AggregateWindowedFunctionContext)_localctx).aggregator = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ALL || _la==DISTINCT) ) { + ((AggregateWindowedFunctionContext)_localctx).aggregator = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(7013); + functionArg(); + setState(7014); + match(RR_BRACKET); + setState(7016); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1039,_ctx) ) { + case 1: + { + setState(7015); + overClause(); + } + break; + } + } + break; + case COUNT: + enterOuterAlt(_localctx, 2); + { + setState(7018); + match(COUNT); + setState(7019); + match(LR_BRACKET); + setState(7027); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1041,_ctx) ) { + case 1: + { + setState(7020); + ((AggregateWindowedFunctionContext)_localctx).starArg = match(STAR); + } + break; + case 2: + { + setState(7022); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1040,_ctx) ) { + case 1: + { + setState(7021); + ((AggregateWindowedFunctionContext)_localctx).aggregator = match(ALL); + } + break; + } + setState(7024); + functionArg(); + } + break; + case 3: + { + setState(7025); + ((AggregateWindowedFunctionContext)_localctx).aggregator = match(DISTINCT); + setState(7026); + functionArgs(); + } + break; + } + setState(7029); + match(RR_BRACKET); + setState(7031); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1042,_ctx) ) { + case 1: + { + setState(7030); + overClause(); + } + break; + } + } + break; + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + enterOuterAlt(_localctx, 3); + { + setState(7033); + _la = _input.LA(1); + if ( !(((((_la - 288)) & ~0x3f) == 0 && ((1L << (_la - 288)) & 62652423L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7034); + match(LR_BRACKET); + setState(7036); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1043,_ctx) ) { + case 1: + { + setState(7035); + ((AggregateWindowedFunctionContext)_localctx).aggregator = match(ALL); + } + break; + } + setState(7038); + functionArg(); + setState(7039); + match(RR_BRACKET); + setState(7041); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1044,_ctx) ) { + case 1: + { + setState(7040); + overClause(); + } + break; + } + } + break; + case GROUP_CONCAT: + enterOuterAlt(_localctx, 4); + { + setState(7043); + match(GROUP_CONCAT); + setState(7044); + match(LR_BRACKET); + setState(7046); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1045,_ctx) ) { + case 1: + { + setState(7045); + ((AggregateWindowedFunctionContext)_localctx).aggregator = match(DISTINCT); + } + break; + } + setState(7048); + functionArgs(); + setState(7059); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ORDER) { + { + setState(7049); + match(ORDER); + setState(7050); + match(BY); + setState(7051); + orderByExpression(); + setState(7056); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7052); + match(COMMA); + setState(7053); + orderByExpression(); + } + } + setState(7058); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(7063); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEPARATOR) { + { + setState(7061); + match(SEPARATOR); + setState(7062); + ((AggregateWindowedFunctionContext)_localctx).separator = match(STRING_LITERAL); + } + } + + setState(7065); + match(RR_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NonAggregateWindowedFunctionContext extends ParserRuleContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public OverClauseContext overClause() { + return getRuleContext(OverClauseContext.class,0); + } + public TerminalNode LAG() { return getToken(MySqlParser.LAG, 0); } + public TerminalNode LEAD() { return getToken(MySqlParser.LEAD, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public List decimalLiteral() { + return getRuleContexts(DecimalLiteralContext.class); + } + public DecimalLiteralContext decimalLiteral(int i) { + return getRuleContext(DecimalLiteralContext.class,i); + } + public TerminalNode FIRST_VALUE() { return getToken(MySqlParser.FIRST_VALUE, 0); } + public TerminalNode LAST_VALUE() { return getToken(MySqlParser.LAST_VALUE, 0); } + public TerminalNode CUME_DIST() { return getToken(MySqlParser.CUME_DIST, 0); } + public TerminalNode DENSE_RANK() { return getToken(MySqlParser.DENSE_RANK, 0); } + public TerminalNode PERCENT_RANK() { return getToken(MySqlParser.PERCENT_RANK, 0); } + public TerminalNode RANK() { return getToken(MySqlParser.RANK, 0); } + public TerminalNode ROW_NUMBER() { return getToken(MySqlParser.ROW_NUMBER, 0); } + public TerminalNode NTH_VALUE() { return getToken(MySqlParser.NTH_VALUE, 0); } + public TerminalNode NTILE() { return getToken(MySqlParser.NTILE, 0); } + public NonAggregateWindowedFunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nonAggregateWindowedFunction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNonAggregateWindowedFunction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNonAggregateWindowedFunction(this); + } + } + + public final NonAggregateWindowedFunctionContext nonAggregateWindowedFunction() throws RecognitionException { + NonAggregateWindowedFunctionContext _localctx = new NonAggregateWindowedFunctionContext(_ctx, getState()); + enterRule(_localctx, 660, RULE_nonAggregateWindowedFunction); + int _la; + try { + setState(7107); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LAG: + case LEAD: + enterOuterAlt(_localctx, 1); + { + setState(7069); + _la = _input.LA(1); + if ( !(_la==LAG || _la==LEAD) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7070); + match(LR_BRACKET); + setState(7071); + expression(0); + setState(7074); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1050,_ctx) ) { + case 1: + { + setState(7072); + match(COMMA); + setState(7073); + decimalLiteral(); + } + break; + } + setState(7078); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(7076); + match(COMMA); + setState(7077); + decimalLiteral(); + } + } + + setState(7080); + match(RR_BRACKET); + setState(7081); + overClause(); + } + break; + case FIRST_VALUE: + case LAST_VALUE: + enterOuterAlt(_localctx, 2); + { + setState(7083); + _la = _input.LA(1); + if ( !(_la==FIRST_VALUE || _la==LAST_VALUE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7084); + match(LR_BRACKET); + setState(7085); + expression(0); + setState(7086); + match(RR_BRACKET); + setState(7087); + overClause(); + } + break; + case CUME_DIST: + case DENSE_RANK: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + enterOuterAlt(_localctx, 3); + { + setState(7089); + _la = _input.LA(1); + if ( !(((((_la - 292)) & ~0x3f) == 0 && ((1L << (_la - 292)) & 14339L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7090); + match(LR_BRACKET); + setState(7091); + match(RR_BRACKET); + setState(7092); + overClause(); + } + break; + case NTH_VALUE: + enterOuterAlt(_localctx, 4); + { + setState(7093); + match(NTH_VALUE); + setState(7094); + match(LR_BRACKET); + setState(7095); + expression(0); + setState(7096); + match(COMMA); + setState(7097); + decimalLiteral(); + setState(7098); + match(RR_BRACKET); + setState(7099); + overClause(); + } + break; + case NTILE: + enterOuterAlt(_localctx, 5); + { + setState(7101); + match(NTILE); + setState(7102); + match(LR_BRACKET); + setState(7103); + decimalLiteral(); + setState(7104); + match(RR_BRACKET); + setState(7105); + overClause(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OverClauseContext extends ParserRuleContext { + public TerminalNode OVER() { return getToken(MySqlParser.OVER, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public WindowSpecContext windowSpec() { + return getRuleContext(WindowSpecContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public WindowNameContext windowName() { + return getRuleContext(WindowNameContext.class,0); + } + public OverClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_overClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterOverClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitOverClause(this); + } + } + + public final OverClauseContext overClause() throws RecognitionException { + OverClauseContext _localctx = new OverClauseContext(_ctx, getState()); + enterRule(_localctx, 662, RULE_overClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(7109); + match(OVER); + setState(7115); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LR_BRACKET: + { + setState(7110); + match(LR_BRACKET); + setState(7111); + windowSpec(); + setState(7112); + match(RR_BRACKET); + } + break; + case ARRAY: + case ATTRIBUTE: + case BUCKETS: + case CONDITION: + case CURRENT: + case CURRENT_USER: + case DATABASE: + case DEFAULT: + case DIAGNOSTICS: + case EMPTY: + case ENFORCED: + case EXCEPT: + case GROUP: + case IF: + case IGNORED: + case INSERT: + case LATERAL: + case LEFT: + case NUMBER: + case OPTIONAL: + case ORDER: + case PRIMARY: + case REPEAT: + case REPLACE: + case RIGHT: + case SCHEMA: + case SKIP_QUERY_REWRITE: + case STACKED: + case DATE: + case TIME: + case TIMESTAMP: + case DATETIME: + case YEAR: + case BINARY: + case TEXT: + case ENUM: + case SERIAL: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case NESTED: + case ORDINALITY: + case PATH: + case AVG: + case BIT_AND: + case BIT_OR: + case BIT_XOR: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case GROUP_CONCAT: + case LAG: + case LAST_VALUE: + case LEAD: + case MAX: + case MIN: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case STD: + case STDDEV: + case STDDEV_POP: + case STDDEV_SAMP: + case SUM: + case VAR_POP: + case VAR_SAMP: + case VARIANCE: + case CURRENT_DATE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case LOCALTIME: + case CURDATE: + case CURTIME: + case DATE_ADD: + case DATE_SUB: + case LOCALTIMESTAMP: + case NOW: + case POSITION: + case SUBSTR: + case SUBSTRING: + case SYSDATE: + case TRIM: + case UTC_DATE: + case UTC_TIME: + case UTC_TIMESTAMP: + case ACCOUNT: + case ACTION: + case AFTER: + case AGGREGATE: + case ALGORITHM: + case ANY: + case AT: + case AUTHORS: + case AUTOCOMMIT: + case AUTOEXTEND_SIZE: + case AUTO_INCREMENT: + case AVG_ROW_LENGTH: + case BEGIN: + case BINLOG: + case BIT: + case BLOCK: + case BOOL: + case BOOLEAN: + case BTREE: + case CACHE: + case CASCADED: + case CHAIN: + case CHANGED: + case CHANNEL: + case CHECKSUM: + case PAGE_CHECKSUM: + case CIPHER: + case CLASS_ORIGIN: + case CLIENT: + case CLOSE: + case CLUSTERING: + case COALESCE: + case CODE: + case COLUMNS: + case COLUMN_FORMAT: + case COLUMN_NAME: + case COMMENT: + case COMMIT: + case COMPACT: + case COMPLETION: + case COMPRESSED: + case COMPRESSION: + case CONCURRENT: + case CONNECT: + case CONNECTION: + case CONSISTENT: + case CONSTRAINT_CATALOG: + case CONSTRAINT_SCHEMA: + case CONSTRAINT_NAME: + case CONTAINS: + case CONTEXT: + case CONTRIBUTORS: + case COPY: + case CPU: + case CURSOR_NAME: + case DATA: + case DATAFILE: + case DEALLOCATE: + case DEFAULT_AUTH: + case DEFINER: + case DELAY_KEY_WRITE: + case DES_KEY_FILE: + case DIRECTORY: + case DISABLE: + case DISCARD: + case DISK: + case DO: + case DUMPFILE: + case DUPLICATE: + case DYNAMIC: + case ENABLE: + case ENCRYPTION: + case END: + case ENDS: + case ENGINE: + case ENGINES: + case ERROR: + case ERRORS: + case ESCAPE: + case EVEN: + case EVENT: + case EVENTS: + case EVERY: + case EXCHANGE: + case EXCLUSIVE: + case EXPIRE: + case EXPORT: + case EXTENDED: + case EXTENT_SIZE: + case FAILED_LOGIN_ATTEMPTS: + case FAST: + case FAULTS: + case FIELDS: + case FILE_BLOCK_SIZE: + case FILTER: + case FIRST: + case FIXED: + case FLUSH: + case FOLLOWS: + case FOUND: + case FULL: + case FUNCTION: + case GENERAL: + case GLOBAL: + case GRANTS: + case GROUP_REPLICATION: + case HANDLER: + case HASH: + case HELP: + case HISTORY: + case HOST: + case HOSTS: + case IDENTIFIED: + case IGNORE_SERVER_IDS: + case IMPORT: + case INDEXES: + case INITIAL_SIZE: + case INPLACE: + case INSERT_METHOD: + case INSTALL: + case INSTANCE: + case INSTANT: + case INVISIBLE: + case INVOKER: + case IO: + case IO_THREAD: + case IPC: + case ISOLATION: + case ISSUER: + case JSON: + case KEY_BLOCK_SIZE: + case LANGUAGE: + case LAST: + case LEAVES: + case LESS: + case LEVEL: + case LIST: + case LOCAL: + case LOGFILE: + case LOGS: + case MASTER: + case MASTER_AUTO_POSITION: + case MASTER_CONNECT_RETRY: + case MASTER_DELAY: + case MASTER_HEARTBEAT_PERIOD: + case MASTER_HOST: + case MASTER_LOG_FILE: + case MASTER_LOG_POS: + case MASTER_PASSWORD: + case MASTER_PORT: + case MASTER_RETRY_COUNT: + case MASTER_SSL: + case MASTER_SSL_CA: + case MASTER_SSL_CAPATH: + case MASTER_SSL_CERT: + case MASTER_SSL_CIPHER: + case MASTER_SSL_CRL: + case MASTER_SSL_CRLPATH: + case MASTER_SSL_KEY: + case MASTER_TLS_VERSION: + case MASTER_USER: + case MAX_CONNECTIONS_PER_HOUR: + case MAX_QUERIES_PER_HOUR: + case MAX_ROWS: + case MAX_SIZE: + case MAX_UPDATES_PER_HOUR: + case MAX_USER_CONNECTIONS: + case MEDIUM: + case MEMBER: + case MERGE: + case MESSAGE_TEXT: + case MID: + case MIGRATE: + case MIN_ROWS: + case MODE: + case MODIFY: + case MUTEX: + case MYSQL: + case MYSQL_ERRNO: + case NAME: + case NAMES: + case NCHAR: + case NEVER: + case NEXT: + case NO: + case NOCOPY: + case NOWAIT: + case NODEGROUP: + case NONE: + case ODBC: + case OFFLINE: + case OFFSET: + case OF: + case OJ: + case OLD_PASSWORD: + case ONE: + case ONLINE: + case ONLY: + case OPEN: + case OPTIMIZER_COSTS: + case OPTIONS: + case OWNER: + case PACK_KEYS: + case PAGE: + case PARSER: + case PARTIAL: + case PARTITIONING: + case PARTITIONS: + case PASSWORD: + case PASSWORD_LOCK_TIME: + case PHASE: + case PLUGIN: + case PLUGIN_DIR: + case PLUGINS: + case PORT: + case PRECEDES: + case PREPARE: + case PRESERVE: + case PREV: + case PROCESSLIST: + case PROFILE: + case PROFILES: + case PROXY: + case QUERY: + case QUICK: + case REBUILD: + case RECOVER: + case RECURSIVE: + case REDO_BUFFER_SIZE: + case REDUNDANT: + case RELAY: + case RELAY_LOG_FILE: + case RELAY_LOG_POS: + case RELAYLOG: + case REMOVE: + case REORGANIZE: + case REPAIR: + case REPLICATE_DO_DB: + case REPLICATE_DO_TABLE: + case REPLICATE_IGNORE_DB: + case REPLICATE_IGNORE_TABLE: + case REPLICATE_REWRITE_DB: + case REPLICATE_WILD_DO_TABLE: + case REPLICATE_WILD_IGNORE_TABLE: + case REPLICATION: + case RESET: + case RESUME: + case RETURNED_SQLSTATE: + case RETURNING: + case RETURNS: + case REUSE: + case ROLE: + case ROLLBACK: + case ROLLUP: + case ROTATE: + case ROW: + case ROWS: + case ROW_FORMAT: + case RTREE: + case SAVEPOINT: + case SCHEDULE: + case SECURITY: + case SERVER: + case SESSION: + case SHARE: + case SHARED: + case SIGNED: + case SIMPLE: + case SLAVE: + case SLOW: + case SNAPSHOT: + case SOCKET: + case SOME: + case SONAME: + case SOUNDS: + case SOURCE: + case SQL_AFTER_GTIDS: + case SQL_AFTER_MTS_GAPS: + case SQL_BEFORE_GTIDS: + case SQL_BUFFER_RESULT: + case SQL_CACHE: + case SQL_NO_CACHE: + case SQL_THREAD: + case START: + case STARTS: + case STATS_AUTO_RECALC: + case STATS_PERSISTENT: + case STATS_SAMPLE_PAGES: + case STATUS: + case STOP: + case STORAGE: + case STRING: + case SUBCLASS_ORIGIN: + case SUBJECT: + case SUBPARTITION: + case SUBPARTITIONS: + case SUSPEND: + case SWAPS: + case SWITCHES: + case TABLE_NAME: + case TABLESPACE: + case TABLE_TYPE: + case TEMPORARY: + case TEMPTABLE: + case THAN: + case TRADITIONAL: + case TRANSACTION: + case TRANSACTIONAL: + case TRIGGERS: + case TRUNCATE: + case UNBOUNDED: + case UNDEFINED: + case UNDOFILE: + case UNDO_BUFFER_SIZE: + case UNINSTALL: + case UNKNOWN: + case UNTIL: + case UPGRADE: + case USER: + case USE_FRM: + case USER_RESOURCES: + case VALIDATION: + case VALUE: + case VARIABLES: + case VIEW: + case VIRTUAL: + case VISIBLE: + case WAIT: + case WARNINGS: + case WITHOUT: + case WORK: + case WRAPPER: + case X509: + case XA: + case XML: + case EUR: + case USA: + case JIS: + case ISO: + case INTERNAL: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case ADMIN: + case AUDIT_ABORT_EXEMPT: + case AUDIT_ADMIN: + case AUTHENTICATION_POLICY_ADMIN: + case BACKUP_ADMIN: + case BINLOG_ADMIN: + case BINLOG_ENCRYPTION_ADMIN: + case CLONE_ADMIN: + case CONNECTION_ADMIN: + case ENCRYPTION_KEY_ADMIN: + case EXECUTE: + case FILE: + case FIREWALL_ADMIN: + case FIREWALL_EXEMPT: + case FIREWALL_USER: + case GROUP_REPLICATION_ADMIN: + case INNODB_REDO_LOG_ARCHIVE: + case INVOKE: + case LAMBDA: + case NDB_STORED_USER: + case PASSWORDLESS_USER_ADMIN: + case PERSIST_RO_VARIABLES_ADMIN: + case PRIVILEGES: + case PROCESS: + case RELOAD: + case REPLICATION_APPLIER: + case REPLICATION_SLAVE_ADMIN: + case RESOURCE_GROUP_ADMIN: + case RESOURCE_GROUP_USER: + case ROLE_ADMIN: + case ROUTINE: + case S3: + case SESSION_VARIABLES_ADMIN: + case SET_USER_ID: + case SHOW_ROUTINE: + case SHUTDOWN: + case SUPER: + case SYSTEM_VARIABLES_ADMIN: + case TABLES: + case TABLE_ENCRYPTION_ADMIN: + case VERSION_TOKEN_ADMIN: + case XA_RECOVER_ADMIN: + case ARMSCII8: + case ASCII: + case BIG5: + case CP1250: + case CP1251: + case CP1256: + case CP1257: + case CP850: + case CP852: + case CP866: + case CP932: + case DEC8: + case EUCJPMS: + case EUCKR: + case GB18030: + case GB2312: + case GBK: + case GEOSTD8: + case GREEK: + case HEBREW: + case HP8: + case KEYBCS2: + case KOI8R: + case KOI8U: + case LATIN1: + case LATIN2: + case LATIN5: + case LATIN7: + case MACCE: + case MACROMAN: + case SJIS: + case SWE7: + case TIS620: + case UCS2: + case UJIS: + case UTF16: + case UTF16LE: + case UTF32: + case UTF8: + case UTF8MB3: + case UTF8MB4: + case ARCHIVE: + case BLACKHOLE: + case CSV: + case FEDERATED: + case INNODB: + case MEMORY: + case MRG_MYISAM: + case MYISAM: + case NDB: + case NDBCLUSTER: + case PERFORMANCE_SCHEMA: + case TOKUDB: + case REPEATABLE: + case COMMITTED: + case UNCOMMITTED: + case SERIALIZABLE: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CATALOG_NAME: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENGINE_ATTRIBUTE: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SECONDARY_ENGINE_ATTRIBUTE: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SCHEMA_NAME: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case TP_CONNECTION_ADMIN: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + case CHARSET_REVERSE_QOUTE_STRING: + case STRING_LITERAL: + case ID: + { + setState(7114); + windowName(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WindowSpecContext extends ParserRuleContext { + public WindowNameContext windowName() { + return getRuleContext(WindowNameContext.class,0); + } + public PartitionClauseContext partitionClause() { + return getRuleContext(PartitionClauseContext.class,0); + } + public OrderByClauseContext orderByClause() { + return getRuleContext(OrderByClauseContext.class,0); + } + public FrameClauseContext frameClause() { + return getRuleContext(FrameClauseContext.class,0); + } + public WindowSpecContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_windowSpec; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWindowSpec(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWindowSpec(this); + } + } + + public final WindowSpecContext windowSpec() throws RecognitionException { + WindowSpecContext _localctx = new WindowSpecContext(_ctx, getState()); + enterRule(_localctx, 664, RULE_windowSpec); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7118); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1054,_ctx) ) { + case 1: + { + setState(7117); + windowName(); + } + break; + } + setState(7121); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PARTITION) { + { + setState(7120); + partitionClause(); + } + } + + setState(7124); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ORDER) { + { + setState(7123); + orderByClause(); + } + } + + setState(7127); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==RANGE || _la==ROWS) { + { + setState(7126); + frameClause(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WindowNameContext extends ParserRuleContext { + public UidContext uid() { + return getRuleContext(UidContext.class,0); + } + public WindowNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_windowName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterWindowName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitWindowName(this); + } + } + + public final WindowNameContext windowName() throws RecognitionException { + WindowNameContext _localctx = new WindowNameContext(_ctx, getState()); + enterRule(_localctx, 666, RULE_windowName); + try { + enterOuterAlt(_localctx, 1); + { + setState(7129); + uid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FrameClauseContext extends ParserRuleContext { + public FrameUnitsContext frameUnits() { + return getRuleContext(FrameUnitsContext.class,0); + } + public FrameExtentContext frameExtent() { + return getRuleContext(FrameExtentContext.class,0); + } + public FrameClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_frameClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFrameClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFrameClause(this); + } + } + + public final FrameClauseContext frameClause() throws RecognitionException { + FrameClauseContext _localctx = new FrameClauseContext(_ctx, getState()); + enterRule(_localctx, 668, RULE_frameClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(7131); + frameUnits(); + setState(7132); + frameExtent(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FrameUnitsContext extends ParserRuleContext { + public TerminalNode ROWS() { return getToken(MySqlParser.ROWS, 0); } + public TerminalNode RANGE() { return getToken(MySqlParser.RANGE, 0); } + public FrameUnitsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_frameUnits; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFrameUnits(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFrameUnits(this); + } + } + + public final FrameUnitsContext frameUnits() throws RecognitionException { + FrameUnitsContext _localctx = new FrameUnitsContext(_ctx, getState()); + enterRule(_localctx, 670, RULE_frameUnits); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7134); + _la = _input.LA(1); + if ( !(_la==RANGE || _la==ROWS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FrameExtentContext extends ParserRuleContext { + public FrameRangeContext frameRange() { + return getRuleContext(FrameRangeContext.class,0); + } + public FrameBetweenContext frameBetween() { + return getRuleContext(FrameBetweenContext.class,0); + } + public FrameExtentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_frameExtent; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFrameExtent(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFrameExtent(this); + } + } + + public final FrameExtentContext frameExtent() throws RecognitionException { + FrameExtentContext _localctx = new FrameExtentContext(_ctx, getState()); + enterRule(_localctx, 672, RULE_frameExtent); + try { + setState(7138); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1058,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7136); + frameRange(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7137); + frameBetween(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FrameBetweenContext extends ParserRuleContext { + public TerminalNode BETWEEN() { return getToken(MySqlParser.BETWEEN, 0); } + public List frameRange() { + return getRuleContexts(FrameRangeContext.class); + } + public FrameRangeContext frameRange(int i) { + return getRuleContext(FrameRangeContext.class,i); + } + public TerminalNode AND() { return getToken(MySqlParser.AND, 0); } + public FrameBetweenContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_frameBetween; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFrameBetween(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFrameBetween(this); + } + } + + public final FrameBetweenContext frameBetween() throws RecognitionException { + FrameBetweenContext _localctx = new FrameBetweenContext(_ctx, getState()); + enterRule(_localctx, 674, RULE_frameBetween); + try { + enterOuterAlt(_localctx, 1); + { + setState(7140); + match(BETWEEN); + setState(7141); + frameRange(); + setState(7142); + match(AND); + setState(7143); + frameRange(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FrameRangeContext extends ParserRuleContext { + public TerminalNode CURRENT() { return getToken(MySqlParser.CURRENT, 0); } + public TerminalNode ROW() { return getToken(MySqlParser.ROW, 0); } + public TerminalNode UNBOUNDED() { return getToken(MySqlParser.UNBOUNDED, 0); } + public TerminalNode PRECEDING() { return getToken(MySqlParser.PRECEDING, 0); } + public TerminalNode FOLLOWING() { return getToken(MySqlParser.FOLLOWING, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public FrameRangeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_frameRange; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFrameRange(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFrameRange(this); + } + } + + public final FrameRangeContext frameRange() throws RecognitionException { + FrameRangeContext _localctx = new FrameRangeContext(_ctx, getState()); + enterRule(_localctx, 676, RULE_frameRange); + int _la; + try { + setState(7152); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1059,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7145); + match(CURRENT); + setState(7146); + match(ROW); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7147); + match(UNBOUNDED); + setState(7148); + _la = _input.LA(1); + if ( !(_la==FOLLOWING || _la==PRECEDING) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7149); + expression(0); + setState(7150); + _la = _input.LA(1); + if ( !(_la==FOLLOWING || _la==PRECEDING) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PartitionClauseContext extends ParserRuleContext { + public TerminalNode PARTITION() { return getToken(MySqlParser.PARTITION, 0); } + public TerminalNode BY() { return getToken(MySqlParser.BY, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public PartitionClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_partitionClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPartitionClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPartitionClause(this); + } + } + + public final PartitionClauseContext partitionClause() throws RecognitionException { + PartitionClauseContext _localctx = new PartitionClauseContext(_ctx, getState()); + enterRule(_localctx, 678, RULE_partitionClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7154); + match(PARTITION); + setState(7155); + match(BY); + setState(7156); + expression(0); + setState(7161); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7157); + match(COMMA); + setState(7158); + expression(0); + } + } + setState(7163); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ScalarFunctionNameContext extends ParserRuleContext { + public FunctionNameBaseContext functionNameBase() { + return getRuleContext(FunctionNameBaseContext.class,0); + } + public TerminalNode ASCII() { return getToken(MySqlParser.ASCII, 0); } + public TerminalNode CURDATE() { return getToken(MySqlParser.CURDATE, 0); } + public TerminalNode CURRENT_DATE() { return getToken(MySqlParser.CURRENT_DATE, 0); } + public TerminalNode CURRENT_TIME() { return getToken(MySqlParser.CURRENT_TIME, 0); } + public TerminalNode CURRENT_TIMESTAMP() { return getToken(MySqlParser.CURRENT_TIMESTAMP, 0); } + public TerminalNode CURTIME() { return getToken(MySqlParser.CURTIME, 0); } + public TerminalNode DATE_ADD() { return getToken(MySqlParser.DATE_ADD, 0); } + public TerminalNode DATE_SUB() { return getToken(MySqlParser.DATE_SUB, 0); } + public TerminalNode IF() { return getToken(MySqlParser.IF, 0); } + public TerminalNode INSERT() { return getToken(MySqlParser.INSERT, 0); } + public TerminalNode LOCALTIME() { return getToken(MySqlParser.LOCALTIME, 0); } + public TerminalNode LOCALTIMESTAMP() { return getToken(MySqlParser.LOCALTIMESTAMP, 0); } + public TerminalNode MID() { return getToken(MySqlParser.MID, 0); } + public TerminalNode NOW() { return getToken(MySqlParser.NOW, 0); } + public TerminalNode REPEAT() { return getToken(MySqlParser.REPEAT, 0); } + public TerminalNode REPLACE() { return getToken(MySqlParser.REPLACE, 0); } + public TerminalNode SUBSTR() { return getToken(MySqlParser.SUBSTR, 0); } + public TerminalNode SUBSTRING() { return getToken(MySqlParser.SUBSTRING, 0); } + public TerminalNode SYSDATE() { return getToken(MySqlParser.SYSDATE, 0); } + public TerminalNode TRIM() { return getToken(MySqlParser.TRIM, 0); } + public TerminalNode UTC_DATE() { return getToken(MySqlParser.UTC_DATE, 0); } + public TerminalNode UTC_TIME() { return getToken(MySqlParser.UTC_TIME, 0); } + public TerminalNode UTC_TIMESTAMP() { return getToken(MySqlParser.UTC_TIMESTAMP, 0); } + public ScalarFunctionNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_scalarFunctionName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterScalarFunctionName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitScalarFunctionName(this); + } + } + + public final ScalarFunctionNameContext scalarFunctionName() throws RecognitionException { + ScalarFunctionNameContext _localctx = new ScalarFunctionNameContext(_ctx, getState()); + enterRule(_localctx, 680, RULE_scalarFunctionName); + try { + setState(7188); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DATABASE: + case LEFT: + case RIGHT: + case SCHEMA: + case DATE: + case TIME: + case TIMESTAMP: + case YEAR: + case JSON_ARRAY: + case JSON_ARRAYAGG: + case JSON_ARRAY_APPEND: + case JSON_ARRAY_INSERT: + case JSON_CONTAINS: + case JSON_CONTAINS_PATH: + case JSON_DEPTH: + case JSON_EXTRACT: + case JSON_INSERT: + case JSON_KEYS: + case JSON_LENGTH: + case JSON_MERGE: + case JSON_MERGE_PATCH: + case JSON_MERGE_PRESERVE: + case JSON_OBJECT: + case JSON_OBJECTAGG: + case JSON_OVERLAPS: + case JSON_PRETTY: + case JSON_QUOTE: + case JSON_REMOVE: + case JSON_REPLACE: + case JSON_SCHEMA_VALID: + case JSON_SCHEMA_VALIDATION_REPORT: + case JSON_SEARCH: + case JSON_SET: + case JSON_STORAGE_FREE: + case JSON_STORAGE_SIZE: + case JSON_TABLE: + case JSON_TYPE: + case JSON_UNQUOTE: + case JSON_VALID: + case JSON_VALUE: + case COUNT: + case CUME_DIST: + case DENSE_RANK: + case FIRST_VALUE: + case LAG: + case LAST_VALUE: + case LEAD: + case NTILE: + case NTH_VALUE: + case PERCENT_RANK: + case RANK: + case ROW_NUMBER: + case POSITION: + case INVISIBLE: + case VISIBLE: + case QUARTER: + case MONTH: + case DAY: + case HOUR: + case MINUTE: + case WEEK: + case SECOND: + case MICROSECOND: + case SESSION_VARIABLES_ADMIN: + case GEOMETRYCOLLECTION: + case LINESTRING: + case MULTILINESTRING: + case MULTIPOINT: + case MULTIPOLYGON: + case POINT: + case POLYGON: + case ABS: + case ACOS: + case ADDDATE: + case ADDTIME: + case AES_DECRYPT: + case AES_ENCRYPT: + case AREA: + case ASBINARY: + case ASIN: + case ASTEXT: + case ASWKB: + case ASWKT: + case ASYMMETRIC_DECRYPT: + case ASYMMETRIC_DERIVE: + case ASYMMETRIC_ENCRYPT: + case ASYMMETRIC_SIGN: + case ASYMMETRIC_VERIFY: + case ATAN: + case ATAN2: + case BENCHMARK: + case BIN: + case BIT_COUNT: + case BIT_LENGTH: + case BUFFER: + case CEIL: + case CEILING: + case CENTROID: + case CHARACTER_LENGTH: + case CHARSET: + case CHAR_LENGTH: + case COERCIBILITY: + case COLLATION: + case COMPRESS: + case CONCAT: + case CONCAT_WS: + case CONNECTION_ID: + case CONV: + case CONVERT_TZ: + case COS: + case COT: + case CRC32: + case CREATE_ASYMMETRIC_PRIV_KEY: + case CREATE_ASYMMETRIC_PUB_KEY: + case CREATE_DH_PARAMETERS: + case CREATE_DIGEST: + case CROSSES: + case DATEDIFF: + case DATE_FORMAT: + case DAYNAME: + case DAYOFMONTH: + case DAYOFWEEK: + case DAYOFYEAR: + case DECODE: + case DEGREES: + case DES_DECRYPT: + case DES_ENCRYPT: + case DIMENSION: + case DISJOINT: + case ELT: + case ENCODE: + case ENCRYPT: + case ENDPOINT: + case ENVELOPE: + case EQUALS: + case EXP: + case EXPORT_SET: + case EXTERIORRING: + case EXTRACTVALUE: + case FIELD: + case FIND_IN_SET: + case FLOOR: + case FORMAT: + case FOUND_ROWS: + case FROM_BASE64: + case FROM_DAYS: + case FROM_UNIXTIME: + case GEOMCOLLFROMTEXT: + case GEOMCOLLFROMWKB: + case GEOMETRYCOLLECTIONFROMTEXT: + case GEOMETRYCOLLECTIONFROMWKB: + case GEOMETRYFROMTEXT: + case GEOMETRYFROMWKB: + case GEOMETRYN: + case GEOMETRYTYPE: + case GEOMFROMTEXT: + case GEOMFROMWKB: + case GET_FORMAT: + case GET_LOCK: + case GLENGTH: + case GREATEST: + case GTID_SUBSET: + case GTID_SUBTRACT: + case HEX: + case IFNULL: + case INET6_ATON: + case INET6_NTOA: + case INET_ATON: + case INET_NTOA: + case INSTR: + case INTERIORRINGN: + case INTERSECTS: + case ISCLOSED: + case ISEMPTY: + case ISNULL: + case ISSIMPLE: + case IS_FREE_LOCK: + case IS_IPV4: + case IS_IPV4_COMPAT: + case IS_IPV4_MAPPED: + case IS_IPV6: + case IS_USED_LOCK: + case LAST_INSERT_ID: + case LCASE: + case LEAST: + case LENGTH: + case LINEFROMTEXT: + case LINEFROMWKB: + case LINESTRINGFROMTEXT: + case LINESTRINGFROMWKB: + case LN: + case LOAD_FILE: + case LOCATE: + case LOG: + case LOG10: + case LOG2: + case LOWER: + case LPAD: + case LTRIM: + case MAKEDATE: + case MAKETIME: + case MAKE_SET: + case MASTER_POS_WAIT: + case MBRCONTAINS: + case MBRDISJOINT: + case MBREQUAL: + case MBRINTERSECTS: + case MBROVERLAPS: + case MBRTOUCHES: + case MBRWITHIN: + case MD5: + case MLINEFROMTEXT: + case MLINEFROMWKB: + case MONTHNAME: + case MPOINTFROMTEXT: + case MPOINTFROMWKB: + case MPOLYFROMTEXT: + case MPOLYFROMWKB: + case MULTILINESTRINGFROMTEXT: + case MULTILINESTRINGFROMWKB: + case MULTIPOINTFROMTEXT: + case MULTIPOINTFROMWKB: + case MULTIPOLYGONFROMTEXT: + case MULTIPOLYGONFROMWKB: + case NAME_CONST: + case NULLIF: + case NUMGEOMETRIES: + case NUMINTERIORRINGS: + case NUMPOINTS: + case OCT: + case OCTET_LENGTH: + case ORD: + case OVERLAPS: + case PERIOD_ADD: + case PERIOD_DIFF: + case PI: + case POINTFROMTEXT: + case POINTFROMWKB: + case POINTN: + case POLYFROMTEXT: + case POLYFROMWKB: + case POLYGONFROMTEXT: + case POLYGONFROMWKB: + case POW: + case POWER: + case QUOTE: + case RADIANS: + case RAND: + case RANDOM: + case RANDOM_BYTES: + case RELEASE_LOCK: + case REVERSE: + case ROUND: + case ROW_COUNT: + case RPAD: + case RTRIM: + case SEC_TO_TIME: + case SESSION_USER: + case SHA: + case SHA1: + case SHA2: + case SIGN: + case SIN: + case SLEEP: + case SOUNDEX: + case SQL_THREAD_WAIT_AFTER_GTIDS: + case SQRT: + case SRID: + case STARTPOINT: + case STRCMP: + case STR_TO_DATE: + case ST_AREA: + case ST_ASBINARY: + case ST_ASTEXT: + case ST_ASWKB: + case ST_ASWKT: + case ST_BUFFER: + case ST_CENTROID: + case ST_CONTAINS: + case ST_CROSSES: + case ST_DIFFERENCE: + case ST_DIMENSION: + case ST_DISJOINT: + case ST_DISTANCE: + case ST_ENDPOINT: + case ST_ENVELOPE: + case ST_EQUALS: + case ST_EXTERIORRING: + case ST_GEOMCOLLFROMTEXT: + case ST_GEOMCOLLFROMTXT: + case ST_GEOMCOLLFROMWKB: + case ST_GEOMETRYCOLLECTIONFROMTEXT: + case ST_GEOMETRYCOLLECTIONFROMWKB: + case ST_GEOMETRYFROMTEXT: + case ST_GEOMETRYFROMWKB: + case ST_GEOMETRYN: + case ST_GEOMETRYTYPE: + case ST_GEOMFROMTEXT: + case ST_GEOMFROMWKB: + case ST_INTERIORRINGN: + case ST_INTERSECTION: + case ST_INTERSECTS: + case ST_ISCLOSED: + case ST_ISEMPTY: + case ST_ISSIMPLE: + case ST_LINEFROMTEXT: + case ST_LINEFROMWKB: + case ST_LINESTRINGFROMTEXT: + case ST_LINESTRINGFROMWKB: + case ST_NUMGEOMETRIES: + case ST_NUMINTERIORRING: + case ST_NUMINTERIORRINGS: + case ST_NUMPOINTS: + case ST_OVERLAPS: + case ST_POINTFROMTEXT: + case ST_POINTFROMWKB: + case ST_POINTN: + case ST_POLYFROMTEXT: + case ST_POLYFROMWKB: + case ST_POLYGONFROMTEXT: + case ST_POLYGONFROMWKB: + case ST_SRID: + case ST_STARTPOINT: + case ST_SYMDIFFERENCE: + case ST_TOUCHES: + case ST_UNION: + case ST_WITHIN: + case ST_X: + case ST_Y: + case SUBDATE: + case SUBSTRING_INDEX: + case SUBTIME: + case SYSTEM_USER: + case TAN: + case TIMEDIFF: + case TIMESTAMPADD: + case TIMESTAMPDIFF: + case TIME_FORMAT: + case TIME_TO_SEC: + case TOUCHES: + case TO_BASE64: + case TO_DAYS: + case TO_SECONDS: + case UCASE: + case UNCOMPRESS: + case UNCOMPRESSED_LENGTH: + case UNHEX: + case UNIX_TIMESTAMP: + case UPDATEXML: + case UPPER: + case UUID: + case UUID_SHORT: + case VALIDATE_PASSWORD_STRENGTH: + case VERSION: + case WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS: + case WEEKDAY: + case WEEKOFYEAR: + case WEIGHT_STRING: + case WITHIN: + case YEARWEEK: + case Y_FUNCTION: + case X_FUNCTION: + case MOD: + enterOuterAlt(_localctx, 1); + { + setState(7164); + functionNameBase(); + } + break; + case ASCII: + enterOuterAlt(_localctx, 2); + { + setState(7165); + match(ASCII); + } + break; + case CURDATE: + enterOuterAlt(_localctx, 3); + { + setState(7166); + match(CURDATE); + } + break; + case CURRENT_DATE: + enterOuterAlt(_localctx, 4); + { + setState(7167); + match(CURRENT_DATE); + } + break; + case CURRENT_TIME: + enterOuterAlt(_localctx, 5); + { + setState(7168); + match(CURRENT_TIME); + } + break; + case CURRENT_TIMESTAMP: + enterOuterAlt(_localctx, 6); + { + setState(7169); + match(CURRENT_TIMESTAMP); + } + break; + case CURTIME: + enterOuterAlt(_localctx, 7); + { + setState(7170); + match(CURTIME); + } + break; + case DATE_ADD: + enterOuterAlt(_localctx, 8); + { + setState(7171); + match(DATE_ADD); + } + break; + case DATE_SUB: + enterOuterAlt(_localctx, 9); + { + setState(7172); + match(DATE_SUB); + } + break; + case IF: + enterOuterAlt(_localctx, 10); + { + setState(7173); + match(IF); + } + break; + case INSERT: + enterOuterAlt(_localctx, 11); + { + setState(7174); + match(INSERT); + } + break; + case LOCALTIME: + enterOuterAlt(_localctx, 12); + { + setState(7175); + match(LOCALTIME); + } + break; + case LOCALTIMESTAMP: + enterOuterAlt(_localctx, 13); + { + setState(7176); + match(LOCALTIMESTAMP); + } + break; + case MID: + enterOuterAlt(_localctx, 14); + { + setState(7177); + match(MID); + } + break; + case NOW: + enterOuterAlt(_localctx, 15); + { + setState(7178); + match(NOW); + } + break; + case REPEAT: + enterOuterAlt(_localctx, 16); + { + setState(7179); + match(REPEAT); + } + break; + case REPLACE: + enterOuterAlt(_localctx, 17); + { + setState(7180); + match(REPLACE); + } + break; + case SUBSTR: + enterOuterAlt(_localctx, 18); + { + setState(7181); + match(SUBSTR); + } + break; + case SUBSTRING: + enterOuterAlt(_localctx, 19); + { + setState(7182); + match(SUBSTRING); + } + break; + case SYSDATE: + enterOuterAlt(_localctx, 20); + { + setState(7183); + match(SYSDATE); + } + break; + case TRIM: + enterOuterAlt(_localctx, 21); + { + setState(7184); + match(TRIM); + } + break; + case UTC_DATE: + enterOuterAlt(_localctx, 22); + { + setState(7185); + match(UTC_DATE); + } + break; + case UTC_TIME: + enterOuterAlt(_localctx, 23); + { + setState(7186); + match(UTC_TIME); + } + break; + case UTC_TIMESTAMP: + enterOuterAlt(_localctx, 24); + { + setState(7187); + match(UTC_TIMESTAMP); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PasswordFunctionClauseContext extends ParserRuleContext { + public Token functionName; + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public FunctionArgContext functionArg() { + return getRuleContext(FunctionArgContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public TerminalNode OLD_PASSWORD() { return getToken(MySqlParser.OLD_PASSWORD, 0); } + public PasswordFunctionClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_passwordFunctionClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPasswordFunctionClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPasswordFunctionClause(this); + } + } + + public final PasswordFunctionClauseContext passwordFunctionClause() throws RecognitionException { + PasswordFunctionClauseContext _localctx = new PasswordFunctionClauseContext(_ctx, getState()); + enterRule(_localctx, 682, RULE_passwordFunctionClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7190); + ((PasswordFunctionClauseContext)_localctx).functionName = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==OLD_PASSWORD || _la==PASSWORD) ) { + ((PasswordFunctionClauseContext)_localctx).functionName = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7191); + match(LR_BRACKET); + setState(7192); + functionArg(); + setState(7193); + match(RR_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionArgsContext extends ParserRuleContext { + public List constant() { + return getRuleContexts(ConstantContext.class); + } + public ConstantContext constant(int i) { + return getRuleContext(ConstantContext.class,i); + } + public List fullColumnName() { + return getRuleContexts(FullColumnNameContext.class); + } + public FullColumnNameContext fullColumnName(int i) { + return getRuleContext(FullColumnNameContext.class,i); + } + public List functionCall() { + return getRuleContexts(FunctionCallContext.class); + } + public FunctionCallContext functionCall(int i) { + return getRuleContext(FunctionCallContext.class,i); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public FunctionArgsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionArgs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFunctionArgs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFunctionArgs(this); + } + } + + public final FunctionArgsContext functionArgs() throws RecognitionException { + FunctionArgsContext _localctx = new FunctionArgsContext(_ctx, getState()); + enterRule(_localctx, 684, RULE_functionArgs); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7199); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1062,_ctx) ) { + case 1: + { + setState(7195); + constant(); + } + break; + case 2: + { + setState(7196); + fullColumnName(); + } + break; + case 3: + { + setState(7197); + functionCall(); + } + break; + case 4: + { + setState(7198); + expression(0); + } + break; + } + setState(7210); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7201); + match(COMMA); + setState(7206); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1063,_ctx) ) { + case 1: + { + setState(7202); + constant(); + } + break; + case 2: + { + setState(7203); + fullColumnName(); + } + break; + case 3: + { + setState(7204); + functionCall(); + } + break; + case 4: + { + setState(7205); + expression(0); + } + break; + } + } + } + setState(7212); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionArgContext extends ParserRuleContext { + public ConstantContext constant() { + return getRuleContext(ConstantContext.class,0); + } + public FullColumnNameContext fullColumnName() { + return getRuleContext(FullColumnNameContext.class,0); + } + public FunctionCallContext functionCall() { + return getRuleContext(FunctionCallContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public FunctionArgContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionArg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFunctionArg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFunctionArg(this); + } + } + + public final FunctionArgContext functionArg() throws RecognitionException { + FunctionArgContext _localctx = new FunctionArgContext(_ctx, getState()); + enterRule(_localctx, 686, RULE_functionArg); + try { + setState(7217); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1065,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7213); + constant(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7214); + fullColumnName(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7215); + functionCall(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7216); + expression(0); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionContext extends ParserRuleContext { + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + + public ExpressionContext() { } + public void copyFrom(ExpressionContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IsExpressionContext extends ExpressionContext { + public Token testValue; + public PredicateContext predicate() { + return getRuleContext(PredicateContext.class,0); + } + public TerminalNode IS() { return getToken(MySqlParser.IS, 0); } + public TerminalNode TRUE() { return getToken(MySqlParser.TRUE, 0); } + public TerminalNode FALSE() { return getToken(MySqlParser.FALSE, 0); } + public TerminalNode UNKNOWN() { return getToken(MySqlParser.UNKNOWN, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public IsExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIsExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIsExpression(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NotExpressionContext extends ExpressionContext { + public Token notOperator; + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public TerminalNode EXCLAMATION_SYMBOL() { return getToken(MySqlParser.EXCLAMATION_SYMBOL, 0); } + public NotExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNotExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNotExpression(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class LogicalExpressionContext extends ExpressionContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public LogicalOperatorContext logicalOperator() { + return getRuleContext(LogicalOperatorContext.class,0); + } + public LogicalExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLogicalExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLogicalExpression(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class PredicateExpressionContext extends ExpressionContext { + public PredicateContext predicate() { + return getRuleContext(PredicateContext.class,0); + } + public PredicateExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPredicateExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPredicateExpression(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + return expression(0); + } + + private ExpressionContext expression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); + ExpressionContext _prevctx = _localctx; + int _startState = 688; + enterRecursionRule(_localctx, 688, RULE_expression, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(7230); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1067,_ctx) ) { + case 1: + { + _localctx = new NotExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + + setState(7220); + ((NotExpressionContext)_localctx).notOperator = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==NOT || _la==EXCLAMATION_SYMBOL) ) { + ((NotExpressionContext)_localctx).notOperator = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7221); + expression(4); + } + break; + case 2: + { + _localctx = new IsExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7222); + predicate(0); + setState(7223); + match(IS); + setState(7225); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(7224); + match(NOT); + } + } + + setState(7227); + ((IsExpressionContext)_localctx).testValue = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==FALSE || _la==TRUE || _la==UNKNOWN) ) { + ((IsExpressionContext)_localctx).testValue = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 3: + { + _localctx = new PredicateExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7229); + predicate(0); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(7238); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,1068,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new LogicalExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(7232); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(7233); + logicalOperator(); + setState(7234); + expression(4); + } + } + } + setState(7240); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,1068,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PredicateContext extends ParserRuleContext { + public PredicateContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_predicate; } + + public PredicateContext() { } + public void copyFrom(PredicateContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SoundsLikePredicateContext extends PredicateContext { + public List predicate() { + return getRuleContexts(PredicateContext.class); + } + public PredicateContext predicate(int i) { + return getRuleContext(PredicateContext.class,i); + } + public TerminalNode SOUNDS() { return getToken(MySqlParser.SOUNDS, 0); } + public TerminalNode LIKE() { return getToken(MySqlParser.LIKE, 0); } + public SoundsLikePredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSoundsLikePredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSoundsLikePredicate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ExpressionAtomPredicateContext extends PredicateContext { + public ExpressionAtomContext expressionAtom() { + return getRuleContext(ExpressionAtomContext.class,0); + } + public ExpressionAtomPredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterExpressionAtomPredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitExpressionAtomPredicate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SubqueryComparisonPredicateContext extends PredicateContext { + public Token quantifier; + public PredicateContext predicate() { + return getRuleContext(PredicateContext.class,0); + } + public ComparisonOperatorContext comparisonOperator() { + return getRuleContext(ComparisonOperatorContext.class,0); + } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public TerminalNode ALL() { return getToken(MySqlParser.ALL, 0); } + public TerminalNode ANY() { return getToken(MySqlParser.ANY, 0); } + public TerminalNode SOME() { return getToken(MySqlParser.SOME, 0); } + public SubqueryComparisonPredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubqueryComparisonPredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubqueryComparisonPredicate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class JsonMemberOfPredicateContext extends PredicateContext { + public List predicate() { + return getRuleContexts(PredicateContext.class); + } + public PredicateContext predicate(int i) { + return getRuleContext(PredicateContext.class,i); + } + public TerminalNode MEMBER() { return getToken(MySqlParser.MEMBER, 0); } + public TerminalNode OF() { return getToken(MySqlParser.OF, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public JsonMemberOfPredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJsonMemberOfPredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJsonMemberOfPredicate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class BinaryComparisonPredicateContext extends PredicateContext { + public PredicateContext left; + public PredicateContext right; + public ComparisonOperatorContext comparisonOperator() { + return getRuleContext(ComparisonOperatorContext.class,0); + } + public List predicate() { + return getRuleContexts(PredicateContext.class); + } + public PredicateContext predicate(int i) { + return getRuleContext(PredicateContext.class,i); + } + public BinaryComparisonPredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBinaryComparisonPredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBinaryComparisonPredicate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class InPredicateContext extends PredicateContext { + public PredicateContext predicate() { + return getRuleContext(PredicateContext.class,0); + } + public TerminalNode IN() { return getToken(MySqlParser.IN, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public ExpressionsContext expressions() { + return getRuleContext(ExpressionsContext.class,0); + } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public InPredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterInPredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitInPredicate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class BetweenPredicateContext extends PredicateContext { + public List predicate() { + return getRuleContexts(PredicateContext.class); + } + public PredicateContext predicate(int i) { + return getRuleContext(PredicateContext.class,i); + } + public TerminalNode BETWEEN() { return getToken(MySqlParser.BETWEEN, 0); } + public TerminalNode AND() { return getToken(MySqlParser.AND, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public BetweenPredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBetweenPredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBetweenPredicate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IsNullPredicateContext extends PredicateContext { + public PredicateContext predicate() { + return getRuleContext(PredicateContext.class,0); + } + public TerminalNode IS() { return getToken(MySqlParser.IS, 0); } + public NullNotnullContext nullNotnull() { + return getRuleContext(NullNotnullContext.class,0); + } + public IsNullPredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIsNullPredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIsNullPredicate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class LikePredicateContext extends PredicateContext { + public List predicate() { + return getRuleContexts(PredicateContext.class); + } + public PredicateContext predicate(int i) { + return getRuleContext(PredicateContext.class,i); + } + public TerminalNode LIKE() { return getToken(MySqlParser.LIKE, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public TerminalNode ESCAPE() { return getToken(MySqlParser.ESCAPE, 0); } + public TerminalNode STRING_LITERAL() { return getToken(MySqlParser.STRING_LITERAL, 0); } + public LikePredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLikePredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLikePredicate(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class RegexpPredicateContext extends PredicateContext { + public Token regex; + public List predicate() { + return getRuleContexts(PredicateContext.class); + } + public PredicateContext predicate(int i) { + return getRuleContext(PredicateContext.class,i); + } + public TerminalNode REGEXP() { return getToken(MySqlParser.REGEXP, 0); } + public TerminalNode RLIKE() { return getToken(MySqlParser.RLIKE, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public RegexpPredicateContext(PredicateContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterRegexpPredicate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitRegexpPredicate(this); + } + } + + public final PredicateContext predicate() throws RecognitionException { + return predicate(0); + } + + private PredicateContext predicate(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + PredicateContext _localctx = new PredicateContext(_ctx, _parentState); + PredicateContext _prevctx = _localctx; + int _startState = 690; + enterRecursionRule(_localctx, 690, RULE_predicate, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + _localctx = new ExpressionAtomPredicateContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + + setState(7242); + expressionAtom(0); + } + _ctx.stop = _input.LT(-1); + setState(7308); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,1076,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(7306); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1075,_ctx) ) { + case 1: + { + _localctx = new BinaryComparisonPredicateContext(new PredicateContext(_parentctx, _parentState)); + ((BinaryComparisonPredicateContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(7244); + if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); + setState(7245); + comparisonOperator(); + setState(7246); + ((BinaryComparisonPredicateContext)_localctx).right = predicate(9); + } + break; + case 2: + { + _localctx = new BetweenPredicateContext(new PredicateContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(7248); + if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(7250); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(7249); + match(NOT); + } + } + + setState(7252); + match(BETWEEN); + setState(7253); + predicate(0); + setState(7254); + match(AND); + setState(7255); + predicate(7); + } + break; + case 3: + { + _localctx = new SoundsLikePredicateContext(new PredicateContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(7257); + if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(7258); + match(SOUNDS); + setState(7259); + match(LIKE); + setState(7260); + predicate(6); + } + break; + case 4: + { + _localctx = new RegexpPredicateContext(new PredicateContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(7261); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(7263); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(7262); + match(NOT); + } + } + + setState(7265); + ((RegexpPredicateContext)_localctx).regex = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==REGEXP || _la==RLIKE) ) { + ((RegexpPredicateContext)_localctx).regex = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7266); + predicate(4); + } + break; + case 5: + { + _localctx = new InPredicateContext(new PredicateContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(7267); + if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); + setState(7269); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(7268); + match(NOT); + } + } + + setState(7271); + match(IN); + setState(7272); + match(LR_BRACKET); + setState(7275); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1072,_ctx) ) { + case 1: + { + setState(7273); + selectStatement(); + } + break; + case 2: + { + setState(7274); + expressions(); + } + break; + } + setState(7277); + match(RR_BRACKET); + } + break; + case 6: + { + _localctx = new IsNullPredicateContext(new PredicateContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(7279); + if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); + setState(7280); + match(IS); + setState(7281); + nullNotnull(); + } + break; + case 7: + { + _localctx = new SubqueryComparisonPredicateContext(new PredicateContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(7282); + if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(7283); + comparisonOperator(); + setState(7284); + ((SubqueryComparisonPredicateContext)_localctx).quantifier = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ALL || _la==ANY || _la==SOME) ) { + ((SubqueryComparisonPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7285); + match(LR_BRACKET); + setState(7286); + selectStatement(); + setState(7287); + match(RR_BRACKET); + } + break; + case 8: + { + _localctx = new LikePredicateContext(new PredicateContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(7289); + if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(7291); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(7290); + match(NOT); + } + } + + setState(7293); + match(LIKE); + setState(7294); + predicate(0); + setState(7297); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1074,_ctx) ) { + case 1: + { + setState(7295); + match(ESCAPE); + setState(7296); + match(STRING_LITERAL); + } + break; + } + } + break; + case 9: + { + _localctx = new JsonMemberOfPredicateContext(new PredicateContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(7299); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(7300); + match(MEMBER); + setState(7301); + match(OF); + setState(7302); + match(LR_BRACKET); + setState(7303); + predicate(0); + setState(7304); + match(RR_BRACKET); + } + break; + } + } + } + setState(7310); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,1076,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionAtomContext extends ParserRuleContext { + public ExpressionAtomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionAtom; } + + public ExpressionAtomContext() { } + public void copyFrom(ExpressionAtomContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class UnaryExpressionAtomContext extends ExpressionAtomContext { + public UnaryOperatorContext unaryOperator() { + return getRuleContext(UnaryOperatorContext.class,0); + } + public ExpressionAtomContext expressionAtom() { + return getRuleContext(ExpressionAtomContext.class,0); + } + public UnaryExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUnaryExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUnaryExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class CollateExpressionAtomContext extends ExpressionAtomContext { + public ExpressionAtomContext expressionAtom() { + return getRuleContext(ExpressionAtomContext.class,0); + } + public TerminalNode COLLATE() { return getToken(MySqlParser.COLLATE, 0); } + public CollationNameContext collationName() { + return getRuleContext(CollationNameContext.class,0); + } + public CollateExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCollateExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCollateExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class VariableAssignExpressionAtomContext extends ExpressionAtomContext { + public TerminalNode LOCAL_ID() { return getToken(MySqlParser.LOCAL_ID, 0); } + public TerminalNode VAR_ASSIGN() { return getToken(MySqlParser.VAR_ASSIGN, 0); } + public ExpressionAtomContext expressionAtom() { + return getRuleContext(ExpressionAtomContext.class,0); + } + public VariableAssignExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterVariableAssignExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitVariableAssignExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MysqlVariableExpressionAtomContext extends ExpressionAtomContext { + public MysqlVariableContext mysqlVariable() { + return getRuleContext(MysqlVariableContext.class,0); + } + public MysqlVariableExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMysqlVariableExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMysqlVariableExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NestedExpressionAtomContext extends ExpressionAtomContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public NestedExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNestedExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNestedExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class NestedRowExpressionAtomContext extends ExpressionAtomContext { + public TerminalNode ROW() { return getToken(MySqlParser.ROW, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public List COMMA() { return getTokens(MySqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(MySqlParser.COMMA, i); + } + public NestedRowExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterNestedRowExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitNestedRowExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class MathExpressionAtomContext extends ExpressionAtomContext { + public ExpressionAtomContext left; + public ExpressionAtomContext right; + public MultOperatorContext multOperator() { + return getRuleContext(MultOperatorContext.class,0); + } + public List expressionAtom() { + return getRuleContexts(ExpressionAtomContext.class); + } + public ExpressionAtomContext expressionAtom(int i) { + return getRuleContext(ExpressionAtomContext.class,i); + } + public AddOperatorContext addOperator() { + return getRuleContext(AddOperatorContext.class,0); + } + public MathExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMathExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMathExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ExistsExpressionAtomContext extends ExpressionAtomContext { + public TerminalNode EXISTS() { return getToken(MySqlParser.EXISTS, 0); } + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public ExistsExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterExistsExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitExistsExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class IntervalExpressionAtomContext extends ExpressionAtomContext { + public TerminalNode INTERVAL() { return getToken(MySqlParser.INTERVAL, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public IntervalTypeContext intervalType() { + return getRuleContext(IntervalTypeContext.class,0); + } + public IntervalExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIntervalExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIntervalExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SpelExpressionAtomContext extends ExpressionAtomContext { + public TerminalNode SPEL() { return getToken(MySqlParser.SPEL, 0); } + public SpelExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSpelExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSpelExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class JsonExpressionAtomContext extends ExpressionAtomContext { + public ExpressionAtomContext left; + public ExpressionAtomContext right; + public JsonOperatorContext jsonOperator() { + return getRuleContext(JsonOperatorContext.class,0); + } + public List expressionAtom() { + return getRuleContexts(ExpressionAtomContext.class); + } + public ExpressionAtomContext expressionAtom(int i) { + return getRuleContext(ExpressionAtomContext.class,i); + } + public JsonExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJsonExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJsonExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class SubqueryExpressionAtomContext extends ExpressionAtomContext { + public TerminalNode LR_BRACKET() { return getToken(MySqlParser.LR_BRACKET, 0); } + public SelectStatementContext selectStatement() { + return getRuleContext(SelectStatementContext.class,0); + } + public TerminalNode RR_BRACKET() { return getToken(MySqlParser.RR_BRACKET, 0); } + public SubqueryExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterSubqueryExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitSubqueryExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class ConstantExpressionAtomContext extends ExpressionAtomContext { + public ConstantContext constant() { + return getRuleContext(ConstantContext.class,0); + } + public ConstantExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterConstantExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitConstantExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class FunctionCallExpressionAtomContext extends ExpressionAtomContext { + public FunctionCallContext functionCall() { + return getRuleContext(FunctionCallContext.class,0); + } + public FunctionCallExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFunctionCallExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFunctionCallExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class BinaryExpressionAtomContext extends ExpressionAtomContext { + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public ExpressionAtomContext expressionAtom() { + return getRuleContext(ExpressionAtomContext.class,0); + } + public BinaryExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBinaryExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBinaryExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class FullColumnNameExpressionAtomContext extends ExpressionAtomContext { + public FullColumnNameContext fullColumnName() { + return getRuleContext(FullColumnNameContext.class,0); + } + public FullColumnNameExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFullColumnNameExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFullColumnNameExpressionAtom(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class BitExpressionAtomContext extends ExpressionAtomContext { + public ExpressionAtomContext left; + public ExpressionAtomContext right; + public BitOperatorContext bitOperator() { + return getRuleContext(BitOperatorContext.class,0); + } + public List expressionAtom() { + return getRuleContexts(ExpressionAtomContext.class); + } + public ExpressionAtomContext expressionAtom(int i) { + return getRuleContext(ExpressionAtomContext.class,i); + } + public BitExpressionAtomContext(ExpressionAtomContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBitExpressionAtom(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBitExpressionAtom(this); + } + } + + public final ExpressionAtomContext expressionAtom() throws RecognitionException { + return expressionAtom(0); + } + + private ExpressionAtomContext expressionAtom(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ExpressionAtomContext _localctx = new ExpressionAtomContext(_ctx, _parentState); + ExpressionAtomContext _prevctx = _localctx; + int _startState = 692; + enterRecursionRule(_localctx, 692, RULE_expressionAtom, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(7360); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1079,_ctx) ) { + case 1: + { + _localctx = new ConstantExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + + setState(7312); + constant(); + } + break; + case 2: + { + _localctx = new FullColumnNameExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7313); + fullColumnName(); + } + break; + case 3: + { + _localctx = new FunctionCallExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7314); + functionCall(); + } + break; + case 4: + { + _localctx = new MysqlVariableExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7315); + mysqlVariable(); + } + break; + case 5: + { + _localctx = new UnaryExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7316); + unaryOperator(); + setState(7317); + expressionAtom(13); + } + break; + case 6: + { + _localctx = new BinaryExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7319); + match(BINARY); + setState(7320); + expressionAtom(12); + } + break; + case 7: + { + _localctx = new VariableAssignExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7321); + match(LOCAL_ID); + setState(7322); + match(VAR_ASSIGN); + setState(7323); + expressionAtom(11); + } + break; + case 8: + { + _localctx = new SpelExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7324); + match(SPEL); + } + break; + case 9: + { + _localctx = new NestedExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7325); + match(LR_BRACKET); + setState(7326); + expression(0); + setState(7331); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7327); + match(COMMA); + setState(7328); + expression(0); + } + } + setState(7333); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(7334); + match(RR_BRACKET); + } + break; + case 10: + { + _localctx = new NestedRowExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7336); + match(ROW); + setState(7337); + match(LR_BRACKET); + setState(7338); + expression(0); + setState(7341); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(7339); + match(COMMA); + setState(7340); + expression(0); + } + } + setState(7343); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==COMMA ); + setState(7345); + match(RR_BRACKET); + } + break; + case 11: + { + _localctx = new ExistsExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7347); + match(EXISTS); + setState(7348); + match(LR_BRACKET); + setState(7349); + selectStatement(); + setState(7350); + match(RR_BRACKET); + } + break; + case 12: + { + _localctx = new SubqueryExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7352); + match(LR_BRACKET); + setState(7353); + selectStatement(); + setState(7354); + match(RR_BRACKET); + } + break; + case 13: + { + _localctx = new IntervalExpressionAtomContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(7356); + match(INTERVAL); + setState(7357); + expression(0); + setState(7358); + intervalType(); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(7383); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,1081,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(7381); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1080,_ctx) ) { + case 1: + { + _localctx = new BitExpressionAtomContext(new ExpressionAtomContext(_parentctx, _parentState)); + ((BitExpressionAtomContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expressionAtom); + setState(7362); + if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(7363); + bitOperator(); + setState(7364); + ((BitExpressionAtomContext)_localctx).right = expressionAtom(5); + } + break; + case 2: + { + _localctx = new MathExpressionAtomContext(new ExpressionAtomContext(_parentctx, _parentState)); + ((MathExpressionAtomContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expressionAtom); + setState(7366); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(7367); + multOperator(); + setState(7368); + ((MathExpressionAtomContext)_localctx).right = expressionAtom(4); + } + break; + case 3: + { + _localctx = new MathExpressionAtomContext(new ExpressionAtomContext(_parentctx, _parentState)); + ((MathExpressionAtomContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expressionAtom); + setState(7370); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(7371); + addOperator(); + setState(7372); + ((MathExpressionAtomContext)_localctx).right = expressionAtom(3); + } + break; + case 4: + { + _localctx = new JsonExpressionAtomContext(new ExpressionAtomContext(_parentctx, _parentState)); + ((JsonExpressionAtomContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expressionAtom); + setState(7374); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(7375); + jsonOperator(); + setState(7376); + ((JsonExpressionAtomContext)_localctx).right = expressionAtom(2); + } + break; + case 5: + { + _localctx = new CollateExpressionAtomContext(new ExpressionAtomContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expressionAtom); + setState(7378); + if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)"); + setState(7379); + match(COLLATE); + setState(7380); + collationName(); + } + break; + } + } + } + setState(7385); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,1081,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UnaryOperatorContext extends ParserRuleContext { + public TerminalNode EXCLAMATION_SYMBOL() { return getToken(MySqlParser.EXCLAMATION_SYMBOL, 0); } + public TerminalNode BIT_NOT_OP() { return getToken(MySqlParser.BIT_NOT_OP, 0); } + public TerminalNode PLUS() { return getToken(MySqlParser.PLUS, 0); } + public TerminalNode MINUS() { return getToken(MySqlParser.MINUS, 0); } + public TerminalNode NOT() { return getToken(MySqlParser.NOT, 0); } + public UnaryOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unaryOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterUnaryOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitUnaryOperator(this); + } + } + + public final UnaryOperatorContext unaryOperator() throws RecognitionException { + UnaryOperatorContext _localctx = new UnaryOperatorContext(_ctx, getState()); + enterRule(_localctx, 694, RULE_unaryOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7386); + _la = _input.LA(1); + if ( !(_la==NOT || ((((_la - 1121)) & ~0x3f) == 0 && ((1L << (_la - 1121)) & 387L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ComparisonOperatorContext extends ParserRuleContext { + public TerminalNode EQUAL_SYMBOL() { return getToken(MySqlParser.EQUAL_SYMBOL, 0); } + public TerminalNode GREATER_SYMBOL() { return getToken(MySqlParser.GREATER_SYMBOL, 0); } + public TerminalNode LESS_SYMBOL() { return getToken(MySqlParser.LESS_SYMBOL, 0); } + public TerminalNode EXCLAMATION_SYMBOL() { return getToken(MySqlParser.EXCLAMATION_SYMBOL, 0); } + public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_comparisonOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterComparisonOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitComparisonOperator(this); + } + } + + public final ComparisonOperatorContext comparisonOperator() throws RecognitionException { + ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState()); + enterRule(_localctx, 696, RULE_comparisonOperator); + try { + setState(7402); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1082,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7388); + match(EQUAL_SYMBOL); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7389); + match(GREATER_SYMBOL); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7390); + match(LESS_SYMBOL); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7391); + match(LESS_SYMBOL); + setState(7392); + match(EQUAL_SYMBOL); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(7393); + match(GREATER_SYMBOL); + setState(7394); + match(EQUAL_SYMBOL); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(7395); + match(LESS_SYMBOL); + setState(7396); + match(GREATER_SYMBOL); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(7397); + match(EXCLAMATION_SYMBOL); + setState(7398); + match(EQUAL_SYMBOL); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(7399); + match(LESS_SYMBOL); + setState(7400); + match(EQUAL_SYMBOL); + setState(7401); + match(GREATER_SYMBOL); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LogicalOperatorContext extends ParserRuleContext { + public TerminalNode AND() { return getToken(MySqlParser.AND, 0); } + public List BIT_AND_OP() { return getTokens(MySqlParser.BIT_AND_OP); } + public TerminalNode BIT_AND_OP(int i) { + return getToken(MySqlParser.BIT_AND_OP, i); + } + public TerminalNode XOR() { return getToken(MySqlParser.XOR, 0); } + public TerminalNode OR() { return getToken(MySqlParser.OR, 0); } + public List BIT_OR_OP() { return getTokens(MySqlParser.BIT_OR_OP); } + public TerminalNode BIT_OR_OP(int i) { + return getToken(MySqlParser.BIT_OR_OP, i); + } + public LogicalOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_logicalOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterLogicalOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitLogicalOperator(this); + } + } + + public final LogicalOperatorContext logicalOperator() throws RecognitionException { + LogicalOperatorContext _localctx = new LogicalOperatorContext(_ctx, getState()); + enterRule(_localctx, 698, RULE_logicalOperator); + try { + setState(7411); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + enterOuterAlt(_localctx, 1); + { + setState(7404); + match(AND); + } + break; + case BIT_AND_OP: + enterOuterAlt(_localctx, 2); + { + setState(7405); + match(BIT_AND_OP); + setState(7406); + match(BIT_AND_OP); + } + break; + case XOR: + enterOuterAlt(_localctx, 3); + { + setState(7407); + match(XOR); + } + break; + case OR: + enterOuterAlt(_localctx, 4); + { + setState(7408); + match(OR); + } + break; + case BIT_OR_OP: + enterOuterAlt(_localctx, 5); + { + setState(7409); + match(BIT_OR_OP); + setState(7410); + match(BIT_OR_OP); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BitOperatorContext extends ParserRuleContext { + public List LESS_SYMBOL() { return getTokens(MySqlParser.LESS_SYMBOL); } + public TerminalNode LESS_SYMBOL(int i) { + return getToken(MySqlParser.LESS_SYMBOL, i); + } + public List GREATER_SYMBOL() { return getTokens(MySqlParser.GREATER_SYMBOL); } + public TerminalNode GREATER_SYMBOL(int i) { + return getToken(MySqlParser.GREATER_SYMBOL, i); + } + public TerminalNode BIT_AND_OP() { return getToken(MySqlParser.BIT_AND_OP, 0); } + public TerminalNode BIT_XOR_OP() { return getToken(MySqlParser.BIT_XOR_OP, 0); } + public TerminalNode BIT_OR_OP() { return getToken(MySqlParser.BIT_OR_OP, 0); } + public BitOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_bitOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterBitOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitBitOperator(this); + } + } + + public final BitOperatorContext bitOperator() throws RecognitionException { + BitOperatorContext _localctx = new BitOperatorContext(_ctx, getState()); + enterRule(_localctx, 700, RULE_bitOperator); + try { + setState(7420); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LESS_SYMBOL: + enterOuterAlt(_localctx, 1); + { + setState(7413); + match(LESS_SYMBOL); + setState(7414); + match(LESS_SYMBOL); + } + break; + case GREATER_SYMBOL: + enterOuterAlt(_localctx, 2); + { + setState(7415); + match(GREATER_SYMBOL); + setState(7416); + match(GREATER_SYMBOL); + } + break; + case BIT_AND_OP: + enterOuterAlt(_localctx, 3); + { + setState(7417); + match(BIT_AND_OP); + } + break; + case BIT_XOR_OP: + enterOuterAlt(_localctx, 4); + { + setState(7418); + match(BIT_XOR_OP); + } + break; + case BIT_OR_OP: + enterOuterAlt(_localctx, 5); + { + setState(7419); + match(BIT_OR_OP); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MultOperatorContext extends ParserRuleContext { + public TerminalNode STAR() { return getToken(MySqlParser.STAR, 0); } + public TerminalNode DIVIDE() { return getToken(MySqlParser.DIVIDE, 0); } + public TerminalNode MODULE() { return getToken(MySqlParser.MODULE, 0); } + public TerminalNode DIV() { return getToken(MySqlParser.DIV, 0); } + public TerminalNode MOD() { return getToken(MySqlParser.MOD, 0); } + public MultOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_multOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterMultOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitMultOperator(this); + } + } + + public final MultOperatorContext multOperator() throws RecognitionException { + MultOperatorContext _localctx = new MultOperatorContext(_ctx, getState()); + enterRule(_localctx, 702, RULE_multOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7422); + _la = _input.LA(1); + if ( !(((((_la - 1118)) & ~0x3f) == 0 && ((1L << (_la - 1118)) & 103L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AddOperatorContext extends ParserRuleContext { + public TerminalNode PLUS() { return getToken(MySqlParser.PLUS, 0); } + public TerminalNode MINUS() { return getToken(MySqlParser.MINUS, 0); } + public AddOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_addOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterAddOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitAddOperator(this); + } + } + + public final AddOperatorContext addOperator() throws RecognitionException { + AddOperatorContext _localctx = new AddOperatorContext(_ctx, getState()); + enterRule(_localctx, 704, RULE_addOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7424); + _la = _input.LA(1); + if ( !(_la==PLUS || _la==MINUS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class JsonOperatorContext extends ParserRuleContext { + public TerminalNode MINUS() { return getToken(MySqlParser.MINUS, 0); } + public List GREATER_SYMBOL() { return getTokens(MySqlParser.GREATER_SYMBOL); } + public TerminalNode GREATER_SYMBOL(int i) { + return getToken(MySqlParser.GREATER_SYMBOL, i); + } + public JsonOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_jsonOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterJsonOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitJsonOperator(this); + } + } + + public final JsonOperatorContext jsonOperator() throws RecognitionException { + JsonOperatorContext _localctx = new JsonOperatorContext(_ctx, getState()); + enterRule(_localctx, 706, RULE_jsonOperator); + try { + setState(7431); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,1085,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7426); + match(MINUS); + setState(7427); + match(GREATER_SYMBOL); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7428); + match(MINUS); + setState(7429); + match(GREATER_SYMBOL); + setState(7430); + match(GREATER_SYMBOL); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CharsetNameBaseContext extends ParserRuleContext { + public TerminalNode ARMSCII8() { return getToken(MySqlParser.ARMSCII8, 0); } + public TerminalNode ASCII() { return getToken(MySqlParser.ASCII, 0); } + public TerminalNode BIG5() { return getToken(MySqlParser.BIG5, 0); } + public TerminalNode BINARY() { return getToken(MySqlParser.BINARY, 0); } + public TerminalNode CP1250() { return getToken(MySqlParser.CP1250, 0); } + public TerminalNode CP1251() { return getToken(MySqlParser.CP1251, 0); } + public TerminalNode CP1256() { return getToken(MySqlParser.CP1256, 0); } + public TerminalNode CP1257() { return getToken(MySqlParser.CP1257, 0); } + public TerminalNode CP850() { return getToken(MySqlParser.CP850, 0); } + public TerminalNode CP852() { return getToken(MySqlParser.CP852, 0); } + public TerminalNode CP866() { return getToken(MySqlParser.CP866, 0); } + public TerminalNode CP932() { return getToken(MySqlParser.CP932, 0); } + public TerminalNode DEC8() { return getToken(MySqlParser.DEC8, 0); } + public TerminalNode EUCJPMS() { return getToken(MySqlParser.EUCJPMS, 0); } + public TerminalNode EUCKR() { return getToken(MySqlParser.EUCKR, 0); } + public TerminalNode GB18030() { return getToken(MySqlParser.GB18030, 0); } + public TerminalNode GB2312() { return getToken(MySqlParser.GB2312, 0); } + public TerminalNode GBK() { return getToken(MySqlParser.GBK, 0); } + public TerminalNode GEOSTD8() { return getToken(MySqlParser.GEOSTD8, 0); } + public TerminalNode GREEK() { return getToken(MySqlParser.GREEK, 0); } + public TerminalNode HEBREW() { return getToken(MySqlParser.HEBREW, 0); } + public TerminalNode HP8() { return getToken(MySqlParser.HP8, 0); } + public TerminalNode KEYBCS2() { return getToken(MySqlParser.KEYBCS2, 0); } + public TerminalNode KOI8R() { return getToken(MySqlParser.KOI8R, 0); } + public TerminalNode KOI8U() { return getToken(MySqlParser.KOI8U, 0); } + public TerminalNode LATIN1() { return getToken(MySqlParser.LATIN1, 0); } + public TerminalNode LATIN2() { return getToken(MySqlParser.LATIN2, 0); } + public TerminalNode LATIN5() { return getToken(MySqlParser.LATIN5, 0); } + public TerminalNode LATIN7() { return getToken(MySqlParser.LATIN7, 0); } + public TerminalNode MACCE() { return getToken(MySqlParser.MACCE, 0); } + public TerminalNode MACROMAN() { return getToken(MySqlParser.MACROMAN, 0); } + public TerminalNode SJIS() { return getToken(MySqlParser.SJIS, 0); } + public TerminalNode SWE7() { return getToken(MySqlParser.SWE7, 0); } + public TerminalNode TIS620() { return getToken(MySqlParser.TIS620, 0); } + public TerminalNode UCS2() { return getToken(MySqlParser.UCS2, 0); } + public TerminalNode UJIS() { return getToken(MySqlParser.UJIS, 0); } + public TerminalNode UTF16() { return getToken(MySqlParser.UTF16, 0); } + public TerminalNode UTF16LE() { return getToken(MySqlParser.UTF16LE, 0); } + public TerminalNode UTF32() { return getToken(MySqlParser.UTF32, 0); } + public TerminalNode UTF8() { return getToken(MySqlParser.UTF8, 0); } + public TerminalNode UTF8MB3() { return getToken(MySqlParser.UTF8MB3, 0); } + public TerminalNode UTF8MB4() { return getToken(MySqlParser.UTF8MB4, 0); } + public CharsetNameBaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_charsetNameBase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterCharsetNameBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitCharsetNameBase(this); + } + } + + public final CharsetNameBaseContext charsetNameBase() throws RecognitionException { + CharsetNameBaseContext _localctx = new CharsetNameBaseContext(_ctx, getState()); + enterRule(_localctx, 708, RULE_charsetNameBase); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7433); + _la = _input.LA(1); + if ( !(_la==BINARY || ((((_la - 747)) & ~0x3f) == 0 && ((1L << (_la - 747)) & 2199023255551L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TransactionLevelBaseContext extends ParserRuleContext { + public TerminalNode REPEATABLE() { return getToken(MySqlParser.REPEATABLE, 0); } + public TerminalNode COMMITTED() { return getToken(MySqlParser.COMMITTED, 0); } + public TerminalNode UNCOMMITTED() { return getToken(MySqlParser.UNCOMMITTED, 0); } + public TerminalNode SERIALIZABLE() { return getToken(MySqlParser.SERIALIZABLE, 0); } + public TransactionLevelBaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transactionLevelBase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterTransactionLevelBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitTransactionLevelBase(this); + } + } + + public final TransactionLevelBaseContext transactionLevelBase() throws RecognitionException { + TransactionLevelBaseContext _localctx = new TransactionLevelBaseContext(_ctx, getState()); + enterRule(_localctx, 710, RULE_transactionLevelBase); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7435); + _la = _input.LA(1); + if ( !(((((_la - 800)) & ~0x3f) == 0 && ((1L << (_la - 800)) & 15L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrivilegesBaseContext extends ParserRuleContext { + public TerminalNode TABLES() { return getToken(MySqlParser.TABLES, 0); } + public TerminalNode ROUTINE() { return getToken(MySqlParser.ROUTINE, 0); } + public TerminalNode EXECUTE() { return getToken(MySqlParser.EXECUTE, 0); } + public TerminalNode FILE() { return getToken(MySqlParser.FILE, 0); } + public TerminalNode PROCESS() { return getToken(MySqlParser.PROCESS, 0); } + public TerminalNode RELOAD() { return getToken(MySqlParser.RELOAD, 0); } + public TerminalNode SHUTDOWN() { return getToken(MySqlParser.SHUTDOWN, 0); } + public TerminalNode SUPER() { return getToken(MySqlParser.SUPER, 0); } + public TerminalNode PRIVILEGES() { return getToken(MySqlParser.PRIVILEGES, 0); } + public PrivilegesBaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_privilegesBase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterPrivilegesBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitPrivilegesBase(this); + } + } + + public final PrivilegesBaseContext privilegesBase() throws RecognitionException { + PrivilegesBaseContext _localctx = new PrivilegesBaseContext(_ctx, getState()); + enterRule(_localctx, 712, RULE_privilegesBase); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7437); + _la = _input.LA(1); + if ( !(((((_la - 709)) & ~0x3f) == 0 && ((1L << (_la - 709)) & 23656792067L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IntervalTypeBaseContext extends ParserRuleContext { + public TerminalNode QUARTER() { return getToken(MySqlParser.QUARTER, 0); } + public TerminalNode MONTH() { return getToken(MySqlParser.MONTH, 0); } + public TerminalNode DAY() { return getToken(MySqlParser.DAY, 0); } + public TerminalNode HOUR() { return getToken(MySqlParser.HOUR, 0); } + public TerminalNode MINUTE() { return getToken(MySqlParser.MINUTE, 0); } + public TerminalNode WEEK() { return getToken(MySqlParser.WEEK, 0); } + public TerminalNode SECOND() { return getToken(MySqlParser.SECOND, 0); } + public TerminalNode MICROSECOND() { return getToken(MySqlParser.MICROSECOND, 0); } + public IntervalTypeBaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_intervalTypeBase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterIntervalTypeBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitIntervalTypeBase(this); + } + } + + public final IntervalTypeBaseContext intervalTypeBase() throws RecognitionException { + IntervalTypeBaseContext _localctx = new IntervalTypeBaseContext(_ctx, getState()); + enterRule(_localctx, 714, RULE_intervalTypeBase); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7439); + _la = _input.LA(1); + if ( !(((((_la - 690)) & ~0x3f) == 0 && ((1L << (_la - 690)) & 255L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DataTypeBaseContext extends ParserRuleContext { + public TerminalNode DATE() { return getToken(MySqlParser.DATE, 0); } + public TerminalNode TIME() { return getToken(MySqlParser.TIME, 0); } + public TerminalNode TIMESTAMP() { return getToken(MySqlParser.TIMESTAMP, 0); } + public TerminalNode DATETIME() { return getToken(MySqlParser.DATETIME, 0); } + public TerminalNode YEAR() { return getToken(MySqlParser.YEAR, 0); } + public TerminalNode ENUM() { return getToken(MySqlParser.ENUM, 0); } + public TerminalNode TEXT() { return getToken(MySqlParser.TEXT, 0); } + public DataTypeBaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dataTypeBase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterDataTypeBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitDataTypeBase(this); + } + } + + public final DataTypeBaseContext dataTypeBase() throws RecognitionException { + DataTypeBaseContext _localctx = new DataTypeBaseContext(_ctx, getState()); + enterRule(_localctx, 716, RULE_dataTypeBase); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7441); + _la = _input.LA(1); + if ( !(((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & 1179679L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class KeywordsCanBeIdContext extends ParserRuleContext { + public TerminalNode ACCOUNT() { return getToken(MySqlParser.ACCOUNT, 0); } + public TerminalNode ACTION() { return getToken(MySqlParser.ACTION, 0); } + public TerminalNode ADMIN() { return getToken(MySqlParser.ADMIN, 0); } + public TerminalNode AFTER() { return getToken(MySqlParser.AFTER, 0); } + public TerminalNode AGGREGATE() { return getToken(MySqlParser.AGGREGATE, 0); } + public TerminalNode ALGORITHM() { return getToken(MySqlParser.ALGORITHM, 0); } + public TerminalNode ANY() { return getToken(MySqlParser.ANY, 0); } + public TerminalNode ARRAY() { return getToken(MySqlParser.ARRAY, 0); } + public TerminalNode AT() { return getToken(MySqlParser.AT, 0); } + public TerminalNode AUDIT_ADMIN() { return getToken(MySqlParser.AUDIT_ADMIN, 0); } + public TerminalNode AUDIT_ABORT_EXEMPT() { return getToken(MySqlParser.AUDIT_ABORT_EXEMPT, 0); } + public TerminalNode AUTHORS() { return getToken(MySqlParser.AUTHORS, 0); } + public TerminalNode AUTOCOMMIT() { return getToken(MySqlParser.AUTOCOMMIT, 0); } + public TerminalNode AUTOEXTEND_SIZE() { return getToken(MySqlParser.AUTOEXTEND_SIZE, 0); } + public TerminalNode AUTO_INCREMENT() { return getToken(MySqlParser.AUTO_INCREMENT, 0); } + public TerminalNode AUTHENTICATION_POLICY_ADMIN() { return getToken(MySqlParser.AUTHENTICATION_POLICY_ADMIN, 0); } + public TerminalNode AVG() { return getToken(MySqlParser.AVG, 0); } + public TerminalNode AVG_ROW_LENGTH() { return getToken(MySqlParser.AVG_ROW_LENGTH, 0); } + public TerminalNode ATTRIBUTE() { return getToken(MySqlParser.ATTRIBUTE, 0); } + public TerminalNode BACKUP_ADMIN() { return getToken(MySqlParser.BACKUP_ADMIN, 0); } + public TerminalNode BEGIN() { return getToken(MySqlParser.BEGIN, 0); } + public TerminalNode BINLOG() { return getToken(MySqlParser.BINLOG, 0); } + public TerminalNode BINLOG_ADMIN() { return getToken(MySqlParser.BINLOG_ADMIN, 0); } + public TerminalNode BINLOG_ENCRYPTION_ADMIN() { return getToken(MySqlParser.BINLOG_ENCRYPTION_ADMIN, 0); } + public TerminalNode BIT() { return getToken(MySqlParser.BIT, 0); } + public TerminalNode BIT_AND() { return getToken(MySqlParser.BIT_AND, 0); } + public TerminalNode BIT_OR() { return getToken(MySqlParser.BIT_OR, 0); } + public TerminalNode BIT_XOR() { return getToken(MySqlParser.BIT_XOR, 0); } + public TerminalNode BLOCK() { return getToken(MySqlParser.BLOCK, 0); } + public TerminalNode BOOL() { return getToken(MySqlParser.BOOL, 0); } + public TerminalNode BOOLEAN() { return getToken(MySqlParser.BOOLEAN, 0); } + public TerminalNode BTREE() { return getToken(MySqlParser.BTREE, 0); } + public TerminalNode BUCKETS() { return getToken(MySqlParser.BUCKETS, 0); } + public TerminalNode CACHE() { return getToken(MySqlParser.CACHE, 0); } + public TerminalNode CASCADED() { return getToken(MySqlParser.CASCADED, 0); } + public TerminalNode CHAIN() { return getToken(MySqlParser.CHAIN, 0); } + public TerminalNode CHANGED() { return getToken(MySqlParser.CHANGED, 0); } + public TerminalNode CHANNEL() { return getToken(MySqlParser.CHANNEL, 0); } + public TerminalNode CHECKSUM() { return getToken(MySqlParser.CHECKSUM, 0); } + public TerminalNode PAGE_CHECKSUM() { return getToken(MySqlParser.PAGE_CHECKSUM, 0); } + public TerminalNode CATALOG_NAME() { return getToken(MySqlParser.CATALOG_NAME, 0); } + public TerminalNode CIPHER() { return getToken(MySqlParser.CIPHER, 0); } + public TerminalNode CLASS_ORIGIN() { return getToken(MySqlParser.CLASS_ORIGIN, 0); } + public TerminalNode CLIENT() { return getToken(MySqlParser.CLIENT, 0); } + public TerminalNode CLONE_ADMIN() { return getToken(MySqlParser.CLONE_ADMIN, 0); } + public TerminalNode CLOSE() { return getToken(MySqlParser.CLOSE, 0); } + public TerminalNode CLUSTERING() { return getToken(MySqlParser.CLUSTERING, 0); } + public TerminalNode COALESCE() { return getToken(MySqlParser.COALESCE, 0); } + public TerminalNode CODE() { return getToken(MySqlParser.CODE, 0); } + public TerminalNode COLUMNS() { return getToken(MySqlParser.COLUMNS, 0); } + public TerminalNode COLUMN_FORMAT() { return getToken(MySqlParser.COLUMN_FORMAT, 0); } + public TerminalNode COLUMN_NAME() { return getToken(MySqlParser.COLUMN_NAME, 0); } + public TerminalNode COMMENT() { return getToken(MySqlParser.COMMENT, 0); } + public TerminalNode COMMIT() { return getToken(MySqlParser.COMMIT, 0); } + public TerminalNode COMPACT() { return getToken(MySqlParser.COMPACT, 0); } + public TerminalNode COMPLETION() { return getToken(MySqlParser.COMPLETION, 0); } + public TerminalNode COMPRESSED() { return getToken(MySqlParser.COMPRESSED, 0); } + public TerminalNode COMPRESSION() { return getToken(MySqlParser.COMPRESSION, 0); } + public TerminalNode CONCURRENT() { return getToken(MySqlParser.CONCURRENT, 0); } + public TerminalNode CONDITION() { return getToken(MySqlParser.CONDITION, 0); } + public TerminalNode CONNECT() { return getToken(MySqlParser.CONNECT, 0); } + public TerminalNode CONNECTION() { return getToken(MySqlParser.CONNECTION, 0); } + public TerminalNode CONNECTION_ADMIN() { return getToken(MySqlParser.CONNECTION_ADMIN, 0); } + public TerminalNode CONSISTENT() { return getToken(MySqlParser.CONSISTENT, 0); } + public TerminalNode CONSTRAINT_CATALOG() { return getToken(MySqlParser.CONSTRAINT_CATALOG, 0); } + public TerminalNode CONSTRAINT_NAME() { return getToken(MySqlParser.CONSTRAINT_NAME, 0); } + public TerminalNode CONSTRAINT_SCHEMA() { return getToken(MySqlParser.CONSTRAINT_SCHEMA, 0); } + public TerminalNode CONTAINS() { return getToken(MySqlParser.CONTAINS, 0); } + public TerminalNode CONTEXT() { return getToken(MySqlParser.CONTEXT, 0); } + public TerminalNode CONTRIBUTORS() { return getToken(MySqlParser.CONTRIBUTORS, 0); } + public TerminalNode COPY() { return getToken(MySqlParser.COPY, 0); } + public TerminalNode COUNT() { return getToken(MySqlParser.COUNT, 0); } + public TerminalNode CPU() { return getToken(MySqlParser.CPU, 0); } + public TerminalNode CURRENT() { return getToken(MySqlParser.CURRENT, 0); } + public TerminalNode CURRENT_USER() { return getToken(MySqlParser.CURRENT_USER, 0); } + public TerminalNode CURSOR_NAME() { return getToken(MySqlParser.CURSOR_NAME, 0); } + public TerminalNode DATA() { return getToken(MySqlParser.DATA, 0); } + public TerminalNode DATAFILE() { return getToken(MySqlParser.DATAFILE, 0); } + public TerminalNode DEALLOCATE() { return getToken(MySqlParser.DEALLOCATE, 0); } + public TerminalNode DEFAULT() { return getToken(MySqlParser.DEFAULT, 0); } + public TerminalNode DEFAULT_AUTH() { return getToken(MySqlParser.DEFAULT_AUTH, 0); } + public TerminalNode DEFINER() { return getToken(MySqlParser.DEFINER, 0); } + public TerminalNode DELAY_KEY_WRITE() { return getToken(MySqlParser.DELAY_KEY_WRITE, 0); } + public TerminalNode DES_KEY_FILE() { return getToken(MySqlParser.DES_KEY_FILE, 0); } + public TerminalNode DIAGNOSTICS() { return getToken(MySqlParser.DIAGNOSTICS, 0); } + public TerminalNode DIRECTORY() { return getToken(MySqlParser.DIRECTORY, 0); } + public TerminalNode DISABLE() { return getToken(MySqlParser.DISABLE, 0); } + public TerminalNode DISCARD() { return getToken(MySqlParser.DISCARD, 0); } + public TerminalNode DISK() { return getToken(MySqlParser.DISK, 0); } + public TerminalNode DO() { return getToken(MySqlParser.DO, 0); } + public TerminalNode DUMPFILE() { return getToken(MySqlParser.DUMPFILE, 0); } + public TerminalNode DUPLICATE() { return getToken(MySqlParser.DUPLICATE, 0); } + public TerminalNode DYNAMIC() { return getToken(MySqlParser.DYNAMIC, 0); } + public TerminalNode EMPTY() { return getToken(MySqlParser.EMPTY, 0); } + public TerminalNode ENABLE() { return getToken(MySqlParser.ENABLE, 0); } + public TerminalNode ENCRYPTION() { return getToken(MySqlParser.ENCRYPTION, 0); } + public TerminalNode ENCRYPTION_KEY_ADMIN() { return getToken(MySqlParser.ENCRYPTION_KEY_ADMIN, 0); } + public TerminalNode END() { return getToken(MySqlParser.END, 0); } + public TerminalNode ENDS() { return getToken(MySqlParser.ENDS, 0); } + public TerminalNode ENGINE() { return getToken(MySqlParser.ENGINE, 0); } + public TerminalNode ENGINE_ATTRIBUTE() { return getToken(MySqlParser.ENGINE_ATTRIBUTE, 0); } + public TerminalNode ENGINES() { return getToken(MySqlParser.ENGINES, 0); } + public TerminalNode ENFORCED() { return getToken(MySqlParser.ENFORCED, 0); } + public TerminalNode ERROR() { return getToken(MySqlParser.ERROR, 0); } + public TerminalNode ERRORS() { return getToken(MySqlParser.ERRORS, 0); } + public TerminalNode ESCAPE() { return getToken(MySqlParser.ESCAPE, 0); } + public TerminalNode EUR() { return getToken(MySqlParser.EUR, 0); } + public TerminalNode EVEN() { return getToken(MySqlParser.EVEN, 0); } + public TerminalNode EVENT() { return getToken(MySqlParser.EVENT, 0); } + public TerminalNode EVENTS() { return getToken(MySqlParser.EVENTS, 0); } + public TerminalNode EVERY() { return getToken(MySqlParser.EVERY, 0); } + public TerminalNode EXCEPT() { return getToken(MySqlParser.EXCEPT, 0); } + public TerminalNode EXCHANGE() { return getToken(MySqlParser.EXCHANGE, 0); } + public TerminalNode EXCLUSIVE() { return getToken(MySqlParser.EXCLUSIVE, 0); } + public TerminalNode EXPIRE() { return getToken(MySqlParser.EXPIRE, 0); } + public TerminalNode EXPORT() { return getToken(MySqlParser.EXPORT, 0); } + public TerminalNode EXTENDED() { return getToken(MySqlParser.EXTENDED, 0); } + public TerminalNode EXTENT_SIZE() { return getToken(MySqlParser.EXTENT_SIZE, 0); } + public TerminalNode FAILED_LOGIN_ATTEMPTS() { return getToken(MySqlParser.FAILED_LOGIN_ATTEMPTS, 0); } + public TerminalNode FAST() { return getToken(MySqlParser.FAST, 0); } + public TerminalNode FAULTS() { return getToken(MySqlParser.FAULTS, 0); } + public TerminalNode FIELDS() { return getToken(MySqlParser.FIELDS, 0); } + public TerminalNode FILE_BLOCK_SIZE() { return getToken(MySqlParser.FILE_BLOCK_SIZE, 0); } + public TerminalNode FILTER() { return getToken(MySqlParser.FILTER, 0); } + public TerminalNode FIREWALL_ADMIN() { return getToken(MySqlParser.FIREWALL_ADMIN, 0); } + public TerminalNode FIREWALL_EXEMPT() { return getToken(MySqlParser.FIREWALL_EXEMPT, 0); } + public TerminalNode FIREWALL_USER() { return getToken(MySqlParser.FIREWALL_USER, 0); } + public TerminalNode FIRST() { return getToken(MySqlParser.FIRST, 0); } + public TerminalNode FIXED() { return getToken(MySqlParser.FIXED, 0); } + public TerminalNode FLUSH() { return getToken(MySqlParser.FLUSH, 0); } + public TerminalNode FOLLOWS() { return getToken(MySqlParser.FOLLOWS, 0); } + public TerminalNode FOUND() { return getToken(MySqlParser.FOUND, 0); } + public TerminalNode FULL() { return getToken(MySqlParser.FULL, 0); } + public TerminalNode FUNCTION() { return getToken(MySqlParser.FUNCTION, 0); } + public TerminalNode GENERAL() { return getToken(MySqlParser.GENERAL, 0); } + public TerminalNode GLOBAL() { return getToken(MySqlParser.GLOBAL, 0); } + public TerminalNode GRANTS() { return getToken(MySqlParser.GRANTS, 0); } + public TerminalNode GROUP() { return getToken(MySqlParser.GROUP, 0); } + public TerminalNode GROUP_CONCAT() { return getToken(MySqlParser.GROUP_CONCAT, 0); } + public TerminalNode GROUP_REPLICATION() { return getToken(MySqlParser.GROUP_REPLICATION, 0); } + public TerminalNode GROUP_REPLICATION_ADMIN() { return getToken(MySqlParser.GROUP_REPLICATION_ADMIN, 0); } + public TerminalNode HANDLER() { return getToken(MySqlParser.HANDLER, 0); } + public TerminalNode HASH() { return getToken(MySqlParser.HASH, 0); } + public TerminalNode HELP() { return getToken(MySqlParser.HELP, 0); } + public TerminalNode HISTORY() { return getToken(MySqlParser.HISTORY, 0); } + public TerminalNode HOST() { return getToken(MySqlParser.HOST, 0); } + public TerminalNode HOSTS() { return getToken(MySqlParser.HOSTS, 0); } + public TerminalNode IDENTIFIED() { return getToken(MySqlParser.IDENTIFIED, 0); } + public TerminalNode IGNORED() { return getToken(MySqlParser.IGNORED, 0); } + public TerminalNode IGNORE_SERVER_IDS() { return getToken(MySqlParser.IGNORE_SERVER_IDS, 0); } + public TerminalNode IMPORT() { return getToken(MySqlParser.IMPORT, 0); } + public TerminalNode INDEXES() { return getToken(MySqlParser.INDEXES, 0); } + public TerminalNode INITIAL_SIZE() { return getToken(MySqlParser.INITIAL_SIZE, 0); } + public TerminalNode INNODB_REDO_LOG_ARCHIVE() { return getToken(MySqlParser.INNODB_REDO_LOG_ARCHIVE, 0); } + public TerminalNode INPLACE() { return getToken(MySqlParser.INPLACE, 0); } + public TerminalNode INSERT_METHOD() { return getToken(MySqlParser.INSERT_METHOD, 0); } + public TerminalNode INSTALL() { return getToken(MySqlParser.INSTALL, 0); } + public TerminalNode INSTANCE() { return getToken(MySqlParser.INSTANCE, 0); } + public TerminalNode INSTANT() { return getToken(MySqlParser.INSTANT, 0); } + public TerminalNode INTERNAL() { return getToken(MySqlParser.INTERNAL, 0); } + public TerminalNode INVOKE() { return getToken(MySqlParser.INVOKE, 0); } + public TerminalNode INVOKER() { return getToken(MySqlParser.INVOKER, 0); } + public TerminalNode IO() { return getToken(MySqlParser.IO, 0); } + public TerminalNode IO_THREAD() { return getToken(MySqlParser.IO_THREAD, 0); } + public TerminalNode IPC() { return getToken(MySqlParser.IPC, 0); } + public TerminalNode ISO() { return getToken(MySqlParser.ISO, 0); } + public TerminalNode ISOLATION() { return getToken(MySqlParser.ISOLATION, 0); } + public TerminalNode ISSUER() { return getToken(MySqlParser.ISSUER, 0); } + public TerminalNode JIS() { return getToken(MySqlParser.JIS, 0); } + public TerminalNode JSON() { return getToken(MySqlParser.JSON, 0); } + public TerminalNode KEY_BLOCK_SIZE() { return getToken(MySqlParser.KEY_BLOCK_SIZE, 0); } + public TerminalNode LAMBDA() { return getToken(MySqlParser.LAMBDA, 0); } + public TerminalNode LANGUAGE() { return getToken(MySqlParser.LANGUAGE, 0); } + public TerminalNode LAST() { return getToken(MySqlParser.LAST, 0); } + public TerminalNode LATERAL() { return getToken(MySqlParser.LATERAL, 0); } + public TerminalNode LEAVES() { return getToken(MySqlParser.LEAVES, 0); } + public TerminalNode LESS() { return getToken(MySqlParser.LESS, 0); } + public TerminalNode LEVEL() { return getToken(MySqlParser.LEVEL, 0); } + public TerminalNode LIST() { return getToken(MySqlParser.LIST, 0); } + public TerminalNode LOCAL() { return getToken(MySqlParser.LOCAL, 0); } + public TerminalNode LOGFILE() { return getToken(MySqlParser.LOGFILE, 0); } + public TerminalNode LOGS() { return getToken(MySqlParser.LOGS, 0); } + public TerminalNode MASTER() { return getToken(MySqlParser.MASTER, 0); } + public TerminalNode MASTER_AUTO_POSITION() { return getToken(MySqlParser.MASTER_AUTO_POSITION, 0); } + public TerminalNode MASTER_CONNECT_RETRY() { return getToken(MySqlParser.MASTER_CONNECT_RETRY, 0); } + public TerminalNode MASTER_DELAY() { return getToken(MySqlParser.MASTER_DELAY, 0); } + public TerminalNode MASTER_HEARTBEAT_PERIOD() { return getToken(MySqlParser.MASTER_HEARTBEAT_PERIOD, 0); } + public TerminalNode MASTER_HOST() { return getToken(MySqlParser.MASTER_HOST, 0); } + public TerminalNode MASTER_LOG_FILE() { return getToken(MySqlParser.MASTER_LOG_FILE, 0); } + public TerminalNode MASTER_LOG_POS() { return getToken(MySqlParser.MASTER_LOG_POS, 0); } + public TerminalNode MASTER_PASSWORD() { return getToken(MySqlParser.MASTER_PASSWORD, 0); } + public TerminalNode MASTER_PORT() { return getToken(MySqlParser.MASTER_PORT, 0); } + public TerminalNode MASTER_RETRY_COUNT() { return getToken(MySqlParser.MASTER_RETRY_COUNT, 0); } + public TerminalNode MASTER_SSL() { return getToken(MySqlParser.MASTER_SSL, 0); } + public TerminalNode MASTER_SSL_CA() { return getToken(MySqlParser.MASTER_SSL_CA, 0); } + public TerminalNode MASTER_SSL_CAPATH() { return getToken(MySqlParser.MASTER_SSL_CAPATH, 0); } + public TerminalNode MASTER_SSL_CERT() { return getToken(MySqlParser.MASTER_SSL_CERT, 0); } + public TerminalNode MASTER_SSL_CIPHER() { return getToken(MySqlParser.MASTER_SSL_CIPHER, 0); } + public TerminalNode MASTER_SSL_CRL() { return getToken(MySqlParser.MASTER_SSL_CRL, 0); } + public TerminalNode MASTER_SSL_CRLPATH() { return getToken(MySqlParser.MASTER_SSL_CRLPATH, 0); } + public TerminalNode MASTER_SSL_KEY() { return getToken(MySqlParser.MASTER_SSL_KEY, 0); } + public TerminalNode MASTER_TLS_VERSION() { return getToken(MySqlParser.MASTER_TLS_VERSION, 0); } + public TerminalNode MASTER_USER() { return getToken(MySqlParser.MASTER_USER, 0); } + public TerminalNode MAX_CONNECTIONS_PER_HOUR() { return getToken(MySqlParser.MAX_CONNECTIONS_PER_HOUR, 0); } + public TerminalNode MAX_QUERIES_PER_HOUR() { return getToken(MySqlParser.MAX_QUERIES_PER_HOUR, 0); } + public TerminalNode MAX() { return getToken(MySqlParser.MAX, 0); } + public TerminalNode MAX_ROWS() { return getToken(MySqlParser.MAX_ROWS, 0); } + public TerminalNode MAX_SIZE() { return getToken(MySqlParser.MAX_SIZE, 0); } + public TerminalNode MAX_UPDATES_PER_HOUR() { return getToken(MySqlParser.MAX_UPDATES_PER_HOUR, 0); } + public TerminalNode MAX_USER_CONNECTIONS() { return getToken(MySqlParser.MAX_USER_CONNECTIONS, 0); } + public TerminalNode MEDIUM() { return getToken(MySqlParser.MEDIUM, 0); } + public TerminalNode MEMBER() { return getToken(MySqlParser.MEMBER, 0); } + public TerminalNode MEMORY() { return getToken(MySqlParser.MEMORY, 0); } + public TerminalNode MERGE() { return getToken(MySqlParser.MERGE, 0); } + public TerminalNode MESSAGE_TEXT() { return getToken(MySqlParser.MESSAGE_TEXT, 0); } + public TerminalNode MID() { return getToken(MySqlParser.MID, 0); } + public TerminalNode MIGRATE() { return getToken(MySqlParser.MIGRATE, 0); } + public TerminalNode MIN() { return getToken(MySqlParser.MIN, 0); } + public TerminalNode MIN_ROWS() { return getToken(MySqlParser.MIN_ROWS, 0); } + public TerminalNode MODE() { return getToken(MySqlParser.MODE, 0); } + public TerminalNode MODIFY() { return getToken(MySqlParser.MODIFY, 0); } + public TerminalNode MUTEX() { return getToken(MySqlParser.MUTEX, 0); } + public TerminalNode MYSQL() { return getToken(MySqlParser.MYSQL, 0); } + public TerminalNode MYSQL_ERRNO() { return getToken(MySqlParser.MYSQL_ERRNO, 0); } + public TerminalNode NAME() { return getToken(MySqlParser.NAME, 0); } + public TerminalNode NAMES() { return getToken(MySqlParser.NAMES, 0); } + public TerminalNode NCHAR() { return getToken(MySqlParser.NCHAR, 0); } + public TerminalNode NDB_STORED_USER() { return getToken(MySqlParser.NDB_STORED_USER, 0); } + public TerminalNode NESTED() { return getToken(MySqlParser.NESTED, 0); } + public TerminalNode NEVER() { return getToken(MySqlParser.NEVER, 0); } + public TerminalNode NEXT() { return getToken(MySqlParser.NEXT, 0); } + public TerminalNode NO() { return getToken(MySqlParser.NO, 0); } + public TerminalNode NOCOPY() { return getToken(MySqlParser.NOCOPY, 0); } + public TerminalNode NODEGROUP() { return getToken(MySqlParser.NODEGROUP, 0); } + public TerminalNode NONE() { return getToken(MySqlParser.NONE, 0); } + public TerminalNode NOWAIT() { return getToken(MySqlParser.NOWAIT, 0); } + public TerminalNode NUMBER() { return getToken(MySqlParser.NUMBER, 0); } + public TerminalNode ODBC() { return getToken(MySqlParser.ODBC, 0); } + public TerminalNode OFFLINE() { return getToken(MySqlParser.OFFLINE, 0); } + public TerminalNode OFFSET() { return getToken(MySqlParser.OFFSET, 0); } + public TerminalNode OF() { return getToken(MySqlParser.OF, 0); } + public TerminalNode OJ() { return getToken(MySqlParser.OJ, 0); } + public TerminalNode OLD_PASSWORD() { return getToken(MySqlParser.OLD_PASSWORD, 0); } + public TerminalNode ONE() { return getToken(MySqlParser.ONE, 0); } + public TerminalNode ONLINE() { return getToken(MySqlParser.ONLINE, 0); } + public TerminalNode ONLY() { return getToken(MySqlParser.ONLY, 0); } + public TerminalNode OPEN() { return getToken(MySqlParser.OPEN, 0); } + public TerminalNode OPTIMIZER_COSTS() { return getToken(MySqlParser.OPTIMIZER_COSTS, 0); } + public TerminalNode OPTIONAL() { return getToken(MySqlParser.OPTIONAL, 0); } + public TerminalNode OPTIONS() { return getToken(MySqlParser.OPTIONS, 0); } + public TerminalNode ORDER() { return getToken(MySqlParser.ORDER, 0); } + public TerminalNode ORDINALITY() { return getToken(MySqlParser.ORDINALITY, 0); } + public TerminalNode OWNER() { return getToken(MySqlParser.OWNER, 0); } + public TerminalNode PACK_KEYS() { return getToken(MySqlParser.PACK_KEYS, 0); } + public TerminalNode PAGE() { return getToken(MySqlParser.PAGE, 0); } + public TerminalNode PARSER() { return getToken(MySqlParser.PARSER, 0); } + public TerminalNode PARTIAL() { return getToken(MySqlParser.PARTIAL, 0); } + public TerminalNode PARTITIONING() { return getToken(MySqlParser.PARTITIONING, 0); } + public TerminalNode PARTITIONS() { return getToken(MySqlParser.PARTITIONS, 0); } + public TerminalNode PASSWORD() { return getToken(MySqlParser.PASSWORD, 0); } + public TerminalNode PASSWORDLESS_USER_ADMIN() { return getToken(MySqlParser.PASSWORDLESS_USER_ADMIN, 0); } + public TerminalNode PASSWORD_LOCK_TIME() { return getToken(MySqlParser.PASSWORD_LOCK_TIME, 0); } + public TerminalNode PATH() { return getToken(MySqlParser.PATH, 0); } + public TerminalNode PERSIST_RO_VARIABLES_ADMIN() { return getToken(MySqlParser.PERSIST_RO_VARIABLES_ADMIN, 0); } + public TerminalNode PHASE() { return getToken(MySqlParser.PHASE, 0); } + public TerminalNode PLUGINS() { return getToken(MySqlParser.PLUGINS, 0); } + public TerminalNode PLUGIN_DIR() { return getToken(MySqlParser.PLUGIN_DIR, 0); } + public TerminalNode PLUGIN() { return getToken(MySqlParser.PLUGIN, 0); } + public TerminalNode PORT() { return getToken(MySqlParser.PORT, 0); } + public TerminalNode PRECEDES() { return getToken(MySqlParser.PRECEDES, 0); } + public TerminalNode PREPARE() { return getToken(MySqlParser.PREPARE, 0); } + public TerminalNode PRESERVE() { return getToken(MySqlParser.PRESERVE, 0); } + public TerminalNode PREV() { return getToken(MySqlParser.PREV, 0); } + public TerminalNode PRIMARY() { return getToken(MySqlParser.PRIMARY, 0); } + public TerminalNode PROCESSLIST() { return getToken(MySqlParser.PROCESSLIST, 0); } + public TerminalNode PROFILE() { return getToken(MySqlParser.PROFILE, 0); } + public TerminalNode PROFILES() { return getToken(MySqlParser.PROFILES, 0); } + public TerminalNode PROXY() { return getToken(MySqlParser.PROXY, 0); } + public TerminalNode QUERY() { return getToken(MySqlParser.QUERY, 0); } + public TerminalNode QUICK() { return getToken(MySqlParser.QUICK, 0); } + public TerminalNode REBUILD() { return getToken(MySqlParser.REBUILD, 0); } + public TerminalNode RECOVER() { return getToken(MySqlParser.RECOVER, 0); } + public TerminalNode RECURSIVE() { return getToken(MySqlParser.RECURSIVE, 0); } + public TerminalNode REDO_BUFFER_SIZE() { return getToken(MySqlParser.REDO_BUFFER_SIZE, 0); } + public TerminalNode REDUNDANT() { return getToken(MySqlParser.REDUNDANT, 0); } + public TerminalNode RELAY() { return getToken(MySqlParser.RELAY, 0); } + public TerminalNode RELAYLOG() { return getToken(MySqlParser.RELAYLOG, 0); } + public TerminalNode RELAY_LOG_FILE() { return getToken(MySqlParser.RELAY_LOG_FILE, 0); } + public TerminalNode RELAY_LOG_POS() { return getToken(MySqlParser.RELAY_LOG_POS, 0); } + public TerminalNode REMOVE() { return getToken(MySqlParser.REMOVE, 0); } + public TerminalNode REORGANIZE() { return getToken(MySqlParser.REORGANIZE, 0); } + public TerminalNode REPAIR() { return getToken(MySqlParser.REPAIR, 0); } + public TerminalNode REPLICATE_DO_DB() { return getToken(MySqlParser.REPLICATE_DO_DB, 0); } + public TerminalNode REPLICATE_DO_TABLE() { return getToken(MySqlParser.REPLICATE_DO_TABLE, 0); } + public TerminalNode REPLICATE_IGNORE_DB() { return getToken(MySqlParser.REPLICATE_IGNORE_DB, 0); } + public TerminalNode REPLICATE_IGNORE_TABLE() { return getToken(MySqlParser.REPLICATE_IGNORE_TABLE, 0); } + public TerminalNode REPLICATE_REWRITE_DB() { return getToken(MySqlParser.REPLICATE_REWRITE_DB, 0); } + public TerminalNode REPLICATE_WILD_DO_TABLE() { return getToken(MySqlParser.REPLICATE_WILD_DO_TABLE, 0); } + public TerminalNode REPLICATE_WILD_IGNORE_TABLE() { return getToken(MySqlParser.REPLICATE_WILD_IGNORE_TABLE, 0); } + public TerminalNode REPLICATION() { return getToken(MySqlParser.REPLICATION, 0); } + public TerminalNode REPLICATION_APPLIER() { return getToken(MySqlParser.REPLICATION_APPLIER, 0); } + public TerminalNode REPLICATION_SLAVE_ADMIN() { return getToken(MySqlParser.REPLICATION_SLAVE_ADMIN, 0); } + public TerminalNode RESET() { return getToken(MySqlParser.RESET, 0); } + public TerminalNode RESOURCE_GROUP_ADMIN() { return getToken(MySqlParser.RESOURCE_GROUP_ADMIN, 0); } + public TerminalNode RESOURCE_GROUP_USER() { return getToken(MySqlParser.RESOURCE_GROUP_USER, 0); } + public TerminalNode RESUME() { return getToken(MySqlParser.RESUME, 0); } + public TerminalNode RETURNED_SQLSTATE() { return getToken(MySqlParser.RETURNED_SQLSTATE, 0); } + public TerminalNode RETURNING() { return getToken(MySqlParser.RETURNING, 0); } + public TerminalNode RETURNS() { return getToken(MySqlParser.RETURNS, 0); } + public TerminalNode REUSE() { return getToken(MySqlParser.REUSE, 0); } + public TerminalNode ROLE() { return getToken(MySqlParser.ROLE, 0); } + public TerminalNode ROLE_ADMIN() { return getToken(MySqlParser.ROLE_ADMIN, 0); } + public TerminalNode ROLLBACK() { return getToken(MySqlParser.ROLLBACK, 0); } + public TerminalNode ROLLUP() { return getToken(MySqlParser.ROLLUP, 0); } + public TerminalNode ROTATE() { return getToken(MySqlParser.ROTATE, 0); } + public TerminalNode ROW() { return getToken(MySqlParser.ROW, 0); } + public TerminalNode ROWS() { return getToken(MySqlParser.ROWS, 0); } + public TerminalNode ROW_FORMAT() { return getToken(MySqlParser.ROW_FORMAT, 0); } + public TerminalNode RTREE() { return getToken(MySqlParser.RTREE, 0); } + public TerminalNode S3() { return getToken(MySqlParser.S3, 0); } + public TerminalNode SAVEPOINT() { return getToken(MySqlParser.SAVEPOINT, 0); } + public TerminalNode SCHEDULE() { return getToken(MySqlParser.SCHEDULE, 0); } + public TerminalNode SCHEMA_NAME() { return getToken(MySqlParser.SCHEMA_NAME, 0); } + public TerminalNode SECURITY() { return getToken(MySqlParser.SECURITY, 0); } + public TerminalNode SECONDARY_ENGINE_ATTRIBUTE() { return getToken(MySqlParser.SECONDARY_ENGINE_ATTRIBUTE, 0); } + public TerminalNode SERIAL() { return getToken(MySqlParser.SERIAL, 0); } + public TerminalNode SERVER() { return getToken(MySqlParser.SERVER, 0); } + public TerminalNode SESSION() { return getToken(MySqlParser.SESSION, 0); } + public TerminalNode SESSION_VARIABLES_ADMIN() { return getToken(MySqlParser.SESSION_VARIABLES_ADMIN, 0); } + public TerminalNode SET_USER_ID() { return getToken(MySqlParser.SET_USER_ID, 0); } + public TerminalNode SHARE() { return getToken(MySqlParser.SHARE, 0); } + public TerminalNode SHARED() { return getToken(MySqlParser.SHARED, 0); } + public TerminalNode SHOW_ROUTINE() { return getToken(MySqlParser.SHOW_ROUTINE, 0); } + public TerminalNode SIGNED() { return getToken(MySqlParser.SIGNED, 0); } + public TerminalNode SIMPLE() { return getToken(MySqlParser.SIMPLE, 0); } + public TerminalNode SLAVE() { return getToken(MySqlParser.SLAVE, 0); } + public TerminalNode SLOW() { return getToken(MySqlParser.SLOW, 0); } + public TerminalNode SKIP_QUERY_REWRITE() { return getToken(MySqlParser.SKIP_QUERY_REWRITE, 0); } + public TerminalNode SNAPSHOT() { return getToken(MySqlParser.SNAPSHOT, 0); } + public TerminalNode SOCKET() { return getToken(MySqlParser.SOCKET, 0); } + public TerminalNode SOME() { return getToken(MySqlParser.SOME, 0); } + public TerminalNode SONAME() { return getToken(MySqlParser.SONAME, 0); } + public TerminalNode SOUNDS() { return getToken(MySqlParser.SOUNDS, 0); } + public TerminalNode SOURCE() { return getToken(MySqlParser.SOURCE, 0); } + public TerminalNode SQL_AFTER_GTIDS() { return getToken(MySqlParser.SQL_AFTER_GTIDS, 0); } + public TerminalNode SQL_AFTER_MTS_GAPS() { return getToken(MySqlParser.SQL_AFTER_MTS_GAPS, 0); } + public TerminalNode SQL_BEFORE_GTIDS() { return getToken(MySqlParser.SQL_BEFORE_GTIDS, 0); } + public TerminalNode SQL_BUFFER_RESULT() { return getToken(MySqlParser.SQL_BUFFER_RESULT, 0); } + public TerminalNode SQL_CACHE() { return getToken(MySqlParser.SQL_CACHE, 0); } + public TerminalNode SQL_NO_CACHE() { return getToken(MySqlParser.SQL_NO_CACHE, 0); } + public TerminalNode SQL_THREAD() { return getToken(MySqlParser.SQL_THREAD, 0); } + public TerminalNode STACKED() { return getToken(MySqlParser.STACKED, 0); } + public TerminalNode START() { return getToken(MySqlParser.START, 0); } + public TerminalNode STARTS() { return getToken(MySqlParser.STARTS, 0); } + public TerminalNode STATS_AUTO_RECALC() { return getToken(MySqlParser.STATS_AUTO_RECALC, 0); } + public TerminalNode STATS_PERSISTENT() { return getToken(MySqlParser.STATS_PERSISTENT, 0); } + public TerminalNode STATS_SAMPLE_PAGES() { return getToken(MySqlParser.STATS_SAMPLE_PAGES, 0); } + public TerminalNode STATUS() { return getToken(MySqlParser.STATUS, 0); } + public TerminalNode STD() { return getToken(MySqlParser.STD, 0); } + public TerminalNode STDDEV() { return getToken(MySqlParser.STDDEV, 0); } + public TerminalNode STDDEV_POP() { return getToken(MySqlParser.STDDEV_POP, 0); } + public TerminalNode STDDEV_SAMP() { return getToken(MySqlParser.STDDEV_SAMP, 0); } + public TerminalNode STOP() { return getToken(MySqlParser.STOP, 0); } + public TerminalNode STORAGE() { return getToken(MySqlParser.STORAGE, 0); } + public TerminalNode STRING() { return getToken(MySqlParser.STRING, 0); } + public TerminalNode SUBCLASS_ORIGIN() { return getToken(MySqlParser.SUBCLASS_ORIGIN, 0); } + public TerminalNode SUBJECT() { return getToken(MySqlParser.SUBJECT, 0); } + public TerminalNode SUBPARTITION() { return getToken(MySqlParser.SUBPARTITION, 0); } + public TerminalNode SUBPARTITIONS() { return getToken(MySqlParser.SUBPARTITIONS, 0); } + public TerminalNode SUM() { return getToken(MySqlParser.SUM, 0); } + public TerminalNode SUSPEND() { return getToken(MySqlParser.SUSPEND, 0); } + public TerminalNode SWAPS() { return getToken(MySqlParser.SWAPS, 0); } + public TerminalNode SWITCHES() { return getToken(MySqlParser.SWITCHES, 0); } + public TerminalNode SYSTEM_VARIABLES_ADMIN() { return getToken(MySqlParser.SYSTEM_VARIABLES_ADMIN, 0); } + public TerminalNode TABLE_NAME() { return getToken(MySqlParser.TABLE_NAME, 0); } + public TerminalNode TABLESPACE() { return getToken(MySqlParser.TABLESPACE, 0); } + public TerminalNode TABLE_ENCRYPTION_ADMIN() { return getToken(MySqlParser.TABLE_ENCRYPTION_ADMIN, 0); } + public TerminalNode TABLE_TYPE() { return getToken(MySqlParser.TABLE_TYPE, 0); } + public TerminalNode TEMPORARY() { return getToken(MySqlParser.TEMPORARY, 0); } + public TerminalNode TEMPTABLE() { return getToken(MySqlParser.TEMPTABLE, 0); } + public TerminalNode THAN() { return getToken(MySqlParser.THAN, 0); } + public TerminalNode TP_CONNECTION_ADMIN() { return getToken(MySqlParser.TP_CONNECTION_ADMIN, 0); } + public TerminalNode TRADITIONAL() { return getToken(MySqlParser.TRADITIONAL, 0); } + public TerminalNode TRANSACTION() { return getToken(MySqlParser.TRANSACTION, 0); } + public TerminalNode TRANSACTIONAL() { return getToken(MySqlParser.TRANSACTIONAL, 0); } + public TerminalNode TRIGGERS() { return getToken(MySqlParser.TRIGGERS, 0); } + public TerminalNode TRUNCATE() { return getToken(MySqlParser.TRUNCATE, 0); } + public TerminalNode UNBOUNDED() { return getToken(MySqlParser.UNBOUNDED, 0); } + public TerminalNode UNDEFINED() { return getToken(MySqlParser.UNDEFINED, 0); } + public TerminalNode UNDOFILE() { return getToken(MySqlParser.UNDOFILE, 0); } + public TerminalNode UNDO_BUFFER_SIZE() { return getToken(MySqlParser.UNDO_BUFFER_SIZE, 0); } + public TerminalNode UNINSTALL() { return getToken(MySqlParser.UNINSTALL, 0); } + public TerminalNode UNKNOWN() { return getToken(MySqlParser.UNKNOWN, 0); } + public TerminalNode UNTIL() { return getToken(MySqlParser.UNTIL, 0); } + public TerminalNode UPGRADE() { return getToken(MySqlParser.UPGRADE, 0); } + public TerminalNode USA() { return getToken(MySqlParser.USA, 0); } + public TerminalNode USER() { return getToken(MySqlParser.USER, 0); } + public TerminalNode USE_FRM() { return getToken(MySqlParser.USE_FRM, 0); } + public TerminalNode USER_RESOURCES() { return getToken(MySqlParser.USER_RESOURCES, 0); } + public TerminalNode VALIDATION() { return getToken(MySqlParser.VALIDATION, 0); } + public TerminalNode VALUE() { return getToken(MySqlParser.VALUE, 0); } + public TerminalNode VAR_POP() { return getToken(MySqlParser.VAR_POP, 0); } + public TerminalNode VAR_SAMP() { return getToken(MySqlParser.VAR_SAMP, 0); } + public TerminalNode VARIABLES() { return getToken(MySqlParser.VARIABLES, 0); } + public TerminalNode VARIANCE() { return getToken(MySqlParser.VARIANCE, 0); } + public TerminalNode VERSION_TOKEN_ADMIN() { return getToken(MySqlParser.VERSION_TOKEN_ADMIN, 0); } + public TerminalNode VIEW() { return getToken(MySqlParser.VIEW, 0); } + public TerminalNode VIRTUAL() { return getToken(MySqlParser.VIRTUAL, 0); } + public TerminalNode WAIT() { return getToken(MySqlParser.WAIT, 0); } + public TerminalNode WARNINGS() { return getToken(MySqlParser.WARNINGS, 0); } + public TerminalNode WITHOUT() { return getToken(MySqlParser.WITHOUT, 0); } + public TerminalNode WORK() { return getToken(MySqlParser.WORK, 0); } + public TerminalNode WRAPPER() { return getToken(MySqlParser.WRAPPER, 0); } + public TerminalNode X509() { return getToken(MySqlParser.X509, 0); } + public TerminalNode XA() { return getToken(MySqlParser.XA, 0); } + public TerminalNode XA_RECOVER_ADMIN() { return getToken(MySqlParser.XA_RECOVER_ADMIN, 0); } + public TerminalNode XML() { return getToken(MySqlParser.XML, 0); } + public KeywordsCanBeIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_keywordsCanBeId; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterKeywordsCanBeId(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitKeywordsCanBeId(this); + } + } + + public final KeywordsCanBeIdContext keywordsCanBeId() throws RecognitionException { + KeywordsCanBeIdContext _localctx = new KeywordsCanBeIdContext(_ctx, getState()); + enterRule(_localctx, 718, RULE_keywordsCanBeId); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7443); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1513781565514616832L) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 146666055054393409L) != 0) || _la==SKIP_QUERY_REWRITE || _la==STACKED || ((((_la - 240)) & ~0x3f) == 0 && ((1L << (_la - 240)) & 1769897061370560513L) != 0) || ((((_la - 306)) & ~0x3f) == 0 && ((1L << (_la - 306)) & -134217473L) != 0) || ((((_la - 370)) & ~0x3f) == 0 && ((1L << (_la - 370)) & -171798822913L) != 0) || ((((_la - 435)) & ~0x3f) == 0 && ((1L << (_la - 435)) & -33685505L) != 0) || ((((_la - 499)) & ~0x3f) == 0 && ((1L << (_la - 499)) & -2306265222165299201L) != 0) || ((((_la - 563)) & ~0x3f) == 0 && ((1L << (_la - 563)) & -35184640524289L) != 0) || ((((_la - 627)) & ~0x3f) == 0 && ((1L << (_la - 627)) & 9077990211383719935L) != 0) || ((((_la - 698)) & ~0x3f) == 0 && ((1L << (_la - 698)) & 514225960183805L) != 0) || _la==MEMORY || _la==CATALOG_NAME || _la==ENGINE_ATTRIBUTE || _la==SECONDARY_ENGINE_ATTRIBUTE || _la==SCHEMA_NAME || _la==TP_CONNECTION_ADMIN) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionNameBaseContext extends ParserRuleContext { + public TerminalNode ABS() { return getToken(MySqlParser.ABS, 0); } + public TerminalNode ACOS() { return getToken(MySqlParser.ACOS, 0); } + public TerminalNode ADDDATE() { return getToken(MySqlParser.ADDDATE, 0); } + public TerminalNode ADDTIME() { return getToken(MySqlParser.ADDTIME, 0); } + public TerminalNode AES_DECRYPT() { return getToken(MySqlParser.AES_DECRYPT, 0); } + public TerminalNode AES_ENCRYPT() { return getToken(MySqlParser.AES_ENCRYPT, 0); } + public TerminalNode AREA() { return getToken(MySqlParser.AREA, 0); } + public TerminalNode ASBINARY() { return getToken(MySqlParser.ASBINARY, 0); } + public TerminalNode ASIN() { return getToken(MySqlParser.ASIN, 0); } + public TerminalNode ASTEXT() { return getToken(MySqlParser.ASTEXT, 0); } + public TerminalNode ASWKB() { return getToken(MySqlParser.ASWKB, 0); } + public TerminalNode ASWKT() { return getToken(MySqlParser.ASWKT, 0); } + public TerminalNode ASYMMETRIC_DECRYPT() { return getToken(MySqlParser.ASYMMETRIC_DECRYPT, 0); } + public TerminalNode ASYMMETRIC_DERIVE() { return getToken(MySqlParser.ASYMMETRIC_DERIVE, 0); } + public TerminalNode ASYMMETRIC_ENCRYPT() { return getToken(MySqlParser.ASYMMETRIC_ENCRYPT, 0); } + public TerminalNode ASYMMETRIC_SIGN() { return getToken(MySqlParser.ASYMMETRIC_SIGN, 0); } + public TerminalNode ASYMMETRIC_VERIFY() { return getToken(MySqlParser.ASYMMETRIC_VERIFY, 0); } + public TerminalNode ATAN() { return getToken(MySqlParser.ATAN, 0); } + public TerminalNode ATAN2() { return getToken(MySqlParser.ATAN2, 0); } + public TerminalNode BENCHMARK() { return getToken(MySqlParser.BENCHMARK, 0); } + public TerminalNode BIN() { return getToken(MySqlParser.BIN, 0); } + public TerminalNode BIT_COUNT() { return getToken(MySqlParser.BIT_COUNT, 0); } + public TerminalNode BIT_LENGTH() { return getToken(MySqlParser.BIT_LENGTH, 0); } + public TerminalNode BUFFER() { return getToken(MySqlParser.BUFFER, 0); } + public TerminalNode CEIL() { return getToken(MySqlParser.CEIL, 0); } + public TerminalNode CEILING() { return getToken(MySqlParser.CEILING, 0); } + public TerminalNode CENTROID() { return getToken(MySqlParser.CENTROID, 0); } + public TerminalNode CHARACTER_LENGTH() { return getToken(MySqlParser.CHARACTER_LENGTH, 0); } + public TerminalNode CHARSET() { return getToken(MySqlParser.CHARSET, 0); } + public TerminalNode CHAR_LENGTH() { return getToken(MySqlParser.CHAR_LENGTH, 0); } + public TerminalNode COERCIBILITY() { return getToken(MySqlParser.COERCIBILITY, 0); } + public TerminalNode COLLATION() { return getToken(MySqlParser.COLLATION, 0); } + public TerminalNode COMPRESS() { return getToken(MySqlParser.COMPRESS, 0); } + public TerminalNode CONCAT() { return getToken(MySqlParser.CONCAT, 0); } + public TerminalNode CONCAT_WS() { return getToken(MySqlParser.CONCAT_WS, 0); } + public TerminalNode CONNECTION_ID() { return getToken(MySqlParser.CONNECTION_ID, 0); } + public TerminalNode CONV() { return getToken(MySqlParser.CONV, 0); } + public TerminalNode CONVERT_TZ() { return getToken(MySqlParser.CONVERT_TZ, 0); } + public TerminalNode COS() { return getToken(MySqlParser.COS, 0); } + public TerminalNode COT() { return getToken(MySqlParser.COT, 0); } + public TerminalNode COUNT() { return getToken(MySqlParser.COUNT, 0); } + public TerminalNode CRC32() { return getToken(MySqlParser.CRC32, 0); } + public TerminalNode CREATE_ASYMMETRIC_PRIV_KEY() { return getToken(MySqlParser.CREATE_ASYMMETRIC_PRIV_KEY, 0); } + public TerminalNode CREATE_ASYMMETRIC_PUB_KEY() { return getToken(MySqlParser.CREATE_ASYMMETRIC_PUB_KEY, 0); } + public TerminalNode CREATE_DH_PARAMETERS() { return getToken(MySqlParser.CREATE_DH_PARAMETERS, 0); } + public TerminalNode CREATE_DIGEST() { return getToken(MySqlParser.CREATE_DIGEST, 0); } + public TerminalNode CROSSES() { return getToken(MySqlParser.CROSSES, 0); } + public TerminalNode CUME_DIST() { return getToken(MySqlParser.CUME_DIST, 0); } + public TerminalNode DATABASE() { return getToken(MySqlParser.DATABASE, 0); } + public TerminalNode DATE() { return getToken(MySqlParser.DATE, 0); } + public TerminalNode DATEDIFF() { return getToken(MySqlParser.DATEDIFF, 0); } + public TerminalNode DATE_FORMAT() { return getToken(MySqlParser.DATE_FORMAT, 0); } + public TerminalNode DAY() { return getToken(MySqlParser.DAY, 0); } + public TerminalNode DAYNAME() { return getToken(MySqlParser.DAYNAME, 0); } + public TerminalNode DAYOFMONTH() { return getToken(MySqlParser.DAYOFMONTH, 0); } + public TerminalNode DAYOFWEEK() { return getToken(MySqlParser.DAYOFWEEK, 0); } + public TerminalNode DAYOFYEAR() { return getToken(MySqlParser.DAYOFYEAR, 0); } + public TerminalNode DECODE() { return getToken(MySqlParser.DECODE, 0); } + public TerminalNode DEGREES() { return getToken(MySqlParser.DEGREES, 0); } + public TerminalNode DENSE_RANK() { return getToken(MySqlParser.DENSE_RANK, 0); } + public TerminalNode DES_DECRYPT() { return getToken(MySqlParser.DES_DECRYPT, 0); } + public TerminalNode DES_ENCRYPT() { return getToken(MySqlParser.DES_ENCRYPT, 0); } + public TerminalNode DIMENSION() { return getToken(MySqlParser.DIMENSION, 0); } + public TerminalNode DISJOINT() { return getToken(MySqlParser.DISJOINT, 0); } + public TerminalNode ELT() { return getToken(MySqlParser.ELT, 0); } + public TerminalNode ENCODE() { return getToken(MySqlParser.ENCODE, 0); } + public TerminalNode ENCRYPT() { return getToken(MySqlParser.ENCRYPT, 0); } + public TerminalNode ENDPOINT() { return getToken(MySqlParser.ENDPOINT, 0); } + public TerminalNode ENVELOPE() { return getToken(MySqlParser.ENVELOPE, 0); } + public TerminalNode EQUALS() { return getToken(MySqlParser.EQUALS, 0); } + public TerminalNode EXP() { return getToken(MySqlParser.EXP, 0); } + public TerminalNode EXPORT_SET() { return getToken(MySqlParser.EXPORT_SET, 0); } + public TerminalNode EXTERIORRING() { return getToken(MySqlParser.EXTERIORRING, 0); } + public TerminalNode EXTRACTVALUE() { return getToken(MySqlParser.EXTRACTVALUE, 0); } + public TerminalNode FIELD() { return getToken(MySqlParser.FIELD, 0); } + public TerminalNode FIND_IN_SET() { return getToken(MySqlParser.FIND_IN_SET, 0); } + public TerminalNode FIRST_VALUE() { return getToken(MySqlParser.FIRST_VALUE, 0); } + public TerminalNode FLOOR() { return getToken(MySqlParser.FLOOR, 0); } + public TerminalNode FORMAT() { return getToken(MySqlParser.FORMAT, 0); } + public TerminalNode FOUND_ROWS() { return getToken(MySqlParser.FOUND_ROWS, 0); } + public TerminalNode FROM_BASE64() { return getToken(MySqlParser.FROM_BASE64, 0); } + public TerminalNode FROM_DAYS() { return getToken(MySqlParser.FROM_DAYS, 0); } + public TerminalNode FROM_UNIXTIME() { return getToken(MySqlParser.FROM_UNIXTIME, 0); } + public TerminalNode GEOMCOLLFROMTEXT() { return getToken(MySqlParser.GEOMCOLLFROMTEXT, 0); } + public TerminalNode GEOMCOLLFROMWKB() { return getToken(MySqlParser.GEOMCOLLFROMWKB, 0); } + public TerminalNode GEOMETRYCOLLECTION() { return getToken(MySqlParser.GEOMETRYCOLLECTION, 0); } + public TerminalNode GEOMETRYCOLLECTIONFROMTEXT() { return getToken(MySqlParser.GEOMETRYCOLLECTIONFROMTEXT, 0); } + public TerminalNode GEOMETRYCOLLECTIONFROMWKB() { return getToken(MySqlParser.GEOMETRYCOLLECTIONFROMWKB, 0); } + public TerminalNode GEOMETRYFROMTEXT() { return getToken(MySqlParser.GEOMETRYFROMTEXT, 0); } + public TerminalNode GEOMETRYFROMWKB() { return getToken(MySqlParser.GEOMETRYFROMWKB, 0); } + public TerminalNode GEOMETRYN() { return getToken(MySqlParser.GEOMETRYN, 0); } + public TerminalNode GEOMETRYTYPE() { return getToken(MySqlParser.GEOMETRYTYPE, 0); } + public TerminalNode GEOMFROMTEXT() { return getToken(MySqlParser.GEOMFROMTEXT, 0); } + public TerminalNode GEOMFROMWKB() { return getToken(MySqlParser.GEOMFROMWKB, 0); } + public TerminalNode GET_FORMAT() { return getToken(MySqlParser.GET_FORMAT, 0); } + public TerminalNode GET_LOCK() { return getToken(MySqlParser.GET_LOCK, 0); } + public TerminalNode GLENGTH() { return getToken(MySqlParser.GLENGTH, 0); } + public TerminalNode GREATEST() { return getToken(MySqlParser.GREATEST, 0); } + public TerminalNode GTID_SUBSET() { return getToken(MySqlParser.GTID_SUBSET, 0); } + public TerminalNode GTID_SUBTRACT() { return getToken(MySqlParser.GTID_SUBTRACT, 0); } + public TerminalNode HEX() { return getToken(MySqlParser.HEX, 0); } + public TerminalNode HOUR() { return getToken(MySqlParser.HOUR, 0); } + public TerminalNode IFNULL() { return getToken(MySqlParser.IFNULL, 0); } + public TerminalNode INET6_ATON() { return getToken(MySqlParser.INET6_ATON, 0); } + public TerminalNode INET6_NTOA() { return getToken(MySqlParser.INET6_NTOA, 0); } + public TerminalNode INET_ATON() { return getToken(MySqlParser.INET_ATON, 0); } + public TerminalNode INET_NTOA() { return getToken(MySqlParser.INET_NTOA, 0); } + public TerminalNode INSTR() { return getToken(MySqlParser.INSTR, 0); } + public TerminalNode INTERIORRINGN() { return getToken(MySqlParser.INTERIORRINGN, 0); } + public TerminalNode INTERSECTS() { return getToken(MySqlParser.INTERSECTS, 0); } + public TerminalNode INVISIBLE() { return getToken(MySqlParser.INVISIBLE, 0); } + public TerminalNode ISCLOSED() { return getToken(MySqlParser.ISCLOSED, 0); } + public TerminalNode ISEMPTY() { return getToken(MySqlParser.ISEMPTY, 0); } + public TerminalNode ISNULL() { return getToken(MySqlParser.ISNULL, 0); } + public TerminalNode ISSIMPLE() { return getToken(MySqlParser.ISSIMPLE, 0); } + public TerminalNode IS_FREE_LOCK() { return getToken(MySqlParser.IS_FREE_LOCK, 0); } + public TerminalNode IS_IPV4() { return getToken(MySqlParser.IS_IPV4, 0); } + public TerminalNode IS_IPV4_COMPAT() { return getToken(MySqlParser.IS_IPV4_COMPAT, 0); } + public TerminalNode IS_IPV4_MAPPED() { return getToken(MySqlParser.IS_IPV4_MAPPED, 0); } + public TerminalNode IS_IPV6() { return getToken(MySqlParser.IS_IPV6, 0); } + public TerminalNode IS_USED_LOCK() { return getToken(MySqlParser.IS_USED_LOCK, 0); } + public TerminalNode LAG() { return getToken(MySqlParser.LAG, 0); } + public TerminalNode LAST_INSERT_ID() { return getToken(MySqlParser.LAST_INSERT_ID, 0); } + public TerminalNode LAST_VALUE() { return getToken(MySqlParser.LAST_VALUE, 0); } + public TerminalNode LCASE() { return getToken(MySqlParser.LCASE, 0); } + public TerminalNode LEAD() { return getToken(MySqlParser.LEAD, 0); } + public TerminalNode LEAST() { return getToken(MySqlParser.LEAST, 0); } + public TerminalNode LEFT() { return getToken(MySqlParser.LEFT, 0); } + public TerminalNode LENGTH() { return getToken(MySqlParser.LENGTH, 0); } + public TerminalNode LINEFROMTEXT() { return getToken(MySqlParser.LINEFROMTEXT, 0); } + public TerminalNode LINEFROMWKB() { return getToken(MySqlParser.LINEFROMWKB, 0); } + public TerminalNode LINESTRING() { return getToken(MySqlParser.LINESTRING, 0); } + public TerminalNode LINESTRINGFROMTEXT() { return getToken(MySqlParser.LINESTRINGFROMTEXT, 0); } + public TerminalNode LINESTRINGFROMWKB() { return getToken(MySqlParser.LINESTRINGFROMWKB, 0); } + public TerminalNode LN() { return getToken(MySqlParser.LN, 0); } + public TerminalNode LOAD_FILE() { return getToken(MySqlParser.LOAD_FILE, 0); } + public TerminalNode LOCATE() { return getToken(MySqlParser.LOCATE, 0); } + public TerminalNode LOG() { return getToken(MySqlParser.LOG, 0); } + public TerminalNode LOG10() { return getToken(MySqlParser.LOG10, 0); } + public TerminalNode LOG2() { return getToken(MySqlParser.LOG2, 0); } + public TerminalNode LOWER() { return getToken(MySqlParser.LOWER, 0); } + public TerminalNode LPAD() { return getToken(MySqlParser.LPAD, 0); } + public TerminalNode LTRIM() { return getToken(MySqlParser.LTRIM, 0); } + public TerminalNode MAKEDATE() { return getToken(MySqlParser.MAKEDATE, 0); } + public TerminalNode MAKETIME() { return getToken(MySqlParser.MAKETIME, 0); } + public TerminalNode MAKE_SET() { return getToken(MySqlParser.MAKE_SET, 0); } + public TerminalNode MASTER_POS_WAIT() { return getToken(MySqlParser.MASTER_POS_WAIT, 0); } + public TerminalNode MBRCONTAINS() { return getToken(MySqlParser.MBRCONTAINS, 0); } + public TerminalNode MBRDISJOINT() { return getToken(MySqlParser.MBRDISJOINT, 0); } + public TerminalNode MBREQUAL() { return getToken(MySqlParser.MBREQUAL, 0); } + public TerminalNode MBRINTERSECTS() { return getToken(MySqlParser.MBRINTERSECTS, 0); } + public TerminalNode MBROVERLAPS() { return getToken(MySqlParser.MBROVERLAPS, 0); } + public TerminalNode MBRTOUCHES() { return getToken(MySqlParser.MBRTOUCHES, 0); } + public TerminalNode MBRWITHIN() { return getToken(MySqlParser.MBRWITHIN, 0); } + public TerminalNode MD5() { return getToken(MySqlParser.MD5, 0); } + public TerminalNode MICROSECOND() { return getToken(MySqlParser.MICROSECOND, 0); } + public TerminalNode MINUTE() { return getToken(MySqlParser.MINUTE, 0); } + public TerminalNode MLINEFROMTEXT() { return getToken(MySqlParser.MLINEFROMTEXT, 0); } + public TerminalNode MLINEFROMWKB() { return getToken(MySqlParser.MLINEFROMWKB, 0); } + public TerminalNode MOD() { return getToken(MySqlParser.MOD, 0); } + public TerminalNode MONTH() { return getToken(MySqlParser.MONTH, 0); } + public TerminalNode MONTHNAME() { return getToken(MySqlParser.MONTHNAME, 0); } + public TerminalNode MPOINTFROMTEXT() { return getToken(MySqlParser.MPOINTFROMTEXT, 0); } + public TerminalNode MPOINTFROMWKB() { return getToken(MySqlParser.MPOINTFROMWKB, 0); } + public TerminalNode MPOLYFROMTEXT() { return getToken(MySqlParser.MPOLYFROMTEXT, 0); } + public TerminalNode MPOLYFROMWKB() { return getToken(MySqlParser.MPOLYFROMWKB, 0); } + public TerminalNode MULTILINESTRING() { return getToken(MySqlParser.MULTILINESTRING, 0); } + public TerminalNode MULTILINESTRINGFROMTEXT() { return getToken(MySqlParser.MULTILINESTRINGFROMTEXT, 0); } + public TerminalNode MULTILINESTRINGFROMWKB() { return getToken(MySqlParser.MULTILINESTRINGFROMWKB, 0); } + public TerminalNode MULTIPOINT() { return getToken(MySqlParser.MULTIPOINT, 0); } + public TerminalNode MULTIPOINTFROMTEXT() { return getToken(MySqlParser.MULTIPOINTFROMTEXT, 0); } + public TerminalNode MULTIPOINTFROMWKB() { return getToken(MySqlParser.MULTIPOINTFROMWKB, 0); } + public TerminalNode MULTIPOLYGON() { return getToken(MySqlParser.MULTIPOLYGON, 0); } + public TerminalNode MULTIPOLYGONFROMTEXT() { return getToken(MySqlParser.MULTIPOLYGONFROMTEXT, 0); } + public TerminalNode MULTIPOLYGONFROMWKB() { return getToken(MySqlParser.MULTIPOLYGONFROMWKB, 0); } + public TerminalNode NAME_CONST() { return getToken(MySqlParser.NAME_CONST, 0); } + public TerminalNode NTH_VALUE() { return getToken(MySqlParser.NTH_VALUE, 0); } + public TerminalNode NTILE() { return getToken(MySqlParser.NTILE, 0); } + public TerminalNode NULLIF() { return getToken(MySqlParser.NULLIF, 0); } + public TerminalNode NUMGEOMETRIES() { return getToken(MySqlParser.NUMGEOMETRIES, 0); } + public TerminalNode NUMINTERIORRINGS() { return getToken(MySqlParser.NUMINTERIORRINGS, 0); } + public TerminalNode NUMPOINTS() { return getToken(MySqlParser.NUMPOINTS, 0); } + public TerminalNode OCT() { return getToken(MySqlParser.OCT, 0); } + public TerminalNode OCTET_LENGTH() { return getToken(MySqlParser.OCTET_LENGTH, 0); } + public TerminalNode ORD() { return getToken(MySqlParser.ORD, 0); } + public TerminalNode OVERLAPS() { return getToken(MySqlParser.OVERLAPS, 0); } + public TerminalNode PERCENT_RANK() { return getToken(MySqlParser.PERCENT_RANK, 0); } + public TerminalNode PERIOD_ADD() { return getToken(MySqlParser.PERIOD_ADD, 0); } + public TerminalNode PERIOD_DIFF() { return getToken(MySqlParser.PERIOD_DIFF, 0); } + public TerminalNode PI() { return getToken(MySqlParser.PI, 0); } + public TerminalNode POINT() { return getToken(MySqlParser.POINT, 0); } + public TerminalNode POINTFROMTEXT() { return getToken(MySqlParser.POINTFROMTEXT, 0); } + public TerminalNode POINTFROMWKB() { return getToken(MySqlParser.POINTFROMWKB, 0); } + public TerminalNode POINTN() { return getToken(MySqlParser.POINTN, 0); } + public TerminalNode POLYFROMTEXT() { return getToken(MySqlParser.POLYFROMTEXT, 0); } + public TerminalNode POLYFROMWKB() { return getToken(MySqlParser.POLYFROMWKB, 0); } + public TerminalNode POLYGON() { return getToken(MySqlParser.POLYGON, 0); } + public TerminalNode POLYGONFROMTEXT() { return getToken(MySqlParser.POLYGONFROMTEXT, 0); } + public TerminalNode POLYGONFROMWKB() { return getToken(MySqlParser.POLYGONFROMWKB, 0); } + public TerminalNode POSITION() { return getToken(MySqlParser.POSITION, 0); } + public TerminalNode POW() { return getToken(MySqlParser.POW, 0); } + public TerminalNode POWER() { return getToken(MySqlParser.POWER, 0); } + public TerminalNode QUARTER() { return getToken(MySqlParser.QUARTER, 0); } + public TerminalNode QUOTE() { return getToken(MySqlParser.QUOTE, 0); } + public TerminalNode RADIANS() { return getToken(MySqlParser.RADIANS, 0); } + public TerminalNode RAND() { return getToken(MySqlParser.RAND, 0); } + public TerminalNode RANDOM() { return getToken(MySqlParser.RANDOM, 0); } + public TerminalNode RANK() { return getToken(MySqlParser.RANK, 0); } + public TerminalNode RANDOM_BYTES() { return getToken(MySqlParser.RANDOM_BYTES, 0); } + public TerminalNode RELEASE_LOCK() { return getToken(MySqlParser.RELEASE_LOCK, 0); } + public TerminalNode REVERSE() { return getToken(MySqlParser.REVERSE, 0); } + public TerminalNode RIGHT() { return getToken(MySqlParser.RIGHT, 0); } + public TerminalNode ROUND() { return getToken(MySqlParser.ROUND, 0); } + public TerminalNode ROW_COUNT() { return getToken(MySqlParser.ROW_COUNT, 0); } + public TerminalNode ROW_NUMBER() { return getToken(MySqlParser.ROW_NUMBER, 0); } + public TerminalNode RPAD() { return getToken(MySqlParser.RPAD, 0); } + public TerminalNode RTRIM() { return getToken(MySqlParser.RTRIM, 0); } + public TerminalNode SCHEMA() { return getToken(MySqlParser.SCHEMA, 0); } + public TerminalNode SECOND() { return getToken(MySqlParser.SECOND, 0); } + public TerminalNode SEC_TO_TIME() { return getToken(MySqlParser.SEC_TO_TIME, 0); } + public TerminalNode SESSION_USER() { return getToken(MySqlParser.SESSION_USER, 0); } + public TerminalNode SESSION_VARIABLES_ADMIN() { return getToken(MySqlParser.SESSION_VARIABLES_ADMIN, 0); } + public TerminalNode SHA() { return getToken(MySqlParser.SHA, 0); } + public TerminalNode SHA1() { return getToken(MySqlParser.SHA1, 0); } + public TerminalNode SHA2() { return getToken(MySqlParser.SHA2, 0); } + public TerminalNode SIGN() { return getToken(MySqlParser.SIGN, 0); } + public TerminalNode SIN() { return getToken(MySqlParser.SIN, 0); } + public TerminalNode SLEEP() { return getToken(MySqlParser.SLEEP, 0); } + public TerminalNode SOUNDEX() { return getToken(MySqlParser.SOUNDEX, 0); } + public TerminalNode SQL_THREAD_WAIT_AFTER_GTIDS() { return getToken(MySqlParser.SQL_THREAD_WAIT_AFTER_GTIDS, 0); } + public TerminalNode SQRT() { return getToken(MySqlParser.SQRT, 0); } + public TerminalNode SRID() { return getToken(MySqlParser.SRID, 0); } + public TerminalNode STARTPOINT() { return getToken(MySqlParser.STARTPOINT, 0); } + public TerminalNode STRCMP() { return getToken(MySqlParser.STRCMP, 0); } + public TerminalNode STR_TO_DATE() { return getToken(MySqlParser.STR_TO_DATE, 0); } + public TerminalNode ST_AREA() { return getToken(MySqlParser.ST_AREA, 0); } + public TerminalNode ST_ASBINARY() { return getToken(MySqlParser.ST_ASBINARY, 0); } + public TerminalNode ST_ASTEXT() { return getToken(MySqlParser.ST_ASTEXT, 0); } + public TerminalNode ST_ASWKB() { return getToken(MySqlParser.ST_ASWKB, 0); } + public TerminalNode ST_ASWKT() { return getToken(MySqlParser.ST_ASWKT, 0); } + public TerminalNode ST_BUFFER() { return getToken(MySqlParser.ST_BUFFER, 0); } + public TerminalNode ST_CENTROID() { return getToken(MySqlParser.ST_CENTROID, 0); } + public TerminalNode ST_CONTAINS() { return getToken(MySqlParser.ST_CONTAINS, 0); } + public TerminalNode ST_CROSSES() { return getToken(MySqlParser.ST_CROSSES, 0); } + public TerminalNode ST_DIFFERENCE() { return getToken(MySqlParser.ST_DIFFERENCE, 0); } + public TerminalNode ST_DIMENSION() { return getToken(MySqlParser.ST_DIMENSION, 0); } + public TerminalNode ST_DISJOINT() { return getToken(MySqlParser.ST_DISJOINT, 0); } + public TerminalNode ST_DISTANCE() { return getToken(MySqlParser.ST_DISTANCE, 0); } + public TerminalNode ST_ENDPOINT() { return getToken(MySqlParser.ST_ENDPOINT, 0); } + public TerminalNode ST_ENVELOPE() { return getToken(MySqlParser.ST_ENVELOPE, 0); } + public TerminalNode ST_EQUALS() { return getToken(MySqlParser.ST_EQUALS, 0); } + public TerminalNode ST_EXTERIORRING() { return getToken(MySqlParser.ST_EXTERIORRING, 0); } + public TerminalNode ST_GEOMCOLLFROMTEXT() { return getToken(MySqlParser.ST_GEOMCOLLFROMTEXT, 0); } + public TerminalNode ST_GEOMCOLLFROMTXT() { return getToken(MySqlParser.ST_GEOMCOLLFROMTXT, 0); } + public TerminalNode ST_GEOMCOLLFROMWKB() { return getToken(MySqlParser.ST_GEOMCOLLFROMWKB, 0); } + public TerminalNode ST_GEOMETRYCOLLECTIONFROMTEXT() { return getToken(MySqlParser.ST_GEOMETRYCOLLECTIONFROMTEXT, 0); } + public TerminalNode ST_GEOMETRYCOLLECTIONFROMWKB() { return getToken(MySqlParser.ST_GEOMETRYCOLLECTIONFROMWKB, 0); } + public TerminalNode ST_GEOMETRYFROMTEXT() { return getToken(MySqlParser.ST_GEOMETRYFROMTEXT, 0); } + public TerminalNode ST_GEOMETRYFROMWKB() { return getToken(MySqlParser.ST_GEOMETRYFROMWKB, 0); } + public TerminalNode ST_GEOMETRYN() { return getToken(MySqlParser.ST_GEOMETRYN, 0); } + public TerminalNode ST_GEOMETRYTYPE() { return getToken(MySqlParser.ST_GEOMETRYTYPE, 0); } + public TerminalNode ST_GEOMFROMTEXT() { return getToken(MySqlParser.ST_GEOMFROMTEXT, 0); } + public TerminalNode ST_GEOMFROMWKB() { return getToken(MySqlParser.ST_GEOMFROMWKB, 0); } + public TerminalNode ST_INTERIORRINGN() { return getToken(MySqlParser.ST_INTERIORRINGN, 0); } + public TerminalNode ST_INTERSECTION() { return getToken(MySqlParser.ST_INTERSECTION, 0); } + public TerminalNode ST_INTERSECTS() { return getToken(MySqlParser.ST_INTERSECTS, 0); } + public TerminalNode ST_ISCLOSED() { return getToken(MySqlParser.ST_ISCLOSED, 0); } + public TerminalNode ST_ISEMPTY() { return getToken(MySqlParser.ST_ISEMPTY, 0); } + public TerminalNode ST_ISSIMPLE() { return getToken(MySqlParser.ST_ISSIMPLE, 0); } + public TerminalNode ST_LINEFROMTEXT() { return getToken(MySqlParser.ST_LINEFROMTEXT, 0); } + public TerminalNode ST_LINEFROMWKB() { return getToken(MySqlParser.ST_LINEFROMWKB, 0); } + public TerminalNode ST_LINESTRINGFROMTEXT() { return getToken(MySqlParser.ST_LINESTRINGFROMTEXT, 0); } + public TerminalNode ST_LINESTRINGFROMWKB() { return getToken(MySqlParser.ST_LINESTRINGFROMWKB, 0); } + public TerminalNode ST_NUMGEOMETRIES() { return getToken(MySqlParser.ST_NUMGEOMETRIES, 0); } + public TerminalNode ST_NUMINTERIORRING() { return getToken(MySqlParser.ST_NUMINTERIORRING, 0); } + public TerminalNode ST_NUMINTERIORRINGS() { return getToken(MySqlParser.ST_NUMINTERIORRINGS, 0); } + public TerminalNode ST_NUMPOINTS() { return getToken(MySqlParser.ST_NUMPOINTS, 0); } + public TerminalNode ST_OVERLAPS() { return getToken(MySqlParser.ST_OVERLAPS, 0); } + public TerminalNode ST_POINTFROMTEXT() { return getToken(MySqlParser.ST_POINTFROMTEXT, 0); } + public TerminalNode ST_POINTFROMWKB() { return getToken(MySqlParser.ST_POINTFROMWKB, 0); } + public TerminalNode ST_POINTN() { return getToken(MySqlParser.ST_POINTN, 0); } + public TerminalNode ST_POLYFROMTEXT() { return getToken(MySqlParser.ST_POLYFROMTEXT, 0); } + public TerminalNode ST_POLYFROMWKB() { return getToken(MySqlParser.ST_POLYFROMWKB, 0); } + public TerminalNode ST_POLYGONFROMTEXT() { return getToken(MySqlParser.ST_POLYGONFROMTEXT, 0); } + public TerminalNode ST_POLYGONFROMWKB() { return getToken(MySqlParser.ST_POLYGONFROMWKB, 0); } + public TerminalNode ST_SRID() { return getToken(MySqlParser.ST_SRID, 0); } + public TerminalNode ST_STARTPOINT() { return getToken(MySqlParser.ST_STARTPOINT, 0); } + public TerminalNode ST_SYMDIFFERENCE() { return getToken(MySqlParser.ST_SYMDIFFERENCE, 0); } + public TerminalNode ST_TOUCHES() { return getToken(MySqlParser.ST_TOUCHES, 0); } + public TerminalNode ST_UNION() { return getToken(MySqlParser.ST_UNION, 0); } + public TerminalNode ST_WITHIN() { return getToken(MySqlParser.ST_WITHIN, 0); } + public TerminalNode ST_X() { return getToken(MySqlParser.ST_X, 0); } + public TerminalNode ST_Y() { return getToken(MySqlParser.ST_Y, 0); } + public TerminalNode SUBDATE() { return getToken(MySqlParser.SUBDATE, 0); } + public TerminalNode SUBSTRING_INDEX() { return getToken(MySqlParser.SUBSTRING_INDEX, 0); } + public TerminalNode SUBTIME() { return getToken(MySqlParser.SUBTIME, 0); } + public TerminalNode SYSTEM_USER() { return getToken(MySqlParser.SYSTEM_USER, 0); } + public TerminalNode TAN() { return getToken(MySqlParser.TAN, 0); } + public TerminalNode TIME() { return getToken(MySqlParser.TIME, 0); } + public TerminalNode TIMEDIFF() { return getToken(MySqlParser.TIMEDIFF, 0); } + public TerminalNode TIMESTAMP() { return getToken(MySqlParser.TIMESTAMP, 0); } + public TerminalNode TIMESTAMPADD() { return getToken(MySqlParser.TIMESTAMPADD, 0); } + public TerminalNode TIMESTAMPDIFF() { return getToken(MySqlParser.TIMESTAMPDIFF, 0); } + public TerminalNode TIME_FORMAT() { return getToken(MySqlParser.TIME_FORMAT, 0); } + public TerminalNode TIME_TO_SEC() { return getToken(MySqlParser.TIME_TO_SEC, 0); } + public TerminalNode TOUCHES() { return getToken(MySqlParser.TOUCHES, 0); } + public TerminalNode TO_BASE64() { return getToken(MySqlParser.TO_BASE64, 0); } + public TerminalNode TO_DAYS() { return getToken(MySqlParser.TO_DAYS, 0); } + public TerminalNode TO_SECONDS() { return getToken(MySqlParser.TO_SECONDS, 0); } + public TerminalNode UCASE() { return getToken(MySqlParser.UCASE, 0); } + public TerminalNode UNCOMPRESS() { return getToken(MySqlParser.UNCOMPRESS, 0); } + public TerminalNode UNCOMPRESSED_LENGTH() { return getToken(MySqlParser.UNCOMPRESSED_LENGTH, 0); } + public TerminalNode UNHEX() { return getToken(MySqlParser.UNHEX, 0); } + public TerminalNode UNIX_TIMESTAMP() { return getToken(MySqlParser.UNIX_TIMESTAMP, 0); } + public TerminalNode UPDATEXML() { return getToken(MySqlParser.UPDATEXML, 0); } + public TerminalNode UPPER() { return getToken(MySqlParser.UPPER, 0); } + public TerminalNode UUID() { return getToken(MySqlParser.UUID, 0); } + public TerminalNode UUID_SHORT() { return getToken(MySqlParser.UUID_SHORT, 0); } + public TerminalNode VALIDATE_PASSWORD_STRENGTH() { return getToken(MySqlParser.VALIDATE_PASSWORD_STRENGTH, 0); } + public TerminalNode VERSION() { return getToken(MySqlParser.VERSION, 0); } + public TerminalNode VISIBLE() { return getToken(MySqlParser.VISIBLE, 0); } + public TerminalNode WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() { return getToken(MySqlParser.WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS, 0); } + public TerminalNode WEEK() { return getToken(MySqlParser.WEEK, 0); } + public TerminalNode WEEKDAY() { return getToken(MySqlParser.WEEKDAY, 0); } + public TerminalNode WEEKOFYEAR() { return getToken(MySqlParser.WEEKOFYEAR, 0); } + public TerminalNode WEIGHT_STRING() { return getToken(MySqlParser.WEIGHT_STRING, 0); } + public TerminalNode WITHIN() { return getToken(MySqlParser.WITHIN, 0); } + public TerminalNode YEAR() { return getToken(MySqlParser.YEAR, 0); } + public TerminalNode YEARWEEK() { return getToken(MySqlParser.YEARWEEK, 0); } + public TerminalNode Y_FUNCTION() { return getToken(MySqlParser.Y_FUNCTION, 0); } + public TerminalNode X_FUNCTION() { return getToken(MySqlParser.X_FUNCTION, 0); } + public TerminalNode JSON_ARRAY() { return getToken(MySqlParser.JSON_ARRAY, 0); } + public TerminalNode JSON_OBJECT() { return getToken(MySqlParser.JSON_OBJECT, 0); } + public TerminalNode JSON_QUOTE() { return getToken(MySqlParser.JSON_QUOTE, 0); } + public TerminalNode JSON_CONTAINS() { return getToken(MySqlParser.JSON_CONTAINS, 0); } + public TerminalNode JSON_CONTAINS_PATH() { return getToken(MySqlParser.JSON_CONTAINS_PATH, 0); } + public TerminalNode JSON_EXTRACT() { return getToken(MySqlParser.JSON_EXTRACT, 0); } + public TerminalNode JSON_KEYS() { return getToken(MySqlParser.JSON_KEYS, 0); } + public TerminalNode JSON_OVERLAPS() { return getToken(MySqlParser.JSON_OVERLAPS, 0); } + public TerminalNode JSON_SEARCH() { return getToken(MySqlParser.JSON_SEARCH, 0); } + public TerminalNode JSON_VALUE() { return getToken(MySqlParser.JSON_VALUE, 0); } + public TerminalNode JSON_ARRAY_APPEND() { return getToken(MySqlParser.JSON_ARRAY_APPEND, 0); } + public TerminalNode JSON_ARRAY_INSERT() { return getToken(MySqlParser.JSON_ARRAY_INSERT, 0); } + public TerminalNode JSON_INSERT() { return getToken(MySqlParser.JSON_INSERT, 0); } + public TerminalNode JSON_MERGE() { return getToken(MySqlParser.JSON_MERGE, 0); } + public TerminalNode JSON_MERGE_PATCH() { return getToken(MySqlParser.JSON_MERGE_PATCH, 0); } + public TerminalNode JSON_MERGE_PRESERVE() { return getToken(MySqlParser.JSON_MERGE_PRESERVE, 0); } + public TerminalNode JSON_REMOVE() { return getToken(MySqlParser.JSON_REMOVE, 0); } + public TerminalNode JSON_REPLACE() { return getToken(MySqlParser.JSON_REPLACE, 0); } + public TerminalNode JSON_SET() { return getToken(MySqlParser.JSON_SET, 0); } + public TerminalNode JSON_UNQUOTE() { return getToken(MySqlParser.JSON_UNQUOTE, 0); } + public TerminalNode JSON_DEPTH() { return getToken(MySqlParser.JSON_DEPTH, 0); } + public TerminalNode JSON_LENGTH() { return getToken(MySqlParser.JSON_LENGTH, 0); } + public TerminalNode JSON_TYPE() { return getToken(MySqlParser.JSON_TYPE, 0); } + public TerminalNode JSON_VALID() { return getToken(MySqlParser.JSON_VALID, 0); } + public TerminalNode JSON_TABLE() { return getToken(MySqlParser.JSON_TABLE, 0); } + public TerminalNode JSON_SCHEMA_VALID() { return getToken(MySqlParser.JSON_SCHEMA_VALID, 0); } + public TerminalNode JSON_SCHEMA_VALIDATION_REPORT() { return getToken(MySqlParser.JSON_SCHEMA_VALIDATION_REPORT, 0); } + public TerminalNode JSON_PRETTY() { return getToken(MySqlParser.JSON_PRETTY, 0); } + public TerminalNode JSON_STORAGE_FREE() { return getToken(MySqlParser.JSON_STORAGE_FREE, 0); } + public TerminalNode JSON_STORAGE_SIZE() { return getToken(MySqlParser.JSON_STORAGE_SIZE, 0); } + public TerminalNode JSON_ARRAYAGG() { return getToken(MySqlParser.JSON_ARRAYAGG, 0); } + public TerminalNode JSON_OBJECTAGG() { return getToken(MySqlParser.JSON_OBJECTAGG, 0); } + public FunctionNameBaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionNameBase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).enterFunctionNameBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof MySqlParserListener ) ((MySqlParserListener)listener).exitFunctionNameBase(this); + } + } + + public final FunctionNameBaseContext functionNameBase() throws RecognitionException { + FunctionNameBaseContext _localctx = new FunctionNameBaseContext(_ctx, getState()); + enterRule(_localctx, 720, RULE_functionNameBase); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7445); + _la = _input.LA(1); + if ( !(_la==DATABASE || ((((_la - 98)) & ~0x3f) == 0 && ((1L << (_la - 98)) & 11258999068426241L) != 0) || ((((_la - 218)) & ~0x3f) == 0 && ((1L << (_la - 218)) & -17179869161L) != 0) || ((((_la - 282)) & ~0x3f) == 0 && ((1L << (_la - 282)) & 8796109397507L) != 0) || _la==INVISIBLE || ((((_la - 674)) & ~0x3f) == 0 && ((1L << (_la - 674)) & -9223372036838064127L) != 0) || ((((_la - 804)) & ~0x3f) == 0 && ((1L << (_la - 804)) & -8589934599L) != 0) || ((((_la - 868)) & ~0x3f) == 0 && ((1L << (_la - 868)) & -257L) != 0) || ((((_la - 932)) & ~0x3f) == 0 && ((1L << (_la - 932)) & -1L) != 0) || ((((_la - 996)) & ~0x3f) == 0 && ((1L << (_la - 996)) & -1057L) != 0) || ((((_la - 1060)) & ~0x3f) == 0 && ((1L << (_la - 1060)) & 562949416550399L) != 0) || _la==MOD) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 344: + return expression_sempred((ExpressionContext)_localctx, predIndex); + case 345: + return predicate_sempred((PredicateContext)_localctx, predIndex); + case 346: + return expressionAtom_sempred((ExpressionAtomContext)_localctx, predIndex); + } + return true; + } + private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 3); + } + return true; + } + private boolean predicate_sempred(PredicateContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return precpred(_ctx, 8); + case 2: + return precpred(_ctx, 6); + case 3: + return precpred(_ctx, 5); + case 4: + return precpred(_ctx, 3); + case 5: + return precpred(_ctx, 10); + case 6: + return precpred(_ctx, 9); + case 7: + return precpred(_ctx, 7); + case 8: + return precpred(_ctx, 4); + case 9: + return precpred(_ctx, 2); + } + return true; + } + private boolean expressionAtom_sempred(ExpressionAtomContext _localctx, int predIndex) { + switch (predIndex) { + case 10: + return precpred(_ctx, 4); + case 11: + return precpred(_ctx, 3); + case 12: + return precpred(_ctx, 2); + case 13: + return precpred(_ctx, 1); + case 14: + return precpred(_ctx, 15); + } + return true; + } + + private static final String _serializedATNSegment0 = + "\u0004\u0001\u048a\u1d18\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ + "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+ + "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+ + "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+ + "\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+ + "\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+ + "\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+ + "\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+ + "\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+ + "\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+ + "\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+ + "\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+ + "\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+ + ",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+ + "1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+ + "6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+ + ";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+ + "@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+ + "E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+ + "J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+ + "O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+ + "T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+ + "Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+ + "^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007"+ + "c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007"+ + "h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007"+ + "m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007"+ + "r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007"+ + "w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007"+ + "|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007"+ + "\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007"+ + "\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007"+ + "\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007"+ + "\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007"+ + "\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007"+ + "\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007"+ + "\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007"+ + "\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007"+ + "\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007"+ + "\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007"+ + "\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0002\u00a1\u0007"+ + "\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3\u0002\u00a4\u0007"+ + "\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6\u0002\u00a7\u0007"+ + "\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9\u0002\u00aa\u0007"+ + "\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac\u0002\u00ad\u0007"+ + "\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007"+ + "\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007"+ + "\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007"+ + "\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0002\u00b9\u0007"+ + "\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb\u0002\u00bc\u0007"+ + "\u00bc\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be\u0002\u00bf\u0007"+ + "\u00bf\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1\u0002\u00c2\u0007"+ + "\u00c2\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4\u0002\u00c5\u0007"+ + "\u00c5\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7\u0002\u00c8\u0007"+ + "\u00c8\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca\u0002\u00cb\u0007"+ + "\u00cb\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd\u0002\u00ce\u0007"+ + "\u00ce\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0\u0002\u00d1\u0007"+ + "\u00d1\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3\u0002\u00d4\u0007"+ + "\u00d4\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6\u0002\u00d7\u0007"+ + "\u00d7\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9\u0002\u00da\u0007"+ + "\u00da\u0002\u00db\u0007\u00db\u0002\u00dc\u0007\u00dc\u0002\u00dd\u0007"+ + "\u00dd\u0002\u00de\u0007\u00de\u0002\u00df\u0007\u00df\u0002\u00e0\u0007"+ + "\u00e0\u0002\u00e1\u0007\u00e1\u0002\u00e2\u0007\u00e2\u0002\u00e3\u0007"+ + "\u00e3\u0002\u00e4\u0007\u00e4\u0002\u00e5\u0007\u00e5\u0002\u00e6\u0007"+ + "\u00e6\u0002\u00e7\u0007\u00e7\u0002\u00e8\u0007\u00e8\u0002\u00e9\u0007"+ + "\u00e9\u0002\u00ea\u0007\u00ea\u0002\u00eb\u0007\u00eb\u0002\u00ec\u0007"+ + "\u00ec\u0002\u00ed\u0007\u00ed\u0002\u00ee\u0007\u00ee\u0002\u00ef\u0007"+ + "\u00ef\u0002\u00f0\u0007\u00f0\u0002\u00f1\u0007\u00f1\u0002\u00f2\u0007"+ + "\u00f2\u0002\u00f3\u0007\u00f3\u0002\u00f4\u0007\u00f4\u0002\u00f5\u0007"+ + "\u00f5\u0002\u00f6\u0007\u00f6\u0002\u00f7\u0007\u00f7\u0002\u00f8\u0007"+ + "\u00f8\u0002\u00f9\u0007\u00f9\u0002\u00fa\u0007\u00fa\u0002\u00fb\u0007"+ + "\u00fb\u0002\u00fc\u0007\u00fc\u0002\u00fd\u0007\u00fd\u0002\u00fe\u0007"+ + "\u00fe\u0002\u00ff\u0007\u00ff\u0002\u0100\u0007\u0100\u0002\u0101\u0007"+ + "\u0101\u0002\u0102\u0007\u0102\u0002\u0103\u0007\u0103\u0002\u0104\u0007"+ + "\u0104\u0002\u0105\u0007\u0105\u0002\u0106\u0007\u0106\u0002\u0107\u0007"+ + "\u0107\u0002\u0108\u0007\u0108\u0002\u0109\u0007\u0109\u0002\u010a\u0007"+ + "\u010a\u0002\u010b\u0007\u010b\u0002\u010c\u0007\u010c\u0002\u010d\u0007"+ + "\u010d\u0002\u010e\u0007\u010e\u0002\u010f\u0007\u010f\u0002\u0110\u0007"+ + "\u0110\u0002\u0111\u0007\u0111\u0002\u0112\u0007\u0112\u0002\u0113\u0007"+ + "\u0113\u0002\u0114\u0007\u0114\u0002\u0115\u0007\u0115\u0002\u0116\u0007"+ + "\u0116\u0002\u0117\u0007\u0117\u0002\u0118\u0007\u0118\u0002\u0119\u0007"+ + "\u0119\u0002\u011a\u0007\u011a\u0002\u011b\u0007\u011b\u0002\u011c\u0007"+ + "\u011c\u0002\u011d\u0007\u011d\u0002\u011e\u0007\u011e\u0002\u011f\u0007"+ + "\u011f\u0002\u0120\u0007\u0120\u0002\u0121\u0007\u0121\u0002\u0122\u0007"+ + "\u0122\u0002\u0123\u0007\u0123\u0002\u0124\u0007\u0124\u0002\u0125\u0007"+ + "\u0125\u0002\u0126\u0007\u0126\u0002\u0127\u0007\u0127\u0002\u0128\u0007"+ + "\u0128\u0002\u0129\u0007\u0129\u0002\u012a\u0007\u012a\u0002\u012b\u0007"+ + "\u012b\u0002\u012c\u0007\u012c\u0002\u012d\u0007\u012d\u0002\u012e\u0007"+ + "\u012e\u0002\u012f\u0007\u012f\u0002\u0130\u0007\u0130\u0002\u0131\u0007"+ + "\u0131\u0002\u0132\u0007\u0132\u0002\u0133\u0007\u0133\u0002\u0134\u0007"+ + "\u0134\u0002\u0135\u0007\u0135\u0002\u0136\u0007\u0136\u0002\u0137\u0007"+ + "\u0137\u0002\u0138\u0007\u0138\u0002\u0139\u0007\u0139\u0002\u013a\u0007"+ + "\u013a\u0002\u013b\u0007\u013b\u0002\u013c\u0007\u013c\u0002\u013d\u0007"+ + "\u013d\u0002\u013e\u0007\u013e\u0002\u013f\u0007\u013f\u0002\u0140\u0007"+ + "\u0140\u0002\u0141\u0007\u0141\u0002\u0142\u0007\u0142\u0002\u0143\u0007"+ + "\u0143\u0002\u0144\u0007\u0144\u0002\u0145\u0007\u0145\u0002\u0146\u0007"+ + "\u0146\u0002\u0147\u0007\u0147\u0002\u0148\u0007\u0148\u0002\u0149\u0007"+ + "\u0149\u0002\u014a\u0007\u014a\u0002\u014b\u0007\u014b\u0002\u014c\u0007"+ + "\u014c\u0002\u014d\u0007\u014d\u0002\u014e\u0007\u014e\u0002\u014f\u0007"+ + "\u014f\u0002\u0150\u0007\u0150\u0002\u0151\u0007\u0151\u0002\u0152\u0007"+ + "\u0152\u0002\u0153\u0007\u0153\u0002\u0154\u0007\u0154\u0002\u0155\u0007"+ + "\u0155\u0002\u0156\u0007\u0156\u0002\u0157\u0007\u0157\u0002\u0158\u0007"+ + "\u0158\u0002\u0159\u0007\u0159\u0002\u015a\u0007\u015a\u0002\u015b\u0007"+ + "\u015b\u0002\u015c\u0007\u015c\u0002\u015d\u0007\u015d\u0002\u015e\u0007"+ + "\u015e\u0002\u015f\u0007\u015f\u0002\u0160\u0007\u0160\u0002\u0161\u0007"+ + "\u0161\u0002\u0162\u0007\u0162\u0002\u0163\u0007\u0163\u0002\u0164\u0007"+ + "\u0164\u0002\u0165\u0007\u0165\u0002\u0166\u0007\u0166\u0002\u0167\u0007"+ + "\u0167\u0002\u0168\u0007\u0168\u0001\u0000\u0003\u0000\u02d4\b\u0000\u0001"+ + "\u0000\u0001\u0000\u0003\u0000\u02d8\b\u0000\u0001\u0000\u0001\u0000\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0003\u0001\u02df\b\u0001\u0001\u0001\u0003"+ + "\u0001\u02e2\b\u0001\u0001\u0001\u0005\u0001\u02e5\b\u0001\n\u0001\f\u0001"+ + "\u02e8\t\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001\u02ed\b"+ + "\u0001\u0001\u0001\u0003\u0001\u02f0\b\u0001\u0001\u0001\u0003\u0001\u02f3"+ + "\b\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001"+ + "\u0002\u0001\u0002\u0003\u0002\u02fc\b\u0002\u0001\u0003\u0001\u0003\u0001"+ + "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ + "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ + "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ + "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ + "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ + "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ + "\u0004\u0001\u0004\u0003\u0004\u0326\b\u0004\u0001\u0005\u0001\u0005\u0001"+ + "\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+ + "\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005\u0335"+ + "\b\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+ + "\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003\u0006\u0340\b\u0006\u0001"+ + "\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+ + "\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+ + "\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u0351\b\u0007\u0001\b\u0001"+ + "\b\u0001\b\u0003\b\u0356\b\b\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ + "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u0365"+ + "\b\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+ + "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+ + "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0003\n\u0380"+ + "\b\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ + "\u000b\u0001\u000b\u0003\u000b\u0389\b\u000b\u0001\f\u0001\f\u0001\f\u0003"+ + "\f\u038e\b\f\u0001\f\u0001\f\u0005\f\u0392\b\f\n\f\f\f\u0395\t\f\u0001"+ + "\r\u0001\r\u0003\r\u0399\b\r\u0001\r\u0001\r\u0003\r\u039d\b\r\u0001\r"+ + "\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03a6\b\r\u0001"+ + "\r\u0003\r\u03a9\b\r\u0001\r\u0003\r\u03ac\b\r\u0001\r\u0001\r\u0003\r"+ + "\u03b0\b\r\u0001\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0003\u000e"+ + "\u03b7\b\u000e\u0001\u000e\u0003\u000e\u03ba\b\u000e\u0001\u000e\u0001"+ + "\u000e\u0001\u000e\u0003\u000e\u03bf\b\u000e\u0001\u000e\u0001\u000e\u0001"+ + "\u000e\u0001\u000e\u0005\u000e\u03c5\b\u000e\n\u000e\f\u000e\u03c8\t\u000e"+ + "\u0001\u000e\u0001\u000e\u0003\u000e\u03cc\b\u000e\u0001\u000e\u0001\u000e"+ + "\u0001\u000e\u0003\u000e\u03d1\b\u000e\u0001\u000e\u0005\u000e\u03d4\b"+ + "\u000e\n\u000e\f\u000e\u03d7\t\u000e\u0001\u000f\u0001\u000f\u0001\u000f"+ + "\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+ + "\u0003\u000f\u03e2\b\u000f\u0001\u000f\u0003\u000f\u03e5\b\u000f\u0001"+ + "\u000f\u0001\u000f\u0003\u000f\u03e9\b\u000f\u0001\u000f\u0003\u000f\u03ec"+ + "\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u03f0\b\u000f\u0001\u000f"+ + "\u0003\u000f\u03f3\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u03f7\b"+ + "\u000f\u0001\u000f\u0003\u000f\u03fa\b\u000f\u0001\u000f\u0003\u000f\u03fd"+ + "\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0401\b\u000f\u0001\u000f"+ + "\u0003\u000f\u0404\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0408\b"+ + "\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0003\u0010\u040e"+ + "\b\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u0414"+ + "\b\u0010\u0001\u0010\u0001\u0010\u0005\u0010\u0418\b\u0010\n\u0010\f\u0010"+ + "\u041b\t\u0010\u0001\u0010\u0001\u0010\u0005\u0010\u041f\b\u0010\n\u0010"+ + "\f\u0010\u0422\t\u0010\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011"+ + "\u0003\u0011\u0428\b\u0011\u0001\u0011\u0003\u0011\u042b\b\u0011\u0001"+ + "\u0011\u0001\u0011\u0003\u0011\u042f\b\u0011\u0001\u0011\u0001\u0011\u0001"+ + "\u0011\u0003\u0011\u0434\b\u0011\u0001\u0011\u0001\u0011\u0005\u0011\u0438"+ + "\b\u0011\n\u0011\f\u0011\u043b\t\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+ + "\u0001\u0011\u0005\u0011\u0441\b\u0011\n\u0011\f\u0011\u0444\t\u0011\u0001"+ + "\u0011\u0001\u0011\u0003\u0011\u0448\b\u0011\u0001\u0012\u0001\u0012\u0001"+ + "\u0012\u0003\u0012\u044d\b\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0005"+ + "\u0012\u0452\b\u0012\n\u0012\f\u0012\u0455\t\u0012\u0001\u0013\u0001\u0013"+ + "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013"+ + "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0005\u0013\u0463\b\u0013"+ + "\n\u0013\f\u0013\u0466\t\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001"+ + "\u0014\u0003\u0014\u046c\b\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u0470"+ + "\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+ + "\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u047a\b\u0014\u0001\u0014\u0001"+ + "\u0014\u0003\u0014\u047e\b\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u0482"+ + "\b\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u0486\b\u0014\u0001\u0014"+ + "\u0001\u0014\u0003\u0014\u048a\b\u0014\u0001\u0014\u0005\u0014\u048d\b"+ + "\u0014\n\u0014\f\u0014\u0490\t\u0014\u0003\u0014\u0492\b\u0014\u0001\u0014"+ + "\u0003\u0014\u0495\b\u0014\u0001\u0014\u0003\u0014\u0498\b\u0014\u0001"+ + "\u0014\u0003\u0014\u049b\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+ + "\u0014\u0003\u0014\u04a1\b\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u04a5"+ + "\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u04ab"+ + "\b\u0014\u0001\u0014\u0005\u0014\u04ae\b\u0014\n\u0014\f\u0014\u04b1\t"+ + "\u0014\u0003\u0014\u04b3\b\u0014\u0001\u0014\u0003\u0014\u04b6\b\u0014"+ + "\u0003\u0014\u04b8\b\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015"+ + "\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0003\u0015"+ + "\u04c3\b\u0015\u0001\u0015\u0001\u0015\u0003\u0015\u04c7\b\u0015\u0001"+ + "\u0015\u0003\u0015\u04ca\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001"+ + "\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001"+ + "\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u04d8\b\u0016\u0001\u0016\u0003"+ + "\u0016\u04db\b\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u04df\b\u0016"+ + "\u0001\u0016\u0003\u0016\u04e2\b\u0016\u0001\u0016\u0001\u0016\u0003\u0016"+ + "\u04e6\b\u0016\u0001\u0016\u0003\u0016\u04e9\b\u0016\u0001\u0016\u0001"+ + "\u0016\u0003\u0016\u04ed\b\u0016\u0001\u0016\u0003\u0016\u04f0\b\u0016"+ + "\u0001\u0016\u0001\u0016\u0003\u0016\u04f4\b\u0016\u0001\u0016\u0003\u0016"+ + "\u04f7\b\u0016\u0001\u0016\u0003\u0016\u04fa\b\u0016\u0001\u0016\u0001"+ + "\u0016\u0003\u0016\u04fe\b\u0016\u0001\u0016\u0003\u0016\u0501\b\u0016"+ + "\u0001\u0016\u0001\u0016\u0003\u0016\u0505\b\u0016\u0001\u0016\u0001\u0016"+ + "\u0001\u0017\u0001\u0017\u0003\u0017\u050b\b\u0017\u0001\u0017\u0001\u0017"+ + "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+ + "\u0001\u0017\u0001\u0017\u0001\u0017\u0003\u0017\u0518\b\u0017\u0001\u0017"+ + "\u0001\u0017\u0001\u0018\u0001\u0018\u0003\u0018\u051e\b\u0018\u0001\u0018"+ + "\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+ + "\u0005\u0019\u0527\b\u0019\n\u0019\f\u0019\u052a\t\u0019\u0001\u0019\u0001"+ + "\u0019\u0003\u0019\u052e\b\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+ + "\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u0536\b\u0019\u0001\u001a\u0001"+ + "\u001a\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0003\u001c\u053e"+ + "\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u0543\b\u001c"+ + "\u0001\u001c\u0003\u001c\u0546\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ + "\u0003\u001c\u054b\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ + "\u0001\u001c\u0001\u001c\u0003\u001c\u0553\b\u001c\u0001\u001c\u0001\u001c"+ + "\u0001\u001c\u0003\u001c\u0558\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ + "\u0001\u001c\u0003\u001c\u055e\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ + "\u0003\u001c\u0563\b\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u0567\b"+ + "\u001c\u0003\u001c\u0569\b\u001c\u0001\u001d\u0003\u001d\u056c\b\u001d"+ + "\u0001\u001d\u0001\u001d\u0003\u001d\u0570\b\u001d\u0001\u001d\u0001\u001d"+ + "\u0003\u001d\u0574\b\u001d\u0001\u001d\u0003\u001d\u0577\b\u001d\u0001"+ + "\u001d\u0001\u001d\u0003\u001d\u057b\b\u001d\u0001\u001d\u0001\u001d\u0003"+ + "\u001d\u057f\b\u001d\u0001\u001d\u0001\u001d\u0003\u001d\u0583\b\u001d"+ + "\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0003\u001d\u0589\b\u001d"+ + "\u0001\u001d\u0003\u001d\u058c\b\u001d\u0001\u001e\u0001\u001e\u0001\u001e"+ + "\u0001\u001e\u0001\u001e\u0003\u001e\u0593\b\u001e\u0001\u001f\u0001\u001f"+ + "\u0001\u001f\u0003\u001f\u0598\b\u001f\u0001 \u0001 \u0001 \u0001 \u0003"+ + " \u059e\b \u0001!\u0001!\u0001!\u0005!\u05a3\b!\n!\f!\u05a6\t!\u0001!"+ + "\u0001!\u0001!\u0003!\u05ab\b!\u0001!\u0001!\u0001!\u0001!\u0005!\u05b1"+ + "\b!\n!\f!\u05b4\t!\u0003!\u05b6\b!\u0001!\u0001!\u0001!\u0005!\u05bb\b"+ + "!\n!\f!\u05be\t!\u0003!\u05c0\b!\u0003!\u05c2\b!\u0001\"\u0001\"\u0001"+ + "\"\u0001\"\u0003\"\u05c8\b\"\u0001#\u0001#\u0001#\u0001#\u0003#\u05ce"+ + "\b#\u0001#\u0001#\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001"+ + "$\u0001$\u0001$\u0001$\u0001$\u0001$\u0003$\u05df\b$\u0001%\u0001%\u0001"+ + "%\u0001%\u0001%\u0003%\u05e6\b%\u0001&\u0001&\u0001&\u0001\'\u0001\'\u0003"+ + "\'\u05ed\b\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ + "\'\u0001\'\u0001\'\u0003\'\u05f9\b\'\u0001\'\u0001\'\u0001\'\u0003\'\u05fe"+ + "\b\'\u0001\'\u0003\'\u0601\b\'\u0001(\u0003(\u0604\b(\u0001(\u0001(\u0001"+ + "(\u0001)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001*\u0001*\u0003*\u0611"+ + "\b*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001"+ + "*\u0001*\u0003*\u061e\b*\u0001*\u0001*\u0001*\u0003*\u0623\b*\u0001+\u0001"+ + "+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001"+ + "+\u0001+\u0001+\u0003+\u0633\b+\u0001,\u0001,\u0001,\u0001,\u0005,\u0639"+ + "\b,\n,\f,\u063c\t,\u0001,\u0001,\u0001-\u0001-\u0001-\u0001-\u0001-\u0003"+ + "-\u0645\b-\u0001-\u0003-\u0648\b-\u0001-\u0003-\u064b\b-\u0001.\u0001"+ + ".\u0005.\u064f\b.\n.\f.\u0652\t.\u0001.\u0003.\u0655\b.\u0001.\u0003."+ + "\u0658\b.\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ + "/\u0003/\u0663\b/\u0001/\u0003/\u0666\b/\u0001/\u0001/\u0001/\u0003/\u066b"+ + "\b/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ + "/\u0001/\u0003/\u0678\b/\u0001/\u0001/\u0001/\u0001/\u0001/\u0003/\u067f"+ + "\b/\u0001/\u0001/\u0001/\u0001/\u0001/\u0003/\u0686\b/\u0003/\u0688\b"+ + "/\u0001/\u0001/\u0001/\u0001/\u0001/\u0003/\u068f\b/\u00010\u00010\u0003"+ + "0\u0693\b0\u00030\u0695\b0\u00010\u00010\u00010\u00030\u069a\b0\u0001"+ + "0\u00030\u069d\b0\u00010\u00010\u00050\u06a1\b0\n0\f0\u06a4\t0\u00010"+ + "\u00010\u00030\u06a8\b0\u00030\u06aa\b0\u00010\u00010\u00030\u06ae\b0"+ + "\u00010\u00030\u06b1\b0\u00010\u00030\u06b4\b0\u00010\u00010\u00050\u06b8"+ + "\b0\n0\f0\u06bb\t0\u00010\u00010\u00030\u06bf\b0\u00030\u06c1\b0\u0001"+ + "0\u00010\u00010\u00030\u06c6\b0\u00010\u00010\u00010\u00010\u00010\u0003"+ + "0\u06cd\b0\u00030\u06cf\b0\u00010\u00010\u00010\u00010\u00010\u00030\u06d6"+ + "\b0\u00011\u00011\u00011\u00031\u06db\b1\u00011\u00011\u00031\u06df\b"+ + "1\u00011\u00031\u06e2\b1\u00012\u00012\u00012\u00012\u00012\u00012\u0003"+ + "2\u06ea\b2\u00012\u00012\u00012\u00012\u00012\u00012\u00032\u06f2\b2\u0003"+ + "2\u06f4\b2\u00013\u00013\u00013\u00013\u00013\u00013\u00013\u00013\u0003"+ + "3\u06fe\b3\u00014\u00014\u00034\u0702\b4\u00014\u00034\u0705\b4\u0001"+ + "4\u00014\u00054\u0709\b4\n4\f4\u070c\t4\u00014\u00014\u00034\u0710\b4"+ + "\u00014\u00034\u0713\b4\u00014\u00014\u00054\u0717\b4\n4\f4\u071a\t4\u0003"+ + "4\u071c\b4\u00015\u00015\u00035\u0720\b5\u00015\u00035\u0723\b5\u0001"+ + "5\u00015\u00035\u0727\b5\u00015\u00015\u00015\u00035\u072c\b5\u00015\u0001"+ + "5\u00015\u00035\u0731\b5\u00015\u00015\u00015\u00035\u0736\b5\u00015\u0001"+ + "5\u00035\u073a\b5\u00015\u00015\u00035\u073e\b5\u00015\u00015\u00035\u0742"+ + "\b5\u00015\u00015\u00035\u0746\b5\u00015\u00015\u00035\u074a\b5\u0001"+ + "5\u00015\u00035\u074e\b5\u00015\u00015\u00015\u00035\u0753\b5\u00015\u0001"+ + "5\u00015\u00035\u0758\b5\u00015\u00015\u00015\u00035\u075d\b5\u00015\u0001"+ + "5\u00015\u00015\u00035\u0763\b5\u00015\u00015\u00015\u00035\u0768\b5\u0001"+ + "5\u00015\u00015\u00035\u076d\b5\u00015\u00015\u00015\u00035\u0772\b5\u0001"+ + "5\u00015\u00015\u00035\u0777\b5\u00015\u00015\u00015\u00035\u077c\b5\u0001"+ + "5\u00015\u00015\u00015\u00035\u0782\b5\u00015\u00015\u00015\u00035\u0787"+ + "\b5\u00015\u00015\u00015\u00035\u078c\b5\u00015\u00015\u00015\u00035\u0791"+ + "\b5\u00015\u00015\u00015\u00035\u0796\b5\u00015\u00015\u00015\u00035\u079b"+ + "\b5\u00015\u00015\u00015\u00035\u07a0\b5\u00015\u00015\u00015\u00035\u07a5"+ + "\b5\u00015\u00015\u00015\u00015\u00015\u00035\u07ac\b5\u00015\u00015\u0001"+ + "5\u00035\u07b1\b5\u00015\u00015\u00015\u00035\u07b6\b5\u00015\u00015\u0001"+ + "5\u00035\u07bb\b5\u00015\u00015\u00035\u07bf\b5\u00015\u00015\u00015\u0003"+ + "5\u07c4\b5\u00015\u00015\u00015\u00015\u00015\u00015\u00035\u07cc\b5\u0001"+ + "5\u00015\u00015\u00035\u07d1\b5\u00015\u00015\u00015\u00015\u00035\u07d7"+ + "\b5\u00016\u00016\u00017\u00017\u00017\u00018\u00018\u00018\u00018\u0001"+ + "8\u00038\u07e3\b8\u00018\u00018\u00018\u00018\u00018\u00038\u07ea\b8\u0003"+ + "8\u07ec\b8\u00018\u00018\u00018\u00018\u00058\u07f2\b8\n8\f8\u07f5\t8"+ + "\u00018\u00018\u00038\u07f9\b8\u00019\u00039\u07fc\b9\u00019\u00019\u0001"+ + "9\u00019\u00019\u00019\u00039\u0804\b9\u00019\u00019\u00019\u00019\u0003"+ + "9\u080a\b9\u00019\u00019\u00039\u080e\b9\u00019\u00019\u00019\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00019\u00039\u081b\b9\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00039\u0827"+ + "\b9\u00039\u0829\b9\u0001:\u0003:\u082c\b:\u0001:\u0001:\u0001:\u0001"+ + ":\u0001:\u0001:\u0003:\u0834\b:\u0001:\u0001:\u0001:\u0001:\u0003:\u083a"+ + "\b:\u0001:\u0001:\u0001:\u0001:\u0003:\u0840\b:\u0001;\u0001;\u0001;\u0001"+ + ";\u0001;\u0001;\u0001;\u0001;\u0001;\u0005;\u084b\b;\n;\f;\u084e\t;\u0001"+ + ";\u0001;\u0005;\u0852\b;\n;\f;\u0855\t;\u0001;\u0001;\u0001;\u0001;\u0005"+ + ";\u085b\b;\n;\f;\u085e\t;\u0001;\u0001;\u0003;\u0862\b;\u0001;\u0001;"+ + "\u0001;\u0001;\u0001;\u0001;\u0001;\u0005;\u086b\b;\n;\f;\u086e\t;\u0001"+ + ";\u0001;\u0001;\u0001;\u0005;\u0874\b;\n;\f;\u0877\t;\u0001;\u0001;\u0003"+ + ";\u087b\b;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0005"+ + ";\u0885\b;\n;\f;\u0888\t;\u0001;\u0001;\u0005;\u088c\b;\n;\f;\u088f\t"+ + ";\u0001;\u0001;\u0001;\u0001;\u0005;\u0895\b;\n;\f;\u0898\t;\u0001;\u0001"+ + ";\u0003;\u089c\b;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001"+ + ";\u0005;\u08a6\b;\n;\f;\u08a9\t;\u0001;\u0001;\u0005;\u08ad\b;\n;\f;\u08b0"+ + "\t;\u0001;\u0001;\u0001;\u0001;\u0005;\u08b6\b;\n;\f;\u08b9\t;\u0001;"+ + "\u0001;\u0003;\u08bd\b;\u0001;\u0001;\u0001;\u0005;\u08c2\b;\n;\f;\u08c5"+ + "\t;\u0001;\u0001;\u0001;\u0001;\u0005;\u08cb\b;\n;\f;\u08ce\t;\u0001;"+ + "\u0001;\u0003;\u08d2\b;\u0003;\u08d4\b;\u0001<\u0001<\u0001<\u0003<\u08d9"+ + "\b<\u0001=\u0001=\u0001=\u0001=\u0004=\u08df\b=\u000b=\f=\u08e0\u0001"+ + "=\u0001=\u0001>\u0001>\u0001>\u0005>\u08e8\b>\n>\f>\u08eb\t>\u0001?\u0003"+ + "?\u08ee\b?\u0001?\u0003?\u08f1\b?\u0001?\u0001?\u0003?\u08f5\b?\u0001"+ + "?\u0001?\u0001?\u0003?\u08fa\b?\u0001?\u0001?\u0001?\u0001?\u0003?\u0900"+ + "\b?\u0001?\u0001?\u0001?\u0001?\u0003?\u0906\b?\u0001?\u0001?\u0001?\u0003"+ + "?\u090b\b?\u0001?\u0001?\u0001?\u0003?\u0910\b?\u0001?\u0001?\u0001?\u0003"+ + "?\u0915\b?\u0001?\u0001?\u0001?\u0003?\u091a\b?\u0001?\u0003?\u091d\b"+ + "?\u0001@\u0001@\u0001@\u0003@\u0922\b@\u0001@\u0004@\u0925\b@\u000b@\f"+ + "@\u0926\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0003"+ + "@\u0931\b@\u0001A\u0001A\u0003A\u0935\bA\u0001A\u0001A\u0001A\u0001A\u0001"+ + "A\u0003A\u093c\bA\u0001A\u0001A\u0001A\u0003A\u0941\bA\u0001A\u0003A\u0944"+ + "\bA\u0001A\u0001A\u0001A\u0003A\u0949\bA\u0001A\u0003A\u094c\bA\u0001"+ + "A\u0001A\u0003A\u0950\bA\u0001A\u0001A\u0003A\u0954\bA\u0001B\u0001B\u0001"+ + "B\u0001B\u0005B\u095a\bB\nB\fB\u095d\tB\u0001C\u0001C\u0001C\u0001C\u0001"+ + "C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001"+ + "D\u0001D\u0003D\u096f\bD\u0001D\u0003D\u0972\bD\u0001D\u0003D\u0975\b"+ + "D\u0001D\u0001D\u0003D\u0979\bD\u0001D\u0001D\u0001E\u0001E\u0001E\u0001"+ + "E\u0005E\u0981\bE\nE\fE\u0984\tE\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+ + "F\u0001F\u0001F\u0005F\u098e\bF\nF\fF\u0991\tF\u0001F\u0001F\u0001G\u0001"+ + "G\u0003G\u0997\bG\u0001G\u0003G\u099a\bG\u0001G\u0001G\u0001G\u0003G\u099f"+ + "\bG\u0001G\u0001G\u0001G\u0005G\u09a4\bG\nG\fG\u09a7\tG\u0003G\u09a9\b"+ + "G\u0001G\u0003G\u09ac\bG\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001"+ + "H\u0001H\u0001H\u0003H\u09b7\bH\u0001H\u0003H\u09ba\bH\u0001H\u0001H\u0003"+ + "H\u09be\bH\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0003I\u09c6\bI\u0001"+ + "I\u0003I\u09c9\bI\u0001I\u0001I\u0001I\u0003I\u09ce\bI\u0001I\u0001I\u0001"+ + "I\u0001I\u0001I\u0001I\u0003I\u09d6\bI\u0001I\u0001I\u0001I\u0001I\u0003"+ + "I\u09dc\bI\u0001I\u0001I\u0003I\u09e0\bI\u0001J\u0001J\u0003J\u09e4\b"+ + "J\u0001J\u0005J\u09e7\bJ\nJ\fJ\u09ea\tJ\u0001J\u0001J\u0003J\u09ee\bJ"+ + "\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u09f5\bJ\u0001J\u0001J\u0003"+ + "J\u09f9\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0005J\u0a02"+ + "\bJ\nJ\fJ\u0a05\tJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u0a0c\bJ"+ + "\u0001J\u0003J\u0a0f\bJ\u0001J\u0001J\u0005J\u0a13\bJ\nJ\fJ\u0a16\tJ\u0001"+ + "J\u0001J\u0001J\u0003J\u0a1b\bJ\u0003J\u0a1d\bJ\u0001J\u0001J\u0001J\u0003"+ + "J\u0a22\bJ\u0001J\u0003J\u0a25\bJ\u0001J\u0001J\u0005J\u0a29\bJ\nJ\fJ"+ + "\u0a2c\tJ\u0001J\u0001J\u0001J\u0003J\u0a31\bJ\u0003J\u0a33\bJ\u0001J"+ + "\u0001J\u0003J\u0a37\bJ\u0001J\u0003J\u0a3a\bJ\u0001J\u0003J\u0a3d\bJ"+ + "\u0001J\u0001J\u0005J\u0a41\bJ\nJ\fJ\u0a44\tJ\u0001J\u0001J\u0001J\u0003"+ + "J\u0a49\bJ\u0001J\u0003J\u0a4c\bJ\u0001J\u0001J\u0005J\u0a50\bJ\nJ\fJ"+ + "\u0a53\tJ\u0001J\u0001J\u0001J\u0003J\u0a58\bJ\u0003J\u0a5a\bJ\u0001J"+ + "\u0001J\u0001J\u0003J\u0a5f\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0003J\u0a67\bJ\u0003J\u0a69\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0001J\u0003J\u0a72\bJ\u0001J\u0003J\u0a75\bJ\u0001J\u0003J\u0a78\b"+ + "J\u0001J\u0001J\u0001J\u0003J\u0a7d\bJ\u0003J\u0a7f\bJ\u0001J\u0001J\u0001"+ + "J\u0001J\u0001J\u0001J\u0001J\u0003J\u0a88\bJ\u0001J\u0003J\u0a8b\bJ\u0001"+ + "J\u0003J\u0a8e\bJ\u0001J\u0001J\u0001J\u0003J\u0a93\bJ\u0003J\u0a95\b"+ + "J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u0a9e\bJ\u0001"+ + "J\u0001J\u0001J\u0003J\u0aa3\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0003J\u0aab\bJ\u0001J\u0001J\u0003J\u0aaf\bJ\u0001J\u0001J\u0001J\u0001"+ + "J\u0001J\u0001J\u0003J\u0ab7\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0001J\u0001J\u0003J\u0ac1\bJ\u0001J\u0001J\u0001J\u0003J\u0ac6\bJ\u0001"+ + "J\u0001J\u0001J\u0001J\u0001J\u0003J\u0acd\bJ\u0001J\u0001J\u0003J\u0ad1"+ + "\bJ\u0001J\u0001J\u0003J\u0ad5\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0001J\u0003J\u0ae8\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0001J\u0003J\u0af2\bJ\u0001J\u0001J\u0001J\u0001J\u0003J\u0af8\bJ\u0001"+ + "J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "J\u0001J\u0001J\u0001J\u0001J\u0003J\u0b09\bJ\u0001J\u0001J\u0003J\u0b0d"+ + "\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u0b17"+ + "\bJ\u0001J\u0001J\u0001J\u0003J\u0b1c\bJ\u0001J\u0003J\u0b1f\bJ\u0001"+ + "J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u0b28\bJ\u0001J\u0001"+ + "J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u0b33\bJ\u0001"+ + "J\u0001J\u0001J\u0001J\u0005J\u0b39\bJ\nJ\fJ\u0b3c\tJ\u0001J\u0001J\u0001"+ + "J\u0003J\u0b41\bJ\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0005K\u0b49"+ + "\bK\nK\fK\u0b4c\tK\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001"+ + "K\u0001K\u0003K\u0b57\bK\u0001K\u0001K\u0001K\u0001K\u0001K\u0003K\u0b5e"+ + "\bK\u0001K\u0001K\u0001K\u0001K\u0001K\u0003K\u0b65\bK\u0001K\u0001K\u0001"+ + "K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0005K\u0b72"+ + "\bK\nK\fK\u0b75\tK\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001"+ + "K\u0001K\u0001K\u0003K\u0b81\bK\u0001K\u0001K\u0001K\u0001K\u0003K\u0b87"+ + "\bK\u0001K\u0001K\u0001K\u0001K\u0003K\u0b8d\bK\u0001K\u0001K\u0001K\u0001"+ + "K\u0003K\u0b93\bK\u0001K\u0001K\u0001K\u0001K\u0003K\u0b99\bK\u0001K\u0001"+ + "K\u0001K\u0001K\u0003K\u0b9f\bK\u0001K\u0001K\u0001K\u0001K\u0003K\u0ba5"+ + "\bK\u0001L\u0001L\u0001L\u0003L\u0baa\bL\u0001L\u0001L\u0001M\u0001M\u0001"+ + "M\u0003M\u0bb1\bM\u0001M\u0001M\u0001N\u0001N\u0001N\u0003N\u0bb8\bN\u0001"+ + "N\u0001N\u0001N\u0001N\u0001N\u0003N\u0bbf\bN\u0001N\u0001N\u0001N\u0003"+ + "N\u0bc4\bN\u0001N\u0005N\u0bc7\bN\nN\fN\u0bca\tN\u0001O\u0001O\u0001O"+ + "\u0001O\u0001O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0003P\u0bd7"+ + "\bP\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0003Q\u0bde\bQ\u0001Q\u0001Q\u0001"+ + "R\u0001R\u0001R\u0003R\u0be5\bR\u0001R\u0001R\u0001S\u0001S\u0003S\u0beb"+ + "\bS\u0001S\u0001S\u0003S\u0bef\bS\u0001S\u0001S\u0003S\u0bf3\bS\u0001"+ + "T\u0001T\u0001T\u0001T\u0001T\u0003T\u0bfa\bT\u0001T\u0003T\u0bfd\bT\u0001"+ + "U\u0001U\u0001U\u0003U\u0c02\bU\u0001U\u0001U\u0001V\u0001V\u0001V\u0003"+ + "V\u0c09\bV\u0001V\u0001V\u0001V\u0005V\u0c0e\bV\nV\fV\u0c11\tV\u0001V"+ + "\u0003V\u0c14\bV\u0001W\u0001W\u0001W\u0003W\u0c19\bW\u0001W\u0001W\u0001"+ + "W\u0005W\u0c1e\bW\nW\fW\u0c21\tW\u0001X\u0001X\u0001X\u0001X\u0001X\u0001"+ + "X\u0001X\u0001X\u0005X\u0c2b\bX\nX\fX\u0c2e\tX\u0003X\u0c30\bX\u0001X"+ + "\u0001X\u0001X\u0003X\u0c35\bX\u0001X\u0001X\u0001X\u0003X\u0c3a\bX\u0005"+ + "X\u0c3c\bX\nX\fX\u0c3f\tX\u0001X\u0001X\u0001X\u0003X\u0c44\bX\u0001Y"+ + "\u0001Y\u0001Y\u0001Y\u0001Y\u0005Y\u0c4b\bY\nY\fY\u0c4e\tY\u0001Z\u0001"+ + "Z\u0001Z\u0001Z\u0001[\u0001[\u0003[\u0c56\b[\u0001[\u0001[\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0003\\\u0c5f\b\\\u0001\\\u0003\\\u0c62\b\\"+ + "\u0001]\u0001]\u0003]\u0c66\b]\u0001^\u0001^\u0001^\u0001_\u0001_\u0001"+ + "_\u0001_\u0003_\u0c6f\b_\u0001`\u0001`\u0003`\u0c73\b`\u0001`\u0003`\u0c76"+ + "\b`\u0001`\u0003`\u0c79\b`\u0001`\u0001`\u0001`\u0001`\u0003`\u0c7f\b"+ + "`\u0001`\u0003`\u0c82\b`\u0001`\u0001`\u0003`\u0c86\b`\u0001`\u0003`\u0c89"+ + "\b`\u0001`\u0001`\u0003`\u0c8d\b`\u0001`\u0003`\u0c90\b`\u0001`\u0001"+ + "`\u0001`\u0001`\u0005`\u0c96\b`\n`\f`\u0c99\t`\u0003`\u0c9b\b`\u0001`"+ + "\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0005`\u0ca4\b`\n`\f`\u0ca7"+ + "\t`\u0003`\u0ca9\b`\u0001a\u0001a\u0001a\u0003a\u0cae\ba\u0001a\u0003"+ + "a\u0cb1\ba\u0001a\u0001a\u0001a\u0003a\u0cb6\ba\u0001a\u0001a\u0001a\u0001"+ + "a\u0001a\u0001a\u0001a\u0001a\u0003a\u0cc0\ba\u0001a\u0001a\u0001a\u0003"+ + "a\u0cc5\ba\u0001a\u0001a\u0004a\u0cc9\ba\u000ba\fa\u0cca\u0003a\u0ccd"+ + "\ba\u0001a\u0001a\u0004a\u0cd1\ba\u000ba\fa\u0cd2\u0003a\u0cd5\ba\u0001"+ + "a\u0001a\u0001a\u0001a\u0003a\u0cdb\ba\u0001a\u0001a\u0001a\u0001a\u0005"+ + "a\u0ce1\ba\na\fa\u0ce4\ta\u0001a\u0001a\u0003a\u0ce8\ba\u0001a\u0001a"+ + "\u0001a\u0001a\u0005a\u0cee\ba\na\fa\u0cf1\ta\u0003a\u0cf3\ba\u0001b\u0001"+ + "b\u0001b\u0003b\u0cf8\bb\u0001b\u0003b\u0cfb\bb\u0001b\u0001b\u0001b\u0003"+ + "b\u0d00\bb\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0003b\u0d08\bb\u0001"+ + "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0003b\u0d10\bb\u0001b\u0001b\u0001"+ + "b\u0001b\u0003b\u0d16\bb\u0001b\u0001b\u0001b\u0001b\u0005b\u0d1c\bb\n"+ + "b\fb\u0d1f\tb\u0001b\u0001b\u0003b\u0d23\bb\u0001b\u0001b\u0001b\u0001"+ + "b\u0005b\u0d29\bb\nb\fb\u0d2c\tb\u0003b\u0d2e\bb\u0001c\u0001c\u0003c"+ + "\u0d32\bc\u0001c\u0003c\u0d35\bc\u0001c\u0001c\u0001c\u0001c\u0001c\u0001"+ + "c\u0003c\u0d3d\bc\u0001c\u0001c\u0001c\u0001c\u0003c\u0d43\bc\u0001c\u0001"+ + "c\u0001c\u0001c\u0001c\u0005c\u0d4a\bc\nc\fc\u0d4d\tc\u0003c\u0d4f\bc"+ + "\u0001d\u0001d\u0003d\u0d53\bd\u0001d\u0001d\u0003d\u0d57\bd\u0001d\u0001"+ + "d\u0003d\u0d5b\bd\u0001d\u0004d\u0d5e\bd\u000bd\fd\u0d5f\u0001d\u0001"+ + "d\u0003d\u0d64\bd\u0001d\u0001d\u0003d\u0d68\bd\u0003d\u0d6a\bd\u0001"+ + "d\u0003d\u0d6d\bd\u0001d\u0003d\u0d70\bd\u0001d\u0003d\u0d73\bd\u0001"+ + "d\u0001d\u0004d\u0d77\bd\u000bd\fd\u0d78\u0001d\u0001d\u0003d\u0d7d\b"+ + "d\u0001d\u0003d\u0d80\bd\u0001d\u0003d\u0d83\bd\u0001d\u0003d\u0d86\b"+ + "d\u0001d\u0003d\u0d89\bd\u0001d\u0001d\u0001d\u0004d\u0d8e\bd\u000bd\f"+ + "d\u0d8f\u0003d\u0d92\bd\u0001e\u0001e\u0003e\u0d96\be\u0001f\u0001f\u0001"+ + "f\u0003f\u0d9b\bf\u0001f\u0001f\u0001f\u0001f\u0003f\u0da1\bf\u0001f\u0005"+ + "f\u0da4\bf\nf\ff\u0da7\tf\u0001g\u0001g\u0001g\u0001g\u0003g\u0dad\bg"+ + "\u0001g\u0001g\u0001g\u0001g\u0003g\u0db3\bg\u0001g\u0005g\u0db6\bg\n"+ + "g\fg\u0db9\tg\u0003g\u0dbb\bg\u0001h\u0001h\u0001h\u0001h\u0003h\u0dc1"+ + "\bh\u0001i\u0001i\u0003i\u0dc5\bi\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0003j\u0dcd\bj\u0001k\u0001k\u0003k\u0dd1\bk\u0001k\u0003k\u0dd4\b"+ + "k\u0001k\u0003k\u0dd7\bk\u0001k\u0001k\u0001k\u0003k\u0ddc\bk\u0001k\u0003"+ + "k\u0ddf\bk\u0001k\u0001k\u0001k\u0001k\u0001k\u0003k\u0de6\bk\u0001k\u0001"+ + "k\u0003k\u0dea\bk\u0001k\u0003k\u0ded\bk\u0001k\u0001k\u0003k\u0df1\b"+ + "k\u0001l\u0001l\u0003l\u0df5\bl\u0001l\u0003l\u0df8\bl\u0001l\u0003l\u0dfb"+ + "\bl\u0001l\u0001l\u0001l\u0003l\u0e00\bl\u0001l\u0001l\u0001l\u0001l\u0003"+ + "l\u0e06\bl\u0005l\u0e08\bl\nl\fl\u0e0b\tl\u0001l\u0001l\u0001l\u0001l"+ + "\u0001l\u0001l\u0001l\u0003l\u0e14\bl\u0001l\u0001l\u0001l\u0001l\u0003"+ + "l\u0e1a\bl\u0005l\u0e1c\bl\nl\fl\u0e1f\tl\u0001l\u0001l\u0001l\u0003l"+ + "\u0e24\bl\u0001l\u0001l\u0003l\u0e28\bl\u0001m\u0001m\u0001m\u0001m\u0003"+ + "m\u0e2e\bm\u0001m\u0003m\u0e31\bm\u0001n\u0001n\u0001n\u0001n\u0001n\u0001"+ + "n\u0001n\u0001n\u0001n\u0001n\u0003n\u0e3d\bn\u0001n\u0001n\u0003n\u0e41"+ + "\bn\u0001n\u0001n\u0003n\u0e45\bn\u0001o\u0001o\u0001o\u0001o\u0001o\u0001"+ + "o\u0003o\u0e4d\bo\u0001o\u0001o\u0003o\u0e51\bo\u0001p\u0001p\u0001p\u0001"+ + "p\u0001q\u0001q\u0003q\u0e59\bq\u0001q\u0003q\u0e5c\bq\u0001q\u0001q\u0003"+ + "q\u0e60\bq\u0001q\u0003q\u0e63\bq\u0001q\u0001q\u0001q\u0001q\u0005q\u0e69"+ + "\bq\nq\fq\u0e6c\tq\u0001q\u0001q\u0003q\u0e70\bq\u0001q\u0003q\u0e73\b"+ + "q\u0001q\u0003q\u0e76\bq\u0001r\u0001r\u0003r\u0e7a\br\u0001r\u0003r\u0e7d"+ + "\br\u0001r\u0001r\u0001r\u0001r\u0001r\u0005r\u0e84\br\nr\fr\u0e87\tr"+ + "\u0001r\u0001r\u0003r\u0e8b\br\u0001s\u0001s\u0001s\u0001s\u0001s\u0005"+ + "s\u0e92\bs\ns\fs\u0e95\ts\u0001t\u0001t\u0003t\u0e99\bt\u0001u\u0001u"+ + "\u0001u\u0005u\u0e9e\bu\nu\fu\u0ea1\tu\u0001v\u0001v\u0005v\u0ea5\bv\n"+ + "v\fv\u0ea8\tv\u0001v\u0001v\u0001v\u0005v\u0ead\bv\nv\fv\u0eb0\tv\u0001"+ + "v\u0001v\u0001v\u0003v\u0eb5\bv\u0001w\u0001w\u0001w\u0001w\u0001w\u0001"+ + "w\u0003w\u0ebd\bw\u0001w\u0003w\u0ec0\bw\u0001w\u0003w\u0ec3\bw\u0001"+ + "w\u0001w\u0001w\u0005w\u0ec8\bw\nw\fw\u0ecb\tw\u0003w\u0ecd\bw\u0001w"+ + "\u0001w\u0001w\u0001w\u0001w\u0003w\u0ed4\bw\u0001w\u0003w\u0ed7\bw\u0001"+ + "w\u0001w\u0001w\u0001w\u0001w\u0001w\u0003w\u0edf\bw\u0001x\u0001x\u0001"+ + "x\u0001x\u0003x\u0ee5\bx\u0001x\u0001x\u0001x\u0001x\u0001y\u0001y\u0001"+ + "y\u0001y\u0001y\u0003y\u0ef0\by\u0001z\u0003z\u0ef3\bz\u0001z\u0001z\u0003"+ + "z\u0ef7\bz\u0001z\u0001z\u0005z\u0efb\bz\nz\fz\u0efe\tz\u0001z\u0001z"+ + "\u0001z\u0001z\u0005z\u0f04\bz\nz\fz\u0f07\tz\u0001z\u0001z\u0003z\u0f0b"+ + "\bz\u0001z\u0001z\u0003z\u0f0f\bz\u0001z\u0001z\u0005z\u0f13\bz\nz\fz"+ + "\u0f16\tz\u0001z\u0001z\u0001z\u0003z\u0f1b\bz\u0003z\u0f1d\bz\u0001z"+ + "\u0001z\u0003z\u0f21\bz\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001"+ + "{\u0003{\u0f2a\b{\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001"+ + "|\u0003|\u0f34\b|\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001"+ + "}\u0003}\u0f3e\b}\u0001~\u0001~\u0005~\u0f42\b~\n~\f~\u0f45\t~\u0001~"+ + "\u0001~\u0003~\u0f49\b~\u0001~\u0001~\u0003~\u0f4d\b~\u0001~\u0003~\u0f50"+ + "\b~\u0001~\u0003~\u0f53\b~\u0001~\u0003~\u0f56\b~\u0001~\u0003~\u0f59"+ + "\b~\u0001~\u0001~\u0005~\u0f5d\b~\n~\f~\u0f60\t~\u0001~\u0001~\u0001~"+ + "\u0003~\u0f65\b~\u0001~\u0003~\u0f68\b~\u0001~\u0003~\u0f6b\b~\u0001~"+ + "\u0003~\u0f6e\b~\u0001~\u0003~\u0f71\b~\u0001~\u0003~\u0f74\b~\u0003~"+ + "\u0f76\b~\u0001\u007f\u0001\u007f\u0005\u007f\u0f7a\b\u007f\n\u007f\f"+ + "\u007f\u0f7d\t\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u0f82"+ + "\b\u007f\u0001\u007f\u0003\u007f\u0f85\b\u007f\u0001\u007f\u0003\u007f"+ + "\u0f88\b\u007f\u0001\u007f\u0003\u007f\u0f8b\b\u007f\u0001\u007f\u0003"+ + "\u007f\u0f8e\b\u007f\u0001\u007f\u0003\u007f\u0f91\b\u007f\u0001\u0080"+ + "\u0001\u0080\u0003\u0080\u0f95\b\u0080\u0001\u0080\u0001\u0080\u0001\u0081"+ + "\u0001\u0081\u0003\u0081\u0f9b\b\u0081\u0001\u0081\u0001\u0081\u0003\u0081"+ + "\u0f9f\b\u0081\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082"+ + "\u0001\u0082\u0003\u0082\u0fa7\b\u0082\u0001\u0082\u0001\u0082\u0003\u0082"+ + "\u0fab\b\u0082\u0001\u0082\u0003\u0082\u0fae\b\u0082\u0003\u0082\u0fb0"+ + "\b\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001"+ + "\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0003"+ + "\u0083\u0fbd\b\u0083\u0001\u0083\u0003\u0083\u0fc0\b\u0083\u0001\u0084"+ + "\u0001\u0084\u0001\u0084\u0005\u0084\u0fc5\b\u0084\n\u0084\f\u0084\u0fc8"+ + "\t\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001"+ + "\u0085\u0001\u0085\u0003\u0085\u0fd1\b\u0085\u0001\u0085\u0003\u0085\u0fd4"+ + "\b\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0003\u0085\u0fd9\b\u0085"+ + "\u0003\u0085\u0fdb\b\u0085\u0001\u0085\u0001\u0085\u0003\u0085\u0fdf\b"+ + "\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001"+ + "\u0085\u0003\u0085\u0fe7\b\u0085\u0001\u0086\u0001\u0086\u0001\u0086\u0001"+ + "\u0086\u0003\u0086\u0fed\b\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001"+ + "\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0003\u0087\u0ff6\b\u0087\u0001"+ + "\u0087\u0001\u0087\u0001\u0087\u0001\u0088\u0001\u0088\u0001\u0088\u0001"+ + "\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u1003"+ + "\b\u0088\u0001\u0089\u0001\u0089\u0003\u0089\u1007\b\u0089\u0001\u0089"+ + "\u0001\u0089\u0005\u0089\u100b\b\u0089\n\u0089\f\u0089\u100e\t\u0089\u0001"+ + "\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0003"+ + "\u008a\u1016\b\u008a\u0001\u008a\u0003\u008a\u1019\b\u008a\u0001\u008a"+ + "\u0001\u008a\u0003\u008a\u101d\b\u008a\u0001\u008a\u0003\u008a\u1020\b"+ + "\u008a\u0001\u008a\u0001\u008a\u0003\u008a\u1024\b\u008a\u0001\u008a\u0001"+ + "\u008a\u0003\u008a\u1028\b\u008a\u0001\u008a\u0003\u008a\u102b\b\u008a"+ + "\u0003\u008a\u102d\b\u008a\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b"+ + "\u0005\u008b\u1033\b\u008b\n\u008b\f\u008b\u1036\t\u008b\u0001\u008b\u0001"+ + "\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+ + "\u008b\u0001\u008b\u0003\u008b\u1041\b\u008b\u0001\u008b\u0001\u008b\u0004"+ + "\u008b\u1045\b\u008b\u000b\u008b\f\u008b\u1046\u0003\u008b\u1049\b\u008b"+ + "\u0001\u008b\u0001\u008b\u0004\u008b\u104d\b\u008b\u000b\u008b\f\u008b"+ + "\u104e\u0003\u008b\u1051\b\u008b\u0003\u008b\u1053\b\u008b\u0001\u008c"+ + "\u0001\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u1059\b\u008c\u0001\u008c"+ + "\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0003\u008c"+ + "\u1061\b\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d"+ + "\u0001\u008d\u0003\u008d\u1069\b\u008d\u0001\u008e\u0001\u008e\u0003\u008e"+ + "\u106d\b\u008e\u0001\u008e\u0001\u008e\u0003\u008e\u1071\b\u008e\u0001"+ + "\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0005\u008f\u1078"+ + "\b\u008f\n\u008f\f\u008f\u107b\t\u008f\u0001\u008f\u0001\u008f\u0003\u008f"+ + "\u107f\b\u008f\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0091\u0001\u0091"+ + "\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091"+ + "\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0005\u0091"+ + "\u1091\b\u0091\n\u0091\f\u0091\u1094\t\u0091\u0001\u0092\u0001\u0092\u0003"+ + "\u0092\u1098\b\u0092\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0003"+ + "\u0093\u109e\b\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001"+ + "\u0093\u0003\u0093\u10a5\b\u0093\u0001\u0094\u0001\u0094\u0001\u0094\u0003"+ + "\u0094\u10aa\b\u0094\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001"+ + "\u0095\u0005\u0095\u10b1\b\u0095\n\u0095\f\u0095\u10b4\t\u0095\u0003\u0095"+ + "\u10b6\b\u0095\u0001\u0096\u0001\u0096\u0003\u0096\u10ba\b\u0096\u0001"+ + "\u0097\u0001\u0097\u0003\u0097\u10be\b\u0097\u0001\u0097\u0001\u0097\u0003"+ + "\u0097\u10c2\b\u0097\u0001\u0097\u0003\u0097\u10c5\b\u0097\u0001\u0097"+ + "\u0003\u0097\u10c8\b\u0097\u0001\u0097\u0003\u0097\u10cb\b\u0097\u0001"+ + "\u0098\u0001\u0098\u0003\u0098\u10cf\b\u0098\u0001\u0098\u0001\u0098\u0003"+ + "\u0098\u10d3\b\u0098\u0001\u0098\u0003\u0098\u10d6\b\u0098\u0001\u0098"+ + "\u0003\u0098\u10d9\b\u0098\u0001\u0098\u0003\u0098\u10dc\b\u0098\u0001"+ + "\u0099\u0001\u0099\u0001\u0099\u0001\u009a\u0001\u009a\u0003\u009a\u10e3"+ + "\b\u009a\u0001\u009a\u0001\u009a\u0003\u009a\u10e7\b\u009a\u0001\u009a"+ + "\u0001\u009a\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009c"+ + "\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0005\u009c\u10f4\b\u009c"+ + "\n\u009c\f\u009c\u10f7\t\u009c\u0001\u009c\u0003\u009c\u10fa\b\u009c\u0001"+ + "\u009d\u0001\u009d\u0001\u009d\u0001\u009e\u0001\u009e\u0001\u009e\u0001"+ + "\u009e\u0001\u009e\u0001\u009f\u0001\u009f\u0003\u009f\u1106\b\u009f\u0001"+ + "\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0005\u009f\u110c\b\u009f\n"+ + "\u009f\f\u009f\u110f\t\u009f\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001"+ + "\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0003\u00a0\u1118\b\u00a0\u0001"+ + "\u00a1\u0001\u00a1\u0003\u00a1\u111c\b\u00a1\u0001\u00a1\u0003\u00a1\u111f"+ + "\b\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a2\u0001\u00a2\u0003\u00a2\u1125"+ + "\b\u00a2\u0001\u00a2\u0003\u00a2\u1128\b\u00a2\u0001\u00a2\u0003\u00a2"+ + "\u112b\b\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3"+ + "\u0001\u00a3\u0001\u00a3\u0003\u00a3\u1134\b\u00a3\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0003\u00a4"+ + "\u113d\b\u00a4\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5"+ + "\u0001\u00a5\u0005\u00a5\u1145\b\u00a5\n\u00a5\f\u00a5\u1148\t\u00a5\u0001"+ + "\u00a5\u0003\u00a5\u114b\b\u00a5\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+ + "\u00a6\u0001\u00a6\u0001\u00a6\u0005\u00a6\u1153\b\u00a6\n\u00a6\f\u00a6"+ + "\u1156\t\u00a6\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7"+ + "\u0001\u00a7\u0001\u00a7\u0003\u00a7\u115f\b\u00a7\u0001\u00a8\u0001\u00a8"+ + "\u0001\u00a8\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0003\u00a9\u1167\b\u00a9"+ + "\u0001\u00a9\u0003\u00a9\u116a\b\u00a9\u0001\u00aa\u0001\u00aa\u0001\u00aa"+ + "\u0001\u00aa\u0001\u00aa\u0005\u00aa\u1171\b\u00aa\n\u00aa\f\u00aa\u1174"+ + "\t\u00aa\u0003\u00aa\u1176\b\u00aa\u0001\u00aa\u0001\u00aa\u0003\u00aa"+ + "\u117a\b\u00aa\u0001\u00aa\u0005\u00aa\u117d\b\u00aa\n\u00aa\f\u00aa\u1180"+ + "\t\u00aa\u0001\u00aa\u0003\u00aa\u1183\b\u00aa\u0001\u00ab\u0001\u00ab"+ + "\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0005\u00ab\u118a\b\u00ab\n\u00ab"+ + "\f\u00ab\u118d\t\u00ab\u0003\u00ab\u118f\b\u00ab\u0001\u00ac\u0001\u00ac"+ + "\u0001\u00ac\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ae\u0001\u00ae"+ + "\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae"+ + "\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae"+ + "\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae"+ + "\u0001\u00ae\u0005\u00ae\u11ac\b\u00ae\n\u00ae\f\u00ae\u11af\t\u00ae\u0003"+ + "\u00ae\u11b1\b\u00ae\u0001\u00ae\u0003\u00ae\u11b4\b\u00ae\u0001\u00af"+ + "\u0001\u00af\u0001\u00b0\u0001\u00b0\u0001\u00b1\u0001\u00b1\u0001\u00b2"+ + "\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ + "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ + "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ + "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ + "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ + "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ + "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ + "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0005\u00b3\u11ea\b\u00b3\n\u00b3"+ + "\f\u00b3\u11ed\t\u00b3\u0001\u00b3\u0001\u00b3\u0003\u00b3\u11f1\b\u00b3"+ + "\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4"+ + "\u0001\u00b5\u0001\u00b5\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6"+ + "\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6"+ + "\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6"+ + "\u0001\u00b6\u0001\u00b6\u0003\u00b6\u120d\b\u00b6\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0003\u00b7\u121b\b\u00b7"+ + "\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0005\u00b8\u1220\b\u00b8\n\u00b8"+ + "\f\u00b8\u1223\t\u00b8\u0001\u00b8\u0003\u00b8\u1226\b\u00b8\u0001\u00b9"+ + "\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0003\u00b9\u122c\b\u00b9\u0001\u00ba"+ + "\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba"+ + "\u1234\b\u00ba\u0003\u00ba\u1236\b\u00ba\u0001\u00bb\u0001\u00bb\u0001"+ + "\u00bb\u0001\u00bb\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001"+ + "\u00bc\u0003\u00bc\u1241\b\u00bc\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001"+ + "\u00bd\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0003\u00be\u124b"+ + "\b\u00be\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003"+ + "\u00bf\u1252\b\u00bf\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0003"+ + "\u00c0\u1258\b\u00c0\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001"+ + "\u00c2\u0001\u00c2\u0003\u00c2\u1260\b\u00c2\u0001\u00c3\u0001\u00c3\u0001"+ + "\u00c3\u0003\u00c3\u1265\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001"+ + "\u00c3\u0005\u00c3\u126b\b\u00c3\n\u00c3\f\u00c3\u126e\t\u00c3\u0001\u00c3"+ + "\u0001\u00c3\u0001\u00c3\u0005\u00c3\u1273\b\u00c3\n\u00c3\f\u00c3\u1276"+ + "\t\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0005\u00c3\u127b\b\u00c3"+ + "\n\u00c3\f\u00c3\u127e\t\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0005"+ + "\u00c3\u1283\b\u00c3\n\u00c3\f\u00c3\u1286\t\u00c3\u0001\u00c3\u0005\u00c3"+ + "\u1289\b\u00c3\n\u00c3\f\u00c3\u128c\t\u00c3\u0001\u00c3\u0001\u00c3\u0003"+ + "\u00c3\u1290\b\u00c3\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0003\u00c4\u1295"+ + "\b\u00c4\u0001\u00c4\u0004\u00c4\u1298\b\u00c4\u000b\u00c4\f\u00c4\u1299"+ + "\u0001\u00c4\u0001\u00c4\u0004\u00c4\u129e\b\u00c4\u000b\u00c4\f\u00c4"+ + "\u129f\u0003\u00c4\u12a2\b\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001"+ + "\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0004\u00c5\u12ab\b\u00c5\u000b"+ + "\u00c5\f\u00c5\u12ac\u0001\u00c5\u0005\u00c5\u12b0\b\u00c5\n\u00c5\f\u00c5"+ + "\u12b3\t\u00c5\u0001\u00c5\u0001\u00c5\u0004\u00c5\u12b7\b\u00c5\u000b"+ + "\u00c5\f\u00c5\u12b8\u0003\u00c5\u12bb\b\u00c5\u0001\u00c5\u0001\u00c5"+ + "\u0001\u00c5\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c7\u0001\u00c7"+ + "\u0001\u00c7\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0003\u00c8\u12c9\b\u00c8"+ + "\u0001\u00c8\u0001\u00c8\u0004\u00c8\u12cd\b\u00c8\u000b\u00c8\f\u00c8"+ + "\u12ce\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0003\u00c8\u12d4\b\u00c8\u0001"+ + "\u00c9\u0001\u00c9\u0001\u00c9\u0003\u00c9\u12d9\b\u00c9\u0001\u00c9\u0001"+ + "\u00c9\u0004\u00c9\u12dd\b\u00c9\u000b\u00c9\f\u00c9\u12de\u0001\u00c9"+ + "\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0003\u00c9\u12e6\b\u00c9"+ + "\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00cb\u0001\u00cb\u0001\u00cb"+ + "\u0003\u00cb\u12ee\b\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb"+ + "\u0004\u00cb\u12f4\b\u00cb\u000b\u00cb\f\u00cb\u12f5\u0001\u00cb\u0001"+ + "\u00cb\u0001\u00cb\u0003\u00cb\u12fb\b\u00cb\u0001\u00cc\u0001\u00cc\u0001"+ + "\u00cc\u0001\u00cc\u0003\u00cc\u1301\b\u00cc\u0001\u00cc\u0003\u00cc\u1304"+ + "\b\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001"+ + "\u00cc\u0003\u00cc\u130c\b\u00cc\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001"+ + "\u00cd\u0001\u00cd\u0003\u00cd\u1313\b\u00cd\u0001\u00ce\u0001\u00ce\u0001"+ + "\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0003\u00ce\u131c"+ + "\b\u00ce\u0001\u00ce\u0003\u00ce\u131f\b\u00ce\u0001\u00cf\u0001\u00cf"+ + "\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00d0\u0001\u00d0"+ + "\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0005\u00d0"+ + "\u132e\b\u00d0\n\u00d0\f\u00d0\u1331\t\u00d0\u0001\u00d0\u0001\u00d0\u0001"+ + "\u00d1\u0001\u00d1\u0001\u00d1\u0003\u00d1\u1338\b\u00d1\u0001\u00d1\u0001"+ + "\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0003\u00d1\u1340"+ + "\b\u00d1\u0001\u00d2\u0001\u00d2\u0003\u00d2\u1344\b\u00d2\u0001\u00d2"+ + "\u0001\u00d2\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0003\u00d3\u134b\b\u00d3"+ + "\u0001\u00d3\u0001\u00d3\u0004\u00d3\u134f\b\u00d3\u000b\u00d3\f\u00d3"+ + "\u1350\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0004\u00d4\u1357"+ + "\b\u00d4\u000b\u00d4\f\u00d4\u1358\u0001\u00d5\u0001\u00d5\u0001\u00d5"+ + "\u0001\u00d5\u0001\u00d5\u0005\u00d5\u1360\b\u00d5\n\u00d5\f\u00d5\u1363"+ + "\t\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0003\u00d5\u1368\b\u00d5"+ + "\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0005\u00d5\u136d\b\u00d5\n\u00d5"+ + "\f\u00d5\u1370\t\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5"+ + "\u0003\u00d5\u1376\b\u00d5\u0001\u00d5\u0005\u00d5\u1379\b\u00d5\n\u00d5"+ + "\f\u00d5\u137c\t\u00d5\u0003\u00d5\u137e\b\u00d5\u0003\u00d5\u1380\b\u00d5"+ + "\u0001\u00d5\u0001\u00d5\u0004\u00d5\u1384\b\u00d5\u000b\u00d5\f\u00d5"+ + "\u1385\u0003\u00d5\u1388\b\u00d5\u0001\u00d5\u0001\u00d5\u0005\u00d5\u138c"+ + "\b\u00d5\n\u00d5\f\u00d5\u138f\t\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5"+ + "\u0001\u00d5\u0003\u00d5\u1395\b\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5"+ + "\u0003\u00d5\u139a\b\u00d5\u0001\u00d5\u0001\u00d5\u0003\u00d5\u139e\b"+ + "\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0003\u00d5\u13a4"+ + "\b\u00d5\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0005"+ + "\u00d6\u13ab\b\u00d6\n\u00d6\f\u00d6\u13ae\t\u00d6\u0001\u00d6\u0001\u00d6"+ + "\u0001\u00d6\u0003\u00d6\u13b3\b\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6"+ + "\u0005\u00d6\u13b8\b\u00d6\n\u00d6\f\u00d6\u13bb\t\u00d6\u0001\u00d6\u0001"+ + "\u00d6\u0001\u00d6\u0003\u00d6\u13c0\b\u00d6\u0001\u00d6\u0001\u00d6\u0001"+ + "\u00d6\u0001\u00d6\u0003\u00d6\u13c6\b\u00d6\u0001\u00d6\u0005\u00d6\u13c9"+ + "\b\u00d6\n\u00d6\f\u00d6\u13cc\t\u00d6\u0003\u00d6\u13ce\b\u00d6\u0003"+ + "\u00d6\u13d0\b\u00d6\u0001\u00d6\u0001\u00d6\u0004\u00d6\u13d4\b\u00d6"+ + "\u000b\u00d6\f\u00d6\u13d5\u0003\u00d6\u13d8\b\u00d6\u0001\u00d6\u0001"+ + "\u00d6\u0005\u00d6\u13dc\b\u00d6\n\u00d6\f\u00d6\u13df\t\u00d6\u0001\u00d6"+ + "\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0003\u00d6\u13e5\b\u00d6\u0003\u00d6"+ + "\u13e7\b\u00d6\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0003\u00d7\u13ec\b"+ + "\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0005\u00d7\u13f1\b\u00d7\n"+ + "\u00d7\f\u00d7\u13f4\t\u00d7\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0005\u00d8\u13fa\b\u00d8\n\u00d8\f\u00d8\u13fd\t\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0003\u00d8\u1401\b\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0005\u00d8\u1408\b\u00d8\n\u00d8\f\u00d8\u140b"+ + "\t\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8\u1411"+ + "\b\u00d8\u0001\u00d8\u0005\u00d8\u1414\b\u00d8\n\u00d8\f\u00d8\u1417\t"+ + "\u00d8\u0003\u00d8\u1419\b\u00d8\u0003\u00d8\u141b\b\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0005\u00d8\u1421\b\u00d8\n\u00d8"+ + "\f\u00d8\u1424\t\u00d8\u0003\u00d8\u1426\b\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8\u142e\b\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8\u1433\b\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0003\u00d8\u1438\b\u00d8\u0005\u00d8\u143a\b"+ + "\u00d8\n\u00d8\f\u00d8\u143d\t\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0003\u00d8\u1442\b\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8"+ + "\u1447\b\u00d8\u0005\u00d8\u1449\b\u00d8\n\u00d8\f\u00d8\u144c\t\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8\u1451\b\u00d8\u0003\u00d8"+ + "\u1453\b\u00d8\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9"+ + "\u0001\u00d9\u0001\u00d9\u0005\u00d9\u145c\b\u00d9\n\u00d9\f\u00d9\u145f"+ + "\t\u00d9\u0003\u00d9\u1461\b\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9"+ + "\u0005\u00d9\u1466\b\u00d9\n\u00d9\f\u00d9\u1469\t\u00d9\u0003\u00d9\u146b"+ + "\b\u00d9\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001"+ + "\u00da\u0001\u00da\u0001\u00da\u0005\u00da\u1475\b\u00da\n\u00da\f\u00da"+ + "\u1478\t\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0003\u00da\u147d\b"+ + "\u00da\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0005"+ + "\u00db\u1484\b\u00db\n\u00db\f\u00db\u1487\t\u00db\u0001\u00dc\u0001\u00dc"+ + "\u0001\u00dc\u0001\u00dc\u0005\u00dc\u148d\b\u00dc\n\u00dc\f\u00dc\u1490"+ + "\t\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u1494\b\u00dc\u0001\u00dc"+ + "\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0005\u00dc\u149b\b\u00dc"+ + "\n\u00dc\f\u00dc\u149e\t\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0003"+ + "\u00dc\u14a3\b\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ + "\u00dc\u0001\u00dc\u0001\u00dc\u0005\u00dc\u14ac\b\u00dc\n\u00dc\f\u00dc"+ + "\u14af\t\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u14b4\b"+ + "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u14b9\b\u00dc\u0005"+ + "\u00dc\u14bb\b\u00dc\n\u00dc\f\u00dc\u14be\t\u00dc\u0001\u00dc\u0001\u00dc"+ + "\u0001\u00dc\u0003\u00dc\u14c3\b\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc"+ + "\u0003\u00dc\u14c8\b\u00dc\u0005\u00dc\u14ca\b\u00dc\n\u00dc\f\u00dc\u14cd"+ + "\t\u00dc\u0003\u00dc\u14cf\b\u00dc\u0001\u00dd\u0001\u00dd\u0001\u00dd"+ + "\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0005\u00dd"+ + "\u14d9\b\u00dd\n\u00dd\f\u00dd\u14dc\t\u00dd\u0001\u00de\u0001\u00de\u0001"+ + "\u00de\u0001\u00de\u0003\u00de\u14e2\b\u00de\u0001\u00de\u0001\u00de\u0001"+ + "\u00de\u0003\u00de\u14e7\b\u00de\u0001\u00df\u0001\u00df\u0001\u00df\u0001"+ + "\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001"+ + "\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001"+ + "\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001"+ + "\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001"+ + "\u00e0\u0003\u00e0\u1505\b\u00e0\u0001\u00e1\u0001\u00e1\u0003\u00e1\u1509"+ + "\b\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0003\u00e1\u150e\b\u00e1"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2"+ + "\u1515\b\u00e2\u0001\u00e2\u0003\u00e2\u1518\b\u00e2\u0001\u00e2\u0001"+ + "\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u151e\b\u00e2\u0001\u00e3\u0001"+ + "\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001"+ + "\u00e3\u0003\u00e3\u1528\b\u00e3\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001"+ + "\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0003\u00e4\u1532"+ + "\b\u00e4\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0003\u00e5\u153c\b\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0003\u00e5\u1542\b\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0003"+ + "\u00e5\u154b\b\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0003"+ + "\u00e5\u1551\b\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0003\u00e5\u1558\b\u00e5\u0003\u00e5\u155a\b\u00e5\u0001\u00e6"+ + "\u0001\u00e6\u0001\u00e6\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7"+ + "\u0001\u00e7\u0003\u00e7\u1564\b\u00e7\u0001\u00e8\u0001\u00e8\u0003\u00e8"+ + "\u1568\b\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8\u156c\b\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0003\u00e8\u1576\b\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0003\u00e8\u157b\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0003\u00e8\u15c3\b\u00e8\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001"+ + "\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001"+ + "\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001"+ + "\u00e9\u0003\u00e9\u15d5\b\u00e9\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001"+ + "\u00ea\u0001\u00eb\u0001\u00eb\u0003\u00eb\u15dd\b\u00eb\u0001\u00eb\u0001"+ + "\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001"+ + "\u00eb\u0005\u00eb\u15e7\b\u00eb\n\u00eb\f\u00eb\u15ea\t\u00eb\u0001\u00eb"+ + "\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0003\u00eb\u15f0\b\u00eb\u0003\u00eb"+ + "\u15f2\b\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb"+ + "\u0001\u00eb\u0005\u00eb\u15fa\b\u00eb\n\u00eb\f\u00eb\u15fd\t\u00eb\u0003"+ + "\u00eb\u15ff\b\u00eb\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0005"+ + "\u00ec\u1605\b\u00ec\n\u00ec\f\u00ec\u1608\t\u00ec\u0001\u00ed\u0001\u00ed"+ + "\u0001\u00ed\u0001\u00ed\u0003\u00ed\u160e\b\u00ed\u0001\u00ee\u0001\u00ee"+ + "\u0003\u00ee\u1612\b\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ef"+ + "\u0001\u00ef\u0003\u00ef\u1619\b\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef"+ + "\u0003\u00ef\u161e\b\u00ef\u0001\u00ef\u0003\u00ef\u1621\b\u00ef\u0001"+ + "\u00ef\u0003\u00ef\u1624\b\u00ef\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001"+ + "\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0003\u00f0\u162d\b\u00f0\u0001"+ + "\u00f1\u0001\u00f1\u0003\u00f1\u1631\b\u00f1\u0001\u00f1\u0001\u00f1\u0003"+ + "\u00f1\u1635\b\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001"+ + "\u00f1\u0001\u00f1\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001"+ + "\u00f2\u0001\u00f2\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001"+ + "\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0003\u00f4\u164c"+ + "\b\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0003"+ + "\u00f4\u1653\b\u00f4\u0005\u00f4\u1655\b\u00f4\n\u00f4\f\u00f4\u1658\t"+ + "\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0003\u00f4\u165e"+ + "\b\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0003"+ + "\u00f4\u1665\b\u00f4\u0001\u00f4\u0003\u00f4\u1668\b\u00f4\u0001\u00f4"+ + "\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4"+ + "\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0005\u00f4"+ + "\u1676\b\u00f4\n\u00f4\f\u00f4\u1679\t\u00f4\u0003\u00f4\u167b\b\u00f4"+ + "\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0001\u00f5\u0001\u00f5\u0003\u00f5\u1685\b\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0003\u00f5\u1689\b\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0003\u00f5\u168f\b\u00f5\u0001\u00f5\u0003\u00f5\u1692\b\u00f5\u0001"+ + "\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u1697\b\u00f5\u0001\u00f5\u0001"+ + "\u00f5\u0003\u00f5\u169b\b\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001"+ + "\u00f5\u0001\u00f5\u0003\u00f5\u16a2\b\u00f5\u0001\u00f5\u0003\u00f5\u16a5"+ + "\b\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u16ab"+ + "\b\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001"+ + "\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001"+ + "\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001"+ + "\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u16c3"+ + "\b\u00f5\u0001\u00f5\u0003\u00f5\u16c6\b\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0001\u00f5\u0001\u00f5\u0003\u00f5\u16d2\b\u00f5\u0001\u00f5\u0003\u00f5"+ + "\u16d5\b\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u16df\b\u00f5\u0001\u00f5"+ + "\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5"+ + "\u16e7\b\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u16eb\b\u00f5\u0001"+ + "\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u16f2"+ + "\b\u00f5\u0001\u00f5\u0003\u00f5\u16f5\b\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0005\u00f5\u16fc\b\u00f5\n\u00f5"+ + "\f\u00f5\u16ff\t\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5"+ + "\u1704\b\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5"+ + "\u170a\b\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u1714\b\u00f5\u0003\u00f5"+ + "\u1716\b\u00f5\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0003\u00f6"+ + "\u171c\b\u00f6\u0001\u00f6\u0003\u00f6\u171f\b\u00f6\u0001\u00f6\u0003"+ + "\u00f6\u1722\b\u00f6\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001"+ + "\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0003"+ + "\u00f7\u172e\b\u00f7\u0001\u00f7\u0003\u00f7\u1731\b\u00f7\u0001\u00f8"+ + "\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0003\u00f8\u1737\b\u00f8\u0001\u00f9"+ + "\u0003\u00f9\u173a\b\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9"+ + "\u0001\u00f9\u0001\u00f9\u0003\u00f9\u1742\b\u00f9\u0001\u00f9\u0001\u00f9"+ + "\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0003\u00f9\u174a\b\u00f9"+ + "\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0003\u00fa\u1750\b\u00fa"+ + "\u0001\u00fa\u0001\u00fa\u0003\u00fa\u1754\b\u00fa\u0001\u00fb\u0001\u00fb"+ + "\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb"+ + "\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0003\u00fb\u1762\b\u00fb"+ + "\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fd\u0001\u00fd\u0001\u00fd"+ + "\u0001\u00fd\u0001\u00fd\u0005\u00fd\u176c\b\u00fd\n\u00fd\f\u00fd\u176f"+ + "\t\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0003\u00fd\u1775"+ + "\b\u00fd\u0001\u00fd\u0003\u00fd\u1778\b\u00fd\u0001\u00fd\u0001\u00fd"+ + "\u0001\u00fd\u0001\u00fe\u0001\u00fe\u0003\u00fe\u177f\b\u00fe\u0001\u00fe"+ + "\u0001\u00fe\u0001\u00fe\u0005\u00fe\u1784\b\u00fe\n\u00fe\f\u00fe\u1787"+ + "\t\u00fe\u0001\u00ff\u0001\u00ff\u0003\u00ff\u178b\b\u00ff\u0001\u00ff"+ + "\u0001\u00ff\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0005\u0100\u1796\b\u0100\n\u0100\f\u0100\u1799"+ + "\t\u0100\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0102\u0001"+ + "\u0102\u0001\u0103\u0001\u0103\u0003\u0103\u17a3\b\u0103\u0001\u0103\u0001"+ + "\u0103\u0001\u0103\u0001\u0103\u0003\u0103\u17a9\b\u0103\u0001\u0104\u0001"+ + "\u0104\u0001\u0104\u0003\u0104\u17ae\b\u0104\u0001\u0104\u0001\u0104\u0001"+ + "\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0001"+ + "\u0104\u0001\u0104\u0001\u0104\u0003\u0104\u17bb\b\u0104\u0003\u0104\u17bd"+ + "\b\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0003\u0104\u17c2\b\u0104"+ + "\u0001\u0104\u0001\u0104\u0003\u0104\u17c6\b\u0104\u0001\u0104\u0003\u0104"+ + "\u17c9\b\u0104\u0003\u0104\u17cb\b\u0104\u0001\u0105\u0001\u0105\u0001"+ + "\u0105\u0001\u0105\u0001\u0105\u0003\u0105\u17d2\b\u0105\u0001\u0106\u0001"+ + "\u0106\u0001\u0106\u0001\u0106\u0001\u0106\u0003\u0106\u17d9\b\u0106\u0001"+ + "\u0106\u0003\u0106\u17dc\b\u0106\u0001\u0106\u0003\u0106\u17df\b\u0106"+ + "\u0001\u0106\u0001\u0106\u0001\u0106\u0001\u0106\u0003\u0106\u17e5\b\u0106"+ + "\u0001\u0106\u0001\u0106\u0003\u0106\u17e9\b\u0106\u0001\u0107\u0001\u0107"+ + "\u0001\u0107\u0001\u0107\u0003\u0107\u17ef\b\u0107\u0001\u0108\u0001\u0108"+ + "\u0001\u0108\u0001\u0108\u0003\u0108\u17f5\b\u0108\u0001\u0108\u0001\u0108"+ + "\u0001\u0109\u0001\u0109\u0001\u0109\u0001\u010a\u0001\u010a\u0001\u010a"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0003\u010b\u1802\b\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0003\u010b\u1807\b\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0005\u010b\u180d\b\u010b\n\u010b\f\u010b\u1810"+ + "\t\u010b\u0003\u010b\u1812\b\u010b\u0001\u010c\u0001\u010c\u0001\u010c"+ + "\u0003\u010c\u1817\b\u010c\u0001\u010c\u0001\u010c\u0001\u010c\u0003\u010c"+ + "\u181c\b\u010c\u0001\u010c\u0001\u010c\u0001\u010c\u0001\u010c\u0005\u010c"+ + "\u1822\b\u010c\n\u010c\f\u010c\u1825\t\u010c\u0003\u010c\u1827\b\u010c"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0003\u010d\u182f\b\u010d\u0001\u010e\u0001\u010e\u0003\u010e\u1833\b"+ + "\u010e\u0001\u010e\u0001\u010e\u0001\u010e\u0005\u010e\u1838\b\u010e\n"+ + "\u010e\f\u010e\u183b\t\u010e\u0001\u010f\u0001\u010f\u0001\u010f\u0003"+ + "\u010f\u1840\b\u010f\u0001\u010f\u0003\u010f\u1843\b\u010f\u0001\u0110"+ + "\u0001\u0110\u0003\u0110\u1847\b\u0110\u0001\u0110\u0001\u0110\u0001\u0110"+ + "\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110"+ + "\u0005\u0110\u1852\b\u0110\n\u0110\f\u0110\u1855\t\u0110\u0001\u0110\u0001"+ + "\u0110\u0001\u0110\u0003\u0110\u185a\b\u0110\u0001\u0110\u0001\u0110\u0001"+ + "\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0005"+ + "\u0110\u1864\b\u0110\n\u0110\f\u0110\u1867\t\u0110\u0003\u0110\u1869\b"+ + "\u0110\u0001\u0111\u0001\u0111\u0001\u0112\u0001\u0112\u0001\u0112\u0001"+ + "\u0112\u0001\u0112\u0003\u0112\u1872\b\u0112\u0001\u0112\u0001\u0112\u0001"+ + "\u0112\u0003\u0112\u1877\b\u0112\u0001\u0113\u0001\u0113\u0001\u0113\u0001"+ + "\u0113\u0003\u0113\u187d\b\u0113\u0001\u0114\u0001\u0114\u0001\u0115\u0001"+ + "\u0115\u0003\u0115\u1883\b\u0115\u0001\u0116\u0001\u0116\u0001\u0116\u0003"+ + "\u0116\u1888\b\u0116\u0003\u0116\u188a\b\u0116\u0001\u0116\u0003\u0116"+ + "\u188d\b\u0116\u0001\u0116\u0001\u0116\u0003\u0116\u1891\b\u0116\u0003"+ + "\u0116\u1893\b\u0116\u0001\u0117\u0001\u0117\u0003\u0117\u1897\b\u0117"+ + "\u0001\u0117\u0001\u0117\u0001\u0117\u0001\u0117\u0003\u0117\u189d\b\u0117"+ + "\u0001\u0117\u0003\u0117\u18a0\b\u0117\u0001\u0117\u0003\u0117\u18a3\b"+ + "\u0117\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0003\u0118\u18a9"+ + "\b\u0118\u0001\u0119\u0001\u0119\u0001\u011a\u0001\u011a\u0001\u011a\u0001"+ + "\u011a\u0001\u011a\u0003\u011a\u18b2\b\u011a\u0001\u011b\u0001\u011b\u0001"+ + "\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0003\u011c\u18ba\b\u011c\u0001"+ + "\u011d\u0001\u011d\u0003\u011d\u18be\b\u011d\u0001\u011e\u0001\u011e\u0001"+ + "\u011e\u0003\u011e\u18c3\b\u011e\u0001\u011f\u0001\u011f\u0001\u0120\u0001"+ + "\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001"+ + "\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001"+ + "\u0120\u0004\u0120\u18d5\b\u0120\u000b\u0120\f\u0120\u18d6\u0001\u0121"+ + "\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0003\u0121\u18de\b\u0121"+ + "\u0003\u0121\u18e0\b\u0121\u0001\u0122\u0001\u0122\u0001\u0122\u0004\u0122"+ + "\u18e5\b\u0122\u000b\u0122\f\u0122\u18e6\u0003\u0122\u18e9\b\u0122\u0001"+ + "\u0123\u0001\u0123\u0003\u0123\u18ed\b\u0123\u0001\u0124\u0001\u0124\u0001"+ + "\u0124\u0003\u0124\u18f2\b\u0124\u0001\u0125\u0001\u0125\u0001\u0125\u0001"+ + "\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0003"+ + "\u0125\u18fd\b\u0125\u0001\u0126\u0001\u0126\u0001\u0126\u0003\u0126\u1902"+ + "\b\u0126\u0001\u0127\u0001\u0127\u0001\u0128\u0001\u0128\u0003\u0128\u1908"+ + "\b\u0128\u0001\u0129\u0003\u0129\u190b\b\u0129\u0001\u0129\u0001\u0129"+ + "\u0003\u0129\u190f\b\u0129\u0001\u0129\u0004\u0129\u1912\b\u0129\u000b"+ + "\u0129\f\u0129\u1913\u0001\u0129\u0003\u0129\u1917\b\u0129\u0001\u0129"+ + "\u0001\u0129\u0003\u0129\u191b\b\u0129\u0001\u0129\u0001\u0129\u0003\u0129"+ + "\u191f\b\u0129\u0003\u0129\u1921\b\u0129\u0001\u012a\u0001\u012a\u0001"+ + "\u012b\u0003\u012b\u1926\b\u012b\u0001\u012b\u0001\u012b\u0001\u012c\u0003"+ + "\u012c\u192b\b\u012c\u0001\u012c\u0001\u012c\u0001\u012d\u0001\u012d\u0001"+ + "\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001"+ + "\u012d\u0003\u012d\u1938\b\u012d\u0001\u012d\u0003\u012d\u193b\b\u012d"+ + "\u0001\u012e\u0001\u012e\u0003\u012e\u193f\b\u012e\u0001\u012e\u0003\u012e"+ + "\u1942\b\u012e\u0001\u012e\u0003\u012e\u1945\b\u012e\u0001\u012e\u0001"+ + "\u012e\u0001\u012e\u0003\u012e\u194a\b\u012e\u0001\u012e\u0001\u012e\u0001"+ + "\u012e\u0003\u012e\u194f\b\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001"+ + "\u012e\u0003\u012e\u1955\b\u012e\u0001\u012e\u0003\u012e\u1958\b\u012e"+ + "\u0001\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u195d\b\u012e\u0001\u012e"+ + "\u0003\u012e\u1960\b\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0003\u012e"+ + "\u1965\b\u012e\u0001\u012e\u0003\u012e\u1968\b\u012e\u0001\u012e\u0001"+ + "\u012e\u0003\u012e\u196c\b\u012e\u0001\u012e\u0005\u012e\u196f\b\u012e"+ + "\n\u012e\f\u012e\u1972\t\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u1976"+ + "\b\u012e\u0001\u012e\u0005\u012e\u1979\b\u012e\n\u012e\f\u012e\u197c\t"+ + "\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u1980\b\u012e\u0001\u012e\u0003"+ + "\u012e\u1983\b\u012e\u0001\u012e\u0005\u012e\u1986\b\u012e\n\u012e\f\u012e"+ + "\u1989\t\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u198d\b\u012e\u0001"+ + "\u012e\u0005\u012e\u1990\b\u012e\n\u012e\f\u012e\u1993\t\u012e\u0001\u012e"+ + "\u0001\u012e\u0001\u012e\u0003\u012e\u1998\b\u012e\u0001\u012e\u0001\u012e"+ + "\u0001\u012e\u0003\u012e\u199d\b\u012e\u0001\u012e\u0001\u012e\u0001\u012e"+ + "\u0003\u012e\u19a2\b\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0003\u012e"+ + "\u19a7\b\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u19ab\b\u012e\u0001"+ + "\u012e\u0003\u012e\u19ae\b\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0003"+ + "\u012e\u19b3\b\u012e\u0001\u012e\u0001\u012e\u0003\u012e\u19b7\b\u012e"+ + "\u0001\u012e\u0001\u012e\u0003\u012e\u19bb\b\u012e\u0001\u012f\u0001\u012f"+ + "\u0001\u012f\u0001\u012f\u0005\u012f\u19c1\b\u012f\n\u012f\f\u012f\u19c4"+ + "\t\u012f\u0001\u012f\u0001\u012f\u0001\u0130\u0001\u0130\u0003\u0130\u19ca"+ + "\b\u0130\u0001\u0130\u0001\u0130\u0003\u0130\u19ce\b\u0130\u0001\u0130"+ + "\u0001\u0130\u0001\u0130\u0003\u0130\u19d3\b\u0130\u0001\u0130\u0001\u0130"+ + "\u0001\u0130\u0003\u0130\u19d8\b\u0130\u0001\u0130\u0001\u0130\u0003\u0130"+ + "\u19dc\b\u0130\u0003\u0130\u19de\b\u0130\u0001\u0130\u0003\u0130\u19e1"+ + "\b\u0130\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0132\u0001"+ + "\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0133\u0001"+ + "\u0133\u0001\u0133\u0001\u0133\u0003\u0133\u19f1\b\u0133\u0001\u0133\u0001"+ + "\u0133\u0001\u0134\u0001\u0134\u0001\u0134\u0005\u0134\u19f8\b\u0134\n"+ + "\u0134\f\u0134\u19fb\t\u0134\u0001\u0135\u0001\u0135\u0001\u0135\u0005"+ + "\u0135\u1a00\b\u0135\n\u0135\f\u0135\u1a03\t\u0135\u0001\u0136\u0001\u0136"+ + "\u0001\u0136\u0005\u0136\u1a08\b\u0136\n\u0136\f\u0136\u1a0b\t\u0136\u0001"+ + "\u0137\u0001\u0137\u0001\u0137\u0001\u0137\u0005\u0137\u1a11\b\u0137\n"+ + "\u0137\f\u0137\u1a14\t\u0137\u0001\u0137\u0001\u0137\u0001\u0138\u0001"+ + "\u0138\u0001\u0138\u0005\u0138\u1a1b\b\u0138\n\u0138\f\u0138\u1a1e\t\u0138"+ + "\u0001\u0139\u0001\u0139\u0001\u0139\u0005\u0139\u1a23\b\u0139\n\u0139"+ + "\f\u0139\u1a26\t\u0139\u0001\u013a\u0001\u013a\u0001\u013a\u0005\u013a"+ + "\u1a2b\b\u013a\n\u013a\f\u013a\u1a2e\t\u013a\u0001\u013b\u0001\u013b\u0001"+ + "\u013b\u0005\u013b\u1a33\b\u013b\n\u013b\f\u013b\u1a36\t\u013b\u0001\u013c"+ + "\u0001\u013c\u0001\u013c\u0005\u013c\u1a3b\b\u013c\n\u013c\f\u013c\u1a3e"+ + "\t\u013c\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001"+ + "\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0003\u013d\u1a49\b\u013d\u0001"+ + "\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0003\u013d\u1a50"+ + "\b\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001"+ + "\u013d\u0001\u013d\u0001\u013d\u0003\u013d\u1a5a\b\u013d\u0001\u013e\u0001"+ + "\u013e\u0001\u013e\u0003\u013e\u1a5f\b\u013e\u0001\u013e\u0003\u013e\u1a62"+ + "\b\u013e\u0001\u013e\u0001\u013e\u0001\u013e\u0003\u013e\u1a67\b\u013e"+ + "\u0001\u013e\u0003\u013e\u1a6a\b\u013e\u0001\u013f\u0001\u013f\u0003\u013f"+ + "\u1a6e\b\u013f\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0141\u0001\u0141"+ + "\u0001\u0141\u0001\u0141\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0143"+ + "\u0001\u0143\u0001\u0143\u0003\u0143\u1a7d\b\u0143\u0001\u0144\u0001\u0144"+ + "\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0003\u0144\u1a85\b\u0144"+ + "\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0003\u0144"+ + "\u1a8c\b\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0003\u0144\u1a91\b"+ + "\u0144\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1a96\b\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0004"+ + "\u0145\u1ab6\b\u0145\u000b\u0145\f\u0145\u1ab7\u0001\u0145\u0001\u0145"+ + "\u0003\u0145\u1abc\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145"+ + "\u0004\u0145\u1ac2\b\u0145\u000b\u0145\f\u0145\u1ac3\u0001\u0145\u0001"+ + "\u0145\u0003\u0145\u1ac8\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1ad1\b\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003"+ + "\u0145\u1ad9\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1ade"+ + "\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0003\u0145\u1ae6\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003"+ + "\u0145\u1aeb\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1af0"+ + "\b\u0145\u0003\u0145\u1af2\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145"+ + "\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1afb\b\u0145"+ + "\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1b00\b\u0145\u0001\u0145"+ + "\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145"+ + "\u1b08\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1b0d\b"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0003\u0145\u1b15\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1b1d\b\u0145\u0001\u0145\u0003"+ + "\u0145\u1b20\b\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1b2a\b\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0003\u0145\u1b3c\b\u0145\u0001"+ + "\u0145\u0003\u0145\u1b3f\b\u0145\u0001\u0145\u0003\u0145\u1b42\b\u0145"+ + "\u0001\u0145\u0001\u0145\u0003\u0145\u1b46\b\u0145\u0001\u0146\u0001\u0146"+ + "\u0001\u0146\u0001\u0146\u0001\u0146\u0001\u0147\u0001\u0147\u0001\u0147"+ + "\u0001\u0147\u0005\u0147\u1b51\b\u0147\n\u0147\f\u0147\u1b54\t\u0147\u0001"+ + "\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0003\u0147\u1b5b"+ + "\b\u0147\u0001\u0148\u0001\u0148\u0003\u0148\u1b5f\b\u0148\u0001\u0149"+ + "\u0001\u0149\u0001\u0149\u0003\u0149\u1b64\b\u0149\u0001\u0149\u0001\u0149"+ + "\u0001\u0149\u0003\u0149\u1b69\b\u0149\u0001\u0149\u0001\u0149\u0001\u0149"+ + "\u0001\u0149\u0003\u0149\u1b6f\b\u0149\u0001\u0149\u0001\u0149\u0001\u0149"+ + "\u0003\u0149\u1b74\b\u0149\u0001\u0149\u0001\u0149\u0003\u0149\u1b78\b"+ + "\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0003\u0149\u1b7d\b\u0149\u0001"+ + "\u0149\u0001\u0149\u0001\u0149\u0003\u0149\u1b82\b\u0149\u0001\u0149\u0001"+ + "\u0149\u0001\u0149\u0003\u0149\u1b87\b\u0149\u0001\u0149\u0001\u0149\u0001"+ + "\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0005\u0149\u1b8f\b\u0149\n"+ + "\u0149\f\u0149\u1b92\t\u0149\u0003\u0149\u1b94\b\u0149\u0001\u0149\u0001"+ + "\u0149\u0003\u0149\u1b98\b\u0149\u0001\u0149\u0001\u0149\u0003\u0149\u1b9c"+ + "\b\u0149\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0003"+ + "\u014a\u1ba3\b\u014a\u0001\u014a\u0001\u014a\u0003\u014a\u1ba7\b\u014a"+ + "\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a"+ + "\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a"+ + "\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a"+ + "\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a"+ + "\u0001\u014a\u0001\u014a\u0001\u014a\u0003\u014a\u1bc4\b\u014a\u0001\u014b"+ + "\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0003\u014b"+ + "\u1bcc\b\u014b\u0001\u014c\u0003\u014c\u1bcf\b\u014c\u0001\u014c\u0003"+ + "\u014c\u1bd2\b\u014c\u0001\u014c\u0003\u014c\u1bd5\b\u014c\u0001\u014c"+ + "\u0003\u014c\u1bd8\b\u014c\u0001\u014d\u0001\u014d\u0001\u014e\u0001\u014e"+ + "\u0001\u014e\u0001\u014f\u0001\u014f\u0001\u0150\u0001\u0150\u0003\u0150"+ + "\u1be3\b\u0150\u0001\u0151\u0001\u0151\u0001\u0151\u0001\u0151\u0001\u0151"+ + "\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152"+ + "\u0001\u0152\u0003\u0152\u1bf1\b\u0152\u0001\u0153\u0001\u0153\u0001\u0153"+ + "\u0001\u0153\u0001\u0153\u0005\u0153\u1bf8\b\u0153\n\u0153\f\u0153\u1bfb"+ + "\t\u0153\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001"+ + "\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001"+ + "\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001"+ + "\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001"+ + "\u0154\u0003\u0154\u1c15\b\u0154\u0001\u0155\u0001\u0155\u0001\u0155\u0001"+ + "\u0155\u0001\u0155\u0001\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0003"+ + "\u0156\u1c20\b\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0001\u0156\u0001"+ + "\u0156\u0003\u0156\u1c27\b\u0156\u0005\u0156\u1c29\b\u0156\n\u0156\f\u0156"+ + "\u1c2c\t\u0156\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0003\u0157"+ + "\u1c32\b\u0157\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158"+ + "\u0001\u0158\u0003\u0158\u1c3a\b\u0158\u0001\u0158\u0001\u0158\u0001\u0158"+ + "\u0003\u0158\u1c3f\b\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158"+ + "\u0005\u0158\u1c45\b\u0158\n\u0158\f\u0158\u1c48\t\u0158\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0003\u0159\u1c53\b\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0003\u0159\u1c60\b\u0159\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0003\u0159\u1c66\b\u0159\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0003\u0159\u1c6c\b\u0159\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u0159\u0003\u0159\u1c7c\b\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u0159\u0003\u0159\u1c82\b\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0005\u0159\u1c8b\b\u0159\n"+ + "\u0159\f\u0159\u1c8e\t\u0159\u0001\u015a\u0001\u015a\u0001\u015a\u0001"+ + "\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001"+ + "\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001"+ + "\u015a\u0001\u015a\u0001\u015a\u0005\u015a\u1ca2\b\u015a\n\u015a\f\u015a"+ + "\u1ca5\t\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a"+ + "\u0001\u015a\u0001\u015a\u0004\u015a\u1cae\b\u015a\u000b\u015a\f\u015a"+ + "\u1caf\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001"+ + "\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001"+ + "\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0003\u015a\u1cc1\b\u015a\u0001"+ + "\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001"+ + "\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001"+ + "\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001"+ + "\u015a\u0005\u015a\u1cd6\b\u015a\n\u015a\f\u015a\u1cd9\t\u015a\u0001\u015b"+ + "\u0001\u015b\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c"+ + "\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c"+ + "\u0001\u015c\u0001\u015c\u0001\u015c\u0003\u015c\u1ceb\b\u015c\u0001\u015d"+ + "\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015d"+ + "\u0003\u015d\u1cf4\b\u015d\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e"+ + "\u0001\u015e\u0001\u015e\u0001\u015e\u0003\u015e\u1cfd\b\u015e\u0001\u015f"+ + "\u0001\u015f\u0001\u0160\u0001\u0160\u0001\u0161\u0001\u0161\u0001\u0161"+ + "\u0001\u0161\u0001\u0161\u0003\u0161\u1d08\b\u0161\u0001\u0162\u0001\u0162"+ + "\u0001\u0163\u0001\u0163\u0001\u0164\u0001\u0164\u0001\u0165\u0001\u0165"+ + "\u0001\u0166\u0001\u0166\u0001\u0167\u0001\u0167\u0001\u0168\u0001\u0168"+ + "\u0001\u0168\u0000\u0003\u02b0\u02b2\u02b4\u0169\u0000\u0002\u0004\u0006"+ + "\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,."+ + "02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088"+ + "\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0"+ + "\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8"+ + "\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0"+ + "\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8"+ + "\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100"+ + "\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118"+ + "\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130"+ + "\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148"+ + "\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160"+ + "\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178"+ + "\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190"+ + "\u0192\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8"+ + "\u01aa\u01ac\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0"+ + "\u01c2\u01c4\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8"+ + "\u01da\u01dc\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f0"+ + "\u01f2\u01f4\u01f6\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208"+ + "\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220"+ + "\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u0234\u0236\u0238"+ + "\u023a\u023c\u023e\u0240\u0242\u0244\u0246\u0248\u024a\u024c\u024e\u0250"+ + "\u0252\u0254\u0256\u0258\u025a\u025c\u025e\u0260\u0262\u0264\u0266\u0268"+ + "\u026a\u026c\u026e\u0270\u0272\u0274\u0276\u0278\u027a\u027c\u027e\u0280"+ + "\u0282\u0284\u0286\u0288\u028a\u028c\u028e\u0290\u0292\u0294\u0296\u0298"+ + "\u029a\u029c\u029e\u02a0\u02a2\u02a4\u02a6\u02a8\u02aa\u02ac\u02ae\u02b0"+ + "\u02b2\u02b4\u02b6\u02b8\u02ba\u02bc\u02be\u02c0\u02c2\u02c4\u02c6\u02c8"+ + "\u02ca\u02cc\u02ce\u02d0\u0000\u0090\u0002\u0000((\u0097\u0097\u0002\u0000"+ + "\u0214\u0214\u021a\u021a\u0003\u0000FF\u00a0\u00a0\u00b6\u00b6\u0003\u0000"+ + "++\u0181\u0181\u01c7\u01c7\u0004\u0000++\u01a4\u01a4\u0212\u0212\u0264"+ + "\u0264\u0002\u0000\u0203\u0203\u047d\u047d\u0002\u0000OO\u008e\u008e\u0002"+ + "\u0000\u0010\u0010\u014f\u014f\u0003\u0000--VV\u00b9\u00b9\u0002\u0000"+ + "\u01b3\u01b3\u022f\u022f\u0003\u0000\u01fb\u01fb\u028b\u028b\u0293\u0293"+ + "\u0002\u0000\u0189\u0189\u01cd\u01cd\u0002\u0000\u0161\u0161\u01db\u01db"+ + "\u0002\u0000++\u0473\u0474\u0002\u0000\u015f\u015f\u01bc\u01bc\u0002\u0000"+ + "\u01cc\u01cc\u02a2\u02a2\u0003\u0000QQUU~~\u0003\u0000++\u0193\u0193\u01b0"+ + "\u01b0\u0003\u0000++\u018f\u018f\u0319\u0319\u0002\u0000\u027e\u027e\u02a1"+ + "\u02a1\u0002\u0000RR\\\\\u0003\u0000\u01b5\u01b5\u0225\u0225\u0266\u0266"+ + "\u0002\u0000FF\u00a0\u00a0\u0001\u0000\u0165\u0166\u0001\u0000\u0473\u0474"+ + "\u0002\u0000\u047d\u047d\u0485\u0485\u0002\u0000RR\u0185\u0185\u0002\u0000"+ + "\u0222\u0222\u047d\u047d\u0002\u0000\u0223\u0223\u047d\u047d\u0003\u0000"+ + "\u01af\u01af\u01d6\u01d6\u020a\u020a\u0007\u0000++\u0173\u0173\u0175\u0175"+ + "\u0193\u0193\u01b0\u01b0\u023e\u023e\u0485\u0485\u0002\u0000\u0203\u0203"+ + "\u0213\u0213\u0001\u0000\u0474\u0475\u0002\u0000\u0006\u000644\u0004\u0000"+ + "++\u0181\u0181\u01c7\u01c7\u01cb\u01cb\u0002\u0000\u001b\u001b\u001f\u001f"+ + "\u0002\u0000\r\r\u00b0\u00b0\u0002\u0000\u00c1\u00c1\u02a6\u02a6\u0002"+ + "\u0000\u0016\u0016\u0091\u0091\u0003\u0000,,LLkk\u0002\u0000kk\u0177\u0177"+ + "\u0002\u0000\u016e\u016e\u01ac\u01ac\u0002\u0000ff\u025a\u025a\u0002\u0000"+ + ",,kk\u0002\u0000\u0007\u000722\u0002\u0000\u00bd\u00bd\u029e\u029e\u0004"+ + "\u0000\u01af\u01af\u01d6\u01d6\u0209\u0209\u0233\u0233\u0002\u0000\u01af"+ + "\u01af\u0209\u0209\u0002\u0000\u000e\u000e..\u0003\u0000CCOO\u00bb\u00bb"+ + "\u0002\u0000##TT\u0002\u0000bb\u0095\u0095\u0002\u0000\u0007\u000723\u0001"+ + "\u0000\u0273\u0274\u0002\u0000\u00ad\u00ad\u02e7\u02e7\u0002\u0000\u01b8"+ + "\u01b8\u0262\u0262\u0002\u0000\u00e3\u00e3\u01de\u01de\u0005\u0000ll\u01e3"+ + "\u01e4\u01e6\u01e6\u01ea\u01f2\u0240\u0240\u0004\u0000\u01e0\u01e1\u01e5"+ + "\u01e5\u01e7\u01e8\u0241\u0241\u0003\u0000mm\u01df\u01df\u01e9\u01e9\u0002"+ + "\u0000\u01cf\u01cf\u0275\u0275\u0002\u0000\u026f\u026f\u0271\u0271\u0002"+ + "\u0000\u0159\u0159\u0276\u0276\u0002\u0000[[\u0250\u0250\u0002\u00004"+ + "4\u0187\u0187\u0003\u0000 >>\u00b4\u00b4\u0003\u0000\u0084\u0084\u00ad"+ + "\u00ad\u01b6\u01b6\u0003\u0000\r\r\u0014\u0014\u00bc\u00bc\u0002\u0000"+ + "++zz\u0002\u0000hh\u00b7\u00b7\u0002\u0000\u0169\u0169\u0267\u0267\u0002"+ + "\u0000))\u02a0\u02a0\u0002\u0000tt\u01db\u01db\u0002\u0000\u01a7\u01a7"+ + "\u0239\u0239\u0004\u0000\u00cf\u00cf\u00d1\u00d1\u00d7\u00d7\u027f\u027f"+ + "\u0002\u0000\u0455\u0455\u0465\u0465\u0002\u0000\u015a\u015a\u0242\u0242"+ + "\u0002\u0000EEQQ\u0006\u0000\u0084\u0084\u00ad\u00ad\u00b2\u00b2\u01a0"+ + "\u01a0\u01b6\u01b6\u02a0\u02a0\u0002\u0000\u0202\u0202\u027b\u027b\u0002"+ + "\u0000\u019d\u019d\u02a4\u02a4\u0002\u0000\u0084\u0084\u01b6\u01b6\u0003"+ + "\u0000RR]]\u01c5\u01c5\u0003\u0000\u01b8\u01b8\u01db\u01db\u0262\u0262"+ + "\u0002\u0000\u027b\u027b\u029f\u029f\u0002\u0000\u0179\u0179\u0238\u0238"+ + "\u0006\u0000\u00e3\u00e3\u019a\u019a\u019c\u019c\u01b7\u01b7\u023f\u023f"+ + "\u0268\u0268\u0002\u0000./??\u0003\u0000\u01a7\u01a7\u0227\u0227\u0376"+ + "\u0376\u0002\u0000\u01d3\u01d3\u028d\u028d\n\u0000\u0168\u0168\u0170\u0170"+ + "\u017b\u017d\u0184\u0184\u01fc\u01fc\u0204\u0204\u0280\u0280\u0287\u0287"+ + "\u0345\u0345\u03ee\u03ee\u0002\u0000$$\u00a9\u00a9\u0002\u0000vv\u03e5"+ + "\u03e5\u000b\u0000\u0168\u0168\u0170\u0170\u017b\u017d\u0184\u0184\u01fc"+ + "\u01fc\u0204\u0204\u0251\u0251\u0280\u0280\u0287\u0287\u0345\u0345\u03ee"+ + "\u03ee\u0002\u0000\u0472\u0472\u0487\u0488\u0001\u0000\u0488\u0489\u0002"+ + "\u0000\u0178\u0178\u0314\u031f\u0003\u0000\u0473\u0475\u047e\u047e\u0480"+ + "\u0480\u0002\u0000@@\u00b3\u00b3\u0002\u0000uu\u0481\u0481\u0005\u0000"+ + "\u001a\u001a\u00df\u00e1\u00e8\u00e8\u00ea\u00ed\u0207\u0207\u0002\u0000"+ + "\u001a\u001a\u00df\u00df\u0002\u0000\u001a\u001a\u00df\u00e0\u0001\u0000"+ + "\u00c5\u00d0\u0003\u0000\u00b8\u00b8\u00c4\u00c4\u0265\u0265\u0002\u0000"+ + "\u00d4\u00d9\u01b0\u01b0\u0006\u0000\u00da\u00da\u00e5\u00e5\u00e7\u00e7"+ + "\u00e9\u00e9\u00f0\u00f0\u015d\u015e\u0004\u0000\u00db\u00de\u00e3\u00e4"+ + "\u00e6\u00e6\u015b\u015b\u0002\u0000\u009a\u009a\u00ee\u00ee\u0002\u0000"+ + "\u01d3\u01d3\u0324\u032c\u0003\u0000\u00d4\u00d4\u00e3\u00e3\u0207\u0207"+ + "\u0006\u0000\u00c9\u00c9\u00cf\u00cf\u00d2\u00d2\u00da\u00db\u00dd\u00de"+ + "\u01d3\u01d3\u0001\u0000\u00d7\u00d8\u0002\u0000\u00b8\u00b8\u0265\u0265"+ + "\u0002\u0000\u00c9\u00c9\u00cf\u00cf\u0002\u0000\u013c\u013d\u0143\u0143"+ + "\u0003\u0000\u0097\u0097\u013a\u013d\u014c\u014c\u0001\u0000\u0146\u0147"+ + "\u0003\u0000\u0012\u0012``\u00b1\u00b1\u0002\u0000\u00df\u00df\u00e3\u00e3"+ + "\u0002\u0000\u00da\u00db\u00dd\u00dd\u0003\u0000\u000e\u000e..\u03e3\u03e3"+ + "\u0003\u0000\u011f\u011f\u012b\u012c\u0136\u0136\u0003\u0000\u0120\u0122"+ + "\u0132\u0135\u0137\u0139\u0002\u0000\u0128\u0128\u012a\u012a\u0002\u0000"+ + "\u0126\u0126\u0129\u0129\u0002\u0000\u0124\u0125\u012f\u0131\u0002\u0000"+ + "\u0086\u0086\u025a\u025a\u0002\u0000\u01b2\u01b2\u0230\u0230\u0002\u0000"+ + "\u0218\u0218\u0228\u0228\u0002\u0000ss\u0468\u0468\u0003\u0000@@\u00b3"+ + "\u00b3\u0297\u0297\u0002\u0000\u008a\u008a\u0096\u0096\u0003\u0000\u0007"+ + "\u0007\u0152\u0152\u026b\u026b\u0003\u0000ss\u0461\u0462\u0468\u0469\u0002"+ + "\u0000\u045e\u0460\u0463\u0464\u0001\u0000\u0461\u0462\u0002\u0000\u00e3"+ + "\u00e3\u02eb\u0313\u0001\u0000\u0320\u0323\u0005\u0000\u02c5\u02c6\u02d6"+ + "\u02d8\u02de\u02de\u02e4\u02e5\u02e7\u02e7\u0001\u0000\u02b2\u02b9\u0003"+ + "\u0000\u00da\u00de\u00eb\u00eb\u00ee\u00ee:\u0000\f\f\u000f\u000f\u0013"+ + "\u0013\u001e\u001e$$&&++1188::<\u0594\u0001\u0000\u0000\u0000"+ + "@\u0599\u0001\u0000\u0000\u0000B\u05c1\u0001\u0000\u0000\u0000D\u05c7"+ + "\u0001\u0000\u0000\u0000F\u05c9\u0001\u0000\u0000\u0000H\u05de\u0001\u0000"+ + "\u0000\u0000J\u05e5\u0001\u0000\u0000\u0000L\u05e7\u0001\u0000\u0000\u0000"+ + "N\u0600\u0001\u0000\u0000\u0000P\u0603\u0001\u0000\u0000\u0000R\u0608"+ + "\u0001\u0000\u0000\u0000T\u0622\u0001\u0000\u0000\u0000V\u0632\u0001\u0000"+ + "\u0000\u0000X\u0634\u0001\u0000\u0000\u0000Z\u064a\u0001\u0000\u0000\u0000"+ + "\\\u064c\u0001\u0000\u0000\u0000^\u068e\u0001\u0000\u0000\u0000`\u06d5"+ + "\u0001\u0000\u0000\u0000b\u06d7\u0001\u0000\u0000\u0000d\u06f3\u0001\u0000"+ + "\u0000\u0000f\u06fd\u0001\u0000\u0000\u0000h\u071b\u0001\u0000\u0000\u0000"+ + "j\u07d6\u0001\u0000\u0000\u0000l\u07d8\u0001\u0000\u0000\u0000n\u07da"+ + "\u0001\u0000\u0000\u0000p\u07dd\u0001\u0000\u0000\u0000r\u0828\u0001\u0000"+ + "\u0000\u0000t\u083f\u0001\u0000\u0000\u0000v\u08d3\u0001\u0000\u0000\u0000"+ + "x\u08d8\u0001\u0000\u0000\u0000z\u08da\u0001\u0000\u0000\u0000|\u08e4"+ + "\u0001\u0000\u0000\u0000~\u091c\u0001\u0000\u0000\u0000\u0080\u0930\u0001"+ + "\u0000\u0000\u0000\u0082\u0932\u0001\u0000\u0000\u0000\u0084\u0955\u0001"+ + "\u0000\u0000\u0000\u0086\u095e\u0001\u0000\u0000\u0000\u0088\u0965\u0001"+ + "\u0000\u0000\u0000\u008a\u097c\u0001\u0000\u0000\u0000\u008c\u0985\u0001"+ + "\u0000\u0000\u0000\u008e\u0994\u0001\u0000\u0000\u0000\u0090\u09ad\u0001"+ + "\u0000\u0000\u0000\u0092\u09c1\u0001\u0000\u0000\u0000\u0094\u0b40\u0001"+ + "\u0000\u0000\u0000\u0096\u0ba4\u0001\u0000\u0000\u0000\u0098\u0ba6\u0001"+ + "\u0000\u0000\u0000\u009a\u0bad\u0001\u0000\u0000\u0000\u009c\u0bb4\u0001"+ + "\u0000\u0000\u0000\u009e\u0bcb\u0001\u0000\u0000\u0000\u00a0\u0bd3\u0001"+ + "\u0000\u0000\u0000\u00a2\u0bda\u0001\u0000\u0000\u0000\u00a4\u0be1\u0001"+ + "\u0000\u0000\u0000\u00a6\u0be8\u0001\u0000\u0000\u0000\u00a8\u0bf4\u0001"+ + "\u0000\u0000\u0000\u00aa\u0bfe\u0001\u0000\u0000\u0000\u00ac\u0c05\u0001"+ + "\u0000\u0000\u0000\u00ae\u0c15\u0001\u0000\u0000\u0000\u00b0\u0c43\u0001"+ + "\u0000\u0000\u0000\u00b2\u0c45\u0001\u0000\u0000\u0000\u00b4\u0c4f\u0001"+ + "\u0000\u0000\u0000\u00b6\u0c53\u0001\u0000\u0000\u0000\u00b8\u0c59\u0001"+ + "\u0000\u0000\u0000\u00ba\u0c65\u0001\u0000\u0000\u0000\u00bc\u0c67\u0001"+ + "\u0000\u0000\u0000\u00be\u0c6e\u0001\u0000\u0000\u0000\u00c0\u0c70\u0001"+ + "\u0000\u0000\u0000\u00c2\u0caa\u0001\u0000\u0000\u0000\u00c4\u0cf4\u0001"+ + "\u0000\u0000\u0000\u00c6\u0d2f\u0001\u0000\u0000\u0000\u00c8\u0d91\u0001"+ + "\u0000\u0000\u0000\u00ca\u0d95\u0001\u0000\u0000\u0000\u00cc\u0d97\u0001"+ + "\u0000\u0000\u0000\u00ce\u0dba\u0001\u0000\u0000\u0000\u00d0\u0dbc\u0001"+ + "\u0000\u0000\u0000\u00d2\u0dc4\u0001\u0000\u0000\u0000\u00d4\u0dcc\u0001"+ + "\u0000\u0000\u0000\u00d6\u0dce\u0001\u0000\u0000\u0000\u00d8\u0df2\u0001"+ + "\u0000\u0000\u0000\u00da\u0e29\u0001\u0000\u0000\u0000\u00dc\u0e32\u0001"+ + "\u0000\u0000\u0000\u00de\u0e46\u0001\u0000\u0000\u0000\u00e0\u0e52\u0001"+ + "\u0000\u0000\u0000\u00e2\u0e56\u0001\u0000\u0000\u0000\u00e4\u0e77\u0001"+ + "\u0000\u0000\u0000\u00e6\u0e8c\u0001\u0000\u0000\u0000\u00e8\u0e96\u0001"+ + "\u0000\u0000\u0000\u00ea\u0e9a\u0001\u0000\u0000\u0000\u00ec\u0eb4\u0001"+ + "\u0000\u0000\u0000\u00ee\u0ede\u0001\u0000\u0000\u0000\u00f0\u0ee0\u0001"+ + "\u0000\u0000\u0000\u00f2\u0eef\u0001\u0000\u0000\u0000\u00f4\u0f20\u0001"+ + "\u0000\u0000\u0000\u00f6\u0f29\u0001\u0000\u0000\u0000\u00f8\u0f33\u0001"+ + "\u0000\u0000\u0000\u00fa\u0f3d\u0001\u0000\u0000\u0000\u00fc\u0f75\u0001"+ + "\u0000\u0000\u0000\u00fe\u0f77\u0001\u0000\u0000\u0000\u0100\u0f92\u0001"+ + "\u0000\u0000\u0000\u0102\u0f98\u0001\u0000\u0000\u0000\u0104\u0fa0\u0001"+ + "\u0000\u0000\u0000\u0106\u0fb1\u0001\u0000\u0000\u0000\u0108\u0fc1\u0001"+ + "\u0000\u0000\u0000\u010a\u0fe6\u0001\u0000\u0000\u0000\u010c\u0fec\u0001"+ + "\u0000\u0000\u0000\u010e\u0ff5\u0001\u0000\u0000\u0000\u0110\u1002\u0001"+ + "\u0000\u0000\u0000\u0112\u1006\u0001\u0000\u0000\u0000\u0114\u102c\u0001"+ + "\u0000\u0000\u0000\u0116\u1052\u0001\u0000\u0000\u0000\u0118\u1060\u0001"+ + "\u0000\u0000\u0000\u011a\u1068\u0001\u0000\u0000\u0000\u011c\u106c\u0001"+ + "\u0000\u0000\u0000\u011e\u1072\u0001\u0000\u0000\u0000\u0120\u1080\u0001"+ + "\u0000\u0000\u0000\u0122\u1083\u0001\u0000\u0000\u0000\u0124\u1095\u0001"+ + "\u0000\u0000\u0000\u0126\u1099\u0001\u0000\u0000\u0000\u0128\u10a9\u0001"+ + "\u0000\u0000\u0000\u012a\u10ab\u0001\u0000\u0000\u0000\u012c\u10b7\u0001"+ + "\u0000\u0000\u0000\u012e\u10bb\u0001\u0000\u0000\u0000\u0130\u10cc\u0001"+ + "\u0000\u0000\u0000\u0132\u10dd\u0001\u0000\u0000\u0000\u0134\u10e0\u0001"+ + "\u0000\u0000\u0000\u0136\u10ea\u0001\u0000\u0000\u0000\u0138\u10ee\u0001"+ + "\u0000\u0000\u0000\u013a\u10fb\u0001\u0000\u0000\u0000\u013c\u10fe\u0001"+ + "\u0000\u0000\u0000\u013e\u1103\u0001\u0000\u0000\u0000\u0140\u1117\u0001"+ + "\u0000\u0000\u0000\u0142\u1119\u0001\u0000\u0000\u0000\u0144\u112a\u0001"+ + "\u0000\u0000\u0000\u0146\u1133\u0001\u0000\u0000\u0000\u0148\u113c\u0001"+ + "\u0000\u0000\u0000\u014a\u113e\u0001\u0000\u0000\u0000\u014c\u114c\u0001"+ + "\u0000\u0000\u0000\u014e\u1157\u0001\u0000\u0000\u0000\u0150\u1160\u0001"+ + "\u0000\u0000\u0000\u0152\u1163\u0001\u0000\u0000\u0000\u0154\u116b\u0001"+ + "\u0000\u0000\u0000\u0156\u1184\u0001\u0000\u0000\u0000\u0158\u1190\u0001"+ + "\u0000\u0000\u0000\u015a\u1193\u0001\u0000\u0000\u0000\u015c\u11b3\u0001"+ + "\u0000\u0000\u0000\u015e\u11b5\u0001\u0000\u0000\u0000\u0160\u11b7\u0001"+ + "\u0000\u0000\u0000\u0162\u11b9\u0001\u0000\u0000\u0000\u0164\u11bb\u0001"+ + "\u0000\u0000\u0000\u0166\u11f0\u0001\u0000\u0000\u0000\u0168\u11f2\u0001"+ + "\u0000\u0000\u0000\u016a\u11f8\u0001\u0000\u0000\u0000\u016c\u120c\u0001"+ + "\u0000\u0000\u0000\u016e\u121a\u0001\u0000\u0000\u0000\u0170\u1225\u0001"+ + "\u0000\u0000\u0000\u0172\u1227\u0001\u0000\u0000\u0000\u0174\u122d\u0001"+ + "\u0000\u0000\u0000\u0176\u1237\u0001\u0000\u0000\u0000\u0178\u123b\u0001"+ + "\u0000\u0000\u0000\u017a\u1242\u0001\u0000\u0000\u0000\u017c\u1246\u0001"+ + "\u0000\u0000\u0000\u017e\u124c\u0001\u0000\u0000\u0000\u0180\u1253\u0001"+ + "\u0000\u0000\u0000\u0182\u1259\u0001\u0000\u0000\u0000\u0184\u125f\u0001"+ + "\u0000\u0000\u0000\u0186\u1264\u0001\u0000\u0000\u0000\u0188\u1291\u0001"+ + "\u0000\u0000\u0000\u018a\u12a6\u0001\u0000\u0000\u0000\u018c\u12bf\u0001"+ + "\u0000\u0000\u0000\u018e\u12c2\u0001\u0000\u0000\u0000\u0190\u12c8\u0001"+ + "\u0000\u0000\u0000\u0192\u12d8\u0001\u0000\u0000\u0000\u0194\u12e7\u0001"+ + "\u0000\u0000\u0000\u0196\u12ed\u0001\u0000\u0000\u0000\u0198\u130b\u0001"+ + "\u0000\u0000\u0000\u019a\u130d\u0001\u0000\u0000\u0000\u019c\u1314\u0001"+ + "\u0000\u0000\u0000\u019e\u1320\u0001\u0000\u0000\u0000\u01a0\u1326\u0001"+ + "\u0000\u0000\u0000\u01a2\u133f\u0001\u0000\u0000\u0000\u01a4\u1343\u0001"+ + "\u0000\u0000\u0000\u01a6\u1347\u0001\u0000\u0000\u0000\u01a8\u1352\u0001"+ + "\u0000\u0000\u0000\u01aa\u13a3\u0001\u0000\u0000\u0000\u01ac\u13e6\u0001"+ + "\u0000\u0000\u0000\u01ae\u13e8\u0001\u0000\u0000\u0000\u01b0\u1452\u0001"+ + "\u0000\u0000\u0000\u01b2\u146a\u0001\u0000\u0000\u0000\u01b4\u146c\u0001"+ + "\u0000\u0000\u0000\u01b6\u147e\u0001\u0000\u0000\u0000\u01b8\u14ce\u0001"+ + "\u0000\u0000\u0000\u01ba\u14d0\u0001\u0000\u0000\u0000\u01bc\u14dd\u0001"+ + "\u0000\u0000\u0000\u01be\u14e8\u0001\u0000\u0000\u0000\u01c0\u1504\u0001"+ + "\u0000\u0000\u0000\u01c2\u1508\u0001\u0000\u0000\u0000\u01c4\u151d\u0001"+ + "\u0000\u0000\u0000\u01c6\u1527\u0001\u0000\u0000\u0000\u01c8\u1531\u0001"+ + "\u0000\u0000\u0000\u01ca\u1559\u0001\u0000\u0000\u0000\u01cc\u155b\u0001"+ + "\u0000\u0000\u0000\u01ce\u155e\u0001\u0000\u0000\u0000\u01d0\u15c2\u0001"+ + "\u0000\u0000\u0000\u01d2\u15d4\u0001\u0000\u0000\u0000\u01d4\u15d6\u0001"+ + "\u0000\u0000\u0000\u01d6\u15da\u0001\u0000\u0000\u0000\u01d8\u1600\u0001"+ + "\u0000\u0000\u0000\u01da\u1609\u0001\u0000\u0000\u0000\u01dc\u160f\u0001"+ + "\u0000\u0000\u0000\u01de\u1616\u0001\u0000\u0000\u0000\u01e0\u162c\u0001"+ + "\u0000\u0000\u0000\u01e2\u162e\u0001\u0000\u0000\u0000\u01e4\u163c\u0001"+ + "\u0000\u0000\u0000\u01e6\u1642\u0001\u0000\u0000\u0000\u01e8\u167a\u0001"+ + "\u0000\u0000\u0000\u01ea\u1715\u0001\u0000\u0000\u0000\u01ec\u1721\u0001"+ + "\u0000\u0000\u0000\u01ee\u1730\u0001\u0000\u0000\u0000\u01f0\u1736\u0001"+ + "\u0000\u0000\u0000\u01f2\u1749\u0001\u0000\u0000\u0000\u01f4\u1753\u0001"+ + "\u0000\u0000\u0000\u01f6\u1761\u0001\u0000\u0000\u0000\u01f8\u1763\u0001"+ + "\u0000\u0000\u0000\u01fa\u1766\u0001\u0000\u0000\u0000\u01fc\u177c\u0001"+ + "\u0000\u0000\u0000\u01fe\u1788\u0001\u0000\u0000\u0000\u0200\u178e\u0001"+ + "\u0000\u0000\u0000\u0202\u179a\u0001\u0000\u0000\u0000\u0204\u179e\u0001"+ + "\u0000\u0000\u0000\u0206\u17a0\u0001\u0000\u0000\u0000\u0208\u17ca\u0001"+ + "\u0000\u0000\u0000\u020a\u17d1\u0001\u0000\u0000\u0000\u020c\u17d3\u0001"+ + "\u0000\u0000\u0000\u020e\u17ea\u0001\u0000\u0000\u0000\u0210\u17f0\u0001"+ + "\u0000\u0000\u0000\u0212\u17f8\u0001\u0000\u0000\u0000\u0214\u17fb\u0001"+ + "\u0000\u0000\u0000\u0216\u17fe\u0001\u0000\u0000\u0000\u0218\u1813\u0001"+ + "\u0000\u0000\u0000\u021a\u1828\u0001\u0000\u0000\u0000\u021c\u1830\u0001"+ + "\u0000\u0000\u0000\u021e\u183c\u0001\u0000\u0000\u0000\u0220\u1844\u0001"+ + "\u0000\u0000\u0000\u0222\u186a\u0001\u0000\u0000\u0000\u0224\u1876\u0001"+ + "\u0000\u0000\u0000\u0226\u1878\u0001\u0000\u0000\u0000\u0228\u187e\u0001"+ + "\u0000\u0000\u0000\u022a\u1882\u0001\u0000\u0000\u0000\u022c\u1892\u0001"+ + "\u0000\u0000\u0000\u022e\u189f\u0001\u0000\u0000\u0000\u0230\u18a8\u0001"+ + "\u0000\u0000\u0000\u0232\u18aa\u0001\u0000\u0000\u0000\u0234\u18b1\u0001"+ + "\u0000\u0000\u0000\u0236\u18b3\u0001\u0000\u0000\u0000\u0238\u18b9\u0001"+ + "\u0000\u0000\u0000\u023a\u18bd\u0001\u0000\u0000\u0000\u023c\u18c2\u0001"+ + "\u0000\u0000\u0000\u023e\u18c4\u0001\u0000\u0000\u0000\u0240\u18c6\u0001"+ + "\u0000\u0000\u0000\u0242\u18d8\u0001\u0000\u0000\u0000\u0244\u18e8\u0001"+ + "\u0000\u0000\u0000\u0246\u18ec\u0001\u0000\u0000\u0000\u0248\u18f1\u0001"+ + "\u0000\u0000\u0000\u024a\u18fc\u0001\u0000\u0000\u0000\u024c\u1901\u0001"+ + "\u0000\u0000\u0000\u024e\u1903\u0001\u0000\u0000\u0000\u0250\u1907\u0001"+ + "\u0000\u0000\u0000\u0252\u1920\u0001\u0000\u0000\u0000\u0254\u1922\u0001"+ + "\u0000\u0000\u0000\u0256\u1925\u0001\u0000\u0000\u0000\u0258\u192a\u0001"+ + "\u0000\u0000\u0000\u025a\u193a\u0001\u0000\u0000\u0000\u025c\u19ba\u0001"+ + "\u0000\u0000\u0000\u025e\u19bc\u0001\u0000\u0000\u0000\u0260\u19dd\u0001"+ + "\u0000\u0000\u0000\u0262\u19e2\u0001\u0000\u0000\u0000\u0264\u19e6\u0001"+ + "\u0000\u0000\u0000\u0266\u19ec\u0001\u0000\u0000\u0000\u0268\u19f4\u0001"+ + "\u0000\u0000\u0000\u026a\u19fc\u0001\u0000\u0000\u0000\u026c\u1a04\u0001"+ + "\u0000\u0000\u0000\u026e\u1a0c\u0001\u0000\u0000\u0000\u0270\u1a17\u0001"+ + "\u0000\u0000\u0000\u0272\u1a1f\u0001\u0000\u0000\u0000\u0274\u1a27\u0001"+ + "\u0000\u0000\u0000\u0276\u1a2f\u0001\u0000\u0000\u0000\u0278\u1a37\u0001"+ + "\u0000\u0000\u0000\u027a\u1a59\u0001\u0000\u0000\u0000\u027c\u1a69\u0001"+ + "\u0000\u0000\u0000\u027e\u1a6d\u0001\u0000\u0000\u0000\u0280\u1a6f\u0001"+ + "\u0000\u0000\u0000\u0282\u1a72\u0001\u0000\u0000\u0000\u0284\u1a76\u0001"+ + "\u0000\u0000\u0000\u0286\u1a7c\u0001\u0000\u0000\u0000\u0288\u1a90\u0001"+ + "\u0000\u0000\u0000\u028a\u1b45\u0001\u0000\u0000\u0000\u028c\u1b47\u0001"+ + "\u0000\u0000\u0000\u028e\u1b5a\u0001\u0000\u0000\u0000\u0290\u1b5c\u0001"+ + "\u0000\u0000\u0000\u0292\u1b9b\u0001\u0000\u0000\u0000\u0294\u1bc3\u0001"+ + "\u0000\u0000\u0000\u0296\u1bc5\u0001\u0000\u0000\u0000\u0298\u1bce\u0001"+ + "\u0000\u0000\u0000\u029a\u1bd9\u0001\u0000\u0000\u0000\u029c\u1bdb\u0001"+ + "\u0000\u0000\u0000\u029e\u1bde\u0001\u0000\u0000\u0000\u02a0\u1be2\u0001"+ + "\u0000\u0000\u0000\u02a2\u1be4\u0001\u0000\u0000\u0000\u02a4\u1bf0\u0001"+ + "\u0000\u0000\u0000\u02a6\u1bf2\u0001\u0000\u0000\u0000\u02a8\u1c14\u0001"+ + "\u0000\u0000\u0000\u02aa\u1c16\u0001\u0000\u0000\u0000\u02ac\u1c1f\u0001"+ + "\u0000\u0000\u0000\u02ae\u1c31\u0001\u0000\u0000\u0000\u02b0\u1c3e\u0001"+ + "\u0000\u0000\u0000\u02b2\u1c49\u0001\u0000\u0000\u0000\u02b4\u1cc0\u0001"+ + "\u0000\u0000\u0000\u02b6\u1cda\u0001\u0000\u0000\u0000\u02b8\u1cea\u0001"+ + "\u0000\u0000\u0000\u02ba\u1cf3\u0001\u0000\u0000\u0000\u02bc\u1cfc\u0001"+ + "\u0000\u0000\u0000\u02be\u1cfe\u0001\u0000\u0000\u0000\u02c0\u1d00\u0001"+ + "\u0000\u0000\u0000\u02c2\u1d07\u0001\u0000\u0000\u0000\u02c4\u1d09\u0001"+ + "\u0000\u0000\u0000\u02c6\u1d0b\u0001\u0000\u0000\u0000\u02c8\u1d0d\u0001"+ + "\u0000\u0000\u0000\u02ca\u1d0f\u0001\u0000\u0000\u0000\u02cc\u1d11\u0001"+ + "\u0000\u0000\u0000\u02ce\u1d13\u0001\u0000\u0000\u0000\u02d0\u1d15\u0001"+ + "\u0000\u0000\u0000\u02d2\u02d4\u0003\u0002\u0001\u0000\u02d3\u02d2\u0001"+ + "\u0000\u0000\u0000\u02d3\u02d4\u0001\u0000\u0000\u0000\u02d4\u02d7\u0001"+ + "\u0000\u0000\u0000\u02d5\u02d6\u0005\u0462\u0000\u0000\u02d6\u02d8\u0005"+ + "\u0462\u0000\u0000\u02d7\u02d5\u0001\u0000\u0000\u0000\u02d7\u02d8\u0001"+ + "\u0000\u0000\u0000\u02d8\u02d9\u0001\u0000\u0000\u0000\u02d9\u02da\u0005"+ + "\u0000\u0000\u0001\u02da\u0001\u0001\u0000\u0000\u0000\u02db\u02de\u0003"+ + "\u0004\u0002\u0000\u02dc\u02dd\u0005\u0462\u0000\u0000\u02dd\u02df\u0005"+ + "\u0462\u0000\u0000\u02de\u02dc\u0001\u0000\u0000\u0000\u02de\u02df\u0001"+ + "\u0000\u0000\u0000\u02df\u02e1\u0001\u0000\u0000\u0000\u02e0\u02e2\u0005"+ + "\u0471\u0000\u0000\u02e1\u02e0\u0001\u0000\u0000\u0000\u02e1\u02e2\u0001"+ + "\u0000\u0000\u0000\u02e2\u02e5\u0001\u0000\u0000\u0000\u02e3\u02e5\u0003"+ + "\u0006\u0003\u0000\u02e4\u02db\u0001\u0000\u0000\u0000\u02e4\u02e3\u0001"+ + "\u0000\u0000\u0000\u02e5\u02e8\u0001\u0000\u0000\u0000\u02e6\u02e4\u0001"+ + "\u0000\u0000\u0000\u02e6\u02e7\u0001\u0000\u0000\u0000\u02e7\u02f2\u0001"+ + "\u0000\u0000\u0000\u02e8\u02e6\u0001\u0000\u0000\u0000\u02e9\u02ef\u0003"+ + "\u0004\u0002\u0000\u02ea\u02eb\u0005\u0462\u0000\u0000\u02eb\u02ed\u0005"+ + "\u0462\u0000\u0000\u02ec\u02ea\u0001\u0000\u0000\u0000\u02ec\u02ed\u0001"+ + "\u0000\u0000\u0000\u02ed\u02ee\u0001\u0000\u0000\u0000\u02ee\u02f0\u0005"+ + "\u0471\u0000\u0000\u02ef\u02ec\u0001\u0000\u0000\u0000\u02ef\u02f0\u0001"+ + "\u0000\u0000\u0000\u02f0\u02f3\u0001\u0000\u0000\u0000\u02f1\u02f3\u0003"+ + "\u0006\u0003\u0000\u02f2\u02e9\u0001\u0000\u0000\u0000\u02f2\u02f1\u0001"+ + "\u0000\u0000\u0000\u02f3\u0003\u0001\u0000\u0000\u0000\u02f4\u02fc\u0003"+ + "\b\u0004\u0000\u02f5\u02fc\u0003\n\u0005\u0000\u02f6\u02fc\u0003\f\u0006"+ + "\u0000\u02f7\u02fc\u0003\u000e\u0007\u0000\u02f8\u02fc\u0003\u0010\b\u0000"+ + "\u02f9\u02fc\u0003\u0014\n\u0000\u02fa\u02fc\u0003\u0016\u000b\u0000\u02fb"+ + "\u02f4\u0001\u0000\u0000\u0000\u02fb\u02f5\u0001\u0000\u0000\u0000\u02fb"+ + "\u02f6\u0001\u0000\u0000\u0000\u02fb\u02f7\u0001\u0000\u0000\u0000\u02fb"+ + "\u02f8\u0001\u0000\u0000\u0000\u02fb\u02f9\u0001\u0000\u0000\u0000\u02fb"+ + "\u02fa\u0001\u0000\u0000\u0000\u02fc\u0005\u0001\u0000\u0000\u0000\u02fd"+ + "\u02fe\u0005\u0471\u0000\u0000\u02fe\u0007\u0001\u0000\u0000\u0000\u02ff"+ + "\u0326\u0003\u0018\f\u0000\u0300\u0326\u0003\u001a\r\u0000\u0301\u0326"+ + "\u0003\u001c\u000e\u0000\u0302\u0326\u0003\u001e\u000f\u0000\u0303\u0326"+ + "\u0003 \u0010\u0000\u0304\u0326\u0003\"\u0011\u0000\u0305\u0326\u0003"+ + "&\u0013\u0000\u0306\u0326\u0003(\u0014\u0000\u0307\u0326\u0003*\u0015"+ + "\u0000\u0308\u0326\u0003,\u0016\u0000\u0309\u0326\u0003.\u0017\u0000\u030a"+ + "\u0326\u00038\u001c\u0000\u030b\u0326\u0003$\u0012\u0000\u030c\u0326\u0003"+ + "\u0080@\u0000\u030d\u0326\u0003\u0082A\u0000\u030e\u0326\u0003\u0084B"+ + "\u0000\u030f\u0326\u0003\u0086C\u0000\u0310\u0326\u0003\u0088D\u0000\u0311"+ + "\u0326\u0003\u008aE\u0000\u0312\u0326\u0003\u008cF\u0000\u0313\u0326\u0003"+ + "\u008eG\u0000\u0314\u0326\u0003\u0090H\u0000\u0315\u0326\u0003\u0092I"+ + "\u0000\u0316\u0326\u0003\u0098L\u0000\u0317\u0326\u0003\u009aM\u0000\u0318"+ + "\u0326\u0003\u009cN\u0000\u0319\u0326\u0003\u009eO\u0000\u031a\u0326\u0003"+ + "\u00a0P\u0000\u031b\u0326\u0003\u00a2Q\u0000\u031c\u0326\u0003\u00a4R"+ + "\u0000\u031d\u0326\u0003\u00a6S\u0000\u031e\u0326\u0003\u00a8T\u0000\u031f"+ + "\u0326\u0003\u00aaU\u0000\u0320\u0326\u0003\u00acV\u0000\u0321\u0326\u0003"+ + "\u00aeW\u0000\u0322\u0326\u0003\u00b0X\u0000\u0323\u0326\u0003\u00b2Y"+ + "\u0000\u0324\u0326\u0003\u00b6[\u0000\u0325\u02ff\u0001\u0000\u0000\u0000"+ + "\u0325\u0300\u0001\u0000\u0000\u0000\u0325\u0301\u0001\u0000\u0000\u0000"+ + "\u0325\u0302\u0001\u0000\u0000\u0000\u0325\u0303\u0001\u0000\u0000\u0000"+ + "\u0325\u0304\u0001\u0000\u0000\u0000\u0325\u0305\u0001\u0000\u0000\u0000"+ + "\u0325\u0306\u0001\u0000\u0000\u0000\u0325\u0307\u0001\u0000\u0000\u0000"+ + "\u0325\u0308\u0001\u0000\u0000\u0000\u0325\u0309\u0001\u0000\u0000\u0000"+ + "\u0325\u030a\u0001\u0000\u0000\u0000\u0325\u030b\u0001\u0000\u0000\u0000"+ + "\u0325\u030c\u0001\u0000\u0000\u0000\u0325\u030d\u0001\u0000\u0000\u0000"+ + "\u0325\u030e\u0001\u0000\u0000\u0000\u0325\u030f\u0001\u0000\u0000\u0000"+ + "\u0325\u0310\u0001\u0000\u0000\u0000\u0325\u0311\u0001\u0000\u0000\u0000"+ + "\u0325\u0312\u0001\u0000\u0000\u0000\u0325\u0313\u0001\u0000\u0000\u0000"+ + "\u0325\u0314\u0001\u0000\u0000\u0000\u0325\u0315\u0001\u0000\u0000\u0000"+ + "\u0325\u0316\u0001\u0000\u0000\u0000\u0325\u0317\u0001\u0000\u0000\u0000"+ + "\u0325\u0318\u0001\u0000\u0000\u0000\u0325\u0319\u0001\u0000\u0000\u0000"+ + "\u0325\u031a\u0001\u0000\u0000\u0000\u0325\u031b\u0001\u0000\u0000\u0000"+ + "\u0325\u031c\u0001\u0000\u0000\u0000\u0325\u031d\u0001\u0000\u0000\u0000"+ + "\u0325\u031e\u0001\u0000\u0000\u0000\u0325\u031f\u0001\u0000\u0000\u0000"+ + "\u0325\u0320\u0001\u0000\u0000\u0000\u0325\u0321\u0001\u0000\u0000\u0000"+ + "\u0325\u0322\u0001\u0000\u0000\u0000\u0325\u0323\u0001\u0000\u0000\u0000"+ + "\u0325\u0324\u0001\u0000\u0000\u0000\u0326\t\u0001\u0000\u0000\u0000\u0327"+ + "\u0335\u0003\u00c8d\u0000\u0328\u0335\u0003\u00c0`\u0000\u0329\u0335\u0003"+ + "\u00cae\u0000\u032a\u0335\u0003\u00ba]\u0000\u032b\u0335\u0003\u00c6c"+ + "\u0000\u032c\u0335\u0003\u00b8\\\u0000\u032d\u0335\u0003\u00c2a\u0000"+ + "\u032e\u0335\u0003\u00c4b\u0000\u032f\u0335\u0003\u00bc^\u0000\u0330\u0335"+ + "\u0003\u00be_\u0000\u0331\u0335\u0003\u00ccf\u0000\u0332\u0335\u0003\u021c"+ + "\u010e\u0000\u0333\u0335\u0003\u021e\u010f\u0000\u0334\u0327\u0001\u0000"+ + "\u0000\u0000\u0334\u0328\u0001\u0000\u0000\u0000\u0334\u0329\u0001\u0000"+ + "\u0000\u0000\u0334\u032a\u0001\u0000\u0000\u0000\u0334\u032b\u0001\u0000"+ + "\u0000\u0000\u0334\u032c\u0001\u0000\u0000\u0000\u0334\u032d\u0001\u0000"+ + "\u0000\u0000\u0334\u032e\u0001\u0000\u0000\u0000\u0334\u032f\u0001\u0000"+ + "\u0000\u0000\u0334\u0330\u0001\u0000\u0000\u0000\u0334\u0331\u0001\u0000"+ + "\u0000\u0000\u0334\u0332\u0001\u0000\u0000\u0000\u0334\u0333\u0001\u0000"+ + "\u0000\u0000\u0335\u000b\u0001\u0000\u0000\u0000\u0336\u0340\u0003\u012a"+ + "\u0095\u0000\u0337\u0340\u0003\u012c\u0096\u0000\u0338\u0340\u0003\u012e"+ + "\u0097\u0000\u0339\u0340\u0003\u0130\u0098\u0000\u033a\u0340\u0003\u0132"+ + "\u0099\u0000\u033b\u0340\u0003\u0134\u009a\u0000\u033c\u0340\u0003\u0136"+ + "\u009b\u0000\u033d\u0340\u0003\u0138\u009c\u0000\u033e\u0340\u0003\u013a"+ + "\u009d\u0000\u033f\u0336\u0001\u0000\u0000\u0000\u033f\u0337\u0001\u0000"+ + "\u0000\u0000\u033f\u0338\u0001\u0000\u0000\u0000\u033f\u0339\u0001\u0000"+ + "\u0000\u0000\u033f\u033a\u0001\u0000\u0000\u0000\u033f\u033b\u0001\u0000"+ + "\u0000\u0000\u033f\u033c\u0001\u0000\u0000\u0000\u033f\u033d\u0001\u0000"+ + "\u0000\u0000\u033f\u033e\u0001\u0000\u0000\u0000\u0340\r\u0001\u0000\u0000"+ + "\u0000\u0341\u0351\u0003\u014a\u00a5\u0000\u0342\u0351\u0003\u014c\u00a6"+ + "\u0000\u0343\u0351\u0003\u014e\u00a7\u0000\u0344\u0351\u0003\u0150\u00a8"+ + "\u0000\u0345\u0351\u0003\u0152\u00a9\u0000\u0346\u0351\u0003\u0154\u00aa"+ + "\u0000\u0347\u0351\u0003\u0156\u00ab\u0000\u0348\u0351\u0003\u0158\u00ac"+ + "\u0000\u0349\u0351\u0003\u015a\u00ad\u0000\u034a\u0351\u0003\u0172\u00b9"+ + "\u0000\u034b\u0351\u0003\u0174\u00ba\u0000\u034c\u0351\u0003\u0176\u00bb"+ + "\u0000\u034d\u0351\u0003\u0178\u00bc\u0000\u034e\u0351\u0003\u017a\u00bd"+ + "\u0000\u034f\u0351\u0003\u017c\u00be\u0000\u0350\u0341\u0001\u0000\u0000"+ + "\u0000\u0350\u0342\u0001\u0000\u0000\u0000\u0350\u0343\u0001\u0000\u0000"+ + "\u0000\u0350\u0344\u0001\u0000\u0000\u0000\u0350\u0345\u0001\u0000\u0000"+ + "\u0000\u0350\u0346\u0001\u0000\u0000\u0000\u0350\u0347\u0001\u0000\u0000"+ + "\u0000\u0350\u0348\u0001\u0000\u0000\u0000\u0350\u0349\u0001\u0000\u0000"+ + "\u0000\u0350\u034a\u0001\u0000\u0000\u0000\u0350\u034b\u0001\u0000\u0000"+ + "\u0000\u0350\u034c\u0001\u0000\u0000\u0000\u0350\u034d\u0001\u0000\u0000"+ + "\u0000\u0350\u034e\u0001\u0000\u0000\u0000\u0350\u034f\u0001\u0000\u0000"+ + "\u0000\u0351\u000f\u0001\u0000\u0000\u0000\u0352\u0356\u0003\u017e\u00bf"+ + "\u0000\u0353\u0356\u0003\u0180\u00c0\u0000\u0354\u0356\u0003\u0182\u00c1"+ + "\u0000\u0355\u0352\u0001\u0000\u0000\u0000\u0355\u0353\u0001\u0000\u0000"+ + "\u0000\u0355\u0354\u0001\u0000\u0000\u0000\u0356\u0011\u0001\u0000\u0000"+ + "\u0000\u0357\u0365\u0003\u0186\u00c3\u0000\u0358\u0365\u0003\u0188\u00c4"+ + "\u0000\u0359\u0365\u0003\u018a\u00c5\u0000\u035a\u0365\u0003\u018e\u00c7"+ + "\u0000\u035b\u0365\u0003\u0190\u00c8\u0000\u035c\u0365\u0003\u0192\u00c9"+ + "\u0000\u035d\u0365\u0003\u0196\u00cb\u0000\u035e\u0365\u0003\u018c\u00c6"+ + "\u0000\u035f\u0365\u0003\u0194\u00ca\u0000\u0360\u0365\u0003\u0198\u00cc"+ + "\u0000\u0361\u0362\u0003\u021c\u010e\u0000\u0362\u0363\u0003\n\u0005\u0000"+ + "\u0363\u0365\u0001\u0000\u0000\u0000\u0364\u0357\u0001\u0000\u0000\u0000"+ + "\u0364\u0358\u0001\u0000\u0000\u0000\u0364\u0359\u0001\u0000\u0000\u0000"+ + "\u0364\u035a\u0001\u0000\u0000\u0000\u0364\u035b\u0001\u0000\u0000\u0000"+ + "\u0364\u035c\u0001\u0000\u0000\u0000\u0364\u035d\u0001\u0000\u0000\u0000"+ + "\u0364\u035e\u0001\u0000\u0000\u0000\u0364\u035f\u0001\u0000\u0000\u0000"+ + "\u0364\u0360\u0001\u0000\u0000\u0000\u0364\u0361\u0001\u0000\u0000\u0000"+ + "\u0365\u0013\u0001\u0000\u0000\u0000\u0366\u0380\u0003\u01aa\u00d5\u0000"+ + "\u0367\u0380\u0003\u01ac\u00d6\u0000\u0368\u0380\u0003\u01ae\u00d7\u0000"+ + "\u0369\u0380\u0003\u01b0\u00d8\u0000\u036a\u0380\u0003\u01b4\u00da\u0000"+ + "\u036b\u0380\u0003\u01b6\u00db\u0000\u036c\u0380\u0003\u01b8\u00dc\u0000"+ + "\u036d\u0380\u0003\u01ba\u00dd\u0000\u036e\u0380\u0003\u01d6\u00eb\u0000"+ + "\u036f\u0380\u0003\u01d8\u00ec\u0000\u0370\u0380\u0003\u01da\u00ed\u0000"+ + "\u0371\u0380\u0003\u01dc\u00ee\u0000\u0372\u0380\u0003\u01de\u00ef\u0000"+ + "\u0373\u0380\u0003\u01e2\u00f1\u0000\u0374\u0380\u0003\u01e4\u00f2\u0000"+ + "\u0375\u0380\u0003\u01e6\u00f3\u0000\u0376\u0380\u0003\u01e8\u00f4\u0000"+ + "\u0377\u0380\u0003\u01ea\u00f5\u0000\u0378\u0380\u0003\u01f8\u00fc\u0000"+ + "\u0379\u0380\u0003\u01fa\u00fd\u0000\u037a\u0380\u0003\u01fc\u00fe\u0000"+ + "\u037b\u0380\u0003\u01fe\u00ff\u0000\u037c\u0380\u0003\u0200\u0100\u0000"+ + "\u037d\u0380\u0003\u0202\u0101\u0000\u037e\u0380\u0003\u0204\u0102\u0000"+ + "\u037f\u0366\u0001\u0000\u0000\u0000\u037f\u0367\u0001\u0000\u0000\u0000"+ + "\u037f\u0368\u0001\u0000\u0000\u0000\u037f\u0369\u0001\u0000\u0000\u0000"+ + "\u037f\u036a\u0001\u0000\u0000\u0000\u037f\u036b\u0001\u0000\u0000\u0000"+ + "\u037f\u036c\u0001\u0000\u0000\u0000\u037f\u036d\u0001\u0000\u0000\u0000"+ + "\u037f\u036e\u0001\u0000\u0000\u0000\u037f\u036f\u0001\u0000\u0000\u0000"+ + "\u037f\u0370\u0001\u0000\u0000\u0000\u037f\u0371\u0001\u0000\u0000\u0000"+ + "\u037f\u0372\u0001\u0000\u0000\u0000\u037f\u0373\u0001\u0000\u0000\u0000"+ + "\u037f\u0374\u0001\u0000\u0000\u0000\u037f\u0375\u0001\u0000\u0000\u0000"+ + "\u037f\u0376\u0001\u0000\u0000\u0000\u037f\u0377\u0001\u0000\u0000\u0000"+ + "\u037f\u0378\u0001\u0000\u0000\u0000\u037f\u0379\u0001\u0000\u0000\u0000"+ + "\u037f\u037a\u0001\u0000\u0000\u0000\u037f\u037b\u0001\u0000\u0000\u0000"+ + "\u037f\u037c\u0001\u0000\u0000\u0000\u037f\u037d\u0001\u0000\u0000\u0000"+ + "\u037f\u037e\u0001\u0000\u0000\u0000\u0380\u0015\u0001\u0000\u0000\u0000"+ + "\u0381\u0389\u0003\u020e\u0107\u0000\u0382\u0389\u0003\u0210\u0108\u0000"+ + "\u0383\u0389\u0003\u0212\u0109\u0000\u0384\u0389\u0003\u0214\u010a\u0000"+ + "\u0385\u0389\u0003\u0216\u010b\u0000\u0386\u0389\u0003\u0218\u010c\u0000"+ + "\u0387\u0389\u0003\u0220\u0110\u0000\u0388\u0381\u0001\u0000\u0000\u0000"+ + "\u0388\u0382\u0001\u0000\u0000\u0000\u0388\u0383\u0001\u0000\u0000\u0000"+ + "\u0388\u0384\u0001\u0000\u0000\u0000\u0388\u0385\u0001\u0000\u0000\u0000"+ + "\u0388\u0386\u0001\u0000\u0000\u0000\u0388\u0387\u0001\u0000\u0000\u0000"+ + "\u0389\u0017\u0001\u0000\u0000\u0000\u038a\u038b\u0005\"\u0000\u0000\u038b"+ + "\u038d\u0007\u0000\u0000\u0000\u038c\u038e\u0003\u0282\u0141\u0000\u038d"+ + "\u038c\u0001\u0000\u0000\u0000\u038d\u038e\u0001\u0000\u0000\u0000\u038e"+ + "\u038f\u0001\u0000\u0000\u0000\u038f\u0393\u0003\u0248\u0124\u0000\u0390"+ + "\u0392\u0003:\u001d\u0000\u0391\u0390\u0001\u0000\u0000\u0000\u0392\u0395"+ + "\u0001\u0000\u0000\u0000\u0393\u0391\u0001\u0000\u0000\u0000\u0393\u0394"+ + "\u0001\u0000\u0000\u0000\u0394\u0019\u0001\u0000\u0000\u0000\u0395\u0393"+ + "\u0001\u0000\u0000\u0000\u0396\u0398\u0005\"\u0000\u0000\u0397\u0399\u0003"+ + "@ "; + private static final String _serializedATNSegment1 = + "\u0000\u0398\u0397\u0001\u0000\u0000\u0000\u0398\u0399\u0001\u0000\u0000"+ + "\u0000\u0399\u039a\u0001\u0000\u0000\u0000\u039a\u039c\u0005\u01a0\u0000"+ + "\u0000\u039b\u039d\u0003\u0282\u0141\u0000\u039c\u039b\u0001\u0000\u0000"+ + "\u0000\u039c\u039d\u0001\u0000\u0000\u0000\u039d\u039e\u0001\u0000\u0000"+ + "\u0000\u039e\u039f\u0003\u0226\u0113\u0000\u039f\u03a0\u0005w\u0000\u0000"+ + "\u03a0\u03a1\u0005\u025e\u0000\u0000\u03a1\u03a8\u0003B!\u0000\u03a2\u03a3"+ + "\u0005w\u0000\u0000\u03a3\u03a5\u0005\u0174\u0000\u0000\u03a4\u03a6\u0005"+ + "s\u0000\u0000\u03a5\u03a4\u0001\u0000\u0000\u0000\u03a5\u03a6\u0001\u0000"+ + "\u0000\u0000\u03a6\u03a7\u0001\u0000\u0000\u0000\u03a7\u03a9\u0005\u0232"+ + "\u0000\u0000\u03a8\u03a2\u0001\u0000\u0000\u0000\u03a8\u03a9\u0001\u0000"+ + "\u0000\u0000\u03a9\u03ab\u0001\u0000\u0000\u0000\u03aa\u03ac\u0003J%\u0000"+ + "\u03ab\u03aa\u0001\u0000\u0000\u0000\u03ab\u03ac\u0001\u0000\u0000\u0000"+ + "\u03ac\u03af\u0001\u0000\u0000\u0000\u03ad\u03ae\u0005\u0171\u0000\u0000"+ + "\u03ae\u03b0\u0005\u047d\u0000\u0000\u03af\u03ad\u0001\u0000\u0000\u0000"+ + "\u03af\u03b0\u0001\u0000\u0000\u0000\u03b0\u03b1\u0001\u0000\u0000\u0000"+ + "\u03b1\u03b2\u0005\u0190\u0000\u0000\u03b2\u03b3\u0003\u0184\u00c2\u0000"+ + "\u03b3\u001b\u0001\u0000\u0000\u0000\u03b4\u03b6\u0005\"\u0000\u0000\u03b5"+ + "\u03b7\u0007\u0001\u0000\u0000\u03b6\u03b5\u0001\u0000\u0000\u0000\u03b6"+ + "\u03b7\u0001\u0000\u0000\u0000\u03b7\u03b9\u0001\u0000\u0000\u0000\u03b8"+ + "\u03ba\u0007\u0002\u0000\u0000\u03b9\u03b8\u0001\u0000\u0000\u0000\u03b9"+ + "\u03ba\u0001\u0000\u0000\u0000\u03ba\u03bb\u0001\u0000\u0000\u0000\u03bb"+ + "\u03bc\u0005R\u0000\u0000\u03bc\u03be\u0003\u0248\u0124\u0000\u03bd\u03bf"+ + "\u0003L&\u0000\u03be\u03bd\u0001\u0000\u0000\u0000\u03be\u03bf\u0001\u0000"+ + "\u0000\u0000\u03bf\u03c0\u0001\u0000\u0000\u0000\u03c0\u03c1\u0005w\u0000"+ + "\u0000\u03c1\u03c2\u0003\u0228\u0114\u0000\u03c2\u03c6\u0003\u026e\u0137"+ + "\u0000\u03c3\u03c5\u0003N\'\u0000\u03c4\u03c3\u0001\u0000\u0000\u0000"+ + "\u03c5\u03c8\u0001\u0000\u0000\u0000\u03c6\u03c4\u0001\u0000\u0000\u0000"+ + "\u03c6\u03c7\u0001\u0000\u0000\u0000\u03c7\u03d5\u0001\u0000\u0000\u0000"+ + "\u03c8\u03c6\u0001\u0000\u0000\u0000\u03c9\u03cb\u0005\u0151\u0000\u0000"+ + "\u03ca\u03cc\u0005\u0465\u0000\u0000\u03cb\u03ca\u0001\u0000\u0000\u0000"+ + "\u03cb\u03cc\u0001\u0000\u0000\u0000\u03cc\u03cd\u0001\u0000\u0000\u0000"+ + "\u03cd\u03d4\u0007\u0003\u0000\u0000\u03ce\u03d0\u0005h\u0000\u0000\u03cf"+ + "\u03d1\u0005\u0465\u0000\u0000\u03d0\u03cf\u0001\u0000\u0000\u0000\u03d0"+ + "\u03d1\u0001\u0000\u0000\u0000\u03d1\u03d2\u0001\u0000\u0000\u0000\u03d2"+ + "\u03d4\u0007\u0004\u0000\u0000\u03d3\u03c9\u0001\u0000\u0000\u0000\u03d3"+ + "\u03ce\u0001\u0000\u0000\u0000\u03d4\u03d7\u0001\u0000\u0000\u0000\u03d5"+ + "\u03d3\u0001\u0000\u0000\u0000\u03d5\u03d6\u0001\u0000\u0000\u0000\u03d6"+ + "\u001d\u0001\u0000\u0000\u0000\u03d7\u03d5\u0001\u0000\u0000\u0000\u03d8"+ + "\u03d9\u0005\"\u0000\u0000\u03d9\u03da\u0005\u01dc\u0000\u0000\u03da\u03db"+ + "\u0005J\u0000\u0000\u03db\u03dc\u0003\u0248\u0124\u0000\u03dc\u03dd\u0005"+ + "\u0006\u0000\u0000\u03dd\u03de\u0005\u0294\u0000\u0000\u03de\u03e4\u0005"+ + "\u047d\u0000\u0000\u03df\u03e1\u0005\u01c6\u0000\u0000\u03e0\u03e2\u0005"+ + "\u0465\u0000\u0000\u03e1\u03e0\u0001\u0000\u0000\u0000\u03e1\u03e2\u0001"+ + "\u0000\u0000\u0000\u03e2\u03e3\u0001\u0000\u0000\u0000\u03e3\u03e5\u0003"+ + "\u0250\u0128\u0000\u03e4\u03df\u0001\u0000\u0000\u0000\u03e4\u03e5\u0001"+ + "\u0000\u0000\u0000\u03e5\u03eb\u0001\u0000\u0000\u0000\u03e6\u03e8\u0005"+ + "\u0295\u0000\u0000\u03e7\u03e9\u0005\u0465\u0000\u0000\u03e8\u03e7\u0001"+ + "\u0000\u0000\u0000\u03e8\u03e9\u0001\u0000\u0000\u0000\u03e9\u03ea\u0001"+ + "\u0000\u0000\u0000\u03ea\u03ec\u0003\u0250\u0128\u0000\u03eb\u03e6\u0001"+ + "\u0000\u0000\u0000\u03eb\u03ec\u0001\u0000\u0000\u0000\u03ec\u03f2\u0001"+ + "\u0000\u0000\u0000\u03ed\u03ef\u0005\u023d\u0000\u0000\u03ee\u03f0\u0005"+ + "\u0465\u0000\u0000\u03ef\u03ee\u0001\u0000\u0000\u0000\u03ef\u03f0\u0001"+ + "\u0000\u0000\u0000\u03f0\u03f1\u0001\u0000\u0000\u0000\u03f1\u03f3\u0003"+ + "\u0250\u0128\u0000\u03f2\u03ed\u0001\u0000\u0000\u0000\u03f2\u03f3\u0001"+ + "\u0000\u0000\u0000\u03f3\u03f9\u0001\u0000\u0000\u0000\u03f4\u03f6\u0005"+ + "\u0211\u0000\u0000\u03f5\u03f7\u0005\u0465\u0000\u0000\u03f6\u03f5\u0001"+ + "\u0000\u0000\u0000\u03f6\u03f7\u0001\u0000\u0000\u0000\u03f7\u03f8\u0001"+ + "\u0000\u0000\u0000\u03f8\u03fa\u0003\u0248\u0124\u0000\u03f9\u03f4\u0001"+ + "\u0000\u0000\u0000\u03f9\u03fa\u0001\u0000\u0000\u0000\u03fa\u03fc\u0001"+ + "\u0000\u0000\u0000\u03fb\u03fd\u0005\u02a3\u0000\u0000\u03fc\u03fb\u0001"+ + "\u0000\u0000\u0000\u03fc\u03fd\u0001\u0000\u0000\u0000\u03fd\u0403\u0001"+ + "\u0000\u0000\u0000\u03fe\u0400\u0005\u0171\u0000\u0000\u03ff\u0401\u0005"+ + "\u0465\u0000\u0000\u0400\u03ff\u0001\u0000\u0000\u0000\u0400\u0401\u0001"+ + "\u0000\u0000\u0000\u0401\u0402\u0001\u0000\u0000\u0000\u0402\u0404\u0005"+ + "\u047d\u0000\u0000\u0403\u03fe\u0001\u0000\u0000\u0000\u0403\u0404\u0001"+ + "\u0000\u0000\u0000\u0404\u0405\u0001\u0000\u0000\u0000\u0405\u0407\u0005"+ + "\u019a\u0000\u0000\u0406\u0408\u0005\u0465\u0000\u0000\u0407\u0406\u0001"+ + "\u0000\u0000\u0000\u0407\u0408\u0001\u0000\u0000\u0000\u0408\u0409\u0001"+ + "\u0000\u0000\u0000\u0409\u040a\u0003\u023c\u011e\u0000\u040a\u001f\u0001"+ + "\u0000\u0000\u0000\u040b\u040d\u0005\"\u0000\u0000\u040c\u040e\u0003@"+ + " \u0000\u040d\u040c\u0001\u0000\u0000\u0000\u040d\u040e\u0001\u0000\u0000"+ + "\u0000\u040e\u040f\u0001\u0000\u0000\u0000\u040f\u0410\u0005\u0084\u0000"+ + "\u0000\u0410\u0411\u0003\u0226\u0113\u0000\u0411\u0413\u0005\u046e\u0000"+ + "\u0000\u0412\u0414\u0003P(\u0000\u0413\u0412\u0001\u0000\u0000\u0000\u0413"+ + "\u0414\u0001\u0000\u0000\u0000\u0414\u0419\u0001\u0000\u0000\u0000\u0415"+ + "\u0416\u0005\u0470\u0000\u0000\u0416\u0418\u0003P(\u0000\u0417\u0415\u0001"+ + "\u0000\u0000\u0000\u0418\u041b\u0001\u0000\u0000\u0000\u0419\u0417\u0001"+ + "\u0000\u0000\u0000\u0419\u041a\u0001\u0000\u0000\u0000\u041a\u041c\u0001"+ + "\u0000\u0000\u0000\u041b\u0419\u0001\u0000\u0000\u0000\u041c\u0420\u0005"+ + "\u046f\u0000\u0000\u041d\u041f\u0003T*\u0000\u041e\u041d\u0001\u0000\u0000"+ + "\u0000\u041f\u0422\u0001\u0000\u0000\u0000\u0420\u041e\u0001\u0000\u0000"+ + "\u0000\u0420\u0421\u0001\u0000\u0000\u0000\u0421\u0423\u0001\u0000\u0000"+ + "\u0000\u0422\u0420\u0001\u0000\u0000\u0000\u0423\u0424\u0003\u0184\u00c2"+ + "\u0000\u0424!\u0001\u0000\u0000\u0000\u0425\u0427\u0005\"\u0000\u0000"+ + "\u0426\u0428\u0003@ \u0000\u0427\u0426\u0001\u0000\u0000\u0000\u0427\u0428"+ + "\u0001\u0000\u0000\u0000\u0428\u042a\u0001\u0000\u0000\u0000\u0429\u042b"+ + "\u0005\u0150\u0000\u0000\u042a\u0429\u0001\u0000\u0000\u0000\u042a\u042b"+ + "\u0001\u0000\u0000\u0000\u042b\u042c\u0001\u0000\u0000\u0000\u042c\u042e"+ + "\u0005\u01b6\u0000\u0000\u042d\u042f\u0003\u0282\u0141\u0000\u042e\u042d"+ + "\u0001\u0000\u0000\u0000\u042e\u042f\u0001\u0000\u0000\u0000\u042f\u0430"+ + "\u0001\u0000\u0000\u0000\u0430\u0431\u0003\u0226\u0113\u0000\u0431\u0433"+ + "\u0005\u046e\u0000\u0000\u0432\u0434\u0003R)\u0000\u0433\u0432\u0001\u0000"+ + "\u0000\u0000\u0433\u0434\u0001\u0000\u0000\u0000\u0434\u0439\u0001\u0000"+ + "\u0000\u0000\u0435\u0436\u0005\u0470\u0000\u0000\u0436\u0438\u0003R)\u0000"+ + "\u0437\u0435\u0001\u0000\u0000\u0000\u0438\u043b\u0001\u0000\u0000\u0000"+ + "\u0439\u0437\u0001\u0000\u0000\u0000\u0439\u043a\u0001\u0000\u0000\u0000"+ + "\u043a\u043c\u0001\u0000\u0000\u0000\u043b\u0439\u0001\u0000\u0000\u0000"+ + "\u043c\u043d\u0005\u046f\u0000\u0000\u043d\u043e\u0005\u0253\u0000\u0000"+ + "\u043e\u0442\u0003\u025c\u012e\u0000\u043f\u0441\u0003T*\u0000\u0440\u043f"+ + "\u0001\u0000\u0000\u0000\u0441\u0444\u0001\u0000\u0000\u0000\u0442\u0440"+ + "\u0001\u0000\u0000\u0000\u0442\u0443\u0001\u0000\u0000\u0000\u0443\u0447"+ + "\u0001\u0000\u0000\u0000\u0444\u0442\u0001\u0000\u0000\u0000\u0445\u0448"+ + "\u0003\u0184\u00c2\u0000\u0446\u0448\u0003\u0194\u00ca\u0000\u0447\u0445"+ + "\u0001\u0000\u0000\u0000\u0447\u0446\u0001\u0000\u0000\u0000\u0448#\u0001"+ + "\u0000\u0000\u0000\u0449\u044a\u0005\"\u0000\u0000\u044a\u044c\u0005\u0255"+ + "\u0000\u0000\u044b\u044d\u0003\u0282\u0141\u0000\u044c\u044b\u0001\u0000"+ + "\u0000\u0000\u044c\u044d\u0001\u0000\u0000\u0000\u044d\u044e\u0001\u0000"+ + "\u0000\u0000\u044e\u0453\u0003\u022a\u0115\u0000\u044f\u0450\u0005\u0470"+ + "\u0000\u0000\u0450\u0452\u0003\u022a\u0115\u0000\u0451\u044f\u0001\u0000"+ + "\u0000\u0000\u0452\u0455\u0001\u0000\u0000\u0000\u0453\u0451\u0001\u0000"+ + "\u0000\u0000\u0453\u0454\u0001\u0000\u0000\u0000\u0454%\u0001\u0000\u0000"+ + "\u0000\u0455\u0453\u0001\u0000\u0000\u0000\u0456\u0457\u0005\"\u0000\u0000"+ + "\u0457\u0458\u0005\u0261\u0000\u0000\u0458\u0459\u0003\u0248\u0124\u0000"+ + "\u0459\u045a\u0005D\u0000\u0000\u045a\u045b\u0005\u0185\u0000\u0000\u045b"+ + "\u045c\u0005\u02a8\u0000\u0000\u045c\u045d\u0007\u0005\u0000\u0000\u045d"+ + "\u045e\u0005\u021e\u0000\u0000\u045e\u045f\u0005\u046e\u0000\u0000\u045f"+ + "\u0464\u0003V+\u0000\u0460\u0461\u0005\u0470\u0000\u0000\u0461\u0463\u0003"+ + "V+\u0000\u0462\u0460\u0001\u0000\u0000\u0000\u0463\u0466\u0001\u0000\u0000"+ + "\u0000\u0464\u0462\u0001\u0000\u0000\u0000\u0464\u0465\u0001\u0000\u0000"+ + "\u0000\u0465\u0467\u0001\u0000\u0000\u0000\u0466\u0464\u0001\u0000\u0000"+ + "\u0000\u0467\u0468\u0005\u046f\u0000\u0000\u0468\'\u0001\u0000\u0000\u0000"+ + "\u0469\u046b\u0005\"\u0000\u0000\u046a\u046c\u0005\u028a\u0000\u0000\u046b"+ + "\u046a\u0001\u0000\u0000\u0000\u046b\u046c\u0001\u0000\u0000\u0000\u046c"+ + "\u046d\u0001\u0000\u0000\u0000\u046d\u046f\u0005\u00ad\u0000\u0000\u046e"+ + "\u0470\u0003\u0282\u0141\u0000\u046f\u046e\u0001\u0000\u0000\u0000\u046f"+ + "\u0470\u0001\u0000\u0000\u0000\u0470\u0471\u0001\u0000\u0000\u0000\u0471"+ + "\u0479\u0003\u0228\u0114\u0000\u0472\u0473\u0005c\u0000\u0000\u0473\u047a"+ + "\u0003\u0228\u0114\u0000\u0474\u0475\u0005\u046e\u0000\u0000\u0475\u0476"+ + "\u0005c\u0000\u0000\u0476\u0477\u0003\u0228\u0114\u0000\u0477\u0478\u0005"+ + "\u046f\u0000\u0000\u0478\u047a\u0001\u0000\u0000\u0000\u0479\u0472\u0001"+ + "\u0000\u0000\u0000\u0479\u0474\u0001\u0000\u0000\u0000\u047a\u04b8\u0001"+ + "\u0000\u0000\u0000\u047b\u047d\u0005\"\u0000\u0000\u047c\u047e\u0005\u028a"+ + "\u0000\u0000\u047d\u047c\u0001\u0000\u0000\u0000\u047d\u047e\u0001\u0000"+ + "\u0000\u0000\u047e\u047f\u0001\u0000\u0000\u0000\u047f\u0481\u0005\u00ad"+ + "\u0000\u0000\u0480\u0482\u0003\u0282\u0141\u0000\u0481\u0480\u0001\u0000"+ + "\u0000\u0000\u0481\u0482\u0001\u0000\u0000\u0000\u0482\u0483\u0001\u0000"+ + "\u0000\u0000\u0483\u0485\u0003\u0228\u0114\u0000\u0484\u0486\u0003X,\u0000"+ + "\u0485\u0484\u0001\u0000\u0000\u0000\u0485\u0486\u0001\u0000\u0000\u0000"+ + "\u0486\u0491\u0001\u0000\u0000\u0000\u0487\u048e\u0003j5\u0000\u0488\u048a"+ + "\u0005\u0470\u0000\u0000\u0489\u0488\u0001\u0000\u0000\u0000\u0489\u048a"+ + "\u0001\u0000\u0000\u0000\u048a\u048b\u0001\u0000\u0000\u0000\u048b\u048d"+ + "\u0003j5\u0000\u048c\u0489\u0001\u0000\u0000\u0000\u048d\u0490\u0001\u0000"+ + "\u0000\u0000\u048e\u048c\u0001\u0000\u0000\u0000\u048e\u048f\u0001\u0000"+ + "\u0000\u0000\u048f\u0492\u0001\u0000\u0000\u0000\u0490\u048e\u0001\u0000"+ + "\u0000\u0000\u0491\u0487\u0001\u0000\u0000\u0000\u0491\u0492\u0001\u0000"+ + "\u0000\u0000\u0492\u0494\u0001\u0000\u0000\u0000\u0493\u0495\u0003p8\u0000"+ + "\u0494\u0493\u0001\u0000\u0000\u0000\u0494\u0495\u0001\u0000\u0000\u0000"+ + "\u0495\u0497\u0001\u0000\u0000\u0000\u0496\u0498\u0007\u0006\u0000\u0000"+ + "\u0497\u0496\u0001\u0000\u0000\u0000\u0497\u0498\u0001\u0000\u0000\u0000"+ + "\u0498\u049a\u0001\u0000\u0000\u0000\u0499\u049b\u0005\r\u0000\u0000\u049a"+ + "\u0499\u0001\u0000\u0000\u0000\u049a\u049b\u0001\u0000\u0000\u0000\u049b"+ + "\u049c\u0001\u0000\u0000\u0000\u049c\u049d\u0003\u00c8d\u0000\u049d\u04b8"+ + "\u0001\u0000\u0000\u0000\u049e\u04a0\u0005\"\u0000\u0000\u049f\u04a1\u0005"+ + "\u028a\u0000\u0000\u04a0\u049f\u0001\u0000\u0000\u0000\u04a0\u04a1\u0001"+ + "\u0000\u0000\u0000\u04a1\u04a2\u0001\u0000\u0000\u0000\u04a2\u04a4\u0005"+ + "\u00ad\u0000\u0000\u04a3\u04a5\u0003\u0282\u0141\u0000\u04a4\u04a3\u0001"+ + "\u0000\u0000\u0000\u04a4\u04a5\u0001\u0000\u0000\u0000\u04a5\u04a6\u0001"+ + "\u0000\u0000\u0000\u04a6\u04a7\u0003\u0228\u0114\u0000\u04a7\u04b2\u0003"+ + "X,\u0000\u04a8\u04af\u0003j5\u0000\u04a9\u04ab\u0005\u0470\u0000\u0000"+ + "\u04aa\u04a9\u0001\u0000\u0000\u0000\u04aa\u04ab\u0001\u0000\u0000\u0000"+ + "\u04ab\u04ac\u0001\u0000\u0000\u0000\u04ac\u04ae\u0003j5\u0000\u04ad\u04aa"+ + "\u0001\u0000\u0000\u0000\u04ae\u04b1\u0001\u0000\u0000\u0000\u04af\u04ad"+ + "\u0001\u0000\u0000\u0000\u04af\u04b0\u0001\u0000\u0000\u0000\u04b0\u04b3"+ + "\u0001\u0000\u0000\u0000\u04b1\u04af\u0001\u0000\u0000\u0000\u04b2\u04a8"+ + "\u0001\u0000\u0000\u0000\u04b2\u04b3\u0001\u0000\u0000\u0000\u04b3\u04b5"+ + "\u0001\u0000\u0000\u0000\u04b4\u04b6\u0003p8\u0000\u04b5\u04b4\u0001\u0000"+ + "\u0000\u0000\u04b5\u04b6\u0001\u0000\u0000\u0000\u04b6\u04b8\u0001\u0000"+ + "\u0000\u0000\u04b7\u0469\u0001\u0000\u0000\u0000\u04b7\u047b\u0001\u0000"+ + "\u0000\u0000\u04b7\u049e\u0001\u0000\u0000\u0000\u04b8)\u0001\u0000\u0000"+ + "\u0000\u04b9\u04ba\u0005\"\u0000\u0000\u04ba\u04bb\u0005\u0288\u0000\u0000"+ + "\u04bb\u04bc\u0003\u0248\u0124\u0000\u04bc\u04bd\u0005\u0006\u0000\u0000"+ + "\u04bd\u04be\u0005\u0186\u0000\u0000\u04be\u04c2\u0005\u047d\u0000\u0000"+ + "\u04bf\u04c0\u0005\u01ad\u0000\u0000\u04c0\u04c1\u0005\u0465\u0000\u0000"+ + "\u04c1\u04c3\u0003\u0250\u0128\u0000\u04c2\u04bf\u0001\u0000\u0000\u0000"+ + "\u04c2\u04c3\u0001\u0000\u0000\u0000\u04c3\u04c9\u0001\u0000\u0000\u0000"+ + "\u04c4\u04c6\u0005\u019a\u0000\u0000\u04c5\u04c7\u0005\u0465\u0000\u0000"+ + "\u04c6\u04c5\u0001\u0000\u0000\u0000\u04c6\u04c7\u0001\u0000\u0000\u0000"+ + "\u04c7\u04c8\u0001\u0000\u0000\u0000\u04c8\u04ca\u0003\u023c\u011e\u0000"+ + "\u04c9\u04c4\u0001\u0000\u0000\u0000\u04c9\u04ca\u0001\u0000\u0000\u0000"+ + "\u04ca+\u0001\u0000\u0000\u0000\u04cb\u04cc\u0005\"\u0000\u0000\u04cc"+ + "\u04cd\u0005\u0288\u0000\u0000\u04cd\u04ce\u0003\u0248\u0124\u0000\u04ce"+ + "\u04cf\u0005\u0006\u0000\u0000\u04cf\u04d0\u0005\u0186\u0000\u0000\u04d0"+ + "\u04d1\u0005\u047d\u0000\u0000\u04d1\u04d2\u0005\u00bb\u0000\u0000\u04d2"+ + "\u04d3\u0005\u01dc\u0000\u0000\u04d3\u04d4\u0005J\u0000\u0000\u04d4\u04da"+ + "\u0003\u0248\u0124\u0000\u04d5\u04d7\u0005\u01a8\u0000\u0000\u04d6\u04d8"+ + "\u0005\u0465\u0000\u0000\u04d7\u04d6\u0001\u0000\u0000\u0000\u04d7\u04d8"+ + "\u0001\u0000\u0000\u0000\u04d8\u04d9\u0001\u0000\u0000\u0000\u04d9\u04db"+ + "\u0003\u0250\u0128\u0000\u04da\u04d5\u0001\u0000\u0000\u0000\u04da\u04db"+ + "\u0001\u0000\u0000\u0000\u04db\u04e1\u0001\u0000\u0000\u0000\u04dc\u04de"+ + "\u0005\u01c6\u0000\u0000\u04dd\u04df\u0005\u0465\u0000\u0000\u04de\u04dd"+ + "\u0001\u0000\u0000\u0000\u04de\u04df\u0001\u0000\u0000\u0000\u04df\u04e0"+ + "\u0001\u0000\u0000\u0000\u04e0\u04e2\u0003\u0250\u0128\u0000\u04e1\u04dc"+ + "\u0001\u0000\u0000\u0000\u04e1\u04e2\u0001\u0000\u0000\u0000\u04e2\u04e8"+ + "\u0001\u0000\u0000\u0000\u04e3\u04e5\u0005\u0156\u0000\u0000\u04e4\u04e6"+ + "\u0005\u0465\u0000\u0000\u04e5\u04e4\u0001\u0000\u0000\u0000\u04e5\u04e6"+ + "\u0001\u0000\u0000\u0000\u04e6\u04e7\u0001\u0000\u0000\u0000\u04e7\u04e9"+ + "\u0003\u0250\u0128\u0000\u04e8\u04e3\u0001\u0000\u0000\u0000\u04e8\u04e9"+ + "\u0001\u0000\u0000\u0000\u04e9\u04ef\u0001\u0000\u0000\u0000\u04ea\u04ec"+ + "\u0005\u01f6\u0000\u0000\u04eb\u04ed\u0005\u0465\u0000\u0000\u04ec\u04eb"+ + "\u0001\u0000\u0000\u0000\u04ec\u04ed\u0001\u0000\u0000\u0000\u04ed\u04ee"+ + "\u0001\u0000\u0000\u0000\u04ee\u04f0\u0003\u0250\u0128\u0000\u04ef\u04ea"+ + "\u0001\u0000\u0000\u0000\u04ef\u04f0\u0001\u0000\u0000\u0000\u04f0\u04f6"+ + "\u0001\u0000\u0000\u0000\u04f1\u04f3\u0005\u0211\u0000\u0000\u04f2\u04f4"+ + "\u0005\u0465\u0000\u0000\u04f3\u04f2\u0001\u0000\u0000\u0000\u04f3\u04f4"+ + "\u0001\u0000\u0000\u0000\u04f4\u04f5\u0001\u0000\u0000\u0000\u04f5\u04f7"+ + "\u0003\u0248\u0124\u0000\u04f6\u04f1\u0001\u0000\u0000\u0000\u04f6\u04f7"+ + "\u0001\u0000\u0000\u0000\u04f7\u04f9\u0001\u0000\u0000\u0000\u04f8\u04fa"+ + "\u0005\u02a3\u0000\u0000\u04f9\u04f8\u0001\u0000\u0000\u0000\u04f9\u04fa"+ + "\u0001\u0000\u0000\u0000\u04fa\u0500\u0001\u0000\u0000\u0000\u04fb\u04fd"+ + "\u0005\u0171\u0000\u0000\u04fc\u04fe\u0005\u0465\u0000\u0000\u04fd\u04fc"+ + "\u0001\u0000\u0000\u0000\u04fd\u04fe\u0001\u0000\u0000\u0000\u04fe\u04ff"+ + "\u0001\u0000\u0000\u0000\u04ff\u0501\u0005\u047d\u0000\u0000\u0500\u04fb"+ + "\u0001\u0000\u0000\u0000\u0500\u0501\u0001\u0000\u0000\u0000\u0501\u0502"+ + "\u0001\u0000\u0000\u0000\u0502\u0504\u0005\u019a\u0000\u0000\u0503\u0505"+ + "\u0005\u0465\u0000\u0000\u0504\u0503\u0001\u0000\u0000\u0000\u0504\u0505"+ + "\u0001\u0000\u0000\u0000\u0505\u0506\u0001\u0000\u0000\u0000\u0506\u0507"+ + "\u0003\u023c\u011e\u0000\u0507-\u0001\u0000\u0000\u0000\u0508\u050a\u0005"+ + "\"\u0000\u0000\u0509\u050b\u0003@ \u0000\u050a\u0509\u0001\u0000\u0000"+ + "\u0000\u050a\u050b\u0001\u0000\u0000\u0000\u050b\u050c\u0001\u0000\u0000"+ + "\u0000\u050c\u050d\u0005\u00b2\u0000\u0000\u050d\u050e\u0003\u0226\u0113"+ + "\u0000\u050e\u050f\u0007\u0007\u0000\u0000\u050f\u0510\u0007\b\u0000\u0000"+ + "\u0510\u0511\u0005w\u0000\u0000\u0511\u0512\u0003\u0228\u0114\u0000\u0512"+ + "\u0513\u0005B\u0000\u0000\u0513\u0514\u00055\u0000\u0000\u0514\u0517\u0005"+ + "\u0259\u0000\u0000\u0515\u0516\u0007\t\u0000\u0000\u0516\u0518\u0003\u0226"+ + "\u0113\u0000\u0517\u0515\u0001\u0000\u0000\u0000\u0517\u0518\u0001\u0000"+ + "\u0000\u0000\u0518\u0519\u0001\u0000\u0000\u0000\u0519\u051a\u0003\u0184"+ + "\u00c2\u0000\u051a/\u0001\u0000\u0000\u0000\u051b\u051d\u0005\u00c1\u0000"+ + "\u0000\u051c\u051e\u0005\u023c\u0000\u0000\u051d\u051c\u0001\u0000\u0000"+ + "\u0000\u051d\u051e\u0001\u0000\u0000\u0000\u051e\u051f\u0001\u0000\u0000"+ + "\u0000\u051f\u0520\u00032\u0019\u0000\u05201\u0001\u0000\u0000\u0000\u0521"+ + "\u052d\u00034\u001a\u0000\u0522\u0523\u0005\u046e\u0000\u0000\u0523\u0528"+ + "\u00036\u001b\u0000\u0524\u0525\u0005\u0470\u0000\u0000\u0525\u0527\u0003"+ + "6\u001b\u0000\u0526\u0524\u0001\u0000\u0000\u0000\u0527\u052a\u0001\u0000"+ + "\u0000\u0000\u0528\u0526\u0001\u0000\u0000\u0000\u0528\u0529\u0001\u0000"+ + "\u0000\u0000\u0529\u052b\u0001\u0000\u0000\u0000\u052a\u0528\u0001\u0000"+ + "\u0000\u0000\u052b\u052c\u0005\u046f\u0000\u0000\u052c\u052e\u0001\u0000"+ + "\u0000\u0000\u052d\u0522\u0001\u0000\u0000\u0000\u052d\u052e\u0001\u0000"+ + "\u0000\u0000\u052e\u052f\u0001\u0000\u0000\u0000\u052f\u0530\u0005\r\u0000"+ + "\u0000\u0530\u0531\u0005\u046e\u0000\u0000\u0531\u0532\u0003\n\u0005\u0000"+ + "\u0532\u0535\u0005\u046f\u0000\u0000\u0533\u0534\u0005\u0470\u0000\u0000"+ + "\u0534\u0536\u00032\u0019\u0000\u0535\u0533\u0001\u0000\u0000\u0000\u0535"+ + "\u0536\u0001\u0000\u0000\u0000\u05363\u0001\u0000\u0000\u0000\u0537\u0538"+ + "\u0003\u0248\u0124\u0000\u05385\u0001\u0000\u0000\u0000\u0539\u053a\u0003"+ + "\u0248\u0124\u0000\u053a7\u0001\u0000\u0000\u0000\u053b\u053d\u0005\""+ + "\u0000\u0000\u053c\u053e\u0003\u0284\u0142\u0000\u053d\u053c\u0001\u0000"+ + "\u0000\u0000\u053d\u053e\u0001\u0000\u0000\u0000\u053e\u0542\u0001\u0000"+ + "\u0000\u0000\u053f\u0540\u0005\u0151\u0000\u0000\u0540\u0541\u0005\u0465"+ + "\u0000\u0000\u0541\u0543\u0007\n\u0000\u0000\u0542\u053f\u0001\u0000\u0000"+ + "\u0000\u0542\u0543\u0001\u0000\u0000\u0000\u0543\u0545\u0001\u0000\u0000"+ + "\u0000\u0544\u0546\u0003@ \u0000\u0545\u0544\u0001\u0000\u0000\u0000\u0545"+ + "\u0546\u0001\u0000\u0000\u0000\u0546\u054a\u0001\u0000\u0000\u0000\u0547"+ + "\u0548\u0005\u00a1\u0000\u0000\u0548\u0549\u0005\u025f\u0000\u0000\u0549"+ + "\u054b\u0007\u000b\u0000\u0000\u054a\u0547\u0001\u0000\u0000\u0000\u054a"+ + "\u054b\u0001\u0000\u0000\u0000\u054b\u054c\u0001\u0000\u0000\u0000\u054c"+ + "\u054d\u0005\u02a0\u0000\u0000\u054d\u0552\u0003\u0226\u0113\u0000\u054e"+ + "\u054f\u0005\u046e\u0000\u0000\u054f\u0550\u0003\u0268\u0134\u0000\u0550"+ + "\u0551\u0005\u046f\u0000\u0000\u0551\u0553\u0001\u0000\u0000\u0000\u0552"+ + "\u054e\u0001\u0000\u0000\u0000\u0552\u0553\u0001\u0000\u0000\u0000\u0553"+ + "\u0554\u0001\u0000\u0000\u0000\u0554\u0568\u0005\r\u0000\u0000\u0555\u0557"+ + "\u0005\u046e\u0000\u0000\u0556\u0558\u00030\u0018\u0000\u0557\u0556\u0001"+ + "\u0000\u0000\u0000\u0557\u0558\u0001\u0000\u0000\u0000\u0558\u0559\u0001"+ + "\u0000\u0000\u0000\u0559\u055a\u0003\u00c8d\u0000\u055a\u055b\u0005\u046f"+ + "\u0000\u0000\u055b\u0569\u0001\u0000\u0000\u0000\u055c\u055e\u00030\u0018"+ + "\u0000\u055d\u055c\u0001\u0000\u0000\u0000\u055d\u055e\u0001\u0000\u0000"+ + "\u0000\u055e\u055f\u0001\u0000\u0000\u0000\u055f\u0566\u0003\u00c8d\u0000"+ + "\u0560\u0562\u0005\u00c1\u0000\u0000\u0561\u0563\u0007\f\u0000\u0000\u0562"+ + "\u0561\u0001\u0000\u0000\u0000\u0562\u0563\u0001\u0000\u0000\u0000\u0563"+ + "\u0564\u0001\u0000\u0000\u0000\u0564\u0565\u0005\u001b\u0000\u0000\u0565"+ + "\u0567\u0005y\u0000\u0000\u0566\u0560\u0001\u0000\u0000\u0000\u0566\u0567"+ + "\u0001\u0000\u0000\u0000\u0567\u0569\u0001\u0000\u0000\u0000\u0568\u0555"+ + "\u0001\u0000\u0000\u0000\u0568\u055d\u0001\u0000\u0000\u0000\u05699\u0001"+ + "\u0000\u0000\u0000\u056a\u056c\u0005+\u0000\u0000\u056b\u056a\u0001\u0000"+ + "\u0000\u0000\u056b\u056c\u0001\u0000\u0000\u0000\u056c\u056d\u0001\u0000"+ + "\u0000\u0000\u056d\u056f\u0003<\u001e\u0000\u056e\u0570\u0005\u0465\u0000"+ + "\u0000\u056f\u056e\u0001\u0000\u0000\u0000\u056f\u0570\u0001\u0000\u0000"+ + "\u0000\u0570\u0573\u0001\u0000\u0000\u0000\u0571\u0574\u0003\u0238\u011c"+ + "\u0000\u0572\u0574\u0005+\u0000\u0000\u0573\u0571\u0001\u0000\u0000\u0000"+ + "\u0573\u0572\u0001\u0000\u0000\u0000\u0574\u058c\u0001\u0000\u0000\u0000"+ + "\u0575\u0577\u0005+\u0000\u0000\u0576\u0575\u0001\u0000\u0000\u0000\u0576"+ + "\u0577\u0001\u0000\u0000\u0000\u0577\u0578\u0001\u0000\u0000\u0000\u0578"+ + "\u057a\u0005\u001c\u0000\u0000\u0579\u057b\u0005\u0465\u0000\u0000\u057a"+ + "\u0579\u0001\u0000\u0000\u0000\u057a\u057b\u0001\u0000\u0000\u0000\u057b"+ + "\u057c\u0001\u0000\u0000\u0000\u057c\u058c\u0003\u023a\u011d\u0000\u057d"+ + "\u057f\u0005+\u0000\u0000\u057e\u057d\u0001\u0000\u0000\u0000\u057e\u057f"+ + "\u0001\u0000\u0000\u0000\u057f\u0580\u0001\u0000\u0000\u0000\u0580\u0582"+ + "\u0005\u0196\u0000\u0000\u0581\u0583\u0005\u0465\u0000\u0000\u0582\u0581"+ + "\u0001\u0000\u0000\u0000\u0582\u0583\u0001\u0000\u0000\u0000\u0583\u0584"+ + "\u0001\u0000\u0000\u0000\u0584\u058c\u0005\u047d\u0000\u0000\u0585\u0586"+ + "\u0005\u0087\u0000\u0000\u0586\u0588\u0005\u021b\u0000\u0000\u0587\u0589"+ + "\u0005\u0465\u0000\u0000\u0588\u0587\u0001\u0000\u0000\u0000\u0588\u0589"+ + "\u0001\u0000\u0000\u0000\u0589\u058a\u0001\u0000\u0000\u0000\u058a\u058c"+ + "\u0007\r\u0000\u0000\u058b\u056b\u0001\u0000\u0000\u0000\u058b\u0576\u0001"+ + "\u0000\u0000\u0000\u058b\u057e\u0001\u0000\u0000\u0000\u058b\u0585\u0001"+ + "\u0000\u0000\u0000\u058c;\u0001\u0000\u0000\u0000\u058d\u058e\u0005\u001a"+ + "\u0000\u0000\u058e\u0593\u0005\u009a\u0000\u0000\u058f\u0593\u0005\u034a"+ + "\u0000\u0000\u0590\u0591\u0005\u00df\u0000\u0000\u0591\u0593\u0005\u009a"+ + "\u0000\u0000\u0592\u058d\u0001\u0000\u0000\u0000\u0592\u058f\u0001\u0000"+ + "\u0000\u0000\u0592\u0590\u0001\u0000\u0000\u0000\u0593=\u0001\u0000\u0000"+ + "\u0000\u0594\u0597\u0005&\u0000\u0000\u0595\u0596\u0005\u046e\u0000\u0000"+ + "\u0596\u0598\u0005\u046f\u0000\u0000\u0597\u0595\u0001\u0000\u0000\u0000"+ + "\u0597\u0598\u0001\u0000\u0000\u0000\u0598?\u0001\u0000\u0000\u0000\u0599"+ + "\u059a\u0005\u0189\u0000\u0000\u059a\u059d\u0005\u0465\u0000\u0000\u059b"+ + "\u059e\u0003\u0234\u011a\u0000\u059c\u059e\u0003>\u001f\u0000\u059d\u059b"+ + "\u0001\u0000\u0000\u0000\u059d\u059c\u0001\u0000\u0000\u0000\u059eA\u0001"+ + "\u0000\u0000\u0000\u059f\u05a0\u0005\u0153\u0000\u0000\u05a0\u05a4\u0003"+ + "D\"\u0000\u05a1\u05a3\u0003F#\u0000\u05a2\u05a1\u0001\u0000\u0000\u0000"+ + "\u05a3\u05a6\u0001\u0000\u0000\u0000\u05a4\u05a2\u0001\u0000\u0000\u0000"+ + "\u05a4\u05a5\u0001\u0000\u0000\u0000\u05a5\u05c2\u0001\u0000\u0000\u0000"+ + "\u05a6\u05a4\u0001\u0000\u0000\u0000\u05a7\u05aa\u0005\u01a2\u0000\u0000"+ + "\u05a8\u05ab\u0003\u024e\u0127\u0000\u05a9\u05ab\u0003\u02b0\u0158\u0000"+ + "\u05aa\u05a8\u0001\u0000\u0000\u0000\u05aa\u05a9\u0001\u0000\u0000\u0000"+ + "\u05ab\u05ac\u0001\u0000\u0000\u0000\u05ac\u05b5\u0003H$\u0000\u05ad\u05ae"+ + "\u0005\u0277\u0000\u0000\u05ae\u05b2\u0003D\"\u0000\u05af\u05b1\u0003"+ + "F#\u0000\u05b0\u05af\u0001\u0000\u0000\u0000\u05b1\u05b4\u0001\u0000\u0000"+ + "\u0000\u05b2\u05b0\u0001\u0000\u0000\u0000\u05b2\u05b3\u0001\u0000\u0000"+ + "\u0000\u05b3\u05b6\u0001\u0000\u0000\u0000\u05b4\u05b2\u0001\u0000\u0000"+ + "\u0000\u05b5\u05ad\u0001\u0000\u0000\u0000\u05b5\u05b6\u0001\u0000\u0000"+ + "\u0000\u05b6\u05bf\u0001\u0000\u0000\u0000\u05b7\u05b8\u0005\u0199\u0000"+ + "\u0000\u05b8\u05bc\u0003D\"\u0000\u05b9\u05bb\u0003F#\u0000\u05ba\u05b9"+ + "\u0001\u0000\u0000\u0000\u05bb\u05be\u0001\u0000\u0000\u0000\u05bc\u05ba"+ + "\u0001\u0000\u0000\u0000\u05bc\u05bd\u0001\u0000\u0000\u0000\u05bd\u05c0"+ + "\u0001\u0000\u0000\u0000\u05be\u05bc\u0001\u0000\u0000\u0000\u05bf\u05b7"+ + "\u0001\u0000\u0000\u0000\u05bf\u05c0\u0001\u0000\u0000\u0000\u05c0\u05c2"+ + "\u0001\u0000\u0000\u0000\u05c1\u059f\u0001\u0000\u0000\u0000\u05c1\u05a7"+ + "\u0001\u0000\u0000\u0000\u05c2C\u0001\u0000\u0000\u0000\u05c3\u05c8\u0005"+ + "\u013c\u0000\u0000\u05c4\u05c8\u0003\u0252\u0129\u0000\u05c5\u05c8\u0003"+ + "\u024e\u0127\u0000\u05c6\u05c8\u0003\u02b0\u0158\u0000\u05c7\u05c3\u0001"+ + "\u0000\u0000\u0000\u05c7\u05c4\u0001\u0000\u0000\u0000\u05c7\u05c5\u0001"+ + "\u0000\u0000\u0000\u05c7\u05c6\u0001\u0000\u0000\u0000\u05c8E\u0001\u0000"+ + "\u0000\u0000\u05c9\u05ca\u0005\u0461\u0000\u0000\u05ca\u05cd\u0005W\u0000"+ + "\u0000\u05cb\u05ce\u0003\u024e\u0127\u0000\u05cc\u05ce\u0003\u02b0\u0158"+ + "\u0000\u05cd\u05cb\u0001\u0000\u0000\u0000\u05cd\u05cc\u0001\u0000\u0000"+ + "\u0000\u05ce\u05cf\u0001\u0000\u0000\u0000\u05cf\u05d0\u0003H$\u0000\u05d0"+ + "G\u0001\u0000\u0000\u0000\u05d1\u05df\u0003\u02ca\u0165\u0000\u05d2\u05df"+ + "\u0005\u00de\u0000\u0000\u05d3\u05df\u0005\u00f1\u0000\u0000\u05d4\u05df"+ + "\u0005\u00f2\u0000\u0000\u05d5\u05df\u0005\u00f3\u0000\u0000\u05d6\u05df"+ + "\u0005\u00f4\u0000\u0000\u05d7\u05df\u0005\u00f5\u0000\u0000\u05d8\u05df"+ + "\u0005\u00f6\u0000\u0000\u05d9\u05df\u0005\u00f7\u0000\u0000\u05da\u05df"+ + "\u0005\u00f8\u0000\u0000\u05db\u05df\u0005\u00f9\u0000\u0000\u05dc\u05df"+ + "\u0005\u00fa\u0000\u0000\u05dd\u05df\u0005\u00fb\u0000\u0000\u05de\u05d1"+ + "\u0001\u0000\u0000\u0000\u05de\u05d2\u0001\u0000\u0000\u0000\u05de\u05d3"+ + "\u0001\u0000\u0000\u0000\u05de\u05d4\u0001\u0000\u0000\u0000\u05de\u05d5"+ + "\u0001\u0000\u0000\u0000\u05de\u05d6\u0001\u0000\u0000\u0000\u05de\u05d7"+ + "\u0001\u0000\u0000\u0000\u05de\u05d8\u0001\u0000\u0000\u0000\u05de\u05d9"+ + "\u0001\u0000\u0000\u0000\u05de\u05da\u0001\u0000\u0000\u0000\u05de\u05db"+ + "\u0001\u0000\u0000\u0000\u05de\u05dc\u0001\u0000\u0000\u0000\u05de\u05dd"+ + "\u0001\u0000\u0000\u0000\u05dfI\u0001\u0000\u0000\u0000\u05e0\u05e6\u0005"+ + "\u0194\u0000\u0000\u05e1\u05e6\u0005\u018d\u0000\u0000\u05e2\u05e3\u0005"+ + "\u018d\u0000\u0000\u05e3\u05e4\u0005w\u0000\u0000\u05e4\u05e6\u0005\u0267"+ + "\u0000\u0000\u05e5\u05e0\u0001\u0000\u0000\u0000\u05e5\u05e1\u0001\u0000"+ + "\u0000\u0000\u05e5\u05e2\u0001\u0000\u0000\u0000\u05e6K\u0001\u0000\u0000"+ + "\u0000\u05e7\u05e8\u0005\u00bc\u0000\u0000\u05e8\u05e9\u0007\u000e\u0000"+ + "\u0000\u05e9M\u0001\u0000\u0000\u0000\u05ea\u05ec\u0005\u01d4\u0000\u0000"+ + "\u05eb\u05ed\u0005\u0465\u0000\u0000\u05ec\u05eb\u0001\u0000\u0000\u0000"+ + "\u05ec\u05ed\u0001\u0000\u0000\u0000\u05ed\u05ee\u0001\u0000\u0000\u0000"+ + "\u05ee\u0601\u0003\u0250\u0128\u0000\u05ef\u0601\u0003L&\u0000\u05f0\u05f1"+ + "\u0005\u00c1\u0000\u0000\u05f1\u05f2\u0005\u0224\u0000\u0000\u05f2\u0601"+ + "\u0003\u0248\u0124\u0000\u05f3\u05f4\u0005\u0171\u0000\u0000\u05f4\u0601"+ + "\u0005\u047d\u0000\u0000\u05f5\u0601\u0007\u000f\u0000\u0000\u05f6\u05f8"+ + "\u0005\u036c\u0000\u0000\u05f7\u05f9\u0005\u0465\u0000\u0000\u05f8\u05f7"+ + "\u0001\u0000\u0000\u0000\u05f8\u05f9\u0001\u0000\u0000\u0000\u05f9\u05fa"+ + "\u0001\u0000\u0000\u0000\u05fa\u0601\u0005\u047d\u0000\u0000\u05fb\u05fd"+ + "\u0005\u03e9\u0000\u0000\u05fc\u05fe\u0005\u0465\u0000\u0000\u05fd\u05fc"+ + "\u0001\u0000\u0000\u0000\u05fd\u05fe\u0001\u0000\u0000\u0000\u05fe\u05ff"+ + "\u0001\u0000\u0000\u0000\u05ff\u0601\u0005\u047d\u0000\u0000\u0600\u05ea"+ + "\u0001\u0000\u0000\u0000\u0600\u05ef\u0001\u0000\u0000\u0000\u0600\u05f0"+ + "\u0001\u0000\u0000\u0000\u0600\u05f3\u0001\u0000\u0000\u0000\u0600\u05f5"+ + "\u0001\u0000\u0000\u0000\u0600\u05f6\u0001\u0000\u0000\u0000\u0600\u05fb"+ + "\u0001\u0000\u0000\u0000\u0601O\u0001\u0000\u0000\u0000\u0602\u0604\u0007"+ + "\u0010\u0000\u0000\u0603\u0602\u0001\u0000\u0000\u0000\u0603\u0604\u0001"+ + "\u0000\u0000\u0000\u0604\u0605\u0001\u0000\u0000\u0000\u0605\u0606\u0003"+ + "\u0248\u0124\u0000\u0606\u0607\u0003\u025c\u012e\u0000\u0607Q\u0001\u0000"+ + "\u0000\u0000\u0608\u0609\u0003\u0248\u0124\u0000\u0609\u060a\u0003\u025c"+ + "\u012e\u0000\u060aS\u0001\u0000\u0000\u0000\u060b\u060c\u0005\u0171\u0000"+ + "\u0000\u060c\u0623\u0005\u047d\u0000\u0000\u060d\u060e\u0005\u01d5\u0000"+ + "\u0000\u060e\u0623\u0005\u00a1\u0000\u0000\u060f\u0611\u0005s\u0000\u0000"+ + "\u0610\u060f\u0001\u0000\u0000\u0000\u0610\u0611\u0001\u0000\u0000\u0000"+ + "\u0611\u0612\u0001\u0000\u0000\u0000\u0612\u0623\u00050\u0000\u0000\u0613"+ + "\u0614\u0005\u017e\u0000\u0000\u0614\u061e\u0005\u00a1\u0000\u0000\u0615"+ + "\u0616\u0005\u020a\u0000\u0000\u0616\u061e\u0005\u00a1\u0000\u0000\u0617"+ + "\u0618\u0005\u0088\u0000\u0000\u0618\u0619\u0005\u00a1\u0000\u0000\u0619"+ + "\u061e\u0005\u0185\u0000\u0000\u061a\u061b\u0005q\u0000\u0000\u061b\u061c"+ + "\u0005\u00a1\u0000\u0000\u061c\u061e\u0005\u0185\u0000\u0000\u061d\u0613"+ + "\u0001\u0000\u0000\u0000\u061d\u0615\u0001\u0000\u0000\u0000\u061d\u0617"+ + "\u0001\u0000\u0000\u0000\u061d\u061a\u0001\u0000\u0000\u0000\u061e\u0623"+ + "\u0001\u0000\u0000\u0000\u061f\u0620\u0005\u00a1\u0000\u0000\u0620\u0621"+ + "\u0005\u025f\u0000\u0000\u0621\u0623\u0007\u000b\u0000\u0000\u0622\u060b"+ + "\u0001\u0000\u0000\u0000\u0622\u060d\u0001\u0000\u0000\u0000\u0622\u0610"+ + "\u0001\u0000\u0000\u0000\u0622\u061d\u0001\u0000\u0000\u0000\u0622\u061f"+ + "\u0001\u0000\u0000\u0000\u0623U\u0001\u0000\u0000\u0000\u0624\u0625\u0005"+ + "\u01bf\u0000\u0000\u0625\u0633\u0005\u047d\u0000\u0000\u0626\u0627\u0005"+ + "(\u0000\u0000\u0627\u0633\u0005\u047d\u0000\u0000\u0628\u0629\u0005\u029a"+ + "\u0000\u0000\u0629\u0633\u0005\u047d\u0000\u0000\u062a\u062b\u0005\u0228"+ + "\u0000\u0000\u062b\u0633\u0005\u047d\u0000\u0000\u062c\u062d\u0005\u026a"+ + "\u0000\u0000\u062d\u0633\u0005\u047d\u0000\u0000\u062e\u062f\u0005\u021f"+ + "\u0000\u0000\u062f\u0633\u0005\u047d\u0000\u0000\u0630\u0631\u0005\u022e"+ + "\u0000\u0000\u0631\u0633\u0003\u024e\u0127\u0000\u0632\u0624\u0001\u0000"+ + "\u0000\u0000\u0632\u0626\u0001\u0000\u0000\u0000\u0632\u0628\u0001\u0000"+ + "\u0000\u0000\u0632\u062a\u0001\u0000\u0000\u0000\u0632\u062c\u0001\u0000"+ + "\u0000\u0000\u0632\u062e\u0001\u0000\u0000\u0000\u0632\u0630\u0001\u0000"+ + "\u0000\u0000\u0633W\u0001\u0000\u0000\u0000\u0634\u0635\u0005\u046e\u0000"+ + "\u0000\u0635\u063a\u0003Z-\u0000\u0636\u0637\u0005\u0470\u0000\u0000\u0637"+ + "\u0639\u0003Z-\u0000\u0638\u0636\u0001\u0000\u0000\u0000\u0639\u063c\u0001"+ + "\u0000\u0000\u0000\u063a\u0638\u0001\u0000\u0000\u0000\u063a\u063b\u0001"+ + "\u0000\u0000\u0000\u063b\u063d\u0001\u0000\u0000\u0000\u063c\u063a\u0001"+ + "\u0000\u0000\u0000\u063d\u063e\u0005\u046f\u0000\u0000\u063eY\u0001\u0000"+ + "\u0000\u0000\u063f\u0640\u0003\u022c\u0116\u0000\u0640\u0641\u0003\\."+ + "\u0000\u0641\u064b\u0001\u0000\u0000\u0000\u0642\u0644\u0003`0\u0000\u0643"+ + "\u0645\u0005s\u0000\u0000\u0644\u0643\u0001\u0000\u0000\u0000\u0644\u0645"+ + "\u0001\u0000\u0000\u0000\u0645\u0647\u0001\u0000\u0000\u0000\u0646\u0648"+ + "\u0005:\u0000\u0000\u0647\u0646\u0001\u0000\u0000\u0000\u0647\u0648\u0001"+ + "\u0000\u0000\u0000\u0648\u064b\u0001\u0000\u0000\u0000\u0649\u064b\u0003"+ + "h4\u0000\u064a\u063f\u0001\u0000\u0000\u0000\u064a\u0642\u0001\u0000\u0000"+ + "\u0000\u064a\u0649\u0001\u0000\u0000\u0000\u064b[\u0001\u0000\u0000\u0000"+ + "\u064c\u0650\u0003\u025c\u012e\u0000\u064d\u064f\u0003^/\u0000\u064e\u064d"+ + "\u0001\u0000\u0000\u0000\u064f\u0652\u0001\u0000\u0000\u0000\u0650\u064e"+ + "\u0001\u0000\u0000\u0000\u0650\u0651\u0001\u0000\u0000\u0000\u0651\u0654"+ + "\u0001\u0000\u0000\u0000\u0652\u0650\u0001\u0000\u0000\u0000\u0653\u0655"+ + "\u0005s\u0000\u0000\u0654\u0653\u0001\u0000\u0000\u0000\u0654\u0655\u0001"+ + "\u0000\u0000\u0000\u0655\u0657\u0001\u0000\u0000\u0000\u0656\u0658\u0005"+ + ":\u0000\u0000\u0657\u0656\u0001\u0000\u0000\u0000\u0657\u0658\u0001\u0000"+ + "\u0000\u0000\u0658]\u0001\u0000\u0000\u0000\u0659\u068f\u0003\u0258\u012c"+ + "\u0000\u065a\u065b\u0005+\u0000\u0000\u065b\u068f\u0003\u027a\u013d\u0000"+ + "\u065c\u068f\u0005\u02a2\u0000\u0000\u065d\u068f\u0005\u01cc\u0000\u0000"+ + "\u065e\u0663\u0005\u0157\u0000\u0000\u065f\u0660\u0005w\u0000\u0000\u0660"+ + "\u0661\u0005\u00b9\u0000\u0000\u0661\u0663\u0003\u027c\u013e\u0000\u0662"+ + "\u065e\u0001\u0000\u0000\u0000\u0662\u065f\u0001\u0000\u0000\u0000\u0663"+ + "\u068f\u0001\u0000\u0000\u0000\u0664\u0666\u0005\u0083\u0000\u0000\u0665"+ + "\u0664\u0001\u0000\u0000\u0000\u0665\u0666\u0001\u0000\u0000\u0000\u0666"+ + "\u0667\u0001\u0000\u0000\u0000\u0667\u068f\u0005\\\u0000\u0000\u0668\u066a"+ + "\u0005\u00b6\u0000\u0000\u0669\u066b\u0005\\\u0000\u0000\u066a\u0669\u0001"+ + "\u0000\u0000\u0000\u066a\u066b\u0001\u0000\u0000\u0000\u066b\u068f\u0001"+ + "\u0000\u0000\u0000\u066c\u066d\u0005\u0171\u0000\u0000\u066d\u068f\u0005"+ + "\u047d\u0000\u0000\u066e\u066f\u0005\u016f\u0000\u0000\u066f\u068f\u0007"+ + "\u0011\u0000\u0000\u0670\u0671\u0005\u027d\u0000\u0000\u0671\u068f\u0007"+ + "\u0012\u0000\u0000\u0672\u068f\u0003b1\u0000\u0673\u0674\u0005\u001c\u0000"+ + "\u0000\u0674\u068f\u0003\u023a\u011d\u0000\u0675\u0676\u0005G\u0000\u0000"+ + "\u0676\u0678\u0005\t\u0000\u0000\u0677\u0675\u0001\u0000\u0000\u0000\u0677"+ + "\u0678\u0001\u0000\u0000\u0000\u0678\u0679\u0001\u0000\u0000\u0000\u0679"+ + "\u067a\u0005\r\u0000\u0000\u067a\u067b\u0005\u046e\u0000\u0000\u067b\u067c"+ + "\u0003\u02b0\u0158\u0000\u067c\u067e\u0005\u046f\u0000\u0000\u067d\u067f"+ + "\u0007\u0013\u0000\u0000\u067e\u067d\u0001\u0000\u0000\u0000\u067e\u067f"+ + "\u0001\u0000\u0000\u0000\u067f\u068f\u0001\u0000\u0000\u0000\u0680\u0681"+ + "\u0005\u00f0\u0000\u0000\u0681\u0682\u0005+\u0000\u0000\u0682\u068f\u0005"+ + "\u029e\u0000\u0000\u0683\u0685\u0005\u001f\u0000\u0000\u0684\u0686\u0003"+ + "\u0248\u0124\u0000\u0685\u0684\u0001\u0000\u0000\u0000\u0685\u0686\u0001"+ + "\u0000\u0000\u0000\u0686\u0688\u0001\u0000\u0000\u0000\u0687\u0683\u0001"+ + "\u0000\u0000\u0000\u0687\u0688\u0001\u0000\u0000\u0000\u0688\u0689\u0001"+ + "\u0000\u0000\u0000\u0689\u068a\u0005\u001b\u0000\u0000\u068a\u068b\u0005"+ + "\u046e\u0000\u0000\u068b\u068c\u0003\u02b0\u0158\u0000\u068c\u068d\u0005"+ + "\u046f\u0000\u0000\u068d\u068f\u0001\u0000\u0000\u0000\u068e\u0659\u0001"+ + "\u0000\u0000\u0000\u068e\u065a\u0001\u0000\u0000\u0000\u068e\u065c\u0001"+ + "\u0000\u0000\u0000\u068e\u065d\u0001\u0000\u0000\u0000\u068e\u0662\u0001"+ + "\u0000\u0000\u0000\u068e\u0665\u0001\u0000\u0000\u0000\u068e\u0668\u0001"+ + "\u0000\u0000\u0000\u068e\u066c\u0001\u0000\u0000\u0000\u068e\u066e\u0001"+ + "\u0000\u0000\u0000\u068e\u0670\u0001\u0000\u0000\u0000\u068e\u0672\u0001"+ + "\u0000\u0000\u0000\u068e\u0673\u0001\u0000\u0000\u0000\u068e\u0677\u0001"+ + "\u0000\u0000\u0000\u068e\u0680\u0001\u0000\u0000\u0000\u068e\u0687\u0001"+ + "\u0000\u0000\u0000\u068f_\u0001\u0000\u0000\u0000\u0690\u0692\u0005\u001f"+ + "\u0000\u0000\u0691\u0693\u0003\u0248\u0124\u0000\u0692\u0691\u0001\u0000"+ + "\u0000\u0000\u0692\u0693\u0001\u0000\u0000\u0000\u0693\u0695\u0001\u0000"+ + "\u0000\u0000\u0694\u0690\u0001\u0000\u0000\u0000\u0694\u0695\u0001\u0000"+ + "\u0000\u0000\u0695\u0696\u0001\u0000\u0000\u0000\u0696\u0697\u0005\u0083"+ + "\u0000\u0000\u0697\u0699\u0005\\\u0000\u0000\u0698\u069a\u0003\u0248\u0124"+ + "\u0000\u0699\u0698\u0001\u0000\u0000\u0000\u0699\u069a\u0001\u0000\u0000"+ + "\u0000\u069a\u069c\u0001\u0000\u0000\u0000\u069b\u069d\u0003L&\u0000\u069c"+ + "\u069b\u0001\u0000\u0000\u0000\u069c\u069d\u0001\u0000\u0000\u0000\u069d"+ + "\u069e\u0001\u0000\u0000\u0000\u069e\u06a2\u0003\u026e\u0137\u0000\u069f"+ + "\u06a1\u0003N\'\u0000\u06a0\u069f\u0001\u0000\u0000\u0000\u06a1\u06a4"+ + "\u0001\u0000\u0000\u0000\u06a2\u06a0\u0001\u0000\u0000\u0000\u06a2\u06a3"+ + "\u0001\u0000\u0000\u0000\u06a3\u06d6\u0001\u0000\u0000\u0000\u06a4\u06a2"+ + "\u0001\u0000\u0000\u0000\u06a5\u06a7\u0005\u001f\u0000\u0000\u06a6\u06a8"+ + "\u0003\u0248\u0124\u0000\u06a7\u06a6\u0001\u0000\u0000\u0000\u06a7\u06a8"+ + "\u0001\u0000\u0000\u0000\u06a8\u06aa\u0001\u0000\u0000\u0000\u06a9\u06a5"+ + "\u0001\u0000\u0000\u0000\u06a9\u06aa\u0001\u0000\u0000\u0000\u06aa\u06ab"+ + "\u0001\u0000\u0000\u0000\u06ab\u06ad\u0005\u00b6\u0000\u0000\u06ac\u06ae"+ + "\u0007\u0014\u0000\u0000\u06ad\u06ac\u0001\u0000\u0000\u0000\u06ad\u06ae"+ + "\u0001\u0000\u0000\u0000\u06ae\u06b0\u0001\u0000\u0000\u0000\u06af\u06b1"+ + "\u0003\u0248\u0124\u0000\u06b0\u06af\u0001\u0000\u0000\u0000\u06b0\u06b1"+ + "\u0001\u0000\u0000\u0000\u06b1\u06b3\u0001\u0000\u0000\u0000\u06b2\u06b4"+ + "\u0003L&\u0000\u06b3\u06b2\u0001\u0000\u0000\u0000\u06b3\u06b4\u0001\u0000"+ + "\u0000\u0000\u06b4\u06b5\u0001\u0000\u0000\u0000\u06b5\u06b9\u0003\u026e"+ + "\u0137\u0000\u06b6\u06b8\u0003N\'\u0000\u06b7\u06b6\u0001\u0000\u0000"+ + "\u0000\u06b8\u06bb\u0001\u0000\u0000\u0000\u06b9\u06b7\u0001\u0000\u0000"+ + "\u0000\u06b9\u06ba\u0001\u0000\u0000\u0000\u06ba\u06d6\u0001\u0000\u0000"+ + "\u0000\u06bb\u06b9\u0001\u0000\u0000\u0000\u06bc\u06be\u0005\u001f\u0000"+ + "\u0000\u06bd\u06bf\u0003\u0248\u0124\u0000\u06be\u06bd\u0001\u0000\u0000"+ + "\u0000\u06be\u06bf\u0001\u0000\u0000\u0000\u06bf\u06c1\u0001\u0000\u0000"+ + "\u0000\u06c0\u06bc\u0001\u0000\u0000\u0000\u06c0\u06c1\u0001\u0000\u0000"+ + "\u0000\u06c1\u06c2\u0001\u0000\u0000\u0000\u06c2\u06c3\u0005D\u0000\u0000"+ + "\u06c3\u06c5\u0005\\\u0000\u0000\u06c4\u06c6\u0003\u0248\u0124\u0000\u06c5"+ + "\u06c4\u0001\u0000\u0000\u0000\u06c5\u06c6\u0001\u0000\u0000\u0000\u06c6"+ + "\u06c7\u0001\u0000\u0000\u0000\u06c7\u06c8\u0003\u026e\u0137\u0000\u06c8"+ + "\u06c9\u0003b1\u0000\u06c9\u06d6\u0001\u0000\u0000\u0000\u06ca\u06cc\u0005"+ + "\u001f\u0000\u0000\u06cb\u06cd\u0003\u0248\u0124\u0000\u06cc\u06cb\u0001"+ + "\u0000\u0000\u0000\u06cc\u06cd\u0001\u0000\u0000\u0000\u06cd\u06cf\u0001"+ + "\u0000\u0000\u0000\u06ce\u06ca\u0001\u0000\u0000\u0000\u06ce\u06cf\u0001"+ + "\u0000\u0000\u0000\u06cf\u06d0\u0001\u0000\u0000\u0000\u06d0\u06d1\u0005"+ + "\u001b\u0000\u0000\u06d1\u06d2\u0005\u046e\u0000\u0000\u06d2\u06d3\u0003"+ + "\u02b0\u0158\u0000\u06d3\u06d4\u0005\u046f\u0000\u0000\u06d4\u06d6\u0001"+ + "\u0000\u0000\u0000\u06d5\u0694\u0001\u0000\u0000\u0000\u06d5\u06a9\u0001"+ + "\u0000\u0000\u0000\u06d5\u06c0\u0001\u0000\u0000\u0000\u06d5\u06ce\u0001"+ + "\u0000\u0000\u0000\u06d6a\u0001\u0000\u0000\u0000\u06d7\u06d8\u0005\u0089"+ + "\u0000\u0000\u06d8\u06da\u0003\u0228\u0114\u0000\u06d9\u06db\u0003\u026e"+ + "\u0137\u0000\u06da\u06d9\u0001\u0000\u0000\u0000\u06da\u06db\u0001\u0000"+ + "\u0000\u0000\u06db\u06de\u0001\u0000\u0000\u0000\u06dc\u06dd\u0005n\u0000"+ + "\u0000\u06dd\u06df\u0007\u0015\u0000\u0000\u06de\u06dc\u0001\u0000\u0000"+ + "\u0000\u06de\u06df\u0001\u0000\u0000\u0000\u06df\u06e1\u0001\u0000\u0000"+ + "\u0000\u06e0\u06e2\u0003d2\u0000\u06e1\u06e0\u0001\u0000\u0000\u0000\u06e1"+ + "\u06e2\u0001\u0000\u0000\u0000\u06e2c\u0001\u0000\u0000\u0000\u06e3\u06e4"+ + "\u0005w\u0000\u0000\u06e4\u06e5\u0005-\u0000\u0000\u06e5\u06e9\u0003f"+ + "3\u0000\u06e6\u06e7\u0005w\u0000\u0000\u06e7\u06e8\u0005\u00b9\u0000\u0000"+ + "\u06e8\u06ea\u0003f3\u0000\u06e9\u06e6\u0001\u0000\u0000\u0000\u06e9\u06ea"+ + "\u0001\u0000\u0000\u0000\u06ea\u06f4\u0001\u0000\u0000\u0000\u06eb\u06ec"+ + "\u0005w\u0000\u0000\u06ec\u06ed\u0005\u00b9\u0000\u0000\u06ed\u06f1\u0003"+ + "f3\u0000\u06ee\u06ef\u0005w\u0000\u0000\u06ef\u06f0\u0005-\u0000\u0000"+ + "\u06f0\u06f2\u0003f3\u0000\u06f1\u06ee\u0001\u0000\u0000\u0000\u06f1\u06f2"+ + "\u0001\u0000\u0000\u0000\u06f2\u06f4\u0001\u0000\u0000\u0000\u06f3\u06e3"+ + "\u0001\u0000\u0000\u0000\u06f3\u06eb\u0001\u0000\u0000\u0000\u06f4e\u0001"+ + "\u0000\u0000\u0000\u06f5\u06fe\u0005\u0091\u0000\u0000\u06f6\u06fe\u0005"+ + "\u0016\u0000\u0000\u06f7\u06f8\u0005\u009a\u0000\u0000\u06f8\u06fe\u0005"+ + "u\u0000\u0000\u06f9\u06fa\u0005\u020a\u0000\u0000\u06fa\u06fe\u0005\u014e"+ + "\u0000\u0000\u06fb\u06fc\u0005\u009a\u0000\u0000\u06fc\u06fe\u0005+\u0000"+ + "\u0000\u06fd\u06f5\u0001\u0000\u0000\u0000\u06fd\u06f6\u0001\u0000\u0000"+ + "\u0000\u06fd\u06f7\u0001\u0000\u0000\u0000\u06fd\u06f9\u0001\u0000\u0000"+ + "\u0000\u06fd\u06fb\u0001\u0000\u0000\u0000\u06feg\u0001\u0000\u0000\u0000"+ + "\u06ff\u0701\u0007\u0014\u0000\u0000\u0700\u0702\u0003\u0248\u0124\u0000"+ + "\u0701\u0700\u0001\u0000\u0000\u0000\u0701\u0702\u0001\u0000\u0000\u0000"+ + "\u0702\u0704\u0001\u0000\u0000\u0000\u0703\u0705\u0003L&\u0000\u0704\u0703"+ + "\u0001\u0000\u0000\u0000\u0704\u0705\u0001\u0000\u0000\u0000\u0705\u0706"+ + "\u0001\u0000\u0000\u0000\u0706\u070a\u0003\u026e\u0137\u0000\u0707\u0709"+ + "\u0003N\'\u0000\u0708\u0707\u0001\u0000\u0000\u0000\u0709\u070c\u0001"+ + "\u0000\u0000\u0000\u070a\u0708\u0001\u0000\u0000\u0000\u070a\u070b\u0001"+ + "\u0000\u0000\u0000\u070b\u071c\u0001\u0000\u0000\u0000\u070c\u070a\u0001"+ + "\u0000\u0000\u0000\u070d\u070f\u0007\u0016\u0000\u0000\u070e\u0710\u0007"+ + "\u0014\u0000\u0000\u070f\u070e\u0001\u0000\u0000\u0000\u070f\u0710\u0001"+ + "\u0000\u0000\u0000\u0710\u0712\u0001\u0000\u0000\u0000\u0711\u0713\u0003"+ + "\u0248\u0124\u0000\u0712\u0711\u0001\u0000\u0000\u0000\u0712\u0713\u0001"+ + "\u0000\u0000\u0000\u0713\u0714\u0001\u0000\u0000\u0000\u0714\u0718\u0003"+ + "\u026e\u0137\u0000\u0715\u0717\u0003N\'\u0000\u0716\u0715\u0001\u0000"+ + "\u0000\u0000\u0717\u071a\u0001\u0000\u0000\u0000\u0718\u0716\u0001\u0000"+ + "\u0000\u0000\u0718\u0719\u0001\u0000\u0000\u0000\u0719\u071c\u0001\u0000"+ + "\u0000\u0000\u071a\u0718\u0001\u0000\u0000\u0000\u071b\u06ff\u0001\u0000"+ + "\u0000\u0000\u071b\u070d\u0001\u0000\u0000\u0000\u071ci\u0001\u0000\u0000"+ + "\u0000\u071d\u071f\u0005\u019a\u0000\u0000\u071e\u0720\u0005\u0465\u0000"+ + "\u0000\u071f\u071e\u0001\u0000\u0000\u0000\u071f\u0720\u0001\u0000\u0000"+ + "\u0000\u0720\u0722\u0001\u0000\u0000\u0000\u0721\u0723\u0003\u023c\u011e"+ + "\u0000\u0722\u0721\u0001\u0000\u0000\u0000\u0722\u0723\u0001\u0000\u0000"+ + "\u0000\u0723\u07d7\u0001\u0000\u0000\u0000\u0724\u0726\u0005\u036c\u0000"+ + "\u0000\u0725\u0727\u0005\u0465\u0000\u0000\u0726\u0725\u0001\u0000\u0000"+ + "\u0000\u0726\u0727\u0001\u0000\u0000\u0000\u0727\u0728\u0001\u0000\u0000"+ + "\u0000\u0728\u07d7\u0005\u047d\u0000\u0000\u0729\u072b\u0005\u0156\u0000"+ + "\u0000\u072a\u072c\u0005\u0465\u0000\u0000\u072b\u072a\u0001\u0000\u0000"+ + "\u0000\u072b\u072c\u0001\u0000\u0000\u0000\u072c\u072d\u0001\u0000\u0000"+ + "\u0000\u072d\u07d7\u0003\u024e\u0127\u0000\u072e\u0730\u0005\u0157\u0000"+ + "\u0000\u072f\u0731\u0005\u0465\u0000\u0000\u0730\u072f\u0001\u0000\u0000"+ + "\u0000\u0730\u0731\u0001\u0000\u0000\u0000\u0731\u0732\u0001\u0000\u0000"+ + "\u0000\u0732\u07d7\u0003\u024e\u0127\u0000\u0733\u0735\u0005\u0158\u0000"+ + "\u0000\u0734\u0736\u0005\u0465\u0000\u0000\u0735\u0734\u0001\u0000\u0000"+ + "\u0000\u0735\u0736\u0001\u0000\u0000\u0000\u0736\u0737\u0001\u0000\u0000"+ + "\u0000\u0737\u07d7\u0003\u024e\u0127\u0000\u0738\u073a\u0005+\u0000\u0000"+ + "\u0739\u0738\u0001\u0000\u0000\u0000\u0739\u073a\u0001\u0000\u0000\u0000"+ + "\u073a\u073b\u0001\u0000\u0000\u0000\u073b\u073d\u0003<\u001e\u0000\u073c"+ + "\u073e\u0005\u0465\u0000\u0000\u073d\u073c\u0001\u0000\u0000\u0000\u073d"+ + "\u073e\u0001\u0000\u0000\u0000\u073e\u0741\u0001\u0000\u0000\u0000\u073f"+ + "\u0742\u0003\u0238\u011c\u0000\u0740\u0742\u0005+\u0000\u0000\u0741\u073f"+ + "\u0001\u0000\u0000\u0000\u0741\u0740\u0001\u0000\u0000\u0000\u0742\u07d7"+ + "\u0001\u0000\u0000\u0000\u0743\u0745\u0007\u0017\u0000\u0000\u0744\u0746"+ + "\u0005\u0465\u0000\u0000\u0745\u0744\u0001\u0000\u0000\u0000\u0745\u0746"+ + "\u0001\u0000\u0000\u0000\u0746\u0747\u0001\u0000\u0000\u0000\u0747\u07d7"+ + "\u0007\u0018\u0000\u0000\u0748\u074a\u0005+\u0000\u0000\u0749\u0748\u0001"+ + "\u0000\u0000\u0000\u0749\u074a\u0001\u0000\u0000\u0000\u074a\u074b\u0001"+ + "\u0000\u0000\u0000\u074b\u074d\u0005\u001c\u0000\u0000\u074c\u074e\u0005"+ + "\u0465\u0000\u0000\u074d\u074c\u0001\u0000\u0000\u0000\u074d\u074e\u0001"+ + "\u0000\u0000\u0000\u074e\u074f\u0001\u0000\u0000\u0000\u074f\u07d7\u0003"+ + "\u023a\u011d\u0000\u0750\u0752\u0005\u0171\u0000\u0000\u0751\u0753\u0005"+ + "\u0465\u0000\u0000\u0752\u0751\u0001\u0000\u0000\u0000\u0752\u0753\u0001"+ + "\u0000\u0000\u0000\u0753\u0754\u0001\u0000\u0000\u0000\u0754\u07d7\u0005"+ + "\u047d\u0000\u0000\u0755\u0757\u0005\u0176\u0000\u0000\u0756\u0758\u0005"+ + "\u0465\u0000\u0000\u0757\u0756\u0001\u0000\u0000\u0000\u0757\u0758\u0001"+ + "\u0000\u0000\u0000\u0758\u0759\u0001\u0000\u0000\u0000\u0759\u07d7\u0007"+ + "\u0019\u0000\u0000\u075a\u075c\u0005\u0179\u0000\u0000\u075b\u075d\u0005"+ + "\u0465\u0000\u0000\u075c\u075b\u0001\u0000\u0000\u0000\u075c\u075d\u0001"+ + "\u0000\u0000\u0000\u075d\u075e\u0001\u0000\u0000\u0000\u075e\u07d7\u0005"+ + "\u047d\u0000\u0000\u075f\u0760\u0007\u001a\u0000\u0000\u0760\u0762\u0005"+ + "\u018c\u0000\u0000\u0761\u0763\u0005\u0465\u0000\u0000\u0762\u0761\u0001"+ + "\u0000\u0000\u0000\u0762\u0763\u0001\u0000\u0000\u0000\u0763\u0764\u0001"+ + "\u0000\u0000\u0000\u0764\u07d7\u0005\u047d\u0000\u0000\u0765\u0767\u0005"+ + "\u018a\u0000\u0000\u0766\u0768\u0005\u0465\u0000\u0000\u0767\u0766\u0001"+ + "\u0000\u0000\u0000\u0767\u0768\u0001\u0000\u0000\u0000\u0768\u0769\u0001"+ + "\u0000\u0000\u0000\u0769\u07d7\u0007\u0018\u0000\u0000\u076a\u076c\u0005"+ + "\u0196\u0000\u0000\u076b\u076d\u0005\u0465\u0000\u0000\u076c\u076b\u0001"+ + "\u0000\u0000\u0000\u076c\u076d\u0001\u0000\u0000\u0000\u076d\u076e\u0001"+ + "\u0000\u0000\u0000\u076e\u07d7\u0005\u047d\u0000\u0000\u076f\u0771\u0007"+ + "\u001b\u0000\u0000\u0770\u0772\u0005\u0465\u0000\u0000\u0771\u0770\u0001"+ + "\u0000\u0000\u0000\u0771\u0772\u0001\u0000\u0000\u0000\u0772\u0773\u0001"+ + "\u0000\u0000\u0000\u0773\u07d7\u0007\u0018\u0000\u0000\u0774\u0776\u0007"+ + "\u001c\u0000\u0000\u0775\u0777\u0005\u0465\u0000\u0000\u0776\u0775\u0001"+ + "\u0000\u0000\u0000\u0776\u0777\u0001\u0000\u0000\u0000\u0777\u0778\u0001"+ + "\u0000\u0000\u0000\u0778\u07d7\u0003\u024e\u0127\u0000\u0779\u077b\u0005"+ + "\u0197\u0000\u0000\u077a\u077c\u0005\u0465\u0000\u0000\u077b\u077a\u0001"+ + "\u0000\u0000\u0000\u077b\u077c\u0001\u0000\u0000\u0000\u077c\u077d\u0001"+ + "\u0000\u0000\u0000\u077d\u07d7\u0003\u024e\u0127\u0000\u077e\u077f\u0005"+ + "R\u0000\u0000\u077f\u0781\u0005\u018c\u0000\u0000\u0780\u0782\u0005\u0465"+ + "\u0000\u0000\u0781\u0780\u0001\u0000\u0000\u0000\u0781\u0782\u0001\u0000"+ + "\u0000\u0000\u0782\u0783\u0001\u0000\u0000\u0000\u0783\u07d7\u0005\u047d"+ + "\u0000\u0000\u0784\u0786\u0005\u01c8\u0000\u0000\u0785\u0787\u0005\u0465"+ + "\u0000\u0000\u0786\u0785\u0001\u0000\u0000\u0000\u0786\u0787\u0001\u0000"+ + "\u0000\u0000\u0787\u0788\u0001\u0000\u0000\u0000\u0788\u07d7\u0007\u001d"+ + "\u0000\u0000\u0789\u078b\u0005\u01d4\u0000\u0000\u078a\u078c\u0005\u0465"+ + "\u0000\u0000\u078b\u078a\u0001\u0000\u0000\u0000\u078b\u078c\u0001\u0000"+ + "\u0000\u0000\u078c\u078d\u0001\u0000\u0000\u0000\u078d\u07d7\u0003\u0250"+ + "\u0128\u0000\u078e\u0790\u0005\u01f5\u0000\u0000\u078f\u0791\u0005\u0465"+ + "\u0000\u0000\u0790\u078f\u0001\u0000\u0000\u0000\u0790\u0791\u0001\u0000"+ + "\u0000\u0000\u0791\u0792\u0001\u0000\u0000\u0000\u0792\u07d7\u0003\u024e"+ + "\u0127\u0000\u0793\u0795\u0005\u01ff\u0000\u0000\u0794\u0796\u0005\u0465"+ + "\u0000\u0000\u0795\u0794\u0001\u0000\u0000\u0000\u0795\u0796\u0001\u0000"+ + "\u0000\u0000\u0796\u0797\u0001\u0000\u0000\u0000\u0797\u07d7\u0003\u024e"+ + "\u0127\u0000\u0798\u079a\u0005\u0220\u0000\u0000\u0799\u079b\u0005\u0465"+ + "\u0000\u0000\u079a\u0799\u0001\u0000\u0000\u0000\u079a\u079b\u0001\u0000"+ + "\u0000\u0000\u079b\u079c\u0001\u0000\u0000\u0000\u079c\u07d7\u0007\r\u0000"+ + "\u0000\u079d\u079f\u0005\u0228\u0000\u0000\u079e\u07a0\u0005\u0465\u0000"+ + "\u0000\u079f\u079e\u0001\u0000\u0000\u0000\u079f\u07a0\u0001\u0000\u0000"+ + "\u0000\u07a0\u07a1\u0001\u0000\u0000\u0000\u07a1\u07d7\u0005\u047d\u0000"+ + "\u0000\u07a2\u07a4\u0005\u025b\u0000\u0000\u07a3\u07a5\u0005\u0465\u0000"+ + "\u0000\u07a4\u07a3\u0001\u0000\u0000\u0000\u07a4\u07a5\u0001\u0000\u0000"+ + "\u0000\u07a5\u07a6\u0001\u0000\u0000\u0000\u07a6\u07d7\u0007\u001e\u0000"+ + "\u0000\u07a7\u07a8\u0005\u0276\u0000\u0000\u07a8\u07d7\u0005\u028e\u0000"+ + "\u0000\u07a9\u07ab\u0005\u03e9\u0000\u0000\u07aa\u07ac\u0005\u0465\u0000"+ + "\u0000\u07ab\u07aa\u0001\u0000\u0000\u0000\u07ab\u07ac\u0001\u0000\u0000"+ + "\u0000\u07ac\u07ad\u0001\u0000\u0000\u0000\u07ad\u07d7\u0005\u047d\u0000"+ + "\u0000\u07ae\u07b0\u0005\u0278\u0000\u0000\u07af\u07b1\u0005\u0465\u0000"+ + "\u0000\u07b0\u07af\u0001\u0000\u0000\u0000\u07b0\u07b1\u0001\u0000\u0000"+ + "\u0000\u07b1\u07b2\u0001\u0000\u0000\u0000\u07b2\u07d7\u0007\r\u0000\u0000"+ + "\u07b3\u07b5\u0005\u0279\u0000\u0000\u07b4\u07b6\u0005\u0465\u0000\u0000"+ + "\u07b5\u07b4\u0001\u0000\u0000\u0000\u07b5\u07b6\u0001\u0000\u0000\u0000"+ + "\u07b6\u07b7\u0001\u0000\u0000\u0000\u07b7\u07d7\u0007\r\u0000\u0000\u07b8"+ + "\u07ba\u0005\u027a\u0000\u0000\u07b9\u07bb\u0005\u0465\u0000\u0000\u07ba"+ + "\u07b9\u0001\u0000\u0000\u0000\u07ba\u07bb\u0001\u0000\u0000\u0000\u07bb"+ + "\u07be\u0001\u0000\u0000\u0000\u07bc\u07bf\u0005+\u0000\u0000\u07bd\u07bf"+ + "\u0003\u024e\u0127\u0000\u07be\u07bc\u0001\u0000\u0000\u0000\u07be\u07bd"+ + "\u0001\u0000\u0000\u0000\u07bf\u07d7\u0001\u0000\u0000\u0000\u07c0\u07c1"+ + "\u0005\u0288\u0000\u0000\u07c1\u07c3\u0003\u0248\u0124\u0000\u07c2\u07c4"+ + "\u0003n7\u0000\u07c3\u07c2\u0001\u0000\u0000\u0000\u07c3\u07c4\u0001\u0000"+ + "\u0000\u0000\u07c4\u07d7\u0001\u0000\u0000\u0000\u07c5\u07c6\u0005\u0289"+ + "\u0000\u0000\u07c6\u07c7\u0005\u0465\u0000\u0000\u07c7\u07d7\u0003l6\u0000"+ + "\u07c8\u07d7\u0003n7\u0000\u07c9\u07cb\u0005\u028f\u0000\u0000\u07ca\u07cc"+ + "\u0005\u0465\u0000\u0000\u07cb\u07ca\u0001\u0000\u0000\u0000\u07cb\u07cc"+ + "\u0001\u0000\u0000\u0000\u07cc\u07cd\u0001\u0000\u0000\u0000\u07cd\u07d7"+ + "\u0007\u0018\u0000\u0000\u07ce\u07d0\u0005\u00b5\u0000\u0000\u07cf\u07d1"+ + "\u0005\u0465\u0000\u0000\u07d0\u07cf\u0001\u0000\u0000\u0000\u07d0\u07d1"+ + "\u0001\u0000\u0000\u0000\u07d1\u07d2\u0001\u0000\u0000\u0000\u07d2\u07d3"+ + "\u0005\u046e\u0000\u0000\u07d3\u07d4\u0003\u026c\u0136\u0000\u07d4\u07d5"+ + "\u0005\u046f\u0000\u0000\u07d5\u07d7\u0001\u0000\u0000\u0000\u07d6\u071d"+ + "\u0001\u0000\u0000\u0000\u07d6\u0724\u0001\u0000\u0000\u0000\u07d6\u0729"+ + "\u0001\u0000\u0000\u0000\u07d6\u072e\u0001\u0000\u0000\u0000\u07d6\u0733"+ + "\u0001\u0000\u0000\u0000\u07d6\u0739\u0001\u0000\u0000\u0000\u07d6\u0743"+ + "\u0001\u0000\u0000\u0000\u07d6\u0749\u0001\u0000\u0000\u0000\u07d6\u0750"+ + "\u0001\u0000\u0000\u0000\u07d6\u0755\u0001\u0000\u0000\u0000\u07d6\u075a"+ + "\u0001\u0000\u0000\u0000\u07d6\u075f\u0001\u0000\u0000\u0000\u07d6\u0765"+ + "\u0001\u0000\u0000\u0000\u07d6\u076a\u0001\u0000\u0000\u0000\u07d6\u076f"+ + "\u0001\u0000\u0000\u0000\u07d6\u0774\u0001\u0000\u0000\u0000\u07d6\u0779"+ + "\u0001\u0000\u0000\u0000\u07d6\u077e\u0001\u0000\u0000\u0000\u07d6\u0784"+ + "\u0001\u0000\u0000\u0000\u07d6\u0789\u0001\u0000\u0000\u0000\u07d6\u078e"+ + "\u0001\u0000\u0000\u0000\u07d6\u0793\u0001\u0000\u0000\u0000\u07d6\u0798"+ + "\u0001\u0000\u0000\u0000\u07d6\u079d\u0001\u0000\u0000\u0000\u07d6\u07a2"+ + "\u0001\u0000\u0000\u0000\u07d6\u07a7\u0001\u0000\u0000\u0000\u07d6\u07a9"+ + "\u0001\u0000\u0000\u0000\u07d6\u07ae\u0001\u0000\u0000\u0000\u07d6\u07b3"+ + "\u0001\u0000\u0000\u0000\u07d6\u07b8\u0001\u0000\u0000\u0000\u07d6\u07c0"+ + "\u0001\u0000\u0000\u0000\u07d6\u07c5\u0001\u0000\u0000\u0000\u07d6\u07c8"+ + "\u0001\u0000\u0000\u0000\u07d6\u07c9\u0001\u0000\u0000\u0000\u07d6\u07ce"+ + "\u0001\u0000\u0000\u0000\u07d7k\u0001\u0000\u0000\u0000\u07d8\u07d9\u0007"+ + "\u001f\u0000\u0000\u07d9m\u0001\u0000\u0000\u0000\u07da\u07db\u0005\u027d"+ + "\u0000\u0000\u07db\u07dc\u0007\u0012\u0000\u0000\u07dco\u0001\u0000\u0000"+ + "\u0000\u07dd\u07de\u0005\u0082\u0000\u0000\u07de\u07df\u0005\u0014\u0000"+ + "\u0000\u07df\u07e2\u0003r9\u0000\u07e0\u07e1\u0005\u0227\u0000\u0000\u07e1"+ + "\u07e3\u0003\u024e\u0127\u0000\u07e2\u07e0\u0001\u0000\u0000\u0000\u07e2"+ + "\u07e3\u0001\u0000\u0000\u0000\u07e3\u07eb\u0001\u0000\u0000\u0000\u07e4"+ + "\u07e5\u0005\u0282\u0000\u0000\u07e5\u07e6\u0005\u0014\u0000\u0000\u07e6"+ + "\u07e9\u0003t:\u0000\u07e7\u07e8\u0005\u0283\u0000\u0000\u07e8\u07ea\u0003"+ + "\u024e\u0127\u0000\u07e9\u07e7\u0001\u0000\u0000\u0000\u07e9\u07ea\u0001"+ + "\u0000\u0000\u0000\u07ea\u07ec\u0001\u0000\u0000\u0000\u07eb\u07e4\u0001"+ + "\u0000\u0000\u0000\u07eb\u07ec\u0001\u0000\u0000\u0000\u07ec\u07f8\u0001"+ + "\u0000\u0000\u0000\u07ed\u07ee\u0005\u046e\u0000\u0000\u07ee\u07f3\u0003"+ + "v;\u0000\u07ef\u07f0\u0005\u0470\u0000\u0000\u07f0\u07f2\u0003v;\u0000"+ + "\u07f1\u07ef\u0001\u0000\u0000\u0000\u07f2\u07f5\u0001\u0000\u0000\u0000"+ + "\u07f3\u07f1\u0001\u0000\u0000\u0000\u07f3\u07f4\u0001\u0000\u0000\u0000"+ + "\u07f4\u07f6\u0001\u0000\u0000\u0000\u07f5\u07f3\u0001\u0000\u0000\u0000"+ + "\u07f6\u07f7\u0005\u046f\u0000\u0000\u07f7\u07f9\u0001\u0000\u0000\u0000"+ + "\u07f8\u07ed\u0001\u0000\u0000\u0000\u07f8\u07f9\u0001\u0000\u0000\u0000"+ + "\u07f9q\u0001\u0000\u0000\u0000\u07fa\u07fc\u0005e\u0000\u0000\u07fb\u07fa"+ + "\u0001\u0000\u0000\u0000\u07fb\u07fc\u0001\u0000\u0000\u0000\u07fc\u07fd"+ + "\u0001\u0000\u0000\u0000\u07fd\u07fe\u0005\u01bc\u0000\u0000\u07fe\u07ff"+ + "\u0005\u046e\u0000\u0000\u07ff\u0800\u0003\u02b0\u0158\u0000\u0800\u0801"+ + "\u0005\u046f\u0000\u0000\u0801\u0829\u0001\u0000\u0000\u0000\u0802\u0804"+ + "\u0005e\u0000\u0000\u0803\u0802\u0001\u0000\u0000\u0000\u0803\u0804\u0001"+ + "\u0000\u0000\u0000\u0804\u0805\u0001\u0000\u0000\u0000\u0805\u0809\u0005"+ + "\\\u0000\u0000\u0806\u0807\u0005\u0151\u0000\u0000\u0807\u0808\u0005\u0465"+ + "\u0000\u0000\u0808\u080a\u0007 \u0000\u0000\u0809\u0806\u0001\u0000\u0000"+ + "\u0000\u0809\u080a\u0001\u0000\u0000\u0000\u080a\u080b\u0001\u0000\u0000"+ + "\u0000\u080b\u080d\u0005\u046e\u0000\u0000\u080c\u080e\u0003\u0268\u0134"+ + "\u0000\u080d\u080c\u0001\u0000\u0000\u0000\u080d\u080e\u0001\u0000\u0000"+ + "\u0000\u080e\u080f\u0001\u0000\u0000\u0000\u080f\u0829\u0005\u046f\u0000"+ + "\u0000\u0810\u081a\u0005\u0086\u0000\u0000\u0811\u0812\u0005\u046e\u0000"+ + "\u0000\u0812\u0813\u0003\u02b0\u0158\u0000\u0813\u0814\u0005\u046f\u0000"+ + "\u0000\u0814\u081b\u0001\u0000\u0000\u0000\u0815\u0816\u0005\u016e\u0000"+ + "\u0000\u0816\u0817\u0005\u046e\u0000\u0000\u0817\u0818\u0003\u0268\u0134"+ + "\u0000\u0818\u0819\u0005\u046f\u0000\u0000\u0819\u081b\u0001\u0000\u0000"+ + "\u0000\u081a\u0811\u0001\u0000\u0000\u0000\u081a\u0815\u0001\u0000\u0000"+ + "\u0000\u081b\u0829\u0001\u0000\u0000\u0000\u081c\u0826\u0005\u01da\u0000"+ + "\u0000\u081d\u081e\u0005\u046e\u0000\u0000\u081e\u081f\u0003\u02b0\u0158"+ + "\u0000\u081f\u0820\u0005\u046f\u0000\u0000\u0820\u0827\u0001\u0000\u0000"+ + "\u0000\u0821\u0822\u0005\u016e\u0000\u0000\u0822\u0823\u0005\u046e\u0000"+ + "\u0000\u0823\u0824\u0003\u0268\u0134\u0000\u0824\u0825\u0005\u046f\u0000"+ + "\u0000\u0825\u0827\u0001\u0000\u0000\u0000\u0826\u081d\u0001\u0000\u0000"+ + "\u0000\u0826\u0821\u0001\u0000\u0000\u0000\u0827\u0829\u0001\u0000\u0000"+ + "\u0000\u0828\u07fb\u0001\u0000\u0000\u0000\u0828\u0803\u0001\u0000\u0000"+ + "\u0000\u0828\u0810\u0001\u0000\u0000\u0000\u0828\u081c\u0001\u0000\u0000"+ + "\u0000\u0829s\u0001\u0000\u0000\u0000\u082a\u082c\u0005e\u0000\u0000\u082b"+ + "\u082a\u0001\u0000\u0000\u0000\u082b\u082c\u0001\u0000\u0000\u0000\u082c"+ + "\u082d\u0001\u0000\u0000\u0000\u082d\u082e\u0005\u01bc\u0000\u0000\u082e"+ + "\u082f\u0005\u046e\u0000\u0000\u082f\u0830\u0003\u02b0\u0158\u0000\u0830"+ + "\u0831\u0005\u046f\u0000\u0000\u0831\u0840\u0001\u0000\u0000\u0000\u0832"+ + "\u0834\u0005e\u0000\u0000\u0833\u0832\u0001\u0000\u0000\u0000\u0833\u0834"+ + "\u0001\u0000\u0000\u0000\u0834\u0835\u0001\u0000\u0000\u0000\u0835\u0839"+ + "\u0005\\\u0000\u0000\u0836\u0837\u0005\u0151\u0000\u0000\u0837\u0838\u0005"+ + "\u0465\u0000\u0000\u0838\u083a\u0007 \u0000\u0000\u0839\u0836\u0001\u0000"+ + "\u0000\u0000\u0839\u083a\u0001\u0000\u0000\u0000\u083a\u083b\u0001\u0000"+ + "\u0000\u0000\u083b\u083c\u0005\u046e\u0000\u0000\u083c\u083d\u0003\u0268"+ + "\u0134\u0000\u083d\u083e\u0005\u046f\u0000\u0000\u083e\u0840\u0001\u0000"+ + "\u0000\u0000\u083f\u082b\u0001\u0000\u0000\u0000\u083f\u0833\u0001\u0000"+ + "\u0000\u0000\u0840u\u0001\u0000\u0000\u0000\u0841\u0842\u0005\u0082\u0000"+ + "\u0000\u0842\u0843\u0003\u0248\u0124\u0000\u0843\u0844\u0005\u00bd\u0000"+ + "\u0000\u0844\u0845\u0005\u01d8\u0000\u0000\u0845\u0846\u0005\u028c\u0000"+ + "\u0000\u0846\u0847\u0005\u046e\u0000\u0000\u0847\u084c\u0003x<\u0000\u0848"+ + "\u0849\u0005\u0470\u0000\u0000\u0849\u084b\u0003x<\u0000\u084a\u0848\u0001"+ + "\u0000\u0000\u0000\u084b\u084e\u0001\u0000\u0000\u0000\u084c\u084a\u0001"+ + "\u0000\u0000\u0000\u084c\u084d\u0001\u0000\u0000\u0000\u084d\u084f\u0001"+ + "\u0000\u0000\u0000\u084e\u084c\u0001\u0000\u0000\u0000\u084f\u0853\u0005"+ + "\u046f\u0000\u0000\u0850\u0852\u0003~?\u0000\u0851\u0850\u0001\u0000\u0000"+ + "\u0000\u0852\u0855\u0001\u0000\u0000\u0000\u0853\u0851\u0001\u0000\u0000"+ + "\u0000\u0853\u0854\u0001\u0000\u0000\u0000\u0854\u0861\u0001\u0000\u0000"+ + "\u0000\u0855\u0853\u0001\u0000\u0000\u0000\u0856\u0857\u0005\u046e\u0000"+ + "\u0000\u0857\u085c\u0003|>\u0000\u0858\u0859\u0005\u0470\u0000\u0000\u0859"+ + "\u085b\u0003|>\u0000\u085a\u0858\u0001\u0000\u0000\u0000\u085b\u085e\u0001"+ + "\u0000\u0000\u0000\u085c\u085a\u0001\u0000\u0000\u0000\u085c\u085d\u0001"+ + "\u0000\u0000\u0000\u085d\u085f\u0001\u0000\u0000\u0000\u085e\u085c\u0001"+ + "\u0000\u0000\u0000\u085f\u0860\u0005\u046f\u0000\u0000\u0860\u0862\u0001"+ + "\u0000\u0000\u0000\u0861\u0856\u0001\u0000\u0000\u0000\u0861\u0862\u0001"+ + "\u0000\u0000\u0000\u0862\u08d4\u0001\u0000\u0000\u0000\u0863\u0864\u0005"+ + "\u0082\u0000\u0000\u0864\u0865\u0003\u0248\u0124\u0000\u0865\u0866\u0005"+ + "\u00bd\u0000\u0000\u0866\u0867\u0005\u01d8\u0000\u0000\u0867\u0868\u0005"+ + "\u028c\u0000\u0000\u0868\u086c\u0003x<\u0000\u0869\u086b\u0003~?\u0000"+ + "\u086a\u0869\u0001\u0000\u0000\u0000\u086b\u086e\u0001\u0000\u0000\u0000"+ + "\u086c\u086a\u0001\u0000\u0000\u0000\u086c\u086d\u0001\u0000\u0000\u0000"+ + "\u086d\u087a\u0001\u0000\u0000\u0000\u086e\u086c\u0001\u0000\u0000\u0000"+ + "\u086f\u0870\u0005\u046e\u0000\u0000\u0870\u0875\u0003|>\u0000\u0871\u0872"+ + "\u0005\u0470\u0000\u0000\u0872\u0874\u0003|>\u0000\u0873\u0871\u0001\u0000"+ + "\u0000\u0000\u0874\u0877\u0001\u0000\u0000\u0000\u0875\u0873\u0001\u0000"+ + "\u0000\u0000\u0875\u0876\u0001\u0000\u0000\u0000\u0876\u0878\u0001\u0000"+ + "\u0000\u0000\u0877\u0875\u0001\u0000\u0000\u0000\u0878\u0879\u0005\u046f"+ + "\u0000\u0000\u0879\u087b\u0001\u0000\u0000\u0000\u087a\u086f\u0001\u0000"+ + "\u0000\u0000\u087a\u087b\u0001\u0000\u0000\u0000\u087b\u08d4\u0001\u0000"+ + "\u0000\u0000\u087c\u087d\u0005\u0082\u0000\u0000\u087d\u087e\u0003\u0248"+ + "\u0124\u0000\u087e\u087f\u0005\u00bd\u0000\u0000\u087f\u0880\u0005Q\u0000"+ + "\u0000\u0880\u0881\u0005\u046e\u0000\u0000\u0881\u0886\u0003x<\u0000\u0882"+ + "\u0883\u0005\u0470\u0000\u0000\u0883\u0885\u0003x<\u0000\u0884\u0882\u0001"+ + "\u0000\u0000\u0000\u0885\u0888\u0001\u0000\u0000\u0000\u0886\u0884\u0001"+ + "\u0000\u0000\u0000\u0886\u0887\u0001\u0000\u0000\u0000\u0887\u0889\u0001"+ + "\u0000\u0000\u0000\u0888\u0886\u0001\u0000\u0000\u0000\u0889\u088d\u0005"+ + "\u046f\u0000\u0000\u088a\u088c\u0003~?\u0000\u088b\u088a\u0001\u0000\u0000"+ + "\u0000\u088c\u088f\u0001\u0000\u0000\u0000\u088d\u088b\u0001\u0000\u0000"+ + "\u0000\u088d\u088e\u0001\u0000\u0000\u0000\u088e\u089b\u0001\u0000\u0000"+ + "\u0000\u088f\u088d\u0001\u0000\u0000\u0000\u0890\u0891\u0005\u046e\u0000"+ + "\u0000\u0891\u0896\u0003|>\u0000\u0892\u0893\u0005\u0470\u0000\u0000\u0893"+ + "\u0895\u0003|>\u0000\u0894\u0892\u0001\u0000\u0000\u0000\u0895\u0898\u0001"+ + "\u0000\u0000\u0000\u0896\u0894\u0001\u0000\u0000\u0000\u0896\u0897\u0001"+ + "\u0000\u0000\u0000\u0897\u0899\u0001\u0000\u0000\u0000\u0898\u0896\u0001"+ + "\u0000\u0000\u0000\u0899\u089a\u0005\u046f\u0000\u0000\u089a\u089c\u0001"+ + "\u0000\u0000\u0000\u089b\u0890\u0001\u0000\u0000\u0000\u089b\u089c\u0001"+ + "\u0000\u0000\u0000\u089c\u08d4\u0001\u0000\u0000\u0000\u089d\u089e\u0005"+ + "\u0082\u0000\u0000\u089e\u089f\u0003\u0248\u0124\u0000\u089f\u08a0\u0005"+ + "\u00bd\u0000\u0000\u08a0\u08a1\u0005Q\u0000\u0000\u08a1\u08a2\u0005\u046e"+ + "\u0000\u0000\u08a2\u08a7\u0003z=\u0000\u08a3\u08a4\u0005\u0470\u0000\u0000"+ + "\u08a4\u08a6\u0003z=\u0000\u08a5\u08a3\u0001\u0000\u0000\u0000\u08a6\u08a9"+ + "\u0001\u0000\u0000\u0000\u08a7\u08a5\u0001\u0000\u0000\u0000\u08a7\u08a8"+ + "\u0001\u0000\u0000\u0000\u08a8\u08aa\u0001\u0000\u0000\u0000\u08a9\u08a7"+ + "\u0001\u0000\u0000\u0000\u08aa\u08ae\u0005\u046f\u0000\u0000\u08ab\u08ad"+ + "\u0003~?\u0000\u08ac\u08ab\u0001\u0000\u0000\u0000\u08ad\u08b0\u0001\u0000"+ + "\u0000\u0000\u08ae\u08ac\u0001\u0000\u0000\u0000\u08ae\u08af\u0001\u0000"+ + "\u0000\u0000\u08af\u08bc\u0001\u0000\u0000\u0000\u08b0\u08ae\u0001\u0000"+ + "\u0000\u0000\u08b1\u08b2\u0005\u046e\u0000\u0000\u08b2\u08b7\u0003|>\u0000"+ + "\u08b3\u08b4\u0005\u0470\u0000\u0000\u08b4\u08b6\u0003|>\u0000\u08b5\u08b3"+ + "\u0001\u0000\u0000\u0000\u08b6\u08b9\u0001\u0000\u0000\u0000\u08b7\u08b5"+ + "\u0001\u0000\u0000\u0000\u08b7\u08b8\u0001\u0000\u0000\u0000\u08b8\u08ba"+ + "\u0001\u0000\u0000\u0000\u08b9\u08b7\u0001\u0000\u0000\u0000\u08ba\u08bb"+ + "\u0005\u046f\u0000\u0000\u08bb\u08bd\u0001\u0000\u0000\u0000\u08bc\u08b1"+ + "\u0001\u0000\u0000\u0000\u08bc\u08bd\u0001\u0000\u0000\u0000\u08bd\u08d4"+ + "\u0001\u0000\u0000\u0000\u08be\u08bf\u0005\u0082\u0000\u0000\u08bf\u08c3"+ + "\u0003\u0248\u0124\u0000\u08c0\u08c2\u0003~?\u0000\u08c1\u08c0\u0001\u0000"+ + "\u0000\u0000\u08c2\u08c5\u0001\u0000\u0000\u0000\u08c3\u08c1\u0001\u0000"+ + "\u0000\u0000\u08c3\u08c4\u0001\u0000\u0000\u0000\u08c4\u08d1\u0001\u0000"+ + "\u0000\u0000\u08c5\u08c3\u0001\u0000\u0000\u0000\u08c6\u08c7\u0005\u046e"+ + "\u0000\u0000\u08c7\u08cc\u0003|>\u0000\u08c8\u08c9\u0005\u0470\u0000\u0000"+ + "\u08c9\u08cb\u0003|>\u0000\u08ca\u08c8\u0001\u0000\u0000\u0000\u08cb\u08ce"+ + "\u0001\u0000\u0000\u0000\u08cc\u08ca\u0001\u0000\u0000\u0000\u08cc\u08cd"+ + "\u0001\u0000\u0000\u0000\u08cd\u08cf\u0001\u0000\u0000\u0000\u08ce\u08cc"+ + "\u0001\u0000\u0000\u0000\u08cf\u08d0\u0005\u046f\u0000\u0000\u08d0\u08d2"+ + "\u0001\u0000\u0000\u0000\u08d1\u08c6\u0001\u0000\u0000\u0000\u08d1\u08d2"+ + "\u0001\u0000\u0000\u0000\u08d2\u08d4\u0001\u0000\u0000\u0000\u08d3\u0841"+ + "\u0001\u0000\u0000\u0000\u08d3\u0863\u0001\u0000\u0000\u0000\u08d3\u087c"+ + "\u0001\u0000\u0000\u0000\u08d3\u089d\u0001\u0000\u0000\u0000\u08d3\u08be"+ + "\u0001\u0000\u0000\u0000\u08d4w\u0001\u0000\u0000\u0000\u08d5\u08d9\u0003"+ + "\u025a\u012d\u0000\u08d6\u08d9\u0003\u02b0\u0158\u0000\u08d7\u08d9\u0005"+ + "o\u0000\u0000\u08d8\u08d5\u0001\u0000\u0000\u0000\u08d8\u08d6\u0001\u0000"+ + "\u0000\u0000\u08d8\u08d7\u0001\u0000\u0000\u0000\u08d9y\u0001\u0000\u0000"+ + "\u0000\u08da\u08db\u0005\u046e\u0000\u0000\u08db\u08de\u0003x<\u0000\u08dc"+ + "\u08dd\u0005\u0470\u0000\u0000\u08dd\u08df\u0003x<\u0000\u08de\u08dc\u0001"+ + "\u0000\u0000\u0000\u08df\u08e0\u0001\u0000\u0000\u0000\u08e0\u08de\u0001"+ + "\u0000\u0000\u0000\u08e0\u08e1\u0001\u0000\u0000\u0000\u08e1\u08e2\u0001"+ + "\u0000\u0000\u0000\u08e2\u08e3\u0005\u046f\u0000\u0000\u08e3{\u0001\u0000"+ + "\u0000\u0000\u08e4\u08e5\u0005\u0282\u0000\u0000\u08e5\u08e9\u0003\u0248"+ + "\u0124\u0000\u08e6\u08e8\u0003~?\u0000\u08e7\u08e6\u0001\u0000\u0000\u0000"+ + "\u08e8\u08eb\u0001\u0000\u0000\u0000\u08e9\u08e7\u0001\u0000\u0000\u0000"+ + "\u08e9\u08ea\u0001\u0000\u0000\u0000\u08ea}\u0001\u0000\u0000\u0000\u08eb"+ + "\u08e9\u0001\u0000\u0000\u0000\u08ec\u08ee\u0005+\u0000\u0000\u08ed\u08ec"+ + "\u0001\u0000\u0000\u0000\u08ed\u08ee\u0001\u0000\u0000\u0000\u08ee\u08f0"+ + "\u0001\u0000\u0000\u0000\u08ef\u08f1\u0005\u027d\u0000\u0000\u08f0\u08ef"+ + "\u0001\u0000\u0000\u0000\u08f0\u08f1\u0001\u0000\u0000\u0000\u08f1\u08f2"+ + "\u0001\u0000\u0000\u0000\u08f2\u08f4\u0005\u019a\u0000\u0000\u08f3\u08f5"+ + "\u0005\u0465\u0000\u0000\u08f4\u08f3\u0001\u0000\u0000\u0000\u08f4\u08f5"+ + "\u0001\u0000\u0000\u0000\u08f5\u08f6\u0001\u0000\u0000\u0000\u08f6\u091d"+ + "\u0003\u023c\u011e\u0000\u08f7\u08f9\u0005\u0171\u0000\u0000\u08f8\u08fa"+ + "\u0005\u0465\u0000\u0000\u08f9\u08f8\u0001\u0000\u0000\u0000\u08f9\u08fa"+ + "\u0001\u0000\u0000\u0000\u08fa\u08fb\u0001\u0000\u0000\u0000\u08fb\u091d"+ + "\u0005\u047d\u0000\u0000\u08fc\u08fd\u0005\u0185\u0000\u0000\u08fd\u08ff"+ + "\u0005\u018c\u0000\u0000\u08fe\u0900\u0005\u0465\u0000\u0000\u08ff\u08fe"+ + "\u0001\u0000\u0000\u0000\u08ff\u0900\u0001\u0000\u0000\u0000\u0900\u0901"+ + "\u0001\u0000\u0000\u0000\u0901\u091d\u0005\u047d\u0000\u0000\u0902\u0903"+ + "\u0005R\u0000\u0000\u0903\u0905\u0005\u018c\u0000\u0000\u0904\u0906\u0005"+ + "\u0465\u0000\u0000\u0905\u0904\u0001\u0000\u0000\u0000\u0905\u0906\u0001"+ + "\u0000\u0000\u0000\u0906\u0907\u0001\u0000\u0000\u0000\u0907\u091d\u0005"+ + "\u047d\u0000\u0000\u0908\u090a\u0005\u01f5\u0000\u0000\u0909\u090b\u0005"+ + "\u0465\u0000\u0000\u090a\u0909\u0001\u0000\u0000\u0000\u090a\u090b\u0001"+ + "\u0000\u0000\u0000\u090b\u090c\u0001\u0000\u0000\u0000\u090c\u091d\u0003"+ + "\u024e\u0127\u0000\u090d\u090f\u0005\u01ff\u0000\u0000\u090e\u0910\u0005"+ + "\u0465\u0000\u0000\u090f\u090e\u0001\u0000\u0000\u0000\u090f\u0910\u0001"+ + "\u0000\u0000\u0000\u0910\u0911\u0001\u0000\u0000\u0000\u0911\u091d\u0003"+ + "\u024e\u0127\u0000\u0912\u0914\u0005\u0288\u0000\u0000\u0913\u0915\u0005"+ + "\u0465\u0000\u0000\u0914\u0913\u0001\u0000\u0000\u0000\u0914\u0915\u0001"+ + "\u0000\u0000\u0000\u0915\u0916\u0001\u0000\u0000\u0000\u0916\u091d\u0003"+ + "\u0248\u0124\u0000\u0917\u0919\u0005\u0211\u0000\u0000\u0918\u091a\u0005"+ + "\u0465\u0000\u0000\u0919\u0918\u0001\u0000\u0000\u0000\u0919\u091a\u0001"+ + "\u0000\u0000\u0000\u091a\u091b\u0001\u0000\u0000\u0000\u091b\u091d\u0003"+ + "\u0248\u0124\u0000\u091c\u08ed\u0001\u0000\u0000\u0000\u091c\u08f7\u0001"+ + "\u0000\u0000\u0000\u091c\u08fc\u0001\u0000\u0000\u0000\u091c\u0902\u0001"+ + "\u0000\u0000\u0000\u091c\u0908\u0001\u0000\u0000\u0000\u091c\u090d\u0001"+ + "\u0000\u0000\u0000\u091c\u0912\u0001\u0000\u0000\u0000\u091c\u0917\u0001"+ + "\u0000\u0000\u0000\u091d\u007f\u0001\u0000\u0000\u0000\u091e\u091f\u0005"+ + "\b\u0000\u0000\u091f\u0921\u0007\u0000\u0000\u0000\u0920\u0922\u0003\u0248"+ + "\u0124\u0000\u0921\u0920\u0001\u0000\u0000\u0000\u0921\u0922\u0001\u0000"+ + "\u0000\u0000\u0922\u0924\u0001\u0000\u0000\u0000\u0923\u0925\u0003:\u001d"+ + "\u0000\u0924\u0923\u0001\u0000\u0000\u0000\u0925\u0926\u0001\u0000\u0000"+ + "\u0000\u0926\u0924\u0001\u0000\u0000\u0000\u0926\u0927\u0001\u0000\u0000"+ + "\u0000\u0927\u0931\u0001\u0000\u0000\u0000\u0928\u0929\u0005\b\u0000\u0000"+ + "\u0929\u092a\u0007\u0000\u0000\u0000\u092a\u092b\u0003\u0248\u0124\u0000"+ + "\u092b\u092c\u0005\u0299\u0000\u0000\u092c\u092d\u0005\u0185\u0000\u0000"+ + "\u092d\u092e\u0005\u018c\u0000\u0000\u092e\u092f\u0005\u0205\u0000\u0000"+ + "\u092f\u0931\u0001\u0000\u0000\u0000\u0930\u091e\u0001\u0000\u0000\u0000"+ + "\u0930\u0928\u0001\u0000\u0000\u0000\u0931\u0081\u0001\u0000\u0000\u0000"+ + "\u0932\u0934\u0005\b\u0000\u0000\u0933\u0935\u0003@ \u0000\u0934\u0933"+ + "\u0001\u0000\u0000\u0000\u0934\u0935\u0001\u0000\u0000\u0000\u0935\u0936"+ + "\u0001\u0000\u0000\u0000\u0936\u0937\u0005\u01a0\u0000\u0000\u0937\u093b"+ + "\u0003\u0226\u0113\u0000\u0938\u0939\u0005w\u0000\u0000\u0939\u093a\u0005"+ + "\u025e\u0000\u0000\u093a\u093c\u0003B!\u0000\u093b\u0938\u0001\u0000\u0000"+ + "\u0000\u093b\u093c\u0001\u0000\u0000\u0000\u093c\u0943\u0001\u0000\u0000"+ + "\u0000\u093d\u093e\u0005w\u0000\u0000\u093e\u0940\u0005\u0174\u0000\u0000"+ + "\u093f\u0941\u0005s\u0000\u0000\u0940\u093f\u0001\u0000\u0000\u0000\u0940"+ + "\u0941\u0001\u0000\u0000\u0000\u0941\u0942\u0001\u0000\u0000\u0000\u0942"+ + "\u0944\u0005\u0232\u0000\u0000\u0943\u093d\u0001\u0000\u0000\u0000\u0943"+ + "\u0944\u0001\u0000\u0000\u0000\u0944\u0948\u0001\u0000\u0000\u0000\u0945"+ + "\u0946\u0005\u008c\u0000\u0000\u0946\u0947\u0005\u00b0\u0000\u0000\u0947"+ + "\u0949\u0003\u0226\u0113\u0000\u0948\u0945\u0001\u0000\u0000\u0000\u0948"+ + "\u0949\u0001\u0000\u0000\u0000\u0949\u094b\u0001\u0000\u0000\u0000\u094a"+ + "\u094c\u0003J%\u0000\u094b\u094a\u0001\u0000\u0000\u0000\u094b\u094c\u0001"+ + "\u0000\u0000\u0000\u094c\u094f\u0001\u0000\u0000\u0000\u094d\u094e\u0005"+ + "\u0171\u0000\u0000\u094e\u0950\u0005\u047d\u0000\u0000\u094f\u094d\u0001"+ + "\u0000\u0000\u0000\u094f\u0950\u0001\u0000\u0000\u0000\u0950\u0953\u0001"+ + "\u0000\u0000\u0000\u0951\u0952\u0005\u0190\u0000\u0000\u0952\u0954\u0003"+ + "\u0184\u00c2\u0000\u0953\u0951\u0001\u0000\u0000\u0000\u0953\u0954\u0001"+ + "\u0000\u0000\u0000\u0954\u0083\u0001\u0000\u0000\u0000\u0955\u0956\u0005"+ + "\b\u0000\u0000\u0956\u0957\u0005\u01b6\u0000\u0000\u0957\u095b\u0003\u0226"+ + "\u0113\u0000\u0958\u095a\u0003T*\u0000\u0959\u0958\u0001\u0000\u0000\u0000"+ + "\u095a\u095d\u0001\u0000\u0000\u0000\u095b\u0959\u0001\u0000\u0000\u0000"+ + "\u095b\u095c\u0001\u0000\u0000\u0000\u095c\u0085\u0001\u0000\u0000\u0000"+ + "\u095d\u095b\u0001\u0000\u0000\u0000\u095e\u095f\u0005\b\u0000\u0000\u095f"+ + "\u0960\u0005\u01ca\u0000\u0000\u0960\u0961\u0005\u0258\u0000\u0000\u0961"+ + "\u0962\u0005\u0318\u0000\u0000\u0962\u0963\u0005\u01de\u0000\u0000\u0963"+ + "\u0964\u0005\\\u0000\u0000\u0964\u0087\u0001\u0000\u0000\u0000\u0965\u0966"+ + "\u0005\b\u0000\u0000\u0966\u0967\u0005\u01dc\u0000\u0000\u0967\u0968\u0005"+ + "J\u0000\u0000\u0968\u0969\u0003\u0248\u0124\u0000\u0969\u096a\u0005\u0006"+ + "\u0000\u0000\u096a\u096b\u0005\u0294\u0000\u0000\u096b\u0971\u0005\u047d"+ + "\u0000\u0000\u096c\u096e\u0005\u01c6\u0000\u0000\u096d\u096f\u0005\u0465"+ + "\u0000\u0000\u096e\u096d\u0001\u0000\u0000\u0000\u096e\u096f\u0001\u0000"+ + "\u0000\u0000\u096f\u0970\u0001\u0000\u0000\u0000\u0970\u0972\u0003\u0250"+ + "\u0128\u0000\u0971\u096c\u0001\u0000\u0000\u0000\u0971\u0972\u0001\u0000"+ + "\u0000\u0000\u0972\u0974\u0001\u0000\u0000\u0000\u0973\u0975\u0005\u02a3"+ + "\u0000\u0000\u0974\u0973\u0001\u0000\u0000\u0000\u0974\u0975\u0001\u0000"+ + "\u0000\u0000\u0975\u0976\u0001\u0000\u0000\u0000\u0976\u0978\u0005\u019a"+ + "\u0000\u0000\u0977\u0979\u0005\u0465\u0000\u0000\u0978\u0977\u0001\u0000"+ + "\u0000\u0000\u0978\u0979\u0001\u0000\u0000\u0000\u0979\u097a\u0001\u0000"+ + "\u0000\u0000\u097a\u097b\u0003\u023c\u011e\u0000\u097b\u0089\u0001\u0000"+ + "\u0000\u0000\u097c\u097d\u0005\b\u0000\u0000\u097d\u097e\u0005\u0084\u0000"+ + "\u0000\u097e\u0982\u0003\u0226\u0113\u0000\u097f\u0981\u0003T*\u0000\u0980"+ + "\u097f\u0001\u0000\u0000\u0000\u0981\u0984\u0001\u0000\u0000\u0000\u0982"+ + "\u0980\u0001\u0000\u0000\u0000\u0982\u0983\u0001\u0000\u0000\u0000\u0983"+ + "\u008b\u0001\u0000\u0000\u0000\u0984\u0982\u0001\u0000\u0000\u0000\u0985"+ + "\u0986\u0005\b\u0000\u0000\u0986\u0987\u0005\u0261\u0000\u0000\u0987\u0988"+ + "\u0003\u0248\u0124\u0000\u0988\u0989\u0005\u021e\u0000\u0000\u0989\u098a"+ + "\u0005\u046e\u0000\u0000\u098a\u098f\u0003V+\u0000\u098b\u098c\u0005\u0470"+ + "\u0000\u0000\u098c\u098e\u0003V+\u0000\u098d\u098b\u0001\u0000\u0000\u0000"+ + "\u098e\u0991\u0001\u0000\u0000\u0000\u098f\u098d\u0001\u0000\u0000\u0000"+ + "\u098f\u0990\u0001\u0000\u0000\u0000\u0990\u0992\u0001\u0000\u0000\u0000"+ + "\u0991\u098f\u0001\u0000\u0000\u0000\u0992\u0993\u0005\u046f\u0000\u0000"+ + "\u0993\u008d\u0001\u0000\u0000\u0000\u0994\u0996\u0005\b\u0000\u0000\u0995"+ + "\u0997\u0007\u0001\u0000\u0000\u0996\u0995\u0001\u0000\u0000\u0000\u0996"+ + "\u0997\u0001\u0000\u0000\u0000\u0997\u0999\u0001\u0000\u0000\u0000\u0998"+ + "\u099a\u0005O\u0000\u0000\u0999\u0998\u0001\u0000\u0000\u0000\u0999\u099a"+ + "\u0001\u0000\u0000\u0000\u099a\u099b\u0001\u0000\u0000\u0000\u099b\u099c"+ + "\u0005\u00ad\u0000\u0000\u099c\u099e\u0003\u0228\u0114\u0000\u099d\u099f"+ + "\u0003\u0286\u0143\u0000\u099e\u099d\u0001\u0000\u0000\u0000\u099e\u099f"+ + "\u0001\u0000\u0000\u0000\u099f\u09a8\u0001\u0000\u0000\u0000\u09a0\u09a5"+ + "\u0003\u0094J\u0000\u09a1\u09a2\u0005\u0470\u0000\u0000\u09a2\u09a4\u0003"+ + "\u0094J\u0000\u09a3\u09a1\u0001\u0000\u0000\u0000\u09a4\u09a7\u0001\u0000"+ + "\u0000\u0000\u09a5\u09a3\u0001\u0000\u0000\u0000\u09a5\u09a6\u0001\u0000"+ + "\u0000\u0000\u09a6\u09a9\u0001\u0000\u0000\u0000\u09a7\u09a5\u0001\u0000"+ + "\u0000\u0000\u09a8\u09a0\u0001\u0000\u0000\u0000\u09a8\u09a9\u0001\u0000"+ + "\u0000\u0000\u09a9\u09ab\u0001\u0000\u0000\u0000\u09aa\u09ac\u0003p8\u0000"+ + "\u09ab\u09aa\u0001\u0000\u0000\u0000\u09ab\u09ac\u0001\u0000\u0000\u0000"+ + "\u09ac\u008f\u0001\u0000\u0000\u0000\u09ad\u09ae\u0005\b\u0000\u0000\u09ae"+ + "\u09af\u0005\u0288\u0000\u0000\u09af\u09b0\u0003\u0248\u0124\u0000\u09b0"+ + "\u09b1\u0007!\u0000\u0000\u09b1\u09b2\u0005\u0186\u0000\u0000\u09b2\u09b6"+ + "\u0005\u047d\u0000\u0000\u09b3\u09b4\u0005\u01c6\u0000\u0000\u09b4\u09b5"+ + "\u0005\u0465\u0000\u0000\u09b5\u09b7\u0003\u0250\u0128\u0000\u09b6\u09b3"+ + "\u0001\u0000\u0000\u0000\u09b6\u09b7\u0001\u0000\u0000\u0000\u09b7\u09b9"+ + "\u0001\u0000\u0000\u0000\u09b8\u09ba\u0005\u02a3\u0000\u0000\u09b9\u09b8"+ + "\u0001\u0000\u0000\u0000\u09b9\u09ba\u0001\u0000\u0000\u0000\u09ba\u09bb"+ + "\u0001\u0000\u0000\u0000\u09bb\u09bd\u0005\u019a\u0000\u0000\u09bc\u09be"+ + "\u0005\u0465\u0000\u0000\u09bd\u09bc\u0001\u0000\u0000\u0000\u09bd\u09be"+ + "\u0001\u0000\u0000\u0000\u09be\u09bf\u0001\u0000\u0000\u0000\u09bf\u09c0"+ + "\u0003\u023c\u011e\u0000\u09c0\u0091\u0001\u0000\u0000\u0000\u09c1\u09c5"+ + "\u0005\b\u0000\u0000\u09c2\u09c3\u0005\u0151\u0000\u0000\u09c3\u09c4\u0005"+ + "\u0465\u0000\u0000\u09c4\u09c6\u0007\n\u0000\u0000\u09c5\u09c2\u0001\u0000"+ + "\u0000\u0000\u09c5\u09c6\u0001\u0000\u0000\u0000\u09c6\u09c8\u0001\u0000"+ + "\u0000\u0000\u09c7\u09c9\u0003@ \u0000\u09c8\u09c7\u0001\u0000\u0000\u0000"+ + "\u09c8\u09c9\u0001\u0000\u0000\u0000\u09c9\u09cd\u0001\u0000\u0000\u0000"+ + "\u09ca\u09cb\u0005\u00a1\u0000\u0000\u09cb\u09cc\u0005\u025f\u0000\u0000"+ + "\u09cc\u09ce\u0007\u000b\u0000\u0000\u09cd\u09ca\u0001\u0000\u0000\u0000"+ + "\u09cd\u09ce\u0001\u0000\u0000\u0000\u09ce\u09cf\u0001\u0000\u0000\u0000"+ + "\u09cf\u09d0\u0005\u02a0\u0000\u0000\u09d0\u09d5\u0003\u0226\u0113\u0000"+ + "\u09d1\u09d2\u0005\u046e\u0000\u0000\u09d2\u09d3\u0003\u0268\u0134\u0000"+ + "\u09d3\u09d4\u0005\u046f\u0000\u0000\u09d4\u09d6\u0001\u0000\u0000\u0000"+ + "\u09d5\u09d1\u0001\u0000\u0000\u0000\u09d5\u09d6\u0001\u0000\u0000\u0000"+ + "\u09d6\u09d7\u0001\u0000\u0000\u0000\u09d7\u09d8\u0005\r\u0000\u0000\u09d8"+ + "\u09df\u0003\u00c8d\u0000\u09d9\u09db\u0005\u00c1\u0000\u0000\u09da\u09dc"+ + "\u0007\f\u0000\u0000\u09db\u09da\u0001\u0000\u0000\u0000\u09db\u09dc\u0001"+ + "\u0000\u0000\u0000\u09dc\u09dd\u0001\u0000\u0000\u0000\u09dd\u09de\u0005"+ + "\u001b\u0000\u0000\u09de\u09e0\u0005y\u0000\u0000\u09df\u09d9\u0001\u0000"+ + "\u0000\u0000\u09df\u09e0\u0001\u0000\u0000\u0000\u09e0\u0093\u0001\u0000"+ + "\u0000\u0000\u09e1\u09e8\u0003j5\u0000\u09e2\u09e4\u0005\u0470\u0000\u0000"+ + "\u09e3\u09e2\u0001\u0000\u0000\u0000\u09e3\u09e4\u0001\u0000\u0000\u0000"+ + "\u09e4\u09e5\u0001\u0000\u0000\u0000\u09e5\u09e7\u0003j5\u0000\u09e6\u09e3"+ + "\u0001\u0000\u0000\u0000\u09e7\u09ea\u0001\u0000\u0000\u0000\u09e8\u09e6"+ + "\u0001\u0000\u0000\u0000\u09e8\u09e9\u0001\u0000\u0000\u0000\u09e9\u0b41"+ + "\u0001\u0000\u0000\u0000\u09ea\u09e8\u0001\u0000\u0000\u0000\u09eb\u09ed"+ + "\u0005\u0006\u0000\u0000\u09ec\u09ee\u0005\u001d\u0000\u0000\u09ed\u09ec"+ + "\u0001\u0000\u0000\u0000\u09ed\u09ee\u0001\u0000\u0000\u0000\u09ee\u09ef"+ + "\u0001\u0000\u0000\u0000\u09ef\u09f0\u0003\u0248\u0124\u0000\u09f0\u09f4"+ + "\u0003\\.\u0000\u09f1\u09f5\u0005\u01af\u0000\u0000\u09f2\u09f3\u0005"+ + "\u014f\u0000\u0000\u09f3\u09f5\u0003\u0248\u0124\u0000\u09f4\u09f1\u0001"+ + "\u0000\u0000\u0000\u09f4\u09f2\u0001\u0000\u0000\u0000\u09f4\u09f5\u0001"+ + "\u0000\u0000\u0000\u09f5\u0b41\u0001\u0000\u0000\u0000\u09f6\u09f8\u0005"+ + "\u0006\u0000\u0000\u09f7\u09f9\u0005\u001d\u0000\u0000\u09f8\u09f7\u0001"+ + "\u0000\u0000\u0000\u09f8\u09f9\u0001\u0000\u0000\u0000\u09f9\u09fa\u0001"+ + "\u0000\u0000\u0000\u09fa\u09fb\u0005\u046e\u0000\u0000\u09fb\u09fc\u0003"+ + "\u0248\u0124\u0000\u09fc\u0a03\u0003\\.\u0000\u09fd\u09fe\u0005\u0470"+ + "\u0000\u0000\u09fe\u09ff\u0003\u0248\u0124\u0000\u09ff\u0a00\u0003\\."+ + "\u0000\u0a00\u0a02\u0001\u0000\u0000\u0000\u0a01\u09fd\u0001\u0000\u0000"+ + "\u0000\u0a02\u0a05\u0001\u0000\u0000\u0000\u0a03\u0a01\u0001\u0000\u0000"+ + "\u0000\u0a03\u0a04\u0001\u0000\u0000\u0000\u0a04\u0a06\u0001\u0000\u0000"+ + "\u0000\u0a05\u0a03\u0001\u0000\u0000\u0000\u0a06\u0a07\u0005\u046f\u0000"+ + "\u0000\u0a07\u0b41\u0001\u0000\u0000\u0000\u0a08\u0a09\u0005\u0006\u0000"+ + "\u0000\u0a09\u0a0b\u0007\u0014\u0000\u0000\u0a0a\u0a0c\u0003\u0248\u0124"+ + "\u0000\u0a0b\u0a0a\u0001\u0000\u0000\u0000\u0a0b\u0a0c\u0001\u0000\u0000"+ + "\u0000\u0a0c\u0a0e\u0001\u0000\u0000\u0000\u0a0d\u0a0f\u0003L&\u0000\u0a0e"+ + "\u0a0d\u0001\u0000\u0000\u0000\u0a0e\u0a0f\u0001\u0000\u0000\u0000\u0a0f"+ + "\u0a10\u0001\u0000\u0000\u0000\u0a10\u0a14\u0003\u026e\u0137\u0000\u0a11"+ + "\u0a13\u0003N\'\u0000\u0a12\u0a11\u0001\u0000\u0000\u0000\u0a13\u0a16"+ + "\u0001\u0000\u0000\u0000\u0a14\u0a12\u0001\u0000\u0000\u0000\u0a14\u0a15"+ + "\u0001\u0000\u0000\u0000\u0a15\u0b41\u0001\u0000\u0000\u0000\u0a16\u0a14"+ + "\u0001\u0000\u0000\u0000\u0a17\u0a1c\u0005\u0006\u0000\u0000\u0a18\u0a1a"+ + "\u0005\u001f\u0000\u0000\u0a19\u0a1b\u0003\u0248\u0124\u0000\u0a1a\u0a19"+ + "\u0001\u0000\u0000\u0000\u0a1a\u0a1b\u0001\u0000\u0000\u0000\u0a1b\u0a1d"+ + "\u0001\u0000\u0000\u0000\u0a1c\u0a18\u0001\u0000\u0000\u0000\u0a1c\u0a1d"+ + "\u0001\u0000\u0000\u0000\u0a1d\u0a1e\u0001\u0000\u0000\u0000\u0a1e\u0a1f"+ + "\u0005\u0083\u0000\u0000\u0a1f\u0a21\u0005\\\u0000\u0000\u0a20\u0a22\u0003"+ + "\u0248\u0124\u0000\u0a21\u0a20\u0001\u0000\u0000\u0000\u0a21\u0a22\u0001"+ + "\u0000\u0000\u0000\u0a22\u0a24\u0001\u0000\u0000\u0000\u0a23\u0a25\u0003"+ + "L&\u0000\u0a24\u0a23\u0001\u0000\u0000\u0000\u0a24\u0a25\u0001\u0000\u0000"+ + "\u0000\u0a25\u0a26\u0001\u0000\u0000\u0000\u0a26\u0a2a\u0003\u026e\u0137"+ + "\u0000\u0a27\u0a29\u0003N\'\u0000\u0a28\u0a27\u0001\u0000\u0000\u0000"+ + "\u0a29\u0a2c\u0001\u0000\u0000\u0000\u0a2a\u0a28\u0001\u0000\u0000\u0000"+ + "\u0a2a\u0a2b\u0001\u0000\u0000\u0000\u0a2b\u0b41\u0001\u0000\u0000\u0000"+ + "\u0a2c\u0a2a\u0001\u0000\u0000\u0000\u0a2d\u0a32\u0005\u0006\u0000\u0000"+ + "\u0a2e\u0a30\u0005\u001f\u0000\u0000\u0a2f\u0a31\u0003\u0248\u0124\u0000"+ + "\u0a30\u0a2f\u0001\u0000\u0000\u0000\u0a30\u0a31\u0001\u0000\u0000\u0000"+ + "\u0a31\u0a33\u0001\u0000\u0000\u0000\u0a32\u0a2e\u0001\u0000\u0000\u0000"+ + "\u0a32\u0a33\u0001\u0000\u0000\u0000\u0a33\u0a34\u0001\u0000\u0000\u0000"+ + "\u0a34\u0a36\u0005\u00b6\u0000\u0000\u0a35\u0a37\u0007\u0014\u0000\u0000"+ + "\u0a36\u0a35\u0001\u0000\u0000\u0000\u0a36\u0a37\u0001\u0000\u0000\u0000"+ + "\u0a37\u0a39\u0001\u0000\u0000\u0000\u0a38\u0a3a\u0003\u0248\u0124\u0000"+ + "\u0a39\u0a38\u0001\u0000\u0000\u0000\u0a39\u0a3a\u0001\u0000\u0000\u0000"+ + "\u0a3a\u0a3c\u0001\u0000\u0000\u0000\u0a3b\u0a3d\u0003L&\u0000\u0a3c\u0a3b"+ + "\u0001\u0000\u0000\u0000\u0a3c\u0a3d\u0001\u0000\u0000\u0000\u0a3d\u0a3e"+ + "\u0001\u0000\u0000\u0000\u0a3e\u0a42\u0003\u026e\u0137\u0000\u0a3f\u0a41"+ + "\u0003N\'\u0000\u0a40\u0a3f\u0001\u0000\u0000\u0000\u0a41\u0a44\u0001"+ + "\u0000\u0000\u0000\u0a42\u0a40\u0001\u0000\u0000\u0000\u0a42\u0a43\u0001"+ + "\u0000\u0000\u0000\u0a43\u0b41\u0001\u0000\u0000\u0000\u0a44\u0a42\u0001"+ + "\u0000\u0000\u0000\u0a45\u0a46\u0005\u0006\u0000\u0000\u0a46\u0a48\u0007"+ + "\u0016\u0000\u0000\u0a47\u0a49\u0007\u0014\u0000\u0000\u0a48\u0a47\u0001"+ + "\u0000\u0000\u0000\u0a48\u0a49\u0001\u0000\u0000\u0000\u0a49\u0a4b\u0001"+ + "\u0000\u0000\u0000\u0a4a\u0a4c\u0003\u0248\u0124\u0000\u0a4b\u0a4a\u0001"+ + "\u0000\u0000\u0000\u0a4b\u0a4c\u0001\u0000\u0000\u0000\u0a4c\u0a4d\u0001"+ + "\u0000\u0000\u0000\u0a4d\u0a51\u0003\u026e\u0137\u0000\u0a4e\u0a50\u0003"+ + "N\'\u0000\u0a4f\u0a4e\u0001\u0000\u0000\u0000\u0a50\u0a53\u0001\u0000"+ + "\u0000\u0000\u0a51\u0a4f\u0001\u0000\u0000\u0000\u0a51\u0a52\u0001\u0000"+ + "\u0000\u0000\u0a52\u0b41\u0001\u0000\u0000\u0000\u0a53\u0a51\u0001\u0000"+ + "\u0000\u0000\u0a54\u0a59\u0005\u0006\u0000\u0000\u0a55\u0a57\u0005\u001f"+ + "\u0000\u0000\u0a56\u0a58\u0003\u0248\u0124\u0000\u0a57\u0a56\u0001\u0000"+ + "\u0000\u0000\u0a57\u0a58\u0001\u0000\u0000\u0000\u0a58\u0a5a\u0001\u0000"+ + "\u0000\u0000\u0a59\u0a55\u0001\u0000\u0000\u0000\u0a59\u0a5a\u0001\u0000"+ + "\u0000\u0000\u0a5a\u0a5b\u0001\u0000\u0000\u0000\u0a5b\u0a5c\u0005D\u0000"+ + "\u0000\u0a5c\u0a5e\u0005\\\u0000\u0000\u0a5d\u0a5f\u0003\u0248\u0124\u0000"+ + "\u0a5e\u0a5d\u0001\u0000\u0000\u0000\u0a5e\u0a5f\u0001\u0000\u0000\u0000"+ + "\u0a5f\u0a60\u0001\u0000\u0000\u0000\u0a60\u0a61\u0003\u026e\u0137\u0000"+ + "\u0a61\u0a62\u0003b1\u0000\u0a62\u0b41\u0001\u0000\u0000\u0000\u0a63\u0a68"+ + "\u0005\u0006\u0000\u0000\u0a64\u0a66\u0005\u001f\u0000\u0000\u0a65\u0a67"+ + "\u0003\u0248\u0124\u0000\u0a66\u0a65\u0001\u0000\u0000\u0000\u0a66\u0a67"+ + "\u0001\u0000\u0000\u0000\u0a67\u0a69\u0001\u0000\u0000\u0000\u0a68\u0a64"+ + "\u0001\u0000\u0000\u0000\u0a68\u0a69\u0001\u0000\u0000\u0000\u0a69\u0a6a"+ + "\u0001\u0000\u0000\u0000\u0a6a\u0a71\u0005\u001b\u0000\u0000\u0a6b\u0a72"+ + "\u0003\u0248\u0124\u0000\u0a6c\u0a72\u0003\u0252\u0129\u0000\u0a6d\u0a6e"+ + "\u0005\u046e\u0000\u0000\u0a6e\u0a6f\u0003\u02b0\u0158\u0000\u0a6f\u0a70"+ + "\u0005\u046f\u0000\u0000\u0a70\u0a72\u0001\u0000\u0000\u0000\u0a71\u0a6b"+ + "\u0001\u0000\u0000\u0000\u0a71\u0a6c\u0001\u0000\u0000\u0000\u0a71\u0a6d"+ + "\u0001\u0000\u0000\u0000\u0a72\u0a74\u0001\u0000\u0000\u0000\u0a73\u0a75"+ + "\u0005s\u0000\u0000\u0a74\u0a73\u0001\u0000\u0000\u0000\u0a74\u0a75\u0001"+ + "\u0000\u0000\u0000\u0a75\u0a77\u0001\u0000\u0000\u0000\u0a76\u0a78\u0005"+ + ":\u0000\u0000\u0a77\u0a76\u0001\u0000\u0000\u0000\u0a77\u0a78\u0001\u0000"+ + "\u0000\u0000\u0a78\u0b41\u0001\u0000\u0000\u0000\u0a79\u0a7e\u0005\b\u0000"+ + "\u0000\u0a7a\u0a7c\u0005\u001f\u0000\u0000\u0a7b\u0a7d\u0003\u0248\u0124"+ + "\u0000\u0a7c\u0a7b\u0001\u0000\u0000\u0000\u0a7c\u0a7d\u0001\u0000\u0000"+ + "\u0000\u0a7d\u0a7f\u0001\u0000\u0000\u0000\u0a7e\u0a7a\u0001\u0000\u0000"+ + "\u0000\u0a7e\u0a7f\u0001\u0000\u0000\u0000\u0a7f\u0a80\u0001\u0000\u0000"+ + "\u0000\u0a80\u0a87\u0005\u001b\u0000\u0000\u0a81\u0a88\u0003\u0248\u0124"+ + "\u0000\u0a82\u0a88\u0003\u0252\u0129\u0000\u0a83\u0a84\u0005\u046e\u0000"+ + "\u0000\u0a84\u0a85\u0003\u02b0\u0158\u0000\u0a85\u0a86\u0005\u046f\u0000"+ + "\u0000\u0a86\u0a88\u0001\u0000\u0000\u0000\u0a87\u0a81\u0001\u0000\u0000"+ + "\u0000\u0a87\u0a82\u0001\u0000\u0000\u0000\u0a87\u0a83\u0001\u0000\u0000"+ + "\u0000\u0a88\u0a8a\u0001\u0000\u0000\u0000\u0a89\u0a8b\u0005s\u0000\u0000"+ + "\u0a8a\u0a89\u0001\u0000\u0000\u0000\u0a8a\u0a8b\u0001\u0000\u0000\u0000"+ + "\u0a8b\u0a8d\u0001\u0000\u0000\u0000\u0a8c\u0a8e\u0005:\u0000\u0000\u0a8d"+ + "\u0a8c\u0001\u0000\u0000\u0000\u0a8d\u0a8e\u0001\u0000\u0000\u0000\u0a8e"+ + "\u0b41\u0001\u0000\u0000\u0000\u0a8f\u0a94\u0005\u0006\u0000\u0000\u0a90"+ + "\u0a92\u0005\u001f\u0000\u0000\u0a91\u0a93\u0003\u0248\u0124\u0000\u0a92"+ + "\u0a91\u0001\u0000\u0000\u0000\u0a92\u0a93\u0001\u0000\u0000\u0000\u0a93"+ + "\u0a95\u0001\u0000\u0000\u0000\u0a94\u0a90\u0001\u0000\u0000\u0000\u0a94"+ + "\u0a95\u0001\u0000\u0000\u0000\u0a95\u0a96\u0001\u0000\u0000\u0000\u0a96"+ + "\u0a97\u0005\u001b\u0000\u0000\u0a97\u0a98\u0005\u046e\u0000\u0000\u0a98"+ + "\u0a99\u0003\u02b0\u0158\u0000\u0a99\u0a9a\u0005\u046f\u0000\u0000\u0a9a"+ + "\u0b41\u0001\u0000\u0000\u0000\u0a9b\u0a9d\u0005\u0151\u0000\u0000\u0a9c"+ + "\u0a9e\u0005\u0465\u0000\u0000\u0a9d\u0a9c\u0001\u0000\u0000\u0000\u0a9d"+ + "\u0a9e\u0001\u0000\u0000\u0000\u0a9e\u0a9f\u0001\u0000\u0000\u0000\u0a9f"+ + "\u0b41\u0007\"\u0000\u0000\u0aa0\u0aa2\u0005\b\u0000\u0000\u0aa1\u0aa3"+ + "\u0005\u001d\u0000\u0000\u0aa2\u0aa1\u0001\u0000\u0000\u0000\u0aa2\u0aa3"+ + "\u0001\u0000\u0000\u0000\u0aa3\u0aa4\u0001\u0000\u0000\u0000\u0aa4\u0aaa"+ + "\u0003\u0248\u0124\u0000\u0aa5\u0aa6\u0005\u009a\u0000\u0000\u0aa6\u0aa7"+ + "\u0005+\u0000\u0000\u0aa7\u0aab\u0003\u027a\u013d\u0000\u0aa8\u0aa9\u0005"+ + "4\u0000\u0000\u0aa9\u0aab\u0005+\u0000\u0000\u0aaa\u0aa5\u0001\u0000\u0000"+ + "\u0000\u0aaa\u0aa8\u0001\u0000\u0000\u0000\u0aab\u0b41\u0001\u0000\u0000"+ + "\u0000\u0aac\u0aae\u0005\u0019\u0000\u0000\u0aad\u0aaf\u0005\u001d\u0000"+ + "\u0000\u0aae\u0aad\u0001\u0000\u0000\u0000\u0aae\u0aaf\u0001\u0000\u0000"+ + "\u0000\u0aaf\u0ab0\u0001\u0000\u0000\u0000\u0ab0\u0ab1\u0003\u0248\u0124"+ + "\u0000\u0ab1\u0ab2\u0003\u0248\u0124\u0000\u0ab2\u0ab6\u0003\\.\u0000"+ + "\u0ab3\u0ab7\u0005\u01af\u0000\u0000\u0ab4\u0ab5\u0005\u014f\u0000\u0000"+ + "\u0ab5\u0ab7\u0003\u0248\u0124\u0000\u0ab6\u0ab3\u0001\u0000\u0000\u0000"+ + "\u0ab6\u0ab4\u0001\u0000\u0000\u0000\u0ab6\u0ab7\u0001\u0000\u0000\u0000"+ + "\u0ab7\u0b41\u0001\u0000\u0000\u0000\u0ab8\u0ab9\u0005\u008c\u0000\u0000"+ + "\u0ab9\u0aba\u0005\u001d\u0000\u0000\u0aba\u0abb\u0003\u0248\u0124\u0000"+ + "\u0abb\u0abc\u0005\u00b0\u0000\u0000\u0abc\u0abd\u0003\u0248\u0124\u0000"+ + "\u0abd\u0b41\u0001\u0000\u0000\u0000\u0abe\u0ac0\u0005h\u0000\u0000\u0abf"+ + "\u0ac1\u0005\u0465\u0000\u0000\u0ac0\u0abf\u0001\u0000\u0000\u0000\u0ac0"+ + "\u0ac1\u0001\u0000\u0000\u0000\u0ac1\u0ac2\u0001\u0000\u0000\u0000\u0ac2"+ + "\u0b41\u0007\u0004\u0000\u0000\u0ac3\u0ac5\u0005\u0201\u0000\u0000\u0ac4"+ + "\u0ac6\u0005\u001d\u0000\u0000\u0ac5\u0ac4\u0001\u0000\u0000\u0000\u0ac5"+ + "\u0ac6\u0001\u0000\u0000\u0000\u0ac6\u0ac7\u0001\u0000\u0000\u0000\u0ac7"+ + "\u0ac8\u0003\u0248\u0124\u0000\u0ac8\u0acc\u0003\\.\u0000\u0ac9\u0acd"+ + "\u0005\u01af\u0000\u0000\u0aca\u0acb\u0005\u014f\u0000\u0000\u0acb\u0acd"+ + "\u0003\u0248\u0124\u0000\u0acc\u0ac9\u0001\u0000\u0000\u0000\u0acc\u0aca"+ + "\u0001\u0000\u0000\u0000\u0acc\u0acd\u0001\u0000\u0000\u0000\u0acd\u0b41"+ + "\u0001\u0000\u0000\u0000\u0ace\u0ad0\u00054\u0000\u0000\u0acf\u0ad1\u0005"+ + "\u001d\u0000\u0000\u0ad0\u0acf\u0001\u0000\u0000\u0000\u0ad0\u0ad1\u0001"+ + "\u0000\u0000\u0000\u0ad1\u0ad2\u0001\u0000\u0000\u0000\u0ad2\u0ad4\u0003"+ + "\u0248\u0124\u0000\u0ad3\u0ad5\u0005\u0091\u0000\u0000\u0ad4\u0ad3\u0001"+ + "\u0000\u0000\u0000\u0ad4\u0ad5\u0001\u0000\u0000\u0000\u0ad5\u0b41\u0001"+ + "\u0000\u0000\u0000\u0ad6\u0ad7\u00054\u0000\u0000\u0ad7\u0ad8\u0007#\u0000"+ + "\u0000\u0ad8\u0b41\u0003\u0248\u0124\u0000\u0ad9\u0ada\u00054\u0000\u0000"+ + "\u0ada\u0adb\u0005\u0083\u0000\u0000\u0adb\u0b41\u0005\\\u0000\u0000\u0adc"+ + "\u0add\u00054\u0000\u0000\u0add\u0ade\u0007\u0014\u0000\u0000\u0ade\u0b41"+ + "\u0003\u0248\u0124\u0000\u0adf\u0ae0\u0005\u008c\u0000\u0000\u0ae0\u0ae1"+ + "\u0007\u0014\u0000\u0000\u0ae1\u0ae2\u0003\u0248\u0124\u0000\u0ae2\u0ae3"+ + "\u0005\u00b0\u0000\u0000\u0ae3\u0ae4\u0003\u0248\u0124\u0000\u0ae4\u0b41"+ + "\u0001\u0000\u0000\u0000\u0ae5\u0ae7\u0005\b\u0000\u0000\u0ae6\u0ae8\u0005"+ + "\u001d\u0000\u0000\u0ae7\u0ae6\u0001\u0000\u0000\u0000\u0ae7\u0ae8\u0001"+ + "\u0000\u0000\u0000\u0ae8\u0ae9\u0001\u0000\u0000\u0000\u0ae9\u0af7\u0003"+ + "\u0248\u0124\u0000\u0aea\u0aeb\u0005\u009a\u0000\u0000\u0aeb\u0af1\u0005"+ + "+\u0000\u0000\u0aec\u0af2\u0003\u0252\u0129\u0000\u0aed\u0aee\u0005\u046e"+ + "\u0000\u0000\u0aee\u0aef\u0003\u02b0\u0158\u0000\u0aef\u0af0\u0005\u046f"+ + "\u0000\u0000\u0af0\u0af2\u0001\u0000\u0000\u0000\u0af1\u0aec\u0001\u0000"+ + "\u0000\u0000\u0af1\u0aed\u0001\u0000\u0000\u0000\u0af2\u0af8\u0001\u0000"+ + "\u0000\u0000\u0af3\u0af4\u0005\u009a\u0000\u0000\u0af4\u0af8\u0007\u000f"+ + "\u0000\u0000\u0af5\u0af6\u00054\u0000\u0000\u0af6\u0af8\u0005+\u0000\u0000"+ + "\u0af7\u0aea\u0001\u0000\u0000\u0000\u0af7\u0af3\u0001\u0000\u0000\u0000"+ + "\u0af7\u0af5\u0001\u0000\u0000\u0000\u0af8\u0b41\u0001\u0000\u0000\u0000"+ + "\u0af9\u0afa\u0005\b\u0000\u0000\u0afa\u0afb\u0005R\u0000\u0000\u0afb"+ + "\u0afc\u0003\u0248\u0124\u0000\u0afc\u0afd\u0007\u000f\u0000\u0000\u0afd"+ + "\u0b41\u0001\u0000\u0000\u0000\u0afe\u0aff\u00054\u0000\u0000\u0aff\u0b00"+ + "\u0005D\u0000\u0000\u0b00\u0b01\u0005\\\u0000\u0000\u0b01\u0b41\u0003"+ + "\u0248\u0124\u0000\u0b02\u0b03\u0005\u018d\u0000\u0000\u0b03\u0b41\u0005"+ + "]\u0000\u0000\u0b04\u0b05\u0005\u0194\u0000\u0000\u0b05\u0b41\u0005]\u0000"+ + "\u0000\u0b06\u0b08\u0005\u008c\u0000\u0000\u0b07\u0b09\u0007$\u0000\u0000"+ + "\u0b08\u0b07\u0001\u0000\u0000\u0000\u0b08\u0b09\u0001\u0000\u0000\u0000"+ + "\u0b09\u0b0c\u0001\u0000\u0000\u0000\u0b0a\u0b0d\u0003\u0248\u0124\u0000"+ + "\u0b0b\u0b0d\u0003\u0226\u0113\u0000\u0b0c\u0b0a\u0001\u0000\u0000\u0000"+ + "\u0b0c\u0b0b\u0001\u0000\u0000\u0000\u0b0d\u0b41\u0001\u0000\u0000\u0000"+ + "\u0b0e\u0b0f\u0005}\u0000\u0000\u0b0f\u0b10\u0005\u0014\u0000\u0000\u0b10"+ + "\u0b41\u0003\u0268\u0134\u0000\u0b11\u0b12\u0005!\u0000\u0000\u0b12\u0b16"+ + "\u0005\u00b0\u0000\u0000\u0b13\u0b17\u0005\u034a\u0000\u0000\u0b14\u0b15"+ + "\u0005\u001a\u0000\u0000\u0b15\u0b17\u0005\u009a\u0000\u0000\u0b16\u0b13"+ + "\u0001\u0000\u0000\u0000\u0b16\u0b14\u0001\u0000\u0000\u0000\u0b17\u0b18"+ + "\u0001\u0000\u0000\u0000\u0b18\u0b1b\u0003\u0238\u011c\u0000\u0b19\u0b1a"+ + "\u0005\u001c\u0000\u0000\u0b1a\u0b1c\u0003\u023a\u011d\u0000\u0b1b\u0b19"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0b1c\u0001\u0000\u0000\u0000\u0b1c\u0b41"+ + "\u0001\u0000\u0000\u0000\u0b1d\u0b1f\u0005+\u0000\u0000\u0b1e\u0b1d\u0001"+ + "\u0000\u0000\u0000\u0b1e\u0b1f\u0001\u0000\u0000\u0000\u0b1f\u0b20\u0001"+ + "\u0000\u0000\u0000\u0b20\u0b21\u0005\u001a\u0000\u0000\u0b21\u0b22\u0005"+ + "\u009a\u0000\u0000\u0b22\u0b23\u0005\u0465\u0000\u0000\u0b23\u0b27\u0003"+ + "\u0238\u011c\u0000\u0b24\u0b25\u0005\u001c\u0000\u0000\u0b25\u0b26\u0005"+ + "\u0465\u0000\u0000\u0b26\u0b28\u0003\u023a\u011d\u0000\u0b27\u0b24\u0001"+ + "\u0000\u0000\u0000\u0b27\u0b28\u0001\u0000\u0000\u0000\u0b28\u0b41\u0001"+ + "\u0000\u0000\u0000\u0b29\u0b2a\u0005\u018e\u0000\u0000\u0b2a\u0b41\u0005"+ + "\u0288\u0000\u0000\u0b2b\u0b2c\u0005\u01c3\u0000\u0000\u0b2c\u0b41\u0005"+ + "\u0288\u0000\u0000\u0b2d\u0b41\u0005C\u0000\u0000\u0b2e\u0b2f\u0007%\u0000"+ + "\u0000\u0b2f\u0b41\u0005\u029d\u0000\u0000\u0b30\u0b32\u0005\u0006\u0000"+ + "\u0000\u0b31\u0b33\u0005\u001d\u0000\u0000\u0b32\u0b31\u0001\u0000\u0000"+ + "\u0000\u0b32\u0b33\u0001\u0000\u0000\u0000\u0b33\u0b34\u0001\u0000\u0000"+ + "\u0000\u0b34\u0b35\u0005\u046e\u0000\u0000\u0b35\u0b3a\u0003Z-\u0000\u0b36"+ + "\u0b37\u0005\u0470\u0000\u0000\u0b37\u0b39\u0003Z-\u0000\u0b38\u0b36\u0001"+ + "\u0000\u0000\u0000\u0b39\u0b3c\u0001\u0000\u0000\u0000\u0b3a\u0b38\u0001"+ + "\u0000\u0000\u0000\u0b3a\u0b3b\u0001\u0000\u0000\u0000\u0b3b\u0b3d\u0001"+ + "\u0000\u0000\u0000\u0b3c\u0b3a\u0001\u0000\u0000\u0000\u0b3d\u0b3e\u0005"+ + "\u046f\u0000\u0000\u0b3e\u0b41\u0001\u0000\u0000\u0000\u0b3f\u0b41\u0003"+ + "\u0096K\u0000\u0b40\u09e1\u0001\u0000\u0000\u0000\u0b40\u09eb\u0001\u0000"+ + "\u0000\u0000\u0b40\u09f6\u0001\u0000\u0000\u0000\u0b40\u0a08\u0001\u0000"+ + "\u0000\u0000\u0b40\u0a17\u0001\u0000\u0000\u0000\u0b40\u0a2d\u0001\u0000"+ + "\u0000\u0000\u0b40\u0a45\u0001\u0000\u0000\u0000\u0b40\u0a54\u0001\u0000"+ + "\u0000\u0000\u0b40\u0a63\u0001\u0000\u0000\u0000\u0b40\u0a79\u0001\u0000"+ + "\u0000\u0000\u0b40\u0a8f\u0001\u0000\u0000\u0000\u0b40\u0a9b\u0001\u0000"+ + "\u0000\u0000\u0b40\u0aa0\u0001\u0000\u0000\u0000\u0b40\u0aac\u0001\u0000"+ + "\u0000\u0000\u0b40\u0ab8\u0001\u0000\u0000\u0000\u0b40\u0abe\u0001\u0000"+ + "\u0000\u0000\u0b40\u0ac3\u0001\u0000\u0000\u0000\u0b40\u0ace\u0001\u0000"+ + "\u0000\u0000\u0b40\u0ad6\u0001\u0000\u0000\u0000\u0b40\u0ad9\u0001\u0000"+ + "\u0000\u0000\u0b40\u0adc\u0001\u0000\u0000\u0000\u0b40\u0adf\u0001\u0000"+ + "\u0000\u0000\u0b40\u0ae5\u0001\u0000\u0000\u0000\u0b40\u0af9\u0001\u0000"+ + "\u0000\u0000\u0b40\u0afe\u0001\u0000\u0000\u0000\u0b40\u0b02\u0001\u0000"+ + "\u0000\u0000\u0b40\u0b04\u0001\u0000\u0000\u0000\u0b40\u0b06\u0001\u0000"+ + "\u0000\u0000\u0b40\u0b0e\u0001\u0000\u0000\u0000\u0b40\u0b11\u0001\u0000"+ + "\u0000\u0000\u0b40\u0b1e\u0001\u0000\u0000\u0000\u0b40\u0b29\u0001\u0000"+ + "\u0000\u0000\u0b40\u0b2b\u0001\u0000\u0000\u0000\u0b40\u0b2d\u0001\u0000"+ + "\u0000\u0000\u0b40\u0b2e\u0001\u0000\u0000\u0000\u0b40\u0b30\u0001\u0000"+ + "\u0000\u0000\u0b40\u0b3f\u0001\u0000\u0000\u0000\u0b41\u0095\u0001\u0000"+ + "\u0000\u0000\u0b42\u0b43\u0005\u0006\u0000\u0000\u0b43\u0b44\u0005\u0082"+ + "\u0000\u0000\u0b44\u0b45\u0005\u046e\u0000\u0000\u0b45\u0b4a\u0003v;\u0000"+ + "\u0b46\u0b47\u0005\u0470\u0000\u0000\u0b47\u0b49\u0003v;\u0000\u0b48\u0b46"+ + "\u0001\u0000\u0000\u0000\u0b49\u0b4c\u0001\u0000\u0000\u0000\u0b4a\u0b48"+ + "\u0001\u0000\u0000\u0000\u0b4a\u0b4b\u0001\u0000\u0000\u0000\u0b4b\u0b4d"+ + "\u0001\u0000\u0000\u0000\u0b4c\u0b4a\u0001\u0000\u0000\u0000\u0b4d\u0b4e"+ + "\u0005\u046f\u0000\u0000\u0b4e\u0ba5\u0001\u0000\u0000\u0000\u0b4f\u0b50"+ + "\u00054\u0000\u0000\u0b50\u0b51\u0005\u0082\u0000\u0000\u0b51\u0ba5\u0003"+ + "\u0268\u0134\u0000\u0b52\u0b53\u0005\u018e\u0000\u0000\u0b53\u0b56\u0005"+ + "\u0082\u0000\u0000\u0b54\u0b57\u0003\u0268\u0134\u0000\u0b55\u0b57\u0005"+ + "\u0007\u0000\u0000\u0b56\u0b54\u0001\u0000\u0000\u0000\u0b56\u0b55\u0001"+ + "\u0000\u0000\u0000\u0b57\u0b58\u0001\u0000\u0000\u0000\u0b58\u0ba5\u0005"+ + "\u0288\u0000\u0000\u0b59\u0b5a\u0005\u01c3\u0000\u0000\u0b5a\u0b5d\u0005"+ + "\u0082\u0000\u0000\u0b5b\u0b5e\u0003\u0268\u0134\u0000\u0b5c\u0b5e\u0005"+ + "\u0007\u0000\u0000\u0b5d\u0b5b\u0001\u0000\u0000\u0000\u0b5d\u0b5c\u0001"+ + "\u0000\u0000\u0000\u0b5e\u0b5f\u0001\u0000\u0000\u0000\u0b5f\u0ba5\u0005"+ + "\u0288\u0000\u0000\u0b60\u0b61\u0005\u0291\u0000\u0000\u0b61\u0b64\u0005"+ + "\u0082\u0000\u0000\u0b62\u0b65\u0003\u0268\u0134\u0000\u0b63\u0b65\u0005"+ + "\u0007\u0000\u0000\u0b64\u0b62\u0001\u0000\u0000\u0000\u0b64\u0b63\u0001"+ + "\u0000\u0000\u0000\u0b65\u0ba5\u0001\u0000\u0000\u0000\u0b66\u0b67\u0005"+ + "\u016c\u0000\u0000\u0b67\u0b68\u0005\u0082\u0000\u0000\u0b68\u0ba5\u0003"+ + "\u024e\u0127\u0000\u0b69\u0b6a\u0005\u0244\u0000\u0000\u0b6a\u0b6b\u0005"+ + "\u0082\u0000\u0000\u0b6b\u0b6c\u0003\u0268\u0134\u0000\u0b6c\u0b6d\u0005"+ + "X\u0000\u0000\u0b6d\u0b6e\u0005\u046e\u0000\u0000\u0b6e\u0b73\u0003v;"+ + "\u0000\u0b6f\u0b70\u0005\u0470\u0000\u0000\u0b70\u0b72\u0003v;\u0000\u0b71"+ + "\u0b6f\u0001\u0000\u0000\u0000\u0b72\u0b75\u0001\u0000\u0000\u0000\u0b73"+ + "\u0b71\u0001\u0000\u0000\u0000\u0b73\u0b74\u0001\u0000\u0000\u0000\u0b74"+ + "\u0b76\u0001\u0000\u0000\u0000\u0b75\u0b73\u0001\u0000\u0000\u0000\u0b76"+ + "\u0b77\u0005\u046f\u0000\u0000\u0b77\u0ba5\u0001\u0000\u0000\u0000\u0b78"+ + "\u0b79\u0005\u01a3\u0000\u0000\u0b79\u0b7a\u0005\u0082\u0000\u0000\u0b7a"+ + "\u0b7b\u0003\u0248\u0124\u0000\u0b7b\u0b7c\u0005\u00c1\u0000\u0000\u0b7c"+ + "\u0b7d\u0005\u00ad\u0000\u0000\u0b7d\u0b80\u0003\u0228\u0114\u0000\u0b7e"+ + "\u0b7f\u0007%\u0000\u0000\u0b7f\u0b81\u0005\u029d\u0000\u0000\u0b80\u0b7e"+ + "\u0001\u0000\u0000\u0000\u0b80\u0b81\u0001\u0000\u0000\u0000\u0b81\u0ba5"+ + "\u0001\u0000\u0000\u0000\u0b82\u0b83\u0005\n\u0000\u0000\u0b83\u0b86\u0005"+ + "\u0082\u0000\u0000\u0b84\u0b87\u0003\u0268\u0134\u0000\u0b85\u0b87\u0005"+ + "\u0007\u0000\u0000\u0b86\u0b84\u0001\u0000\u0000\u0000\u0b86\u0b85\u0001"+ + "\u0000\u0000\u0000\u0b87\u0ba5\u0001\u0000\u0000\u0000\u0b88\u0b89\u0005"+ + "\u001b\u0000\u0000\u0b89\u0b8c\u0005\u0082\u0000\u0000\u0b8a\u0b8d\u0003"+ + "\u0268\u0134\u0000\u0b8b\u0b8d\u0005\u0007\u0000\u0000\u0b8c\u0b8a\u0001"+ + "\u0000\u0000\u0000\u0b8c\u0b8b\u0001\u0000\u0000\u0000\u0b8d\u0ba5\u0001"+ + "\u0000\u0000\u0000\u0b8e\u0b8f\u0005x\u0000\u0000\u0b8f\u0b92\u0005\u0082"+ + "\u0000\u0000\u0b90\u0b93\u0003\u0268\u0134\u0000\u0b91\u0b93\u0005\u0007"+ + "\u0000\u0000\u0b92\u0b90\u0001\u0000\u0000\u0000\u0b92\u0b91\u0001\u0000"+ + "\u0000\u0000\u0b93\u0ba5\u0001\u0000\u0000\u0000\u0b94\u0b95\u0005\u023a"+ + "\u0000\u0000\u0b95\u0b98\u0005\u0082\u0000\u0000\u0b96\u0b99\u0003\u0268"+ + "\u0134\u0000\u0b97\u0b99\u0005\u0007\u0000\u0000\u0b98\u0b96\u0001\u0000"+ + "\u0000\u0000\u0b98\u0b97\u0001\u0000\u0000\u0000\u0b99\u0ba5\u0001\u0000"+ + "\u0000\u0000\u0b9a\u0b9b\u0005\u0245\u0000\u0000\u0b9b\u0b9e\u0005\u0082"+ + "\u0000\u0000\u0b9c\u0b9f\u0003\u0268\u0134\u0000\u0b9d\u0b9f\u0005\u0007"+ + "\u0000\u0000\u0b9e\u0b9c\u0001\u0000\u0000\u0000\u0b9e\u0b9d\u0001\u0000"+ + "\u0000\u0000\u0b9f\u0ba5\u0001\u0000\u0000\u0000\u0ba0\u0ba1\u0005\u0243"+ + "\u0000\u0000\u0ba1\u0ba5\u0005\u0226\u0000\u0000\u0ba2\u0ba3\u0005\u0299"+ + "\u0000\u0000\u0ba3\u0ba5\u0005\u0226\u0000\u0000\u0ba4\u0b42\u0001\u0000"+ + "\u0000\u0000\u0ba4\u0b4f\u0001\u0000\u0000\u0000\u0ba4\u0b52\u0001\u0000"+ + "\u0000\u0000\u0ba4\u0b59\u0001\u0000\u0000\u0000\u0ba4\u0b60\u0001\u0000"+ + "\u0000\u0000\u0ba4\u0b66\u0001\u0000\u0000\u0000\u0ba4\u0b69\u0001\u0000"+ + "\u0000\u0000\u0ba4\u0b78\u0001\u0000\u0000\u0000\u0ba4\u0b82\u0001\u0000"+ + "\u0000\u0000\u0ba4\u0b88\u0001\u0000\u0000\u0000\u0ba4\u0b8e\u0001\u0000"+ + "\u0000\u0000\u0ba4\u0b94\u0001\u0000\u0000\u0000\u0ba4\u0b9a\u0001\u0000"+ + "\u0000\u0000\u0ba4\u0ba0\u0001\u0000\u0000\u0000\u0ba4\u0ba2\u0001\u0000"+ + "\u0000\u0000\u0ba5\u0097\u0001\u0000\u0000\u0000\u0ba6\u0ba7\u00054\u0000"+ + "\u0000\u0ba7\u0ba9\u0007\u0000\u0000\u0000\u0ba8\u0baa\u0003\u0280\u0140"+ + "\u0000\u0ba9\u0ba8\u0001\u0000\u0000\u0000\u0ba9\u0baa\u0001\u0000\u0000"+ + "\u0000\u0baa\u0bab\u0001\u0000\u0000\u0000\u0bab\u0bac\u0003\u0248\u0124"+ + "\u0000\u0bac\u0099\u0001\u0000\u0000\u0000\u0bad\u0bae\u00054\u0000\u0000"+ + "\u0bae\u0bb0\u0005\u01a0\u0000\u0000\u0baf\u0bb1\u0003\u0280\u0140\u0000"+ + "\u0bb0\u0baf\u0001\u0000\u0000\u0000\u0bb0\u0bb1\u0001\u0000\u0000\u0000"+ + "\u0bb1\u0bb2\u0001\u0000\u0000\u0000\u0bb2\u0bb3\u0003\u0226\u0113\u0000"+ + "\u0bb3\u009b\u0001\u0000\u0000\u0000\u0bb4\u0bb5\u00054\u0000\u0000\u0bb5"+ + "\u0bb7\u0005R\u0000\u0000\u0bb6\u0bb8\u0007\u0001\u0000\u0000\u0bb7\u0bb6"+ + "\u0001\u0000\u0000\u0000\u0bb7\u0bb8\u0001\u0000\u0000\u0000\u0bb8\u0bb9"+ + "\u0001\u0000\u0000\u0000\u0bb9\u0bba\u0003\u0248\u0124\u0000\u0bba\u0bbb"+ + "\u0005w\u0000\u0000\u0bbb\u0bc8\u0003\u0228\u0114\u0000\u0bbc\u0bbe\u0005"+ + "\u0151\u0000\u0000\u0bbd\u0bbf\u0005\u0465\u0000\u0000\u0bbe\u0bbd\u0001"+ + "\u0000\u0000\u0000\u0bbe\u0bbf\u0001\u0000\u0000\u0000\u0bbf\u0bc0\u0001"+ + "\u0000\u0000\u0000\u0bc0\u0bc7\u0007\u0003\u0000\u0000\u0bc1\u0bc3\u0005"+ + "h\u0000\u0000\u0bc2\u0bc4\u0005\u0465\u0000\u0000\u0bc3\u0bc2\u0001\u0000"+ + "\u0000\u0000\u0bc3\u0bc4\u0001\u0000\u0000\u0000\u0bc4\u0bc5\u0001\u0000"+ + "\u0000\u0000\u0bc5\u0bc7\u0007\u0004\u0000\u0000\u0bc6\u0bbc\u0001\u0000"+ + "\u0000\u0000\u0bc6\u0bc1\u0001\u0000\u0000\u0000\u0bc7\u0bca\u0001\u0000"+ + "\u0000\u0000\u0bc8\u0bc6\u0001\u0000\u0000\u0000\u0bc8\u0bc9\u0001\u0000"+ + "\u0000\u0000\u0bc9\u009d\u0001\u0000\u0000\u0000\u0bca\u0bc8\u0001\u0000"+ + "\u0000\u0000\u0bcb\u0bcc\u00054\u0000\u0000\u0bcc\u0bcd\u0005\u01dc\u0000"+ + "\u0000\u0bcd\u0bce\u0005J\u0000\u0000\u0bce\u0bcf\u0003\u0248\u0124\u0000"+ + "\u0bcf\u0bd0\u0005\u019a\u0000\u0000\u0bd0\u0bd1\u0005\u0465\u0000\u0000"+ + "\u0bd1\u0bd2\u0003\u023c\u011e\u0000\u0bd2\u009f\u0001\u0000\u0000\u0000"+ + "\u0bd3\u0bd4\u00054\u0000\u0000\u0bd4\u0bd6\u0005\u0084\u0000\u0000\u0bd5"+ + "\u0bd7\u0003\u0280\u0140\u0000\u0bd6\u0bd5\u0001\u0000\u0000\u0000\u0bd6"+ + "\u0bd7\u0001\u0000\u0000\u0000\u0bd7\u0bd8\u0001\u0000\u0000\u0000\u0bd8"+ + "\u0bd9\u0003\u0226\u0113\u0000\u0bd9\u00a1\u0001\u0000\u0000\u0000\u0bda"+ + "\u0bdb\u00054\u0000\u0000\u0bdb\u0bdd\u0005\u01b6\u0000\u0000\u0bdc\u0bde"+ + "\u0003\u0280\u0140\u0000\u0bdd\u0bdc\u0001\u0000\u0000\u0000\u0bdd\u0bde"+ + "\u0001\u0000\u0000\u0000\u0bde\u0bdf\u0001\u0000\u0000\u0000\u0bdf\u0be0"+ + "\u0003\u0226\u0113\u0000\u0be0\u00a3\u0001\u0000\u0000\u0000\u0be1\u0be2"+ + "\u00054\u0000\u0000\u0be2\u0be4\u0005\u0261\u0000\u0000\u0be3\u0be5\u0003"+ + "\u0280\u0140\u0000\u0be4\u0be3\u0001\u0000\u0000\u0000\u0be4\u0be5\u0001"+ + "\u0000\u0000\u0000\u0be5\u0be6\u0001\u0000\u0000\u0000\u0be6\u0be7\u0003"+ + "\u0248\u0124\u0000\u0be7\u00a5\u0001\u0000\u0000\u0000\u0be8\u0bea\u0005"+ + "4\u0000\u0000\u0be9\u0beb\u0005\u028a\u0000\u0000\u0bea\u0be9\u0001\u0000"+ + "\u0000\u0000\u0bea\u0beb\u0001\u0000\u0000\u0000\u0beb\u0bec\u0001\u0000"+ + "\u0000\u0000\u0bec\u0bee\u0005\u00ad\u0000\u0000\u0bed\u0bef\u0003\u0280"+ + "\u0140\u0000\u0bee\u0bed\u0001\u0000\u0000\u0000\u0bee\u0bef\u0001\u0000"+ + "\u0000\u0000\u0bef\u0bf0\u0001\u0000\u0000\u0000\u0bf0\u0bf2\u0003\u026c"+ + "\u0136\u0000\u0bf1\u0bf3\u0007&\u0000\u0000\u0bf2\u0bf1\u0001\u0000\u0000"+ + "\u0000\u0bf2\u0bf3\u0001\u0000\u0000\u0000\u0bf3\u00a7\u0001\u0000\u0000"+ + "\u0000\u0bf4\u0bf5\u00054\u0000\u0000\u0bf5\u0bf6\u0005\u0288\u0000\u0000"+ + "\u0bf6\u0bfc\u0003\u0248\u0124\u0000\u0bf7\u0bf9\u0005\u019a\u0000\u0000"+ + "\u0bf8\u0bfa\u0005\u0465\u0000\u0000\u0bf9\u0bf8\u0001\u0000\u0000\u0000"+ + "\u0bf9\u0bfa\u0001\u0000\u0000\u0000\u0bfa\u0bfb\u0001\u0000\u0000\u0000"+ + "\u0bfb\u0bfd\u0003\u023c\u011e\u0000\u0bfc\u0bf7\u0001\u0000\u0000\u0000"+ + "\u0bfc\u0bfd\u0001\u0000\u0000\u0000\u0bfd\u00a9\u0001\u0000\u0000\u0000"+ + "\u0bfe\u0bff\u00054\u0000\u0000\u0bff\u0c01\u0005\u00b2\u0000\u0000\u0c00"+ + "\u0c02\u0003\u0280\u0140\u0000\u0c01\u0c00\u0001\u0000\u0000\u0000\u0c01"+ + "\u0c02\u0001\u0000\u0000\u0000\u0c02\u0c03\u0001\u0000\u0000\u0000\u0c03"+ + "\u0c04\u0003\u0226\u0113\u0000\u0c04\u00ab\u0001\u0000\u0000\u0000\u0c05"+ + "\u0c06\u00054\u0000\u0000\u0c06\u0c08\u0005\u02a0\u0000\u0000\u0c07\u0c09"+ + "\u0003\u0280\u0140\u0000\u0c08\u0c07\u0001\u0000\u0000\u0000\u0c08\u0c09"+ + "\u0001\u0000\u0000\u0000\u0c09\u0c0a\u0001\u0000\u0000\u0000\u0c0a\u0c0f"+ + "\u0003\u0226\u0113\u0000\u0c0b\u0c0c\u0005\u0470\u0000\u0000\u0c0c\u0c0e"+ + "\u0003\u0226\u0113\u0000\u0c0d\u0c0b\u0001\u0000\u0000\u0000\u0c0e\u0c11"+ + "\u0001\u0000\u0000\u0000\u0c0f\u0c0d\u0001\u0000\u0000\u0000\u0c0f\u0c10"+ + "\u0001\u0000\u0000\u0000\u0c10\u0c13\u0001\u0000\u0000\u0000\u0c11\u0c0f"+ + "\u0001\u0000\u0000\u0000\u0c12\u0c14\u0007&\u0000\u0000\u0c13\u0c12\u0001"+ + "\u0000\u0000\u0000\u0c13\u0c14\u0001\u0000\u0000\u0000\u0c14\u00ad\u0001"+ + "\u0000\u0000\u0000\u0c15\u0c16\u00054\u0000\u0000\u0c16\u0c18\u0005\u0255"+ + "\u0000\u0000\u0c17\u0c19\u0003\u0280\u0140\u0000\u0c18\u0c17\u0001\u0000"+ + "\u0000\u0000\u0c18\u0c19\u0001\u0000\u0000\u0000\u0c19\u0c1a\u0001\u0000"+ + "\u0000\u0000\u0c1a\u0c1f\u0003\u022a\u0115\u0000\u0c1b\u0c1c\u0005\u0470"+ + "\u0000\u0000\u0c1c\u0c1e\u0003\u022a\u0115\u0000\u0c1d\u0c1b\u0001\u0000"+ + "\u0000\u0000\u0c1e\u0c21\u0001\u0000\u0000\u0000\u0c1f\u0c1d\u0001\u0000"+ + "\u0000\u0000\u0c1f\u0c20\u0001\u0000\u0000\u0000\u0c20\u00af\u0001\u0000"+ + "\u0000\u0000\u0c21\u0c1f\u0001\u0000\u0000\u0000\u0c22\u0c23\u0005\u009a"+ + "\u0000\u0000\u0c23\u0c24\u0005+\u0000\u0000\u0c24\u0c2f\u0005\u0255\u0000"+ + "\u0000\u0c25\u0c30\u0005\u0212\u0000\u0000\u0c26\u0c30\u0005\u0007\u0000"+ + "\u0000\u0c27\u0c2c\u0003\u022a\u0115\u0000\u0c28\u0c29\u0005\u0470\u0000"+ + "\u0000\u0c29\u0c2b\u0003\u022a\u0115\u0000\u0c2a\u0c28\u0001\u0000\u0000"+ + "\u0000\u0c2b\u0c2e\u0001\u0000\u0000\u0000\u0c2c\u0c2a\u0001\u0000\u0000"+ + "\u0000\u0c2c\u0c2d\u0001\u0000\u0000\u0000\u0c2d\u0c30\u0001\u0000\u0000"+ + "\u0000\u0c2e\u0c2c\u0001\u0000\u0000\u0000\u0c2f\u0c25\u0001\u0000\u0000"+ + "\u0000\u0c2f\u0c26\u0001\u0000\u0000\u0000\u0c2f\u0c27\u0001\u0000\u0000"+ + "\u0000\u0c30\u0c31\u0001\u0000\u0000\u0000\u0c31\u0c34\u0005\u00b0\u0000"+ + "\u0000\u0c32\u0c35\u0003\u0234\u011a\u0000\u0c33\u0c35\u0003\u0248\u0124"+ + "\u0000\u0c34\u0c32\u0001\u0000\u0000\u0000\u0c34\u0c33\u0001\u0000\u0000"+ + "\u0000\u0c35\u0c3d\u0001\u0000\u0000\u0000\u0c36\u0c39\u0005\u0470\u0000"+ + "\u0000\u0c37\u0c3a\u0003\u0234\u011a\u0000\u0c38\u0c3a\u0003\u0248\u0124"+ + "\u0000\u0c39\u0c37\u0001\u0000\u0000\u0000\u0c39\u0c38\u0001\u0000\u0000"+ + "\u0000\u0c3a\u0c3c\u0001\u0000\u0000\u0000\u0c3b\u0c36\u0001\u0000\u0000"+ + "\u0000\u0c3c\u0c3f\u0001\u0000\u0000\u0000\u0c3d\u0c3b\u0001\u0000\u0000"+ + "\u0000\u0c3d\u0c3e\u0001\u0000\u0000\u0000\u0c3e\u0c44\u0001\u0000\u0000"+ + "\u0000\u0c3f\u0c3d\u0001\u0000\u0000\u0000\u0c40\u0c41\u0005\u009a\u0000"+ + "\u0000\u0c41\u0c42\u0005\u0255\u0000\u0000\u0c42\u0c44\u0003\u01b2\u00d9"+ + "\u0000\u0c43\u0c22\u0001\u0000\u0000\u0000\u0c43\u0c40\u0001\u0000\u0000"+ + "\u0000\u0c44\u00b1\u0001\u0000\u0000\u0000\u0c45\u0c46\u0005\u008c\u0000"+ + "\u0000\u0c46\u0c47\u0005\u00ad\u0000\u0000\u0c47\u0c4c\u0003\u00b4Z\u0000"+ + "\u0c48\u0c49\u0005\u0470\u0000\u0000\u0c49\u0c4b\u0003\u00b4Z\u0000\u0c4a"+ + "\u0c48\u0001\u0000\u0000\u0000\u0c4b\u0c4e\u0001\u0000\u0000\u0000\u0c4c"+ + "\u0c4a\u0001\u0000\u0000\u0000\u0c4c\u0c4d\u0001\u0000\u0000\u0000\u0c4d"+ + "\u00b3\u0001\u0000\u0000\u0000\u0c4e\u0c4c\u0001\u0000\u0000\u0000\u0c4f"+ + "\u0c50\u0003\u0228\u0114\u0000\u0c50\u0c51\u0005\u00b0\u0000\u0000\u0c51"+ + "\u0c52\u0003\u0228\u0114\u0000\u0c52\u00b5\u0001\u0000\u0000\u0000\u0c53"+ + "\u0c55\u0005\u0291\u0000\u0000\u0c54\u0c56\u0005\u00ad\u0000\u0000\u0c55"+ + "\u0c54\u0001\u0000\u0000\u0000\u0c55\u0c56\u0001\u0000\u0000\u0000\u0c56"+ + "\u0c57\u0001\u0000\u0000\u0000\u0c57\u0c58\u0003\u0228\u0114\u0000\u0c58"+ + "\u00b7\u0001\u0000\u0000\u0000\u0c59\u0c5a\u0005\u0015\u0000\u0000\u0c5a"+ + "\u0c61\u0003\u0226\u0113\u0000\u0c5b\u0c5e\u0005\u046e\u0000\u0000\u0c5c"+ + "\u0c5f\u0003\u0274\u013a\u0000\u0c5d\u0c5f\u0003\u0270\u0138\u0000\u0c5e"+ + "\u0c5c\u0001\u0000\u0000\u0000\u0c5e\u0c5d\u0001\u0000\u0000\u0000\u0c5e"+ + "\u0c5f\u0001\u0000\u0000\u0000\u0c5f\u0c60\u0001\u0000\u0000\u0000\u0c60"+ + "\u0c62\u0005\u046f\u0000\u0000\u0c61\u0c5b\u0001\u0000\u0000\u0000\u0c61"+ + "\u0c62\u0001\u0000\u0000\u0000\u0c62\u00b9\u0001\u0000\u0000\u0000\u0c63"+ + "\u0c66\u0003\u00d6k\u0000\u0c64\u0c66\u0003\u00d8l\u0000\u0c65\u0c63\u0001"+ + "\u0000\u0000\u0000\u0c65\u0c64\u0001\u0000\u0000\u0000\u0c66\u00bb\u0001"+ + "\u0000\u0000\u0000\u0c67\u0c68\u0005\u0190\u0000\u0000\u0c68\u0c69\u0003"+ + "\u0270\u0138\u0000\u0c69\u00bd\u0001\u0000\u0000\u0000\u0c6a\u0c6f\u0003"+ + "\u00dam\u0000\u0c6b\u0c6f\u0003\u00dcn\u0000\u0c6c\u0c6f\u0003\u00deo"+ + "\u0000\u0c6d\u0c6f\u0003\u00e0p\u0000\u0c6e\u0c6a\u0001\u0000\u0000\u0000"+ + "\u0c6e\u0c6b\u0001\u0000\u0000\u0000\u0c6e\u0c6c\u0001\u0000\u0000\u0000"+ + "\u0c6e\u0c6d\u0001\u0000\u0000\u0000\u0c6f\u00bf\u0001\u0000\u0000\u0000"+ + "\u0c70\u0c72\u0005V\u0000\u0000\u0c71\u0c73\u0007\'\u0000\u0000\u0c72"+ + "\u0c71\u0001\u0000\u0000\u0000\u0c72\u0c73\u0001\u0000\u0000\u0000\u0c73"+ + "\u0c75\u0001\u0000\u0000\u0000\u0c74\u0c76\u0005O\u0000\u0000\u0c75\u0c74"+ + "\u0001\u0000\u0000\u0000\u0c75\u0c76\u0001\u0000\u0000\u0000\u0c76\u0c78"+ + "\u0001\u0000\u0000\u0000\u0c77\u0c79\u0005X\u0000\u0000\u0c78\u0c77\u0001"+ + "\u0000\u0000\u0000\u0c78\u0c79\u0001\u0000\u0000\u0000\u0c79\u0c7a\u0001"+ + "\u0000\u0000\u0000\u0c7a\u0c81\u0003\u0228\u0114\u0000\u0c7b\u0c7c\u0005"+ + "\u0082\u0000\u0000\u0c7c\u0c7e\u0005\u046e\u0000\u0000\u0c7d\u0c7f\u0003"+ + "\u0268\u0134\u0000\u0c7e\u0c7d\u0001\u0000\u0000\u0000\u0c7e\u0c7f\u0001"+ + "\u0000\u0000\u0000\u0c7f\u0c80\u0001\u0000\u0000\u0000\u0c80\u0c82\u0005"+ + "\u046f\u0000\u0000\u0c81\u0c7b\u0001\u0000\u0000\u0000\u0c81\u0c82\u0001"+ + "\u0000\u0000\u0000\u0c82\u0c9a\u0001\u0000\u0000\u0000\u0c83\u0c85\u0005"+ + "\u046e\u0000\u0000\u0c84\u0c86\u0003\u026a\u0135\u0000\u0c85\u0c84\u0001"+ + "\u0000\u0000\u0000\u0c85\u0c86\u0001\u0000\u0000\u0000\u0c86\u0c87\u0001"+ + "\u0000\u0000\u0000\u0c87\u0c89\u0005\u046f\u0000\u0000\u0c88\u0c83\u0001"+ + "\u0000\u0000\u0000\u0c88\u0c89\u0001\u0000\u0000\u0000\u0c89\u0c8a\u0001"+ + "\u0000\u0000\u0000\u0c8a\u0c8f\u0003\u00ceg\u0000\u0c8b\u0c8d\u0005\r"+ + "\u0000\u0000\u0c8c\u0c8b\u0001\u0000\u0000\u0000\u0c8c\u0c8d\u0001\u0000"+ + "\u0000\u0000\u0c8d\u0c8e\u0001\u0000\u0000\u0000\u0c8e\u0c90\u0003\u0248"+ + "\u0124\u0000\u0c8f\u0c8c\u0001\u0000\u0000\u0000\u0c8f\u0c90\u0001\u0000"+ + "\u0000\u0000\u0c90\u0c9b\u0001\u0000\u0000\u0000\u0c91\u0c92\u0005\u009a"+ + "\u0000\u0000\u0c92\u0c97\u0003\u00d0h\u0000\u0c93\u0c94\u0005\u0470\u0000"+ + "\u0000\u0c94\u0c96\u0003\u00d0h\u0000\u0c95\u0c93\u0001\u0000\u0000\u0000"+ + "\u0c96\u0c99\u0001\u0000\u0000\u0000\u0c97\u0c95\u0001\u0000\u0000\u0000"+ + "\u0c97\u0c98\u0001\u0000\u0000\u0000\u0c98\u0c9b\u0001\u0000\u0000\u0000"+ + "\u0c99\u0c97\u0001\u0000\u0000\u0000\u0c9a\u0c88\u0001\u0000\u0000\u0000"+ + "\u0c9a\u0c91\u0001\u0000\u0000\u0000\u0c9b\u0ca8\u0001\u0000\u0000\u0000"+ + "\u0c9c\u0c9d\u0005w\u0000\u0000\u0c9d\u0c9e\u0005\u0192\u0000\u0000\u0c9e"+ + "\u0c9f\u0005\\\u0000\u0000\u0c9f\u0ca0\u0005\u00b9\u0000\u0000\u0ca0\u0ca5"+ + "\u0003\u00d0h\u0000\u0ca1\u0ca2\u0005\u0470\u0000\u0000\u0ca2\u0ca4\u0003"+ + "\u00d0h\u0000\u0ca3\u0ca1\u0001\u0000\u0000\u0000\u0ca4\u0ca7\u0001\u0000"+ + "\u0000\u0000\u0ca5\u0ca3\u0001\u0000\u0000\u0000\u0ca5\u0ca6\u0001\u0000"+ + "\u0000\u0000\u0ca6\u0ca9\u0001\u0000\u0000\u0000\u0ca7\u0ca5\u0001\u0000"+ + "\u0000\u0000\u0ca8\u0c9c\u0001\u0000\u0000\u0000\u0ca8\u0ca9\u0001\u0000"+ + "\u0000\u0000\u0ca9\u00c1\u0001\u0000\u0000\u0000\u0caa\u0cab\u0005g\u0000"+ + "\u0000\u0cab\u0cad\u0005\u0185\u0000\u0000\u0cac\u0cae\u0007(\u0000\u0000"+ + "\u0cad\u0cac\u0001\u0000\u0000\u0000\u0cad\u0cae\u0001\u0000\u0000\u0000"+ + "\u0cae\u0cb0\u0001\u0000\u0000\u0000\u0caf\u0cb1\u0005\u01db\u0000\u0000"+ + "\u0cb0\u0caf\u0001\u0000\u0000\u0000\u0cb0\u0cb1\u0001\u0000\u0000\u0000"+ + "\u0cb1\u0cb2\u0001\u0000\u0000\u0000\u0cb2\u0cb3\u0005S\u0000\u0000\u0cb3"+ + "\u0cb5\u0005\u047d\u0000\u0000\u0cb4\u0cb6\u0007\u0006\u0000\u0000\u0cb5"+ + "\u0cb4\u0001\u0000\u0000\u0000\u0cb5\u0cb6\u0001\u0000\u0000\u0000\u0cb6"+ + "\u0cb7\u0001\u0000\u0000\u0000\u0cb7\u0cb8\u0005X\u0000\u0000\u0cb8\u0cb9"+ + "\u0005\u00ad\u0000\u0000\u0cb9\u0cbf\u0003\u0228\u0114\u0000\u0cba\u0cbb"+ + "\u0005\u0082\u0000\u0000\u0cbb\u0cbc\u0005\u046e\u0000\u0000\u0cbc\u0cbd"+ + "\u0003\u0268\u0134\u0000\u0cbd\u0cbe\u0005\u046f\u0000\u0000\u0cbe\u0cc0"+ + "\u0001\u0000\u0000\u0000\u0cbf\u0cba\u0001\u0000\u0000\u0000\u0cbf\u0cc0"+ + "\u0001\u0000\u0000\u0000\u0cc0\u0cc4\u0001\u0000\u0000\u0000\u0cc1\u0cc2"+ + "\u0005\u001a\u0000\u0000\u0cc2\u0cc3\u0005\u009a\u0000\u0000\u0cc3\u0cc5"+ + "\u0003\u0238\u011c\u0000\u0cc4\u0cc1\u0001\u0000\u0000\u0000\u0cc4\u0cc5"+ + "\u0001\u0000\u0000\u0000\u0cc5\u0ccc\u0001\u0000\u0000\u0000\u0cc6\u0cc8"+ + "\u0007)\u0000\u0000\u0cc7\u0cc9\u0003\u0118\u008c\u0000\u0cc8\u0cc7\u0001"+ + "\u0000\u0000\u0000\u0cc9\u0cca\u0001\u0000\u0000\u0000\u0cca\u0cc8\u0001"+ + "\u0000\u0000\u0000\u0cca\u0ccb\u0001\u0000\u0000\u0000\u0ccb\u0ccd\u0001"+ + "\u0000\u0000\u0000\u0ccc\u0cc6\u0001\u0000\u0000\u0000\u0ccc\u0ccd\u0001"+ + "\u0000\u0000\u0000\u0ccd\u0cd4\u0001\u0000\u0000\u0000\u0cce\u0cd0\u0005"+ + "f\u0000\u0000\u0ccf\u0cd1\u0003\u011a\u008d\u0000\u0cd0\u0ccf\u0001\u0000"+ + "\u0000\u0000\u0cd1\u0cd2\u0001\u0000\u0000\u0000\u0cd2\u0cd0\u0001\u0000"+ + "\u0000\u0000\u0cd2\u0cd3\u0001\u0000\u0000\u0000\u0cd3\u0cd5\u0001\u0000"+ + "\u0000\u0000\u0cd4\u0cce\u0001\u0000\u0000\u0000\u0cd4\u0cd5\u0001\u0000"+ + "\u0000\u0000\u0cd5\u0cda\u0001\u0000\u0000\u0000\u0cd6\u0cd7\u0005O\u0000"+ + "\u0000\u0cd7\u0cd8\u0003\u024e\u0127\u0000\u0cd8\u0cd9\u0007*\u0000\u0000"+ + "\u0cd9\u0cdb\u0001\u0000\u0000\u0000\u0cda\u0cd6\u0001\u0000\u0000\u0000"+ + "\u0cda\u0cdb\u0001\u0000\u0000\u0000\u0cdb\u0ce7\u0001\u0000\u0000\u0000"+ + "\u0cdc\u0cdd\u0005\u046e\u0000\u0000\u0cdd\u0ce2\u0003\u00d2i\u0000\u0cde"+ + "\u0cdf\u0005\u0470\u0000\u0000\u0cdf\u0ce1\u0003\u00d2i\u0000\u0ce0\u0cde"+ + "\u0001\u0000\u0000\u0000\u0ce1\u0ce4\u0001\u0000\u0000\u0000\u0ce2\u0ce0"+ + "\u0001\u0000\u0000\u0000\u0ce2\u0ce3\u0001\u0000\u0000\u0000\u0ce3\u0ce5"+ + "\u0001\u0000\u0000\u0000\u0ce4\u0ce2\u0001\u0000\u0000\u0000\u0ce5\u0ce6"+ + "\u0005\u046f\u0000\u0000\u0ce6\u0ce8\u0001\u0000\u0000\u0000\u0ce7\u0cdc"+ + "\u0001\u0000\u0000\u0000\u0ce7\u0ce8\u0001\u0000\u0000\u0000\u0ce8\u0cf2"+ + "\u0001\u0000\u0000\u0000\u0ce9\u0cea\u0005\u009a\u0000\u0000\u0cea\u0cef"+ + "\u0003\u00d0h\u0000\u0ceb\u0cec\u0005\u0470\u0000\u0000\u0cec\u0cee\u0003"+ + "\u00d0h\u0000\u0ced\u0ceb\u0001\u0000\u0000\u0000\u0cee\u0cf1\u0001\u0000"+ + "\u0000\u0000\u0cef\u0ced\u0001\u0000\u0000\u0000\u0cef\u0cf0\u0001\u0000"+ + "\u0000\u0000\u0cf0\u0cf3\u0001\u0000\u0000\u0000\u0cf1\u0cef\u0001\u0000"+ + "\u0000\u0000\u0cf2\u0ce9\u0001\u0000\u0000\u0000\u0cf2\u0cf3\u0001\u0000"+ + "\u0000\u0000\u0cf3\u00c3\u0001\u0000\u0000\u0000\u0cf4\u0cf5\u0005g\u0000"+ + "\u0000\u0cf5\u0cf7\u0005\u02ab\u0000\u0000\u0cf6\u0cf8\u0007(\u0000\u0000"+ + "\u0cf7\u0cf6\u0001\u0000\u0000\u0000\u0cf7\u0cf8\u0001\u0000\u0000\u0000"+ + "\u0cf8\u0cfa\u0001\u0000\u0000\u0000\u0cf9\u0cfb\u0005\u01db\u0000\u0000"+ + "\u0cfa\u0cf9\u0001\u0000\u0000\u0000\u0cfa\u0cfb\u0001\u0000\u0000\u0000"+ + "\u0cfb\u0cfc\u0001\u0000\u0000\u0000\u0cfc\u0cfd\u0005S\u0000\u0000\u0cfd"+ + "\u0cff\u0005\u047d\u0000\u0000\u0cfe\u0d00\u0007\u0006\u0000\u0000\u0cff"+ + "\u0cfe\u0001\u0000\u0000\u0000\u0cff\u0d00\u0001\u0000\u0000\u0000\u0d00"+ + "\u0d01\u0001\u0000\u0000\u0000\u0d01\u0d02\u0005X\u0000\u0000\u0d02\u0d03"+ + "\u0005\u00ad\u0000\u0000\u0d03\u0d07\u0003\u0228\u0114\u0000\u0d04\u0d05"+ + "\u0005\u001a\u0000\u0000\u0d05\u0d06\u0005\u009a\u0000\u0000\u0d06\u0d08"+ + "\u0003\u0238\u011c\u0000\u0d07\u0d04\u0001\u0000\u0000\u0000\u0d07\u0d08"+ + "\u0001\u0000\u0000\u0000\u0d08\u0d0f\u0001\u0000\u0000\u0000\u0d09\u0d0a"+ + "\u0005\u025a\u0000\u0000\u0d0a\u0d0b\u0005\u01c1\u0000\u0000\u0d0b\u0d0c"+ + "\u0005\u0014\u0000\u0000\u0d0c\u0d0d\u0005\u0467\u0000\u0000\u0d0d\u0d0e"+ + "\u0005\u047d\u0000\u0000\u0d0e\u0d10\u0005\u0466\u0000\u0000\u0d0f\u0d09"+ + "\u0001\u0000\u0000\u0000\u0d0f\u0d10\u0001\u0000\u0000\u0000\u0d10\u0d15"+ + "\u0001\u0000\u0000\u0000\u0d11\u0d12\u0005O\u0000\u0000\u0d12\u0d13\u0003"+ + "\u024e\u0127\u0000\u0d13\u0d14\u0007*\u0000\u0000\u0d14\u0d16\u0001\u0000"+ + "\u0000\u0000\u0d15\u0d11\u0001\u0000\u0000\u0000\u0d15\u0d16\u0001\u0000"+ + "\u0000\u0000\u0d16\u0d22\u0001\u0000\u0000\u0000\u0d17\u0d18\u0005\u046e"+ + "\u0000\u0000\u0d18\u0d1d\u0003\u00d2i\u0000\u0d19\u0d1a\u0005\u0470\u0000"+ + "\u0000\u0d1a\u0d1c\u0003\u00d2i\u0000\u0d1b\u0d19\u0001\u0000\u0000\u0000"+ + "\u0d1c\u0d1f\u0001\u0000\u0000\u0000\u0d1d\u0d1b\u0001\u0000\u0000\u0000"+ + "\u0d1d\u0d1e\u0001\u0000\u0000\u0000\u0d1e\u0d20\u0001\u0000\u0000\u0000"+ + "\u0d1f\u0d1d\u0001\u0000\u0000\u0000\u0d20\u0d21\u0005\u046f\u0000\u0000"+ + "\u0d21\u0d23\u0001\u0000\u0000\u0000\u0d22\u0d17\u0001\u0000\u0000\u0000"+ + "\u0d22\u0d23\u0001\u0000\u0000\u0000\u0d23\u0d2d\u0001\u0000\u0000\u0000"+ + "\u0d24\u0d25\u0005\u009a\u0000\u0000\u0d25\u0d2a\u0003\u00d0h\u0000\u0d26"+ + "\u0d27\u0005\u0470\u0000\u0000\u0d27\u0d29\u0003\u00d0h\u0000\u0d28\u0d26"+ + "\u0001\u0000\u0000\u0000\u0d29\u0d2c\u0001\u0000\u0000\u0000\u0d2a\u0d28"+ + "\u0001\u0000\u0000\u0000\u0d2a\u0d2b\u0001\u0000\u0000\u0000\u0d2b\u0d2e"+ + "\u0001\u0000\u0000\u0000\u0d2c\u0d2a\u0001\u0000\u0000\u0000\u0d2d\u0d24"+ + "\u0001\u0000\u0000\u0000\u0d2d\u0d2e\u0001\u0000\u0000\u0000\u0d2e\u00c5"+ + "\u0001\u0000\u0000\u0000\u0d2f\u0d31\u0005\u008e\u0000\u0000\u0d30\u0d32"+ + "\u0007+\u0000\u0000\u0d31\u0d30\u0001\u0000\u0000\u0000\u0d31\u0d32\u0001"+ + "\u0000\u0000\u0000\u0d32\u0d34\u0001\u0000\u0000\u0000\u0d33\u0d35\u0005"+ + "X\u0000\u0000\u0d34\u0d33\u0001\u0000\u0000\u0000\u0d34\u0d35\u0001\u0000"+ + "\u0000\u0000\u0d35\u0d36\u0001\u0000\u0000\u0000\u0d36\u0d3c\u0003\u0228"+ + "\u0114\u0000\u0d37\u0d38\u0005\u0082\u0000\u0000\u0d38\u0d39\u0005\u046e"+ + "\u0000\u0000\u0d39\u0d3a\u0003\u0268\u0134\u0000\u0d3a\u0d3b\u0005\u046f"+ + "\u0000\u0000\u0d3b\u0d3d\u0001\u0000\u0000\u0000\u0d3c\u0d37\u0001\u0000"+ + "\u0000\u0000\u0d3c\u0d3d\u0001\u0000\u0000\u0000\u0d3d\u0d4e\u0001\u0000"+ + "\u0000\u0000\u0d3e\u0d3f\u0005\u046e\u0000\u0000\u0d3f\u0d40\u0003\u0268"+ + "\u0134\u0000\u0d40\u0d41\u0005\u046f\u0000\u0000\u0d41\u0d43\u0001\u0000"+ + "\u0000\u0000\u0d42\u0d3e\u0001\u0000\u0000\u0000\u0d42\u0d43\u0001\u0000"+ + "\u0000\u0000\u0d43\u0d44\u0001\u0000\u0000\u0000\u0d44\u0d4f\u0003\u00ce"+ + "g\u0000\u0d45\u0d46\u0005\u009a\u0000\u0000\u0d46\u0d4b\u0003\u00d0h\u0000"+ + "\u0d47\u0d48\u0005\u0470\u0000\u0000\u0d48\u0d4a\u0003\u00d0h\u0000\u0d49"+ + "\u0d47\u0001\u0000\u0000\u0000\u0d4a\u0d4d\u0001\u0000\u0000\u0000\u0d4b"+ + "\u0d49\u0001\u0000\u0000\u0000\u0d4b\u0d4c\u0001\u0000\u0000\u0000\u0d4c"+ + "\u0d4f\u0001\u0000\u0000\u0000\u0d4d\u0d4b\u0001\u0000\u0000\u0000\u0d4e"+ + "\u0d42\u0001\u0000\u0000\u0000\u0d4e\u0d45\u0001\u0000\u0000\u0000\u0d4f"+ + "\u00c7\u0001\u0000\u0000\u0000\u0d50\u0d52\u0003\u00fc~\u0000\u0d51\u0d53"+ + "\u0003\u00d4j\u0000\u0d52\u0d51\u0001\u0000\u0000\u0000\u0d52\u0d53\u0001"+ + "\u0000\u0000\u0000\u0d53\u0d92\u0001\u0000\u0000\u0000\u0d54\u0d56\u0003"+ + "\u00f8|\u0000\u0d55\u0d57\u0003\u00d4j\u0000\u0d56\u0d55\u0001\u0000\u0000"+ + "\u0000\u0d56\u0d57\u0001\u0000\u0000\u0000\u0d57\u0d92\u0001\u0000\u0000"+ + "\u0000\u0d58\u0d5b\u0003\u00fe\u007f\u0000\u0d59\u0d5b\u0003\u00fa}\u0000"+ + "\u0d5a\u0d58\u0001\u0000\u0000\u0000\u0d5a\u0d59\u0001\u0000\u0000\u0000"+ + "\u0d5b\u0d5d\u0001\u0000\u0000\u0000\u0d5c\u0d5e\u0003\u0102\u0081\u0000"+ + "\u0d5d\u0d5c\u0001\u0000\u0000\u0000\u0d5e\u0d5f\u0001\u0000\u0000\u0000"+ + "\u0d5f\u0d5d\u0001\u0000\u0000\u0000\u0d5f\u0d60\u0001\u0000\u0000\u0000"+ + "\u0d60\u0d69\u0001\u0000\u0000\u0000\u0d61\u0d63\u0005\u00b5\u0000\u0000"+ + "\u0d62\u0d64\u0007,\u0000\u0000\u0d63\u0d62\u0001\u0000\u0000\u0000\u0d63"+ + "\u0d64\u0001\u0000\u0000\u0000\u0d64\u0d67\u0001\u0000\u0000\u0000\u0d65"+ + "\u0d68\u0003\u00fc~\u0000\u0d66\u0d68\u0003\u00f8|\u0000\u0d67\u0d65\u0001"+ + "\u0000\u0000\u0000\u0d67\u0d66\u0001\u0000\u0000\u0000\u0d68\u0d6a\u0001"+ + "\u0000\u0000\u0000\u0d69\u0d61\u0001\u0000\u0000\u0000\u0d69\u0d6a\u0001"+ + "\u0000\u0000\u0000\u0d6a\u0d6c\u0001\u0000\u0000\u0000\u0d6b\u0d6d\u0003"+ + "\u00e6s\u0000\u0d6c\u0d6b\u0001\u0000\u0000\u0000\u0d6c\u0d6d\u0001\u0000"+ + "\u0000\u0000\u0d6d\u0d6f\u0001\u0000\u0000\u0000\u0d6e\u0d70\u0003\u0126"+ + "\u0093\u0000\u0d6f\u0d6e\u0001\u0000\u0000\u0000\u0d6f\u0d70\u0001\u0000"+ + "\u0000\u0000\u0d70\u0d72\u0001\u0000\u0000\u0000\u0d71\u0d73\u0003\u00d4"+ + "j\u0000\u0d72\u0d71\u0001\u0000\u0000\u0000\u0d72\u0d73\u0001\u0000\u0000"+ + "\u0000\u0d73\u0d92\u0001\u0000\u0000\u0000\u0d74\u0d76\u0003\u00fa}\u0000"+ + "\u0d75\u0d77\u0003\u0100\u0080\u0000\u0d76\u0d75\u0001\u0000\u0000\u0000"+ + "\u0d77\u0d78\u0001\u0000\u0000\u0000\u0d78\u0d76\u0001\u0000\u0000\u0000"+ + "\u0d78\u0d79\u0001\u0000\u0000\u0000\u0d79\u0d7f\u0001\u0000\u0000\u0000"+ + "\u0d7a\u0d7c\u0005\u00b5\u0000\u0000\u0d7b\u0d7d\u0007,\u0000\u0000\u0d7c"+ + "\u0d7b\u0001\u0000\u0000\u0000\u0d7c\u0d7d\u0001\u0000\u0000\u0000\u0d7d"+ + "\u0d7e\u0001\u0000\u0000\u0000\u0d7e\u0d80\u0003\u00f8|\u0000\u0d7f\u0d7a"+ + "\u0001\u0000\u0000\u0000\u0d7f\u0d80\u0001\u0000\u0000\u0000\u0d80\u0d82"+ + "\u0001\u0000\u0000\u0000\u0d81\u0d83\u0003\u00e6s\u0000\u0d82\u0d81\u0001"+ + "\u0000\u0000\u0000\u0d82\u0d83\u0001\u0000\u0000\u0000\u0d83\u0d85\u0001"+ + "\u0000\u0000\u0000\u0d84\u0d86\u0003\u0126\u0093\u0000\u0d85\u0d84\u0001"+ + "\u0000\u0000\u0000\u0d85\u0d86\u0001\u0000\u0000\u0000\u0d86\u0d88\u0001"+ + "\u0000\u0000\u0000\u0d87\u0d89\u0003\u00d4j\u0000\u0d88\u0d87\u0001\u0000"+ + "\u0000\u0000\u0d88\u0d89\u0001\u0000\u0000\u0000\u0d89\u0d92\u0001\u0000"+ + "\u0000\u0000\u0d8a\u0d8d\u0003\u00fe\u007f\u0000\u0d8b\u0d8c\u0005\u0470"+ + "\u0000\u0000\u0d8c\u0d8e\u0003\u0104\u0082\u0000\u0d8d\u0d8b\u0001\u0000"+ + "\u0000\u0000\u0d8e\u0d8f\u0001\u0000\u0000\u0000\u0d8f\u0d8d\u0001\u0000"+ + "\u0000\u0000\u0d8f\u0d90\u0001\u0000\u0000\u0000\u0d90\u0d92\u0001\u0000"+ + "\u0000\u0000\u0d91\u0d50\u0001\u0000\u0000\u0000\u0d91\u0d54\u0001\u0000"+ + "\u0000\u0000\u0d91\u0d5a\u0001\u0000\u0000\u0000\u0d91\u0d74\u0001\u0000"+ + "\u0000\u0000\u0d91\u0d8a\u0001\u0000\u0000\u0000\u0d92\u00c9\u0001\u0000"+ + "\u0000\u0000\u0d93\u0d96\u0003\u00e2q\u0000\u0d94\u0d96\u0003\u00e4r\u0000"+ + "\u0d95\u0d93\u0001\u0000\u0000\u0000\u0d95\u0d94\u0001\u0000\u0000\u0000"+ + "\u0d96\u00cb\u0001\u0000\u0000\u0000\u0d97\u0d98\u0005\u00bd\u0000\u0000"+ + "\u0d98\u0d9a\u0005\u046e\u0000\u0000\u0d99\u0d9b\u0003\u0272\u0139\u0000"+ + "\u0d9a\u0d99\u0001\u0000\u0000\u0000\u0d9a\u0d9b\u0001\u0000\u0000\u0000"+ + "\u0d9b\u0d9c\u0001\u0000\u0000\u0000\u0d9c\u0da5\u0005\u046f\u0000\u0000"+ + "\u0d9d\u0d9e\u0005\u0470\u0000\u0000\u0d9e\u0da0\u0005\u046e\u0000\u0000"+ + "\u0d9f\u0da1\u0003\u0272\u0139\u0000\u0da0\u0d9f\u0001\u0000\u0000\u0000"+ + "\u0da0\u0da1\u0001\u0000\u0000\u0000\u0da1\u0da2\u0001\u0000\u0000\u0000"+ + "\u0da2\u0da4\u0005\u046f\u0000\u0000\u0da3\u0d9d\u0001\u0000\u0000\u0000"+ + "\u0da4\u0da7\u0001\u0000\u0000\u0000\u0da5\u0da3\u0001\u0000\u0000\u0000"+ + "\u0da5\u0da6\u0001\u0000\u0000\u0000\u0da6\u00cd\u0001\u0000\u0000\u0000"+ + "\u0da7\u0da5\u0001\u0000\u0000\u0000\u0da8\u0dbb\u0003\u00c8d\u0000\u0da9"+ + "\u0daa\u0007-\u0000\u0000\u0daa\u0dac\u0005\u046e\u0000\u0000\u0dab\u0dad"+ + "\u0003\u0272\u0139\u0000\u0dac\u0dab\u0001\u0000\u0000\u0000\u0dac\u0dad"+ + "\u0001\u0000\u0000\u0000\u0dad\u0dae\u0001\u0000\u0000\u0000\u0dae\u0db7"+ + "\u0005\u046f\u0000\u0000\u0daf\u0db0\u0005\u0470\u0000\u0000\u0db0\u0db2"+ + "\u0005\u046e\u0000\u0000\u0db1\u0db3\u0003\u0272\u0139\u0000\u0db2\u0db1"+ + "\u0001\u0000\u0000\u0000\u0db2\u0db3\u0001\u0000\u0000\u0000\u0db3\u0db4"+ + "\u0001\u0000\u0000\u0000\u0db4\u0db6\u0005\u046f\u0000\u0000\u0db5\u0daf"+ + "\u0001\u0000\u0000\u0000\u0db6\u0db9\u0001\u0000\u0000\u0000\u0db7\u0db5"+ + "\u0001\u0000\u0000\u0000\u0db7\u0db8\u0001\u0000\u0000\u0000\u0db8\u0dbb"+ + "\u0001\u0000\u0000\u0000\u0db9\u0db7\u0001\u0000\u0000\u0000\u0dba\u0da8"+ + "\u0001\u0000\u0000\u0000\u0dba\u0da9\u0001\u0000\u0000\u0000\u0dbb\u00cf"+ + "\u0001\u0000\u0000\u0000\u0dbc\u0dbd\u0003\u022c\u0116\u0000\u0dbd\u0dc0"+ + "\u0005\u0465\u0000\u0000\u0dbe\u0dc1\u0003\u02b0\u0158\u0000\u0dbf\u0dc1"+ + "\u0005+\u0000\u0000\u0dc0\u0dbe\u0001\u0000\u0000\u0000\u0dc0\u0dbf\u0001"+ + "\u0000\u0000\u0000\u0dc1\u00d1\u0001\u0000\u0000\u0000\u0dc2\u0dc5\u0003"+ + "\u0248\u0124\u0000\u0dc3\u0dc5\u0005\u0488\u0000\u0000\u0dc4\u0dc2\u0001"+ + "\u0000\u0000\u0000\u0dc4\u0dc3\u0001\u0000\u0000\u0000\u0dc5\u00d3\u0001"+ + "\u0000\u0000\u0000\u0dc6\u0dc7\u0005B\u0000\u0000\u0dc7\u0dcd\u0005\u00b9"+ + "\u0000\u0000\u0dc8\u0dc9\u0005h\u0000\u0000\u0dc9\u0dca\u0005Q\u0000\u0000"+ + "\u0dca\u0dcb\u0005\u0263\u0000\u0000\u0dcb\u0dcd\u0005\u0200\u0000\u0000"+ + "\u0dcc\u0dc6\u0001\u0000\u0000\u0000\u0dcc\u0dc8\u0001\u0000\u0000\u0000"+ + "\u0dcd\u00d5\u0001\u0000\u0000\u0000\u0dce\u0dd0\u0005-\u0000\u0000\u0dcf"+ + "\u0dd1\u0005k\u0000\u0000\u0dd0\u0dcf\u0001\u0000\u0000\u0000\u0dd0\u0dd1"+ + "\u0001\u0000\u0000\u0000\u0dd1\u0dd3\u0001\u0000\u0000\u0000\u0dd2\u0dd4"+ + "\u0005\u0239\u0000\u0000\u0dd3\u0dd2\u0001\u0000\u0000\u0000\u0dd3\u0dd4"+ + "\u0001\u0000\u0000\u0000\u0dd4\u0dd6\u0001\u0000\u0000\u0000\u0dd5\u0dd7"+ + "\u0005O\u0000\u0000\u0dd6\u0dd5\u0001\u0000\u0000\u0000\u0dd6\u0dd7\u0001"+ + "\u0000\u0000\u0000\u0dd7\u0dd8\u0001\u0000\u0000\u0000\u0dd8\u0dd9\u0005"+ + "E\u0000\u0000\u0dd9\u0dde\u0003\u0228\u0114\u0000\u0dda\u0ddc\u0005\r"+ + "\u0000\u0000\u0ddb\u0dda\u0001\u0000\u0000\u0000\u0ddb\u0ddc\u0001\u0000"+ + "\u0000\u0000\u0ddc\u0ddd\u0001\u0000\u0000\u0000\u0ddd\u0ddf\u0003\u0248"+ + "\u0124\u0000\u0dde\u0ddb\u0001\u0000\u0000\u0000\u0dde\u0ddf\u0001\u0000"+ + "\u0000\u0000\u0ddf\u0de5\u0001\u0000\u0000\u0000\u0de0\u0de1\u0005\u0082"+ + "\u0000\u0000\u0de1\u0de2\u0005\u046e\u0000\u0000\u0de2\u0de3\u0003\u0268"+ + "\u0134\u0000\u0de3\u0de4\u0005\u046f\u0000\u0000\u0de4\u0de6\u0001\u0000"+ + "\u0000\u0000\u0de5\u0de0\u0001\u0000\u0000\u0000\u0de5\u0de6\u0001\u0000"+ + "\u0000\u0000\u0de6\u0de9\u0001\u0000\u0000\u0000\u0de7\u0de8\u0005\u00bf"+ + "\u0000\u0000\u0de8\u0dea\u0003\u02b0\u0158\u0000\u0de9\u0de7\u0001\u0000"+ + "\u0000\u0000\u0de9\u0dea\u0001\u0000\u0000\u0000\u0dea\u0dec\u0001\u0000"+ + "\u0000\u0000\u0deb\u0ded\u0003\u00e6s\u0000\u0dec\u0deb\u0001\u0000\u0000"+ + "\u0000\u0dec\u0ded\u0001\u0000\u0000\u0000\u0ded\u0df0\u0001\u0000\u0000"+ + "\u0000\u0dee\u0def\u0005d\u0000\u0000\u0def\u0df1\u0003\u0128\u0094\u0000"+ + "\u0df0\u0dee\u0001\u0000\u0000\u0000\u0df0\u0df1\u0001\u0000\u0000\u0000"+ + "\u0df1\u00d7\u0001\u0000\u0000\u0000\u0df2\u0df4\u0005-\u0000\u0000\u0df3"+ + "\u0df5\u0005k\u0000\u0000\u0df4\u0df3\u0001\u0000\u0000\u0000\u0df4\u0df5"+ + "\u0001\u0000\u0000\u0000\u0df5\u0df7\u0001\u0000\u0000\u0000\u0df6\u0df8"+ + "\u0005\u0239\u0000\u0000\u0df7\u0df6\u0001\u0000\u0000\u0000\u0df7\u0df8"+ + "\u0001\u0000\u0000\u0000\u0df8\u0dfa\u0001\u0000\u0000\u0000\u0df9\u0dfb"+ + "\u0005O\u0000\u0000\u0dfa\u0df9\u0001\u0000\u0000\u0000\u0dfa\u0dfb\u0001"+ + "\u0000\u0000\u0000\u0dfb\u0e23\u0001\u0000\u0000\u0000\u0dfc\u0dff\u0003"+ + "\u0228\u0114\u0000\u0dfd\u0dfe\u0005\u046d\u0000\u0000\u0dfe\u0e00\u0005"+ + "\u045e\u0000\u0000\u0dff\u0dfd\u0001\u0000\u0000\u0000\u0dff\u0e00\u0001"+ + "\u0000\u0000\u0000\u0e00\u0e09\u0001\u0000\u0000\u0000\u0e01\u0e02\u0005"+ + "\u0470\u0000\u0000\u0e02\u0e05\u0003\u0228\u0114\u0000\u0e03\u0e04\u0005"+ + "\u046d\u0000\u0000\u0e04\u0e06\u0005\u045e\u0000\u0000\u0e05\u0e03\u0001"+ + "\u0000\u0000\u0000\u0e05\u0e06\u0001\u0000\u0000\u0000\u0e06\u0e08\u0001"+ + "\u0000\u0000\u0000\u0e07\u0e01\u0001\u0000\u0000\u0000\u0e08\u0e0b\u0001"+ + "\u0000\u0000\u0000\u0e09\u0e07\u0001\u0000\u0000\u0000\u0e09\u0e0a\u0001"+ + "\u0000\u0000\u0000\u0e0a\u0e0c\u0001\u0000\u0000\u0000\u0e0b\u0e09\u0001"+ + "\u0000\u0000\u0000\u0e0c\u0e0d\u0005E\u0000\u0000\u0e0d\u0e0e\u0003\u00ea"+ + "u\u0000\u0e0e\u0e24\u0001\u0000\u0000\u0000\u0e0f\u0e10\u0005E\u0000\u0000"+ + "\u0e10\u0e13\u0003\u0228\u0114\u0000\u0e11\u0e12\u0005\u046d\u0000\u0000"+ + "\u0e12\u0e14\u0005\u045e\u0000\u0000\u0e13\u0e11\u0001\u0000\u0000\u0000"+ + "\u0e13\u0e14\u0001\u0000\u0000\u0000\u0e14\u0e1d\u0001\u0000\u0000\u0000"+ + "\u0e15\u0e16\u0005\u0470\u0000\u0000\u0e16\u0e19\u0003\u0228\u0114\u0000"+ + "\u0e17\u0e18\u0005\u046d\u0000\u0000\u0e18\u0e1a\u0005\u045e\u0000\u0000"+ + "\u0e19\u0e17\u0001\u0000\u0000\u0000\u0e19\u0e1a\u0001\u0000\u0000\u0000"+ + "\u0e1a\u0e1c\u0001\u0000\u0000\u0000\u0e1b\u0e15\u0001\u0000\u0000\u0000"+ + "\u0e1c\u0e1f\u0001\u0000\u0000\u0000\u0e1d\u0e1b\u0001\u0000\u0000\u0000"+ + "\u0e1d\u0e1e\u0001\u0000\u0000\u0000\u0e1e\u0e20\u0001\u0000\u0000\u0000"+ + "\u0e1f\u0e1d\u0001\u0000\u0000\u0000\u0e20\u0e21\u0005\u00bc\u0000\u0000"+ + "\u0e21\u0e22\u0003\u00eau\u0000\u0e22\u0e24\u0001\u0000\u0000\u0000\u0e23"+ + "\u0dfc\u0001\u0000\u0000\u0000\u0e23\u0e0f\u0001\u0000\u0000\u0000\u0e24"+ + "\u0e27\u0001\u0000\u0000\u0000\u0e25\u0e26\u0005\u00bf\u0000\u0000\u0e26"+ + "\u0e28\u0003\u02b0\u0158\u0000\u0e27\u0e25\u0001\u0000\u0000\u0000\u0e27"+ + "\u0e28\u0001\u0000\u0000\u0000\u0e28\u00d9\u0001\u0000\u0000\u0000\u0e29"+ + "\u0e2a\u0005\u01bb\u0000\u0000\u0e2a\u0e2b\u0003\u0228\u0114\u0000\u0e2b"+ + "\u0e30\u0005\u021c\u0000\u0000\u0e2c\u0e2e\u0005\r\u0000\u0000\u0e2d\u0e2c"+ + "\u0001\u0000\u0000\u0000\u0e2d\u0e2e\u0001\u0000\u0000\u0000\u0e2e\u0e2f"+ + "\u0001\u0000\u0000\u0000\u0e2f\u0e31\u0003\u0248\u0124\u0000\u0e30\u0e2d"+ + "\u0001\u0000\u0000\u0000\u0e30\u0e31\u0001\u0000\u0000\u0000\u0e31\u00db"+ + "\u0001\u0000\u0000\u0000\u0e32\u0e33\u0005\u01bb\u0000\u0000\u0e33\u0e34"+ + "\u0003\u0228\u0114\u0000\u0e34\u0e35\u0005\u0087\u0000\u0000\u0e35\u0e3c"+ + "\u0003\u0248\u0124\u0000\u0e36\u0e37\u0003\u02b8\u015c\u0000\u0e37\u0e38"+ + "\u0005\u046e\u0000\u0000\u0e38\u0e39\u0003\u0274\u013a\u0000\u0e39\u0e3a"+ + "\u0005\u046f\u0000\u0000\u0e3a\u0e3d\u0001\u0000\u0000\u0000\u0e3b\u0e3d"+ + "\u0007.\u0000\u0000\u0e3c\u0e36\u0001\u0000\u0000\u0000\u0e3c\u0e3b\u0001"+ + "\u0000\u0000\u0000\u0e3d\u0e40\u0001\u0000\u0000\u0000\u0e3e\u0e3f\u0005"+ + "\u00bf\u0000\u0000\u0e3f\u0e41\u0003\u02b0\u0158\u0000\u0e40\u0e3e\u0001"+ + "\u0000\u0000\u0000\u0e40\u0e41\u0001\u0000\u0000\u0000\u0e41\u0e44\u0001"+ + "\u0000\u0000\u0000\u0e42\u0e43\u0005d\u0000\u0000\u0e43\u0e45\u0003\u0128"+ + "\u0094\u0000\u0e44\u0e42\u0001\u0000\u0000\u0000\u0e44\u0e45\u0001\u0000"+ + "\u0000\u0000\u0e45\u00dd\u0001\u0000\u0000\u0000\u0e46\u0e47\u0005\u01bb"+ + "\u0000\u0000\u0e47\u0e48\u0003\u0228\u0114\u0000\u0e48\u0e49\u0005\u0087"+ + "\u0000\u0000\u0e49\u0e4c\u0007/\u0000\u0000\u0e4a\u0e4b\u0005\u00bf\u0000"+ + "\u0000\u0e4b\u0e4d\u0003\u02b0\u0158\u0000\u0e4c\u0e4a\u0001\u0000\u0000"+ + "\u0000\u0e4c\u0e4d\u0001\u0000\u0000\u0000\u0e4d\u0e50\u0001\u0000\u0000"+ + "\u0000\u0e4e\u0e4f\u0005d\u0000\u0000\u0e4f\u0e51\u0003\u0128\u0094\u0000"+ + "\u0e50\u0e4e\u0001\u0000\u0000\u0000\u0e50\u0e51\u0001\u0000\u0000\u0000"+ + "\u0e51\u00df\u0001\u0000\u0000\u0000\u0e52\u0e53\u0005\u01bb\u0000\u0000"+ + "\u0e53\u0e54\u0003\u0228\u0114\u0000\u0e54\u0e55\u0005\u016a\u0000\u0000"+ + "\u0e55\u00e1\u0001\u0000\u0000\u0000\u0e56\u0e58\u0005\u00b9\u0000\u0000"+ + "\u0e57\u0e59\u0005k\u0000\u0000\u0e58\u0e57\u0001\u0000\u0000\u0000\u0e58"+ + "\u0e59\u0001\u0000\u0000\u0000\u0e59\u0e5b\u0001\u0000\u0000\u0000\u0e5a"+ + "\u0e5c\u0005O\u0000\u0000\u0e5b\u0e5a\u0001\u0000\u0000\u0000\u0e5b\u0e5c"+ + "\u0001\u0000\u0000\u0000\u0e5c\u0e5d\u0001\u0000\u0000\u0000\u0e5d\u0e62"+ + "\u0003\u0228\u0114\u0000\u0e5e\u0e60\u0005\r\u0000\u0000\u0e5f\u0e5e\u0001"+ + "\u0000\u0000\u0000\u0e5f\u0e60\u0001\u0000\u0000\u0000\u0e60\u0e61\u0001"+ + "\u0000\u0000\u0000\u0e61\u0e63\u0003\u0248\u0124\u0000\u0e62\u0e5f\u0001"+ + "\u0000\u0000\u0000\u0e62\u0e63\u0001\u0000\u0000\u0000\u0e63\u0e64\u0001"+ + "\u0000\u0000\u0000\u0e64\u0e65\u0005\u009a\u0000\u0000\u0e65\u0e6a\u0003"+ + "\u00d0h\u0000\u0e66\u0e67\u0005\u0470\u0000\u0000\u0e67\u0e69\u0003\u00d0"+ + "h\u0000\u0e68\u0e66\u0001\u0000\u0000\u0000\u0e69\u0e6c\u0001\u0000\u0000"+ + "\u0000\u0e6a\u0e68\u0001\u0000\u0000\u0000\u0e6a\u0e6b\u0001\u0000\u0000"+ + "\u0000\u0e6b\u0e6f\u0001\u0000\u0000\u0000\u0e6c\u0e6a\u0001\u0000\u0000"+ + "\u0000\u0e6d\u0e6e\u0005\u00bf\u0000\u0000\u0e6e\u0e70\u0003\u02b0\u0158"+ + "\u0000\u0e6f\u0e6d\u0001\u0000\u0000\u0000\u0e6f\u0e70\u0001\u0000\u0000"+ + "\u0000\u0e70\u0e72\u0001\u0000\u0000\u0000\u0e71\u0e73\u0003\u00e6s\u0000"+ + "\u0e72\u0e71\u0001\u0000\u0000\u0000\u0e72\u0e73\u0001\u0000\u0000\u0000"+ + "\u0e73\u0e75\u0001\u0000\u0000\u0000\u0e74\u0e76\u0003\u0126\u0093\u0000"+ + "\u0e75\u0e74\u0001\u0000\u0000\u0000\u0e75\u0e76\u0001\u0000\u0000\u0000"+ + "\u0e76\u00e3\u0001\u0000\u0000\u0000\u0e77\u0e79\u0005\u00b9\u0000\u0000"+ + "\u0e78\u0e7a\u0005k\u0000\u0000\u0e79\u0e78\u0001\u0000\u0000\u0000\u0e79"+ + "\u0e7a\u0001\u0000\u0000\u0000\u0e7a\u0e7c\u0001\u0000\u0000\u0000\u0e7b"+ + "\u0e7d\u0005O\u0000\u0000\u0e7c\u0e7b\u0001\u0000\u0000\u0000\u0e7c\u0e7d"+ + "\u0001\u0000\u0000\u0000\u0e7d\u0e7e\u0001\u0000\u0000\u0000\u0e7e\u0e7f"+ + "\u0003\u00eau\u0000\u0e7f\u0e80\u0005\u009a\u0000\u0000\u0e80\u0e85\u0003"+ + "\u00d0h\u0000\u0e81\u0e82\u0005\u0470\u0000\u0000\u0e82\u0e84\u0003\u00d0"+ + "h\u0000\u0e83\u0e81\u0001\u0000\u0000\u0000\u0e84\u0e87\u0001\u0000\u0000"+ + "\u0000\u0e85\u0e83\u0001\u0000\u0000\u0000\u0e85\u0e86\u0001\u0000\u0000"+ + "\u0000\u0e86\u0e8a\u0001\u0000\u0000\u0000\u0e87\u0e85\u0001\u0000\u0000"+ + "\u0000\u0e88\u0e89\u0005\u00bf\u0000\u0000\u0e89\u0e8b\u0003\u02b0\u0158"+ + "\u0000\u0e8a\u0e88\u0001\u0000\u0000\u0000\u0e8a\u0e8b\u0001\u0000\u0000"+ + "\u0000\u0e8b\u00e5\u0001\u0000\u0000\u0000\u0e8c\u0e8d\u0005}\u0000\u0000"+ + "\u0e8d\u0e8e\u0005\u0014\u0000\u0000\u0e8e\u0e93\u0003\u00e8t\u0000\u0e8f"+ + "\u0e90\u0005\u0470\u0000\u0000\u0e90\u0e92\u0003\u00e8t\u0000\u0e91\u0e8f"+ + "\u0001\u0000\u0000\u0000\u0e92\u0e95\u0001\u0000\u0000\u0000\u0e93\u0e91"+ + "\u0001\u0000\u0000\u0000\u0e93\u0e94\u0001\u0000\u0000\u0000\u0e94\u00e7"+ + "\u0001\u0000\u0000\u0000\u0e95\u0e93\u0001\u0000\u0000\u0000\u0e96\u0e98"+ + "\u0003\u02b0\u0158\u0000\u0e97\u0e99\u00070\u0000\u0000\u0e98\u0e97\u0001"+ + "\u0000\u0000\u0000\u0e98\u0e99\u0001\u0000\u0000\u0000\u0e99\u00e9\u0001"+ + "\u0000\u0000\u0000\u0e9a\u0e9f\u0003\u00ecv\u0000\u0e9b\u0e9c\u0005\u0470"+ + "\u0000\u0000\u0e9c\u0e9e\u0003\u00ecv\u0000\u0e9d\u0e9b\u0001\u0000\u0000"+ + "\u0000\u0e9e\u0ea1\u0001\u0000\u0000\u0000\u0e9f\u0e9d\u0001\u0000\u0000"+ + "\u0000\u0e9f\u0ea0\u0001\u0000\u0000\u0000\u0ea0\u00eb\u0001\u0000\u0000"+ + "\u0000\u0ea1\u0e9f\u0001\u0000\u0000\u0000\u0ea2\u0ea6\u0003\u00eew\u0000"+ + "\u0ea3\u0ea5\u0003\u00f4z\u0000\u0ea4\u0ea3\u0001\u0000\u0000\u0000\u0ea5"+ + "\u0ea8\u0001\u0000\u0000\u0000\u0ea6\u0ea4\u0001\u0000\u0000\u0000\u0ea6"+ + "\u0ea7\u0001\u0000\u0000\u0000\u0ea7\u0eb5\u0001\u0000\u0000\u0000\u0ea8"+ + "\u0ea6\u0001\u0000\u0000\u0000\u0ea9\u0eaa\u0005\u046e\u0000\u0000\u0eaa"+ + "\u0eae\u0003\u00eew\u0000\u0eab\u0ead\u0003\u00f4z\u0000\u0eac\u0eab\u0001"+ + "\u0000\u0000\u0000\u0ead\u0eb0\u0001\u0000\u0000\u0000\u0eae\u0eac\u0001"+ + "\u0000\u0000\u0000\u0eae\u0eaf\u0001\u0000\u0000\u0000\u0eaf\u0eb1\u0001"+ + "\u0000\u0000\u0000\u0eb0\u0eae\u0001\u0000\u0000\u0000\u0eb1\u0eb2\u0005"+ + "\u046f\u0000\u0000\u0eb2\u0eb5\u0001\u0000\u0000\u0000\u0eb3\u0eb5\u0003"+ + "\u0106\u0083\u0000\u0eb4\u0ea2\u0001\u0000\u0000\u0000\u0eb4\u0ea9\u0001"+ + "\u0000\u0000\u0000\u0eb4\u0eb3\u0001\u0000\u0000\u0000\u0eb5\u00ed\u0001"+ + "\u0000\u0000\u0000\u0eb6\u0ebc\u0003\u0228\u0114\u0000\u0eb7\u0eb8\u0005"+ + "\u0082\u0000\u0000\u0eb8\u0eb9\u0005\u046e\u0000\u0000\u0eb9\u0eba\u0003"+ + "\u0268\u0134\u0000\u0eba\u0ebb\u0005\u046f\u0000\u0000\u0ebb\u0ebd\u0001"+ + "\u0000\u0000\u0000\u0ebc\u0eb7\u0001\u0000\u0000\u0000\u0ebc\u0ebd\u0001"+ + "\u0000\u0000\u0000\u0ebd\u0ec2\u0001\u0000\u0000\u0000\u0ebe\u0ec0\u0005"+ + "\r\u0000\u0000\u0ebf\u0ebe\u0001\u0000\u0000\u0000\u0ebf\u0ec0\u0001\u0000"+ + "\u0000\u0000\u0ec0\u0ec1\u0001\u0000\u0000\u0000\u0ec1\u0ec3\u0003\u0248"+ + "\u0124\u0000\u0ec2\u0ebf\u0001\u0000\u0000\u0000\u0ec2\u0ec3\u0001\u0000"+ + "\u0000\u0000\u0ec3\u0ecc\u0001\u0000\u0000\u0000\u0ec4\u0ec9\u0003\u00f0"+ + "x\u0000\u0ec5\u0ec6\u0005\u0470\u0000\u0000\u0ec6\u0ec8\u0003\u00f0x\u0000"+ + "\u0ec7\u0ec5\u0001\u0000\u0000\u0000\u0ec8\u0ecb\u0001\u0000\u0000\u0000"+ + "\u0ec9\u0ec7\u0001\u0000\u0000\u0000\u0ec9\u0eca\u0001\u0000\u0000\u0000"+ + "\u0eca\u0ecd\u0001\u0000\u0000\u0000\u0ecb\u0ec9\u0001\u0000\u0000\u0000"+ + "\u0ecc\u0ec4\u0001\u0000\u0000\u0000\u0ecc\u0ecd\u0001\u0000\u0000\u0000"+ + "\u0ecd\u0edf\u0001\u0000\u0000\u0000\u0ece\u0ed4\u0003\u00c8d\u0000\u0ecf"+ + "\u0ed0\u0005\u046e\u0000\u0000\u0ed0\u0ed1\u0003\u00c8d\u0000\u0ed1\u0ed2"+ + "\u0005\u046f\u0000\u0000\u0ed2\u0ed4\u0001\u0000\u0000\u0000\u0ed3\u0ece"+ + "\u0001\u0000\u0000\u0000\u0ed3\u0ecf\u0001\u0000\u0000\u0000\u0ed4\u0ed6"+ + "\u0001\u0000\u0000\u0000\u0ed5\u0ed7\u0005\r\u0000\u0000\u0ed6\u0ed5\u0001"+ + "\u0000\u0000\u0000\u0ed6\u0ed7\u0001\u0000\u0000\u0000\u0ed7\u0ed8\u0001"+ + "\u0000\u0000\u0000\u0ed8\u0ed9\u0003\u0248\u0124\u0000\u0ed9\u0edf\u0001"+ + "\u0000\u0000\u0000\u0eda\u0edb\u0005\u046e\u0000\u0000\u0edb\u0edc\u0003"+ + "\u00eau\u0000\u0edc\u0edd\u0005\u046f\u0000\u0000\u0edd\u0edf\u0001\u0000"+ + "\u0000\u0000\u0ede\u0eb6\u0001\u0000\u0000\u0000\u0ede\u0ed3\u0001\u0000"+ + "\u0000\u0000\u0ede\u0eda\u0001\u0000\u0000\u0000\u0edf\u00ef\u0001\u0000"+ + "\u0000\u0000\u0ee0\u0ee1\u00071\u0000\u0000\u0ee1\u0ee4\u0007\u0014\u0000"+ + "\u0000\u0ee2\u0ee3\u0005B\u0000\u0000\u0ee3\u0ee5\u0003\u00f2y\u0000\u0ee4"+ + "\u0ee2\u0001\u0000\u0000\u0000\u0ee4\u0ee5\u0001\u0000\u0000\u0000\u0ee5"+ + "\u0ee6\u0001\u0000\u0000\u0000\u0ee6\u0ee7\u0005\u046e\u0000\u0000\u0ee7"+ + "\u0ee8\u0003\u0268\u0134\u0000\u0ee8\u0ee9\u0005\u046f\u0000\u0000\u0ee9"+ + "\u00f1\u0001\u0000\u0000\u0000\u0eea\u0ef0\u0005[\u0000\u0000\u0eeb\u0eec"+ + "\u0005}\u0000\u0000\u0eec\u0ef0\u0005\u0014\u0000\u0000\u0eed\u0eee\u0005"+ + "J\u0000\u0000\u0eee\u0ef0\u0005\u0014\u0000\u0000\u0eef\u0eea\u0001\u0000"+ + "\u0000\u0000\u0eef\u0eeb\u0001\u0000\u0000\u0000\u0eef\u0eed\u0001\u0000"+ + "\u0000\u0000\u0ef0\u00f3\u0001\u0000\u0000\u0000\u0ef1\u0ef3\u00072\u0000"+ + "\u0000\u0ef2\u0ef1\u0001\u0000\u0000\u0000\u0ef2\u0ef3\u0001\u0000\u0000"+ + "\u0000\u0ef3\u0ef4\u0001\u0000\u0000\u0000\u0ef4\u0ef6\u0005[\u0000\u0000"+ + "\u0ef5\u0ef7\u0005_\u0000\u0000\u0ef6\u0ef5\u0001\u0000\u0000\u0000\u0ef6"+ + "\u0ef7\u0001\u0000\u0000\u0000\u0ef7\u0ef8\u0001\u0000\u0000\u0000\u0ef8"+ + "\u0efc\u0003\u00eew\u0000\u0ef9\u0efb\u0003\u00f6{\u0000\u0efa\u0ef9\u0001"+ + "\u0000\u0000\u0000\u0efb\u0efe\u0001\u0000\u0000\u0000\u0efc\u0efa\u0001"+ + "\u0000\u0000\u0000\u0efc\u0efd\u0001\u0000\u0000\u0000\u0efd\u0f21\u0001"+ + "\u0000\u0000\u0000\u0efe\u0efc\u0001\u0000\u0000\u0000\u0eff\u0f00\u0005"+ + "\u00ac\u0000\u0000\u0f00\u0f05\u0003\u00eew\u0000\u0f01\u0f02\u0005w\u0000"+ + "\u0000\u0f02\u0f04\u0003\u02b0\u0158\u0000\u0f03\u0f01\u0001\u0000\u0000"+ + "\u0000\u0f04\u0f07\u0001\u0000\u0000\u0000\u0f05\u0f03\u0001\u0000\u0000"+ + "\u0000\u0f05\u0f06\u0001\u0000\u0000\u0000\u0f06\u0f21\u0001\u0000\u0000"+ + "\u0000\u0f07\u0f05\u0001\u0000\u0000\u0000\u0f08\u0f0a\u00073\u0000\u0000"+ + "\u0f09\u0f0b\u0005\u007f\u0000\u0000\u0f0a\u0f09\u0001\u0000\u0000\u0000"+ + "\u0f0a\u0f0b\u0001\u0000\u0000\u0000\u0f0b\u0f0c\u0001\u0000\u0000\u0000"+ + "\u0f0c\u0f0e\u0005[\u0000\u0000\u0f0d\u0f0f\u0005_\u0000\u0000\u0f0e\u0f0d"+ + "\u0001\u0000\u0000\u0000\u0f0e\u0f0f\u0001\u0000\u0000\u0000\u0f0f\u0f10"+ + "\u0001\u0000\u0000\u0000\u0f10\u0f14\u0003\u00eew\u0000\u0f11\u0f13\u0003"+ + "\u00f6{\u0000\u0f12\u0f11\u0001\u0000\u0000\u0000\u0f13\u0f16\u0001\u0000"+ + "\u0000\u0000\u0f14\u0f12\u0001\u0000\u0000\u0000\u0f14\u0f15\u0001\u0000"+ + "\u0000\u0000\u0f15\u0f21\u0001\u0000\u0000\u0000\u0f16\u0f14\u0001\u0000"+ + "\u0000\u0000\u0f17\u0f1c\u0005r\u0000\u0000\u0f18\u0f1a\u00073\u0000\u0000"+ + "\u0f19\u0f1b\u0005\u007f\u0000\u0000\u0f1a\u0f19\u0001\u0000\u0000\u0000"+ + "\u0f1a\u0f1b\u0001\u0000\u0000\u0000\u0f1b\u0f1d\u0001\u0000\u0000\u0000"+ + "\u0f1c\u0f18\u0001\u0000\u0000\u0000\u0f1c\u0f1d\u0001\u0000"; + private static final String _serializedATNSegment2 = + "\u0000\u0000\u0f1d\u0f1e\u0001\u0000\u0000\u0000\u0f1e\u0f1f\u0005[\u0000"+ + "\u0000\u0f1f\u0f21\u0003\u00eew\u0000\u0f20\u0ef2\u0001\u0000\u0000\u0000"+ + "\u0f20\u0eff\u0001\u0000\u0000\u0000\u0f20\u0f08\u0001\u0000\u0000\u0000"+ + "\u0f20\u0f17\u0001\u0000\u0000\u0000\u0f21\u00f5\u0001\u0000\u0000\u0000"+ + "\u0f22\u0f23\u0005w\u0000\u0000\u0f23\u0f2a\u0003\u02b0\u0158\u0000\u0f24"+ + "\u0f25\u0005\u00bc\u0000\u0000\u0f25\u0f26\u0005\u046e\u0000\u0000\u0f26"+ + "\u0f27\u0003\u0268\u0134\u0000\u0f27\u0f28\u0005\u046f\u0000\u0000\u0f28"+ + "\u0f2a\u0001\u0000\u0000\u0000\u0f29\u0f22\u0001\u0000\u0000\u0000\u0f29"+ + "\u0f24\u0001\u0000\u0000\u0000\u0f2a\u00f7\u0001\u0000\u0000\u0000\u0f2b"+ + "\u0f2c\u0005\u046e\u0000\u0000\u0f2c\u0f2d\u0003\u00fc~\u0000\u0f2d\u0f2e"+ + "\u0005\u046f\u0000\u0000\u0f2e\u0f34\u0001\u0000\u0000\u0000\u0f2f\u0f30"+ + "\u0005\u046e\u0000\u0000\u0f30\u0f31\u0003\u00f8|\u0000\u0f31\u0f32\u0005"+ + "\u046f\u0000\u0000\u0f32\u0f34\u0001\u0000\u0000\u0000\u0f33\u0f2b\u0001"+ + "\u0000\u0000\u0000\u0f33\u0f2f\u0001\u0000\u0000\u0000\u0f34\u00f9\u0001"+ + "\u0000\u0000\u0000\u0f35\u0f36\u0005\u046e\u0000\u0000\u0f36\u0f37\u0003"+ + "\u00fe\u007f\u0000\u0f37\u0f38\u0005\u046f\u0000\u0000\u0f38\u0f3e\u0001"+ + "\u0000\u0000\u0000\u0f39\u0f3a\u0005\u046e\u0000\u0000\u0f3a\u0f3b\u0003"+ + "\u00fa}\u0000\u0f3b\u0f3c\u0005\u046f\u0000\u0000\u0f3c\u0f3e\u0001\u0000"+ + "\u0000\u0000\u0f3d\u0f35\u0001\u0000\u0000\u0000\u0f3d\u0f39\u0001\u0000"+ + "\u0000\u0000\u0f3e\u00fb\u0001\u0000\u0000\u0000\u0f3f\u0f43\u0005\u0099"+ + "\u0000\u0000\u0f40\u0f42\u0003\u0110\u0088\u0000\u0f41\u0f40\u0001\u0000"+ + "\u0000\u0000\u0f42\u0f45\u0001\u0000\u0000\u0000\u0f43\u0f41\u0001\u0000"+ + "\u0000\u0000\u0f43\u0f44\u0001\u0000\u0000\u0000\u0f44\u0f46\u0001\u0000"+ + "\u0000\u0000\u0f45\u0f43\u0001\u0000\u0000\u0000\u0f46\u0f48\u0003\u0112"+ + "\u0089\u0000\u0f47\u0f49\u0003\u0116\u008b\u0000\u0f48\u0f47\u0001\u0000"+ + "\u0000\u0000\u0f48\u0f49\u0001\u0000\u0000\u0000\u0f49\u0f4a\u0001\u0000"+ + "\u0000\u0000\u0f4a\u0f4c\u0003\u011c\u008e\u0000\u0f4b\u0f4d\u0003\u011e"+ + "\u008f\u0000\u0f4c\u0f4b\u0001\u0000\u0000\u0000\u0f4c\u0f4d\u0001\u0000"+ + "\u0000\u0000\u0f4d\u0f4f\u0001\u0000\u0000\u0000\u0f4e\u0f50\u0003\u0120"+ + "\u0090\u0000\u0f4f\u0f4e\u0001\u0000\u0000\u0000\u0f4f\u0f50\u0001\u0000"+ + "\u0000\u0000\u0f50\u0f52\u0001\u0000\u0000\u0000\u0f51\u0f53\u0003\u0122"+ + "\u0091\u0000\u0f52\u0f51\u0001\u0000\u0000\u0000\u0f52\u0f53\u0001\u0000"+ + "\u0000\u0000\u0f53\u0f55\u0001\u0000\u0000\u0000\u0f54\u0f56\u0003\u00e6"+ + "s\u0000\u0f55\u0f54\u0001\u0000\u0000\u0000\u0f55\u0f56\u0001\u0000\u0000"+ + "\u0000\u0f56\u0f58\u0001\u0000\u0000\u0000\u0f57\u0f59\u0003\u0126\u0093"+ + "\u0000\u0f58\u0f57\u0001\u0000\u0000\u0000\u0f58\u0f59\u0001\u0000\u0000"+ + "\u0000\u0f59\u0f76\u0001\u0000\u0000\u0000\u0f5a\u0f5e\u0005\u0099\u0000"+ + "\u0000\u0f5b\u0f5d\u0003\u0110\u0088\u0000\u0f5c\u0f5b\u0001\u0000\u0000"+ + "\u0000\u0f5d\u0f60\u0001\u0000\u0000\u0000\u0f5e\u0f5c\u0001\u0000\u0000"+ + "\u0000\u0f5e\u0f5f\u0001\u0000\u0000\u0000\u0f5f\u0f61\u0001\u0000\u0000"+ + "\u0000\u0f60\u0f5e\u0001\u0000\u0000\u0000\u0f61\u0f62\u0003\u0112\u0089"+ + "\u0000\u0f62\u0f64\u0003\u011c\u008e\u0000\u0f63\u0f65\u0003\u011e\u008f"+ + "\u0000\u0f64\u0f63\u0001\u0000\u0000\u0000\u0f64\u0f65\u0001\u0000\u0000"+ + "\u0000\u0f65\u0f67\u0001\u0000\u0000\u0000\u0f66\u0f68\u0003\u0120\u0090"+ + "\u0000\u0f67\u0f66\u0001\u0000\u0000\u0000\u0f67\u0f68\u0001\u0000\u0000"+ + "\u0000\u0f68\u0f6a\u0001\u0000\u0000\u0000\u0f69\u0f6b\u0003\u0122\u0091"+ + "\u0000\u0f6a\u0f69\u0001\u0000\u0000\u0000\u0f6a\u0f6b\u0001\u0000\u0000"+ + "\u0000\u0f6b\u0f6d\u0001\u0000\u0000\u0000\u0f6c\u0f6e\u0003\u00e6s\u0000"+ + "\u0f6d\u0f6c\u0001\u0000\u0000\u0000\u0f6d\u0f6e\u0001\u0000\u0000\u0000"+ + "\u0f6e\u0f70\u0001\u0000\u0000\u0000\u0f6f\u0f71\u0003\u0126\u0093\u0000"+ + "\u0f70\u0f6f\u0001\u0000\u0000\u0000\u0f70\u0f71\u0001\u0000\u0000\u0000"+ + "\u0f71\u0f73\u0001\u0000\u0000\u0000\u0f72\u0f74\u0003\u0116\u008b\u0000"+ + "\u0f73\u0f72\u0001\u0000\u0000\u0000\u0f73\u0f74\u0001\u0000\u0000\u0000"+ + "\u0f74\u0f76\u0001\u0000\u0000\u0000\u0f75\u0f3f\u0001\u0000\u0000\u0000"+ + "\u0f75\u0f5a\u0001\u0000\u0000\u0000\u0f76\u00fd\u0001\u0000\u0000\u0000"+ + "\u0f77\u0f7b\u0005\u0099\u0000\u0000\u0f78\u0f7a\u0003\u0110\u0088\u0000"+ + "\u0f79\u0f78\u0001\u0000\u0000\u0000\u0f7a\u0f7d\u0001\u0000\u0000\u0000"+ + "\u0f7b\u0f79\u0001\u0000\u0000\u0000\u0f7b\u0f7c\u0001\u0000\u0000\u0000"+ + "\u0f7c\u0f7e\u0001\u0000\u0000\u0000\u0f7d\u0f7b\u0001\u0000\u0000\u0000"+ + "\u0f7e\u0f7f\u0003\u0112\u0089\u0000\u0f7f\u0f81\u0003\u011c\u008e\u0000"+ + "\u0f80\u0f82\u0003\u011e\u008f\u0000\u0f81\u0f80\u0001\u0000\u0000\u0000"+ + "\u0f81\u0f82\u0001\u0000\u0000\u0000\u0f82\u0f84\u0001\u0000\u0000\u0000"+ + "\u0f83\u0f85\u0003\u0120\u0090\u0000\u0f84\u0f83\u0001\u0000\u0000\u0000"+ + "\u0f84\u0f85\u0001\u0000\u0000\u0000\u0f85\u0f87\u0001\u0000\u0000\u0000"+ + "\u0f86\u0f88\u0003\u0122\u0091\u0000\u0f87\u0f86\u0001\u0000\u0000\u0000"+ + "\u0f87\u0f88\u0001\u0000\u0000\u0000\u0f88\u0f8a\u0001\u0000\u0000\u0000"+ + "\u0f89\u0f8b\u0003\u00e6s\u0000\u0f8a\u0f89\u0001\u0000\u0000\u0000\u0f8a"+ + "\u0f8b\u0001\u0000\u0000\u0000\u0f8b\u0f8d\u0001\u0000\u0000\u0000\u0f8c"+ + "\u0f8e\u0003\u0126\u0093\u0000\u0f8d\u0f8c\u0001\u0000\u0000\u0000\u0f8d"+ + "\u0f8e\u0001\u0000\u0000\u0000\u0f8e\u0f90\u0001\u0000\u0000\u0000\u0f8f"+ + "\u0f91\u0003\u0102\u0081\u0000\u0f90\u0f8f\u0001\u0000\u0000\u0000\u0f90"+ + "\u0f91\u0001\u0000\u0000\u0000\u0f91\u00ff\u0001\u0000\u0000\u0000\u0f92"+ + "\u0f94\u0005\u00b5\u0000\u0000\u0f93\u0f95\u0007,\u0000\u0000\u0f94\u0f93"+ + "\u0001\u0000\u0000\u0000\u0f94\u0f95\u0001\u0000\u0000\u0000\u0f95\u0f96"+ + "\u0001\u0000\u0000\u0000\u0f96\u0f97\u0003\u00fa}\u0000\u0f97\u0101\u0001"+ + "\u0000\u0000\u0000\u0f98\u0f9a\u0005\u00b5\u0000\u0000\u0f99\u0f9b\u0007"+ + ",\u0000\u0000\u0f9a\u0f99\u0001\u0000\u0000\u0000\u0f9a\u0f9b\u0001\u0000"+ + "\u0000\u0000\u0f9b\u0f9e\u0001\u0000\u0000\u0000\u0f9c\u0f9f\u0003\u00fe"+ + "\u007f\u0000\u0f9d\u0f9f\u0003\u00fa}\u0000\u0f9e\u0f9c\u0001\u0000\u0000"+ + "\u0000\u0f9e\u0f9d\u0001\u0000\u0000\u0000\u0f9f\u0103\u0001\u0000\u0000"+ + "\u0000\u0fa0\u0faf\u0005_\u0000\u0000\u0fa1\u0fb0\u0003\u00fe\u007f\u0000"+ + "\u0fa2\u0fb0\u0003\u00fa}\u0000\u0fa3\u0fa6\u0005\u046e\u0000\u0000\u0fa4"+ + "\u0fa7\u0003\u00fe\u007f\u0000\u0fa5\u0fa7\u0003\u00fa}\u0000\u0fa6\u0fa4"+ + "\u0001\u0000\u0000\u0000\u0fa6\u0fa5\u0001\u0000\u0000\u0000\u0fa7\u0fa8"+ + "\u0001\u0000\u0000\u0000\u0fa8\u0fad\u0005\u046f\u0000\u0000\u0fa9\u0fab"+ + "\u0005\r\u0000\u0000\u0faa\u0fa9\u0001\u0000\u0000\u0000\u0faa\u0fab\u0001"+ + "\u0000\u0000\u0000\u0fab\u0fac\u0001\u0000\u0000\u0000\u0fac\u0fae\u0003"+ + "\u0248\u0124\u0000\u0fad\u0faa\u0001\u0000\u0000\u0000\u0fad\u0fae\u0001"+ + "\u0000\u0000\u0000\u0fae\u0fb0\u0001\u0000\u0000\u0000\u0faf\u0fa1\u0001"+ + "\u0000\u0000\u0000\u0faf\u0fa2\u0001\u0000\u0000\u0000\u0faf\u0fa3\u0001"+ + "\u0000\u0000\u0000\u0fb0\u0105\u0001\u0000\u0000\u0000\u0fb1\u0fb2\u0005"+ + "\u0117\u0000\u0000\u0fb2\u0fb3\u0005\u046e\u0000\u0000\u0fb3\u0fb4\u0005"+ + "\u047d\u0000\u0000\u0fb4\u0fb5\u0005\u0470\u0000\u0000\u0fb5\u0fb6\u0005"+ + "\u047d\u0000\u0000\u0fb6\u0fb7\u0005\u016e\u0000\u0000\u0fb7\u0fb8\u0005"+ + "\u046e\u0000\u0000\u0fb8\u0fb9\u0003\u0108\u0084\u0000\u0fb9\u0fba\u0005"+ + "\u046f\u0000\u0000\u0fba\u0fbf\u0005\u046f\u0000\u0000\u0fbb\u0fbd\u0005"+ + "\r\u0000\u0000\u0fbc\u0fbb\u0001\u0000\u0000\u0000\u0fbc\u0fbd\u0001\u0000"+ + "\u0000\u0000\u0fbd\u0fbe\u0001\u0000\u0000\u0000\u0fbe\u0fc0\u0003\u0248"+ + "\u0124\u0000\u0fbf\u0fbc\u0001\u0000\u0000\u0000\u0fbf\u0fc0\u0001\u0000"+ + "\u0000\u0000\u0fc0\u0107\u0001\u0000\u0000\u0000\u0fc1\u0fc6\u0003\u010a"+ + "\u0085\u0000\u0fc2\u0fc3\u0005\u0470\u0000\u0000\u0fc3\u0fc5\u0003\u010a"+ + "\u0085\u0000\u0fc4\u0fc2\u0001\u0000\u0000\u0000\u0fc5\u0fc8\u0001\u0000"+ + "\u0000\u0000\u0fc6\u0fc4\u0001\u0000\u0000\u0000\u0fc6\u0fc7\u0001\u0000"+ + "\u0000\u0000\u0fc7\u0109\u0001\u0000\u0000\u0000\u0fc8\u0fc6\u0001\u0000"+ + "\u0000\u0000\u0fc9\u0fda\u0003\u022c\u0116\u0000\u0fca\u0fcb\u0005B\u0000"+ + "\u0000\u0fcb\u0fdb\u0005\u011d\u0000\u0000\u0fcc\u0fd8\u0003\u025c\u012e"+ + "\u0000\u0fcd\u0fce\u0005\u011e\u0000\u0000\u0fce\u0fd0\u0005\u047d\u0000"+ + "\u0000\u0fcf\u0fd1\u0003\u010c\u0086\u0000\u0fd0\u0fcf\u0001\u0000\u0000"+ + "\u0000\u0fd0\u0fd1\u0001\u0000\u0000\u0000\u0fd1\u0fd3\u0001\u0000\u0000"+ + "\u0000\u0fd2\u0fd4\u0003\u010e\u0087\u0000\u0fd3\u0fd2\u0001\u0000\u0000"+ + "\u0000\u0fd3\u0fd4\u0001\u0000\u0000\u0000\u0fd4\u0fd9\u0001\u0000\u0000"+ + "\u0000\u0fd5\u0fd6\u0005=\u0000\u0000\u0fd6\u0fd7\u0005\u011e\u0000\u0000"+ + "\u0fd7\u0fd9\u0005\u047d\u0000\u0000\u0fd8\u0fcd\u0001\u0000\u0000\u0000"+ + "\u0fd8\u0fd5\u0001\u0000\u0000\u0000\u0fd9\u0fdb\u0001\u0000\u0000\u0000"+ + "\u0fda\u0fca\u0001\u0000\u0000\u0000\u0fda\u0fcc\u0001\u0000\u0000\u0000"+ + "\u0fdb\u0fe7\u0001\u0000\u0000\u0000\u0fdc\u0fde\u0005\u011c\u0000\u0000"+ + "\u0fdd\u0fdf\u0005\u011e\u0000\u0000\u0fde\u0fdd\u0001\u0000\u0000\u0000"+ + "\u0fde\u0fdf\u0001\u0000\u0000\u0000\u0fdf\u0fe0\u0001\u0000\u0000\u0000"+ + "\u0fe0\u0fe1\u0005\u047d\u0000\u0000\u0fe1\u0fe2\u0005\u016e\u0000\u0000"+ + "\u0fe2\u0fe3\u0005\u046e\u0000\u0000\u0fe3\u0fe4\u0003\u0108\u0084\u0000"+ + "\u0fe4\u0fe5\u0005\u046f\u0000\u0000\u0fe5\u0fe7\u0001\u0000\u0000\u0000"+ + "\u0fe6\u0fc9\u0001\u0000\u0000\u0000\u0fe6\u0fdc\u0001\u0000\u0000\u0000"+ + "\u0fe7\u010b\u0001\u0000\u0000\u0000\u0fe8\u0fed\u0005u\u0000\u0000\u0fe9"+ + "\u0fed\u0005\u019c\u0000\u0000\u0fea\u0feb\u0005+\u0000\u0000\u0feb\u0fed"+ + "\u0003\u027a\u013d\u0000\u0fec\u0fe8\u0001\u0000\u0000\u0000\u0fec\u0fe9"+ + "\u0001\u0000\u0000\u0000\u0fec\u0fea\u0001\u0000\u0000\u0000\u0fed\u0fee"+ + "\u0001\u0000\u0000\u0000\u0fee\u0fef\u0005w\u0000\u0000\u0fef\u0ff0\u0005"+ + "8\u0000\u0000\u0ff0\u010d\u0001\u0000\u0000\u0000\u0ff1\u0ff6\u0005u\u0000"+ + "\u0000\u0ff2\u0ff6\u0005\u019c\u0000\u0000\u0ff3\u0ff4\u0005+\u0000\u0000"+ + "\u0ff4\u0ff6\u0003\u027a\u013d\u0000\u0ff5\u0ff1\u0001\u0000\u0000\u0000"+ + "\u0ff5\u0ff2\u0001\u0000\u0000\u0000\u0ff5\u0ff3\u0001\u0000\u0000\u0000"+ + "\u0ff6\u0ff7\u0001\u0000\u0000\u0000\u0ff7\u0ff8\u0005w\u0000\u0000\u0ff8"+ + "\u0ff9\u0005\u019c\u0000\u0000\u0ff9\u010f\u0001\u0000\u0000\u0000\u0ffa"+ + "\u1003\u00074\u0000\u0000\u0ffb\u1003\u0005L\u0000\u0000\u0ffc\u1003\u0005"+ + "\u00ac\u0000\u0000\u0ffd\u1003\u0005\u00a7\u0000\u0000\u0ffe\u1003\u0005"+ + "\u00a5\u0000\u0000\u0fff\u1003\u0005\u0272\u0000\u0000\u1000\u1003\u0007"+ + "5\u0000\u0000\u1001\u1003\u0005\u00a6\u0000\u0000\u1002\u0ffa\u0001\u0000"+ + "\u0000\u0000\u1002\u0ffb\u0001\u0000\u0000\u0000\u1002\u0ffc\u0001\u0000"+ + "\u0000\u0000\u1002\u0ffd\u0001\u0000\u0000\u0000\u1002\u0ffe\u0001\u0000"+ + "\u0000\u0000\u1002\u0fff\u0001\u0000\u0000\u0000\u1002\u1000\u0001\u0000"+ + "\u0000\u0000\u1002\u1001\u0001\u0000\u0000\u0000\u1003\u0111\u0001\u0000"+ + "\u0000\u0000\u1004\u1007\u0005\u045e\u0000\u0000\u1005\u1007\u0003\u0114"+ + "\u008a\u0000\u1006\u1004\u0001\u0000\u0000\u0000\u1006\u1005\u0001\u0000"+ + "\u0000\u0000\u1007\u100c\u0001\u0000\u0000\u0000\u1008\u1009\u0005\u0470"+ + "\u0000\u0000\u1009\u100b\u0003\u0114\u008a\u0000\u100a\u1008\u0001\u0000"+ + "\u0000\u0000\u100b\u100e\u0001\u0000\u0000\u0000\u100c\u100a\u0001\u0000"+ + "\u0000\u0000\u100c\u100d\u0001\u0000\u0000\u0000\u100d\u0113\u0001\u0000"+ + "\u0000\u0000\u100e\u100c\u0001\u0000\u0000\u0000\u100f\u1010\u0003\u0226"+ + "\u0113\u0000\u1010\u1011\u0005\u046d\u0000\u0000\u1011\u1012\u0005\u045e"+ + "\u0000\u0000\u1012\u102d\u0001\u0000\u0000\u0000\u1013\u1018\u0003\u022c"+ + "\u0116\u0000\u1014\u1016\u0005\r\u0000\u0000\u1015\u1014\u0001\u0000\u0000"+ + "\u0000\u1015\u1016\u0001\u0000\u0000\u0000\u1016\u1017\u0001\u0000\u0000"+ + "\u0000\u1017\u1019\u0003\u0248\u0124\u0000\u1018\u1015\u0001\u0000\u0000"+ + "\u0000\u1018\u1019\u0001\u0000\u0000\u0000\u1019\u102d\u0001\u0000\u0000"+ + "\u0000\u101a\u101f\u0003\u0288\u0144\u0000\u101b\u101d\u0005\r\u0000\u0000"+ + "\u101c\u101b\u0001\u0000\u0000\u0000\u101c\u101d\u0001\u0000\u0000\u0000"+ + "\u101d\u101e\u0001\u0000\u0000\u0000\u101e\u1020\u0003\u0248\u0124\u0000"+ + "\u101f\u101c\u0001\u0000\u0000\u0000\u101f\u1020\u0001\u0000\u0000\u0000"+ + "\u1020\u102d\u0001\u0000\u0000\u0000\u1021\u1022\u0005\u0488\u0000\u0000"+ + "\u1022\u1024\u0005\u0455\u0000\u0000\u1023\u1021\u0001\u0000\u0000\u0000"+ + "\u1023\u1024\u0001\u0000\u0000\u0000\u1024\u1025\u0001\u0000\u0000\u0000"+ + "\u1025\u102a\u0003\u02b0\u0158\u0000\u1026\u1028\u0005\r\u0000\u0000\u1027"+ + "\u1026\u0001\u0000\u0000\u0000\u1027\u1028\u0001\u0000\u0000\u0000\u1028"+ + "\u1029\u0001\u0000\u0000\u0000\u1029\u102b\u0003\u0248\u0124\u0000\u102a"+ + "\u1027\u0001\u0000\u0000\u0000\u102a\u102b\u0001\u0000\u0000\u0000\u102b"+ + "\u102d\u0001\u0000\u0000\u0000\u102c\u100f\u0001\u0000\u0000\u0000\u102c"+ + "\u1013\u0001\u0000\u0000\u0000\u102c\u101a\u0001\u0000\u0000\u0000\u102c"+ + "\u1023\u0001\u0000\u0000\u0000\u102d\u0115\u0001\u0000\u0000\u0000\u102e"+ + "\u102f\u0005X\u0000\u0000\u102f\u1034\u0003\u00d2i\u0000\u1030\u1031\u0005"+ + "\u0470\u0000\u0000\u1031\u1033\u0003\u00d2i\u0000\u1032\u1030\u0001\u0000"+ + "\u0000\u0000\u1033\u1036\u0001\u0000\u0000\u0000\u1034\u1032\u0001\u0000"+ + "\u0000\u0000\u1034\u1035\u0001\u0000\u0000\u0000\u1035\u1053\u0001\u0000"+ + "\u0000\u0000\u1036\u1034\u0001\u0000\u0000\u0000\u1037\u1038\u0005X\u0000"+ + "\u0000\u1038\u1039\u0005\u0191\u0000\u0000\u1039\u1053\u0005\u047d\u0000"+ + "\u0000\u103a\u103b\u0005X\u0000\u0000\u103b\u103c\u0005\u0080\u0000\u0000"+ + "\u103c\u1040\u0005\u047d\u0000\u0000\u103d\u103e\u0005\u001a\u0000\u0000"+ + "\u103e\u103f\u0005\u009a\u0000\u0000\u103f\u1041\u0003\u0238\u011c\u0000"+ + "\u1040\u103d\u0001\u0000\u0000\u0000\u1040\u1041\u0001\u0000\u0000\u0000"+ + "\u1041\u1048\u0001\u0000\u0000\u0000\u1042\u1044\u0007)\u0000\u0000\u1043"+ + "\u1045\u0003\u0118\u008c\u0000\u1044\u1043\u0001\u0000\u0000\u0000\u1045"+ + "\u1046\u0001\u0000\u0000\u0000\u1046\u1044\u0001\u0000\u0000\u0000\u1046"+ + "\u1047\u0001\u0000\u0000\u0000\u1047\u1049\u0001\u0000\u0000\u0000\u1048"+ + "\u1042\u0001\u0000\u0000\u0000\u1048\u1049\u0001\u0000\u0000\u0000\u1049"+ + "\u1050\u0001\u0000\u0000\u0000\u104a\u104c\u0005f\u0000\u0000\u104b\u104d"+ + "\u0003\u011a\u008d\u0000\u104c\u104b\u0001\u0000\u0000\u0000\u104d\u104e"+ + "\u0001\u0000\u0000\u0000\u104e\u104c\u0001\u0000\u0000\u0000\u104e\u104f"+ + "\u0001\u0000\u0000\u0000\u104f\u1051\u0001\u0000\u0000\u0000\u1050\u104a"+ + "\u0001\u0000\u0000\u0000\u1050\u1051\u0001\u0000\u0000\u0000\u1051\u1053"+ + "\u0001\u0000\u0000\u0000\u1052\u102e\u0001\u0000\u0000\u0000\u1052\u1037"+ + "\u0001\u0000\u0000\u0000\u1052\u103a\u0001\u0000\u0000\u0000\u1053\u0117"+ + "\u0001\u0000\u0000\u0000\u1054\u1055\u0005\u00ae\u0000\u0000\u1055\u1056"+ + "\u0005\u0014\u0000\u0000\u1056\u1061\u0005\u047d\u0000\u0000\u1057\u1059"+ + "\u0005{\u0000\u0000\u1058\u1057\u0001\u0000\u0000\u0000\u1058\u1059\u0001"+ + "\u0000\u0000\u0000\u1059\u105a\u0001\u0000\u0000\u0000\u105a\u105b\u0005"+ + "9\u0000\u0000\u105b\u105c\u0005\u0014\u0000\u0000\u105c\u1061\u0005\u047d"+ + "\u0000\u0000\u105d\u105e\u0005;\u0000\u0000\u105e\u105f\u0005\u0014\u0000"+ + "\u0000\u105f\u1061\u0005\u047d\u0000\u0000\u1060\u1054\u0001\u0000\u0000"+ + "\u0000\u1060\u1058\u0001\u0000\u0000\u0000\u1060\u105d\u0001\u0000\u0000"+ + "\u0000\u1061\u0119\u0001\u0000\u0000\u0000\u1062\u1063\u0005\u00aa\u0000"+ + "\u0000\u1063\u1064\u0005\u0014\u0000\u0000\u1064\u1069\u0005\u047d\u0000"+ + "\u0000\u1065\u1066\u0005\u00ae\u0000\u0000\u1066\u1067\u0005\u0014\u0000"+ + "\u0000\u1067\u1069\u0005\u047d\u0000\u0000\u1068\u1062\u0001\u0000\u0000"+ + "\u0000\u1068\u1065\u0001\u0000\u0000\u0000\u1069\u011b\u0001\u0000\u0000"+ + "\u0000\u106a\u106b\u0005E\u0000\u0000\u106b\u106d\u0003\u00eau\u0000\u106c"+ + "\u106a\u0001\u0000\u0000\u0000\u106c\u106d\u0001\u0000\u0000\u0000\u106d"+ + "\u1070\u0001\u0000\u0000\u0000\u106e\u106f\u0005\u00bf\u0000\u0000\u106f"+ + "\u1071\u0003\u02b0\u0158\u0000\u1070\u106e\u0001\u0000\u0000\u0000\u1070"+ + "\u1071\u0001\u0000\u0000\u0000\u1071\u011d\u0001\u0000\u0000\u0000\u1072"+ + "\u1073\u0005J\u0000\u0000\u1073\u1074\u0005\u0014\u0000\u0000\u1074\u1079"+ + "\u0003\u0124\u0092\u0000\u1075\u1076\u0005\u0470\u0000\u0000\u1076\u1078"+ + "\u0003\u0124\u0092\u0000\u1077\u1075\u0001\u0000\u0000\u0000\u1078\u107b"+ + "\u0001\u0000\u0000\u0000\u1079\u1077\u0001\u0000\u0000\u0000\u1079\u107a"+ + "\u0001\u0000\u0000\u0000\u107a\u107e\u0001\u0000\u0000\u0000\u107b\u1079"+ + "\u0001\u0000\u0000\u0000\u107c\u107d\u0005\u00c1\u0000\u0000\u107d\u107f"+ + "\u0005\u0257\u0000\u0000\u107e\u107c\u0001\u0000\u0000\u0000\u107e\u107f"+ + "\u0001\u0000\u0000\u0000\u107f\u011f\u0001\u0000\u0000\u0000\u1080\u1081"+ + "\u0005K\u0000\u0000\u1081\u1082\u0003\u02b0\u0158\u0000\u1082\u0121\u0001"+ + "\u0000\u0000\u0000\u1083\u1084\u0005\u02a5\u0000\u0000\u1084\u1085\u0003"+ + "\u029a\u014d\u0000\u1085\u1086\u0005\r\u0000\u0000\u1086\u1087\u0005\u046e"+ + "\u0000\u0000\u1087\u1088\u0003\u0298\u014c\u0000\u1088\u1092\u0005\u046f"+ + "\u0000\u0000\u1089\u108a\u0005\u0470\u0000\u0000\u108a\u108b\u0003\u029a"+ + "\u014d\u0000\u108b\u108c\u0005\r\u0000\u0000\u108c\u108d\u0005\u046e\u0000"+ + "\u0000\u108d\u108e\u0003\u0298\u014c\u0000\u108e\u108f\u0005\u046f\u0000"+ + "\u0000\u108f\u1091\u0001\u0000\u0000\u0000\u1090\u1089\u0001\u0000\u0000"+ + "\u0000\u1091\u1094\u0001\u0000\u0000\u0000\u1092\u1090\u0001\u0000\u0000"+ + "\u0000\u1092\u1093\u0001\u0000\u0000\u0000\u1093\u0123\u0001\u0000\u0000"+ + "\u0000\u1094\u1092\u0001\u0000\u0000\u0000\u1095\u1097\u0003\u02b0\u0158"+ + "\u0000\u1096\u1098\u00070\u0000\u0000\u1097\u1096\u0001\u0000\u0000\u0000"+ + "\u1097\u1098\u0001\u0000\u0000\u0000\u1098\u0125\u0001\u0000\u0000\u0000"+ + "\u1099\u10a4\u0005d\u0000\u0000\u109a\u109b\u0003\u0128\u0094\u0000\u109b"+ + "\u109c\u0005\u0470\u0000\u0000\u109c\u109e\u0001\u0000\u0000\u0000\u109d"+ + "\u109a\u0001\u0000\u0000\u0000\u109d\u109e\u0001\u0000\u0000\u0000\u109e"+ + "\u109f\u0001\u0000\u0000\u0000\u109f\u10a5\u0003\u0128\u0094\u0000\u10a0"+ + "\u10a1\u0003\u0128\u0094\u0000\u10a1\u10a2\u0005\u0215\u0000\u0000\u10a2"+ + "\u10a3\u0003\u0128\u0094\u0000\u10a3\u10a5\u0001\u0000\u0000\u0000\u10a4"+ + "\u109d\u0001\u0000\u0000\u0000\u10a4\u10a0\u0001\u0000\u0000\u0000\u10a5"+ + "\u0127\u0001\u0000\u0000\u0000\u10a6\u10aa\u0003\u024e\u0127\u0000\u10a7"+ + "\u10aa\u0003\u0236\u011b\u0000\u10a8\u10aa\u0003\u024a\u0125\u0000\u10a9"+ + "\u10a6\u0001\u0000\u0000\u0000\u10a9\u10a7\u0001\u0000\u0000\u0000\u10a9"+ + "\u10a8\u0001\u0000\u0000\u0000\u10aa\u0129\u0001\u0000\u0000\u0000\u10ab"+ + "\u10ac\u0005\u0276\u0000\u0000\u10ac\u10b5\u0005\u028e\u0000\u0000\u10ad"+ + "\u10b2\u0003\u0140\u00a0\u0000\u10ae\u10af\u0005\u0470\u0000\u0000\u10af"+ + "\u10b1\u0003\u0140\u00a0\u0000\u10b0\u10ae\u0001\u0000\u0000\u0000\u10b1"+ + "\u10b4\u0001\u0000\u0000\u0000\u10b2\u10b0\u0001\u0000\u0000\u0000\u10b2"+ + "\u10b3\u0001\u0000\u0000\u0000\u10b3\u10b6\u0001\u0000\u0000\u0000\u10b4"+ + "\u10b2\u0001\u0000\u0000\u0000\u10b5\u10ad\u0001\u0000\u0000\u0000\u10b5"+ + "\u10b6\u0001\u0000\u0000\u0000\u10b6\u012b\u0001\u0000\u0000\u0000\u10b7"+ + "\u10b9\u0005\u0159\u0000\u0000\u10b8\u10ba\u0005\u02a7\u0000\u0000\u10b9"+ + "\u10b8\u0001\u0000\u0000\u0000\u10b9\u10ba\u0001\u0000\u0000\u0000\u10ba"+ + "\u012d\u0001\u0000\u0000\u0000\u10bb\u10bd\u0005\u0172\u0000\u0000\u10bc"+ + "\u10be\u0005\u02a7\u0000\u0000\u10bd\u10bc\u0001\u0000\u0000\u0000\u10bd"+ + "\u10be\u0001\u0000\u0000\u0000\u10be\u10c4\u0001\u0000\u0000\u0000\u10bf"+ + "\u10c1\u0005\u000b\u0000\u0000\u10c0\u10c2\u0005\u020a\u0000\u0000\u10c1"+ + "\u10c0\u0001\u0000\u0000\u0000\u10c1\u10c2\u0001\u0000\u0000\u0000\u10c2"+ + "\u10c3\u0001\u0000\u0000\u0000\u10c3\u10c5\u0005\u0162\u0000\u0000\u10c4"+ + "\u10bf\u0001\u0000\u0000\u0000\u10c4\u10c5\u0001\u0000\u0000\u0000\u10c5"+ + "\u10ca\u0001\u0000\u0000\u0000\u10c6\u10c8\u0005\u020a\u0000\u0000\u10c7"+ + "\u10c6\u0001\u0000\u0000\u0000\u10c7\u10c8\u0001\u0000\u0000\u0000\u10c8"+ + "\u10c9\u0001\u0000\u0000\u0000\u10c9\u10cb\u0005\u008b\u0000\u0000\u10ca"+ + "\u10c7\u0001\u0000\u0000\u0000\u10ca\u10cb\u0001\u0000\u0000\u0000\u10cb"+ + "\u012f\u0001\u0000\u0000\u0000\u10cc\u10ce\u0005\u0256\u0000\u0000\u10cd"+ + "\u10cf\u0005\u02a7\u0000\u0000\u10ce\u10cd\u0001\u0000\u0000\u0000\u10ce"+ + "\u10cf\u0001\u0000\u0000\u0000\u10cf\u10d5\u0001\u0000\u0000\u0000\u10d0"+ + "\u10d2\u0005\u000b\u0000\u0000\u10d1\u10d3\u0005\u020a\u0000\u0000\u10d2"+ + "\u10d1\u0001\u0000\u0000\u0000\u10d2\u10d3\u0001\u0000\u0000\u0000\u10d3"+ + "\u10d4\u0001\u0000\u0000\u0000\u10d4\u10d6\u0005\u0162\u0000\u0000\u10d5"+ + "\u10d0\u0001\u0000\u0000\u0000\u10d5\u10d6\u0001\u0000\u0000\u0000\u10d6"+ + "\u10db\u0001\u0000\u0000\u0000\u10d7\u10d9\u0005\u020a\u0000\u0000\u10d8"+ + "\u10d7\u0001\u0000\u0000\u0000\u10d8\u10d9\u0001\u0000\u0000\u0000\u10d9"+ + "\u10da\u0001\u0000\u0000\u0000\u10da\u10dc\u0005\u008b\u0000\u0000\u10db"+ + "\u10d8\u0001\u0000\u0000\u0000\u10db\u10dc\u0001\u0000\u0000\u0000\u10dc"+ + "\u0131\u0001\u0000\u0000\u0000\u10dd\u10de\u0005\u025d\u0000\u0000\u10de"+ + "\u10df\u0003\u0248\u0124\u0000\u10df\u0133\u0001\u0000\u0000\u0000\u10e0"+ + "\u10e2\u0005\u0256\u0000\u0000\u10e1\u10e3\u0005\u02a7\u0000\u0000\u10e2"+ + "\u10e1\u0001\u0000\u0000\u0000\u10e2\u10e3\u0001\u0000\u0000\u0000\u10e3"+ + "\u10e4\u0001\u0000\u0000\u0000\u10e4\u10e6\u0005\u00b0\u0000\u0000\u10e5"+ + "\u10e7\u0005\u025d\u0000\u0000\u10e6\u10e5\u0001\u0000\u0000\u0000\u10e6"+ + "\u10e7\u0001\u0000\u0000\u0000\u10e7\u10e8\u0001\u0000\u0000\u0000\u10e8"+ + "\u10e9\u0003\u0248\u0124\u0000\u10e9\u0135\u0001\u0000\u0000\u0000\u10ea"+ + "\u10eb\u0005\u008b\u0000\u0000\u10eb\u10ec\u0005\u025d\u0000\u0000\u10ec"+ + "\u10ed\u0003\u0248\u0124\u0000\u10ed\u0137\u0001\u0000\u0000\u0000\u10ee"+ + "\u10ef\u0005h\u0000\u0000\u10ef\u10f0\u00076\u0000\u0000\u10f0\u10f5\u0003"+ + "\u0142\u00a1\u0000\u10f1\u10f2\u0005\u0470\u0000\u0000\u10f2\u10f4\u0003"+ + "\u0142\u00a1\u0000\u10f3\u10f1\u0001\u0000\u0000\u0000\u10f4\u10f7\u0001"+ + "\u0000\u0000\u0000\u10f5\u10f3\u0001\u0000\u0000\u0000\u10f5\u10f6\u0001"+ + "\u0000\u0000\u0000\u10f6\u10f9\u0001\u0000\u0000\u0000\u10f7\u10f5\u0001"+ + "\u0000\u0000\u0000\u10f8\u10fa\u0003\u0286\u0143\u0000\u10f9\u10f8\u0001"+ + "\u0000\u0000\u0000\u10f9\u10fa\u0001\u0000\u0000\u0000\u10fa\u0139\u0001"+ + "\u0000\u0000\u0000\u10fb\u10fc\u0005\u00b7\u0000\u0000\u10fc\u10fd\u0005"+ + "\u02e7\u0000\u0000\u10fd\u013b\u0001\u0000\u0000\u0000\u10fe\u10ff\u0005"+ + "\u009a\u0000\u0000\u10ff\u1100\u0005\u0155\u0000\u0000\u1100\u1101\u0005"+ + "\u0465\u0000\u0000\u1101\u1102\u0007\u0018\u0000\u0000\u1102\u013d\u0001"+ + "\u0000\u0000\u0000\u1103\u1105\u0005\u009a\u0000\u0000\u1104\u1106\u0007"+ + "7\u0000\u0000\u1105\u1104\u0001\u0000\u0000\u0000\u1105\u1106\u0001\u0000"+ + "\u0000\u0000\u1106\u1107\u0001\u0000\u0000\u0000\u1107\u1108\u0005\u028e"+ + "\u0000\u0000\u1108\u110d\u0003\u0146\u00a3\u0000\u1109\u110a\u0005\u0470"+ + "\u0000\u0000\u110a\u110c\u0003\u0146\u00a3\u0000\u110b\u1109\u0001\u0000"+ + "\u0000\u0000\u110c\u110f\u0001\u0000\u0000\u0000\u110d\u110b\u0001\u0000"+ + "\u0000\u0000\u110d\u110e\u0001\u0000\u0000\u0000\u110e\u013f\u0001\u0000"+ + "\u0000\u0000\u110f\u110d\u0001\u0000\u0000\u0000\u1110\u1111\u0005\u00c1"+ + "\u0000\u0000\u1111\u1112\u0005\u017a\u0000\u0000\u1112\u1118\u0005\u0269"+ + "\u0000\u0000\u1113\u1114\u0005\u0087\u0000\u0000\u1114\u1118\u0005\u00c2"+ + "\u0000\u0000\u1115\u1116\u0005\u0087\u0000\u0000\u1116\u1118\u0005\u021b"+ + "\u0000\u0000\u1117\u1110\u0001\u0000\u0000\u0000\u1117\u1113\u0001\u0000"+ + "\u0000\u0000\u1117\u1115\u0001\u0000\u0000\u0000\u1118\u0141\u0001\u0000"+ + "\u0000\u0000\u1119\u111e\u0003\u0228\u0114\u0000\u111a\u111c\u0005\r\u0000"+ + "\u0000\u111b\u111a\u0001\u0000\u0000\u0000\u111b\u111c\u0001\u0000\u0000"+ + "\u0000\u111c\u111d\u0001\u0000\u0000\u0000\u111d\u111f\u0003\u0248\u0124"+ + "\u0000\u111e\u111b\u0001\u0000\u0000\u0000\u111e\u111f\u0001\u0000\u0000"+ + "\u0000\u111f\u1120\u0001\u0000\u0000\u0000\u1120\u1121\u0003\u0144\u00a2"+ + "\u0000\u1121\u0143\u0001\u0000\u0000\u0000\u1122\u1124\u0005\u0087\u0000"+ + "\u0000\u1123\u1125\u0005\u01db\u0000\u0000\u1124\u1123\u0001\u0000\u0000"+ + "\u0000\u1124\u1125\u0001\u0000\u0000\u0000\u1125\u112b\u0001\u0000\u0000"+ + "\u0000\u1126\u1128\u0005k\u0000\u0000\u1127\u1126\u0001\u0000\u0000\u0000"+ + "\u1127\u1128\u0001\u0000\u0000\u0000\u1128\u1129\u0001\u0000\u0000\u0000"+ + "\u1129\u112b\u0005\u00c2\u0000\u0000\u112a\u1122\u0001\u0000\u0000\u0000"+ + "\u112a\u1127\u0001\u0000\u0000\u0000\u112b\u0145\u0001\u0000\u0000\u0000"+ + "\u112c\u112d\u0005\u01d1\u0000\u0000\u112d\u112e\u0005\u01d9\u0000\u0000"+ + "\u112e\u1134\u0003\u0148\u00a4\u0000\u112f\u1130\u0005\u0087\u0000\u0000"+ + "\u1130\u1134\u0005\u00c2\u0000\u0000\u1131\u1132\u0005\u0087\u0000\u0000"+ + "\u1132\u1134\u0005\u021b\u0000\u0000\u1133\u112c\u0001\u0000\u0000\u0000"+ + "\u1133\u112f\u0001\u0000\u0000\u0000\u1133\u1131\u0001\u0000\u0000\u0000"+ + "\u1134\u0147\u0001\u0000\u0000\u0000\u1135\u1136\u0005\u0320\u0000\u0000"+ + "\u1136\u113d\u0005\u0087\u0000\u0000\u1137\u1138\u0005\u0087\u0000\u0000"+ + "\u1138\u113d\u0005\u0321\u0000\u0000\u1139\u113a\u0005\u0087\u0000\u0000"+ + "\u113a\u113d\u0005\u0322\u0000\u0000\u113b\u113d\u0005\u0323\u0000\u0000"+ + "\u113c\u1135\u0001\u0000\u0000\u0000\u113c\u1137\u0001\u0000\u0000\u0000"+ + "\u113c\u1139\u0001\u0000\u0000\u0000\u113c\u113b\u0001\u0000\u0000\u0000"+ + "\u113d\u0149\u0001\u0000\u0000\u0000\u113e\u113f\u0005\u0019\u0000\u0000"+ + "\u113f\u1140\u0005\u01de\u0000\u0000\u1140\u1141\u0005\u00b0\u0000\u0000"+ + "\u1141\u1146\u0003\u015c\u00ae\u0000\u1142\u1143\u0005\u0470\u0000\u0000"+ + "\u1143\u1145\u0003\u015c\u00ae\u0000\u1144\u1142\u0001\u0000\u0000\u0000"+ + "\u1145\u1148\u0001\u0000\u0000\u0000\u1146\u1144\u0001\u0000\u0000\u0000"+ + "\u1146\u1147\u0001\u0000\u0000\u0000\u1147\u114a\u0001\u0000\u0000\u0000"+ + "\u1148\u1146\u0001\u0000\u0000\u0000\u1149\u114b\u0003\u0164\u00b2\u0000"+ + "\u114a\u1149\u0001\u0000\u0000\u0000\u114a\u114b\u0001\u0000\u0000\u0000"+ + "\u114b\u014b\u0001\u0000\u0000\u0000\u114c\u114d\u0005\u0019\u0000\u0000"+ + "\u114d\u114e\u0005\u024d\u0000\u0000\u114e\u114f\u0005\u01ae\u0000\u0000"+ + "\u114f\u1154\u0003\u0166\u00b3\u0000\u1150\u1151\u0005\u0470\u0000\u0000"+ + "\u1151\u1153\u0003\u0166\u00b3\u0000\u1152\u1150\u0001\u0000\u0000\u0000"+ + "\u1153\u1156\u0001\u0000\u0000\u0000\u1154\u1152\u0001\u0000\u0000\u0000"+ + "\u1154\u1155\u0001\u0000\u0000\u0000\u1155\u014d\u0001\u0000\u0000\u0000"+ + "\u1156\u1154\u0001\u0000\u0000\u0000\u1157\u1158\u0005\u0085\u0000\u0000"+ + "\u1158\u1159\u00078\u0000\u0000\u1159\u115e\u0005\u01dd\u0000\u0000\u115a"+ + "\u115b\u0005\u00b0\u0000\u0000\u115b\u115f\u0005\u047d\u0000\u0000\u115c"+ + "\u115d\u0005\u0010\u0000\u0000\u115d\u115f\u0005\u047d\u0000\u0000\u115e"+ + "\u115a\u0001\u0000\u0000\u0000\u115e\u115c\u0001\u0000\u0000\u0000\u115f"+ + "\u014f\u0001\u0000\u0000\u0000\u1160\u1161\u0005\u024e\u0000\u0000\u1161"+ + "\u1162\u0005\u01de\u0000\u0000\u1162\u0151\u0001\u0000\u0000\u0000\u1163"+ + "\u1164\u0005\u024e\u0000\u0000\u1164\u1166\u0005\u0267\u0000\u0000\u1165"+ + "\u1167\u0005\u0007\u0000\u0000\u1166\u1165\u0001\u0000\u0000\u0000\u1166"+ + "\u1167\u0001\u0000\u0000\u0000\u1167\u1169\u0001\u0000\u0000\u0000\u1168"+ + "\u116a\u0003\u0164\u00b2\u0000\u1169\u1168\u0001\u0000\u0000\u0000\u1169"+ + "\u116a\u0001\u0000\u0000\u0000\u116a\u0153\u0001\u0000\u0000\u0000\u116b"+ + "\u116c\u0005\u0276\u0000\u0000\u116c\u1175\u0005\u0267\u0000\u0000\u116d"+ + "\u1172\u0003\u016a\u00b5\u0000\u116e\u116f\u0005\u0470\u0000\u0000\u116f"+ + "\u1171\u0003\u016a\u00b5\u0000\u1170\u116e\u0001\u0000\u0000\u0000\u1171"+ + "\u1174\u0001\u0000\u0000\u0000\u1172\u1170\u0001\u0000\u0000\u0000\u1172"+ + "\u1173\u0001\u0000\u0000\u0000\u1173\u1176\u0001\u0000\u0000\u0000\u1174"+ + "\u1172\u0001\u0000\u0000\u0000\u1175\u116d\u0001\u0000\u0000\u0000\u1175"+ + "\u1176\u0001\u0000\u0000\u0000\u1176\u1179\u0001\u0000\u0000\u0000\u1177"+ + "\u1178\u0005\u0298\u0000\u0000\u1178\u117a\u0003\u016c\u00b6\u0000\u1179"+ + "\u1177\u0001\u0000\u0000\u0000\u1179\u117a\u0001\u0000\u0000\u0000\u117a"+ + "\u117e\u0001\u0000\u0000\u0000\u117b\u117d\u0003\u016e\u00b7\u0000\u117c"+ + "\u117b\u0001\u0000\u0000\u0000\u117d\u1180\u0001\u0000\u0000\u0000\u117e"+ + "\u117c\u0001\u0000\u0000\u0000\u117e\u117f\u0001\u0000\u0000\u0000\u117f"+ + "\u1182\u0001\u0000\u0000\u0000\u1180\u117e\u0001\u0000\u0000\u0000\u1181"+ + "\u1183\u0003\u0164\u00b2\u0000\u1182\u1181\u0001\u0000\u0000\u0000\u1182"+ + "\u1183\u0001\u0000\u0000\u0000\u1183\u0155\u0001\u0000\u0000\u0000\u1184"+ + "\u1185\u0005\u027c\u0000\u0000\u1185\u118e\u0005\u0267\u0000\u0000\u1186"+ + "\u118b\u0003\u016a\u00b5\u0000\u1187\u1188\u0005\u0470\u0000\u0000\u1188"+ + "\u118a\u0003\u016a\u00b5\u0000\u1189\u1187\u0001\u0000\u0000\u0000\u118a"+ + "\u118d\u0001\u0000\u0000\u0000\u118b\u1189\u0001\u0000\u0000\u0000\u118b"+ + "\u118c\u0001\u0000\u0000\u0000\u118c\u118f\u0001\u0000\u0000\u0000\u118d"+ + "\u118b\u0001\u0000\u0000\u0000\u118e\u1186\u0001\u0000\u0000\u0000\u118e"+ + "\u118f\u0001\u0000\u0000\u0000\u118f\u0157\u0001\u0000\u0000\u0000\u1190"+ + "\u1191\u0005\u0276\u0000\u0000\u1191\u1192\u0005\u01ba\u0000\u0000\u1192"+ + "\u0159\u0001\u0000\u0000\u0000\u1193\u1194\u0005\u027c\u0000\u0000\u1194"+ + "\u1195\u0005\u01ba\u0000\u0000\u1195\u015b\u0001\u0000\u0000\u0000\u1196"+ + "\u1197\u0003\u015e\u00af\u0000\u1197\u1198\u0005\u0465\u0000\u0000\u1198"+ + "\u1199\u0005\u047d\u0000\u0000\u1199\u11b4\u0001\u0000\u0000\u0000\u119a"+ + "\u119b\u0003\u0160\u00b0\u0000\u119b\u119c\u0005\u0465\u0000\u0000\u119c"+ + "\u119d\u0003\u024e\u0127\u0000\u119d\u11b4\u0001\u0000\u0000\u0000\u119e"+ + "\u119f\u0003\u0162\u00b1\u0000\u119f\u11a0\u0005\u0465\u0000\u0000\u11a0"+ + "\u11a1\u0007\u0018\u0000\u0000\u11a1\u11b4\u0001\u0000\u0000\u0000\u11a2"+ + "\u11a3\u0005\u01e2\u0000\u0000\u11a3\u11a4\u0005\u0465\u0000\u0000\u11a4"+ + "\u11b4\u0005\u0480\u0000\u0000\u11a5\u11a6\u0005\u01c2\u0000\u0000\u11a6"+ + "\u11a7\u0005\u0465\u0000\u0000\u11a7\u11b0\u0005\u046e\u0000\u0000\u11a8"+ + "\u11ad\u0003\u0248\u0124\u0000\u11a9\u11aa\u0005\u0470\u0000\u0000\u11aa"+ + "\u11ac\u0003\u0248\u0124\u0000\u11ab\u11a9\u0001\u0000\u0000\u0000\u11ac"+ + "\u11af\u0001\u0000\u0000\u0000\u11ad\u11ab\u0001\u0000\u0000\u0000\u11ad"+ + "\u11ae\u0001\u0000\u0000\u0000\u11ae\u11b1\u0001\u0000\u0000\u0000\u11af"+ + "\u11ad\u0001\u0000\u0000\u0000\u11b0\u11a8\u0001\u0000\u0000\u0000\u11b0"+ + "\u11b1\u0001\u0000\u0000\u0000\u11b1\u11b2\u0001\u0000\u0000\u0000\u11b2"+ + "\u11b4\u0005\u046f\u0000\u0000\u11b3\u1196\u0001\u0000\u0000\u0000\u11b3"+ + "\u119a\u0001\u0000\u0000\u0000\u11b3\u119e\u0001\u0000\u0000\u0000\u11b3"+ + "\u11a2\u0001\u0000\u0000\u0000\u11b3\u11a5\u0001\u0000\u0000\u0000\u11b4"+ + "\u015d\u0001\u0000\u0000\u0000\u11b5\u11b6\u00079\u0000\u0000\u11b6\u015f"+ + "\u0001\u0000\u0000\u0000\u11b7\u11b8\u0007:\u0000\u0000\u11b8\u0161\u0001"+ + "\u0000\u0000\u0000\u11b9\u11ba\u0007;\u0000\u0000\u11ba\u0163\u0001\u0000"+ + "\u0000\u0000\u11bb\u11bc\u0005B\u0000\u0000\u11bc\u11bd\u0005\u0164\u0000"+ + "\u0000\u11bd\u11be\u0005\u047d\u0000\u0000\u11be\u0165\u0001\u0000\u0000"+ + "\u0000\u11bf\u11c0\u0005\u0246\u0000\u0000\u11c0\u11c1\u0005\u0465\u0000"+ + "\u0000\u11c1\u11c2\u0005\u046e\u0000\u0000\u11c2\u11c3\u0003\u0268\u0134"+ + "\u0000\u11c3\u11c4\u0005\u046f\u0000\u0000\u11c4\u11f1\u0001\u0000\u0000"+ + "\u0000\u11c5\u11c6\u0005\u0248\u0000\u0000\u11c6\u11c7\u0005\u0465\u0000"+ + "\u0000\u11c7\u11c8\u0005\u046e\u0000\u0000\u11c8\u11c9\u0003\u0268\u0134"+ + "\u0000\u11c9\u11ca\u0005\u046f\u0000\u0000\u11ca\u11f1\u0001\u0000\u0000"+ + "\u0000\u11cb\u11cc\u0005\u0247\u0000\u0000\u11cc\u11cd\u0005\u0465\u0000"+ + "\u0000\u11cd\u11ce\u0005\u046e\u0000\u0000\u11ce\u11cf\u0003\u026c\u0136"+ + "\u0000\u11cf\u11d0\u0005\u046f\u0000\u0000\u11d0\u11f1\u0001\u0000\u0000"+ + "\u0000\u11d1\u11d2\u0005\u0249\u0000\u0000\u11d2\u11d3\u0005\u0465\u0000"+ + "\u0000\u11d3\u11d4\u0005\u046e\u0000\u0000\u11d4\u11d5\u0003\u026c\u0136"+ + "\u0000\u11d5\u11d6\u0005\u046f\u0000\u0000\u11d6\u11f1\u0001\u0000\u0000"+ + "\u0000\u11d7\u11d8\u0005\u024b\u0000\u0000\u11d8\u11d9\u0005\u0465\u0000"+ + "\u0000\u11d9\u11da\u0005\u046e\u0000\u0000\u11da\u11db\u0003\u0276\u013b"+ + "\u0000\u11db\u11dc\u0005\u046f\u0000\u0000\u11dc\u11f1\u0001\u0000\u0000"+ + "\u0000\u11dd\u11de\u0005\u024c\u0000\u0000\u11de\u11df\u0005\u0465\u0000"+ + "\u0000\u11df\u11e0\u0005\u046e\u0000\u0000\u11e0\u11e1\u0003\u0276\u013b"+ + "\u0000\u11e1\u11e2\u0005\u046f\u0000\u0000\u11e2\u11f1\u0001\u0000\u0000"+ + "\u0000\u11e3\u11e4\u0005\u024a\u0000\u0000\u11e4\u11e5\u0005\u0465\u0000"+ + "\u0000\u11e5\u11e6\u0005\u046e\u0000\u0000\u11e6\u11eb\u0003\u0168\u00b4"+ + "\u0000\u11e7\u11e8\u0005\u0470\u0000\u0000\u11e8\u11ea\u0003\u0168\u00b4"+ + "\u0000\u11e9\u11e7\u0001\u0000\u0000\u0000\u11ea\u11ed\u0001\u0000\u0000"+ + "\u0000\u11eb\u11e9\u0001\u0000\u0000\u0000\u11eb\u11ec\u0001\u0000\u0000"+ + "\u0000\u11ec\u11ee\u0001\u0000\u0000\u0000\u11ed\u11eb\u0001\u0000\u0000"+ + "\u0000\u11ee\u11ef\u0005\u046f\u0000\u0000\u11ef\u11f1\u0001\u0000\u0000"+ + "\u0000\u11f0\u11bf\u0001\u0000\u0000\u0000\u11f0\u11c5\u0001\u0000\u0000"+ + "\u0000\u11f0\u11cb\u0001\u0000\u0000\u0000\u11f0\u11d1\u0001\u0000\u0000"+ + "\u0000\u11f0\u11d7\u0001\u0000\u0000\u0000\u11f0\u11dd\u0001\u0000\u0000"+ + "\u0000\u11f0\u11e3\u0001\u0000\u0000\u0000\u11f1\u0167\u0001\u0000\u0000"+ + "\u0000\u11f2\u11f3\u0005\u046e\u0000\u0000\u11f3\u11f4\u0003\u0228\u0114"+ + "\u0000\u11f4\u11f5\u0005\u0470\u0000\u0000\u11f5\u11f6\u0003\u0228\u0114"+ + "\u0000\u11f6\u11f7\u0005\u046f\u0000\u0000\u11f7\u0169\u0001\u0000\u0000"+ + "\u0000\u11f8\u11f9\u0007<\u0000\u0000\u11f9\u016b\u0001\u0000\u0000\u0000"+ + "\u11fa\u11fb\u0007=\u0000\u0000\u11fb\u11fc\u0005\u0465\u0000\u0000\u11fc"+ + "\u120d\u0003\u0170\u00b8\u0000\u11fd\u11fe\u0005\u01e4\u0000\u0000\u11fe"+ + "\u11ff\u0005\u0465\u0000\u0000\u11ff\u1200\u0005\u047d\u0000\u0000\u1200"+ + "\u1201\u0005\u0470\u0000\u0000\u1201\u1202\u0005\u01e5\u0000\u0000\u1202"+ + "\u1203\u0005\u0465\u0000\u0000\u1203\u120d\u0003\u024e\u0127\u0000\u1204"+ + "\u1205\u0005\u0240\u0000\u0000\u1205\u1206\u0005\u0465\u0000\u0000\u1206"+ + "\u1207\u0005\u047d\u0000\u0000\u1207\u1208\u0005\u0470\u0000\u0000\u1208"+ + "\u1209\u0005\u0241\u0000\u0000\u1209\u120a\u0005\u0465\u0000\u0000\u120a"+ + "\u120d\u0003\u024e\u0127\u0000\u120b\u120d\u0005\u0270\u0000\u0000\u120c"+ + "\u11fa\u0001\u0000\u0000\u0000\u120c\u11fd\u0001\u0000\u0000\u0000\u120c"+ + "\u1204\u0001\u0000\u0000\u0000\u120c\u120b\u0001\u0000\u0000\u0000\u120d"+ + "\u016d\u0001\u0000\u0000\u0000\u120e\u120f\u0005\u029a\u0000\u0000\u120f"+ + "\u1210\u0005\u0465\u0000\u0000\u1210\u121b\u0005\u047d\u0000\u0000\u1211"+ + "\u1212\u0005\u0228\u0000\u0000\u1212\u1213\u0005\u0465\u0000\u0000\u1213"+ + "\u121b\u0005\u047d\u0000\u0000\u1214\u1215\u0005\u0188\u0000\u0000\u1215"+ + "\u1216\u0005\u0465\u0000\u0000\u1216\u121b\u0005\u047d\u0000\u0000\u1217"+ + "\u1218\u0005\u022c\u0000\u0000\u1218\u1219\u0005\u0465\u0000\u0000\u1219"+ + "\u121b\u0005\u047d\u0000\u0000\u121a\u120e\u0001\u0000\u0000\u0000\u121a"+ + "\u1211\u0001\u0000\u0000\u0000\u121a\u1214\u0001\u0000\u0000\u0000\u121a"+ + "\u1217\u0001\u0000\u0000\u0000\u121b\u016f\u0001\u0000\u0000\u0000\u121c"+ + "\u1221\u0003\u0240\u0120\u0000\u121d\u121e\u0005\u0470\u0000\u0000\u121e"+ + "\u1220\u0003\u0240\u0120\u0000\u121f\u121d\u0001\u0000\u0000\u0000\u1220"+ + "\u1223\u0001\u0000\u0000\u0000\u1221\u121f\u0001\u0000\u0000\u0000\u1221"+ + "\u1222\u0001\u0000\u0000\u0000\u1222\u1226\u0001\u0000\u0000\u0000\u1223"+ + "\u1221\u0001\u0000\u0000\u0000\u1224\u1226\u0005\u047d\u0000\u0000\u1225"+ + "\u121c\u0001\u0000\u0000\u0000\u1225\u1224\u0001\u0000\u0000\u0000\u1226"+ + "\u0171\u0001\u0000\u0000\u0000\u1227\u1228\u0005\u02aa\u0000\u0000\u1228"+ + "\u1229\u0007>\u0000\u0000\u1229\u122b\u0003\u0242\u0121\u0000\u122a\u122c"+ + "\u0007?\u0000\u0000\u122b\u122a\u0001\u0000\u0000\u0000\u122b\u122c\u0001"+ + "\u0000\u0000\u0000\u122c\u0173\u0001\u0000\u0000\u0000\u122d\u122e\u0005"+ + "\u02aa\u0000\u0000\u122e\u122f\u0005\u0198\u0000\u0000\u122f\u1235\u0003"+ + "\u0242\u0121\u0000\u1230\u1233\u0005\u0284\u0000\u0000\u1231\u1232\u0005"+ + "B\u0000\u0000\u1232\u1234\u0005\u01fe\u0000\u0000\u1233\u1231\u0001\u0000"+ + "\u0000\u0000\u1233\u1234\u0001\u0000\u0000\u0000\u1234\u1236\u0001\u0000"+ + "\u0000\u0000\u1235\u1230\u0001\u0000\u0000\u0000\u1235\u1236\u0001\u0000"+ + "\u0000\u0000\u1236\u0175\u0001\u0000\u0000\u0000\u1237\u1238\u0005\u02aa"+ + "\u0000\u0000\u1238\u1239\u0005\u0231\u0000\u0000\u1239\u123a\u0003\u0242"+ + "\u0121\u0000\u123a\u0177\u0001\u0000\u0000\u0000\u123b\u123c\u0005\u02aa"+ + "\u0000\u0000\u123c\u123d\u0005\u0172\u0000\u0000\u123d\u1240\u0003\u0242"+ + "\u0121\u0000\u123e\u123f\u0005\u0219\u0000\u0000\u123f\u1241\u0005\u022a"+ + "\u0000\u0000\u1240\u123e\u0001\u0000\u0000\u0000\u1240\u1241\u0001\u0000"+ + "\u0000\u0000\u1241\u0179\u0001\u0000\u0000\u0000\u1242\u1243\u0005\u02aa"+ + "\u0000\u0000\u1243\u1244\u0005\u0256\u0000\u0000\u1244\u1245\u0003\u0242"+ + "\u0121\u0000\u1245\u017b\u0001\u0000\u0000\u0000\u1246\u1247\u0005\u02aa"+ + "\u0000\u0000\u1247\u124a\u0005\u023b\u0000\u0000\u1248\u1249\u0005!\u0000"+ + "\u0000\u1249\u124b\u0003\u0242\u0121\u0000\u124a\u1248\u0001\u0000\u0000"+ + "\u0000\u124a\u124b\u0001\u0000\u0000\u0000\u124b\u017d\u0001\u0000\u0000"+ + "\u0000\u124c\u124d\u0005\u0231\u0000\u0000\u124d\u124e\u0003\u0248\u0124"+ + "\u0000\u124e\u1251\u0005E\u0000\u0000\u124f\u1252\u0005\u047d\u0000\u0000"+ + "\u1250\u1252\u0005\u0488\u0000\u0000\u1251\u124f\u0001\u0000\u0000\u0000"+ + "\u1251\u1250\u0001\u0000\u0000\u0000\u1252\u017f\u0001\u0000\u0000\u0000"+ + "\u1253\u1254\u0005\u02c5\u0000\u0000\u1254\u1257\u0003\u0248\u0124\u0000"+ + "\u1255\u1256\u0005\u00bc\u0000\u0000\u1256\u1258\u0003\u0278\u013c\u0000"+ + "\u1257\u1255\u0001\u0000\u0000\u0000\u1257\u1258\u0001\u0000\u0000\u0000"+ + "\u1258\u0181\u0001\u0000\u0000\u0000\u1259\u125a\u0007@\u0000\u0000\u125a"+ + "\u125b\u0005\u0231\u0000\u0000\u125b\u125c\u0003\u0248\u0124\u0000\u125c"+ + "\u0183\u0001\u0000\u0000\u0000\u125d\u1260\u0003\u0186\u00c3\u0000\u125e"+ + "\u1260\u0003\u0004\u0002\u0000\u125f\u125d\u0001\u0000\u0000\u0000\u125f"+ + "\u125e\u0001\u0000\u0000\u0000\u1260\u0185\u0001\u0000\u0000\u0000\u1261"+ + "\u1262\u0003\u0248\u0124\u0000\u1262\u1263\u0005\u0479\u0000\u0000\u1263"+ + "\u1265\u0001\u0000\u0000\u0000\u1264\u1261\u0001\u0000\u0000\u0000\u1264"+ + "\u1265\u0001\u0000\u0000\u0000\u1265\u1266\u0001\u0000\u0000\u0000\u1266"+ + "\u126c\u0005\u0159\u0000\u0000\u1267\u1268\u0003\u019a\u00cd\u0000\u1268"+ + "\u1269\u0005\u0471\u0000\u0000\u1269\u126b\u0001\u0000\u0000\u0000\u126a"+ + "\u1267\u0001\u0000\u0000\u0000\u126b\u126e\u0001\u0000\u0000\u0000\u126c"+ + "\u126a\u0001\u0000\u0000\u0000\u126c\u126d\u0001\u0000\u0000\u0000\u126d"+ + "\u1274\u0001\u0000\u0000\u0000\u126e\u126c\u0001\u0000\u0000\u0000\u126f"+ + "\u1270\u0003\u019c\u00ce\u0000\u1270\u1271\u0005\u0471\u0000\u0000\u1271"+ + "\u1273\u0001\u0000\u0000\u0000\u1272\u126f\u0001\u0000\u0000\u0000\u1273"+ + "\u1276\u0001\u0000\u0000\u0000\u1274\u1272\u0001\u0000\u0000\u0000\u1274"+ + "\u1275\u0001\u0000\u0000\u0000\u1275\u127c\u0001\u0000\u0000\u0000\u1276"+ + "\u1274\u0001\u0000\u0000\u0000\u1277\u1278\u0003\u019e\u00cf\u0000\u1278"+ + "\u1279\u0005\u0471\u0000\u0000\u1279\u127b\u0001\u0000\u0000\u0000\u127a"+ + "\u1277\u0001\u0000\u0000\u0000\u127b\u127e\u0001\u0000\u0000\u0000\u127c"+ + "\u127a\u0001\u0000\u0000\u0000\u127c\u127d\u0001\u0000\u0000\u0000\u127d"+ + "\u1284\u0001\u0000\u0000\u0000\u127e\u127c\u0001\u0000\u0000\u0000\u127f"+ + "\u1280\u0003\u01a0\u00d0\u0000\u1280\u1281\u0005\u0471\u0000\u0000\u1281"+ + "\u1283\u0001\u0000\u0000\u0000\u1282\u127f\u0001\u0000\u0000\u0000\u1283"+ + "\u1286\u0001\u0000\u0000\u0000\u1284\u1282\u0001\u0000\u0000\u0000\u1284"+ + "\u1285\u0001\u0000\u0000\u0000\u1285\u128a\u0001\u0000\u0000\u0000\u1286"+ + "\u1284\u0001\u0000\u0000\u0000\u1287\u1289\u0003\u01a4\u00d2\u0000\u1288"+ + "\u1287\u0001\u0000\u0000\u0000\u1289\u128c\u0001\u0000\u0000\u0000\u128a"+ + "\u1288\u0001\u0000\u0000\u0000\u128a\u128b\u0001\u0000\u0000\u0000\u128b"+ + "\u128d\u0001\u0000\u0000\u0000\u128c\u128a\u0001\u0000\u0000\u0000\u128d"+ + "\u128f\u0005\u0198\u0000\u0000\u128e\u1290\u0003\u0248\u0124\u0000\u128f"+ + "\u128e\u0001\u0000\u0000\u0000\u128f\u1290\u0001\u0000\u0000\u0000\u1290"+ + "\u0187\u0001\u0000\u0000\u0000\u1291\u1294\u0005\u0017\u0000\u0000\u1292"+ + "\u1295\u0003\u0248\u0124\u0000\u1293\u1295\u0003\u02b0\u0158\u0000\u1294"+ + "\u1292\u0001\u0000\u0000\u0000\u1294\u1293\u0001\u0000\u0000\u0000\u1294"+ + "\u1295\u0001\u0000\u0000\u0000\u1295\u1297\u0001\u0000\u0000\u0000\u1296"+ + "\u1298\u0003\u01a6\u00d3\u0000\u1297\u1296\u0001\u0000\u0000\u0000\u1298"+ + "\u1299\u0001\u0000\u0000\u0000\u1299\u1297\u0001\u0000\u0000\u0000\u1299"+ + "\u129a\u0001\u0000\u0000\u0000\u129a\u12a1\u0001\u0000\u0000\u0000\u129b"+ + "\u129d\u00056\u0000\u0000\u129c\u129e\u0003\u01a4\u00d2\u0000\u129d\u129c"+ + "\u0001\u0000\u0000\u0000\u129e\u129f\u0001\u0000\u0000\u0000\u129f\u129d"+ + "\u0001\u0000\u0000\u0000\u129f\u12a0\u0001\u0000\u0000\u0000\u12a0\u12a2"+ + "\u0001\u0000\u0000\u0000\u12a1\u129b\u0001\u0000\u0000\u0000\u12a1\u12a2"+ + "\u0001\u0000\u0000\u0000\u12a2\u12a3\u0001\u0000\u0000\u0000\u12a3\u12a4"+ + "\u0005\u0198\u0000\u0000\u12a4\u12a5\u0005\u0017\u0000\u0000\u12a5\u0189"+ + "\u0001\u0000\u0000\u0000\u12a6\u12a7\u0005N\u0000\u0000\u12a7\u12a8\u0003"+ + "\u02b0\u0158\u0000\u12a8\u12aa\u0005\u00af\u0000\u0000\u12a9\u12ab\u0003"+ + "\u01a4\u00d2\u0000\u12aa\u12a9\u0001\u0000\u0000\u0000\u12ab\u12ac\u0001"+ + "\u0000\u0000\u0000\u12ac\u12aa\u0001\u0000\u0000\u0000\u12ac\u12ad\u0001"+ + "\u0000\u0000\u0000\u12ad\u12b1\u0001\u0000\u0000\u0000\u12ae\u12b0\u0003"+ + "\u01a8\u00d4\u0000\u12af\u12ae\u0001\u0000\u0000\u0000\u12b0\u12b3\u0001"+ + "\u0000\u0000\u0000\u12b1\u12af\u0001\u0000\u0000\u0000\u12b1\u12b2\u0001"+ + "\u0000\u0000\u0000\u12b2\u12ba\u0001\u0000\u0000\u0000\u12b3\u12b1\u0001"+ + "\u0000\u0000\u0000\u12b4\u12b6\u00056\u0000\u0000\u12b5\u12b7\u0003\u01a4"+ + "\u00d2\u0000\u12b6\u12b5\u0001\u0000\u0000\u0000\u12b7\u12b8\u0001\u0000"+ + "\u0000\u0000\u12b8\u12b6\u0001\u0000\u0000\u0000\u12b8\u12b9\u0001\u0000"+ + "\u0000\u0000\u12b9\u12bb\u0001\u0000\u0000\u0000\u12ba\u12b4\u0001\u0000"+ + "\u0000\u0000\u12ba\u12bb\u0001\u0000\u0000\u0000\u12bb\u12bc\u0001\u0000"+ + "\u0000\u0000\u12bc\u12bd\u0005\u0198\u0000\u0000\u12bd\u12be\u0005N\u0000"+ + "\u0000\u12be\u018b\u0001\u0000\u0000\u0000\u12bf\u12c0\u0005Z\u0000\u0000"+ + "\u12c0\u12c1\u0003\u0248\u0124\u0000\u12c1\u018d\u0001\u0000\u0000\u0000"+ + "\u12c2\u12c3\u0005a\u0000\u0000\u12c3\u12c4\u0003\u0248\u0124\u0000\u12c4"+ + "\u018f\u0001\u0000\u0000\u0000\u12c5\u12c6\u0003\u0248\u0124\u0000\u12c6"+ + "\u12c7\u0005\u0479\u0000\u0000\u12c7\u12c9\u0001\u0000\u0000\u0000\u12c8"+ + "\u12c5\u0001\u0000\u0000\u0000\u12c8\u12c9\u0001\u0000\u0000\u0000\u12c9"+ + "\u12ca\u0001\u0000\u0000\u0000\u12ca\u12cc\u0005j\u0000\u0000\u12cb\u12cd"+ + "\u0003\u01a4\u00d2\u0000\u12cc\u12cb\u0001\u0000\u0000\u0000\u12cd\u12ce"+ + "\u0001\u0000\u0000\u0000\u12ce\u12cc\u0001\u0000\u0000\u0000\u12ce\u12cf"+ + "\u0001\u0000\u0000\u0000\u12cf\u12d0\u0001\u0000\u0000\u0000\u12d0\u12d1"+ + "\u0005\u0198\u0000\u0000\u12d1\u12d3\u0005j\u0000\u0000\u12d2\u12d4\u0003"+ + "\u0248\u0124\u0000\u12d3\u12d2\u0001\u0000\u0000\u0000\u12d3\u12d4\u0001"+ + "\u0000\u0000\u0000\u12d4\u0191\u0001\u0000\u0000\u0000\u12d5\u12d6\u0003"+ + "\u0248\u0124\u0000\u12d6\u12d7\u0005\u0479\u0000\u0000\u12d7\u12d9\u0001"+ + "\u0000\u0000\u0000\u12d8\u12d5\u0001\u0000\u0000\u0000\u12d8\u12d9\u0001"+ + "\u0000\u0000\u0000\u12d9\u12da\u0001\u0000\u0000\u0000\u12da\u12dc\u0005"+ + "\u008d\u0000\u0000\u12db\u12dd\u0003\u01a4\u00d2\u0000\u12dc\u12db\u0001"+ + "\u0000\u0000\u0000\u12dd\u12de\u0001\u0000\u0000\u0000\u12de\u12dc\u0001"+ + "\u0000\u0000\u0000\u12de\u12df\u0001\u0000\u0000\u0000\u12df\u12e0\u0001"+ + "\u0000\u0000\u0000\u12e0\u12e1\u0005\u0298\u0000\u0000\u12e1\u12e2\u0003"+ + "\u02b0\u0158\u0000\u12e2\u12e3\u0005\u0198\u0000\u0000\u12e3\u12e5\u0005"+ + "\u008d\u0000\u0000\u12e4\u12e6\u0003\u0248\u0124\u0000\u12e5\u12e4\u0001"+ + "\u0000\u0000\u0000\u12e5\u12e6\u0001\u0000\u0000\u0000\u12e6\u0193\u0001"+ + "\u0000\u0000\u0000\u12e7\u12e8\u0005\u0093\u0000\u0000\u12e8\u12e9\u0003"+ + "\u02b0\u0158\u0000\u12e9\u0195\u0001\u0000\u0000\u0000\u12ea\u12eb\u0003"+ + "\u0248\u0124\u0000\u12eb\u12ec\u0005\u0479\u0000\u0000\u12ec\u12ee\u0001"+ + "\u0000\u0000\u0000\u12ed\u12ea\u0001\u0000\u0000\u0000\u12ed\u12ee\u0001"+ + "\u0000\u0000\u0000\u12ee\u12ef\u0001\u0000\u0000\u0000\u12ef\u12f0\u0005"+ + "\u00c0\u0000\u0000\u12f0\u12f1\u0003\u02b0\u0158\u0000\u12f1\u12f3\u0005"+ + "\u0190\u0000\u0000\u12f2\u12f4\u0003\u01a4\u00d2\u0000\u12f3\u12f2\u0001"+ + "\u0000\u0000\u0000\u12f4\u12f5\u0001\u0000\u0000\u0000\u12f5\u12f3\u0001"+ + "\u0000\u0000\u0000\u12f5\u12f6\u0001\u0000\u0000\u0000\u12f6\u12f7\u0001"+ + "\u0000\u0000\u0000\u12f7\u12f8\u0005\u0198\u0000\u0000\u12f8\u12fa\u0005"+ + "\u00c0\u0000\u0000\u12f9\u12fb\u0003\u0248\u0124\u0000\u12fa\u12f9\u0001"+ + "\u0000\u0000\u0000\u12fa\u12fb\u0001\u0000\u0000\u0000\u12fb\u0197\u0001"+ + "\u0000\u0000\u0000\u12fc\u12fd\u0005\u016a\u0000\u0000\u12fd\u130c\u0003"+ + "\u0248\u0124\u0000\u12fe\u1303\u0005A\u0000\u0000\u12ff\u1301\u0005\u0209"+ + "\u0000\u0000\u1300\u12ff\u0001\u0000\u0000\u0000\u1300\u1301\u0001\u0000"+ + "\u0000\u0000\u1301\u1302\u0001\u0000\u0000\u0000\u1302\u1304\u0005E\u0000"+ + "\u0000\u1303\u1300\u0001\u0000\u0000\u0000\u1303\u1304\u0001\u0000\u0000"+ + "\u0000\u1304\u1305\u0001\u0000\u0000\u0000\u1305\u1306\u0003\u0248\u0124"+ + "\u0000\u1306\u1307\u0005X\u0000\u0000\u1307\u1308\u0003\u0268\u0134\u0000"+ + "\u1308\u130c\u0001\u0000\u0000\u0000\u1309\u130a\u0005\u021c\u0000\u0000"+ + "\u130a\u130c\u0003\u0248\u0124\u0000\u130b\u12fc\u0001\u0000\u0000\u0000"+ + "\u130b\u12fe\u0001\u0000\u0000\u0000\u130b\u1309\u0001\u0000\u0000\u0000"+ + "\u130c\u0199\u0001\u0000\u0000\u0000\u130d\u130e\u0005*\u0000\u0000\u130e"+ + "\u130f\u0003\u0268\u0134\u0000\u130f\u1312\u0003\u025c\u012e\u0000\u1310"+ + "\u1311\u0005+\u0000\u0000\u1311\u1313\u0003\u02b0\u0158\u0000\u1312\u1310"+ + "\u0001\u0000\u0000\u0000\u1312\u1313\u0001\u0000\u0000\u0000\u1313\u019b"+ + "\u0001\u0000\u0000\u0000\u1314\u1315\u0005*\u0000\u0000\u1315\u1316\u0003"+ + "\u0248\u0124\u0000\u1316\u1317\u0005\u001e\u0000\u0000\u1317\u131e\u0005"+ + "B\u0000\u0000\u1318\u131f\u0003\u024e\u0127\u0000\u1319\u131b\u0005\u00a3"+ + "\u0000\u0000\u131a\u131c\u0005\u029e\u0000\u0000\u131b\u131a\u0001\u0000"+ + "\u0000\u0000\u131b\u131c\u0001\u0000\u0000\u0000\u131c\u131d\u0001\u0000"+ + "\u0000\u0000\u131d\u131f\u0005\u047d\u0000\u0000\u131e\u1318\u0001\u0000"+ + "\u0000\u0000\u131e\u1319\u0001\u0000\u0000\u0000\u131f\u019d\u0001\u0000"+ + "\u0000\u0000\u1320\u1321\u0005*\u0000\u0000\u1321\u1322\u0003\u0248\u0124"+ + "\u0000\u1322\u1323\u0005\'\u0000\u0000\u1323\u1324\u0005B\u0000\u0000"+ + "\u1324\u1325\u0003\u00c8d\u0000\u1325\u019f\u0001\u0000\u0000\u0000\u1326"+ + "\u1327\u0005*\u0000\u0000\u1327\u1328\u0007A\u0000\u0000\u1328\u1329\u0005"+ + "\u01bb\u0000\u0000\u1329\u132a\u0005B\u0000\u0000\u132a\u132f\u0003\u01a2"+ + "\u00d1\u0000\u132b\u132c\u0005\u0470\u0000\u0000\u132c\u132e\u0003\u01a2"+ + "\u00d1\u0000\u132d\u132b\u0001\u0000\u0000\u0000\u132e\u1331\u0001\u0000"+ + "\u0000\u0000\u132f\u132d\u0001\u0000\u0000\u0000\u132f\u1330\u0001\u0000"+ + "\u0000\u0000\u1330\u1332\u0001\u0000\u0000\u0000\u1331\u132f\u0001\u0000"+ + "\u0000\u0000\u1332\u1333\u0003\u0184\u00c2\u0000\u1333\u01a1\u0001\u0000"+ + "\u0000\u0000\u1334\u1340\u0003\u024e\u0127\u0000\u1335\u1337\u0005\u00a3"+ + "\u0000\u0000\u1336\u1338\u0005\u029e\u0000\u0000\u1337\u1336\u0001\u0000"+ + "\u0000\u0000\u1337\u1338\u0001\u0000\u0000\u0000\u1338\u1339\u0001\u0000"+ + "\u0000\u0000\u1339\u1340\u0005\u047d\u0000\u0000\u133a\u1340\u0003\u0248"+ + "\u0124\u0000\u133b\u1340\u0005\u00a4\u0000\u0000\u133c\u133d\u0005s\u0000"+ + "\u0000\u133d\u1340\u0005\u01b4\u0000\u0000\u133e\u1340\u0005\u00a2\u0000"+ + "\u0000\u133f\u1334\u0001\u0000\u0000\u0000\u133f\u1335\u0001\u0000\u0000"+ + "\u0000\u133f\u133a\u0001\u0000\u0000\u0000\u133f\u133b\u0001\u0000\u0000"+ + "\u0000\u133f\u133c\u0001\u0000\u0000\u0000\u133f\u133e\u0001\u0000\u0000"+ + "\u0000\u1340\u01a3\u0001\u0000\u0000\u0000\u1341\u1344\u0003\u0012\t\u0000"+ + "\u1342\u1344\u0003\u0004\u0002\u0000\u1343\u1341\u0001\u0000\u0000\u0000"+ + "\u1343\u1342\u0001\u0000\u0000\u0000\u1344\u1345\u0001\u0000\u0000\u0000"+ + "\u1345\u1346\u0005\u0471\u0000\u0000\u1346\u01a5\u0001\u0000\u0000\u0000"+ + "\u1347\u134a\u0005\u00be\u0000\u0000\u1348\u134b\u0003\u025a\u012d\u0000"+ + "\u1349\u134b\u0003\u02b0\u0158\u0000\u134a\u1348\u0001\u0000\u0000\u0000"+ + "\u134a\u1349\u0001\u0000\u0000\u0000\u134b\u134c\u0001\u0000\u0000\u0000"+ + "\u134c\u134e\u0005\u00af\u0000\u0000\u134d\u134f\u0003\u01a4\u00d2\u0000"+ + "\u134e\u134d\u0001\u0000\u0000\u0000\u134f\u1350\u0001\u0000\u0000\u0000"+ + "\u1350\u134e\u0001\u0000\u0000\u0000\u1350\u1351\u0001\u0000\u0000\u0000"+ + "\u1351\u01a7\u0001\u0000\u0000\u0000\u1352\u1353\u00057\u0000\u0000\u1353"+ + "\u1354\u0003\u02b0\u0158\u0000\u1354\u1356\u0005\u00af\u0000\u0000\u1355"+ + "\u1357\u0003\u01a4\u00d2\u0000\u1356\u1355\u0001\u0000\u0000\u0000\u1357"+ + "\u1358\u0001\u0000\u0000\u0000\u1358\u1356\u0001\u0000\u0000\u0000\u1358"+ + "\u1359\u0001\u0000\u0000\u0000\u1359\u01a9\u0001\u0000\u0000\u0000\u135a"+ + "\u135b\u0005\b\u0000\u0000\u135b\u135c\u0005\u029a\u0000\u0000\u135c\u1361"+ + "\u0003\u01be\u00df\u0000\u135d\u135e\u0005\u0470\u0000\u0000\u135e\u1360"+ + "\u0003\u01be\u00df\u0000\u135f\u135d\u0001\u0000\u0000\u0000\u1360\u1363"+ + "\u0001\u0000\u0000\u0000\u1361\u135f\u0001\u0000\u0000\u0000\u1361\u1362"+ + "\u0001\u0000\u0000\u0000\u1362\u13a4\u0001\u0000\u0000\u0000\u1363\u1361"+ + "\u0001\u0000\u0000\u0000\u1364\u1365\u0005\b\u0000\u0000\u1365\u1367\u0005"+ + "\u029a\u0000\u0000\u1366\u1368\u0003\u0280\u0140\u0000\u1367\u1366\u0001"+ + "\u0000\u0000\u0000\u1367\u1368\u0001\u0000\u0000\u0000\u1368\u1369\u0001"+ + "\u0000\u0000\u0000\u1369\u136e\u0003\u01c0\u00e0\u0000\u136a\u136b\u0005"+ + "\u0470\u0000\u0000\u136b\u136d\u0003\u01c0\u00e0\u0000\u136c\u136a\u0001"+ + "\u0000\u0000\u0000\u136d\u1370\u0001\u0000\u0000\u0000\u136e\u136c\u0001"+ + "\u0000\u0000\u0000\u136e\u136f\u0001\u0000\u0000\u0000\u136f\u137f\u0001"+ + "\u0000\u0000\u0000\u1370\u136e\u0001\u0000\u0000\u0000\u1371\u137d\u0005"+ + "\u008f\u0000\u0000\u1372\u137e\u0005\u0212\u0000\u0000\u1373\u137a\u0003"+ + "\u01c6\u00e3\u0000\u1374\u1376\u0005\u000b\u0000\u0000\u1375\u1374\u0001"+ + "\u0000\u0000\u0000\u1375\u1376\u0001\u0000\u0000\u0000\u1376\u1377\u0001"+ + "\u0000\u0000\u0000\u1377\u1379\u0003\u01c6\u00e3\u0000\u1378\u1375\u0001"+ + "\u0000\u0000\u0000\u1379\u137c\u0001\u0000\u0000\u0000\u137a\u1378\u0001"+ + "\u0000\u0000\u0000\u137a\u137b\u0001\u0000\u0000\u0000\u137b\u137e\u0001"+ + "\u0000\u0000\u0000\u137c\u137a\u0001\u0000\u0000\u0000\u137d\u1372\u0001"+ + "\u0000\u0000\u0000\u137d\u1373\u0001\u0000\u0000\u0000\u137e\u1380\u0001"+ + "\u0000\u0000\u0000\u137f\u1371\u0001\u0000\u0000\u0000\u137f\u1380\u0001"+ + "\u0000\u0000\u0000\u1380\u1387\u0001\u0000\u0000\u0000\u1381\u1383\u0005"+ + "\u00c1\u0000\u0000\u1382\u1384\u0003\u01c8\u00e4\u0000\u1383\u1382\u0001"+ + "\u0000\u0000\u0000\u1384\u1385\u0001\u0000\u0000\u0000\u1385\u1383\u0001"+ + "\u0000\u0000\u0000\u1385\u1386\u0001\u0000\u0000\u0000\u1386\u1388\u0001"+ + "\u0000\u0000\u0000\u1387\u1381\u0001\u0000\u0000\u0000\u1387\u1388\u0001"+ + "\u0000\u0000\u0000\u1388\u138d\u0001\u0000\u0000\u0000\u1389\u138c\u0003"+ + "\u01ca\u00e5\u0000\u138a\u138c\u0003\u01cc\u00e6\u0000\u138b\u1389\u0001"+ + "\u0000\u0000\u0000\u138b\u138a\u0001\u0000\u0000\u0000\u138c\u138f\u0001"+ + "\u0000\u0000\u0000\u138d\u138b\u0001\u0000\u0000\u0000\u138d\u138e\u0001"+ + "\u0000\u0000\u0000\u138e\u1394\u0001\u0000\u0000\u0000\u138f\u138d\u0001"+ + "\u0000\u0000\u0000\u1390\u1391\u0005\u0171\u0000\u0000\u1391\u1395\u0005"+ + "\u047d\u0000\u0000\u1392\u1393\u0005\u000f\u0000\u0000\u1393\u1395\u0005"+ + "\u047d\u0000\u0000\u1394\u1390\u0001\u0000\u0000\u0000\u1394\u1392\u0001"+ + "\u0000\u0000\u0000\u1394\u1395\u0001\u0000\u0000\u0000\u1395\u13a4\u0001"+ + "\u0000\u0000\u0000\u1396\u1397\u0005\b\u0000\u0000\u1397\u1399\u0005\u029a"+ + "\u0000\u0000\u1398\u139a\u0003\u0280\u0140\u0000\u1399\u1398\u0001\u0000"+ + "\u0000\u0000\u1399\u139a\u0001\u0000\u0000\u0000\u139a\u139d\u0001\u0000"+ + "\u0000\u0000\u139b\u139e\u0003\u0234\u011a\u0000\u139c\u139e\u0003\u0248"+ + "\u0124\u0000\u139d\u139b\u0001\u0000\u0000\u0000\u139d\u139c\u0001\u0000"+ + "\u0000\u0000\u139e\u139f\u0001\u0000\u0000\u0000\u139f\u13a0\u0005+\u0000"+ + "\u0000\u13a0\u13a1\u0005\u0255\u0000\u0000\u13a1\u13a2\u0003\u01b2\u00d9"+ + "\u0000\u13a2\u13a4\u0001\u0000\u0000\u0000\u13a3\u135a\u0001\u0000\u0000"+ + "\u0000\u13a3\u1364\u0001\u0000\u0000\u0000\u13a3\u1396\u0001\u0000\u0000"+ + "\u0000\u13a4\u01ab\u0001\u0000\u0000\u0000\u13a5\u13a6\u0005\"\u0000\u0000"+ + "\u13a6\u13a7\u0005\u029a\u0000\u0000\u13a7\u13ac\u0003\u01c0\u00e0\u0000"+ + "\u13a8\u13a9\u0005\u0470\u0000\u0000\u13a9\u13ab\u0003\u01c0\u00e0\u0000"+ + "\u13aa\u13a8\u0001\u0000\u0000\u0000\u13ab\u13ae\u0001\u0000\u0000\u0000"+ + "\u13ac\u13aa\u0001\u0000\u0000\u0000\u13ac\u13ad\u0001\u0000\u0000\u0000"+ + "\u13ad\u13e7\u0001\u0000\u0000\u0000\u13ae\u13ac\u0001\u0000\u0000\u0000"+ + "\u13af\u13b0\u0005\"\u0000\u0000\u13b0\u13b2\u0005\u029a\u0000\u0000\u13b1"+ + "\u13b3\u0003\u0282\u0141\u0000\u13b2\u13b1\u0001\u0000\u0000\u0000\u13b2"+ + "\u13b3\u0001\u0000\u0000\u0000\u13b3\u13b4\u0001\u0000\u0000\u0000\u13b4"+ + "\u13b9\u0003\u01c0\u00e0\u0000\u13b5\u13b6\u0005\u0470\u0000\u0000\u13b6"+ + "\u13b8\u0003\u01c0\u00e0\u0000\u13b7\u13b5\u0001\u0000\u0000\u0000\u13b8"+ + "\u13bb\u0001\u0000\u0000\u0000\u13b9\u13b7\u0001\u0000\u0000\u0000\u13b9"+ + "\u13ba\u0001\u0000\u0000\u0000\u13ba\u13bf\u0001\u0000\u0000\u0000\u13bb"+ + "\u13b9\u0001\u0000\u0000\u0000\u13bc\u13bd\u0005+\u0000\u0000\u13bd\u13be"+ + "\u0005\u0255\u0000\u0000\u13be\u13c0\u0003\u01b2\u00d9\u0000\u13bf\u13bc"+ + "\u0001\u0000\u0000\u0000\u13bf\u13c0\u0001\u0000\u0000\u0000\u13c0\u13cf"+ + "\u0001\u0000\u0000\u0000\u13c1\u13cd\u0005\u008f\u0000\u0000\u13c2\u13ce"+ + "\u0005\u0212\u0000\u0000\u13c3\u13ca\u0003\u01c6\u00e3\u0000\u13c4\u13c6"+ + "\u0005\u000b\u0000\u0000\u13c5\u13c4\u0001\u0000\u0000\u0000\u13c5\u13c6"+ + "\u0001\u0000\u0000\u0000\u13c6\u13c7\u0001\u0000\u0000\u0000\u13c7\u13c9"+ + "\u0003\u01c6\u00e3\u0000\u13c8\u13c5\u0001\u0000\u0000\u0000\u13c9\u13cc"+ + "\u0001\u0000\u0000\u0000\u13ca\u13c8\u0001\u0000\u0000\u0000\u13ca\u13cb"+ + "\u0001\u0000\u0000\u0000\u13cb\u13ce\u0001\u0000\u0000\u0000\u13cc\u13ca"+ + "\u0001\u0000\u0000\u0000\u13cd\u13c2\u0001\u0000\u0000\u0000\u13cd\u13c3"+ + "\u0001\u0000\u0000\u0000\u13ce\u13d0\u0001\u0000\u0000\u0000\u13cf\u13c1"+ + "\u0001\u0000\u0000\u0000\u13cf\u13d0\u0001\u0000\u0000\u0000\u13d0\u13d7"+ + "\u0001\u0000\u0000\u0000\u13d1\u13d3\u0005\u00c1\u0000\u0000\u13d2\u13d4"+ + "\u0003\u01c8\u00e4\u0000\u13d3\u13d2\u0001\u0000\u0000\u0000\u13d4\u13d5"+ + "\u0001\u0000\u0000\u0000\u13d5\u13d3\u0001\u0000\u0000\u0000\u13d5\u13d6"+ + "\u0001\u0000\u0000\u0000\u13d6\u13d8\u0001\u0000\u0000\u0000\u13d7\u13d1"+ + "\u0001\u0000\u0000\u0000\u13d7\u13d8\u0001\u0000\u0000\u0000\u13d8\u13dd"+ + "\u0001\u0000\u0000\u0000\u13d9\u13dc\u0003\u01ca\u00e5\u0000\u13da\u13dc"+ + "\u0003\u01cc\u00e6\u0000\u13db\u13d9\u0001\u0000\u0000\u0000\u13db\u13da"+ + "\u0001\u0000\u0000\u0000\u13dc\u13df\u0001\u0000\u0000\u0000\u13dd\u13db"+ + "\u0001\u0000\u0000\u0000\u13dd\u13de\u0001\u0000\u0000\u0000\u13de\u13e4"+ + "\u0001\u0000\u0000\u0000\u13df\u13dd\u0001\u0000\u0000\u0000\u13e0\u13e1"+ + "\u0005\u0171\u0000\u0000\u13e1\u13e5\u0005\u047d\u0000\u0000\u13e2\u13e3"+ + "\u0005\u000f\u0000\u0000\u13e3\u13e5\u0005\u047d\u0000\u0000\u13e4\u13e0"+ + "\u0001\u0000\u0000\u0000\u13e4\u13e2\u0001\u0000\u0000\u0000\u13e4\u13e5"+ + "\u0001\u0000\u0000\u0000\u13e5\u13e7\u0001\u0000\u0000\u0000\u13e6\u13a5"+ + "\u0001\u0000\u0000\u0000\u13e6\u13af\u0001\u0000\u0000\u0000\u13e7\u01ad"+ + "\u0001\u0000\u0000\u0000\u13e8\u13e9\u00054\u0000\u0000\u13e9\u13eb\u0005"+ + "\u029a\u0000\u0000\u13ea\u13ec\u0003\u0280\u0140\u0000\u13eb\u13ea\u0001"+ + "\u0000\u0000\u0000\u13eb\u13ec\u0001\u0000\u0000\u0000\u13ec\u13ed\u0001"+ + "\u0000\u0000\u0000\u13ed\u13f2\u0003\u0234\u011a\u0000\u13ee\u13ef\u0005"+ + "\u0470\u0000\u0000\u13ef\u13f1\u0003\u0234\u011a\u0000\u13f0\u13ee\u0001"+ + "\u0000\u0000\u0000\u13f1\u13f4\u0001\u0000\u0000\u0000\u13f2\u13f0\u0001"+ + "\u0000\u0000\u0000\u13f2\u13f3\u0001\u0000\u0000\u0000\u13f3\u01af\u0001"+ + "\u0000\u0000\u0000\u13f4\u13f2\u0001\u0000\u0000\u0000\u13f5\u13f6\u0005"+ + "I\u0000\u0000\u13f6\u13fb\u0003\u01ce\u00e7\u0000\u13f7\u13f8\u0005\u0470"+ + "\u0000\u0000\u13f8\u13fa\u0003\u01ce\u00e7\u0000\u13f9\u13f7\u0001\u0000"+ + "\u0000\u0000\u13fa\u13fd\u0001\u0000\u0000\u0000\u13fb\u13f9\u0001\u0000"+ + "\u0000\u0000\u13fb\u13fc\u0001\u0000\u0000\u0000\u13fc\u13fe\u0001\u0000"+ + "\u0000\u0000\u13fd\u13fb\u0001\u0000\u0000\u0000\u13fe\u1400\u0005w\u0000"+ + "\u0000\u13ff\u1401\u0007B\u0000\u0000\u1400\u13ff\u0001\u0000\u0000\u0000"+ + "\u1400\u1401\u0001\u0000\u0000\u0000\u1401\u1402\u0001\u0000\u0000\u0000"+ + "\u1402\u1403\u0003\u01d2\u00e9\u0000\u1403\u1404\u0005\u00b0\u0000\u0000"+ + "\u1404\u1409\u0003\u01c0\u00e0\u0000\u1405\u1406\u0005\u0470\u0000\u0000"+ + "\u1406\u1408\u0003\u01c0\u00e0\u0000\u1407\u1405\u0001\u0000\u0000\u0000"+ + "\u1408\u140b\u0001\u0000\u0000\u0000\u1409\u1407\u0001\u0000\u0000\u0000"+ + "\u1409\u140a\u0001\u0000\u0000\u0000\u140a\u141a\u0001\u0000\u0000\u0000"+ + "\u140b\u1409\u0001\u0000\u0000\u0000\u140c\u1418\u0005\u008f\u0000\u0000"+ + "\u140d\u1419\u0005\u0212\u0000\u0000\u140e\u1415\u0003\u01c6\u00e3\u0000"+ + "\u140f\u1411\u0005\u000b\u0000\u0000\u1410\u140f\u0001\u0000\u0000\u0000"+ + "\u1410\u1411\u0001\u0000\u0000\u0000\u1411\u1412\u0001\u0000\u0000\u0000"+ + "\u1412\u1414\u0003\u01c6\u00e3\u0000\u1413\u1410\u0001\u0000\u0000\u0000"+ + "\u1414\u1417\u0001\u0000\u0000\u0000\u1415\u1413\u0001\u0000\u0000\u0000"+ + "\u1415\u1416\u0001\u0000\u0000\u0000\u1416\u1419\u0001\u0000\u0000\u0000"+ + "\u1417\u1415\u0001\u0000\u0000\u0000\u1418\u140d\u0001\u0000\u0000\u0000"+ + "\u1418\u140e\u0001\u0000\u0000\u0000\u1419\u141b\u0001\u0000\u0000\u0000"+ + "\u141a\u140c\u0001\u0000\u0000\u0000\u141a\u141b\u0001\u0000\u0000\u0000"+ + "\u141b\u1425\u0001\u0000\u0000\u0000\u141c\u1422\u0005\u00c1\u0000\u0000"+ + "\u141d\u141e\u0005I\u0000\u0000\u141e\u1421\u0005y\u0000\u0000\u141f\u1421"+ + "\u0003\u01c8\u00e4\u0000\u1420\u141d\u0001\u0000\u0000\u0000\u1420\u141f"+ + "\u0001\u0000\u0000\u0000\u1421\u1424\u0001\u0000\u0000\u0000\u1422\u1420"+ + "\u0001\u0000\u0000\u0000\u1422\u1423\u0001\u0000\u0000\u0000\u1423\u1426"+ + "\u0001\u0000\u0000\u0000\u1424\u1422\u0001\u0000\u0000\u0000\u1425\u141c"+ + "\u0001\u0000\u0000\u0000\u1425\u1426\u0001\u0000\u0000\u0000\u1426\u142d"+ + "\u0001\u0000\u0000\u0000\u1427\u1428\u0005\r\u0000\u0000\u1428\u1429\u0003"+ + "\u0234\u011a\u0000\u1429\u142a\u0005\u00c1\u0000\u0000\u142a\u142b\u0005"+ + "\u0255\u0000\u0000\u142b\u142c\u0003\u01b2\u00d9\u0000\u142c\u142e\u0001"+ + "\u0000\u0000\u0000\u142d\u1427\u0001\u0000\u0000\u0000\u142d\u142e\u0001"+ + "\u0000\u0000\u0000\u142e\u1453\u0001\u0000\u0000\u0000\u142f\u1432\u0005"+ + "I\u0000\u0000\u1430\u1433\u0003\u0234\u011a\u0000\u1431\u1433\u0003\u0248"+ + "\u0124\u0000\u1432\u1430\u0001\u0000\u0000\u0000\u1432\u1431\u0001\u0000"+ + "\u0000\u0000\u1433\u143b\u0001\u0000\u0000\u0000\u1434\u1437\u0005\u0470"+ + "\u0000\u0000\u1435\u1438\u0003\u0234\u011a\u0000\u1436\u1438\u0003\u0248"+ + "\u0124\u0000\u1437\u1435\u0001\u0000\u0000\u0000\u1437\u1436\u0001\u0000"+ + "\u0000\u0000\u1438\u143a\u0001\u0000\u0000\u0000\u1439\u1434\u0001\u0000"+ + "\u0000\u0000\u143a\u143d\u0001\u0000\u0000\u0000\u143b\u1439\u0001\u0000"+ + "\u0000\u0000\u143b\u143c\u0001\u0000\u0000\u0000\u143c\u143e\u0001\u0000"+ + "\u0000\u0000\u143d\u143b\u0001\u0000\u0000\u0000\u143e\u1441\u0005\u00b0"+ + "\u0000\u0000\u143f\u1442\u0003\u0234\u011a\u0000\u1440\u1442\u0003\u0248"+ + "\u0124\u0000\u1441\u143f\u0001\u0000\u0000\u0000\u1441\u1440\u0001\u0000"+ + "\u0000\u0000\u1442\u144a\u0001\u0000\u0000\u0000\u1443\u1446\u0005\u0470"+ + "\u0000\u0000\u1444\u1447\u0003\u0234\u011a\u0000\u1445\u1447\u0003\u0248"+ + "\u0124\u0000\u1446\u1444\u0001\u0000\u0000\u0000\u1446\u1445\u0001\u0000"+ + "\u0000\u0000\u1447\u1449\u0001\u0000\u0000\u0000\u1448\u1443\u0001\u0000"+ + "\u0000\u0000\u1449\u144c\u0001\u0000\u0000\u0000\u144a\u1448\u0001\u0000"+ + "\u0000\u0000\u144a\u144b\u0001\u0000\u0000\u0000\u144b\u1450\u0001\u0000"+ + "\u0000\u0000\u144c\u144a\u0001\u0000\u0000\u0000\u144d\u144e\u0005\u00c1"+ + "\u0000\u0000\u144e\u144f\u0005\u02ba\u0000\u0000\u144f\u1451\u0005y\u0000"+ + "\u0000\u1450\u144d\u0001\u0000\u0000\u0000\u1450\u1451\u0001\u0000\u0000"+ + "\u0000\u1451\u1453\u0001\u0000\u0000\u0000\u1452\u13f5\u0001\u0000\u0000"+ + "\u0000\u1452\u142f\u0001\u0000\u0000\u0000\u1453\u01b1\u0001\u0000\u0000"+ + "\u0000\u1454\u146b\u0005+\u0000\u0000\u1455\u146b\u0005\u0212\u0000\u0000"+ + "\u1456\u1460\u0005\u0007\u0000\u0000\u1457\u1458\u0005<\u0000\u0000\u1458"+ + "\u145d\u0003\u0234\u011a\u0000\u1459\u145a\u0005\u0470\u0000\u0000\u145a"+ + "\u145c\u0003\u0234\u011a\u0000\u145b\u1459\u0001\u0000\u0000\u0000\u145c"+ + "\u145f\u0001\u0000\u0000\u0000\u145d\u145b\u0001\u0000\u0000\u0000\u145d"+ + "\u145e\u0001\u0000\u0000\u0000\u145e\u1461\u0001\u0000\u0000\u0000\u145f"+ + "\u145d\u0001\u0000\u0000\u0000\u1460\u1457\u0001\u0000\u0000\u0000\u1460"+ + "\u1461\u0001\u0000\u0000\u0000\u1461\u146b\u0001\u0000\u0000\u0000\u1462"+ + "\u1467\u0003\u0234\u011a\u0000\u1463\u1464\u0005\u0470\u0000\u0000\u1464"+ + "\u1466\u0003\u0234\u011a\u0000\u1465\u1463\u0001\u0000\u0000\u0000\u1466"+ + "\u1469\u0001\u0000\u0000\u0000\u1467\u1465\u0001\u0000\u0000\u0000\u1467"+ + "\u1468\u0001\u0000\u0000\u0000\u1468\u146b\u0001\u0000\u0000\u0000\u1469"+ + "\u1467\u0001\u0000\u0000\u0000\u146a\u1454\u0001\u0000\u0000\u0000\u146a"+ + "\u1455\u0001\u0000\u0000\u0000\u146a\u1456\u0001\u0000\u0000\u0000\u146a"+ + "\u1462\u0001\u0000\u0000\u0000\u146b\u01b3\u0001\u0000\u0000\u0000\u146c"+ + "\u146d\u0005I\u0000\u0000\u146d\u146e\u0005\u0237\u0000\u0000\u146e\u146f"+ + "\u0005w\u0000\u0000\u146f\u1470\u0003\u0234\u011a\u0000\u1470\u1471\u0005"+ + "\u00b0\u0000\u0000\u1471\u1476\u0003\u0234\u011a\u0000\u1472\u1473\u0005"+ + "\u0470\u0000\u0000\u1473\u1475\u0003\u0234\u011a\u0000\u1474\u1472\u0001"+ + "\u0000\u0000\u0000\u1475\u1478\u0001\u0000\u0000\u0000\u1476\u1474\u0001"+ + "\u0000\u0000\u0000\u1476\u1477\u0001\u0000\u0000\u0000\u1477\u147c\u0001"+ + "\u0000\u0000\u0000\u1478\u1476\u0001\u0000\u0000\u0000\u1479\u147a\u0005"+ + "\u00c1\u0000\u0000\u147a\u147b\u0005I\u0000\u0000\u147b\u147d\u0005y\u0000"+ + "\u0000\u147c\u1479\u0001\u0000\u0000\u0000\u147c\u147d\u0001\u0000\u0000"+ + "\u0000\u147d\u01b5\u0001\u0000\u0000\u0000\u147e\u147f\u0005\u008c\u0000"+ + "\u0000\u147f\u1480\u0005\u029a\u0000\u0000\u1480\u1485\u0003\u01d4\u00ea"+ + "\u0000\u1481\u1482\u0005\u0470\u0000\u0000\u1482\u1484\u0003\u01d4\u00ea"+ + "\u0000\u1483\u1481\u0001\u0000\u0000\u0000\u1484\u1487\u0001\u0000\u0000"+ + "\u0000\u1485\u1483\u0001\u0000\u0000\u0000\u1485\u1486\u0001\u0000\u0000"+ + "\u0000\u1486\u01b7\u0001\u0000\u0000\u0000\u1487\u1485\u0001\u0000\u0000"+ + "\u0000\u1488\u1489\u0005\u0094\u0000\u0000\u1489\u148e\u0003\u01ce\u00e7"+ + "\u0000\u148a\u148b\u0005\u0470\u0000\u0000\u148b\u148d\u0003\u01ce\u00e7"+ + "\u0000\u148c\u148a\u0001\u0000\u0000\u0000\u148d\u1490\u0001\u0000\u0000"+ + "\u0000\u148e\u148c\u0001\u0000\u0000\u0000\u148e\u148f\u0001\u0000\u0000"+ + "\u0000\u148f\u1491\u0001\u0000\u0000\u0000\u1490\u148e\u0001\u0000\u0000"+ + "\u0000\u1491\u1493\u0005w\u0000\u0000\u1492\u1494\u0007B\u0000\u0000\u1493"+ + "\u1492\u0001\u0000\u0000\u0000\u1493\u1494\u0001\u0000\u0000\u0000\u1494"+ + "\u1495\u0001\u0000\u0000\u0000\u1495\u1496\u0003\u01d2\u00e9\u0000\u1496"+ + "\u1497\u0005E\u0000\u0000\u1497\u149c\u0003\u0234\u011a\u0000\u1498\u1499"+ + "\u0005\u0470\u0000\u0000\u1499\u149b\u0003\u0234\u011a\u0000\u149a\u1498"+ + "\u0001\u0000\u0000\u0000\u149b\u149e\u0001\u0000\u0000\u0000\u149c\u149a"+ + "\u0001\u0000\u0000\u0000\u149c\u149d\u0001\u0000\u0000\u0000\u149d\u14cf"+ + "\u0001\u0000\u0000\u0000\u149e\u149c\u0001\u0000\u0000\u0000\u149f\u14a0"+ + "\u0005\u0094\u0000\u0000\u14a0\u14a2\u0005\u0007\u0000\u0000\u14a1\u14a3"+ + "\u0005\u02d6\u0000\u0000\u14a2\u14a1\u0001\u0000\u0000\u0000\u14a2\u14a3"+ + "\u0001\u0000\u0000\u0000\u14a3\u14a4\u0001\u0000\u0000\u0000\u14a4\u14a5"+ + "\u0005\u0470\u0000\u0000\u14a5\u14a6\u0005I\u0000\u0000\u14a6\u14a7\u0005"+ + "y\u0000\u0000\u14a7\u14a8\u0005E\u0000\u0000\u14a8\u14ad\u0003\u0234\u011a"+ + "\u0000\u14a9\u14aa\u0005\u0470\u0000\u0000\u14aa\u14ac\u0003\u0234\u011a"+ + "\u0000\u14ab\u14a9\u0001\u0000\u0000\u0000\u14ac\u14af\u0001\u0000\u0000"+ + "\u0000\u14ad\u14ab\u0001\u0000\u0000\u0000\u14ad\u14ae\u0001\u0000\u0000"+ + "\u0000\u14ae\u14cf\u0001\u0000\u0000\u0000\u14af\u14ad\u0001\u0000\u0000"+ + "\u0000\u14b0\u14b3\u0005\u0094\u0000\u0000\u14b1\u14b4\u0003\u0234\u011a"+ + "\u0000\u14b2\u14b4\u0003\u0248\u0124\u0000\u14b3\u14b1\u0001\u0000\u0000"+ + "\u0000\u14b3\u14b2\u0001\u0000\u0000\u0000\u14b4\u14bc\u0001\u0000\u0000"+ + "\u0000\u14b5\u14b8\u0005\u0470\u0000\u0000\u14b6\u14b9\u0003\u0234\u011a"+ + "\u0000\u14b7\u14b9\u0003\u0248\u0124\u0000\u14b8\u14b6\u0001\u0000\u0000"+ + "\u0000\u14b8\u14b7\u0001\u0000\u0000\u0000\u14b9\u14bb\u0001\u0000\u0000"+ + "\u0000\u14ba\u14b5\u0001\u0000\u0000\u0000\u14bb\u14be\u0001\u0000\u0000"+ + "\u0000\u14bc\u14ba\u0001\u0000\u0000\u0000\u14bc\u14bd\u0001\u0000\u0000"+ + "\u0000\u14bd\u14bf\u0001\u0000\u0000\u0000\u14be\u14bc\u0001\u0000\u0000"+ + "\u0000\u14bf\u14c2\u0005E\u0000\u0000\u14c0\u14c3\u0003\u0234\u011a\u0000"+ + "\u14c1\u14c3\u0003\u0248\u0124\u0000\u14c2\u14c0\u0001\u0000\u0000\u0000"+ + "\u14c2\u14c1\u0001\u0000\u0000\u0000\u14c3\u14cb\u0001\u0000\u0000\u0000"+ + "\u14c4\u14c7\u0005\u0470\u0000\u0000\u14c5\u14c8\u0003\u0234\u011a\u0000"+ + "\u14c6\u14c8\u0003\u0248\u0124\u0000\u14c7\u14c5\u0001\u0000\u0000\u0000"+ + "\u14c7\u14c6\u0001\u0000\u0000\u0000\u14c8\u14ca\u0001\u0000\u0000\u0000"+ + "\u14c9\u14c4\u0001\u0000\u0000\u0000\u14ca\u14cd\u0001\u0000\u0000\u0000"+ + "\u14cb\u14c9\u0001\u0000\u0000\u0000\u14cb\u14cc\u0001\u0000\u0000\u0000"+ + "\u14cc\u14cf\u0001\u0000\u0000\u0000\u14cd\u14cb\u0001\u0000\u0000\u0000"+ + "\u14ce\u1488\u0001\u0000\u0000\u0000\u14ce\u149f\u0001\u0000\u0000\u0000"+ + "\u14ce\u14b0\u0001\u0000\u0000\u0000\u14cf\u01b9\u0001\u0000\u0000\u0000"+ + "\u14d0\u14d1\u0005\u0094\u0000\u0000\u14d1\u14d2\u0005\u0237\u0000\u0000"+ + "\u14d2\u14d3\u0005w\u0000\u0000\u14d3\u14d4\u0003\u0234\u011a\u0000\u14d4"+ + "\u14d5\u0005E\u0000\u0000\u14d5\u14da\u0003\u0234\u011a\u0000\u14d6\u14d7"+ + "\u0005\u0470\u0000\u0000\u14d7\u14d9\u0003\u0234\u011a\u0000\u14d8\u14d6"+ + "\u0001\u0000\u0000\u0000\u14d9\u14dc\u0001\u0000\u0000\u0000\u14da\u14d8"+ + "\u0001\u0000\u0000\u0000\u14da\u14db\u0001\u0000\u0000\u0000\u14db\u01bb"+ + "\u0001\u0000\u0000\u0000\u14dc\u14da\u0001\u0000\u0000\u0000\u14dd\u14de"+ + "\u0005\u009a\u0000\u0000\u14de\u14e1\u0005\u0228\u0000\u0000\u14df\u14e0"+ + "\u0005B\u0000\u0000\u14e0\u14e2\u0003\u0234\u011a\u0000\u14e1\u14df\u0001"+ + "\u0000\u0000\u0000\u14e1\u14e2\u0001\u0000\u0000\u0000\u14e2\u14e3\u0001"+ + "\u0000\u0000\u0000\u14e3\u14e6\u0005\u0465\u0000\u0000\u14e4\u14e7\u0003"+ + "\u02aa\u0155\u0000\u14e5\u14e7\u0005\u047d\u0000\u0000\u14e6\u14e4\u0001"+ + "\u0000\u0000\u0000\u14e6\u14e5\u0001\u0000\u0000\u0000\u14e7\u01bd\u0001"+ + "\u0000\u0000\u0000\u14e8\u14e9\u0003\u0234\u011a\u0000\u14e9\u14ea\u0003"+ + "\u01ca\u00e5\u0000\u14ea\u01bf\u0001\u0000\u0000\u0000\u14eb\u14ec\u0003"+ + "\u0234\u011a\u0000\u14ec\u14ed\u0005\u01c1\u0000\u0000\u14ed\u14ee\u0005"+ + "\u0014\u0000\u0000\u14ee\u14ef\u0005\u0228\u0000\u0000\u14ef\u14f0\u0005"+ + "\u047d\u0000\u0000\u14f0\u1505\u0001\u0000\u0000\u0000\u14f1\u14f2\u0003"+ + "\u0234\u011a\u0000\u14f2\u14f3\u0005\u01c1\u0000\u0000\u14f3\u14f4\u0005"+ + "\u0014\u0000\u0000\u14f4\u14f5\u0005\u03e0\u0000\u0000\u14f5\u14f6\u0005"+ + "\u0228\u0000\u0000\u14f6\u14f7\u0003\u01c2\u00e1\u0000\u14f7\u1505\u0001"+ + "\u0000\u0000\u0000\u14f8\u14f9\u0003\u0234\u011a\u0000\u14f9\u14fa\u0005"+ + "\u01c1\u0000\u0000\u14fa\u14fb\u0005\u0014\u0000\u0000\u14fb\u14fc\u0005"+ + "\u047d\u0000\u0000\u14fc\u14fd\u0003\u01c2\u00e1\u0000\u14fd\u1505\u0001"+ + "\u0000\u0000\u0000\u14fe\u14ff\u0003\u0234\u011a\u0000\u14ff\u1500\u0005"+ + "\u01c1\u0000\u0000\u1500\u1501\u0005\u00c1\u0000\u0000\u1501\u1502\u0003"+ + "\u01c4\u00e2\u0000\u1502\u1505\u0001\u0000\u0000\u0000\u1503\u1505\u0003"+ + "\u0234\u011a\u0000\u1504\u14eb\u0001\u0000\u0000\u0000\u1504\u14f1\u0001"+ + "\u0000\u0000\u0000\u1504\u14f8\u0001\u0000\u0000\u0000\u1504\u14fe\u0001"+ + "\u0000\u0000\u0000\u1504\u1503\u0001\u0000\u0000\u0000\u1505\u01c1\u0001"+ + "\u0000\u0000\u0000\u1506\u1507\u0005\u008e\u0000\u0000\u1507\u1509\u0005"+ + "\u047d\u0000\u0000\u1508\u1506\u0001\u0000\u0000\u0000\u1508\u1509\u0001"+ + "\u0000\u0000\u0000\u1509\u150d\u0001\u0000\u0000\u0000\u150a\u150b\u0005"+ + "\u0092\u0000\u0000\u150b\u150c\u0005$\u0000\u0000\u150c\u150e\u0005\u0228"+ + "\u0000\u0000\u150d\u150a\u0001\u0000\u0000\u0000\u150d\u150e\u0001\u0000"+ + "\u0000\u0000\u150e\u01c3\u0001\u0000\u0000\u0000\u150f\u1517\u0003\u0246"+ + "\u0123\u0000\u1510\u1514\u0007C\u0000\u0000\u1511\u1515\u0005\u047d\u0000"+ + "\u0000\u1512\u1513\u0005\u03e0\u0000\u0000\u1513\u1515\u0005\u0228\u0000"+ + "\u0000\u1514\u1511\u0001\u0000\u0000\u0000\u1514\u1512\u0001\u0000\u0000"+ + "\u0000\u1515\u1516\u0001\u0000\u0000\u0000\u1516\u1518\u0003\u01c2\u00e1"+ + "\u0000\u1517\u1510\u0001\u0000\u0000\u0000\u1517\u1518\u0001\u0000\u0000"+ + "\u0000\u1518\u151e\u0001\u0000\u0000\u0000\u1519\u151a\u0003\u0246\u0123"+ + "\u0000\u151a\u151b\u0005\u00bc\u0000\u0000\u151b\u151c\u0003\u02aa\u0155"+ + "\u0000\u151c\u151e\u0001\u0000\u0000\u0000\u151d\u150f\u0001\u0000\u0000"+ + "\u0000\u151d\u1519\u0001\u0000\u0000\u0000\u151e\u01c5\u0001\u0000\u0000"+ + "\u0000\u151f\u1528\u0005\u00a8\u0000\u0000\u1520\u1528\u0005\u02a9\u0000"+ + "\u0000\u1521\u1522\u0005\u0167\u0000\u0000\u1522\u1528\u0005\u047d\u0000"+ + "\u0000\u1523\u1524\u0005\u01d2\u0000\u0000\u1524\u1528\u0005\u047d\u0000"+ + "\u0000\u1525\u1526\u0005\u0281\u0000\u0000\u1526\u1528\u0005\u047d\u0000"+ + "\u0000\u1527\u151f\u0001\u0000\u0000\u0000\u1527\u1520\u0001\u0000\u0000"+ + "\u0000\u1527\u1521\u0001\u0000\u0000\u0000\u1527\u1523\u0001\u0000\u0000"+ + "\u0000\u1527\u1525\u0001\u0000\u0000\u0000\u1528\u01c7\u0001\u0000\u0000"+ + "\u0000\u1529\u152a\u0005\u01f4\u0000\u0000\u152a\u1532\u0003\u024e\u0127"+ + "\u0000\u152b\u152c\u0005\u01f7\u0000\u0000\u152c\u1532\u0003\u024e\u0127"+ + "\u0000\u152d\u152e\u0005\u01f3\u0000\u0000\u152e\u1532\u0003\u024e\u0127"+ + "\u0000\u152f\u1530\u0005\u01f8\u0000\u0000\u1530\u1532\u0003\u024e\u0127"+ + "\u0000\u1531\u1529\u0001\u0000\u0000\u0000\u1531\u152b\u0001\u0000\u0000"+ + "\u0000\u1531\u152d\u0001\u0000\u0000\u0000\u1531\u152f\u0001\u0000\u0000"+ + "\u0000\u1532\u01c9\u0001\u0000\u0000\u0000\u1533\u1534\u0005\u0228\u0000"+ + "\u0000\u1534\u153b\u0005\u01a5\u0000\u0000\u1535\u153c\u0005+\u0000\u0000"+ + "\u1536\u153c\u0005\u0208\u0000\u0000\u1537\u1538\u0005W\u0000\u0000\u1538"+ + "\u1539\u0003\u024e\u0127\u0000\u1539\u153a\u0005\u02b4\u0000\u0000\u153a"+ + "\u153c\u0001\u0000\u0000\u0000\u153b\u1535\u0001\u0000\u0000\u0000\u153b"+ + "\u1536\u0001\u0000\u0000\u0000\u153b\u1537\u0001\u0000\u0000\u0000\u153b"+ + "\u153c\u0001\u0000\u0000\u0000\u153c\u155a\u0001\u0000\u0000\u0000\u153d"+ + "\u153e\u0005\u0228\u0000\u0000\u153e\u1541\u0005\u01be\u0000\u0000\u153f"+ + "\u1542\u0005+\u0000\u0000\u1540\u1542\u0003\u024e\u0127\u0000\u1541\u153f"+ + "\u0001\u0000\u0000\u0000\u1541\u1540\u0001\u0000\u0000\u0000\u1542\u155a"+ + "\u0001\u0000\u0000\u0000\u1543\u1544\u0005\u0228\u0000\u0000\u1544\u1545"+ + "\u0005\u0254\u0000\u0000\u1545\u154a\u0005W\u0000\u0000\u1546\u154b\u0005"+ + "+\u0000\u0000\u1547\u1548\u0003\u024e\u0127\u0000\u1548\u1549\u0005\u02b4"+ + "\u0000\u0000\u1549\u154b\u0001\u0000\u0000\u0000\u154a\u1546\u0001\u0000"+ + "\u0000\u0000\u154a\u1547\u0001\u0000\u0000\u0000\u154b\u155a\u0001\u0000"+ + "\u0000\u0000\u154c\u154d\u0005\u0228\u0000\u0000\u154d\u154e\u0005\u008f"+ + "\u0000\u0000\u154e\u1550\u0005$\u0000\u0000\u154f\u1551\u0007D\u0000\u0000"+ + "\u1550\u154f\u0001\u0000\u0000\u0000\u1550\u1551\u0001\u0000\u0000\u0000"+ + "\u1551\u155a\u0001\u0000\u0000\u0000\u1552\u1553\u0005\u01a9\u0000\u0000"+ + "\u1553\u155a\u0003\u024e\u0127\u0000\u1554\u1557\u0005\u0229\u0000\u0000"+ + "\u1555\u1558\u0003\u024e\u0127\u0000\u1556\u1558\u0005\u0292\u0000\u0000"+ + "\u1557\u1555\u0001\u0000\u0000\u0000\u1557\u1556\u0001\u0000\u0000\u0000"+ + "\u1558\u155a\u0001\u0000\u0000\u0000\u1559\u1533\u0001\u0000\u0000\u0000"+ + "\u1559\u153d\u0001\u0000\u0000\u0000\u1559\u1543\u0001\u0000\u0000\u0000"+ + "\u1559\u154c\u0001\u0000\u0000\u0000\u1559\u1552\u0001\u0000\u0000\u0000"+ + "\u1559\u1554\u0001\u0000\u0000\u0000\u155a\u01cb\u0001\u0000\u0000\u0000"+ + "\u155b\u155c\u0005\u014d\u0000\u0000\u155c\u155d\u0007E\u0000\u0000\u155d"+ + "\u01cd\u0001\u0000\u0000\u0000\u155e\u1563\u0003\u01d0\u00e8\u0000\u155f"+ + "\u1560\u0005\u046e\u0000\u0000\u1560\u1561\u0003\u0268\u0134\u0000\u1561"+ + "\u1562\u0005\u046f\u0000\u0000\u1562\u1564\u0001\u0000\u0000\u0000\u1563"+ + "\u155f\u0001\u0000\u0000\u0000\u1563\u1564\u0001\u0000\u0000\u0000\u1564"+ + "\u01cf\u0001\u0000\u0000\u0000\u1565\u1567\u0005\u0007\u0000\u0000\u1566"+ + "\u1568\u0005\u02d6\u0000\u0000\u1567\u1566\u0001\u0000\u0000\u0000\u1567"+ + "\u1568\u0001\u0000\u0000\u0000\u1568\u15c3\u0001\u0000\u0000\u0000\u1569"+ + "\u156b\u0005\b\u0000\u0000\u156a\u156c\u0005\u02de\u0000\u0000\u156b\u156a"+ + "\u0001\u0000\u0000\u0000\u156b\u156c\u0001\u0000\u0000\u0000\u156c\u15c3"+ + "\u0001\u0000\u0000\u0000\u156d\u1575\u0005\"\u0000\u0000\u156e\u156f\u0005"+ + "\u028a\u0000\u0000\u156f\u1576\u0005\u02e7\u0000\u0000\u1570\u1576\u0005"+ + "\u02de\u0000\u0000\u1571\u1576\u0005\u02a0\u0000\u0000\u1572\u1576\u0005"+ + "\u029a\u0000\u0000\u1573\u1576\u0005\u0288\u0000\u0000\u1574\u1576\u0005"+ + "\u0255\u0000\u0000\u1575\u156e\u0001\u0000\u0000\u0000\u1575\u1570\u0001"+ + "\u0000\u0000\u0000\u1575\u1571\u0001\u0000\u0000\u0000\u1575\u1572\u0001"+ + "\u0000\u0000\u0000\u1575\u1573\u0001\u0000\u0000\u0000\u1575\u1574\u0001"+ + "\u0000\u0000\u0000\u1575\u1576\u0001\u0000\u0000\u0000\u1576\u15c3\u0001"+ + "\u0000\u0000\u0000\u1577\u15c3\u0005-\u0000\u0000\u1578\u157a\u00054\u0000"+ + "\u0000\u1579\u157b\u0005\u0255\u0000\u0000\u157a\u1579\u0001\u0000\u0000"+ + "\u0000\u157a\u157b\u0001\u0000\u0000\u0000\u157b\u15c3\u0001\u0000\u0000"+ + "\u0000\u157c\u15c3\u0005\u01a0\u0000\u0000\u157d\u15c3\u0005\u02c5\u0000"+ + "\u0000\u157e\u15c3\u0005\u02c6\u0000\u0000\u157f\u1580\u0005I\u0000\u0000"+ + "\u1580\u15c3\u0005y\u0000\u0000\u1581\u15c3\u0005R\u0000\u0000\u1582\u15c3"+ + "\u0005V\u0000\u0000\u1583\u1584\u0005h\u0000\u0000\u1584\u15c3\u0005\u02e7"+ + "\u0000\u0000\u1585\u15c3\u0005\u02d7\u0000\u0000\u1586\u15c3\u0005\u0237"+ + "\u0000\u0000\u1587\u15c3\u0005\u0089\u0000\u0000\u1588\u15c3\u0005\u02d8"+ + "\u0000\u0000\u1589\u158a\u0005\u024d\u0000\u0000\u158a\u15c3\u0007F\u0000"+ + "\u0000\u158b\u15c3\u0005\u0099\u0000\u0000\u158c\u158d\u0005\u009c\u0000"+ + "\u0000\u158d\u15c3\u0007G\u0000\u0000\u158e\u15c3\u0005\u02e4\u0000\u0000"+ + "\u158f\u15c3\u0005\u02e5\u0000\u0000\u1590\u15c3\u0005\u00b2\u0000\u0000"+ + "\u1591\u15c3\u0005\u00b9\u0000\u0000\u1592\u15c3\u0005\u00ba\u0000\u0000"+ + "\u1593\u15c3\u0005\u02bb\u0000\u0000\u1594\u15c3\u0005\u02bc\u0000\u0000"+ + "\u1595\u15c3\u0005\u02bd\u0000\u0000\u1596\u15c3\u0005\u02be\u0000\u0000"+ + "\u1597\u15c3\u0005\u02bf\u0000\u0000\u1598\u15c3\u0005\u02c0\u0000\u0000"+ + "\u1599\u15c3\u0005\u02c1\u0000\u0000\u159a\u15c3\u0005\u02c2\u0000\u0000"+ + "\u159b\u15c3\u0005\u02c3\u0000\u0000\u159c\u15c3\u0005\u02c4\u0000\u0000"+ + "\u159d\u15c3\u0005\u02c7\u0000\u0000\u159e\u15c3\u0005\u02c8\u0000\u0000"+ + "\u159f\u15c3\u0005\u02c9\u0000\u0000\u15a0\u15c3\u0005\u02ca\u0000\u0000"+ + "\u15a1\u15c3\u0005\u02cb\u0000\u0000\u15a2\u15c3\u0005\u02cc\u0000\u0000"+ + "\u15a3\u15c3\u0005\u02cd\u0000\u0000\u15a4\u15c3\u0005\u02ce\u0000\u0000"+ + "\u15a5\u15c3\u0005\u02cf\u0000\u0000\u15a6\u15c3\u0005\u02d0\u0000\u0000"+ + "\u15a7\u15c3\u0005\u02d3\u0000\u0000\u15a8\u15c3\u0005\u02d4\u0000\u0000"+ + "\u15a9\u15c3\u0005\u02d5\u0000\u0000\u15aa\u15c3\u0005\u02d9\u0000\u0000"+ + "\u15ab\u15c3\u0005\u02da\u0000\u0000\u15ac\u15c3\u0005\u02db\u0000\u0000"+ + "\u15ad\u15c3\u0005\u02dc\u0000\u0000\u15ae\u15c3\u0005\u02dd\u0000\u0000"+ + "\u15af\u15c3\u0005\u02e0\u0000\u0000\u15b0\u15c3\u0005\u02e1\u0000\u0000"+ + "\u15b1\u15c3\u0005\u02e2\u0000\u0000\u15b2\u15c3\u0005\u009f\u0000\u0000"+ + "\u15b3\u15c3\u0005\u02e3\u0000\u0000\u15b4\u15c3\u0005\u0436\u0000\u0000"+ + "\u15b5\u15c3\u0005\u02e6\u0000\u0000\u15b6\u15c3\u0005\u02e8\u0000\u0000"+ + "\u15b7\u15c3\u0005\u0441\u0000\u0000\u15b8\u15c3\u0005\u02e9\u0000\u0000"+ + "\u15b9\u15c3\u0005\u02ea\u0000\u0000\u15ba\u15bb\u0005g\u0000\u0000\u15bb"+ + "\u15bc\u0005E\u0000\u0000\u15bc\u15c3\u0005\u02df\u0000\u0000\u15bd\u15be"+ + "\u0005\u0099\u0000\u0000\u15be\u15bf\u0005X\u0000\u0000\u15bf\u15c3\u0005"+ + "\u02df\u0000\u0000\u15c0\u15c1\u0005\u02d1\u0000\u0000\u15c1\u15c3\u0005"+ + "\u02d2\u0000\u0000\u15c2\u1565\u0001\u0000\u0000\u0000\u15c2\u1569\u0001"+ + "\u0000\u0000\u0000\u15c2\u156d\u0001\u0000\u0000\u0000\u15c2\u1577\u0001"+ + "\u0000\u0000\u0000\u15c2\u1578\u0001\u0000\u0000\u0000\u15c2\u157c\u0001"+ + "\u0000\u0000\u0000\u15c2\u157d\u0001\u0000\u0000\u0000\u15c2\u157e\u0001"+ + "\u0000\u0000\u0000\u15c2\u157f\u0001\u0000\u0000\u0000\u15c2\u1581\u0001"+ + "\u0000\u0000\u0000\u15c2\u1582\u0001\u0000\u0000\u0000\u15c2\u1583\u0001"+ + "\u0000\u0000\u0000\u15c2\u1585\u0001\u0000\u0000\u0000\u15c2\u1586\u0001"+ + "\u0000\u0000\u0000\u15c2\u1587\u0001\u0000\u0000\u0000\u15c2\u1588\u0001"+ + "\u0000\u0000\u0000\u15c2\u1589\u0001\u0000\u0000\u0000\u15c2\u158b\u0001"+ + "\u0000\u0000\u0000\u15c2\u158c\u0001\u0000\u0000\u0000\u15c2\u158e\u0001"+ + "\u0000\u0000\u0000\u15c2\u158f\u0001\u0000\u0000\u0000\u15c2\u1590\u0001"+ + "\u0000\u0000\u0000\u15c2\u1591\u0001\u0000\u0000\u0000\u15c2\u1592\u0001"+ + "\u0000\u0000\u0000\u15c2\u1593\u0001\u0000\u0000\u0000\u15c2\u1594\u0001"+ + "\u0000\u0000\u0000\u15c2\u1595\u0001\u0000\u0000\u0000\u15c2\u1596\u0001"+ + "\u0000\u0000\u0000\u15c2\u1597\u0001\u0000\u0000\u0000\u15c2\u1598\u0001"+ + "\u0000\u0000\u0000\u15c2\u1599\u0001\u0000\u0000\u0000\u15c2\u159a\u0001"+ + "\u0000\u0000\u0000\u15c2\u159b\u0001\u0000\u0000\u0000\u15c2\u159c\u0001"+ + "\u0000\u0000\u0000\u15c2\u159d\u0001\u0000\u0000\u0000\u15c2\u159e\u0001"+ + "\u0000\u0000\u0000\u15c2\u159f\u0001\u0000\u0000\u0000\u15c2\u15a0\u0001"+ + "\u0000\u0000\u0000\u15c2\u15a1\u0001\u0000\u0000\u0000\u15c2\u15a2\u0001"+ + "\u0000\u0000\u0000\u15c2\u15a3\u0001\u0000\u0000\u0000\u15c2\u15a4\u0001"+ + "\u0000\u0000\u0000\u15c2\u15a5\u0001\u0000\u0000\u0000\u15c2\u15a6\u0001"+ + "\u0000\u0000\u0000\u15c2\u15a7\u0001\u0000\u0000\u0000\u15c2\u15a8\u0001"+ + "\u0000\u0000\u0000\u15c2\u15a9\u0001\u0000\u0000\u0000\u15c2\u15aa\u0001"+ + "\u0000\u0000\u0000\u15c2\u15ab\u0001\u0000\u0000\u0000\u15c2\u15ac\u0001"+ + "\u0000\u0000\u0000\u15c2\u15ad\u0001\u0000\u0000\u0000\u15c2\u15ae\u0001"+ + "\u0000\u0000\u0000\u15c2\u15af\u0001\u0000\u0000\u0000\u15c2\u15b0\u0001"+ + "\u0000\u0000\u0000\u15c2\u15b1\u0001\u0000\u0000\u0000\u15c2\u15b2\u0001"+ + "\u0000\u0000\u0000\u15c2\u15b3\u0001\u0000\u0000\u0000\u15c2\u15b4\u0001"+ + "\u0000\u0000\u0000\u15c2\u15b5\u0001\u0000\u0000\u0000\u15c2\u15b6\u0001"+ + "\u0000\u0000\u0000\u15c2\u15b7\u0001\u0000\u0000\u0000\u15c2\u15b8\u0001"+ + "\u0000\u0000\u0000\u15c2\u15b9\u0001\u0000\u0000\u0000\u15c2\u15ba\u0001"+ + "\u0000\u0000\u0000\u15c2\u15bd\u0001\u0000\u0000\u0000\u15c2\u15c0\u0001"+ + "\u0000\u0000\u0000\u15c3\u01d1\u0001\u0000\u0000\u0000\u15c4\u15d5\u0005"+ + "\u045e\u0000\u0000\u15c5\u15c6\u0005\u045e\u0000\u0000\u15c6\u15c7\u0005"+ + "\u046d\u0000\u0000\u15c7\u15d5\u0005\u045e\u0000\u0000\u15c8\u15c9\u0003"+ + "\u0248\u0124\u0000\u15c9\u15ca\u0005\u046d\u0000\u0000\u15ca\u15cb\u0005"+ + "\u045e\u0000\u0000\u15cb\u15d5\u0001\u0000\u0000\u0000\u15cc\u15cd\u0003"+ + "\u0248\u0124\u0000\u15cd\u15ce\u0005\u046d\u0000\u0000\u15ce\u15cf\u0003"+ + "\u0248\u0124\u0000\u15cf\u15d5\u0001\u0000\u0000\u0000\u15d0\u15d1\u0003"+ + "\u0248\u0124\u0000\u15d1\u15d2\u0003\u024c\u0126\u0000\u15d2\u15d5\u0001"+ + "\u0000\u0000\u0000\u15d3\u15d5\u0003\u0248\u0124\u0000\u15d4\u15c4\u0001"+ + "\u0000\u0000\u0000\u15d4\u15c5\u0001\u0000\u0000\u0000\u15d4\u15c8\u0001"+ + "\u0000\u0000\u0000\u15d4\u15cc\u0001\u0000\u0000\u0000\u15d4\u15d0\u0001"+ + "\u0000\u0000\u0000\u15d4\u15d3\u0001\u0000\u0000\u0000\u15d5\u01d3\u0001"+ + "\u0000\u0000\u0000\u15d6\u15d7\u0003\u0234\u011a\u0000\u15d7\u15d8\u0005"+ + "\u00b0\u0000\u0000\u15d8\u15d9\u0003\u0234\u011a\u0000\u15d9\u01d5\u0001"+ + "\u0000\u0000\u0000\u15da\u15dc\u0005\n\u0000\u0000\u15db\u15dd\u0007H"+ + "\u0000\u0000\u15dc\u15db\u0001\u0000\u0000\u0000\u15dc\u15dd\u0001\u0000"+ + "\u0000\u0000\u15dd\u15de\u0001\u0000\u0000\u0000\u15de\u15df\u00076\u0000"+ + "\u0000\u15df\u15f1\u0003\u026c\u0136\u0000\u15e0\u15e1\u0005\u00b9\u0000"+ + "\u0000\u15e1\u15e2\u0005M\u0000\u0000\u15e2\u15e3\u0005w\u0000\u0000\u15e3"+ + "\u15e8\u0003\u022c\u0116\u0000\u15e4\u15e5\u0005\u0470\u0000\u0000\u15e5"+ + "\u15e7\u0003\u022c\u0116\u0000\u15e6\u15e4\u0001\u0000\u0000\u0000\u15e7"+ + "\u15ea\u0001\u0000\u0000\u0000\u15e8\u15e6\u0001\u0000\u0000\u0000\u15e8"+ + "\u15e9\u0001\u0000\u0000\u0000\u15e9\u15ef\u0001\u0000\u0000\u0000\u15ea"+ + "\u15e8\u0001\u0000\u0000\u0000\u15eb\u15ec\u0005\u00c1\u0000\u0000\u15ec"+ + "\u15ed\u0003\u024e\u0127\u0000\u15ed\u15ee\u0005\u0013\u0000\u0000\u15ee"+ + "\u15f0\u0001\u0000\u0000\u0000\u15ef\u15eb\u0001\u0000\u0000\u0000\u15ef"+ + "\u15f0\u0001\u0000\u0000\u0000\u15f0\u15f2\u0001\u0000\u0000\u0000\u15f1"+ + "\u15e0\u0001\u0000\u0000\u0000\u15f1\u15f2\u0001\u0000\u0000\u0000\u15f2"+ + "\u15fe\u0001\u0000\u0000\u0000\u15f3\u15f4\u00054\u0000\u0000\u15f4\u15f5"+ + "\u0005M\u0000\u0000\u15f5\u15f6\u0005w\u0000\u0000\u15f6\u15fb\u0003\u022c"+ + "\u0116\u0000\u15f7\u15f8\u0005\u0470\u0000\u0000\u15f8\u15fa\u0003\u022c"+ + "\u0116\u0000\u15f9\u15f7\u0001\u0000\u0000\u0000\u15fa\u15fd\u0001\u0000"+ + "\u0000\u0000\u15fb\u15f9\u0001\u0000\u0000\u0000\u15fb\u15fc\u0001\u0000"+ + "\u0000\u0000\u15fc\u15ff\u0001\u0000\u0000\u0000\u15fd\u15fb\u0001\u0000"+ + "\u0000\u0000\u15fe\u15f3\u0001\u0000\u0000\u0000\u15fe\u15ff\u0001\u0000"+ + "\u0000\u0000\u15ff\u01d7\u0001\u0000\u0000\u0000\u1600\u1601\u0005\u001b"+ + "\u0000\u0000\u1601\u1602\u0005\u00ad\u0000\u0000\u1602\u1606\u0003\u026c"+ + "\u0136\u0000\u1603\u1605\u0003\u01e0\u00f0\u0000\u1604\u1603\u0001\u0000"+ + "\u0000\u0000\u1605\u1608\u0001\u0000\u0000\u0000\u1606\u1604\u0001\u0000"+ + "\u0000\u0000\u1606\u1607\u0001\u0000\u0000\u0000\u1607\u01d9\u0001\u0000"+ + "\u0000\u0000\u1608\u1606\u0001\u0000\u0000\u0000\u1609\u160a\u0005\u0165"+ + "\u0000\u0000\u160a\u160b\u0005\u00ad\u0000\u0000\u160b\u160d\u0003\u026c"+ + "\u0136\u0000\u160c\u160e\u0007I\u0000\u0000\u160d\u160c\u0001\u0000\u0000"+ + "\u0000\u160d\u160e\u0001\u0000\u0000\u0000\u160e\u01db\u0001\u0000\u0000"+ + "\u0000\u160f\u1611\u0005x\u0000\u0000\u1610\u1612\u0007H\u0000\u0000\u1611"+ + "\u1610\u0001\u0000\u0000\u0000\u1611\u1612\u0001\u0000\u0000\u0000\u1612"+ + "\u1613\u0001\u0000\u0000\u0000\u1613\u1614\u00076\u0000\u0000\u1614\u1615"+ + "\u0003\u026c\u0136\u0000\u1615\u01dd\u0001\u0000\u0000\u0000\u1616\u1618"+ + "\u0005\u0245\u0000\u0000\u1617\u1619\u0007H\u0000\u0000\u1618\u1617\u0001"+ + "\u0000\u0000\u0000\u1618\u1619\u0001\u0000\u0000\u0000\u1619\u161a\u0001"+ + "\u0000\u0000\u0000\u161a\u161b\u0005\u00ad\u0000\u0000\u161b\u161d\u0003"+ + "\u026c\u0136\u0000\u161c\u161e\u0005\u0239\u0000\u0000\u161d\u161c\u0001"+ + "\u0000\u0000\u0000\u161d\u161e\u0001\u0000\u0000\u0000\u161e\u1620\u0001"+ + "\u0000\u0000\u0000\u161f\u1621\u0005\u01a7\u0000\u0000\u1620\u161f\u0001"+ + "\u0000\u0000\u0000\u1620\u1621\u0001\u0000\u0000\u0000\u1621\u1623\u0001"+ + "\u0000\u0000\u0000\u1622\u1624\u0005\u029b\u0000\u0000\u1623\u1622\u0001"+ + "\u0000\u0000\u0000\u1623\u1624\u0001\u0000\u0000\u0000\u1624\u01df\u0001"+ + "\u0000\u0000\u0000\u1625\u1626\u0005B\u0000\u0000\u1626\u162d\u0005\u0299"+ + "\u0000\u0000\u1627\u162d\u0005\u0239\u0000\u0000\u1628\u162d\u0005\u01aa"+ + "\u0000\u0000\u1629\u162d\u0005\u01f9\u0000\u0000\u162a\u162d\u0005\u01a7"+ + "\u0000\u0000\u162b\u162d\u0005\u0163\u0000\u0000\u162c\u1625\u0001\u0000"+ + "\u0000\u0000\u162c\u1627\u0001\u0000\u0000\u0000\u162c\u1628\u0001\u0000"+ + "\u0000\u0000\u162c\u1629\u0001\u0000\u0000\u0000\u162c\u162a\u0001\u0000"+ + "\u0000\u0000\u162c\u162b\u0001\u0000\u0000\u0000\u162d\u01e1\u0001\u0000"+ + "\u0000\u0000\u162e\u1630\u0005\"\u0000\u0000\u162f\u1631\u0005\u0150\u0000"+ + "\u0000\u1630\u162f\u0001\u0000\u0000\u0000\u1630\u1631\u0001\u0000\u0000"+ + "\u0000\u1631\u1632\u0001\u0000\u0000\u0000\u1632\u1634\u0005\u01b6\u0000"+ + "\u0000\u1633\u1635\u0003\u0282\u0141\u0000\u1634\u1633\u0001\u0000\u0000"+ + "\u0000\u1634\u1635\u0001\u0000\u0000\u0000\u1635\u1636\u0001\u0000\u0000"+ + "\u0000\u1636\u1637\u0003\u0248\u0124\u0000\u1637\u1638\u0005\u0253\u0000"+ + "\u0000\u1638\u1639\u0007J\u0000\u0000\u1639\u163a\u0005\u026c\u0000\u0000"+ + "\u163a\u163b\u0005\u047d\u0000\u0000\u163b\u01e3\u0001\u0000\u0000\u0000"+ + "\u163c\u163d\u0005\u01c9\u0000\u0000\u163d\u163e\u0005\u022b\u0000\u0000"+ + "\u163e\u163f\u0003\u0248\u0124\u0000\u163f\u1640\u0005\u026c\u0000\u0000"+ + "\u1640\u1641\u0005\u047d\u0000\u0000\u1641\u01e5\u0001\u0000\u0000\u0000"+ + "\u1642\u1643\u0005\u0296\u0000\u0000\u1643\u1644\u0005\u022b\u0000\u0000"+ + "\u1644\u1645\u0003\u0248\u0124\u0000\u1645\u01e7\u0001\u0000\u0000\u0000"+ + "\u1646\u1647\u0005\u009a\u0000\u0000\u1647\u1648\u0003\u01ec\u00f6\u0000"+ + "\u1648\u164b\u0007K\u0000\u0000\u1649\u164c\u0003\u02b0\u0158\u0000\u164a"+ + "\u164c\u0005w\u0000\u0000\u164b\u1649\u0001\u0000\u0000\u0000\u164b\u164a"+ + "\u0001\u0000\u0000\u0000\u164c\u1656\u0001\u0000\u0000\u0000\u164d\u164e"+ + "\u0005\u0470\u0000\u0000\u164e\u164f\u0003\u01ec\u00f6\u0000\u164f\u1652"+ + "\u0007K\u0000\u0000\u1650\u1653\u0003\u02b0\u0158\u0000\u1651\u1653\u0005"+ + "w\u0000\u0000\u1652\u1650\u0001\u0000\u0000\u0000\u1652\u1651\u0001\u0000"+ + "\u0000\u0000\u1653\u1655\u0001\u0000\u0000\u0000\u1654\u164d\u0001\u0000"+ + "\u0000\u0000\u1655\u1658\u0001\u0000\u0000\u0000\u1656\u1654\u0001\u0000"+ + "\u0000\u0000\u1656\u1657\u0001\u0000\u0000\u0000\u1657\u167b\u0001\u0000"+ + "\u0000\u0000\u1658\u1656\u0001\u0000\u0000\u0000\u1659\u165a\u0005\u009a"+ + "\u0000\u0000\u165a\u165d\u0003<\u001e\u0000\u165b\u165e\u0003\u0238\u011c"+ + "\u0000\u165c\u165e\u0005+\u0000\u0000\u165d\u165b\u0001\u0000\u0000\u0000"+ + "\u165d\u165c\u0001\u0000\u0000\u0000\u165e\u167b\u0001\u0000\u0000\u0000"+ + "\u165f\u1660\u0005\u009a\u0000\u0000\u1660\u1667\u0005\u0206\u0000\u0000"+ + "\u1661\u1664\u0003\u0238\u011c\u0000\u1662\u1663\u0005\u001c\u0000\u0000"+ + "\u1663\u1665\u0003\u023a\u011d\u0000\u1664\u1662\u0001\u0000\u0000\u0000"+ + "\u1664\u1665\u0001\u0000\u0000\u0000\u1665\u1668\u0001\u0000\u0000\u0000"+ + "\u1666\u1668\u0005+\u0000\u0000\u1667\u1661\u0001\u0000\u0000\u0000\u1667"+ + "\u1666\u0001\u0000\u0000\u0000\u1668\u167b\u0001\u0000\u0000\u0000\u1669"+ + "\u167b\u0003\u01bc\u00de\u0000\u166a\u167b\u0003\u013e\u009f\u0000\u166b"+ + "\u167b\u0003\u013c\u009e\u0000\u166c\u166d\u0005\u009a\u0000\u0000\u166d"+ + "\u166e\u0003\u0226\u0113\u0000\u166e\u166f\u0007K\u0000\u0000\u166f\u1677"+ + "\u0003\u02b0\u0158\u0000\u1670\u1671\u0005\u0470\u0000\u0000\u1671\u1672"+ + "\u0003\u0226\u0113\u0000\u1672\u1673\u0007K\u0000\u0000\u1673\u1674\u0003"+ + "\u02b0\u0158\u0000\u1674\u1676\u0001\u0000\u0000\u0000\u1675\u1670\u0001"+ + "\u0000\u0000\u0000\u1676\u1679\u0001\u0000\u0000\u0000\u1677\u1675\u0001"+ + "\u0000\u0000\u0000\u1677\u1678\u0001\u0000\u0000\u0000\u1678\u167b\u0001"+ + "\u0000\u0000\u0000\u1679\u1677\u0001\u0000\u0000\u0000\u167a\u1646\u0001"+ + "\u0000\u0000\u0000\u167a\u1659\u0001\u0000\u0000\u0000\u167a\u165f\u0001"+ + "\u0000\u0000\u0000\u167a\u1669\u0001\u0000\u0000\u0000\u167a\u166a\u0001"+ + "\u0000\u0000\u0000\u167a\u166b\u0001\u0000\u0000\u0000\u167a\u166c\u0001"+ + "\u0000\u0000\u0000\u167b\u01e9\u0001\u0000\u0000\u0000\u167c\u167d\u0005"+ + "\u009c\u0000\u0000\u167d\u167e\u00078\u0000\u0000\u167e\u1716\u0005\u01dd"+ + "\u0000\u0000\u167f\u1680\u0005\u009c\u0000\u0000\u1680\u1681\u0007L\u0000"+ + "\u0000\u1681\u1684\u0005\u01a1\u0000\u0000\u1682\u1683\u0005Q\u0000\u0000"+ + "\u1683\u1685\u0005\u047d\u0000\u0000\u1684\u1682\u0001\u0000\u0000\u0000"+ + "\u1684\u1685\u0001\u0000\u0000\u0000\u1685\u1688\u0001\u0000\u0000\u0000"+ + "\u1686\u1687\u0005E\u0000\u0000\u1687\u1689\u0003\u024e\u0127\u0000\u1688"+ + "\u1686\u0001\u0000\u0000\u0000\u1688\u1689\u0001\u0000\u0000\u0000\u1689"+ + "\u1691\u0001\u0000\u0000\u0000\u168a\u168e\u0005d\u0000\u0000\u168b\u168c"+ + "\u0003\u024e\u0127\u0000\u168c\u168d\u0005\u0470\u0000\u0000\u168d\u168f"+ + "\u0001\u0000\u0000\u0000\u168e\u168b\u0001\u0000\u0000\u0000\u168e\u168f"+ + "\u0001\u0000\u0000\u0000\u168f\u1690\u0001\u0000\u0000\u0000\u1690\u1692"+ + "\u0003\u024e\u0127\u0000\u1691\u168a\u0001\u0000\u0000\u0000\u1691\u1692"+ + "\u0001\u0000\u0000\u0000\u1692\u1716\u0001\u0000\u0000\u0000\u1693\u1694"+ + "\u0005\u009c\u0000\u0000\u1694\u1696\u0003\u01ee\u00f7\u0000\u1695\u1697"+ + "\u0003\u01f0\u00f8\u0000\u1696\u1695\u0001\u0000\u0000\u0000\u1696\u1697"+ + "\u0001\u0000\u0000\u0000\u1697\u1716\u0001\u0000\u0000\u0000\u1698\u169a"+ + "\u0005\u009c\u0000\u0000\u1699\u169b\u0005\u01b5\u0000\u0000\u169a\u1699"+ + "\u0001\u0000\u0000\u0000\u169a\u169b\u0001\u0000\u0000\u0000\u169b\u169c"+ + "\u0001\u0000\u0000\u0000\u169c\u169d\u0007)\u0000\u0000\u169d\u169e\u0007"+ + "M\u0000\u0000\u169e\u16a1\u0003\u0228\u0114\u0000\u169f\u16a0\u0007M\u0000"+ + "\u0000\u16a0\u16a2\u0003\u0248\u0124\u0000\u16a1\u169f\u0001\u0000\u0000"+ + "\u0000\u16a1\u16a2\u0001\u0000\u0000\u0000\u16a2\u16a4\u0001\u0000\u0000"+ + "\u0000\u16a3\u16a5\u0003\u01f0\u00f8\u0000\u16a4\u16a3\u0001\u0000\u0000"+ + "\u0000\u16a4\u16a5\u0001\u0000\u0000\u0000\u16a5\u1716\u0001\u0000\u0000"+ + "\u0000\u16a6\u16a7\u0005\u009c\u0000\u0000\u16a7\u16a8\u0005\"\u0000\u0000"+ + "\u16a8\u16aa\u0007\u0000\u0000\u0000\u16a9\u16ab\u0003\u0282\u0141\u0000"+ + "\u16aa\u16a9\u0001\u0000\u0000\u0000\u16aa\u16ab\u0001\u0000\u0000\u0000"+ + "\u16ab\u16ac\u0001\u0000\u0000\u0000\u16ac\u1716\u0003\u0248\u0124\u0000"+ + "\u16ad\u16ae\u0005\u009c\u0000\u0000\u16ae\u16af\u0005\"\u0000\u0000\u16af"+ + "\u16b0\u0007N\u0000\u0000\u16b0\u1716\u0003\u0226\u0113\u0000\u16b1\u16b2"+ + "\u0005\u009c\u0000\u0000\u16b2\u16b3\u0005\"\u0000\u0000\u16b3\u16b4\u0005"+ + "\u029a\u0000\u0000\u16b4\u1716\u0003\u0234\u011a\u0000\u16b5\u16b6\u0005"+ + "\u009c\u0000\u0000\u16b6\u16b7\u0005\u019a\u0000\u0000\u16b7\u16b8\u0003"+ + "\u023c\u011e\u0000\u16b8\u16b9\u0007O\u0000\u0000\u16b9\u1716\u0001\u0000"+ + "\u0000\u0000\u16ba\u16bb\u0005\u009c\u0000\u0000\u16bb\u1716\u0003\u01f2"+ + "\u00f9\u0000\u16bc\u16bd\u0005\u009c\u0000\u0000\u16bd\u16c5\u0007P\u0000"+ + "\u0000\u16be\u16c2\u0005d\u0000\u0000\u16bf\u16c0\u0003\u024e\u0127\u0000"+ + "\u16c0\u16c1\u0005\u0470\u0000\u0000\u16c1\u16c3\u0001\u0000\u0000\u0000"+ + "\u16c2\u16bf\u0001\u0000\u0000\u0000\u16c2\u16c3\u0001\u0000\u0000\u0000"+ + "\u16c3\u16c4\u0001\u0000\u0000\u0000\u16c4\u16c6\u0003\u024e\u0127\u0000"+ + "\u16c5\u16be\u0001\u0000\u0000\u0000\u16c5\u16c6\u0001\u0000\u0000\u0000"+ + "\u16c6\u1716\u0001\u0000\u0000\u0000\u16c7\u16c8\u0005\u009c\u0000\u0000"+ + "\u16c8\u16c9\u0005\u0123\u0000\u0000\u16c9\u16ca\u0005\u046e\u0000\u0000"+ + "\u16ca\u16cb\u0005\u045e\u0000\u0000\u16cb\u16cc\u0005\u046f\u0000\u0000"+ + "\u16cc\u1716\u0007P\u0000\u0000\u16cd\u16ce\u0005\u009c\u0000\u0000\u16ce"+ + "\u16d1\u0003\u01f4\u00fa\u0000\u16cf\u16d0\u0007M\u0000\u0000\u16d0\u16d2"+ + "\u0003\u0248\u0124\u0000\u16d1\u16cf\u0001\u0000\u0000\u0000\u16d1\u16d2"+ + "\u0001\u0000\u0000\u0000\u16d2\u16d4\u0001\u0000\u0000\u0000\u16d3\u16d5"+ + "\u0003\u01f0\u00f8\u0000\u16d4\u16d3\u0001\u0000\u0000\u0000\u16d4\u16d5"+ + "\u0001\u0000\u0000\u0000\u16d5\u1716\u0001\u0000\u0000\u0000\u16d6\u16d7"+ + "\u0005\u009c\u0000\u0000\u16d7\u16d8\u0007Q\u0000\u0000\u16d8\u16d9\u0005"+ + "\u016d\u0000\u0000\u16d9\u1716\u0003\u0226\u0113\u0000\u16da\u16db\u0005"+ + "\u009c\u0000\u0000\u16db\u16de\u0005\u01b9\u0000\u0000\u16dc\u16dd\u0005"+ + "B\u0000\u0000\u16dd\u16df\u0003\u0234\u011a\u0000\u16de\u16dc\u0001\u0000"+ + "\u0000\u0000\u16de\u16df\u0001\u0000\u0000\u0000\u16df\u1716\u0001\u0000"+ + "\u0000\u0000\u16e0\u16e1\u0005\u009c\u0000\u0000\u16e1\u16e2\u0007R\u0000"+ + "\u0000\u16e2\u16e3\u0007M\u0000\u0000\u16e3\u16e6\u0003\u0228\u0114\u0000"+ + "\u16e4\u16e5\u0007M\u0000\u0000\u16e5\u16e7\u0003\u0248\u0124\u0000\u16e6"+ + "\u16e4\u0001\u0000\u0000\u0000\u16e6\u16e7\u0001\u0000\u0000\u0000\u16e7"+ + "\u16ea\u0001\u0000\u0000\u0000\u16e8\u16e9\u0005\u00bf\u0000\u0000\u16e9"+ + "\u16eb\u0003\u02b0\u0158\u0000\u16ea\u16e8\u0001\u0000\u0000\u0000\u16ea"+ + "\u16eb\u0001\u0000\u0000\u0000\u16eb\u1716\u0001\u0000\u0000\u0000\u16ec"+ + "\u16ed\u0005\u009c\u0000\u0000\u16ed\u16ee\u0005\u021c\u0000\u0000\u16ee"+ + "\u16f1\u0005\u02e7\u0000\u0000\u16ef\u16f0\u0007M\u0000\u0000\u16f0\u16f2"+ + "\u0003\u0248\u0124\u0000\u16f1\u16ef\u0001\u0000\u0000\u0000\u16f1\u16f2"+ + "\u0001\u0000\u0000\u0000\u16f2\u16f4\u0001\u0000\u0000\u0000\u16f3\u16f5"+ + "\u0003\u01f0\u00f8\u0000\u16f4\u16f3\u0001\u0000\u0000\u0000\u16f4\u16f5"+ + "\u0001\u0000\u0000\u0000\u16f5\u1716\u0001\u0000\u0000\u0000\u16f6\u16f7"+ + "\u0005\u009c\u0000\u0000\u16f7\u16f8\u0005\u0235\u0000\u0000\u16f8\u16fd"+ + "\u0003\u01f6\u00fb\u0000\u16f9\u16fa\u0005\u0470\u0000\u0000\u16fa\u16fc"+ + "\u0003\u01f6\u00fb\u0000\u16fb\u16f9\u0001\u0000\u0000\u0000\u16fc\u16ff"+ + "\u0001\u0000\u0000\u0000\u16fd\u16fb\u0001\u0000\u0000\u0000\u16fd\u16fe"+ + "\u0001\u0000\u0000\u0000\u16fe\u1703\u0001\u0000\u0000\u0000\u16ff\u16fd"+ + "\u0001\u0000\u0000\u0000\u1700\u1701\u0005B\u0000\u0000\u1701\u1702\u0005"+ + "\u0238\u0000\u0000\u1702\u1704\u0003\u024e\u0127\u0000\u1703\u1700\u0001"+ + "\u0000\u0000\u0000\u1703\u1704\u0001\u0000\u0000\u0000\u1704\u1705\u0001"+ + "\u0000\u0000\u0000\u1705\u1709\u0005d\u0000\u0000\u1706\u1707\u0003\u024e"+ + "\u0127\u0000\u1707\u1708\u0005\u0470\u0000\u0000\u1708\u170a\u0001\u0000"+ + "\u0000\u0000\u1709\u1706\u0001\u0000\u0000\u0000\u1709\u170a\u0001\u0000"+ + "\u0000\u0000\u170a\u170b\u0001\u0000\u0000\u0000\u170b\u170c\u0003\u024e"+ + "\u0127\u0000\u170c\u1716\u0001\u0000\u0000\u0000\u170d\u170e\u0005\u009c"+ + "\u0000\u0000\u170e\u170f\u0005\u0267\u0000\u0000\u170f\u1713\u0005\u027b"+ + "\u0000\u0000\u1710\u1711\u0005B\u0000\u0000\u1711\u1712\u0005\u0164\u0000"+ + "\u0000\u1712\u1714\u0005\u047d\u0000\u0000\u1713\u1710\u0001\u0000\u0000"+ + "\u0000\u1713\u1714\u0001\u0000\u0000\u0000\u1714\u1716\u0001\u0000\u0000"+ + "\u0000\u1715\u167c\u0001\u0000\u0000\u0000\u1715\u167f\u0001\u0000\u0000"+ + "\u0000\u1715\u1693\u0001\u0000\u0000\u0000\u1715\u1698\u0001\u0000\u0000"+ + "\u0000\u1715\u16a6\u0001\u0000\u0000\u0000\u1715\u16ad\u0001\u0000\u0000"+ + "\u0000\u1715\u16b1\u0001\u0000\u0000\u0000\u1715\u16b5\u0001\u0000\u0000"+ + "\u0000\u1715\u16ba\u0001\u0000\u0000\u0000\u1715\u16bc\u0001\u0000\u0000"+ + "\u0000\u1715\u16c7\u0001\u0000\u0000\u0000\u1715\u16cd\u0001\u0000\u0000"+ + "\u0000\u1715\u16d6\u0001\u0000\u0000\u0000\u1715\u16da\u0001\u0000\u0000"+ + "\u0000\u1715\u16e0\u0001\u0000\u0000\u0000\u1715\u16ec\u0001\u0000\u0000"+ + "\u0000\u1715\u16f6\u0001\u0000\u0000\u0000\u1715\u170d\u0001\u0000\u0000"+ + "\u0000\u1716\u01eb\u0001\u0000\u0000\u0000\u1717\u1722\u0005\u0488\u0000"+ + "\u0000\u1718\u1722\u0005\u0489\u0000\u0000\u1719\u171a\u0005\u0472\u0000"+ + "\u0000\u171a\u171c\u0005\u0472\u0000\u0000\u171b\u1719\u0001\u0000\u0000"+ + "\u0000\u171b\u171c\u0001\u0000\u0000\u0000\u171c\u171d\u0001\u0000\u0000"+ + "\u0000\u171d\u171f\u0007S\u0000\u0000\u171e\u171b\u0001\u0000\u0000\u0000"+ + "\u171e\u171f\u0001\u0000\u0000\u0000\u171f\u1720\u0001\u0000\u0000\u0000"+ + "\u1720\u1722\u0003\u0248\u0124\u0000\u1721\u1717\u0001\u0000\u0000\u0000"+ + "\u1721\u1718\u0001\u0000\u0000\u0000\u1721\u171e\u0001\u0000\u0000\u0000"+ + "\u1722\u01ed\u0001\u0000\u0000\u0000\u1723\u1724\u0005\u001a\u0000\u0000"+ + "\u1724\u1731\u0005\u009a\u0000\u0000\u1725\u1731\u0005\u034d\u0000\u0000"+ + "\u1726\u1731\u0005)\u0000\u0000\u1727\u1731\u0005\u0098\u0000\u0000\u1728"+ + "\u1729\u0005\u01b6\u0000\u0000\u1729\u1731\u0005\u027b\u0000\u0000\u172a"+ + "\u172b\u0005\u0084\u0000\u0000\u172b\u1731\u0005\u027b\u0000\u0000\u172c"+ + "\u172e\u00077\u0000\u0000\u172d\u172c\u0001\u0000\u0000\u0000\u172d\u172e"+ + "\u0001\u0000\u0000\u0000\u172e\u172f\u0001\u0000\u0000\u0000\u172f\u1731"+ + "\u0007T\u0000\u0000\u1730\u1723\u0001\u0000\u0000\u0000\u1730\u1725\u0001"+ + "\u0000\u0000\u0000\u1730\u1726\u0001\u0000\u0000\u0000\u1730\u1727\u0001"+ + "\u0000\u0000\u0000\u1730\u1728\u0001\u0000\u0000\u0000\u1730\u172a\u0001"+ + "\u0000\u0000\u0000\u1730\u172d\u0001\u0000\u0000\u0000\u1731\u01ef\u0001"+ + "\u0000\u0000\u0000\u1732\u1733\u0005c\u0000\u0000\u1733\u1737\u0005\u047d"+ + "\u0000\u0000\u1734\u1735\u0005\u00bf\u0000\u0000\u1735\u1737\u0003\u02b0"+ + "\u0158\u0000\u1736\u1732\u0001\u0000\u0000\u0000\u1736\u1734\u0001\u0000"+ + "\u0000\u0000\u1737\u01f1\u0001\u0000\u0000\u0000\u1738\u173a\u0005\u027d"+ + "\u0000\u0000\u1739\u1738\u0001\u0000\u0000\u0000\u1739\u173a\u0001\u0000"+ + "\u0000\u0000\u173a\u173b\u0001\u0000\u0000\u0000\u173b\u174a\u0005\u019b"+ + "\u0000\u0000\u173c\u173d\u0005\u01de\u0000\u0000\u173d\u174a\u0005\u027b"+ + "\u0000\u0000\u173e\u174a\u0005\u022d\u0000\u0000\u173f\u174a\u0005\u02d6"+ + "\u0000\u0000\u1740\u1742\u0005\u01b5\u0000\u0000\u1741\u1740\u0001\u0000"+ + "\u0000\u0000\u1741\u1742\u0001\u0000\u0000\u0000\u1742\u1743\u0001\u0000"+ + "\u0000\u0000\u1743\u174a\u0005\u0234\u0000\u0000\u1744\u174a\u0005\u0236"+ + "\u0000\u0000\u1745\u1746\u0005\u0267\u0000\u0000\u1746\u174a\u0005\u01c0"+ + "\u0000\u0000\u1747\u174a\u0005\u0154\u0000\u0000\u1748\u174a\u0005\u0180"+ + "\u0000\u0000\u1749\u1739\u0001\u0000\u0000\u0000\u1749\u173c\u0001\u0000"+ + "\u0000\u0000\u1749\u173e\u0001\u0000\u0000\u0000\u1749\u173f\u0001\u0000"+ + "\u0000\u0000\u1749\u1741\u0001\u0000\u0000\u0000\u1749\u1744\u0001\u0000"+ + "\u0000\u0000\u1749\u1745\u0001\u0000\u0000\u0000\u1749\u1747\u0001\u0000"+ + "\u0000\u0000\u1749\u1748\u0001\u0000\u0000\u0000\u174a\u01f3\u0001\u0000"+ + "\u0000\u0000\u174b\u1754\u0005\u01a1\u0000\u0000\u174c\u174d\u0005\u00ad"+ + "\u0000\u0000\u174d\u1754\u0005\u027b\u0000\u0000\u174e\u1750\u0005\u01b5"+ + "\u0000\u0000\u174f\u174e\u0001\u0000\u0000\u0000\u174f\u1750\u0001\u0000"+ + "\u0000\u0000\u1750\u1751\u0001\u0000\u0000\u0000\u1751\u1754\u0005\u02e7"+ + "\u0000\u0000\u1752\u1754\u0005\u0290\u0000\u0000\u1753\u174b\u0001\u0000"+ + "\u0000\u0000\u1753\u174c\u0001\u0000\u0000\u0000\u1753\u174f\u0001\u0000"+ + "\u0000\u0000\u1753\u1752\u0001\u0000\u0000\u0000\u1754\u01f5\u0001\u0000"+ + "\u0000\u0000\u1755\u1762\u0005\u0007\u0000\u0000\u1756\u1757\u0005\u015c"+ + "\u0000\u0000\u1757\u1762\u0005\u01ce\u0000\u0000\u1758\u1759\u0005\u017f"+ + "\u0000\u0000\u1759\u1762\u0005\u0286\u0000\u0000\u175a\u1762\u0005\u0182"+ + "\u0000\u0000\u175b\u1762\u0005\u01d0\u0000\u0000\u175c\u1762\u0005\u0319"+ + "\u0000\u0000\u175d\u175e\u0005\u0221\u0000\u0000\u175e\u1762\u0005\u01ab"+ + "\u0000\u0000\u175f\u1762\u0005\u026e\u0000\u0000\u1760\u1762\u0005\u0285"+ + "\u0000\u0000\u1761\u1755\u0001\u0000\u0000\u0000\u1761\u1756\u0001\u0000"+ + "\u0000\u0000\u1761\u1758\u0001\u0000\u0000\u0000\u1761\u175a\u0001\u0000"+ + "\u0000\u0000\u1761\u175b\u0001\u0000\u0000\u0000\u1761\u175c\u0001\u0000"+ + "\u0000\u0000\u1761\u175d\u0001\u0000\u0000\u0000\u1761\u175f\u0001\u0000"+ + "\u0000\u0000\u1761\u1760\u0001\u0000\u0000\u0000\u1762\u01f7\u0001\u0000"+ + "\u0000\u0000\u1763\u1764\u0005\u015a\u0000\u0000\u1764\u1765\u0005\u047d"+ + "\u0000\u0000\u1765\u01f9\u0001\u0000\u0000\u0000\u1766\u1767\u0005\u0160"+ + "\u0000\u0000\u1767\u1768\u0005R\u0000\u0000\u1768\u176d\u0003\u0206\u0103"+ + "\u0000\u1769\u176a\u0005\u0470\u0000\u0000\u176a\u176c\u0003\u0206\u0103"+ + "\u0000\u176b\u1769\u0001\u0000\u0000\u0000\u176c\u176f\u0001\u0000\u0000"+ + "\u0000\u176d\u176b\u0001\u0000\u0000\u0000\u176d\u176e\u0001\u0000\u0000"+ + "\u0000\u176e\u1777\u0001\u0000\u0000\u0000\u176f\u176d\u0001\u0000\u0000"+ + "\u0000\u1770\u1771\u0005\u0082\u0000\u0000\u1771\u1774\u0005\u046e\u0000"+ + "\u0000\u1772\u1775\u0003\u0268\u0134\u0000\u1773\u1775\u0005\u0007\u0000"+ + "\u0000\u1774\u1772\u0001\u0000\u0000\u0000\u1774\u1773\u0001\u0000\u0000"+ + "\u0000\u1775\u1776\u0001\u0000\u0000\u0000\u1776\u1778\u0005\u046f\u0000"+ + "\u0000\u1777\u1770\u0001\u0000\u0000\u0000\u1777\u1778\u0001\u0000\u0000"+ + "\u0000\u1778\u1779\u0001\u0000\u0000\u0000\u1779\u177a\u0005Q\u0000\u0000"+ + "\u177a\u177b\u0003\u0248\u0124\u0000\u177b\u01fb\u0001\u0000\u0000\u0000"+ + "\u177c\u177e\u0005\u01b1\u0000\u0000\u177d\u177f\u0007H\u0000\u0000\u177e"+ + "\u177d\u0001\u0000\u0000\u0000\u177e\u177f\u0001\u0000\u0000\u0000\u177f"+ + "\u1780\u0001\u0000\u0000\u0000\u1780\u1785\u0003\u0208\u0104\u0000\u1781"+ + "\u1782\u0005\u0470\u0000\u0000\u1782\u1784\u0003\u0208\u0104\u0000\u1783"+ + "\u1781\u0001\u0000\u0000\u0000\u1784\u1787\u0001\u0000\u0000\u0000\u1785"+ + "\u1783\u0001\u0000\u0000\u0000\u1785\u1786\u0001\u0000\u0000\u0000\u1786"+ + "\u01fd\u0001\u0000\u0000\u0000\u1787\u1785\u0001\u0000\u0000\u0000\u1788"+ + "\u178a\u0005^\u0000\u0000\u1789\u178b\u0007U\u0000\u0000\u178a\u1789\u0001"+ + "\u0000\u0000\u0000\u178a\u178b\u0001\u0000\u0000\u0000\u178b\u178c\u0001"+ + "\u0000\u0000\u0000\u178c\u178d\u0003\u02b0\u0158\u0000\u178d\u01ff\u0001"+ + "\u0000\u0000\u0000\u178e\u178f\u0005g\u0000\u0000\u178f\u1790\u0005R\u0000"+ + "\u0000\u1790\u1791\u0005X\u0000\u0000\u1791\u1792\u0005\u0160\u0000\u0000"+ + "\u1792\u1797\u0003\u020c\u0106\u0000\u1793\u1794\u0005\u0470\u0000\u0000"+ + "\u1794\u1796\u0003\u020c\u0106\u0000\u1795\u1793\u0001\u0000\u0000\u0000"+ + "\u1796\u1799\u0001\u0000\u0000\u0000\u1797\u1795\u0001\u0000\u0000\u0000"+ + "\u1797\u1798\u0001\u0000\u0000\u0000\u1798\u0201\u0001\u0000\u0000\u0000"+ + "\u1799\u1797\u0001\u0000\u0000\u0000\u179a\u179b\u0005\u024e\u0000\u0000"+ + "\u179b\u179c\u0005\u0238\u0000\u0000\u179c\u179d\u0005\u0160\u0000\u0000"+ + "\u179d\u0203\u0001\u0000\u0000\u0000\u179e\u179f\u0005\u02e4\u0000\u0000"+ + "\u179f\u0205\u0001\u0000\u0000\u0000\u17a0\u17a8\u0003\u0228\u0114\u0000"+ + "\u17a1\u17a3\u0007\u0014\u0000\u0000\u17a2\u17a1\u0001\u0000\u0000\u0000"+ + "\u17a2\u17a3\u0001\u0000\u0000\u0000\u17a3\u17a4\u0001\u0000\u0000\u0000"+ + "\u17a4\u17a5\u0005\u046e\u0000\u0000\u17a5\u17a6\u0003\u0268\u0134\u0000"+ + "\u17a6\u17a7\u0005\u046f\u0000\u0000\u17a7\u17a9\u0001\u0000\u0000\u0000"+ + "\u17a8\u17a2\u0001\u0000\u0000\u0000\u17a8\u17a9\u0001\u0000\u0000\u0000"+ + "\u17a9\u0207\u0001\u0000\u0000\u0000\u17aa\u17bd\u0005\u018b\u0000\u0000"+ + "\u17ab\u17bd\u0005\u01c0\u0000\u0000\u17ac\u17ae\u0007V\u0000\u0000\u17ad"+ + "\u17ac\u0001\u0000\u0000\u0000\u17ad\u17ae\u0001\u0000\u0000\u0000\u17ae"+ + "\u17af\u0001\u0000\u0000\u0000\u17af\u17bd\u0005\u01dd\u0000\u0000\u17b0"+ + "\u17bd\u0005\u021d\u0000\u0000\u17b1\u17bd\u0005\u02d6\u0000\u0000\u17b2"+ + "\u17b3\u0005\u0238\u0000\u0000\u17b3\u17bd\u0005\u0160\u0000\u0000\u17b4"+ + "\u17bd\u0005\u027b\u0000\u0000\u17b5\u17bd\u0005\u029c\u0000\u0000\u17b6"+ + "\u17ba\u0005\u02e7\u0000\u0000\u17b7\u17b8\u0005\u00c1\u0000\u0000\u17b8"+ + "\u17b9\u0005\u0087\u0000\u0000\u17b9\u17bb\u0005h\u0000\u0000\u17ba\u17b7"+ + "\u0001\u0000\u0000\u0000\u17ba\u17bb\u0001\u0000\u0000\u0000\u17bb\u17bd"+ + "\u0001\u0000\u0000\u0000\u17bc\u17aa\u0001\u0000\u0000\u0000\u17bc\u17ab"+ + "\u0001\u0000\u0000\u0000\u17bc\u17ad\u0001\u0000\u0000\u0000\u17bc\u17b0"+ + "\u0001\u0000\u0000\u0000\u17bc\u17b1\u0001\u0000\u0000\u0000\u17bc\u17b2"+ + "\u0001\u0000\u0000\u0000\u17bc\u17b4\u0001\u0000\u0000\u0000\u17bc\u17b5"+ + "\u0001\u0000\u0000\u0000\u17bc\u17b6\u0001\u0000\u0000\u0000\u17bd\u17cb"+ + "\u0001\u0000\u0000\u0000\u17be\u17bf\u0005\u023f\u0000\u0000\u17bf\u17c1"+ + "\u0005\u01dd\u0000\u0000\u17c0\u17c2\u0003\u0164\u00b2\u0000\u17c1\u17c0"+ + "\u0001\u0000\u0000\u0000\u17c1\u17c2\u0001\u0000\u0000\u0000\u17c2\u17cb"+ + "\u0001\u0000\u0000\u0000\u17c3\u17c5\u00076\u0000\u0000\u17c4\u17c6\u0003"+ + "\u026c\u0136\u0000\u17c5\u17c4\u0001\u0000\u0000\u0000\u17c5\u17c6\u0001"+ + "\u0000\u0000\u0000\u17c6\u17c8\u0001\u0000\u0000\u0000\u17c7\u17c9\u0003"+ + "\u020a\u0105\u0000\u17c8\u17c7\u0001\u0000\u0000\u0000\u17c8\u17c9\u0001"+ + "\u0000\u0000\u0000\u17c9\u17cb\u0001\u0000\u0000\u0000\u17ca\u17bc\u0001"+ + "\u0000\u0000\u0000\u17ca\u17be\u0001\u0000\u0000\u0000\u17ca\u17c3\u0001"+ + "\u0000\u0000\u0000\u17cb\u0209\u0001\u0000\u0000\u0000\u17cc\u17cd\u0005"+ + "\u00c1\u0000\u0000\u17cd\u17ce\u0005\u0087\u0000\u0000\u17ce\u17d2\u0005"+ + "h\u0000\u0000\u17cf\u17d0\u0005B\u0000\u0000\u17d0\u17d2\u0005\u01a6\u0000"+ + "\u0000\u17d1\u17cc\u0001\u0000\u0000\u0000\u17d1\u17cf\u0001\u0000\u0000"+ + "\u0000\u17d2\u020b\u0001\u0000\u0000\u0000\u17d3\u17db\u0003\u0228\u0114"+ + "\u0000\u17d4\u17d5\u0005\u0082\u0000\u0000\u17d5\u17d8\u0005\u046e\u0000"+ + "\u0000\u17d6\u17d9\u0003\u0268\u0134\u0000\u17d7\u17d9\u0005\u0007\u0000"+ + "\u0000\u17d8\u17d6\u0001\u0000\u0000\u0000\u17d8\u17d7\u0001\u0000\u0000"+ + "\u0000\u17d9\u17da\u0001\u0000\u0000\u0000\u17da\u17dc\u0005\u046f\u0000"+ + "\u0000\u17db\u17d4\u0001\u0000\u0000\u0000\u17db\u17dc\u0001\u0000\u0000"+ + "\u0000\u17dc\u17e4\u0001\u0000\u0000\u0000\u17dd\u17df\u0007\u0014\u0000"+ + "\u0000\u17de\u17dd\u0001\u0000\u0000\u0000\u17de\u17df\u0001\u0000\u0000"+ + "\u0000\u17df\u17e0\u0001\u0000\u0000\u0000\u17e0\u17e1\u0005\u046e\u0000"+ + "\u0000\u17e1\u17e2\u0003\u0268\u0134\u0000\u17e2\u17e3\u0005\u046f\u0000"+ + "\u0000\u17e3\u17e5\u0001\u0000\u0000\u0000\u17e4\u17de\u0001\u0000\u0000"+ + "\u0000\u17e4\u17e5\u0001\u0000\u0000\u0000\u17e5\u17e8\u0001\u0000\u0000"+ + "\u0000\u17e6\u17e7\u0005O\u0000\u0000\u17e7\u17e9\u0005\u01d7\u0000\u0000"+ + "\u17e8\u17e6\u0001\u0000\u0000\u0000\u17e8\u17e9\u0001\u0000\u0000\u0000"+ + "\u17e9\u020d\u0001\u0000\u0000\u0000\u17ea\u17eb\u0007W\u0000\u0000\u17eb"+ + "\u17ee\u0003\u0228\u0114\u0000\u17ec\u17ef\u0003\u0248\u0124\u0000\u17ed"+ + "\u17ef\u0005\u047d\u0000\u0000\u17ee\u17ec\u0001\u0000\u0000\u0000\u17ee"+ + "\u17ed\u0001\u0000\u0000\u0000\u17ee\u17ef\u0001\u0000\u0000\u0000\u17ef"+ + "\u020f\u0001\u0000\u0000\u0000\u17f0\u17f4\u0007W\u0000\u0000\u17f1\u17f2"+ + "\u0007X\u0000\u0000\u17f2\u17f3\u0005\u0465\u0000\u0000\u17f3\u17f5\u0007"+ + "Y\u0000\u0000\u17f4\u17f1\u0001\u0000\u0000\u0000\u17f4\u17f5\u0001\u0000"+ + "\u0000\u0000\u17f5\u17f6\u0001\u0000\u0000\u0000\u17f6\u17f7\u0003\u0224"+ + "\u0112\u0000\u17f7\u0211\u0001\u0000\u0000\u0000\u17f8\u17f9\u0005\u01bd"+ + "\u0000\u0000\u17f9\u17fa\u0005\u047d\u0000\u0000\u17fa\u0213\u0001\u0000"+ + "\u0000\u0000\u17fb\u17fc\u0005\u00bb\u0000\u0000\u17fc\u17fd\u0003\u0248"+ + "\u0124\u0000\u17fd\u0215\u0001\u0000\u0000\u0000\u17fe\u1806\u0005\u009d"+ + "\u0000\u0000\u17ff\u1801\u0005\u00a3\u0000\u0000\u1800\u1802\u0005\u029e"+ + "\u0000\u0000\u1801\u1800\u0001\u0000\u0000\u0000\u1801\u1802\u0001\u0000"+ + "\u0000\u0000\u1802\u1803\u0001\u0000\u0000\u0000\u1803\u1807\u0003\u0252"+ + "\u0129\u0000\u1804\u1807\u0005\u0485\u0000\u0000\u1805\u1807\u0005\u0486"+ + "\u0000\u0000\u1806\u17ff\u0001\u0000\u0000\u0000\u1806\u1804\u0001\u0000"+ + "\u0000\u0000\u1806\u1805\u0001\u0000\u0000\u0000\u1807\u1811\u0001\u0000"+ + "\u0000\u0000\u1808\u1809\u0005\u009a\u0000\u0000\u1809\u180e\u0003\u021a"+ + "\u010d\u0000\u180a\u180b\u0005\u0470\u0000\u0000\u180b\u180d\u0003\u021a"+ + "\u010d\u0000\u180c\u180a\u0001\u0000\u0000\u0000\u180d\u1810\u0001\u0000"+ + "\u0000\u0000\u180e\u180c\u0001\u0000\u0000\u0000\u180e\u180f\u0001\u0000"+ + "\u0000\u0000\u180f\u1812\u0001\u0000\u0000\u0000\u1810\u180e\u0001\u0000"+ + "\u0000\u0000\u1811\u1808\u0001\u0000\u0000\u0000\u1811\u1812\u0001\u0000"+ + "\u0000\u0000\u1812\u0217\u0001\u0000\u0000\u0000\u1813\u181b\u0005\u0090"+ + "\u0000\u0000\u1814\u1816\u0005\u00a3\u0000\u0000\u1815\u1817\u0005\u029e"+ + "\u0000\u0000\u1816\u1815\u0001\u0000\u0000\u0000\u1816\u1817\u0001\u0000"+ + "\u0000\u0000\u1817\u1818\u0001\u0000\u0000\u0000\u1818\u181c\u0003\u0252"+ + "\u0129\u0000\u1819\u181c\u0005\u0485\u0000\u0000\u181a\u181c\u0005\u0486"+ + "\u0000\u0000\u181b\u1814\u0001\u0000\u0000\u0000\u181b\u1819\u0001\u0000"+ + "\u0000\u0000\u181b\u181a\u0001\u0000\u0000\u0000\u181b\u181c\u0001\u0000"+ + "\u0000\u0000\u181c\u1826\u0001\u0000\u0000\u0000\u181d\u181e\u0005\u009a"+ + "\u0000\u0000\u181e\u1823\u0003\u021a\u010d\u0000\u181f\u1820\u0005\u0470"+ + "\u0000\u0000\u1820\u1822\u0003\u021a\u010d\u0000\u1821\u181f\u0001\u0000"+ + "\u0000\u0000\u1822\u1825\u0001\u0000\u0000\u0000\u1823\u1821\u0001\u0000"+ + "\u0000\u0000\u1823\u1824\u0001\u0000\u0000\u0000\u1824\u1827\u0001\u0000"+ + "\u0000\u0000\u1825\u1823\u0001\u0000\u0000\u0000\u1826\u181d\u0001\u0000"+ + "\u0000\u0000\u1826\u1827\u0001\u0000\u0000\u0000\u1827\u0219\u0001\u0000"+ + "\u0000\u0000\u1828\u1829\u0007Z\u0000\u0000\u1829\u182e\u0005\u0465\u0000"+ + "\u0000\u182a\u182f\u0003\u0252\u0129\u0000\u182b\u182f\u0005\u047e\u0000"+ + "\u0000\u182c\u182f\u0003\u0236\u011b\u0000\u182d\u182f\u0003\u024a\u0125"+ + "\u0000\u182e\u182a\u0001\u0000\u0000\u0000\u182e\u182b\u0001\u0000\u0000"+ + "\u0000\u182e\u182c\u0001\u0000\u0000\u0000\u182e\u182d\u0001\u0000\u0000"+ + "\u0000\u182f\u021b\u0001\u0000\u0000\u0000\u1830\u1832\u0005\u00c1\u0000"+ + "\u0000\u1831\u1833\u0005\u023c\u0000\u0000\u1832\u1831\u0001\u0000\u0000"+ + "\u0000\u1832\u1833\u0001\u0000\u0000\u0000\u1833\u1834\u0001\u0000\u0000"+ + "\u0000\u1834\u1839\u00032\u0019\u0000\u1835\u1836\u0005\u0470\u0000\u0000"+ + "\u1836\u1838\u00032\u0019\u0000\u1837\u1835\u0001\u0000\u0000\u0000\u1838"+ + "\u183b\u0001\u0000\u0000\u0000\u1839\u1837\u0001\u0000\u0000\u0000\u1839"+ + "\u183a\u0001\u0000\u0000\u0000\u183a\u021d\u0001\u0000\u0000\u0000\u183b"+ + "\u1839\u0001\u0000\u0000\u0000\u183c\u183d\u0005\u00ad\u0000\u0000\u183d"+ + "\u183f\u0003\u0228\u0114\u0000\u183e\u1840\u0003\u00e6s\u0000\u183f\u183e"+ + "\u0001\u0000\u0000\u0000\u183f\u1840\u0001\u0000\u0000\u0000\u1840\u1842"+ + "\u0001\u0000\u0000\u0000\u1841\u1843\u0003\u0126\u0093\u0000\u1842\u1841"+ + "\u0001\u0000\u0000\u0000\u1842\u1843\u0001\u0000\u0000\u0000\u1843\u021f"+ + "\u0001\u0000\u0000\u0000\u1844\u1846\u0005H\u0000\u0000\u1845\u1847\u0007"+ + "[\u0000\u0000\u1846\u1845\u0001\u0000\u0000\u0000\u1846\u1847\u0001\u0000"+ + "\u0000\u0000\u1847\u1848\u0001\u0000\u0000\u0000\u1848\u1868\u00051\u0000"+ + "\u0000\u1849\u184a\u0003\u01ec\u00f6\u0000\u184a\u184b\u0005\u0465\u0000"+ + "\u0000\u184b\u1853\u0007\\\u0000\u0000\u184c\u184d\u0005\u0470\u0000\u0000"+ + "\u184d\u184e\u0003\u01ec\u00f6\u0000\u184e\u184f\u0005\u0465\u0000\u0000"+ + "\u184f\u1850\u0007\\\u0000\u0000\u1850\u1852\u0001\u0000\u0000\u0000\u1851"+ + "\u184c\u0001\u0000\u0000\u0000\u1852\u1855\u0001\u0000\u0000\u0000\u1853"+ + "\u1851\u0001\u0000\u0000\u0000\u1853\u1854\u0001\u0000\u0000\u0000\u1854"+ + "\u1869\u0001\u0000\u0000\u0000\u1855\u1853\u0001\u0000\u0000\u0000\u1856"+ + "\u1859\u0005\u001e\u0000\u0000\u1857\u185a\u0003\u024e\u0127\u0000\u1858"+ + "\u185a\u0003\u01ec\u00f6\u0000\u1859\u1857\u0001\u0000\u0000\u0000\u1859"+ + "\u1858\u0001\u0000\u0000\u0000\u185a\u185b\u0001\u0000\u0000\u0000\u185b"+ + "\u185c\u0003\u01ec\u00f6\u0000\u185c\u185d\u0005\u0465\u0000\u0000\u185d"+ + "\u1865\u0003\u0222\u0111\u0000\u185e\u185f\u0005\u0470\u0000\u0000\u185f"+ + "\u1860\u0003\u01ec\u00f6\u0000\u1860\u1861\u0005\u0465\u0000\u0000\u1861"+ + "\u1862\u0003\u0222\u0111\u0000\u1862\u1864\u0001\u0000\u0000\u0000\u1863"+ + "\u185e\u0001\u0000\u0000\u0000\u1864\u1867\u0001\u0000\u0000\u0000\u1865"+ + "\u1863\u0001\u0000\u0000\u0000\u1865\u1866\u0001\u0000\u0000\u0000\u1866"+ + "\u1869\u0001\u0000\u0000\u0000\u1867\u1865\u0001\u0000\u0000\u0000\u1868"+ + "\u1849\u0001\u0000\u0000\u0000\u1868\u1856\u0001\u0000\u0000\u0000\u1869"+ + "\u0221\u0001\u0000\u0000\u0000\u186a\u186b\u0007]\u0000\u0000\u186b\u0223"+ + "\u0001\u0000\u0000\u0000\u186c\u1872\u0003\u00c8d\u0000\u186d\u1872\u0003"+ + "\u00ba]\u0000\u186e\u1872\u0003\u00c0`\u0000\u186f\u1872\u0003\u00c6c"+ + "\u0000\u1870\u1872\u0003\u00cae\u0000\u1871\u186c\u0001\u0000\u0000\u0000"+ + "\u1871\u186d\u0001\u0000\u0000\u0000\u1871\u186e\u0001\u0000\u0000\u0000"+ + "\u1871\u186f\u0001\u0000\u0000\u0000\u1871\u1870\u0001\u0000\u0000\u0000"+ + "\u1872\u1877\u0001\u0000\u0000\u0000\u1873\u1874\u0005B\u0000\u0000\u1874"+ + "\u1875\u0005\u0179\u0000\u0000\u1875\u1877\u0003\u0248\u0124\u0000\u1876"+ + "\u1871\u0001\u0000\u0000\u0000\u1876\u1873\u0001\u0000\u0000\u0000\u1877"+ + "\u0225\u0001\u0000\u0000\u0000\u1878\u187c\u0003\u0248\u0124\u0000\u1879"+ + "\u187d\u0005\u0484\u0000\u0000\u187a\u187b\u0005\u046d\u0000\u0000\u187b"+ + "\u187d\u0003\u0248\u0124\u0000\u187c\u1879\u0001\u0000\u0000\u0000\u187c"+ + "\u187a\u0001\u0000\u0000\u0000\u187c\u187d\u0001\u0000\u0000\u0000\u187d"+ + "\u0227\u0001\u0000\u0000\u0000\u187e\u187f\u0003\u0226\u0113\u0000\u187f"+ + "\u0229\u0001\u0000\u0000\u0000\u1880\u1883\u0003\u0234\u011a\u0000\u1881"+ + "\u1883\u0003\u0248\u0124\u0000\u1882\u1880\u0001\u0000\u0000\u0000\u1882"+ + "\u1881\u0001\u0000\u0000\u0000\u1883\u022b\u0001\u0000\u0000\u0000\u1884"+ + "\u1889\u0003\u0248\u0124\u0000\u1885\u1887\u0003\u024c\u0126\u0000\u1886"+ + "\u1888\u0003\u024c\u0126\u0000\u1887\u1886\u0001\u0000\u0000\u0000\u1887"+ + "\u1888\u0001\u0000\u0000\u0000\u1888\u188a\u0001\u0000\u0000\u0000\u1889"+ + "\u1885\u0001\u0000\u0000\u0000\u1889\u188a\u0001\u0000\u0000\u0000\u188a"+ + "\u1893\u0001\u0000\u0000\u0000\u188b\u188d\t\u0000\u0000\u0000\u188c\u188b"+ + "\u0001\u0000\u0000\u0000\u188c\u188d\u0001\u0000\u0000\u0000\u188d\u188e"+ + "\u0001\u0000\u0000\u0000\u188e\u1890\u0003\u024c\u0126\u0000\u188f\u1891"+ + "\u0003\u024c\u0126\u0000\u1890\u188f\u0001\u0000\u0000\u0000\u1890\u1891"+ + "\u0001\u0000\u0000\u0000\u1891\u1893\u0001\u0000\u0000\u0000\u1892\u1884"+ + "\u0001\u0000\u0000\u0000\u1892\u188c\u0001\u0000\u0000\u0000\u1893\u022d"+ + "\u0001\u0000\u0000\u0000\u1894\u1897\u0003\u0248\u0124\u0000\u1895\u1897"+ + "\u0005\u047d\u0000\u0000\u1896\u1894\u0001\u0000\u0000\u0000\u1896\u1895"+ + "\u0001\u0000\u0000\u0000\u1897\u189c\u0001\u0000\u0000\u0000\u1898\u1899"+ + "\u0005\u046e\u0000\u0000\u1899\u189a\u0003\u024e\u0127\u0000\u189a\u189b"+ + "\u0005\u046f\u0000\u0000\u189b\u189d\u0001\u0000\u0000\u0000\u189c\u1898"+ + "\u0001\u0000\u0000\u0000\u189c\u189d\u0001\u0000\u0000\u0000\u189d\u18a0"+ + "\u0001\u0000\u0000\u0000\u189e\u18a0\u0003\u02b0\u0158\u0000\u189f\u1896"+ + "\u0001\u0000\u0000\u0000\u189f\u189e\u0001\u0000\u0000\u0000\u18a0\u18a2"+ + "\u0001\u0000\u0000\u0000\u18a1\u18a3\u00070\u0000\u0000\u18a2\u18a1\u0001"+ + "\u0000\u0000\u0000\u18a2\u18a3\u0001\u0000\u0000\u0000\u18a3\u022f\u0001"+ + "\u0000\u0000\u0000\u18a4\u18a9\u0005\u047d\u0000\u0000\u18a5\u18a9\u0005"+ + "\u0485\u0000\u0000\u18a6\u18a9\u0005\u02ba\u0000\u0000\u18a7\u18a9\u0003"+ + "\u02ce\u0167\u0000\u18a8\u18a4\u0001\u0000\u0000\u0000\u18a8\u18a5\u0001"+ + "\u0000\u0000\u0000\u18a8\u18a6\u0001\u0000\u0000\u0000\u18a8\u18a7\u0001"+ + "\u0000\u0000\u0000\u18a9\u0231\u0001\u0000\u0000\u0000\u18aa\u18ab\u0007"+ + "^\u0000\u0000\u18ab\u0233\u0001\u0000\u0000\u0000\u18ac\u18b2\u0003\u0230"+ + "\u0118\u0000\u18ad\u18ae\u0003\u0230\u0118\u0000\u18ae\u18af\u0003\u0232"+ + "\u0119\u0000\u18af\u18b2\u0001\u0000\u0000\u0000\u18b0\u18b2\u0003>\u001f"+ + "\u0000\u18b1\u18ac\u0001\u0000\u0000\u0000\u18b1\u18ad\u0001\u0000\u0000"+ + "\u0000\u18b1\u18b0\u0001\u0000\u0000\u0000\u18b2\u0235\u0001\u0000\u0000"+ + "\u0000\u18b3\u18b4\u0007_\u0000\u0000\u18b4\u0237\u0001\u0000\u0000\u0000"+ + "\u18b5\u18ba\u0005\u00e3\u0000\u0000\u18b6\u18ba\u0003\u02c4\u0162\u0000"+ + "\u18b7\u18ba\u0005\u047d\u0000\u0000\u18b8\u18ba\u0005\u047a\u0000\u0000"+ + "\u18b9\u18b5\u0001\u0000\u0000\u0000\u18b9\u18b6\u0001\u0000\u0000\u0000"+ + "\u18b9\u18b7\u0001\u0000\u0000\u0000\u18b9\u18b8\u0001\u0000\u0000\u0000"+ + "\u18ba\u0239\u0001\u0000\u0000\u0000\u18bb\u18be\u0003\u0248\u0124\u0000"+ + "\u18bc\u18be\u0005\u047d\u0000\u0000\u18bd\u18bb\u0001\u0000\u0000\u0000"+ + "\u18bd\u18bc\u0001\u0000\u0000\u0000\u18be\u023b\u0001\u0000\u0000\u0000"+ + "\u18bf\u18c3\u0003\u023e\u011f\u0000\u18c0\u18c3\u0005\u0485\u0000\u0000"+ + "\u18c1\u18c3\u0005\u047d\u0000\u0000\u18c2\u18bf\u0001\u0000\u0000\u0000"+ + "\u18c2\u18c0\u0001\u0000\u0000\u0000\u18c2\u18c1\u0001\u0000\u0000\u0000"+ + "\u18c3\u023d\u0001\u0000\u0000\u0000\u18c4\u18c5\u0007`\u0000\u0000\u18c5"+ + "\u023f\u0001\u0000\u0000\u0000\u18c6\u18c7\u0003\u024e\u0127\u0000\u18c7"+ + "\u18c8\u0005\u0462\u0000\u0000\u18c8\u18c9\u0003\u024e\u0127\u0000\u18c9"+ + "\u18ca\u0005\u0462\u0000\u0000\u18ca\u18cb\u0003\u024e\u0127\u0000\u18cb"+ + "\u18cc\u0005\u0462\u0000\u0000\u18cc\u18cd\u0003\u024e\u0127\u0000\u18cd"+ + "\u18ce\u0005\u0462\u0000\u0000\u18ce\u18d4\u0003\u024e\u0127\u0000\u18cf"+ + "\u18d0\u0005\u0479\u0000\u0000\u18d0\u18d1\u0003\u024e\u0127\u0000\u18d1"+ + "\u18d2\u0005\u0462\u0000\u0000\u18d2\u18d3\u0003\u024e\u0127\u0000\u18d3"+ + "\u18d5\u0001\u0000\u0000\u0000\u18d4\u18cf\u0001\u0000\u0000\u0000\u18d5"+ + "\u18d6\u0001\u0000\u0000\u0000\u18d6\u18d4\u0001\u0000\u0000\u0000\u18d6"+ + "\u18d7\u0001\u0000\u0000\u0000\u18d7\u0241\u0001\u0000\u0000\u0000\u18d8"+ + "\u18df\u0003\u0244\u0122\u0000\u18d9\u18da\u0005\u0470\u0000\u0000\u18da"+ + "\u18dd\u0003\u0244\u0122\u0000\u18db\u18dc\u0005\u0470\u0000\u0000\u18dc"+ + "\u18de\u0003\u024e\u0127\u0000\u18dd\u18db\u0001\u0000\u0000\u0000\u18dd"+ + "\u18de\u0001\u0000\u0000\u0000\u18de\u18e0\u0001\u0000\u0000\u0000\u18df"+ + "\u18d9\u0001\u0000\u0000\u0000\u18df\u18e0\u0001\u0000\u0000\u0000\u18e0"+ + "\u0243\u0001\u0000\u0000\u0000\u18e1\u18e9\u0005\u047d\u0000\u0000\u18e2"+ + "\u18e9\u0005\u0482\u0000\u0000\u18e3\u18e5\u0005\u047f\u0000\u0000\u18e4"+ + "\u18e3\u0001\u0000\u0000\u0000\u18e5\u18e6\u0001\u0000\u0000\u0000\u18e6"+ + "\u18e4\u0001\u0000\u0000\u0000\u18e6\u18e7\u0001\u0000\u0000\u0000\u18e7"+ + "\u18e9\u0001\u0000\u0000\u0000\u18e8\u18e1\u0001\u0000\u0000\u0000\u18e8"+ + "\u18e2\u0001\u0000\u0000\u0000\u18e8\u18e4\u0001\u0000\u0000\u0000\u18e9"+ + "\u0245\u0001\u0000\u0000\u0000\u18ea\u18ed\u0003\u0248\u0124\u0000\u18eb"+ + "\u18ed\u0005\u047d\u0000\u0000\u18ec\u18ea\u0001\u0000\u0000\u0000\u18ec"+ + "\u18eb\u0001\u0000\u0000\u0000\u18ed\u0247\u0001\u0000\u0000\u0000\u18ee"+ + "\u18f2\u0003\u024a\u0125\u0000\u18ef\u18f2\u0005\u047a\u0000\u0000\u18f0"+ + "\u18f2\u0005\u047d\u0000\u0000\u18f1\u18ee\u0001\u0000\u0000\u0000\u18f1"+ + "\u18ef\u0001\u0000\u0000\u0000\u18f1\u18f0\u0001\u0000\u0000\u0000\u18f2"+ + "\u0249\u0001\u0000\u0000\u0000\u18f3\u18fd\u0005\u0485\u0000\u0000\u18f4"+ + "\u18fd\u0003\u02c4\u0162\u0000\u18f5\u18fd\u0003\u02c6\u0163\u0000\u18f6"+ + "\u18fd\u0003\u023e\u011f\u0000\u18f7\u18fd\u0003\u02c8\u0164\u0000\u18f8"+ + "\u18fd\u0003\u02ca\u0165\u0000\u18f9\u18fd\u0003\u02cc\u0166\u0000\u18fa"+ + "\u18fd\u0003\u02ce\u0167\u0000\u18fb\u18fd\u0003\u02a8\u0154\u0000\u18fc"+ + "\u18f3\u0001\u0000\u0000\u0000\u18fc\u18f4\u0001\u0000\u0000\u0000\u18fc"+ + "\u18f5\u0001\u0000\u0000\u0000\u18fc\u18f6\u0001\u0000\u0000\u0000\u18fc"+ + "\u18f7\u0001\u0000\u0000\u0000\u18fc\u18f8\u0001\u0000\u0000\u0000\u18fc"+ + "\u18f9\u0001\u0000\u0000\u0000\u18fc\u18fa\u0001\u0000\u0000\u0000\u18fc"+ + "\u18fb\u0001\u0000\u0000\u0000\u18fd\u024b\u0001\u0000\u0000\u0000\u18fe"+ + "\u1902\u0005\u0484\u0000\u0000\u18ff\u1900\u0005\u046d\u0000\u0000\u1900"+ + "\u1902\u0003\u0248\u0124\u0000\u1901\u18fe\u0001\u0000\u0000\u0000\u1901"+ + "\u18ff\u0001\u0000\u0000\u0000\u1902\u024d\u0001\u0000\u0000\u0000\u1903"+ + "\u1904\u0007a\u0000\u0000\u1904\u024f\u0001\u0000\u0000\u0000\u1905\u1908"+ + "\u0005\u047b\u0000\u0000\u1906\u1908\u0003\u024e\u0127\u0000\u1907\u1905"+ + "\u0001\u0000\u0000\u0000\u1907\u1906\u0001\u0000\u0000\u0000\u1908\u0251"+ + "\u0001\u0000\u0000\u0000\u1909\u190b\u0005\u0483\u0000\u0000\u190a\u1909"+ + "\u0001\u0000\u0000\u0000\u190a\u190b\u0001\u0000\u0000\u0000\u190b\u190c"+ + "\u0001\u0000\u0000\u0000\u190c\u190f\u0005\u047d\u0000\u0000\u190d\u190f"+ + "\u0005\u047c\u0000\u0000\u190e\u190a\u0001\u0000\u0000\u0000\u190e\u190d"+ + "\u0001\u0000\u0000\u0000\u190f\u1911\u0001\u0000\u0000\u0000\u1910\u1912"+ + "\u0005\u047d\u0000\u0000\u1911\u1910\u0001\u0000\u0000\u0000\u1912\u1913"+ + "\u0001\u0000\u0000\u0000\u1913\u1911\u0001\u0000\u0000\u0000\u1913\u1914"+ + "\u0001\u0000\u0000\u0000\u1914\u1921\u0001\u0000\u0000\u0000\u1915\u1917"+ + "\u0005\u0483\u0000\u0000\u1916\u1915\u0001\u0000\u0000\u0000\u1916\u1917"+ + "\u0001\u0000\u0000\u0000\u1917\u1918\u0001\u0000\u0000\u0000\u1918\u191b"+ + "\u0005\u047d\u0000\u0000\u1919\u191b\u0005\u047c\u0000\u0000\u191a\u1916"+ + "\u0001\u0000\u0000\u0000\u191a\u1919\u0001\u0000\u0000\u0000\u191b\u191e"+ + "\u0001\u0000\u0000\u0000\u191c\u191d\u0005\u001c\u0000\u0000\u191d\u191f"+ + "\u0003\u023a\u011d\u0000\u191e\u191c\u0001\u0000\u0000\u0000\u191e\u191f"+ + "\u0001\u0000\u0000\u0000\u191f\u1921\u0001\u0000\u0000\u0000\u1920\u190e"+ + "\u0001\u0000\u0000\u0000\u1920\u191a\u0001\u0000\u0000\u0000\u1921\u0253"+ + "\u0001\u0000\u0000\u0000\u1922\u1923\u0007b\u0000\u0000\u1923\u0255\u0001"+ + "\u0000\u0000\u0000\u1924\u1926\u0005\u0483\u0000\u0000\u1925\u1924\u0001"+ + "\u0000\u0000\u0000\u1925\u1926\u0001\u0000\u0000\u0000\u1926\u1927\u0001"+ + "\u0000\u0000\u0000\u1927\u1928\u0005\u047f\u0000\u0000\u1928\u0257\u0001"+ + "\u0000\u0000\u0000\u1929\u192b\u0005s\u0000\u0000\u192a\u1929\u0001\u0000"+ + "\u0000\u0000\u192a\u192b\u0001\u0000\u0000\u0000\u192b\u192c\u0001\u0000"+ + "\u0000\u0000\u192c\u192d\u0007c\u0000\u0000\u192d\u0259\u0001\u0000\u0000"+ + "\u0000\u192e\u193b\u0003\u0252\u0129\u0000\u192f\u193b\u0003\u024e\u0127"+ + "\u0000\u1930\u1931\u0005\u0462\u0000\u0000\u1931\u193b\u0003\u024e\u0127"+ + "\u0000\u1932\u193b\u0003\u0256\u012b\u0000\u1933\u193b\u0003\u0254\u012a"+ + "\u0000\u1934\u193b\u0005\u0480\u0000\u0000\u1935\u193b\u0005\u0482\u0000"+ + "\u0000\u1936\u1938\u0005s\u0000\u0000\u1937\u1936\u0001\u0000\u0000\u0000"+ + "\u1937\u1938\u0001\u0000\u0000\u0000\u1938\u1939\u0001\u0000\u0000\u0000"+ + "\u1939\u193b\u0007c\u0000\u0000\u193a\u192e\u0001\u0000\u0000\u0000\u193a"+ + "\u192f\u0001\u0000\u0000\u0000\u193a\u1930\u0001\u0000\u0000\u0000\u193a"+ + "\u1932\u0001\u0000\u0000\u0000\u193a\u1933\u0001\u0000\u0000\u0000\u193a"+ + "\u1934\u0001\u0000\u0000\u0000\u193a\u1935\u0001\u0000\u0000\u0000\u193a"+ + "\u1937\u0001\u0000\u0000\u0000\u193b\u025b\u0001\u0000\u0000\u0000\u193c"+ + "\u193e\u0007d\u0000\u0000\u193d\u193f\u0005\u00ef\u0000\u0000\u193e\u193d"+ + "\u0001\u0000\u0000\u0000\u193e\u193f\u0001\u0000\u0000\u0000\u193f\u1941"+ + "\u0001\u0000\u0000\u0000\u1940\u1942\u0003\u0262\u0131\u0000\u1941\u1940"+ + "\u0001\u0000\u0000\u0000\u1941\u1942\u0001\u0000\u0000\u0000\u1942\u1944"+ + "\u0001\u0000\u0000\u0000\u1943\u1945\u0005\u00e3\u0000\u0000\u1944\u1943"+ + "\u0001\u0000\u0000\u0000\u1944\u1945\u0001\u0000\u0000\u0000\u1945\u1949"+ + "\u0001\u0000\u0000\u0000\u1946\u1947\u0003<\u001e\u0000\u1947\u1948\u0003"+ + "\u0238\u011c\u0000\u1948\u194a\u0001\u0000\u0000\u0000\u1949\u1946\u0001"+ + "\u0000\u0000\u0000\u1949\u194a\u0001\u0000\u0000\u0000\u194a\u194e\u0001"+ + "\u0000\u0000\u0000\u194b\u194c\u0005\u001c\u0000\u0000\u194c\u194f\u0003"+ + "\u023a\u011d\u0000\u194d\u194f\u0005\u00e3\u0000\u0000\u194e\u194b\u0001"+ + "\u0000\u0000\u0000\u194e\u194d\u0001\u0000\u0000\u0000\u194e\u194f\u0001"+ + "\u0000\u0000\u0000\u194f\u19bb\u0001\u0000\u0000\u0000\u1950\u1951\u0005"+ + "\u00e2\u0000\u0000\u1951\u1952\u0007e\u0000\u0000\u1952\u1954\u0005\u00ef"+ + "\u0000\u0000\u1953\u1955\u0003\u0262\u0131\u0000\u1954\u1953\u0001\u0000"+ + "\u0000\u0000\u1954\u1955\u0001\u0000\u0000\u0000\u1955\u1957\u0001\u0000"+ + "\u0000\u0000\u1956\u1958\u0005\u00e3\u0000\u0000\u1957\u1956\u0001\u0000"+ + "\u0000\u0000\u1957\u1958\u0001\u0000\u0000\u0000\u1958\u19bb\u0001\u0000"+ + "\u0000\u0000\u1959\u195a\u0005\u00e2\u0000\u0000\u195a\u195c\u0007f\u0000"+ + "\u0000\u195b\u195d\u0003\u0262\u0131\u0000\u195c\u195b\u0001\u0000\u0000"+ + "\u0000\u195c\u195d\u0001\u0000\u0000\u0000\u195d\u195f\u0001\u0000\u0000"+ + "\u0000\u195e\u1960\u0005\u00e3\u0000\u0000\u195f\u195e\u0001\u0000\u0000"+ + "\u0000\u195f\u1960\u0001\u0000\u0000\u0000\u1960\u19bb\u0001\u0000\u0000"+ + "\u0000\u1961\u1962\u0005\u0207\u0000\u0000\u1962\u1964\u0005\u00e0\u0000"+ + "\u0000\u1963\u1965\u0003\u0262\u0131\u0000\u1964\u1963\u0001\u0000\u0000"+ + "\u0000\u1964\u1965\u0001\u0000\u0000\u0000\u1965\u1967\u0001\u0000\u0000"+ + "\u0000\u1966\u1968\u0005\u00e3\u0000\u0000\u1967\u1966\u0001\u0000\u0000"+ + "\u0000\u1967\u1968\u0001\u0000\u0000\u0000\u1968\u19bb\u0001\u0000\u0000"+ + "\u0000\u1969\u196b\u0007g\u0000\u0000\u196a\u196c\u0003\u0262\u0131\u0000"+ + "\u196b\u196a\u0001\u0000\u0000\u0000\u196b\u196c\u0001\u0000\u0000\u0000"+ + "\u196c\u1970\u0001\u0000\u0000\u0000\u196d\u196f\u0007h\u0000\u0000\u196e"+ + "\u196d\u0001\u0000\u0000\u0000\u196f\u1972\u0001\u0000\u0000\u0000\u1970"+ + "\u196e\u0001\u0000\u0000\u0000\u1970\u1971\u0001\u0000\u0000\u0000\u1971"+ + "\u19bb\u0001\u0000\u0000\u0000\u1972\u1970\u0001\u0000\u0000\u0000\u1973"+ + "\u1975\u0005\u00d1\u0000\u0000\u1974\u1976\u0003\u0264\u0132\u0000\u1975"+ + "\u1974\u0001\u0000\u0000\u0000\u1975\u1976\u0001\u0000\u0000\u0000\u1976"+ + "\u197a\u0001\u0000\u0000\u0000\u1977\u1979\u0007h\u0000\u0000\u1978\u1977"+ + "\u0001\u0000\u0000\u0000\u1979\u197c\u0001\u0000\u0000\u0000\u197a\u1978"+ + "\u0001\u0000\u0000\u0000\u197a\u197b\u0001\u0000\u0000\u0000\u197b\u19bb"+ + "\u0001\u0000\u0000\u0000\u197c\u197a\u0001\u0000\u0000\u0000\u197d\u197f"+ + "\u0005\u00d2\u0000\u0000\u197e\u1980\u0005\u00d3\u0000\u0000\u197f\u197e"+ + "\u0001\u0000\u0000\u0000\u197f\u1980\u0001\u0000\u0000\u0000\u1980\u1982"+ + "\u0001\u0000\u0000\u0000\u1981\u1983\u0003\u0264\u0132\u0000\u1982\u1981"+ + "\u0001\u0000\u0000\u0000\u1982\u1983\u0001\u0000\u0000\u0000\u1983\u1987"+ + "\u0001\u0000\u0000\u0000\u1984\u1986\u0007h\u0000\u0000\u1985\u1984\u0001"+ + "\u0000\u0000\u0000\u1986\u1989\u0001\u0000\u0000\u0000\u1987\u1985\u0001"+ + "\u0000\u0000\u0000\u1987\u1988\u0001\u0000\u0000\u0000\u1988\u19bb\u0001"+ + "\u0000\u0000\u0000\u1989\u1987\u0001\u0000\u0000\u0000\u198a\u198c\u0007"+ + "i\u0000\u0000\u198b\u198d\u0003\u0266\u0133\u0000\u198c\u198b\u0001\u0000"+ + "\u0000\u0000\u198c\u198d\u0001\u0000\u0000\u0000\u198d\u1991\u0001\u0000"+ + "\u0000\u0000\u198e\u1990\u0007h\u0000\u0000\u198f\u198e\u0001\u0000\u0000"+ + "\u0000\u1990\u1993\u0001\u0000\u0000\u0000\u1991\u198f\u0001\u0000\u0000"+ + "\u0000\u1991\u1992\u0001\u0000\u0000\u0000\u1992\u19bb\u0001\u0000\u0000"+ + "\u0000\u1993\u1991\u0001\u0000\u0000\u0000\u1994\u19bb\u0007j\u0000\u0000"+ + "\u1995\u1997\u0007k\u0000\u0000\u1996\u1998\u0003\u0262\u0131\u0000\u1997"+ + "\u1996\u0001\u0000\u0000\u0000\u1997\u1998\u0001\u0000\u0000\u0000\u1998"+ + "\u19bb\u0001\u0000\u0000\u0000\u1999\u199a\u0007l\u0000\u0000\u199a\u199c"+ + "\u0003\u025e\u012f\u0000\u199b\u199d\u0005\u00e3\u0000\u0000\u199c\u199b"+ + "\u0001\u0000\u0000\u0000\u199c\u199d\u0001\u0000\u0000\u0000\u199d\u19a1"+ + "\u0001\u0000\u0000\u0000\u199e\u199f\u0003<\u001e\u0000\u199f\u19a0\u0003"+ + "\u0238\u011c\u0000\u19a0\u19a2\u0001\u0000\u0000\u0000\u19a1\u199e\u0001"+ + "\u0000\u0000\u0000\u19a1\u19a2\u0001\u0000\u0000\u0000\u19a2\u19bb\u0001"+ + "\u0000\u0000\u0000\u19a3\u19a6\u0007m\u0000\u0000\u19a4\u19a5\u0005\u03f5"+ + "\u0000\u0000\u19a5\u19a7\u0003\u024e\u0127\u0000\u19a6\u19a4\u0001\u0000"+ + "\u0000\u0000\u19a6\u19a7\u0001\u0000\u0000\u0000\u19a7\u19bb\u0001\u0000"+ + "\u0000\u0000\u19a8\u19aa\u0005\u00e8\u0000\u0000\u19a9\u19ab\u0005\u00e0"+ + "\u0000\u0000\u19aa\u19a9\u0001\u0000\u0000\u0000\u19aa\u19ab\u0001\u0000"+ + "\u0000\u0000\u19ab\u19ad\u0001\u0000\u0000\u0000\u19ac\u19ae\u0005\u00e3"+ + "\u0000\u0000\u19ad\u19ac\u0001\u0000\u0000\u0000\u19ad\u19ae\u0001\u0000"+ + "\u0000\u0000\u19ae\u19b2\u0001\u0000\u0000\u0000\u19af\u19b0\u0003<\u001e"+ + "\u0000\u19b0\u19b1\u0003\u0238\u011c\u0000\u19b1\u19b3\u0001\u0000\u0000"+ + "\u0000\u19b2\u19af\u0001\u0000\u0000\u0000\u19b2\u19b3\u0001\u0000\u0000"+ + "\u0000\u19b3\u19b6\u0001\u0000\u0000\u0000\u19b4\u19b5\u0005\u001c\u0000"+ + "\u0000\u19b5\u19b7\u0003\u023a\u011d\u0000\u19b6\u19b4\u0001\u0000\u0000"+ + "\u0000\u19b6\u19b7\u0001\u0000\u0000\u0000\u19b7\u19bb\u0001\u0000\u0000"+ + "\u0000\u19b8\u19b9\u0005\u00e8\u0000\u0000\u19b9\u19bb\u0005\u00e4\u0000"+ + "\u0000\u19ba\u193c\u0001\u0000\u0000\u0000\u19ba\u1950\u0001\u0000\u0000"+ + "\u0000\u19ba\u1959\u0001\u0000\u0000\u0000\u19ba\u1961\u0001\u0000\u0000"+ + "\u0000\u19ba\u1969\u0001\u0000\u0000\u0000\u19ba\u1973\u0001\u0000\u0000"+ + "\u0000\u19ba\u197d\u0001\u0000\u0000\u0000\u19ba\u198a\u0001\u0000\u0000"+ + "\u0000\u19ba\u1994\u0001\u0000\u0000\u0000\u19ba\u1995\u0001\u0000\u0000"+ + "\u0000\u19ba\u1999\u0001\u0000\u0000\u0000\u19ba\u19a3\u0001\u0000\u0000"+ + "\u0000\u19ba\u19a8\u0001\u0000\u0000\u0000\u19ba\u19b8\u0001\u0000\u0000"+ + "\u0000\u19bb\u025d\u0001\u0000\u0000\u0000\u19bc\u19bd\u0005\u046e\u0000"+ + "\u0000\u19bd\u19c2\u0005\u047d\u0000\u0000\u19be\u19bf\u0005\u0470\u0000"+ + "\u0000\u19bf\u19c1\u0005\u047d\u0000\u0000\u19c0\u19be\u0001\u0000\u0000"+ + "\u0000\u19c1\u19c4\u0001\u0000\u0000\u0000\u19c2\u19c0\u0001\u0000\u0000"+ + "\u0000\u19c2\u19c3\u0001\u0000\u0000\u0000\u19c3\u19c5\u0001\u0000\u0000"+ + "\u0000\u19c4\u19c2\u0001\u0000\u0000\u0000\u19c5\u19c6\u0005\u046f\u0000"+ + "\u0000\u19c6\u025f\u0001\u0000\u0000\u0000\u19c7\u19c9\u0007n\u0000\u0000"+ + "\u19c8\u19ca\u0003\u0262\u0131\u0000\u19c9\u19c8\u0001\u0000\u0000\u0000"+ + "\u19c9\u19ca\u0001\u0000\u0000\u0000\u19ca\u19de\u0001\u0000\u0000\u0000"+ + "\u19cb\u19cd\u0005\u00df\u0000\u0000\u19cc\u19ce\u0003\u0262\u0131\u0000"+ + "\u19cd\u19cc\u0001\u0000\u0000\u0000\u19cd\u19ce\u0001\u0000\u0000\u0000"+ + "\u19ce\u19d2\u0001\u0000\u0000\u0000\u19cf\u19d0\u0003<\u001e\u0000\u19d0"+ + "\u19d1\u0003\u0238\u011c\u0000\u19d1\u19d3\u0001\u0000\u0000\u0000\u19d2"+ + "\u19cf\u0001\u0000\u0000\u0000\u19d2\u19d3\u0001\u0000\u0000\u0000\u19d3"+ + "\u19de\u0001\u0000\u0000\u0000\u19d4\u19de\u0007o\u0000\u0000\u19d5\u19d7"+ + "\u0007p\u0000\u0000\u19d6\u19d8\u0003\u0266\u0133\u0000\u19d7\u19d6\u0001"+ + "\u0000\u0000\u0000\u19d7\u19d8\u0001\u0000\u0000\u0000\u19d8\u19de\u0001"+ + "\u0000\u0000\u0000\u19d9\u19db\u0007q\u0000\u0000\u19da\u19dc\u0007r\u0000"+ + "\u0000\u19db\u19da\u0001\u0000\u0000\u0000\u19db\u19dc\u0001\u0000\u0000"+ + "\u0000\u19dc\u19de\u0001\u0000\u0000\u0000\u19dd\u19c7\u0001\u0000\u0000"+ + "\u0000\u19dd\u19cb\u0001\u0000\u0000\u0000\u19dd\u19d4\u0001\u0000\u0000"+ + "\u0000\u19dd\u19d5\u0001\u0000\u0000\u0000\u19dd\u19d9\u0001\u0000\u0000"+ + "\u0000\u19de\u19e0\u0001\u0000\u0000\u0000\u19df\u19e1\u0005\f\u0000\u0000"+ + "\u19e0\u19df\u0001\u0000\u0000\u0000\u19e0\u19e1\u0001\u0000\u0000\u0000"+ + "\u19e1\u0261\u0001\u0000\u0000\u0000\u19e2\u19e3\u0005\u046e\u0000\u0000"+ + "\u19e3\u19e4\u0003\u024e\u0127\u0000\u19e4\u19e5\u0005\u046f\u0000\u0000"+ + "\u19e5\u0263\u0001\u0000\u0000\u0000\u19e6\u19e7\u0005\u046e\u0000\u0000"+ + "\u19e7\u19e8\u0003\u024e\u0127\u0000\u19e8\u19e9\u0005\u0470\u0000\u0000"+ + "\u19e9\u19ea\u0003\u024e\u0127\u0000\u19ea\u19eb\u0005\u046f\u0000\u0000"+ + "\u19eb\u0265\u0001\u0000\u0000\u0000\u19ec\u19ed\u0005\u046e\u0000\u0000"+ + "\u19ed\u19f0\u0003\u024e\u0127\u0000\u19ee\u19ef\u0005\u0470\u0000\u0000"+ + "\u19ef\u19f1\u0003\u024e\u0127\u0000\u19f0\u19ee\u0001\u0000\u0000\u0000"+ + "\u19f0\u19f1\u0001\u0000\u0000\u0000\u19f1\u19f2\u0001\u0000\u0000\u0000"+ + "\u19f2\u19f3\u0005\u046f\u0000\u0000\u19f3\u0267\u0001\u0000\u0000\u0000"+ + "\u19f4\u19f9\u0003\u0248\u0124\u0000\u19f5\u19f6\u0005\u0470\u0000\u0000"+ + "\u19f6\u19f8\u0003\u0248\u0124\u0000\u19f7\u19f5\u0001\u0000\u0000\u0000"+ + "\u19f8\u19fb\u0001\u0000\u0000\u0000\u19f9\u19f7\u0001\u0000\u0000\u0000"+ + "\u19f9\u19fa\u0001\u0000\u0000\u0000\u19fa\u0269\u0001\u0000\u0000\u0000"+ + "\u19fb\u19f9\u0001\u0000\u0000\u0000\u19fc\u1a01\u0003\u022c\u0116\u0000"+ + "\u19fd\u19fe\u0005\u0470\u0000\u0000\u19fe\u1a00\u0003\u022c\u0116\u0000"+ + "\u19ff\u19fd\u0001\u0000\u0000\u0000\u1a00\u1a03\u0001\u0000\u0000\u0000"+ + "\u1a01\u19ff\u0001\u0000\u0000\u0000\u1a01\u1a02\u0001\u0000\u0000\u0000"+ + "\u1a02\u026b\u0001\u0000\u0000\u0000\u1a03\u1a01\u0001\u0000\u0000\u0000"+ + "\u1a04\u1a09\u0003\u0228\u0114\u0000\u1a05\u1a06\u0005\u0470\u0000\u0000"+ + "\u1a06\u1a08\u0003\u0228\u0114\u0000\u1a07\u1a05\u0001\u0000\u0000\u0000"+ + "\u1a08\u1a0b\u0001\u0000\u0000\u0000\u1a09\u1a07\u0001\u0000\u0000\u0000"+ + "\u1a09\u1a0a\u0001\u0000\u0000\u0000\u1a0a\u026d\u0001\u0000\u0000\u0000"+ + "\u1a0b\u1a09\u0001\u0000\u0000\u0000\u1a0c\u1a0d\u0005\u046e\u0000\u0000"+ + "\u1a0d\u1a12\u0003\u022e\u0117\u0000\u1a0e\u1a0f\u0005\u0470\u0000\u0000"+ + "\u1a0f\u1a11\u0003\u022e\u0117\u0000\u1a10\u1a0e\u0001\u0000\u0000\u0000"+ + "\u1a11\u1a14\u0001\u0000\u0000\u0000\u1a12\u1a10\u0001\u0000\u0000\u0000"+ + "\u1a12\u1a13\u0001\u0000\u0000\u0000\u1a13\u1a15\u0001\u0000\u0000\u0000"+ + "\u1a14\u1a12\u0001\u0000\u0000\u0000\u1a15\u1a16\u0005\u046f\u0000\u0000"+ + "\u1a16\u026f\u0001\u0000\u0000\u0000\u1a17\u1a1c\u0003\u02b0\u0158\u0000"+ + "\u1a18\u1a19\u0005\u0470\u0000\u0000\u1a19\u1a1b\u0003\u02b0\u0158\u0000"+ + "\u1a1a\u1a18\u0001\u0000\u0000\u0000\u1a1b\u1a1e\u0001\u0000\u0000\u0000"+ + "\u1a1c\u1a1a\u0001\u0000\u0000\u0000\u1a1c\u1a1d\u0001\u0000\u0000\u0000"+ + "\u1a1d\u0271\u0001\u0000\u0000\u0000\u1a1e\u1a1c\u0001\u0000\u0000\u0000"+ + "\u1a1f\u1a24\u0003\u027e\u013f\u0000\u1a20\u1a21\u0005\u0470\u0000\u0000"+ + "\u1a21\u1a23\u0003\u027e\u013f\u0000\u1a22\u1a20\u0001\u0000\u0000\u0000"+ + "\u1a23\u1a26\u0001\u0000\u0000\u0000\u1a24\u1a22\u0001\u0000\u0000\u0000"+ + "\u1a24\u1a25\u0001\u0000\u0000\u0000\u1a25\u0273\u0001\u0000\u0000\u0000"+ + "\u1a26\u1a24\u0001\u0000\u0000\u0000\u1a27\u1a2c\u0003\u025a\u012d\u0000"+ + "\u1a28\u1a29\u0005\u0470\u0000\u0000\u1a29\u1a2b\u0003\u025a\u012d\u0000"+ + "\u1a2a\u1a28\u0001\u0000\u0000\u0000\u1a2b\u1a2e\u0001\u0000\u0000\u0000"+ + "\u1a2c\u1a2a\u0001\u0000\u0000\u0000\u1a2c\u1a2d\u0001\u0000\u0000\u0000"+ + "\u1a2d\u0275\u0001\u0000\u0000\u0000\u1a2e\u1a2c\u0001\u0000\u0000\u0000"+ + "\u1a2f\u1a34\u0005\u047d\u0000\u0000\u1a30\u1a31\u0005\u0470\u0000\u0000"+ + "\u1a31\u1a33\u0005\u047d\u0000\u0000\u1a32\u1a30\u0001\u0000\u0000\u0000"+ + "\u1a33\u1a36\u0001\u0000\u0000\u0000\u1a34\u1a32\u0001\u0000\u0000\u0000"+ + "\u1a34\u1a35\u0001\u0000\u0000\u0000\u1a35\u0277\u0001\u0000\u0000\u0000"+ + "\u1a36\u1a34\u0001\u0000\u0000\u0000\u1a37\u1a3c\u0005\u0488\u0000\u0000"+ + "\u1a38\u1a39\u0005\u0470\u0000\u0000\u1a39\u1a3b\u0005\u0488\u0000\u0000"+ + "\u1a3a\u1a38\u0001\u0000\u0000\u0000\u1a3b\u1a3e\u0001\u0000\u0000\u0000"+ + "\u1a3c\u1a3a\u0001\u0000\u0000\u0000\u1a3c\u1a3d\u0001\u0000\u0000\u0000"+ + "\u1a3d\u0279\u0001\u0000\u0000\u0000\u1a3e\u1a3c\u0001\u0000\u0000\u0000"+ + "\u1a3f\u1a5a\u0005u\u0000\u0000\u1a40\u1a41\u0005\u0018\u0000\u0000\u1a41"+ + "\u1a42\u0005\u046e\u0000\u0000\u1a42\u1a43\u0003\u02b0\u0158\u0000\u1a43"+ + "\u1a44\u0005\r\u0000\u0000\u1a44\u1a45\u0003\u0260\u0130\u0000\u1a45\u1a46"+ + "\u0005\u046f\u0000\u0000\u1a46\u1a5a\u0001\u0000\u0000\u0000\u1a47\u1a49"+ + "\u0003\u02b6\u015b\u0000\u1a48\u1a47\u0001\u0000\u0000\u0000\u1a48\u1a49"+ + "\u0001\u0000\u0000\u0000\u1a49\u1a4a\u0001\u0000\u0000\u0000\u1a4a\u1a5a"+ + "\u0003\u025a\u012d\u0000\u1a4b\u1a4f\u0003\u027c\u013e\u0000\u1a4c\u1a4d"+ + "\u0005w\u0000\u0000\u1a4d\u1a4e\u0005\u00b9\u0000\u0000\u1a4e\u1a50\u0003"+ + "\u027c\u013e\u0000\u1a4f\u1a4c\u0001\u0000\u0000\u0000\u1a4f\u1a50\u0001"+ + "\u0000\u0000\u0000\u1a50\u1a5a\u0001\u0000\u0000\u0000\u1a51\u1a52\u0005"+ + "\u046e\u0000\u0000\u1a52\u1a53\u0003\u02b0\u0158\u0000\u1a53\u1a54\u0005"+ + "\u046f\u0000\u0000\u1a54\u1a5a\u0001\u0000\u0000\u0000\u1a55\u1a56\u0005"+ + "\u046e\u0000\u0000\u1a56\u1a57\u0003\u0226\u0113\u0000\u1a57\u1a58\u0005"+ + "\u046f\u0000\u0000\u1a58\u1a5a\u0001\u0000\u0000\u0000\u1a59\u1a3f\u0001"+ + "\u0000\u0000\u0000\u1a59\u1a40\u0001\u0000\u0000\u0000\u1a59\u1a48\u0001"+ + "\u0000\u0000\u0000\u1a59\u1a4b\u0001\u0000\u0000\u0000\u1a59\u1a51\u0001"+ + "\u0000\u0000\u0000\u1a59\u1a55\u0001\u0000\u0000\u0000\u1a5a\u027b\u0001"+ + "\u0000\u0000\u0000\u1a5b\u1a61\u0007s\u0000\u0000\u1a5c\u1a5e\u0005\u046e"+ + "\u0000\u0000\u1a5d\u1a5f\u0003\u024e\u0127\u0000\u1a5e\u1a5d\u0001\u0000"+ + "\u0000\u0000\u1a5e\u1a5f\u0001\u0000\u0000\u0000\u1a5f\u1a60\u0001\u0000"+ + "\u0000\u0000\u1a60\u1a62\u0005\u046f\u0000\u0000\u1a61\u1a5c\u0001\u0000"+ + "\u0000\u0000\u1a61\u1a62\u0001\u0000\u0000\u0000\u1a62\u1a6a\u0001\u0000"+ + "\u0000\u0000\u1a63\u1a64\u0005\u0144\u0000\u0000\u1a64\u1a66\u0005\u046e"+ + "\u0000\u0000\u1a65\u1a67\u0003\u024e\u0127\u0000\u1a66\u1a65\u0001\u0000"+ + "\u0000\u0000\u1a66\u1a67\u0001\u0000\u0000\u0000\u1a67\u1a68\u0001\u0000"+ + "\u0000\u0000\u1a68\u1a6a\u0005\u046f\u0000\u0000\u1a69\u1a5b\u0001\u0000"+ + "\u0000\u0000\u1a69\u1a63\u0001\u0000\u0000\u0000\u1a6a\u027d\u0001\u0000"+ + "\u0000\u0000\u1a6b\u1a6e\u0003\u02b0\u0158\u0000\u1a6c\u1a6e\u0005+\u0000"+ + "\u0000\u1a6d\u1a6b\u0001\u0000\u0000\u0000\u1a6d\u1a6c\u0001\u0000\u0000"+ + "\u0000\u1a6e\u027f\u0001\u0000\u0000\u0000\u1a6f\u1a70\u0005N\u0000\u0000"+ + "\u1a70\u1a71\u0005=\u0000\u0000\u1a71\u0281\u0001\u0000\u0000\u0000\u1a72"+ + "\u1a73\u0005N\u0000\u0000\u1a73\u1a74\u0005s\u0000\u0000\u1a74\u1a75\u0005"+ + "=\u0000\u0000\u1a75\u0283\u0001\u0000\u0000\u0000\u1a76\u1a77\u0005|\u0000"+ + "\u0000\u1a77\u1a78\u0005\u008e\u0000\u0000\u1a78\u0285\u0001\u0000\u0000"+ + "\u0000\u1a79\u1a7a\u0005\u02a3\u0000\u0000\u1a7a\u1a7d\u0003\u024e\u0127"+ + "\u0000\u1a7b\u1a7d\u0005\u0210\u0000\u0000\u1a7c\u1a79\u0001\u0000\u0000"+ + "\u0000\u1a7c\u1a7b\u0001\u0000\u0000\u0000\u1a7d\u0287\u0001\u0000\u0000"+ + "\u0000\u1a7e\u1a91\u0003\u028a\u0145\u0000\u1a7f\u1a91\u0003\u0292\u0149"+ + "\u0000\u1a80\u1a91\u0003\u0294\u014a\u0000\u1a81\u1a82\u0003\u02a8\u0154"+ + "\u0000\u1a82\u1a84\u0005\u046e\u0000\u0000\u1a83\u1a85\u0003\u02ac\u0156"+ + "\u0000\u1a84\u1a83\u0001\u0000\u0000\u0000\u1a84\u1a85\u0001\u0000\u0000"+ + "\u0000\u1a85\u1a86\u0001\u0000\u0000\u0000\u1a86\u1a87\u0005\u046f\u0000"+ + "\u0000\u1a87\u1a91\u0001\u0000\u0000\u0000\u1a88\u1a89\u0003\u0226\u0113"+ + "\u0000\u1a89\u1a8b\u0005\u046e\u0000\u0000\u1a8a\u1a8c\u0003\u02ac\u0156"+ + "\u0000\u1a8b\u1a8a\u0001\u0000\u0000\u0000\u1a8b\u1a8c\u0001\u0000\u0000"+ + "\u0000\u1a8c\u1a8d\u0001\u0000\u0000\u0000\u1a8d\u1a8e\u0005\u046f\u0000"+ + "\u0000\u1a8e\u1a91\u0001\u0000\u0000\u0000\u1a8f\u1a91\u0003\u02aa\u0155"+ + "\u0000\u1a90\u1a7e\u0001\u0000\u0000\u0000\u1a90\u1a7f\u0001\u0000\u0000"+ + "\u0000\u1a90\u1a80\u0001\u0000\u0000\u0000\u1a90\u1a81\u0001\u0000\u0000"+ + "\u0000\u1a90\u1a88\u0001\u0000\u0000\u0000\u1a90\u1a8f\u0001\u0000\u0000"+ + "\u0000\u1a91\u0289\u0001\u0000\u0000\u0000\u1a92\u1a95\u0007t\u0000\u0000"+ + "\u1a93\u1a94\u0005\u046e\u0000\u0000\u1a94\u1a96\u0005\u046f\u0000\u0000"+ + "\u1a95\u1a93\u0001\u0000\u0000\u0000\u1a95\u1a96\u0001\u0000\u0000\u0000"+ + "\u1a96\u1b46\u0001\u0000\u0000\u0000\u1a97\u1b46\u0003"; + private static final String _serializedATNSegment3 = + ">\u001f\u0000\u1a98\u1a99\u0005!\u0000\u0000\u1a99\u1a9a\u0005\u046e\u0000"+ + "\u0000\u1a9a\u1a9b\u0003\u02b0\u0158\u0000\u1a9b\u1a9c\u0005\u0470\u0000"+ + "\u0000\u1a9c\u1a9d\u0003\u0260\u0130\u0000\u1a9d\u1a9e\u0005\u046f\u0000"+ + "\u0000\u1a9e\u1b46\u0001\u0000\u0000\u0000\u1a9f\u1aa0\u0005!\u0000\u0000"+ + "\u1aa0\u1aa1\u0005\u046e\u0000\u0000\u1aa1\u1aa2\u0003\u02b0\u0158\u0000"+ + "\u1aa2\u1aa3\u0005\u00bc\u0000\u0000\u1aa3\u1aa4\u0003\u0238\u011c\u0000"+ + "\u1aa4\u1aa5\u0005\u046f\u0000\u0000\u1aa5\u1b46\u0001\u0000\u0000\u0000"+ + "\u1aa6\u1aa7\u0005\u0018\u0000\u0000\u1aa7\u1aa8\u0005\u046e\u0000\u0000"+ + "\u1aa8\u1aa9\u0003\u02b0\u0158\u0000\u1aa9\u1aaa\u0005\r\u0000\u0000\u1aaa"+ + "\u1aab\u0003\u0260\u0130\u0000\u1aab\u1aac\u0005\u046f\u0000\u0000\u1aac"+ + "\u1b46\u0001\u0000\u0000\u0000\u1aad\u1aae\u0005\u00bd\u0000\u0000\u1aae"+ + "\u1aaf\u0005\u046e\u0000\u0000\u1aaf\u1ab0\u0003\u022c\u0116\u0000\u1ab0"+ + "\u1ab1\u0005\u046f\u0000\u0000\u1ab1\u1b46\u0001\u0000\u0000\u0000\u1ab2"+ + "\u1ab3\u0005\u0017\u0000\u0000\u1ab3\u1ab5\u0003\u02b0\u0158\u0000\u1ab4"+ + "\u1ab6\u0003\u028c\u0146\u0000\u1ab5\u1ab4\u0001\u0000\u0000\u0000\u1ab6"+ + "\u1ab7\u0001\u0000\u0000\u0000\u1ab7\u1ab5\u0001\u0000\u0000\u0000\u1ab7"+ + "\u1ab8\u0001\u0000\u0000\u0000\u1ab8\u1abb\u0001\u0000\u0000\u0000\u1ab9"+ + "\u1aba\u00056\u0000\u0000\u1aba\u1abc\u0003\u02ae\u0157\u0000\u1abb\u1ab9"+ + "\u0001\u0000\u0000\u0000\u1abb\u1abc\u0001\u0000\u0000\u0000\u1abc\u1abd"+ + "\u0001\u0000\u0000\u0000\u1abd\u1abe\u0005\u0198\u0000\u0000\u1abe\u1b46"+ + "\u0001\u0000\u0000\u0000\u1abf\u1ac1\u0005\u0017\u0000\u0000\u1ac0\u1ac2"+ + "\u0003\u028c\u0146\u0000\u1ac1\u1ac0\u0001\u0000\u0000\u0000\u1ac2\u1ac3"+ + "\u0001\u0000\u0000\u0000\u1ac3\u1ac1\u0001\u0000\u0000\u0000\u1ac3\u1ac4"+ + "\u0001\u0000\u0000\u0000\u1ac4\u1ac7\u0001\u0000\u0000\u0000\u1ac5\u1ac6"+ + "\u00056\u0000\u0000\u1ac6\u1ac8\u0003\u02ae\u0157\u0000\u1ac7\u1ac5\u0001"+ + "\u0000\u0000\u0000\u1ac7\u1ac8\u0001\u0000\u0000\u0000\u1ac8\u1ac9\u0001"+ + "\u0000\u0000\u0000\u1ac9\u1aca\u0005\u0198\u0000\u0000\u1aca\u1b46\u0001"+ + "\u0000\u0000\u0000\u1acb\u1acc\u0005\u00df\u0000\u0000\u1acc\u1acd\u0005"+ + "\u046e\u0000\u0000\u1acd\u1ad0\u0003\u02ac\u0156\u0000\u1ace\u1acf\u0005"+ + "\u00bc\u0000\u0000\u1acf\u1ad1\u0003\u0238\u011c\u0000\u1ad0\u1ace\u0001"+ + "\u0000\u0000\u0000\u1ad0\u1ad1\u0001\u0000\u0000\u0000\u1ad1\u1ad2\u0001"+ + "\u0000\u0000\u0000\u1ad2\u1ad3\u0005\u046f\u0000\u0000\u1ad3\u1b46\u0001"+ + "\u0000\u0000\u0000\u1ad4\u1ad5\u0005\u0145\u0000\u0000\u1ad5\u1ad8\u0005"+ + "\u046e\u0000\u0000\u1ad6\u1ad9\u0003\u0252\u0129\u0000\u1ad7\u1ad9\u0003"+ + "\u02b0\u0158\u0000\u1ad8\u1ad6\u0001\u0000\u0000\u0000\u1ad8\u1ad7\u0001"+ + "\u0000\u0000\u0000\u1ad9\u1ada\u0001\u0000\u0000\u0000\u1ada\u1add\u0005"+ + "Q\u0000\u0000\u1adb\u1ade\u0003\u0252\u0129\u0000\u1adc\u1ade\u0003\u02b0"+ + "\u0158\u0000\u1add\u1adb\u0001\u0000\u0000\u0000\u1add\u1adc\u0001\u0000"+ + "\u0000\u0000\u1ade\u1adf\u0001\u0000\u0000\u0000\u1adf\u1ae0\u0005\u046f"+ + "\u0000\u0000\u1ae0\u1b46\u0001\u0000\u0000\u0000\u1ae1\u1ae2\u0007u\u0000"+ + "\u0000\u1ae2\u1ae5\u0005\u046e\u0000\u0000\u1ae3\u1ae6\u0003\u0252\u0129"+ + "\u0000\u1ae4\u1ae6\u0003\u02b0\u0158\u0000\u1ae5\u1ae3\u0001\u0000\u0000"+ + "\u0000\u1ae5\u1ae4\u0001\u0000\u0000\u0000\u1ae6\u1ae7\u0001\u0000\u0000"+ + "\u0000\u1ae7\u1aea\u0005E\u0000\u0000\u1ae8\u1aeb\u0003\u024e\u0127\u0000"+ + "\u1ae9\u1aeb\u0003\u02b0\u0158\u0000\u1aea\u1ae8\u0001\u0000\u0000\u0000"+ + "\u1aea\u1ae9\u0001\u0000\u0000\u0000\u1aeb\u1af1\u0001\u0000\u0000\u0000"+ + "\u1aec\u1aef\u0005B\u0000\u0000\u1aed\u1af0\u0003\u024e\u0127\u0000\u1aee"+ + "\u1af0\u0003\u02b0\u0158\u0000\u1aef\u1aed\u0001\u0000\u0000\u0000\u1aef"+ + "\u1aee\u0001\u0000\u0000\u0000\u1af0\u1af2\u0001\u0000\u0000\u0000\u1af1"+ + "\u1aec\u0001\u0000\u0000\u0000\u1af1\u1af2\u0001\u0000\u0000\u0000\u1af2"+ + "\u1af3\u0001\u0000\u0000\u0000\u1af3\u1af4\u0005\u046f\u0000\u0000\u1af4"+ + "\u1b46\u0001\u0000\u0000\u0000\u1af5\u1af6\u0005\u0149\u0000\u0000\u1af6"+ + "\u1af7\u0005\u046e\u0000\u0000\u1af7\u1afa\u0007v\u0000\u0000\u1af8\u1afb"+ + "\u0003\u0252\u0129\u0000\u1af9\u1afb\u0003\u02b0\u0158\u0000\u1afa\u1af8"+ + "\u0001\u0000\u0000\u0000\u1afa\u1af9\u0001\u0000\u0000\u0000\u1afa\u1afb"+ + "\u0001\u0000\u0000\u0000\u1afb\u1afc\u0001\u0000\u0000\u0000\u1afc\u1aff"+ + "\u0005E\u0000\u0000\u1afd\u1b00\u0003\u0252\u0129\u0000\u1afe\u1b00\u0003"+ + "\u02b0\u0158\u0000\u1aff\u1afd\u0001\u0000\u0000\u0000\u1aff\u1afe\u0001"+ + "\u0000\u0000\u0000\u1b00\u1b01\u0001\u0000\u0000\u0000\u1b01\u1b02\u0005"+ + "\u046f\u0000\u0000\u1b02\u1b46\u0001\u0000\u0000\u0000\u1b03\u1b04\u0005"+ + "\u0149\u0000\u0000\u1b04\u1b07\u0005\u046e\u0000\u0000\u1b05\u1b08\u0003"+ + "\u0252\u0129\u0000\u1b06\u1b08\u0003\u02b0\u0158\u0000\u1b07\u1b05\u0001"+ + "\u0000\u0000\u0000\u1b07\u1b06\u0001\u0000\u0000\u0000\u1b08\u1b09\u0001"+ + "\u0000\u0000\u0000\u1b09\u1b0c\u0005E\u0000\u0000\u1b0a\u1b0d\u0003\u0252"+ + "\u0129\u0000\u1b0b\u1b0d\u0003\u02b0\u0158\u0000\u1b0c\u1b0a\u0001\u0000"+ + "\u0000\u0000\u1b0c\u1b0b\u0001\u0000\u0000\u0000\u1b0d\u1b0e\u0001\u0000"+ + "\u0000\u0000\u1b0e\u1b0f\u0005\u046f\u0000\u0000\u1b0f\u1b46\u0001\u0000"+ + "\u0000\u0000\u1b10\u1b11\u0005\u0450\u0000\u0000\u1b11\u1b14\u0005\u046e"+ + "\u0000\u0000\u1b12\u1b15\u0003\u0252\u0129\u0000\u1b13\u1b15\u0003\u02b0"+ + "\u0158\u0000\u1b14\u1b12\u0001\u0000\u0000\u0000\u1b14\u1b13\u0001\u0000"+ + "\u0000\u0000\u1b15\u1b1c\u0001\u0000\u0000\u0000\u1b16\u1b17\u0005\r\u0000"+ + "\u0000\u1b17\u1b18\u0007w\u0000\u0000\u1b18\u1b19\u0005\u046e\u0000\u0000"+ + "\u1b19\u1b1a\u0003\u024e\u0127\u0000\u1b1a\u1b1b\u0005\u046f\u0000\u0000"+ + "\u1b1b\u1b1d\u0001\u0000\u0000\u0000\u1b1c\u1b16\u0001\u0000\u0000\u0000"+ + "\u1b1c\u1b1d\u0001\u0000\u0000\u0000\u1b1d\u1b1f\u0001\u0000\u0000\u0000"+ + "\u1b1e\u1b20\u0003\u028e\u0147\u0000\u1b1f\u1b1e\u0001\u0000\u0000\u0000"+ + "\u1b1f\u1b20\u0001\u0000\u0000\u0000\u1b20\u1b21\u0001\u0000\u0000\u0000"+ + "\u1b21\u1b22\u0005\u046f\u0000\u0000\u1b22\u1b46\u0001\u0000\u0000\u0000"+ + "\u1b23\u1b24\u0005\u0142\u0000\u0000\u1b24\u1b25\u0005\u046e\u0000\u0000"+ + "\u1b25\u1b26\u0003H$\u0000\u1b26\u1b29\u0005E\u0000\u0000\u1b27\u1b2a"+ + "\u0003\u0252\u0129\u0000\u1b28\u1b2a\u0003\u02b0\u0158\u0000\u1b29\u1b27"+ + "\u0001\u0000\u0000\u0000\u1b29\u1b28\u0001\u0000\u0000\u0000\u1b2a\u1b2b"+ + "\u0001\u0000\u0000\u0000\u1b2b\u1b2c\u0005\u046f\u0000\u0000\u1b2c\u1b46"+ + "\u0001\u0000\u0000\u0000\u1b2d\u1b2e\u0005\u0385\u0000\u0000\u1b2e\u1b2f"+ + "\u0005\u046e\u0000\u0000\u1b2f\u1b30\u0007x\u0000\u0000\u1b30\u1b31\u0005"+ + "\u0470\u0000\u0000\u1b31\u1b32\u0003\u0252\u0129\u0000\u1b32\u1b33\u0005"+ + "\u046f\u0000\u0000\u1b33\u1b46\u0001\u0000\u0000\u0000\u1b34\u1b35\u0005"+ + "\u011b\u0000\u0000\u1b35\u1b36\u0005\u046e\u0000\u0000\u1b36\u1b37\u0003"+ + "\u02b0\u0158\u0000\u1b37\u1b38\u0005\u0470\u0000\u0000\u1b38\u1b3b\u0003"+ + "\u02b0\u0158\u0000\u1b39\u1b3a\u0005\u0252\u0000\u0000\u1b3a\u1b3c\u0003"+ + "\u0260\u0130\u0000\u1b3b\u1b39\u0001\u0000\u0000\u0000\u1b3b\u1b3c\u0001"+ + "\u0000\u0000\u0000\u1b3c\u1b3e\u0001\u0000\u0000\u0000\u1b3d\u1b3f\u0003"+ + "\u010c\u0086\u0000\u1b3e\u1b3d\u0001\u0000\u0000\u0000\u1b3e\u1b3f\u0001"+ + "\u0000\u0000\u0000\u1b3f\u1b41\u0001\u0000\u0000\u0000\u1b40\u1b42\u0003"+ + "\u010e\u0087\u0000\u1b41\u1b40\u0001\u0000\u0000\u0000\u1b41\u1b42\u0001"+ + "\u0000\u0000\u0000\u1b42\u1b43\u0001\u0000\u0000\u0000\u1b43\u1b44\u0005"+ + "\u046f\u0000\u0000\u1b44\u1b46\u0001\u0000\u0000\u0000\u1b45\u1a92\u0001"+ + "\u0000\u0000\u0000\u1b45\u1a97\u0001\u0000\u0000\u0000\u1b45\u1a98\u0001"+ + "\u0000\u0000\u0000\u1b45\u1a9f\u0001\u0000\u0000\u0000\u1b45\u1aa6\u0001"+ + "\u0000\u0000\u0000\u1b45\u1aad\u0001\u0000\u0000\u0000\u1b45\u1ab2\u0001"+ + "\u0000\u0000\u0000\u1b45\u1abf\u0001\u0000\u0000\u0000\u1b45\u1acb\u0001"+ + "\u0000\u0000\u0000\u1b45\u1ad4\u0001\u0000\u0000\u0000\u1b45\u1ae1\u0001"+ + "\u0000\u0000\u0000\u1b45\u1af5\u0001\u0000\u0000\u0000\u1b45\u1b03\u0001"+ + "\u0000\u0000\u0000\u1b45\u1b10\u0001\u0000\u0000\u0000\u1b45\u1b23\u0001"+ + "\u0000\u0000\u0000\u1b45\u1b2d\u0001\u0000\u0000\u0000\u1b45\u1b34\u0001"+ + "\u0000\u0000\u0000\u1b46\u028b\u0001\u0000\u0000\u0000\u1b47\u1b48\u0005"+ + "\u00be\u0000\u0000\u1b48\u1b49\u0003\u02ae\u0157\u0000\u1b49\u1b4a\u0005"+ + "\u00af\u0000\u0000\u1b4a\u1b4b\u0003\u02ae\u0157\u0000\u1b4b\u028d\u0001"+ + "\u0000\u0000\u0000\u1b4c\u1b4d\u0005\u01d9\u0000\u0000\u1b4d\u1b52\u0003"+ + "\u0290\u0148\u0000\u1b4e\u1b4f\u0005\u0470\u0000\u0000\u1b4f\u1b51\u0003"+ + "\u0290\u0148\u0000\u1b50\u1b4e\u0001\u0000\u0000\u0000\u1b51\u1b54\u0001"+ + "\u0000\u0000\u0000\u1b52\u1b50\u0001\u0000\u0000\u0000\u1b52\u1b53\u0001"+ + "\u0000\u0000\u0000\u1b53\u1b5b\u0001\u0000\u0000\u0000\u1b54\u1b52\u0001"+ + "\u0000\u0000\u0000\u1b55\u1b56\u0005\u01d9\u0000\u0000\u1b56\u1b57\u0003"+ + "\u024e\u0127\u0000\u1b57\u1b58\u0005\u0462\u0000\u0000\u1b58\u1b59\u0003"+ + "\u024e\u0127\u0000\u1b59\u1b5b\u0001\u0000\u0000\u0000\u1b5a\u1b4c\u0001"+ + "\u0000\u0000\u0000\u1b5a\u1b55\u0001\u0000\u0000\u0000\u1b5b\u028f\u0001"+ + "\u0000\u0000\u0000\u1b5c\u1b5e\u0003\u024e\u0127\u0000\u1b5d\u1b5f\u0007"+ + "y\u0000\u0000\u1b5e\u1b5d\u0001\u0000\u0000\u0000\u1b5e\u1b5f\u0001\u0000"+ + "\u0000\u0000\u1b5f\u0291\u0001\u0000\u0000\u0000\u1b60\u1b61\u0007z\u0000"+ + "\u0000\u1b61\u1b63\u0005\u046e\u0000\u0000\u1b62\u1b64\u0007,\u0000\u0000"+ + "\u1b63\u1b62\u0001\u0000\u0000\u0000\u1b63\u1b64\u0001\u0000\u0000\u0000"+ + "\u1b64\u1b65\u0001\u0000\u0000\u0000\u1b65\u1b66\u0003\u02ae\u0157\u0000"+ + "\u1b66\u1b68\u0005\u046f\u0000\u0000\u1b67\u1b69\u0003\u0296\u014b\u0000"+ + "\u1b68\u1b67\u0001\u0000\u0000\u0000\u1b68\u1b69\u0001\u0000\u0000\u0000"+ + "\u1b69\u1b9c\u0001\u0000\u0000\u0000\u1b6a\u1b6b\u0005\u0123\u0000\u0000"+ + "\u1b6b\u1b73\u0005\u046e\u0000\u0000\u1b6c\u1b74\u0005\u045e\u0000\u0000"+ + "\u1b6d\u1b6f\u0005\u0007\u0000\u0000\u1b6e\u1b6d\u0001\u0000\u0000\u0000"+ + "\u1b6e\u1b6f\u0001\u0000\u0000\u0000\u1b6f\u1b70\u0001\u0000\u0000\u0000"+ + "\u1b70\u1b74\u0003\u02ae\u0157\u0000\u1b71\u1b72\u00052\u0000\u0000\u1b72"+ + "\u1b74\u0003\u02ac\u0156\u0000\u1b73\u1b6c\u0001\u0000\u0000\u0000\u1b73"+ + "\u1b6e\u0001\u0000\u0000\u0000\u1b73\u1b71\u0001\u0000\u0000\u0000\u1b74"+ + "\u1b75\u0001\u0000\u0000\u0000\u1b75\u1b77\u0005\u046f\u0000\u0000\u1b76"+ + "\u1b78\u0003\u0296\u014b\u0000\u1b77\u1b76\u0001\u0000\u0000\u0000\u1b77"+ + "\u1b78\u0001\u0000\u0000\u0000\u1b78\u1b9c\u0001\u0000\u0000\u0000\u1b79"+ + "\u1b7a\u0007{\u0000\u0000\u1b7a\u1b7c\u0005\u046e\u0000\u0000\u1b7b\u1b7d"+ + "\u0005\u0007\u0000\u0000\u1b7c\u1b7b\u0001\u0000\u0000\u0000\u1b7c\u1b7d"+ + "\u0001\u0000\u0000\u0000\u1b7d\u1b7e\u0001\u0000\u0000\u0000\u1b7e\u1b7f"+ + "\u0003\u02ae\u0157\u0000\u1b7f\u1b81\u0005\u046f\u0000\u0000\u1b80\u1b82"+ + "\u0003\u0296\u014b\u0000\u1b81\u1b80\u0001\u0000\u0000\u0000\u1b81\u1b82"+ + "\u0001\u0000\u0000\u0000\u1b82\u1b9c\u0001\u0000\u0000\u0000\u1b83\u1b84"+ + "\u0005\u0127\u0000\u0000\u1b84\u1b86\u0005\u046e\u0000\u0000\u1b85\u1b87"+ + "\u00052\u0000\u0000\u1b86\u1b85\u0001\u0000\u0000\u0000\u1b86\u1b87\u0001"+ + "\u0000\u0000\u0000\u1b87\u1b88\u0001\u0000\u0000\u0000\u1b88\u1b93\u0003"+ + "\u02ac\u0156\u0000\u1b89\u1b8a\u0005}\u0000\u0000\u1b8a\u1b8b\u0005\u0014"+ + "\u0000\u0000\u1b8b\u1b90\u0003\u00e8t\u0000\u1b8c\u1b8d\u0005\u0470\u0000"+ + "\u0000\u1b8d\u1b8f\u0003\u00e8t\u0000\u1b8e\u1b8c\u0001\u0000\u0000\u0000"+ + "\u1b8f\u1b92\u0001\u0000\u0000\u0000\u1b90\u1b8e\u0001\u0000\u0000\u0000"+ + "\u1b90\u1b91\u0001\u0000\u0000\u0000\u1b91\u1b94\u0001\u0000\u0000\u0000"+ + "\u1b92\u1b90\u0001\u0000\u0000\u0000\u1b93\u1b89\u0001\u0000\u0000\u0000"+ + "\u1b93\u1b94\u0001\u0000\u0000\u0000\u1b94\u1b97\u0001\u0000\u0000\u0000"+ + "\u1b95\u1b96\u0005\u009b\u0000\u0000\u1b96\u1b98\u0005\u047d\u0000\u0000"+ + "\u1b97\u1b95\u0001\u0000\u0000\u0000\u1b97\u1b98\u0001\u0000\u0000\u0000"+ + "\u1b98\u1b99\u0001\u0000\u0000\u0000\u1b99\u1b9a\u0005\u046f\u0000\u0000"+ + "\u1b9a\u1b9c\u0001\u0000\u0000\u0000\u1b9b\u1b60\u0001\u0000\u0000\u0000"+ + "\u1b9b\u1b6a\u0001\u0000\u0000\u0000\u1b9b\u1b79\u0001\u0000\u0000\u0000"+ + "\u1b9b\u1b83\u0001\u0000\u0000\u0000\u1b9c\u0293\u0001\u0000\u0000\u0000"+ + "\u1b9d\u1b9e\u0007|\u0000\u0000\u1b9e\u1b9f\u0005\u046e\u0000\u0000\u1b9f"+ + "\u1ba2\u0003\u02b0\u0158\u0000\u1ba0\u1ba1\u0005\u0470\u0000\u0000\u1ba1"+ + "\u1ba3\u0003\u024e\u0127\u0000\u1ba2\u1ba0\u0001\u0000\u0000\u0000\u1ba2"+ + "\u1ba3\u0001\u0000\u0000\u0000\u1ba3\u1ba6\u0001\u0000\u0000\u0000\u1ba4"+ + "\u1ba5\u0005\u0470\u0000\u0000\u1ba5\u1ba7\u0003\u024e\u0127\u0000\u1ba6"+ + "\u1ba4\u0001\u0000\u0000\u0000\u1ba6\u1ba7\u0001\u0000\u0000\u0000\u1ba7"+ + "\u1ba8\u0001\u0000\u0000\u0000\u1ba8\u1ba9\u0005\u046f\u0000\u0000\u1ba9"+ + "\u1baa\u0003\u0296\u014b\u0000\u1baa\u1bc4\u0001\u0000\u0000\u0000\u1bab"+ + "\u1bac\u0007}\u0000\u0000\u1bac\u1bad\u0005\u046e\u0000\u0000\u1bad\u1bae"+ + "\u0003\u02b0\u0158\u0000\u1bae\u1baf\u0005\u046f\u0000\u0000\u1baf\u1bb0"+ + "\u0003\u0296\u014b\u0000\u1bb0\u1bc4\u0001\u0000\u0000\u0000\u1bb1\u1bb2"+ + "\u0007~\u0000\u0000\u1bb2\u1bb3\u0005\u046e\u0000\u0000\u1bb3\u1bb4\u0005"+ + "\u046f\u0000\u0000\u1bb4\u1bc4\u0003\u0296\u014b\u0000\u1bb5\u1bb6\u0005"+ + "\u012e\u0000\u0000\u1bb6\u1bb7\u0005\u046e\u0000\u0000\u1bb7\u1bb8\u0003"+ + "\u02b0\u0158\u0000\u1bb8\u1bb9\u0005\u0470\u0000\u0000\u1bb9\u1bba\u0003"+ + "\u024e\u0127\u0000\u1bba\u1bbb\u0005\u046f\u0000\u0000\u1bbb\u1bbc\u0003"+ + "\u0296\u014b\u0000\u1bbc\u1bc4\u0001\u0000\u0000\u0000\u1bbd\u1bbe\u0005"+ + "\u012d\u0000\u0000\u1bbe\u1bbf\u0005\u046e\u0000\u0000\u1bbf\u1bc0\u0003"+ + "\u024e\u0127\u0000\u1bc0\u1bc1\u0005\u046f\u0000\u0000\u1bc1\u1bc2\u0003"+ + "\u0296\u014b\u0000\u1bc2\u1bc4\u0001\u0000\u0000\u0000\u1bc3\u1b9d\u0001"+ + "\u0000\u0000\u0000\u1bc3\u1bab\u0001\u0000\u0000\u0000\u1bc3\u1bb1\u0001"+ + "\u0000\u0000\u0000\u1bc3\u1bb5\u0001\u0000\u0000\u0000\u1bc3\u1bbd\u0001"+ + "\u0000\u0000\u0000\u1bc4\u0295\u0001\u0000\u0000\u0000\u1bc5\u1bcb\u0005"+ + "\u0081\u0000\u0000\u1bc6\u1bc7\u0005\u046e\u0000\u0000\u1bc7\u1bc8\u0003"+ + "\u0298\u014c\u0000\u1bc8\u1bc9\u0005\u046f\u0000\u0000\u1bc9\u1bcc\u0001"+ + "\u0000\u0000\u0000\u1bca\u1bcc\u0003\u029a\u014d\u0000\u1bcb\u1bc6\u0001"+ + "\u0000\u0000\u0000\u1bcb\u1bca\u0001\u0000\u0000\u0000\u1bcc\u0297\u0001"+ + "\u0000\u0000\u0000\u1bcd\u1bcf\u0003\u029a\u014d\u0000\u1bce\u1bcd\u0001"+ + "\u0000\u0000\u0000\u1bce\u1bcf\u0001\u0000\u0000\u0000\u1bcf\u1bd1\u0001"+ + "\u0000\u0000\u0000\u1bd0\u1bd2\u0003\u02a6\u0153\u0000\u1bd1\u1bd0\u0001"+ + "\u0000\u0000\u0000\u1bd1\u1bd2\u0001\u0000\u0000\u0000\u1bd2\u1bd4\u0001"+ + "\u0000\u0000\u0000\u1bd3\u1bd5\u0003\u00e6s\u0000\u1bd4\u1bd3\u0001\u0000"+ + "\u0000\u0000\u1bd4\u1bd5\u0001\u0000\u0000\u0000\u1bd5\u1bd7\u0001\u0000"+ + "\u0000\u0000\u1bd6\u1bd8\u0003\u029c\u014e\u0000\u1bd7\u1bd6\u0001\u0000"+ + "\u0000\u0000\u1bd7\u1bd8\u0001\u0000\u0000\u0000\u1bd8\u0299\u0001\u0000"+ + "\u0000\u0000\u1bd9\u1bda\u0003\u0248\u0124\u0000\u1bda\u029b\u0001\u0000"+ + "\u0000\u0000\u1bdb\u1bdc\u0003\u029e\u014f\u0000\u1bdc\u1bdd\u0003\u02a0"+ + "\u0150\u0000\u1bdd\u029d\u0001\u0000\u0000\u0000\u1bde\u1bdf\u0007\u007f"+ + "\u0000\u0000\u1bdf\u029f\u0001\u0000\u0000\u0000\u1be0\u1be3\u0003\u02a4"+ + "\u0152\u0000\u1be1\u1be3\u0003\u02a2\u0151\u0000\u1be2\u1be0\u0001\u0000"+ + "\u0000\u0000\u1be2\u1be1\u0001\u0000\u0000\u0000\u1be3\u02a1\u0001\u0000"+ + "\u0000\u0000\u1be4\u1be5\u0005\u0011\u0000\u0000\u1be5\u1be6\u0003\u02a4"+ + "\u0152\u0000\u1be6\u1be7\u0005\u000b\u0000\u0000\u1be7\u1be8\u0003\u02a4"+ + "\u0152\u0000\u1be8\u02a3\u0001\u0000\u0000\u0000\u1be9\u1bea\u0005$\u0000"+ + "\u0000\u1bea\u1bf1\u0005\u0259\u0000\u0000\u1beb\u1bec\u0005\u0292\u0000"+ + "\u0000\u1bec\u1bf1\u0007\u0080\u0000\u0000\u1bed\u1bee\u0003\u02b0\u0158"+ + "\u0000\u1bee\u1bef\u0007\u0080\u0000\u0000\u1bef\u1bf1\u0001\u0000\u0000"+ + "\u0000\u1bf0\u1be9\u0001\u0000\u0000\u0000\u1bf0\u1beb\u0001\u0000\u0000"+ + "\u0000\u1bf0\u1bed\u0001\u0000\u0000\u0000\u1bf1\u02a5\u0001\u0000\u0000"+ + "\u0000\u1bf2\u1bf3\u0005\u0082\u0000\u0000\u1bf3\u1bf4\u0005\u0014\u0000"+ + "\u0000\u1bf4\u1bf9\u0003\u02b0\u0158\u0000\u1bf5\u1bf6\u0005\u0470\u0000"+ + "\u0000\u1bf6\u1bf8\u0003\u02b0\u0158\u0000\u1bf7\u1bf5\u0001\u0000\u0000"+ + "\u0000\u1bf8\u1bfb\u0001\u0000\u0000\u0000\u1bf9\u1bf7\u0001\u0000\u0000"+ + "\u0000\u1bf9\u1bfa\u0001\u0000\u0000\u0000\u1bfa\u02a7\u0001\u0000\u0000"+ + "\u0000\u1bfb\u1bf9\u0001\u0000\u0000\u0000\u1bfc\u1c15\u0003\u02d0\u0168"+ + "\u0000\u1bfd\u1c15\u0005\u02ec\u0000\u0000\u1bfe\u1c15\u0005\u013e\u0000"+ + "\u0000\u1bff\u1c15\u0005\u013a\u0000\u0000\u1c00\u1c15\u0005\u013b\u0000"+ + "\u0000\u1c01\u1c15\u0005\u013c\u0000\u0000\u1c02\u1c15\u0005\u013f\u0000"+ + "\u0000\u1c03\u1c15\u0005\u0140\u0000\u0000\u1c04\u1c15\u0005\u0141\u0000"+ + "\u0000\u1c05\u1c15\u0005N\u0000\u0000\u1c06\u1c15\u0005V\u0000\u0000\u1c07"+ + "\u1c15\u0005\u013d\u0000\u0000\u1c08\u1c15\u0005\u0143\u0000\u0000\u1c09"+ + "\u1c15\u0005\u01fd\u0000\u0000\u1c0a\u1c15\u0005\u0144\u0000\u0000\u1c0b"+ + "\u1c15\u0005\u008d\u0000\u0000\u1c0c\u1c15\u0005\u008e\u0000\u0000\u1c0d"+ + "\u1c15\u0005\u0146\u0000\u0000\u1c0e\u1c15\u0005\u0147\u0000\u0000\u1c0f"+ + "\u1c15\u0005\u0148\u0000\u0000\u1c10\u1c15\u0005\u0149\u0000\u0000\u1c11"+ + "\u1c15\u0005\u014a\u0000\u0000\u1c12\u1c15\u0005\u014b\u0000\u0000\u1c13"+ + "\u1c15\u0005\u014c\u0000\u0000\u1c14\u1bfc\u0001\u0000\u0000\u0000\u1c14"+ + "\u1bfd\u0001\u0000\u0000\u0000\u1c14\u1bfe\u0001\u0000\u0000\u0000\u1c14"+ + "\u1bff\u0001\u0000\u0000\u0000\u1c14\u1c00\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c01\u0001\u0000\u0000\u0000\u1c14\u1c02\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c03\u0001\u0000\u0000\u0000\u1c14\u1c04\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c05\u0001\u0000\u0000\u0000\u1c14\u1c06\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c07\u0001\u0000\u0000\u0000\u1c14\u1c08\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c09\u0001\u0000\u0000\u0000\u1c14\u1c0a\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c0b\u0001\u0000\u0000\u0000\u1c14\u1c0c\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c0d\u0001\u0000\u0000\u0000\u1c14\u1c0e\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c0f\u0001\u0000\u0000\u0000\u1c14\u1c10\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c11\u0001\u0000\u0000\u0000\u1c14\u1c12\u0001\u0000\u0000\u0000\u1c14"+ + "\u1c13\u0001\u0000\u0000\u0000\u1c15\u02a9\u0001\u0000\u0000\u0000\u1c16"+ + "\u1c17\u0007\u0081\u0000\u0000\u1c17\u1c18\u0005\u046e\u0000\u0000\u1c18"+ + "\u1c19\u0003\u02ae\u0157\u0000\u1c19\u1c1a\u0005\u046f\u0000\u0000\u1c1a"+ + "\u02ab\u0001\u0000\u0000\u0000\u1c1b\u1c20\u0003\u025a\u012d\u0000\u1c1c"+ + "\u1c20\u0003\u022c\u0116\u0000\u1c1d\u1c20\u0003\u0288\u0144\u0000\u1c1e"+ + "\u1c20\u0003\u02b0\u0158\u0000\u1c1f\u1c1b\u0001\u0000\u0000\u0000\u1c1f"+ + "\u1c1c\u0001\u0000\u0000\u0000\u1c1f\u1c1d\u0001\u0000\u0000\u0000\u1c1f"+ + "\u1c1e\u0001\u0000\u0000\u0000\u1c20\u1c2a\u0001\u0000\u0000\u0000\u1c21"+ + "\u1c26\u0005\u0470\u0000\u0000\u1c22\u1c27\u0003\u025a\u012d\u0000\u1c23"+ + "\u1c27\u0003\u022c\u0116\u0000\u1c24\u1c27\u0003\u0288\u0144\u0000\u1c25"+ + "\u1c27\u0003\u02b0\u0158\u0000\u1c26\u1c22\u0001\u0000\u0000\u0000\u1c26"+ + "\u1c23\u0001\u0000\u0000\u0000\u1c26\u1c24\u0001\u0000\u0000\u0000\u1c26"+ + "\u1c25\u0001\u0000\u0000\u0000\u1c27\u1c29\u0001\u0000\u0000\u0000\u1c28"+ + "\u1c21\u0001\u0000\u0000\u0000\u1c29\u1c2c\u0001\u0000\u0000\u0000\u1c2a"+ + "\u1c28\u0001\u0000\u0000\u0000\u1c2a\u1c2b\u0001\u0000\u0000\u0000\u1c2b"+ + "\u02ad\u0001\u0000\u0000\u0000\u1c2c\u1c2a\u0001\u0000\u0000\u0000\u1c2d"+ + "\u1c32\u0003\u025a\u012d\u0000\u1c2e\u1c32\u0003\u022c\u0116\u0000\u1c2f"+ + "\u1c32\u0003\u0288\u0144\u0000\u1c30\u1c32\u0003\u02b0\u0158\u0000\u1c31"+ + "\u1c2d\u0001\u0000\u0000\u0000\u1c31\u1c2e\u0001\u0000\u0000\u0000\u1c31"+ + "\u1c2f\u0001\u0000\u0000\u0000\u1c31\u1c30\u0001\u0000\u0000\u0000\u1c32"+ + "\u02af\u0001\u0000\u0000\u0000\u1c33\u1c34\u0006\u0158\uffff\uffff\u0000"+ + "\u1c34\u1c35\u0007\u0082\u0000\u0000\u1c35\u1c3f\u0003\u02b0\u0158\u0004"+ + "\u1c36\u1c37\u0003\u02b2\u0159\u0000\u1c37\u1c39\u0005Y\u0000\u0000\u1c38"+ + "\u1c3a\u0005s\u0000\u0000\u1c39\u1c38\u0001\u0000\u0000\u0000\u1c39\u1c3a"+ + "\u0001\u0000\u0000\u0000\u1c3a\u1c3b\u0001\u0000\u0000\u0000\u1c3b\u1c3c"+ + "\u0007\u0083\u0000\u0000\u1c3c\u1c3f\u0001\u0000\u0000\u0000\u1c3d\u1c3f"+ + "\u0003\u02b2\u0159\u0000\u1c3e\u1c33\u0001\u0000\u0000\u0000\u1c3e\u1c36"+ + "\u0001\u0000\u0000\u0000\u1c3e\u1c3d\u0001\u0000\u0000\u0000\u1c3f\u1c46"+ + "\u0001\u0000\u0000\u0000\u1c40\u1c41\n\u0003\u0000\u0000\u1c41\u1c42\u0003"+ + "\u02ba\u015d\u0000\u1c42\u1c43\u0003\u02b0\u0158\u0004\u1c43\u1c45\u0001"+ + "\u0000\u0000\u0000\u1c44\u1c40\u0001\u0000\u0000\u0000\u1c45\u1c48\u0001"+ + "\u0000\u0000\u0000\u1c46\u1c44\u0001\u0000\u0000\u0000\u1c46\u1c47\u0001"+ + "\u0000\u0000\u0000\u1c47\u02b1\u0001\u0000\u0000\u0000\u1c48\u1c46\u0001"+ + "\u0000\u0000\u0000\u1c49\u1c4a\u0006\u0159\uffff\uffff\u0000\u1c4a\u1c4b"+ + "\u0003\u02b4\u015a\u0000\u1c4b\u1c8c\u0001\u0000\u0000\u0000\u1c4c\u1c4d"+ + "\n\b\u0000\u0000\u1c4d\u1c4e\u0003\u02b8\u015c\u0000\u1c4e\u1c4f\u0003"+ + "\u02b2\u0159\t\u1c4f\u1c8b\u0001\u0000\u0000\u0000\u1c50\u1c52\n\u0006"+ + "\u0000\u0000\u1c51\u1c53\u0005s\u0000\u0000\u1c52\u1c51\u0001\u0000\u0000"+ + "\u0000\u1c52\u1c53\u0001\u0000\u0000\u0000\u1c53\u1c54\u0001\u0000\u0000"+ + "\u0000\u1c54\u1c55\u0005\u0011\u0000\u0000\u1c55\u1c56\u0003\u02b2\u0159"+ + "\u0000\u1c56\u1c57\u0005\u000b\u0000\u0000\u1c57\u1c58\u0003\u02b2\u0159"+ + "\u0007\u1c58\u1c8b\u0001\u0000\u0000\u0000\u1c59\u1c5a\n\u0005\u0000\u0000"+ + "\u1c5a\u1c5b\u0005\u026d\u0000\u0000\u1c5b\u1c5c\u0005c\u0000\u0000\u1c5c"+ + "\u1c8b\u0003\u02b2\u0159\u0006\u1c5d\u1c5f\n\u0003\u0000\u0000\u1c5e\u1c60"+ + "\u0005s\u0000\u0000\u1c5f\u1c5e\u0001\u0000\u0000\u0000\u1c5f\u1c60\u0001"+ + "\u0000\u0000\u0000\u1c60\u1c61\u0001\u0000\u0000\u0000\u1c61\u1c62\u0007"+ + "\u0084\u0000\u0000\u1c62\u1c8b\u0003\u02b2\u0159\u0004\u1c63\u1c65\n\n"+ + "\u0000\u0000\u1c64\u1c66\u0005s\u0000\u0000\u1c65\u1c64\u0001\u0000\u0000"+ + "\u0000\u1c65\u1c66\u0001\u0000\u0000\u0000\u1c66\u1c67\u0001\u0000\u0000"+ + "\u0000\u1c67\u1c68\u0005Q\u0000\u0000\u1c68\u1c6b\u0005\u046e\u0000\u0000"+ + "\u1c69\u1c6c\u0003\u00c8d\u0000\u1c6a\u1c6c\u0003\u0270\u0138\u0000\u1c6b"+ + "\u1c69\u0001\u0000\u0000\u0000\u1c6b\u1c6a\u0001\u0000\u0000\u0000\u1c6c"+ + "\u1c6d\u0001\u0000\u0000\u0000\u1c6d\u1c6e\u0005\u046f\u0000\u0000\u1c6e"+ + "\u1c8b\u0001\u0000\u0000\u0000\u1c6f\u1c70\n\t\u0000\u0000\u1c70\u1c71"+ + "\u0005Y\u0000\u0000\u1c71\u1c8b\u0003\u0258\u012c\u0000\u1c72\u1c73\n"+ + "\u0007\u0000\u0000\u1c73\u1c74\u0003\u02b8\u015c\u0000\u1c74\u1c75\u0007"+ + "\u0085\u0000\u0000\u1c75\u1c76\u0005\u046e\u0000\u0000\u1c76\u1c77\u0003"+ + "\u00c8d\u0000\u1c77\u1c78\u0005\u046f\u0000\u0000\u1c78\u1c8b\u0001\u0000"+ + "\u0000\u0000\u1c79\u1c7b\n\u0004\u0000\u0000\u1c7a\u1c7c\u0005s\u0000"+ + "\u0000\u1c7b\u1c7a\u0001\u0000\u0000\u0000\u1c7b\u1c7c\u0001\u0000\u0000"+ + "\u0000\u1c7c\u1c7d\u0001\u0000\u0000\u0000\u1c7d\u1c7e\u0005c\u0000\u0000"+ + "\u1c7e\u1c81\u0003\u02b2\u0159\u0000\u1c7f\u1c80\u0005\u019e\u0000\u0000"+ + "\u1c80\u1c82\u0005\u047d\u0000\u0000\u1c81\u1c7f\u0001\u0000\u0000\u0000"+ + "\u1c81\u1c82\u0001\u0000\u0000\u0000\u1c82\u1c8b\u0001\u0000\u0000\u0000"+ + "\u1c83\u1c84\n\u0002\u0000\u0000\u1c84\u1c85\u0005\u01fa\u0000\u0000\u1c85"+ + "\u1c86\u0005\u0216\u0000\u0000\u1c86\u1c87\u0005\u046e\u0000\u0000\u1c87"+ + "\u1c88\u0003\u02b2\u0159\u0000\u1c88\u1c89\u0005\u046f\u0000\u0000\u1c89"+ + "\u1c8b\u0001\u0000\u0000\u0000\u1c8a\u1c4c\u0001\u0000\u0000\u0000\u1c8a"+ + "\u1c50\u0001\u0000\u0000\u0000\u1c8a\u1c59\u0001\u0000\u0000\u0000\u1c8a"+ + "\u1c5d\u0001\u0000\u0000\u0000\u1c8a\u1c63\u0001\u0000\u0000\u0000\u1c8a"+ + "\u1c6f\u0001\u0000\u0000\u0000\u1c8a\u1c72\u0001\u0000\u0000\u0000\u1c8a"+ + "\u1c79\u0001\u0000\u0000\u0000\u1c8a\u1c83\u0001\u0000\u0000\u0000\u1c8b"+ + "\u1c8e\u0001\u0000\u0000\u0000\u1c8c\u1c8a\u0001\u0000\u0000\u0000\u1c8c"+ + "\u1c8d\u0001\u0000\u0000\u0000\u1c8d\u02b3\u0001\u0000\u0000\u0000\u1c8e"+ + "\u1c8c\u0001\u0000\u0000\u0000\u1c8f\u1c90\u0006\u015a\uffff\uffff\u0000"+ + "\u1c90\u1cc1\u0003\u025a\u012d\u0000\u1c91\u1cc1\u0003\u022c\u0116\u0000"+ + "\u1c92\u1cc1\u0003\u0288\u0144\u0000\u1c93\u1cc1\u0003\u0236\u011b\u0000"+ + "\u1c94\u1c95\u0003\u02b6\u015b\u0000\u1c95\u1c96\u0003\u02b4\u015a\r\u1c96"+ + "\u1cc1\u0001\u0000\u0000\u0000\u1c97\u1c98\u0005\u00e3\u0000\u0000\u1c98"+ + "\u1cc1\u0003\u02b4\u015a\f\u1c99\u1c9a\u0005\u0488\u0000\u0000\u1c9a\u1c9b"+ + "\u0005\u0455\u0000\u0000\u1c9b\u1cc1\u0003\u02b4\u015a\u000b\u1c9c\u1cc1"+ + "\u0005\u0001\u0000\u0000\u1c9d\u1c9e\u0005\u046e\u0000\u0000\u1c9e\u1ca3"+ + "\u0003\u02b0\u0158\u0000\u1c9f\u1ca0\u0005\u0470\u0000\u0000\u1ca0\u1ca2"+ + "\u0003\u02b0\u0158\u0000\u1ca1\u1c9f\u0001\u0000\u0000\u0000\u1ca2\u1ca5"+ + "\u0001\u0000\u0000\u0000\u1ca3\u1ca1\u0001\u0000\u0000\u0000\u1ca3\u1ca4"+ + "\u0001\u0000\u0000\u0000\u1ca4\u1ca6\u0001\u0000\u0000\u0000\u1ca5\u1ca3"+ + "\u0001\u0000\u0000\u0000\u1ca6\u1ca7\u0005\u046f\u0000\u0000\u1ca7\u1cc1"+ + "\u0001\u0000\u0000\u0000\u1ca8\u1ca9\u0005\u0259\u0000\u0000\u1ca9\u1caa"+ + "\u0005\u046e\u0000\u0000\u1caa\u1cad\u0003\u02b0\u0158\u0000\u1cab\u1cac"+ + "\u0005\u0470\u0000\u0000\u1cac\u1cae\u0003\u02b0\u0158\u0000\u1cad\u1cab"+ + "\u0001\u0000\u0000\u0000\u1cae\u1caf\u0001\u0000\u0000\u0000\u1caf\u1cad"+ + "\u0001\u0000\u0000\u0000\u1caf\u1cb0\u0001\u0000\u0000\u0000\u1cb0\u1cb1"+ + "\u0001\u0000\u0000\u0000\u1cb1\u1cb2\u0005\u046f\u0000\u0000\u1cb2\u1cc1"+ + "\u0001\u0000\u0000\u0000\u1cb3\u1cb4\u0005=\u0000\u0000\u1cb4\u1cb5\u0005"+ + "\u046e\u0000\u0000\u1cb5\u1cb6\u0003\u00c8d\u0000\u1cb6\u1cb7\u0005\u046f"+ + "\u0000\u0000\u1cb7\u1cc1\u0001\u0000\u0000\u0000\u1cb8\u1cb9\u0005\u046e"+ + "\u0000\u0000\u1cb9\u1cba\u0003\u00c8d\u0000\u1cba\u1cbb\u0005\u046f\u0000"+ + "\u0000\u1cbb\u1cc1\u0001\u0000\u0000\u0000\u1cbc\u1cbd\u0005W\u0000\u0000"+ + "\u1cbd\u1cbe\u0003\u02b0\u0158\u0000\u1cbe\u1cbf\u0003H$\u0000\u1cbf\u1cc1"+ + "\u0001\u0000\u0000\u0000\u1cc0\u1c8f\u0001\u0000\u0000\u0000\u1cc0\u1c91"+ + "\u0001\u0000\u0000\u0000\u1cc0\u1c92\u0001\u0000\u0000\u0000\u1cc0\u1c93"+ + "\u0001\u0000\u0000\u0000\u1cc0\u1c94\u0001\u0000\u0000\u0000\u1cc0\u1c97"+ + "\u0001\u0000\u0000\u0000\u1cc0\u1c99\u0001\u0000\u0000\u0000\u1cc0\u1c9c"+ + "\u0001\u0000\u0000\u0000\u1cc0\u1c9d\u0001\u0000\u0000\u0000\u1cc0\u1ca8"+ + "\u0001\u0000\u0000\u0000\u1cc0\u1cb3\u0001\u0000\u0000\u0000\u1cc0\u1cb8"+ + "\u0001\u0000\u0000\u0000\u1cc0\u1cbc\u0001\u0000\u0000\u0000\u1cc1\u1cd7"+ + "\u0001\u0000\u0000\u0000\u1cc2\u1cc3\n\u0004\u0000\u0000\u1cc3\u1cc4\u0003"+ + "\u02bc\u015e\u0000\u1cc4\u1cc5\u0003\u02b4\u015a\u0005\u1cc5\u1cd6\u0001"+ + "\u0000\u0000\u0000\u1cc6\u1cc7\n\u0003\u0000\u0000\u1cc7\u1cc8\u0003\u02be"+ + "\u015f\u0000\u1cc8\u1cc9\u0003\u02b4\u015a\u0004\u1cc9\u1cd6\u0001\u0000"+ + "\u0000\u0000\u1cca\u1ccb\n\u0002\u0000\u0000\u1ccb\u1ccc\u0003\u02c0\u0160"+ + "\u0000\u1ccc\u1ccd\u0003\u02b4\u015a\u0003\u1ccd\u1cd6\u0001\u0000\u0000"+ + "\u0000\u1cce\u1ccf\n\u0001\u0000\u0000\u1ccf\u1cd0\u0003\u02c2\u0161\u0000"+ + "\u1cd0\u1cd1\u0003\u02b4\u015a\u0002\u1cd1\u1cd6\u0001\u0000\u0000\u0000"+ + "\u1cd2\u1cd3\n\u000f\u0000\u0000\u1cd3\u1cd4\u0005\u001c\u0000\u0000\u1cd4"+ + "\u1cd6\u0003\u023a\u011d\u0000\u1cd5\u1cc2\u0001\u0000\u0000\u0000\u1cd5"+ + "\u1cc6\u0001\u0000\u0000\u0000\u1cd5\u1cca\u0001\u0000\u0000\u0000\u1cd5"+ + "\u1cce\u0001\u0000\u0000\u0000\u1cd5\u1cd2\u0001\u0000\u0000\u0000\u1cd6"+ + "\u1cd9\u0001\u0000\u0000\u0000\u1cd7\u1cd5\u0001\u0000\u0000\u0000\u1cd7"+ + "\u1cd8\u0001\u0000\u0000\u0000\u1cd8\u02b5\u0001\u0000\u0000\u0000\u1cd9"+ + "\u1cd7\u0001\u0000\u0000\u0000\u1cda\u1cdb\u0007\u0086\u0000\u0000\u1cdb"+ + "\u02b7\u0001\u0000\u0000\u0000\u1cdc\u1ceb\u0005\u0465\u0000\u0000\u1cdd"+ + "\u1ceb\u0005\u0466\u0000\u0000\u1cde\u1ceb\u0005\u0467\u0000\u0000\u1cdf"+ + "\u1ce0\u0005\u0467\u0000\u0000\u1ce0\u1ceb\u0005\u0465\u0000\u0000\u1ce1"+ + "\u1ce2\u0005\u0466\u0000\u0000\u1ce2\u1ceb\u0005\u0465\u0000\u0000\u1ce3"+ + "\u1ce4\u0005\u0467\u0000\u0000\u1ce4\u1ceb\u0005\u0466\u0000\u0000\u1ce5"+ + "\u1ce6\u0005\u0468\u0000\u0000\u1ce6\u1ceb\u0005\u0465\u0000\u0000\u1ce7"+ + "\u1ce8\u0005\u0467\u0000\u0000\u1ce8\u1ce9\u0005\u0465\u0000\u0000\u1ce9"+ + "\u1ceb\u0005\u0466\u0000\u0000\u1cea\u1cdc\u0001\u0000\u0000\u0000\u1cea"+ + "\u1cdd\u0001\u0000\u0000\u0000\u1cea\u1cde\u0001\u0000\u0000\u0000\u1cea"+ + "\u1cdf\u0001\u0000\u0000\u0000\u1cea\u1ce1\u0001\u0000\u0000\u0000\u1cea"+ + "\u1ce3\u0001\u0000\u0000\u0000\u1cea\u1ce5\u0001\u0000\u0000\u0000\u1cea"+ + "\u1ce7\u0001\u0000\u0000\u0000\u1ceb\u02b9\u0001\u0000\u0000\u0000\u1cec"+ + "\u1cf4\u0005\u000b\u0000\u0000\u1ced\u1cee\u0005\u046b\u0000\u0000\u1cee"+ + "\u1cf4\u0005\u046b\u0000\u0000\u1cef\u1cf4\u0005\u00c3\u0000\u0000\u1cf0"+ + "\u1cf4\u0005|\u0000\u0000\u1cf1\u1cf2\u0005\u046a\u0000\u0000\u1cf2\u1cf4"+ + "\u0005\u046a\u0000\u0000\u1cf3\u1cec\u0001\u0000\u0000\u0000\u1cf3\u1ced"+ + "\u0001\u0000\u0000\u0000\u1cf3\u1cef\u0001\u0000\u0000\u0000\u1cf3\u1cf0"+ + "\u0001\u0000\u0000\u0000\u1cf3\u1cf1\u0001\u0000\u0000\u0000\u1cf4\u02bb"+ + "\u0001\u0000\u0000\u0000\u1cf5\u1cf6\u0005\u0467\u0000\u0000\u1cf6\u1cfd"+ + "\u0005\u0467\u0000\u0000\u1cf7\u1cf8\u0005\u0466\u0000\u0000\u1cf8\u1cfd"+ + "\u0005\u0466\u0000\u0000\u1cf9\u1cfd\u0005\u046b\u0000\u0000\u1cfa\u1cfd"+ + "\u0005\u046c\u0000\u0000\u1cfb\u1cfd\u0005\u046a\u0000\u0000\u1cfc\u1cf5"+ + "\u0001\u0000\u0000\u0000\u1cfc\u1cf7\u0001\u0000\u0000\u0000\u1cfc\u1cf9"+ + "\u0001\u0000\u0000\u0000\u1cfc\u1cfa\u0001\u0000\u0000\u0000\u1cfc\u1cfb"+ + "\u0001\u0000\u0000\u0000\u1cfd\u02bd\u0001\u0000\u0000\u0000\u1cfe\u1cff"+ + "\u0007\u0087\u0000\u0000\u1cff\u02bf\u0001\u0000\u0000\u0000\u1d00\u1d01"+ + "\u0007\u0088\u0000\u0000\u1d01\u02c1\u0001\u0000\u0000\u0000\u1d02\u1d03"+ + "\u0005\u0462\u0000\u0000\u1d03\u1d08\u0005\u0466\u0000\u0000\u1d04\u1d05"+ + "\u0005\u0462\u0000\u0000\u1d05\u1d06\u0005\u0466\u0000\u0000\u1d06\u1d08"+ + "\u0005\u0466\u0000\u0000\u1d07\u1d02\u0001\u0000\u0000\u0000\u1d07\u1d04"+ + "\u0001\u0000\u0000\u0000\u1d08\u02c3\u0001\u0000\u0000\u0000\u1d09\u1d0a"+ + "\u0007\u0089\u0000\u0000\u1d0a\u02c5\u0001\u0000\u0000\u0000\u1d0b\u1d0c"+ + "\u0007\u008a\u0000\u0000\u1d0c\u02c7\u0001\u0000\u0000\u0000\u1d0d\u1d0e"+ + "\u0007\u008b\u0000\u0000\u1d0e\u02c9\u0001\u0000\u0000\u0000\u1d0f\u1d10"+ + "\u0007\u008c\u0000\u0000\u1d10\u02cb\u0001\u0000\u0000\u0000\u1d11\u1d12"+ + "\u0007\u008d\u0000\u0000\u1d12\u02cd\u0001\u0000\u0000\u0000\u1d13\u1d14"+ + "\u0007\u008e\u0000\u0000\u1d14\u02cf\u0001\u0000\u0000\u0000\u1d15\u1d16"+ + "\u0007\u008f\u0000\u0000\u1d16\u02d1\u0001\u0000\u0000\u0000\u043e\u02d3"+ + "\u02d7\u02de\u02e1\u02e4\u02e6\u02ec\u02ef\u02f2\u02fb\u0325\u0334\u033f"+ + "\u0350\u0355\u0364\u037f\u0388\u038d\u0393\u0398\u039c\u03a5\u03a8\u03ab"+ + "\u03af\u03b6\u03b9\u03be\u03c6\u03cb\u03d0\u03d3\u03d5\u03e1\u03e4\u03e8"+ + "\u03eb\u03ef\u03f2\u03f6\u03f9\u03fc\u0400\u0403\u0407\u040d\u0413\u0419"+ + "\u0420\u0427\u042a\u042e\u0433\u0439\u0442\u0447\u044c\u0453\u0464\u046b"+ + "\u046f\u0479\u047d\u0481\u0485\u0489\u048e\u0491\u0494\u0497\u049a\u04a0"+ + "\u04a4\u04aa\u04af\u04b2\u04b5\u04b7\u04c2\u04c6\u04c9\u04d7\u04da\u04de"+ + "\u04e1\u04e5\u04e8\u04ec\u04ef\u04f3\u04f6\u04f9\u04fd\u0500\u0504\u050a"+ + "\u0517\u051d\u0528\u052d\u0535\u053d\u0542\u0545\u054a\u0552\u0557\u055d"+ + "\u0562\u0566\u0568\u056b\u056f\u0573\u0576\u057a\u057e\u0582\u0588\u058b"+ + "\u0592\u0597\u059d\u05a4\u05aa\u05b2\u05b5\u05bc\u05bf\u05c1\u05c7\u05cd"+ + "\u05de\u05e5\u05ec\u05f8\u05fd\u0600\u0603\u0610\u061d\u0622\u0632\u063a"+ + "\u0644\u0647\u064a\u0650\u0654\u0657\u0662\u0665\u066a\u0677\u067e\u0685"+ + "\u0687\u068e\u0692\u0694\u0699\u069c\u06a2\u06a7\u06a9\u06ad\u06b0\u06b3"+ + "\u06b9\u06be\u06c0\u06c5\u06cc\u06ce\u06d5\u06da\u06de\u06e1\u06e9\u06f1"+ + "\u06f3\u06fd\u0701\u0704\u070a\u070f\u0712\u0718\u071b\u071f\u0722\u0726"+ + "\u072b\u0730\u0735\u0739\u073d\u0741\u0745\u0749\u074d\u0752\u0757\u075c"+ + "\u0762\u0767\u076c\u0771\u0776\u077b\u0781\u0786\u078b\u0790\u0795\u079a"+ + "\u079f\u07a4\u07ab\u07b0\u07b5\u07ba\u07be\u07c3\u07cb\u07d0\u07d6\u07e2"+ + "\u07e9\u07eb\u07f3\u07f8\u07fb\u0803\u0809\u080d\u081a\u0826\u0828\u082b"+ + "\u0833\u0839\u083f\u084c\u0853\u085c\u0861\u086c\u0875\u087a\u0886\u088d"+ + "\u0896\u089b\u08a7\u08ae\u08b7\u08bc\u08c3\u08cc\u08d1\u08d3\u08d8\u08e0"+ + "\u08e9\u08ed\u08f0\u08f4\u08f9\u08ff\u0905\u090a\u090f\u0914\u0919\u091c"+ + "\u0921\u0926\u0930\u0934\u093b\u0940\u0943\u0948\u094b\u094f\u0953\u095b"+ + "\u096e\u0971\u0974\u0978\u0982\u098f\u0996\u0999\u099e\u09a5\u09a8\u09ab"+ + "\u09b6\u09b9\u09bd\u09c5\u09c8\u09cd\u09d5\u09db\u09df\u09e3\u09e8\u09ed"+ + "\u09f4\u09f8\u0a03\u0a0b\u0a0e\u0a14\u0a1a\u0a1c\u0a21\u0a24\u0a2a\u0a30"+ + "\u0a32\u0a36\u0a39\u0a3c\u0a42\u0a48\u0a4b\u0a51\u0a57\u0a59\u0a5e\u0a66"+ + "\u0a68\u0a71\u0a74\u0a77\u0a7c\u0a7e\u0a87\u0a8a\u0a8d\u0a92\u0a94\u0a9d"+ + "\u0aa2\u0aaa\u0aae\u0ab6\u0ac0\u0ac5\u0acc\u0ad0\u0ad4\u0ae7\u0af1\u0af7"+ + "\u0b08\u0b0c\u0b16\u0b1b\u0b1e\u0b27\u0b32\u0b3a\u0b40\u0b4a\u0b56\u0b5d"+ + "\u0b64\u0b73\u0b80\u0b86\u0b8c\u0b92\u0b98\u0b9e\u0ba4\u0ba9\u0bb0\u0bb7"+ + "\u0bbe\u0bc3\u0bc6\u0bc8\u0bd6\u0bdd\u0be4\u0bea\u0bee\u0bf2\u0bf9\u0bfc"+ + "\u0c01\u0c08\u0c0f\u0c13\u0c18\u0c1f\u0c2c\u0c2f\u0c34\u0c39\u0c3d\u0c43"+ + "\u0c4c\u0c55\u0c5e\u0c61\u0c65\u0c6e\u0c72\u0c75\u0c78\u0c7e\u0c81\u0c85"+ + "\u0c88\u0c8c\u0c8f\u0c97\u0c9a\u0ca5\u0ca8\u0cad\u0cb0\u0cb5\u0cbf\u0cc4"+ + "\u0cca\u0ccc\u0cd2\u0cd4\u0cda\u0ce2\u0ce7\u0cef\u0cf2\u0cf7\u0cfa\u0cff"+ + "\u0d07\u0d0f\u0d15\u0d1d\u0d22\u0d2a\u0d2d\u0d31\u0d34\u0d3c\u0d42\u0d4b"+ + "\u0d4e\u0d52\u0d56\u0d5a\u0d5f\u0d63\u0d67\u0d69\u0d6c\u0d6f\u0d72\u0d78"+ + "\u0d7c\u0d7f\u0d82\u0d85\u0d88\u0d8f\u0d91\u0d95\u0d9a\u0da0\u0da5\u0dac"+ + "\u0db2\u0db7\u0dba\u0dc0\u0dc4\u0dcc\u0dd0\u0dd3\u0dd6\u0ddb\u0dde\u0de5"+ + "\u0de9\u0dec\u0df0\u0df4\u0df7\u0dfa\u0dff\u0e05\u0e09\u0e13\u0e19\u0e1d"+ + "\u0e23\u0e27\u0e2d\u0e30\u0e3c\u0e40\u0e44\u0e4c\u0e50\u0e58\u0e5b\u0e5f"+ + "\u0e62\u0e6a\u0e6f\u0e72\u0e75\u0e79\u0e7c\u0e85\u0e8a\u0e93\u0e98\u0e9f"+ + "\u0ea6\u0eae\u0eb4\u0ebc\u0ebf\u0ec2\u0ec9\u0ecc\u0ed3\u0ed6\u0ede\u0ee4"+ + "\u0eef\u0ef2\u0ef6\u0efc\u0f05\u0f0a\u0f0e\u0f14\u0f1a\u0f1c\u0f20\u0f29"+ + "\u0f33\u0f3d\u0f43\u0f48\u0f4c\u0f4f\u0f52\u0f55\u0f58\u0f5e\u0f64\u0f67"+ + "\u0f6a\u0f6d\u0f70\u0f73\u0f75\u0f7b\u0f81\u0f84\u0f87\u0f8a\u0f8d\u0f90"+ + "\u0f94\u0f9a\u0f9e\u0fa6\u0faa\u0fad\u0faf\u0fbc\u0fbf\u0fc6\u0fd0\u0fd3"+ + "\u0fd8\u0fda\u0fde\u0fe6\u0fec\u0ff5\u1002\u1006\u100c\u1015\u1018\u101c"+ + "\u101f\u1023\u1027\u102a\u102c\u1034\u1040\u1046\u1048\u104e\u1050\u1052"+ + "\u1058\u1060\u1068\u106c\u1070\u1079\u107e\u1092\u1097\u109d\u10a4\u10a9"+ + "\u10b2\u10b5\u10b9\u10bd\u10c1\u10c4\u10c7\u10ca\u10ce\u10d2\u10d5\u10d8"+ + "\u10db\u10e2\u10e6\u10f5\u10f9\u1105\u110d\u1117\u111b\u111e\u1124\u1127"+ + "\u112a\u1133\u113c\u1146\u114a\u1154\u115e\u1166\u1169\u1172\u1175\u1179"+ + "\u117e\u1182\u118b\u118e\u11ad\u11b0\u11b3\u11eb\u11f0\u120c\u121a\u1221"+ + "\u1225\u122b\u1233\u1235\u1240\u124a\u1251\u1257\u125f\u1264\u126c\u1274"+ + "\u127c\u1284\u128a\u128f\u1294\u1299\u129f\u12a1\u12ac\u12b1\u12b8\u12ba"+ + "\u12c8\u12ce\u12d3\u12d8\u12de\u12e5\u12ed\u12f5\u12fa\u1300\u1303\u130b"+ + "\u1312\u131b\u131e\u132f\u1337\u133f\u1343\u134a\u1350\u1358\u1361\u1367"+ + "\u136e\u1375\u137a\u137d\u137f\u1385\u1387\u138b\u138d\u1394\u1399\u139d"+ + "\u13a3\u13ac\u13b2\u13b9\u13bf\u13c5\u13ca\u13cd\u13cf\u13d5\u13d7\u13db"+ + "\u13dd\u13e4\u13e6\u13eb\u13f2\u13fb\u1400\u1409\u1410\u1415\u1418\u141a"+ + "\u1420\u1422\u1425\u142d\u1432\u1437\u143b\u1441\u1446\u144a\u1450\u1452"+ + "\u145d\u1460\u1467\u146a\u1476\u147c\u1485\u148e\u1493\u149c\u14a2\u14ad"+ + "\u14b3\u14b8\u14bc\u14c2\u14c7\u14cb\u14ce\u14da\u14e1\u14e6\u1504\u1508"+ + "\u150d\u1514\u1517\u151d\u1527\u1531\u153b\u1541\u154a\u1550\u1557\u1559"+ + "\u1563\u1567\u156b\u1575\u157a\u15c2\u15d4\u15dc\u15e8\u15ef\u15f1\u15fb"+ + "\u15fe\u1606\u160d\u1611\u1618\u161d\u1620\u1623\u162c\u1630\u1634\u164b"+ + "\u1652\u1656\u165d\u1664\u1667\u1677\u167a\u1684\u1688\u168e\u1691\u1696"+ + "\u169a\u16a1\u16a4\u16aa\u16c2\u16c5\u16d1\u16d4\u16de\u16e6\u16ea\u16f1"+ + "\u16f4\u16fd\u1703\u1709\u1713\u1715\u171b\u171e\u1721\u172d\u1730\u1736"+ + "\u1739\u1741\u1749\u174f\u1753\u1761\u176d\u1774\u1777\u177e\u1785\u178a"+ + "\u1797\u17a2\u17a8\u17ad\u17ba\u17bc\u17c1\u17c5\u17c8\u17ca\u17d1\u17d8"+ + "\u17db\u17de\u17e4\u17e8\u17ee\u17f4\u1801\u1806\u180e\u1811\u1816\u181b"+ + "\u1823\u1826\u182e\u1832\u1839\u183f\u1842\u1846\u1853\u1859\u1865\u1868"+ + "\u1871\u1876\u187c\u1882\u1887\u1889\u188c\u1890\u1892\u1896\u189c\u189f"+ + "\u18a2\u18a8\u18b1\u18b9\u18bd\u18c2\u18d6\u18dd\u18df\u18e6\u18e8\u18ec"+ + "\u18f1\u18fc\u1901\u1907\u190a\u190e\u1913\u1916\u191a\u191e\u1920\u1925"+ + "\u192a\u1937\u193a\u193e\u1941\u1944\u1949\u194e\u1954\u1957\u195c\u195f"+ + "\u1964\u1967\u196b\u1970\u1975\u197a\u197f\u1982\u1987\u198c\u1991\u1997"+ + "\u199c\u19a1\u19a6\u19aa\u19ad\u19b2\u19b6\u19ba\u19c2\u19c9\u19cd\u19d2"+ + "\u19d7\u19db\u19dd\u19e0\u19f0\u19f9\u1a01\u1a09\u1a12\u1a1c\u1a24\u1a2c"+ + "\u1a34\u1a3c\u1a48\u1a4f\u1a59\u1a5e\u1a61\u1a66\u1a69\u1a6d\u1a7c\u1a84"+ + "\u1a8b\u1a90\u1a95\u1ab7\u1abb\u1ac3\u1ac7\u1ad0\u1ad8\u1add\u1ae5\u1aea"+ + "\u1aef\u1af1\u1afa\u1aff\u1b07\u1b0c\u1b14\u1b1c\u1b1f\u1b29\u1b3b\u1b3e"+ + "\u1b41\u1b45\u1b52\u1b5a\u1b5e\u1b63\u1b68\u1b6e\u1b73\u1b77\u1b7c\u1b81"+ + "\u1b86\u1b90\u1b93\u1b97\u1b9b\u1ba2\u1ba6\u1bc3\u1bcb\u1bce\u1bd1\u1bd4"+ + "\u1bd7\u1be2\u1bf0\u1bf9\u1c14\u1c1f\u1c26\u1c2a\u1c31\u1c39\u1c3e\u1c46"+ + "\u1c52\u1c5f\u1c65\u1c6b\u1c7b\u1c81\u1c8a\u1c8c\u1ca3\u1caf\u1cc0\u1cd5"+ + "\u1cd7\u1cea\u1cf3\u1cfc\u1d07"; + public static final String _serializedATN = Utils.join( + new String[] { + _serializedATNSegment0, + _serializedATNSegment1, + _serializedATNSegment2, + _serializedATNSegment3 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParserBaseListener.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParserBaseListener.java new file mode 100644 index 000000000..4967efaaa --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParserBaseListener.java @@ -0,0 +1,7468 @@ +// Generated from MySqlParser.g4 by ANTLR 4.13.1 +package org.springframework.ide.vscode.parser.sql; + +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link MySqlParserListener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +@SuppressWarnings("CheckReturnValue") +public class MySqlParserBaseListener implements MySqlParserListener { + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoot(MySqlParser.RootContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoot(MySqlParser.RootContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSqlStatements(MySqlParser.SqlStatementsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSqlStatements(MySqlParser.SqlStatementsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSqlStatement(MySqlParser.SqlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSqlStatement(MySqlParser.SqlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEmptyStatement_(MySqlParser.EmptyStatement_Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEmptyStatement_(MySqlParser.EmptyStatement_Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDdlStatement(MySqlParser.DdlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDdlStatement(MySqlParser.DdlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDmlStatement(MySqlParser.DmlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDmlStatement(MySqlParser.DmlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransactionStatement(MySqlParser.TransactionStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransactionStatement(MySqlParser.TransactionStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReplicationStatement(MySqlParser.ReplicationStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReplicationStatement(MySqlParser.ReplicationStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPreparedStatement(MySqlParser.PreparedStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPreparedStatement(MySqlParser.PreparedStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCompoundStatement(MySqlParser.CompoundStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCompoundStatement(MySqlParser.CompoundStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAdministrationStatement(MySqlParser.AdministrationStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAdministrationStatement(MySqlParser.AdministrationStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUtilityStatement(MySqlParser.UtilityStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUtilityStatement(MySqlParser.UtilityStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateDatabase(MySqlParser.CreateDatabaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateDatabase(MySqlParser.CreateDatabaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateEvent(MySqlParser.CreateEventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateEvent(MySqlParser.CreateEventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateIndex(MySqlParser.CreateIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateIndex(MySqlParser.CreateIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateLogfileGroup(MySqlParser.CreateLogfileGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateLogfileGroup(MySqlParser.CreateLogfileGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateProcedure(MySqlParser.CreateProcedureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateProcedure(MySqlParser.CreateProcedureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateFunction(MySqlParser.CreateFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateFunction(MySqlParser.CreateFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateRole(MySqlParser.CreateRoleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateRole(MySqlParser.CreateRoleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateServer(MySqlParser.CreateServerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateServer(MySqlParser.CreateServerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCopyCreateTable(MySqlParser.CopyCreateTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCopyCreateTable(MySqlParser.CopyCreateTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQueryCreateTable(MySqlParser.QueryCreateTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQueryCreateTable(MySqlParser.QueryCreateTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumnCreateTable(MySqlParser.ColumnCreateTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumnCreateTable(MySqlParser.ColumnCreateTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateTablespaceInnodb(MySqlParser.CreateTablespaceInnodbContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateTablespaceInnodb(MySqlParser.CreateTablespaceInnodbContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateTablespaceNdb(MySqlParser.CreateTablespaceNdbContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateTablespaceNdb(MySqlParser.CreateTablespaceNdbContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateTrigger(MySqlParser.CreateTriggerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateTrigger(MySqlParser.CreateTriggerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWithClause(MySqlParser.WithClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWithClause(MySqlParser.WithClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCommonTableExpressions(MySqlParser.CommonTableExpressionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCommonTableExpressions(MySqlParser.CommonTableExpressionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCteName(MySqlParser.CteNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCteName(MySqlParser.CteNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCteColumnName(MySqlParser.CteColumnNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCteColumnName(MySqlParser.CteColumnNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateView(MySqlParser.CreateViewContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateView(MySqlParser.CreateViewContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateDatabaseOption(MySqlParser.CreateDatabaseOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateDatabaseOption(MySqlParser.CreateDatabaseOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCharSet(MySqlParser.CharSetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCharSet(MySqlParser.CharSetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCurrentUserExpression(MySqlParser.CurrentUserExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCurrentUserExpression(MySqlParser.CurrentUserExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOwnerStatement(MySqlParser.OwnerStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOwnerStatement(MySqlParser.OwnerStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPreciseSchedule(MySqlParser.PreciseScheduleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPreciseSchedule(MySqlParser.PreciseScheduleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIntervalSchedule(MySqlParser.IntervalScheduleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIntervalSchedule(MySqlParser.IntervalScheduleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTimestampValue(MySqlParser.TimestampValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTimestampValue(MySqlParser.TimestampValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIntervalExpr(MySqlParser.IntervalExprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIntervalExpr(MySqlParser.IntervalExprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIntervalType(MySqlParser.IntervalTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIntervalType(MySqlParser.IntervalTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnableType(MySqlParser.EnableTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnableType(MySqlParser.EnableTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexType(MySqlParser.IndexTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexType(MySqlParser.IndexTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexOption(MySqlParser.IndexOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexOption(MySqlParser.IndexOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProcedureParameter(MySqlParser.ProcedureParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProcedureParameter(MySqlParser.ProcedureParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionParameter(MySqlParser.FunctionParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionParameter(MySqlParser.FunctionParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoutineComment(MySqlParser.RoutineCommentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoutineComment(MySqlParser.RoutineCommentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoutineLanguage(MySqlParser.RoutineLanguageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoutineLanguage(MySqlParser.RoutineLanguageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoutineBehavior(MySqlParser.RoutineBehaviorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoutineBehavior(MySqlParser.RoutineBehaviorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoutineData(MySqlParser.RoutineDataContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoutineData(MySqlParser.RoutineDataContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoutineSecurity(MySqlParser.RoutineSecurityContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoutineSecurity(MySqlParser.RoutineSecurityContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterServerOption(MySqlParser.ServerOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitServerOption(MySqlParser.ServerOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateDefinitions(MySqlParser.CreateDefinitionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateDefinitions(MySqlParser.CreateDefinitionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumnDeclaration(MySqlParser.ColumnDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumnDeclaration(MySqlParser.ColumnDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstraintDeclaration(MySqlParser.ConstraintDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstraintDeclaration(MySqlParser.ConstraintDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexDeclaration(MySqlParser.IndexDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexDeclaration(MySqlParser.IndexDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumnDefinition(MySqlParser.ColumnDefinitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumnDefinition(MySqlParser.ColumnDefinitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNullColumnConstraint(MySqlParser.NullColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNullColumnConstraint(MySqlParser.NullColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefaultColumnConstraint(MySqlParser.DefaultColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefaultColumnConstraint(MySqlParser.DefaultColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVisibilityColumnConstraint(MySqlParser.VisibilityColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVisibilityColumnConstraint(MySqlParser.VisibilityColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInvisibilityColumnConstraint(MySqlParser.InvisibilityColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInvisibilityColumnConstraint(MySqlParser.InvisibilityColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAutoIncrementColumnConstraint(MySqlParser.AutoIncrementColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAutoIncrementColumnConstraint(MySqlParser.AutoIncrementColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrimaryKeyColumnConstraint(MySqlParser.PrimaryKeyColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrimaryKeyColumnConstraint(MySqlParser.PrimaryKeyColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUniqueKeyColumnConstraint(MySqlParser.UniqueKeyColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUniqueKeyColumnConstraint(MySqlParser.UniqueKeyColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCommentColumnConstraint(MySqlParser.CommentColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCommentColumnConstraint(MySqlParser.CommentColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFormatColumnConstraint(MySqlParser.FormatColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFormatColumnConstraint(MySqlParser.FormatColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStorageColumnConstraint(MySqlParser.StorageColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStorageColumnConstraint(MySqlParser.StorageColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReferenceColumnConstraint(MySqlParser.ReferenceColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReferenceColumnConstraint(MySqlParser.ReferenceColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCollateColumnConstraint(MySqlParser.CollateColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCollateColumnConstraint(MySqlParser.CollateColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGeneratedColumnConstraint(MySqlParser.GeneratedColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGeneratedColumnConstraint(MySqlParser.GeneratedColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSerialDefaultColumnConstraint(MySqlParser.SerialDefaultColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSerialDefaultColumnConstraint(MySqlParser.SerialDefaultColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCheckColumnConstraint(MySqlParser.CheckColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCheckColumnConstraint(MySqlParser.CheckColumnConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrimaryKeyTableConstraint(MySqlParser.PrimaryKeyTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrimaryKeyTableConstraint(MySqlParser.PrimaryKeyTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUniqueKeyTableConstraint(MySqlParser.UniqueKeyTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUniqueKeyTableConstraint(MySqlParser.UniqueKeyTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForeignKeyTableConstraint(MySqlParser.ForeignKeyTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForeignKeyTableConstraint(MySqlParser.ForeignKeyTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCheckTableConstraint(MySqlParser.CheckTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCheckTableConstraint(MySqlParser.CheckTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReferenceDefinition(MySqlParser.ReferenceDefinitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReferenceDefinition(MySqlParser.ReferenceDefinitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReferenceAction(MySqlParser.ReferenceActionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReferenceAction(MySqlParser.ReferenceActionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReferenceControlType(MySqlParser.ReferenceControlTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReferenceControlType(MySqlParser.ReferenceControlTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleIndexDeclaration(MySqlParser.SimpleIndexDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleIndexDeclaration(MySqlParser.SimpleIndexDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSpecialIndexDeclaration(MySqlParser.SpecialIndexDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSpecialIndexDeclaration(MySqlParser.SpecialIndexDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionEngine(MySqlParser.TableOptionEngineContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionEngine(MySqlParser.TableOptionEngineContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionEngineAttribute(MySqlParser.TableOptionEngineAttributeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionEngineAttribute(MySqlParser.TableOptionEngineAttributeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionAutoextendSize(MySqlParser.TableOptionAutoextendSizeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionAutoextendSize(MySqlParser.TableOptionAutoextendSizeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionAutoIncrement(MySqlParser.TableOptionAutoIncrementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionAutoIncrement(MySqlParser.TableOptionAutoIncrementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionAverage(MySqlParser.TableOptionAverageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionAverage(MySqlParser.TableOptionAverageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionCharset(MySqlParser.TableOptionCharsetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionCharset(MySqlParser.TableOptionCharsetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionChecksum(MySqlParser.TableOptionChecksumContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionChecksum(MySqlParser.TableOptionChecksumContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionCollate(MySqlParser.TableOptionCollateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionCollate(MySqlParser.TableOptionCollateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionComment(MySqlParser.TableOptionCommentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionComment(MySqlParser.TableOptionCommentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionCompression(MySqlParser.TableOptionCompressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionCompression(MySqlParser.TableOptionCompressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionConnection(MySqlParser.TableOptionConnectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionConnection(MySqlParser.TableOptionConnectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionDataDirectory(MySqlParser.TableOptionDataDirectoryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionDataDirectory(MySqlParser.TableOptionDataDirectoryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionDelay(MySqlParser.TableOptionDelayContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionDelay(MySqlParser.TableOptionDelayContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionEncryption(MySqlParser.TableOptionEncryptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionEncryption(MySqlParser.TableOptionEncryptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionPageCompressed(MySqlParser.TableOptionPageCompressedContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionPageCompressed(MySqlParser.TableOptionPageCompressedContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionPageCompressionLevel(MySqlParser.TableOptionPageCompressionLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionPageCompressionLevel(MySqlParser.TableOptionPageCompressionLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionEncryptionKeyId(MySqlParser.TableOptionEncryptionKeyIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionEncryptionKeyId(MySqlParser.TableOptionEncryptionKeyIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionIndexDirectory(MySqlParser.TableOptionIndexDirectoryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionIndexDirectory(MySqlParser.TableOptionIndexDirectoryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionInsertMethod(MySqlParser.TableOptionInsertMethodContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionInsertMethod(MySqlParser.TableOptionInsertMethodContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionKeyBlockSize(MySqlParser.TableOptionKeyBlockSizeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionKeyBlockSize(MySqlParser.TableOptionKeyBlockSizeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionMaxRows(MySqlParser.TableOptionMaxRowsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionMaxRows(MySqlParser.TableOptionMaxRowsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionMinRows(MySqlParser.TableOptionMinRowsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionMinRows(MySqlParser.TableOptionMinRowsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionPackKeys(MySqlParser.TableOptionPackKeysContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionPackKeys(MySqlParser.TableOptionPackKeysContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionPassword(MySqlParser.TableOptionPasswordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionPassword(MySqlParser.TableOptionPasswordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionRowFormat(MySqlParser.TableOptionRowFormatContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionRowFormat(MySqlParser.TableOptionRowFormatContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionStartTransaction(MySqlParser.TableOptionStartTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionStartTransaction(MySqlParser.TableOptionStartTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionSecondaryEngineAttribute(MySqlParser.TableOptionSecondaryEngineAttributeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionSecondaryEngineAttribute(MySqlParser.TableOptionSecondaryEngineAttributeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionRecalculation(MySqlParser.TableOptionRecalculationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionRecalculation(MySqlParser.TableOptionRecalculationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionPersistent(MySqlParser.TableOptionPersistentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionPersistent(MySqlParser.TableOptionPersistentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionSamplePage(MySqlParser.TableOptionSamplePageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionSamplePage(MySqlParser.TableOptionSamplePageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionTablespace(MySqlParser.TableOptionTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionTablespace(MySqlParser.TableOptionTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionTableType(MySqlParser.TableOptionTableTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionTableType(MySqlParser.TableOptionTableTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionTransactional(MySqlParser.TableOptionTransactionalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionTransactional(MySqlParser.TableOptionTransactionalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableOptionUnion(MySqlParser.TableOptionUnionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableOptionUnion(MySqlParser.TableOptionUnionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableType(MySqlParser.TableTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableType(MySqlParser.TableTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTablespaceStorage(MySqlParser.TablespaceStorageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTablespaceStorage(MySqlParser.TablespaceStorageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionDefinitions(MySqlParser.PartitionDefinitionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionDefinitions(MySqlParser.PartitionDefinitionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionFunctionHash(MySqlParser.PartitionFunctionHashContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionFunctionHash(MySqlParser.PartitionFunctionHashContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionFunctionKey(MySqlParser.PartitionFunctionKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionFunctionKey(MySqlParser.PartitionFunctionKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionFunctionRange(MySqlParser.PartitionFunctionRangeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionFunctionRange(MySqlParser.PartitionFunctionRangeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionFunctionList(MySqlParser.PartitionFunctionListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionFunctionList(MySqlParser.PartitionFunctionListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubPartitionFunctionHash(MySqlParser.SubPartitionFunctionHashContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubPartitionFunctionHash(MySqlParser.SubPartitionFunctionHashContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubPartitionFunctionKey(MySqlParser.SubPartitionFunctionKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubPartitionFunctionKey(MySqlParser.SubPartitionFunctionKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionComparison(MySqlParser.PartitionComparisonContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionComparison(MySqlParser.PartitionComparisonContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionListAtom(MySqlParser.PartitionListAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionListAtom(MySqlParser.PartitionListAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionListVector(MySqlParser.PartitionListVectorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionListVector(MySqlParser.PartitionListVectorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionSimple(MySqlParser.PartitionSimpleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionSimple(MySqlParser.PartitionSimpleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionDefinerAtom(MySqlParser.PartitionDefinerAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionDefinerAtom(MySqlParser.PartitionDefinerAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionDefinerVector(MySqlParser.PartitionDefinerVectorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionDefinerVector(MySqlParser.PartitionDefinerVectorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubpartitionDefinition(MySqlParser.SubpartitionDefinitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubpartitionDefinition(MySqlParser.SubpartitionDefinitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionOptionEngine(MySqlParser.PartitionOptionEngineContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionOptionEngine(MySqlParser.PartitionOptionEngineContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionOptionComment(MySqlParser.PartitionOptionCommentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionOptionComment(MySqlParser.PartitionOptionCommentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionOptionDataDirectory(MySqlParser.PartitionOptionDataDirectoryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionOptionDataDirectory(MySqlParser.PartitionOptionDataDirectoryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionOptionIndexDirectory(MySqlParser.PartitionOptionIndexDirectoryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionOptionIndexDirectory(MySqlParser.PartitionOptionIndexDirectoryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionOptionMaxRows(MySqlParser.PartitionOptionMaxRowsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionOptionMaxRows(MySqlParser.PartitionOptionMaxRowsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionOptionMinRows(MySqlParser.PartitionOptionMinRowsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionOptionMinRows(MySqlParser.PartitionOptionMinRowsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionOptionTablespace(MySqlParser.PartitionOptionTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionOptionTablespace(MySqlParser.PartitionOptionTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionOptionNodeGroup(MySqlParser.PartitionOptionNodeGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionOptionNodeGroup(MySqlParser.PartitionOptionNodeGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterSimpleDatabase(MySqlParser.AlterSimpleDatabaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterSimpleDatabase(MySqlParser.AlterSimpleDatabaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterUpgradeName(MySqlParser.AlterUpgradeNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterUpgradeName(MySqlParser.AlterUpgradeNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterEvent(MySqlParser.AlterEventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterEvent(MySqlParser.AlterEventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterFunction(MySqlParser.AlterFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterFunction(MySqlParser.AlterFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterInstance(MySqlParser.AlterInstanceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterInstance(MySqlParser.AlterInstanceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterLogfileGroup(MySqlParser.AlterLogfileGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterLogfileGroup(MySqlParser.AlterLogfileGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterProcedure(MySqlParser.AlterProcedureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterProcedure(MySqlParser.AlterProcedureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterServer(MySqlParser.AlterServerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterServer(MySqlParser.AlterServerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterTable(MySqlParser.AlterTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterTable(MySqlParser.AlterTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterTablespace(MySqlParser.AlterTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterTablespace(MySqlParser.AlterTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterView(MySqlParser.AlterViewContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterView(MySqlParser.AlterViewContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByTableOption(MySqlParser.AlterByTableOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByTableOption(MySqlParser.AlterByTableOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddColumn(MySqlParser.AlterByAddColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddColumn(MySqlParser.AlterByAddColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddIndex(MySqlParser.AlterByAddIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddIndex(MySqlParser.AlterByAddIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddPrimaryKey(MySqlParser.AlterByAddPrimaryKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddPrimaryKey(MySqlParser.AlterByAddPrimaryKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddUniqueKey(MySqlParser.AlterByAddUniqueKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddUniqueKey(MySqlParser.AlterByAddUniqueKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddSpecialIndex(MySqlParser.AlterByAddSpecialIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddSpecialIndex(MySqlParser.AlterByAddSpecialIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddForeignKey(MySqlParser.AlterByAddForeignKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddForeignKey(MySqlParser.AlterByAddForeignKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddCheckTableConstraint(MySqlParser.AlterByAddCheckTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddCheckTableConstraint(MySqlParser.AlterByAddCheckTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAlterCheckTableConstraint(MySqlParser.AlterByAlterCheckTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAlterCheckTableConstraint(MySqlParser.AlterByAlterCheckTableConstraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterBySetAlgorithm(MySqlParser.AlterBySetAlgorithmContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterBySetAlgorithm(MySqlParser.AlterBySetAlgorithmContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByChangeDefault(MySqlParser.AlterByChangeDefaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByChangeDefault(MySqlParser.AlterByChangeDefaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByChangeColumn(MySqlParser.AlterByChangeColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByChangeColumn(MySqlParser.AlterByChangeColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByRenameColumn(MySqlParser.AlterByRenameColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByRenameColumn(MySqlParser.AlterByRenameColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByLock(MySqlParser.AlterByLockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByLock(MySqlParser.AlterByLockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByModifyColumn(MySqlParser.AlterByModifyColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByModifyColumn(MySqlParser.AlterByModifyColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDropColumn(MySqlParser.AlterByDropColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDropColumn(MySqlParser.AlterByDropColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDropConstraintCheck(MySqlParser.AlterByDropConstraintCheckContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDropConstraintCheck(MySqlParser.AlterByDropConstraintCheckContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDropPrimaryKey(MySqlParser.AlterByDropPrimaryKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDropPrimaryKey(MySqlParser.AlterByDropPrimaryKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDropIndex(MySqlParser.AlterByDropIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDropIndex(MySqlParser.AlterByDropIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByRenameIndex(MySqlParser.AlterByRenameIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByRenameIndex(MySqlParser.AlterByRenameIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAlterColumnDefault(MySqlParser.AlterByAlterColumnDefaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAlterColumnDefault(MySqlParser.AlterByAlterColumnDefaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAlterIndexVisibility(MySqlParser.AlterByAlterIndexVisibilityContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAlterIndexVisibility(MySqlParser.AlterByAlterIndexVisibilityContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDropForeignKey(MySqlParser.AlterByDropForeignKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDropForeignKey(MySqlParser.AlterByDropForeignKeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDisableKeys(MySqlParser.AlterByDisableKeysContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDisableKeys(MySqlParser.AlterByDisableKeysContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByEnableKeys(MySqlParser.AlterByEnableKeysContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByEnableKeys(MySqlParser.AlterByEnableKeysContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByRename(MySqlParser.AlterByRenameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByRename(MySqlParser.AlterByRenameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByOrder(MySqlParser.AlterByOrderContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByOrder(MySqlParser.AlterByOrderContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByConvertCharset(MySqlParser.AlterByConvertCharsetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByConvertCharset(MySqlParser.AlterByConvertCharsetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDefaultCharset(MySqlParser.AlterByDefaultCharsetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDefaultCharset(MySqlParser.AlterByDefaultCharsetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDiscardTablespace(MySqlParser.AlterByDiscardTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDiscardTablespace(MySqlParser.AlterByDiscardTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByImportTablespace(MySqlParser.AlterByImportTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByImportTablespace(MySqlParser.AlterByImportTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByForce(MySqlParser.AlterByForceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByForce(MySqlParser.AlterByForceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByValidate(MySqlParser.AlterByValidateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByValidate(MySqlParser.AlterByValidateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddDefinitions(MySqlParser.AlterByAddDefinitionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddDefinitions(MySqlParser.AlterByAddDefinitionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterPartition(MySqlParser.AlterPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterPartition(MySqlParser.AlterPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAddPartition(MySqlParser.AlterByAddPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAddPartition(MySqlParser.AlterByAddPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDropPartition(MySqlParser.AlterByDropPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDropPartition(MySqlParser.AlterByDropPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByDiscardPartition(MySqlParser.AlterByDiscardPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByDiscardPartition(MySqlParser.AlterByDiscardPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByImportPartition(MySqlParser.AlterByImportPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByImportPartition(MySqlParser.AlterByImportPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByTruncatePartition(MySqlParser.AlterByTruncatePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByTruncatePartition(MySqlParser.AlterByTruncatePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByCoalescePartition(MySqlParser.AlterByCoalescePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByCoalescePartition(MySqlParser.AlterByCoalescePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByReorganizePartition(MySqlParser.AlterByReorganizePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByReorganizePartition(MySqlParser.AlterByReorganizePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByExchangePartition(MySqlParser.AlterByExchangePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByExchangePartition(MySqlParser.AlterByExchangePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByAnalyzePartition(MySqlParser.AlterByAnalyzePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByAnalyzePartition(MySqlParser.AlterByAnalyzePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByCheckPartition(MySqlParser.AlterByCheckPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByCheckPartition(MySqlParser.AlterByCheckPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByOptimizePartition(MySqlParser.AlterByOptimizePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByOptimizePartition(MySqlParser.AlterByOptimizePartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByRebuildPartition(MySqlParser.AlterByRebuildPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByRebuildPartition(MySqlParser.AlterByRebuildPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByRepairPartition(MySqlParser.AlterByRepairPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByRepairPartition(MySqlParser.AlterByRepairPartitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByRemovePartitioning(MySqlParser.AlterByRemovePartitioningContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByRemovePartitioning(MySqlParser.AlterByRemovePartitioningContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterByUpgradePartitioning(MySqlParser.AlterByUpgradePartitioningContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterByUpgradePartitioning(MySqlParser.AlterByUpgradePartitioningContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropDatabase(MySqlParser.DropDatabaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropDatabase(MySqlParser.DropDatabaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropEvent(MySqlParser.DropEventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropEvent(MySqlParser.DropEventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropIndex(MySqlParser.DropIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropIndex(MySqlParser.DropIndexContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropLogfileGroup(MySqlParser.DropLogfileGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropLogfileGroup(MySqlParser.DropLogfileGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropProcedure(MySqlParser.DropProcedureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropProcedure(MySqlParser.DropProcedureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropFunction(MySqlParser.DropFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropFunction(MySqlParser.DropFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropServer(MySqlParser.DropServerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropServer(MySqlParser.DropServerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropTable(MySqlParser.DropTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropTable(MySqlParser.DropTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropTablespace(MySqlParser.DropTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropTablespace(MySqlParser.DropTablespaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropTrigger(MySqlParser.DropTriggerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropTrigger(MySqlParser.DropTriggerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropView(MySqlParser.DropViewContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropView(MySqlParser.DropViewContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropRole(MySqlParser.DropRoleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropRole(MySqlParser.DropRoleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetRole(MySqlParser.SetRoleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetRole(MySqlParser.SetRoleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRenameTable(MySqlParser.RenameTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRenameTable(MySqlParser.RenameTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRenameTableClause(MySqlParser.RenameTableClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRenameTableClause(MySqlParser.RenameTableClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTruncateTable(MySqlParser.TruncateTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTruncateTable(MySqlParser.TruncateTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCallStatement(MySqlParser.CallStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCallStatement(MySqlParser.CallStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeleteStatement(MySqlParser.DeleteStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeleteStatement(MySqlParser.DeleteStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDoStatement(MySqlParser.DoStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDoStatement(MySqlParser.DoStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerStatement(MySqlParser.HandlerStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerStatement(MySqlParser.HandlerStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInsertStatement(MySqlParser.InsertStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInsertStatement(MySqlParser.InsertStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLoadDataStatement(MySqlParser.LoadDataStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLoadDataStatement(MySqlParser.LoadDataStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLoadXmlStatement(MySqlParser.LoadXmlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLoadXmlStatement(MySqlParser.LoadXmlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReplaceStatement(MySqlParser.ReplaceStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReplaceStatement(MySqlParser.ReplaceStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleSelect(MySqlParser.SimpleSelectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleSelect(MySqlParser.SimpleSelectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParenthesisSelect(MySqlParser.ParenthesisSelectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParenthesisSelect(MySqlParser.ParenthesisSelectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnionSelect(MySqlParser.UnionSelectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnionSelect(MySqlParser.UnionSelectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnionParenthesisSelect(MySqlParser.UnionParenthesisSelectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnionParenthesisSelect(MySqlParser.UnionParenthesisSelectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWithLateralStatement(MySqlParser.WithLateralStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWithLateralStatement(MySqlParser.WithLateralStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUpdateStatement(MySqlParser.UpdateStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUpdateStatement(MySqlParser.UpdateStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterValuesStatement(MySqlParser.ValuesStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitValuesStatement(MySqlParser.ValuesStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInsertStatementValue(MySqlParser.InsertStatementValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInsertStatementValue(MySqlParser.InsertStatementValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUpdatedElement(MySqlParser.UpdatedElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUpdatedElement(MySqlParser.UpdatedElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAssignmentField(MySqlParser.AssignmentFieldContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAssignmentField(MySqlParser.AssignmentFieldContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLockClause(MySqlParser.LockClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLockClause(MySqlParser.LockClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSingleDeleteStatement(MySqlParser.SingleDeleteStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSingleDeleteStatement(MySqlParser.SingleDeleteStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMultipleDeleteStatement(MySqlParser.MultipleDeleteStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMultipleDeleteStatement(MySqlParser.MultipleDeleteStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerOpenStatement(MySqlParser.HandlerOpenStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerOpenStatement(MySqlParser.HandlerOpenStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerReadIndexStatement(MySqlParser.HandlerReadIndexStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerReadIndexStatement(MySqlParser.HandlerReadIndexStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerReadStatement(MySqlParser.HandlerReadStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerReadStatement(MySqlParser.HandlerReadStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerCloseStatement(MySqlParser.HandlerCloseStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerCloseStatement(MySqlParser.HandlerCloseStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSingleUpdateStatement(MySqlParser.SingleUpdateStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSingleUpdateStatement(MySqlParser.SingleUpdateStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMultipleUpdateStatement(MySqlParser.MultipleUpdateStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMultipleUpdateStatement(MySqlParser.MultipleUpdateStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOrderByClause(MySqlParser.OrderByClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOrderByClause(MySqlParser.OrderByClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOrderByExpression(MySqlParser.OrderByExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOrderByExpression(MySqlParser.OrderByExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableSources(MySqlParser.TableSourcesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableSources(MySqlParser.TableSourcesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableSourceBase(MySqlParser.TableSourceBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableSourceBase(MySqlParser.TableSourceBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableSourceNested(MySqlParser.TableSourceNestedContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableSourceNested(MySqlParser.TableSourceNestedContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableJson(MySqlParser.TableJsonContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableJson(MySqlParser.TableJsonContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAtomTableItem(MySqlParser.AtomTableItemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAtomTableItem(MySqlParser.AtomTableItemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubqueryTableItem(MySqlParser.SubqueryTableItemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubqueryTableItem(MySqlParser.SubqueryTableItemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableSourcesItem(MySqlParser.TableSourcesItemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableSourcesItem(MySqlParser.TableSourcesItemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexHint(MySqlParser.IndexHintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexHint(MySqlParser.IndexHintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexHintType(MySqlParser.IndexHintTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexHintType(MySqlParser.IndexHintTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInnerJoin(MySqlParser.InnerJoinContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInnerJoin(MySqlParser.InnerJoinContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStraightJoin(MySqlParser.StraightJoinContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStraightJoin(MySqlParser.StraightJoinContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOuterJoin(MySqlParser.OuterJoinContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOuterJoin(MySqlParser.OuterJoinContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNaturalJoin(MySqlParser.NaturalJoinContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNaturalJoin(MySqlParser.NaturalJoinContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJoinSpec(MySqlParser.JoinSpecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJoinSpec(MySqlParser.JoinSpecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQueryExpression(MySqlParser.QueryExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQueryExpression(MySqlParser.QueryExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQueryExpressionNointo(MySqlParser.QueryExpressionNointoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQueryExpressionNointo(MySqlParser.QueryExpressionNointoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQuerySpecification(MySqlParser.QuerySpecificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQuerySpecification(MySqlParser.QuerySpecificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQuerySpecificationNointo(MySqlParser.QuerySpecificationNointoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQuerySpecificationNointo(MySqlParser.QuerySpecificationNointoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnionParenthesis(MySqlParser.UnionParenthesisContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnionParenthesis(MySqlParser.UnionParenthesisContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnionStatement(MySqlParser.UnionStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnionStatement(MySqlParser.UnionStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLateralStatement(MySqlParser.LateralStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLateralStatement(MySqlParser.LateralStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJsonTable(MySqlParser.JsonTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJsonTable(MySqlParser.JsonTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJsonColumnList(MySqlParser.JsonColumnListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJsonColumnList(MySqlParser.JsonColumnListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJsonColumn(MySqlParser.JsonColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJsonColumn(MySqlParser.JsonColumnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJsonOnEmpty(MySqlParser.JsonOnEmptyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJsonOnEmpty(MySqlParser.JsonOnEmptyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJsonOnError(MySqlParser.JsonOnErrorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJsonOnError(MySqlParser.JsonOnErrorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectSpec(MySqlParser.SelectSpecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectSpec(MySqlParser.SelectSpecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectElements(MySqlParser.SelectElementsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectElements(MySqlParser.SelectElementsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectStarElement(MySqlParser.SelectStarElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectStarElement(MySqlParser.SelectStarElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectColumnElement(MySqlParser.SelectColumnElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectColumnElement(MySqlParser.SelectColumnElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectFunctionElement(MySqlParser.SelectFunctionElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectFunctionElement(MySqlParser.SelectFunctionElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectExpressionElement(MySqlParser.SelectExpressionElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectExpressionElement(MySqlParser.SelectExpressionElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectIntoVariables(MySqlParser.SelectIntoVariablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectIntoVariables(MySqlParser.SelectIntoVariablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectIntoDumpFile(MySqlParser.SelectIntoDumpFileContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectIntoDumpFile(MySqlParser.SelectIntoDumpFileContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectIntoTextFile(MySqlParser.SelectIntoTextFileContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectIntoTextFile(MySqlParser.SelectIntoTextFileContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectFieldsInto(MySqlParser.SelectFieldsIntoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectFieldsInto(MySqlParser.SelectFieldsIntoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectLinesInto(MySqlParser.SelectLinesIntoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectLinesInto(MySqlParser.SelectLinesIntoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFromClause(MySqlParser.FromClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFromClause(MySqlParser.FromClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGroupByClause(MySqlParser.GroupByClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGroupByClause(MySqlParser.GroupByClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHavingClause(MySqlParser.HavingClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHavingClause(MySqlParser.HavingClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWindowClause(MySqlParser.WindowClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWindowClause(MySqlParser.WindowClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGroupByItem(MySqlParser.GroupByItemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGroupByItem(MySqlParser.GroupByItemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLimitClause(MySqlParser.LimitClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLimitClause(MySqlParser.LimitClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLimitClauseAtom(MySqlParser.LimitClauseAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLimitClauseAtom(MySqlParser.LimitClauseAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStartTransaction(MySqlParser.StartTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStartTransaction(MySqlParser.StartTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBeginWork(MySqlParser.BeginWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBeginWork(MySqlParser.BeginWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCommitWork(MySqlParser.CommitWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCommitWork(MySqlParser.CommitWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRollbackWork(MySqlParser.RollbackWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRollbackWork(MySqlParser.RollbackWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSavepointStatement(MySqlParser.SavepointStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSavepointStatement(MySqlParser.SavepointStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRollbackStatement(MySqlParser.RollbackStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRollbackStatement(MySqlParser.RollbackStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReleaseStatement(MySqlParser.ReleaseStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReleaseStatement(MySqlParser.ReleaseStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLockTables(MySqlParser.LockTablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLockTables(MySqlParser.LockTablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnlockTables(MySqlParser.UnlockTablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnlockTables(MySqlParser.UnlockTablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetAutocommitStatement(MySqlParser.SetAutocommitStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetAutocommitStatement(MySqlParser.SetAutocommitStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetTransactionStatement(MySqlParser.SetTransactionStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetTransactionStatement(MySqlParser.SetTransactionStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransactionMode(MySqlParser.TransactionModeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransactionMode(MySqlParser.TransactionModeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLockTableElement(MySqlParser.LockTableElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLockTableElement(MySqlParser.LockTableElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLockAction(MySqlParser.LockActionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLockAction(MySqlParser.LockActionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransactionOption(MySqlParser.TransactionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransactionOption(MySqlParser.TransactionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransactionLevel(MySqlParser.TransactionLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransactionLevel(MySqlParser.TransactionLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterChangeMaster(MySqlParser.ChangeMasterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitChangeMaster(MySqlParser.ChangeMasterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterChangeReplicationFilter(MySqlParser.ChangeReplicationFilterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitChangeReplicationFilter(MySqlParser.ChangeReplicationFilterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPurgeBinaryLogs(MySqlParser.PurgeBinaryLogsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPurgeBinaryLogs(MySqlParser.PurgeBinaryLogsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterResetMaster(MySqlParser.ResetMasterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitResetMaster(MySqlParser.ResetMasterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterResetSlave(MySqlParser.ResetSlaveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitResetSlave(MySqlParser.ResetSlaveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStartSlave(MySqlParser.StartSlaveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStartSlave(MySqlParser.StartSlaveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStopSlave(MySqlParser.StopSlaveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStopSlave(MySqlParser.StopSlaveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStartGroupReplication(MySqlParser.StartGroupReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStartGroupReplication(MySqlParser.StartGroupReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStopGroupReplication(MySqlParser.StopGroupReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStopGroupReplication(MySqlParser.StopGroupReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMasterStringOption(MySqlParser.MasterStringOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMasterStringOption(MySqlParser.MasterStringOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMasterDecimalOption(MySqlParser.MasterDecimalOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMasterDecimalOption(MySqlParser.MasterDecimalOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMasterBoolOption(MySqlParser.MasterBoolOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMasterBoolOption(MySqlParser.MasterBoolOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMasterRealOption(MySqlParser.MasterRealOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMasterRealOption(MySqlParser.MasterRealOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMasterUidListOption(MySqlParser.MasterUidListOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMasterUidListOption(MySqlParser.MasterUidListOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStringMasterOption(MySqlParser.StringMasterOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStringMasterOption(MySqlParser.StringMasterOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecimalMasterOption(MySqlParser.DecimalMasterOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecimalMasterOption(MySqlParser.DecimalMasterOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBoolMasterOption(MySqlParser.BoolMasterOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBoolMasterOption(MySqlParser.BoolMasterOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterChannelOption(MySqlParser.ChannelOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitChannelOption(MySqlParser.ChannelOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDoDbReplication(MySqlParser.DoDbReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDoDbReplication(MySqlParser.DoDbReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIgnoreDbReplication(MySqlParser.IgnoreDbReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIgnoreDbReplication(MySqlParser.IgnoreDbReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDoTableReplication(MySqlParser.DoTableReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDoTableReplication(MySqlParser.DoTableReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIgnoreTableReplication(MySqlParser.IgnoreTableReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIgnoreTableReplication(MySqlParser.IgnoreTableReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWildDoTableReplication(MySqlParser.WildDoTableReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWildDoTableReplication(MySqlParser.WildDoTableReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWildIgnoreTableReplication(MySqlParser.WildIgnoreTableReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWildIgnoreTableReplication(MySqlParser.WildIgnoreTableReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRewriteDbReplication(MySqlParser.RewriteDbReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRewriteDbReplication(MySqlParser.RewriteDbReplicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTablePair(MySqlParser.TablePairContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTablePair(MySqlParser.TablePairContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterThreadType(MySqlParser.ThreadTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitThreadType(MySqlParser.ThreadTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGtidsUntilOption(MySqlParser.GtidsUntilOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGtidsUntilOption(MySqlParser.GtidsUntilOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMasterLogUntilOption(MySqlParser.MasterLogUntilOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMasterLogUntilOption(MySqlParser.MasterLogUntilOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRelayLogUntilOption(MySqlParser.RelayLogUntilOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRelayLogUntilOption(MySqlParser.RelayLogUntilOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSqlGapsUntilOption(MySqlParser.SqlGapsUntilOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSqlGapsUntilOption(MySqlParser.SqlGapsUntilOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUserConnectionOption(MySqlParser.UserConnectionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUserConnectionOption(MySqlParser.UserConnectionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPasswordConnectionOption(MySqlParser.PasswordConnectionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPasswordConnectionOption(MySqlParser.PasswordConnectionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefaultAuthConnectionOption(MySqlParser.DefaultAuthConnectionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefaultAuthConnectionOption(MySqlParser.DefaultAuthConnectionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPluginDirConnectionOption(MySqlParser.PluginDirConnectionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPluginDirConnectionOption(MySqlParser.PluginDirConnectionOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGtuidSet(MySqlParser.GtuidSetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGtuidSet(MySqlParser.GtuidSetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXaStartTransaction(MySqlParser.XaStartTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXaStartTransaction(MySqlParser.XaStartTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXaEndTransaction(MySqlParser.XaEndTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXaEndTransaction(MySqlParser.XaEndTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXaPrepareStatement(MySqlParser.XaPrepareStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXaPrepareStatement(MySqlParser.XaPrepareStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXaCommitWork(MySqlParser.XaCommitWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXaCommitWork(MySqlParser.XaCommitWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXaRollbackWork(MySqlParser.XaRollbackWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXaRollbackWork(MySqlParser.XaRollbackWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXaRecoverWork(MySqlParser.XaRecoverWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXaRecoverWork(MySqlParser.XaRecoverWorkContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrepareStatement(MySqlParser.PrepareStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrepareStatement(MySqlParser.PrepareStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExecuteStatement(MySqlParser.ExecuteStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExecuteStatement(MySqlParser.ExecuteStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeallocatePrepare(MySqlParser.DeallocatePrepareContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeallocatePrepare(MySqlParser.DeallocatePrepareContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoutineBody(MySqlParser.RoutineBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoutineBody(MySqlParser.RoutineBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBlockStatement(MySqlParser.BlockStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBlockStatement(MySqlParser.BlockStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCaseStatement(MySqlParser.CaseStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCaseStatement(MySqlParser.CaseStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIfStatement(MySqlParser.IfStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIfStatement(MySqlParser.IfStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIterateStatement(MySqlParser.IterateStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIterateStatement(MySqlParser.IterateStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLeaveStatement(MySqlParser.LeaveStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLeaveStatement(MySqlParser.LeaveStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLoopStatement(MySqlParser.LoopStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLoopStatement(MySqlParser.LoopStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRepeatStatement(MySqlParser.RepeatStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRepeatStatement(MySqlParser.RepeatStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReturnStatement(MySqlParser.ReturnStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReturnStatement(MySqlParser.ReturnStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWhileStatement(MySqlParser.WhileStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWhileStatement(MySqlParser.WhileStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCloseCursor(MySqlParser.CloseCursorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCloseCursor(MySqlParser.CloseCursorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFetchCursor(MySqlParser.FetchCursorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFetchCursor(MySqlParser.FetchCursorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpenCursor(MySqlParser.OpenCursorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpenCursor(MySqlParser.OpenCursorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeclareVariable(MySqlParser.DeclareVariableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeclareVariable(MySqlParser.DeclareVariableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeclareCondition(MySqlParser.DeclareConditionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeclareCondition(MySqlParser.DeclareConditionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeclareCursor(MySqlParser.DeclareCursorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeclareCursor(MySqlParser.DeclareCursorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeclareHandler(MySqlParser.DeclareHandlerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeclareHandler(MySqlParser.DeclareHandlerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerConditionCode(MySqlParser.HandlerConditionCodeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerConditionCode(MySqlParser.HandlerConditionCodeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerConditionState(MySqlParser.HandlerConditionStateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerConditionState(MySqlParser.HandlerConditionStateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerConditionName(MySqlParser.HandlerConditionNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerConditionName(MySqlParser.HandlerConditionNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerConditionWarning(MySqlParser.HandlerConditionWarningContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerConditionWarning(MySqlParser.HandlerConditionWarningContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerConditionNotfound(MySqlParser.HandlerConditionNotfoundContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerConditionNotfound(MySqlParser.HandlerConditionNotfoundContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHandlerConditionException(MySqlParser.HandlerConditionExceptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHandlerConditionException(MySqlParser.HandlerConditionExceptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProcedureSqlStatement(MySqlParser.ProcedureSqlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProcedureSqlStatement(MySqlParser.ProcedureSqlStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCaseAlternative(MySqlParser.CaseAlternativeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCaseAlternative(MySqlParser.CaseAlternativeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterElifAlternative(MySqlParser.ElifAlternativeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitElifAlternative(MySqlParser.ElifAlternativeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterUserMysqlV56(MySqlParser.AlterUserMysqlV56Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterUserMysqlV56(MySqlParser.AlterUserMysqlV56Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterUserMysqlV80(MySqlParser.AlterUserMysqlV80Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterUserMysqlV80(MySqlParser.AlterUserMysqlV80Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateUserMysqlV56(MySqlParser.CreateUserMysqlV56Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateUserMysqlV56(MySqlParser.CreateUserMysqlV56Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateUserMysqlV80(MySqlParser.CreateUserMysqlV80Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateUserMysqlV80(MySqlParser.CreateUserMysqlV80Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropUser(MySqlParser.DropUserContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropUser(MySqlParser.DropUserContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGrantStatement(MySqlParser.GrantStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGrantStatement(MySqlParser.GrantStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoleOption(MySqlParser.RoleOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoleOption(MySqlParser.RoleOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGrantProxy(MySqlParser.GrantProxyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGrantProxy(MySqlParser.GrantProxyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRenameUser(MySqlParser.RenameUserContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRenameUser(MySqlParser.RenameUserContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDetailRevoke(MySqlParser.DetailRevokeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDetailRevoke(MySqlParser.DetailRevokeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShortRevoke(MySqlParser.ShortRevokeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShortRevoke(MySqlParser.ShortRevokeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoleRevoke(MySqlParser.RoleRevokeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoleRevoke(MySqlParser.RoleRevokeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRevokeProxy(MySqlParser.RevokeProxyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRevokeProxy(MySqlParser.RevokeProxyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetPasswordStatement(MySqlParser.SetPasswordStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetPasswordStatement(MySqlParser.SetPasswordStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUserSpecification(MySqlParser.UserSpecificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUserSpecification(MySqlParser.UserSpecificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHashAuthOption(MySqlParser.HashAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHashAuthOption(MySqlParser.HashAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRandomAuthOption(MySqlParser.RandomAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRandomAuthOption(MySqlParser.RandomAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStringAuthOption(MySqlParser.StringAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStringAuthOption(MySqlParser.StringAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterModuleAuthOption(MySqlParser.ModuleAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitModuleAuthOption(MySqlParser.ModuleAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleAuthOption(MySqlParser.SimpleAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleAuthOption(MySqlParser.SimpleAuthOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAuthOptionClause(MySqlParser.AuthOptionClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAuthOptionClause(MySqlParser.AuthOptionClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterModule(MySqlParser.ModuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitModule(MySqlParser.ModuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPasswordModuleOption(MySqlParser.PasswordModuleOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPasswordModuleOption(MySqlParser.PasswordModuleOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTlsOption(MySqlParser.TlsOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTlsOption(MySqlParser.TlsOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUserResourceOption(MySqlParser.UserResourceOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUserResourceOption(MySqlParser.UserResourceOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUserPasswordOption(MySqlParser.UserPasswordOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUserPasswordOption(MySqlParser.UserPasswordOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUserLockOption(MySqlParser.UserLockOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUserLockOption(MySqlParser.UserLockOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrivelegeClause(MySqlParser.PrivelegeClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrivelegeClause(MySqlParser.PrivelegeClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrivilege(MySqlParser.PrivilegeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrivilege(MySqlParser.PrivilegeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCurrentSchemaPriviLevel(MySqlParser.CurrentSchemaPriviLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCurrentSchemaPriviLevel(MySqlParser.CurrentSchemaPriviLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGlobalPrivLevel(MySqlParser.GlobalPrivLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGlobalPrivLevel(MySqlParser.GlobalPrivLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefiniteSchemaPrivLevel(MySqlParser.DefiniteSchemaPrivLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefiniteSchemaPrivLevel(MySqlParser.DefiniteSchemaPrivLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefiniteFullTablePrivLevel(MySqlParser.DefiniteFullTablePrivLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefiniteFullTablePrivLevel(MySqlParser.DefiniteFullTablePrivLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefiniteFullTablePrivLevel2(MySqlParser.DefiniteFullTablePrivLevel2Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefiniteFullTablePrivLevel2(MySqlParser.DefiniteFullTablePrivLevel2Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefiniteTablePrivLevel(MySqlParser.DefiniteTablePrivLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefiniteTablePrivLevel(MySqlParser.DefiniteTablePrivLevelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRenameUserClause(MySqlParser.RenameUserClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRenameUserClause(MySqlParser.RenameUserClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnalyzeTable(MySqlParser.AnalyzeTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnalyzeTable(MySqlParser.AnalyzeTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCheckTable(MySqlParser.CheckTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCheckTable(MySqlParser.CheckTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterChecksumTable(MySqlParser.ChecksumTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitChecksumTable(MySqlParser.ChecksumTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOptimizeTable(MySqlParser.OptimizeTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOptimizeTable(MySqlParser.OptimizeTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRepairTable(MySqlParser.RepairTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRepairTable(MySqlParser.RepairTableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCheckTableOption(MySqlParser.CheckTableOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCheckTableOption(MySqlParser.CheckTableOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateUdfunction(MySqlParser.CreateUdfunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateUdfunction(MySqlParser.CreateUdfunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInstallPlugin(MySqlParser.InstallPluginContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInstallPlugin(MySqlParser.InstallPluginContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUninstallPlugin(MySqlParser.UninstallPluginContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUninstallPlugin(MySqlParser.UninstallPluginContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetVariable(MySqlParser.SetVariableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetVariable(MySqlParser.SetVariableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetCharset(MySqlParser.SetCharsetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetCharset(MySqlParser.SetCharsetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetNames(MySqlParser.SetNamesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetNames(MySqlParser.SetNamesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetPassword(MySqlParser.SetPasswordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetPassword(MySqlParser.SetPasswordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetTransaction(MySqlParser.SetTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetTransaction(MySqlParser.SetTransactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetAutocommit(MySqlParser.SetAutocommitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetAutocommit(MySqlParser.SetAutocommitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSetNewValueInsideTrigger(MySqlParser.SetNewValueInsideTriggerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSetNewValueInsideTrigger(MySqlParser.SetNewValueInsideTriggerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowMasterLogs(MySqlParser.ShowMasterLogsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowMasterLogs(MySqlParser.ShowMasterLogsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowLogEvents(MySqlParser.ShowLogEventsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowLogEvents(MySqlParser.ShowLogEventsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowObjectFilter(MySqlParser.ShowObjectFilterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowObjectFilter(MySqlParser.ShowObjectFilterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowColumns(MySqlParser.ShowColumnsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowColumns(MySqlParser.ShowColumnsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowCreateDb(MySqlParser.ShowCreateDbContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowCreateDb(MySqlParser.ShowCreateDbContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowCreateFullIdObject(MySqlParser.ShowCreateFullIdObjectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowCreateFullIdObject(MySqlParser.ShowCreateFullIdObjectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowCreateUser(MySqlParser.ShowCreateUserContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowCreateUser(MySqlParser.ShowCreateUserContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowEngine(MySqlParser.ShowEngineContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowEngine(MySqlParser.ShowEngineContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowGlobalInfo(MySqlParser.ShowGlobalInfoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowGlobalInfo(MySqlParser.ShowGlobalInfoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowErrors(MySqlParser.ShowErrorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowErrors(MySqlParser.ShowErrorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowCountErrors(MySqlParser.ShowCountErrorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowCountErrors(MySqlParser.ShowCountErrorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowSchemaFilter(MySqlParser.ShowSchemaFilterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowSchemaFilter(MySqlParser.ShowSchemaFilterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowRoutine(MySqlParser.ShowRoutineContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowRoutine(MySqlParser.ShowRoutineContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowGrants(MySqlParser.ShowGrantsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowGrants(MySqlParser.ShowGrantsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowIndexes(MySqlParser.ShowIndexesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowIndexes(MySqlParser.ShowIndexesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowOpenTables(MySqlParser.ShowOpenTablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowOpenTables(MySqlParser.ShowOpenTablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowProfile(MySqlParser.ShowProfileContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowProfile(MySqlParser.ShowProfileContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowSlaveStatus(MySqlParser.ShowSlaveStatusContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowSlaveStatus(MySqlParser.ShowSlaveStatusContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableClause(MySqlParser.VariableClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableClause(MySqlParser.VariableClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowCommonEntity(MySqlParser.ShowCommonEntityContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowCommonEntity(MySqlParser.ShowCommonEntityContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowFilter(MySqlParser.ShowFilterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowFilter(MySqlParser.ShowFilterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowGlobalInfoClause(MySqlParser.ShowGlobalInfoClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowGlobalInfoClause(MySqlParser.ShowGlobalInfoClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowSchemaEntity(MySqlParser.ShowSchemaEntityContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowSchemaEntity(MySqlParser.ShowSchemaEntityContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShowProfileType(MySqlParser.ShowProfileTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShowProfileType(MySqlParser.ShowProfileTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBinlogStatement(MySqlParser.BinlogStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBinlogStatement(MySqlParser.BinlogStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCacheIndexStatement(MySqlParser.CacheIndexStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCacheIndexStatement(MySqlParser.CacheIndexStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFlushStatement(MySqlParser.FlushStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFlushStatement(MySqlParser.FlushStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterKillStatement(MySqlParser.KillStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitKillStatement(MySqlParser.KillStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLoadIndexIntoCache(MySqlParser.LoadIndexIntoCacheContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLoadIndexIntoCache(MySqlParser.LoadIndexIntoCacheContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterResetStatement(MySqlParser.ResetStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitResetStatement(MySqlParser.ResetStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterShutdownStatement(MySqlParser.ShutdownStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitShutdownStatement(MySqlParser.ShutdownStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableIndexes(MySqlParser.TableIndexesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableIndexes(MySqlParser.TableIndexesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleFlushOption(MySqlParser.SimpleFlushOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleFlushOption(MySqlParser.SimpleFlushOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterChannelFlushOption(MySqlParser.ChannelFlushOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitChannelFlushOption(MySqlParser.ChannelFlushOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableFlushOption(MySqlParser.TableFlushOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableFlushOption(MySqlParser.TableFlushOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFlushTableOption(MySqlParser.FlushTableOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFlushTableOption(MySqlParser.FlushTableOptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLoadedTableIndexes(MySqlParser.LoadedTableIndexesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLoadedTableIndexes(MySqlParser.LoadedTableIndexesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleDescribeStatement(MySqlParser.SimpleDescribeStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleDescribeStatement(MySqlParser.SimpleDescribeStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFullDescribeStatement(MySqlParser.FullDescribeStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFullDescribeStatement(MySqlParser.FullDescribeStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHelpStatement(MySqlParser.HelpStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHelpStatement(MySqlParser.HelpStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUseStatement(MySqlParser.UseStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUseStatement(MySqlParser.UseStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSignalStatement(MySqlParser.SignalStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSignalStatement(MySqlParser.SignalStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterResignalStatement(MySqlParser.ResignalStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitResignalStatement(MySqlParser.ResignalStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSignalConditionInformation(MySqlParser.SignalConditionInformationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSignalConditionInformation(MySqlParser.SignalConditionInformationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWithStatement(MySqlParser.WithStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWithStatement(MySqlParser.WithStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableStatement(MySqlParser.TableStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableStatement(MySqlParser.TableStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDiagnosticsStatement(MySqlParser.DiagnosticsStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDiagnosticsStatement(MySqlParser.DiagnosticsStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDiagnosticsConditionInformationName(MySqlParser.DiagnosticsConditionInformationNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDiagnosticsConditionInformationName(MySqlParser.DiagnosticsConditionInformationNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDescribeStatements(MySqlParser.DescribeStatementsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDescribeStatements(MySqlParser.DescribeStatementsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDescribeConnection(MySqlParser.DescribeConnectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDescribeConnection(MySqlParser.DescribeConnectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFullId(MySqlParser.FullIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFullId(MySqlParser.FullIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTableName(MySqlParser.TableNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTableName(MySqlParser.TableNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoleName(MySqlParser.RoleNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoleName(MySqlParser.RoleNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFullColumnName(MySqlParser.FullColumnNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFullColumnName(MySqlParser.FullColumnNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexColumnName(MySqlParser.IndexColumnNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexColumnName(MySqlParser.IndexColumnNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleUserName(MySqlParser.SimpleUserNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleUserName(MySqlParser.SimpleUserNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHostName(MySqlParser.HostNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHostName(MySqlParser.HostNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUserName(MySqlParser.UserNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUserName(MySqlParser.UserNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMysqlVariable(MySqlParser.MysqlVariableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMysqlVariable(MySqlParser.MysqlVariableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCharsetName(MySqlParser.CharsetNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCharsetName(MySqlParser.CharsetNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCollationName(MySqlParser.CollationNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCollationName(MySqlParser.CollationNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEngineName(MySqlParser.EngineNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEngineName(MySqlParser.EngineNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEngineNameBase(MySqlParser.EngineNameBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEngineNameBase(MySqlParser.EngineNameBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUuidSet(MySqlParser.UuidSetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUuidSet(MySqlParser.UuidSetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXid(MySqlParser.XidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXid(MySqlParser.XidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXuidStringId(MySqlParser.XuidStringIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXuidStringId(MySqlParser.XuidStringIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAuthPlugin(MySqlParser.AuthPluginContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAuthPlugin(MySqlParser.AuthPluginContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUid(MySqlParser.UidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUid(MySqlParser.UidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleId(MySqlParser.SimpleIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleId(MySqlParser.SimpleIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDottedId(MySqlParser.DottedIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDottedId(MySqlParser.DottedIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecimalLiteral(MySqlParser.DecimalLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecimalLiteral(MySqlParser.DecimalLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFileSizeLiteral(MySqlParser.FileSizeLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFileSizeLiteral(MySqlParser.FileSizeLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

+ */ + @Override public void enterBooleanLiteral(MySqlParser.BooleanLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBooleanLiteral(MySqlParser.BooleanLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHexadecimalLiteral(MySqlParser.HexadecimalLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHexadecimalLiteral(MySqlParser.HexadecimalLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNullNotnull(MySqlParser.NullNotnullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNullNotnull(MySqlParser.NullNotnullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstant(MySqlParser.ConstantContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstant(MySqlParser.ConstantContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStringDataType(MySqlParser.StringDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStringDataType(MySqlParser.StringDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNationalVaryingStringDataType(MySqlParser.NationalVaryingStringDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNationalVaryingStringDataType(MySqlParser.NationalVaryingStringDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNationalStringDataType(MySqlParser.NationalStringDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNationalStringDataType(MySqlParser.NationalStringDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDimensionDataType(MySqlParser.DimensionDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDimensionDataType(MySqlParser.DimensionDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleDataType(MySqlParser.SimpleDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleDataType(MySqlParser.SimpleDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCollectionDataType(MySqlParser.CollectionDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCollectionDataType(MySqlParser.CollectionDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSpatialDataType(MySqlParser.SpatialDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSpatialDataType(MySqlParser.SpatialDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLongVarcharDataType(MySqlParser.LongVarcharDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLongVarcharDataType(MySqlParser.LongVarcharDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLongVarbinaryDataType(MySqlParser.LongVarbinaryDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLongVarbinaryDataType(MySqlParser.LongVarbinaryDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCollectionOptions(MySqlParser.CollectionOptionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCollectionOptions(MySqlParser.CollectionOptionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConvertedDataType(MySqlParser.ConvertedDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConvertedDataType(MySqlParser.ConvertedDataTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLengthOneDimension(MySqlParser.LengthOneDimensionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLengthOneDimension(MySqlParser.LengthOneDimensionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLengthTwoDimension(MySqlParser.LengthTwoDimensionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLengthTwoDimension(MySqlParser.LengthTwoDimensionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLengthTwoOptionalDimension(MySqlParser.LengthTwoOptionalDimensionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLengthTwoOptionalDimension(MySqlParser.LengthTwoOptionalDimensionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUidList(MySqlParser.UidListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUidList(MySqlParser.UidListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFullColumnNameList(MySqlParser.FullColumnNameListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFullColumnNameList(MySqlParser.FullColumnNameListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTables(MySqlParser.TablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTables(MySqlParser.TablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexColumnNames(MySqlParser.IndexColumnNamesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexColumnNames(MySqlParser.IndexColumnNamesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

+ */ + @Override public void enterExpressionsWithDefaults(MySqlParser.ExpressionsWithDefaultsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpressionsWithDefaults(MySqlParser.ExpressionsWithDefaultsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstants(MySqlParser.ConstantsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstants(MySqlParser.ConstantsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleStrings(MySqlParser.SimpleStringsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleStrings(MySqlParser.SimpleStringsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUserVariables(MySqlParser.UserVariablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUserVariables(MySqlParser.UserVariablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefaultValue(MySqlParser.DefaultValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefaultValue(MySqlParser.DefaultValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCurrentTimestamp(MySqlParser.CurrentTimestampContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCurrentTimestamp(MySqlParser.CurrentTimestampContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpressionOrDefault(MySqlParser.ExpressionOrDefaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpressionOrDefault(MySqlParser.ExpressionOrDefaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIfExists(MySqlParser.IfExistsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIfExists(MySqlParser.IfExistsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIfNotExists(MySqlParser.IfNotExistsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIfNotExists(MySqlParser.IfNotExistsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOrReplace(MySqlParser.OrReplaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOrReplace(MySqlParser.OrReplaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWaitNowaitClause(MySqlParser.WaitNowaitClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWaitNowaitClause(MySqlParser.WaitNowaitClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSpecificFunctionCall(MySqlParser.SpecificFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSpecificFunctionCall(MySqlParser.SpecificFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAggregateFunctionCall(MySqlParser.AggregateFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAggregateFunctionCall(MySqlParser.AggregateFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNonAggregateFunctionCall(MySqlParser.NonAggregateFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNonAggregateFunctionCall(MySqlParser.NonAggregateFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterScalarFunctionCall(MySqlParser.ScalarFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitScalarFunctionCall(MySqlParser.ScalarFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUdfFunctionCall(MySqlParser.UdfFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUdfFunctionCall(MySqlParser.UdfFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPasswordFunctionCall(MySqlParser.PasswordFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPasswordFunctionCall(MySqlParser.PasswordFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpleFunctionCall(MySqlParser.SimpleFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpleFunctionCall(MySqlParser.SimpleFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCurrentUser(MySqlParser.CurrentUserContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCurrentUser(MySqlParser.CurrentUserContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDataTypeFunctionCall(MySqlParser.DataTypeFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDataTypeFunctionCall(MySqlParser.DataTypeFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterValuesFunctionCall(MySqlParser.ValuesFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitValuesFunctionCall(MySqlParser.ValuesFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCaseExpressionFunctionCall(MySqlParser.CaseExpressionFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCaseExpressionFunctionCall(MySqlParser.CaseExpressionFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCaseFunctionCall(MySqlParser.CaseFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCaseFunctionCall(MySqlParser.CaseFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCharFunctionCall(MySqlParser.CharFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCharFunctionCall(MySqlParser.CharFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPositionFunctionCall(MySqlParser.PositionFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPositionFunctionCall(MySqlParser.PositionFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubstrFunctionCall(MySqlParser.SubstrFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubstrFunctionCall(MySqlParser.SubstrFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTrimFunctionCall(MySqlParser.TrimFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTrimFunctionCall(MySqlParser.TrimFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWeightFunctionCall(MySqlParser.WeightFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWeightFunctionCall(MySqlParser.WeightFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExtractFunctionCall(MySqlParser.ExtractFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExtractFunctionCall(MySqlParser.ExtractFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGetFormatFunctionCall(MySqlParser.GetFormatFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGetFormatFunctionCall(MySqlParser.GetFormatFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJsonValueFunctionCall(MySqlParser.JsonValueFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJsonValueFunctionCall(MySqlParser.JsonValueFunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCaseFuncAlternative(MySqlParser.CaseFuncAlternativeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCaseFuncAlternative(MySqlParser.CaseFuncAlternativeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLevelWeightList(MySqlParser.LevelWeightListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLevelWeightList(MySqlParser.LevelWeightListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLevelWeightRange(MySqlParser.LevelWeightRangeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLevelWeightRange(MySqlParser.LevelWeightRangeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLevelInWeightListElement(MySqlParser.LevelInWeightListElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLevelInWeightListElement(MySqlParser.LevelInWeightListElementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAggregateWindowedFunction(MySqlParser.AggregateWindowedFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAggregateWindowedFunction(MySqlParser.AggregateWindowedFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNonAggregateWindowedFunction(MySqlParser.NonAggregateWindowedFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNonAggregateWindowedFunction(MySqlParser.NonAggregateWindowedFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOverClause(MySqlParser.OverClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOverClause(MySqlParser.OverClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWindowSpec(MySqlParser.WindowSpecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWindowSpec(MySqlParser.WindowSpecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWindowName(MySqlParser.WindowNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWindowName(MySqlParser.WindowNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrameClause(MySqlParser.FrameClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrameClause(MySqlParser.FrameClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrameUnits(MySqlParser.FrameUnitsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrameUnits(MySqlParser.FrameUnitsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrameExtent(MySqlParser.FrameExtentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrameExtent(MySqlParser.FrameExtentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrameBetween(MySqlParser.FrameBetweenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrameBetween(MySqlParser.FrameBetweenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrameRange(MySqlParser.FrameRangeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrameRange(MySqlParser.FrameRangeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPartitionClause(MySqlParser.PartitionClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPartitionClause(MySqlParser.PartitionClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterScalarFunctionName(MySqlParser.ScalarFunctionNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitScalarFunctionName(MySqlParser.ScalarFunctionNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPasswordFunctionClause(MySqlParser.PasswordFunctionClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPasswordFunctionClause(MySqlParser.PasswordFunctionClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionArgs(MySqlParser.FunctionArgsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionArgs(MySqlParser.FunctionArgsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionArg(MySqlParser.FunctionArgContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionArg(MySqlParser.FunctionArgContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIsExpression(MySqlParser.IsExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIsExpression(MySqlParser.IsExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNotExpression(MySqlParser.NotExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNotExpression(MySqlParser.NotExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLogicalExpression(MySqlParser.LogicalExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLogicalExpression(MySqlParser.LogicalExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPredicateExpression(MySqlParser.PredicateExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPredicateExpression(MySqlParser.PredicateExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSoundsLikePredicate(MySqlParser.SoundsLikePredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSoundsLikePredicate(MySqlParser.SoundsLikePredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpressionAtomPredicate(MySqlParser.ExpressionAtomPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpressionAtomPredicate(MySqlParser.ExpressionAtomPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubqueryComparisonPredicate(MySqlParser.SubqueryComparisonPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubqueryComparisonPredicate(MySqlParser.SubqueryComparisonPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJsonMemberOfPredicate(MySqlParser.JsonMemberOfPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJsonMemberOfPredicate(MySqlParser.JsonMemberOfPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBinaryComparisonPredicate(MySqlParser.BinaryComparisonPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBinaryComparisonPredicate(MySqlParser.BinaryComparisonPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInPredicate(MySqlParser.InPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInPredicate(MySqlParser.InPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBetweenPredicate(MySqlParser.BetweenPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBetweenPredicate(MySqlParser.BetweenPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIsNullPredicate(MySqlParser.IsNullPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIsNullPredicate(MySqlParser.IsNullPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLikePredicate(MySqlParser.LikePredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLikePredicate(MySqlParser.LikePredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRegexpPredicate(MySqlParser.RegexpPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRegexpPredicate(MySqlParser.RegexpPredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnaryExpressionAtom(MySqlParser.UnaryExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnaryExpressionAtom(MySqlParser.UnaryExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCollateExpressionAtom(MySqlParser.CollateExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCollateExpressionAtom(MySqlParser.CollateExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableAssignExpressionAtom(MySqlParser.VariableAssignExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableAssignExpressionAtom(MySqlParser.VariableAssignExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMysqlVariableExpressionAtom(MySqlParser.MysqlVariableExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMysqlVariableExpressionAtom(MySqlParser.MysqlVariableExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNestedExpressionAtom(MySqlParser.NestedExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNestedExpressionAtom(MySqlParser.NestedExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNestedRowExpressionAtom(MySqlParser.NestedRowExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNestedRowExpressionAtom(MySqlParser.NestedRowExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMathExpressionAtom(MySqlParser.MathExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMathExpressionAtom(MySqlParser.MathExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExistsExpressionAtom(MySqlParser.ExistsExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExistsExpressionAtom(MySqlParser.ExistsExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIntervalExpressionAtom(MySqlParser.IntervalExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIntervalExpressionAtom(MySqlParser.IntervalExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSpelExpressionAtom(MySqlParser.SpelExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSpelExpressionAtom(MySqlParser.SpelExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJsonExpressionAtom(MySqlParser.JsonExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJsonExpressionAtom(MySqlParser.JsonExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubqueryExpressionAtom(MySqlParser.SubqueryExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubqueryExpressionAtom(MySqlParser.SubqueryExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstantExpressionAtom(MySqlParser.ConstantExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstantExpressionAtom(MySqlParser.ConstantExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionCallExpressionAtom(MySqlParser.FunctionCallExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionCallExpressionAtom(MySqlParser.FunctionCallExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBinaryExpressionAtom(MySqlParser.BinaryExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBinaryExpressionAtom(MySqlParser.BinaryExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFullColumnNameExpressionAtom(MySqlParser.FullColumnNameExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFullColumnNameExpressionAtom(MySqlParser.FullColumnNameExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBitExpressionAtom(MySqlParser.BitExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBitExpressionAtom(MySqlParser.BitExpressionAtomContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnaryOperator(MySqlParser.UnaryOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnaryOperator(MySqlParser.UnaryOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

+ */ + @Override public void enterLogicalOperator(MySqlParser.LogicalOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLogicalOperator(MySqlParser.LogicalOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBitOperator(MySqlParser.BitOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBitOperator(MySqlParser.BitOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMultOperator(MySqlParser.MultOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMultOperator(MySqlParser.MultOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAddOperator(MySqlParser.AddOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAddOperator(MySqlParser.AddOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJsonOperator(MySqlParser.JsonOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJsonOperator(MySqlParser.JsonOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCharsetNameBase(MySqlParser.CharsetNameBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCharsetNameBase(MySqlParser.CharsetNameBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransactionLevelBase(MySqlParser.TransactionLevelBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransactionLevelBase(MySqlParser.TransactionLevelBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrivilegesBase(MySqlParser.PrivilegesBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrivilegesBase(MySqlParser.PrivilegesBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIntervalTypeBase(MySqlParser.IntervalTypeBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIntervalTypeBase(MySqlParser.IntervalTypeBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDataTypeBase(MySqlParser.DataTypeBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDataTypeBase(MySqlParser.DataTypeBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterKeywordsCanBeId(MySqlParser.KeywordsCanBeIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitKeywordsCanBeId(MySqlParser.KeywordsCanBeIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunctionNameBase(MySqlParser.FunctionNameBaseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunctionNameBase(MySqlParser.FunctionNameBaseContext ctx) { } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

+ */ + @Override public void visitErrorNode(ErrorNode node) { } +} \ No newline at end of file diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParserListener.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParserListener.java new file mode 100644 index 000000000..c6266fc9f --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/sql/MySqlParserListener.java @@ -0,0 +1,6804 @@ +// Generated from MySqlParser.g4 by ANTLR 4.13.1 +package org.springframework.ide.vscode.parser.sql; +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link MySqlParser}. + */ +public interface MySqlParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link MySqlParser#root}. + * @param ctx the parse tree + */ + void enterRoot(MySqlParser.RootContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#root}. + * @param ctx the parse tree + */ + void exitRoot(MySqlParser.RootContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#sqlStatements}. + * @param ctx the parse tree + */ + void enterSqlStatements(MySqlParser.SqlStatementsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#sqlStatements}. + * @param ctx the parse tree + */ + void exitSqlStatements(MySqlParser.SqlStatementsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#sqlStatement}. + * @param ctx the parse tree + */ + void enterSqlStatement(MySqlParser.SqlStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#sqlStatement}. + * @param ctx the parse tree + */ + void exitSqlStatement(MySqlParser.SqlStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#emptyStatement_}. + * @param ctx the parse tree + */ + void enterEmptyStatement_(MySqlParser.EmptyStatement_Context ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#emptyStatement_}. + * @param ctx the parse tree + */ + void exitEmptyStatement_(MySqlParser.EmptyStatement_Context ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#ddlStatement}. + * @param ctx the parse tree + */ + void enterDdlStatement(MySqlParser.DdlStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#ddlStatement}. + * @param ctx the parse tree + */ + void exitDdlStatement(MySqlParser.DdlStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dmlStatement}. + * @param ctx the parse tree + */ + void enterDmlStatement(MySqlParser.DmlStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dmlStatement}. + * @param ctx the parse tree + */ + void exitDmlStatement(MySqlParser.DmlStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#transactionStatement}. + * @param ctx the parse tree + */ + void enterTransactionStatement(MySqlParser.TransactionStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#transactionStatement}. + * @param ctx the parse tree + */ + void exitTransactionStatement(MySqlParser.TransactionStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#replicationStatement}. + * @param ctx the parse tree + */ + void enterReplicationStatement(MySqlParser.ReplicationStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#replicationStatement}. + * @param ctx the parse tree + */ + void exitReplicationStatement(MySqlParser.ReplicationStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#preparedStatement}. + * @param ctx the parse tree + */ + void enterPreparedStatement(MySqlParser.PreparedStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#preparedStatement}. + * @param ctx the parse tree + */ + void exitPreparedStatement(MySqlParser.PreparedStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#compoundStatement}. + * @param ctx the parse tree + */ + void enterCompoundStatement(MySqlParser.CompoundStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#compoundStatement}. + * @param ctx the parse tree + */ + void exitCompoundStatement(MySqlParser.CompoundStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#administrationStatement}. + * @param ctx the parse tree + */ + void enterAdministrationStatement(MySqlParser.AdministrationStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#administrationStatement}. + * @param ctx the parse tree + */ + void exitAdministrationStatement(MySqlParser.AdministrationStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#utilityStatement}. + * @param ctx the parse tree + */ + void enterUtilityStatement(MySqlParser.UtilityStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#utilityStatement}. + * @param ctx the parse tree + */ + void exitUtilityStatement(MySqlParser.UtilityStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createDatabase}. + * @param ctx the parse tree + */ + void enterCreateDatabase(MySqlParser.CreateDatabaseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createDatabase}. + * @param ctx the parse tree + */ + void exitCreateDatabase(MySqlParser.CreateDatabaseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createEvent}. + * @param ctx the parse tree + */ + void enterCreateEvent(MySqlParser.CreateEventContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createEvent}. + * @param ctx the parse tree + */ + void exitCreateEvent(MySqlParser.CreateEventContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createIndex}. + * @param ctx the parse tree + */ + void enterCreateIndex(MySqlParser.CreateIndexContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createIndex}. + * @param ctx the parse tree + */ + void exitCreateIndex(MySqlParser.CreateIndexContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createLogfileGroup}. + * @param ctx the parse tree + */ + void enterCreateLogfileGroup(MySqlParser.CreateLogfileGroupContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createLogfileGroup}. + * @param ctx the parse tree + */ + void exitCreateLogfileGroup(MySqlParser.CreateLogfileGroupContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createProcedure}. + * @param ctx the parse tree + */ + void enterCreateProcedure(MySqlParser.CreateProcedureContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createProcedure}. + * @param ctx the parse tree + */ + void exitCreateProcedure(MySqlParser.CreateProcedureContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createFunction}. + * @param ctx the parse tree + */ + void enterCreateFunction(MySqlParser.CreateFunctionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createFunction}. + * @param ctx the parse tree + */ + void exitCreateFunction(MySqlParser.CreateFunctionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createRole}. + * @param ctx the parse tree + */ + void enterCreateRole(MySqlParser.CreateRoleContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createRole}. + * @param ctx the parse tree + */ + void exitCreateRole(MySqlParser.CreateRoleContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createServer}. + * @param ctx the parse tree + */ + void enterCreateServer(MySqlParser.CreateServerContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createServer}. + * @param ctx the parse tree + */ + void exitCreateServer(MySqlParser.CreateServerContext ctx); + /** + * Enter a parse tree produced by the {@code copyCreateTable} + * labeled alternative in {@link MySqlParser#createTable}. + * @param ctx the parse tree + */ + void enterCopyCreateTable(MySqlParser.CopyCreateTableContext ctx); + /** + * Exit a parse tree produced by the {@code copyCreateTable} + * labeled alternative in {@link MySqlParser#createTable}. + * @param ctx the parse tree + */ + void exitCopyCreateTable(MySqlParser.CopyCreateTableContext ctx); + /** + * Enter a parse tree produced by the {@code queryCreateTable} + * labeled alternative in {@link MySqlParser#createTable}. + * @param ctx the parse tree + */ + void enterQueryCreateTable(MySqlParser.QueryCreateTableContext ctx); + /** + * Exit a parse tree produced by the {@code queryCreateTable} + * labeled alternative in {@link MySqlParser#createTable}. + * @param ctx the parse tree + */ + void exitQueryCreateTable(MySqlParser.QueryCreateTableContext ctx); + /** + * Enter a parse tree produced by the {@code columnCreateTable} + * labeled alternative in {@link MySqlParser#createTable}. + * @param ctx the parse tree + */ + void enterColumnCreateTable(MySqlParser.ColumnCreateTableContext ctx); + /** + * Exit a parse tree produced by the {@code columnCreateTable} + * labeled alternative in {@link MySqlParser#createTable}. + * @param ctx the parse tree + */ + void exitColumnCreateTable(MySqlParser.ColumnCreateTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createTablespaceInnodb}. + * @param ctx the parse tree + */ + void enterCreateTablespaceInnodb(MySqlParser.CreateTablespaceInnodbContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createTablespaceInnodb}. + * @param ctx the parse tree + */ + void exitCreateTablespaceInnodb(MySqlParser.CreateTablespaceInnodbContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createTablespaceNdb}. + * @param ctx the parse tree + */ + void enterCreateTablespaceNdb(MySqlParser.CreateTablespaceNdbContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createTablespaceNdb}. + * @param ctx the parse tree + */ + void exitCreateTablespaceNdb(MySqlParser.CreateTablespaceNdbContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createTrigger}. + * @param ctx the parse tree + */ + void enterCreateTrigger(MySqlParser.CreateTriggerContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createTrigger}. + * @param ctx the parse tree + */ + void exitCreateTrigger(MySqlParser.CreateTriggerContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#withClause}. + * @param ctx the parse tree + */ + void enterWithClause(MySqlParser.WithClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#withClause}. + * @param ctx the parse tree + */ + void exitWithClause(MySqlParser.WithClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#commonTableExpressions}. + * @param ctx the parse tree + */ + void enterCommonTableExpressions(MySqlParser.CommonTableExpressionsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#commonTableExpressions}. + * @param ctx the parse tree + */ + void exitCommonTableExpressions(MySqlParser.CommonTableExpressionsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#cteName}. + * @param ctx the parse tree + */ + void enterCteName(MySqlParser.CteNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#cteName}. + * @param ctx the parse tree + */ + void exitCteName(MySqlParser.CteNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#cteColumnName}. + * @param ctx the parse tree + */ + void enterCteColumnName(MySqlParser.CteColumnNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#cteColumnName}. + * @param ctx the parse tree + */ + void exitCteColumnName(MySqlParser.CteColumnNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createView}. + * @param ctx the parse tree + */ + void enterCreateView(MySqlParser.CreateViewContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createView}. + * @param ctx the parse tree + */ + void exitCreateView(MySqlParser.CreateViewContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createDatabaseOption}. + * @param ctx the parse tree + */ + void enterCreateDatabaseOption(MySqlParser.CreateDatabaseOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createDatabaseOption}. + * @param ctx the parse tree + */ + void exitCreateDatabaseOption(MySqlParser.CreateDatabaseOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#charSet}. + * @param ctx the parse tree + */ + void enterCharSet(MySqlParser.CharSetContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#charSet}. + * @param ctx the parse tree + */ + void exitCharSet(MySqlParser.CharSetContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#currentUserExpression}. + * @param ctx the parse tree + */ + void enterCurrentUserExpression(MySqlParser.CurrentUserExpressionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#currentUserExpression}. + * @param ctx the parse tree + */ + void exitCurrentUserExpression(MySqlParser.CurrentUserExpressionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#ownerStatement}. + * @param ctx the parse tree + */ + void enterOwnerStatement(MySqlParser.OwnerStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#ownerStatement}. + * @param ctx the parse tree + */ + void exitOwnerStatement(MySqlParser.OwnerStatementContext ctx); + /** + * Enter a parse tree produced by the {@code preciseSchedule} + * labeled alternative in {@link MySqlParser#scheduleExpression}. + * @param ctx the parse tree + */ + void enterPreciseSchedule(MySqlParser.PreciseScheduleContext ctx); + /** + * Exit a parse tree produced by the {@code preciseSchedule} + * labeled alternative in {@link MySqlParser#scheduleExpression}. + * @param ctx the parse tree + */ + void exitPreciseSchedule(MySqlParser.PreciseScheduleContext ctx); + /** + * Enter a parse tree produced by the {@code intervalSchedule} + * labeled alternative in {@link MySqlParser#scheduleExpression}. + * @param ctx the parse tree + */ + void enterIntervalSchedule(MySqlParser.IntervalScheduleContext ctx); + /** + * Exit a parse tree produced by the {@code intervalSchedule} + * labeled alternative in {@link MySqlParser#scheduleExpression}. + * @param ctx the parse tree + */ + void exitIntervalSchedule(MySqlParser.IntervalScheduleContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#timestampValue}. + * @param ctx the parse tree + */ + void enterTimestampValue(MySqlParser.TimestampValueContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#timestampValue}. + * @param ctx the parse tree + */ + void exitTimestampValue(MySqlParser.TimestampValueContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#intervalExpr}. + * @param ctx the parse tree + */ + void enterIntervalExpr(MySqlParser.IntervalExprContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#intervalExpr}. + * @param ctx the parse tree + */ + void exitIntervalExpr(MySqlParser.IntervalExprContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#intervalType}. + * @param ctx the parse tree + */ + void enterIntervalType(MySqlParser.IntervalTypeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#intervalType}. + * @param ctx the parse tree + */ + void exitIntervalType(MySqlParser.IntervalTypeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#enableType}. + * @param ctx the parse tree + */ + void enterEnableType(MySqlParser.EnableTypeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#enableType}. + * @param ctx the parse tree + */ + void exitEnableType(MySqlParser.EnableTypeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#indexType}. + * @param ctx the parse tree + */ + void enterIndexType(MySqlParser.IndexTypeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#indexType}. + * @param ctx the parse tree + */ + void exitIndexType(MySqlParser.IndexTypeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#indexOption}. + * @param ctx the parse tree + */ + void enterIndexOption(MySqlParser.IndexOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#indexOption}. + * @param ctx the parse tree + */ + void exitIndexOption(MySqlParser.IndexOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#procedureParameter}. + * @param ctx the parse tree + */ + void enterProcedureParameter(MySqlParser.ProcedureParameterContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#procedureParameter}. + * @param ctx the parse tree + */ + void exitProcedureParameter(MySqlParser.ProcedureParameterContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#functionParameter}. + * @param ctx the parse tree + */ + void enterFunctionParameter(MySqlParser.FunctionParameterContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#functionParameter}. + * @param ctx the parse tree + */ + void exitFunctionParameter(MySqlParser.FunctionParameterContext ctx); + /** + * Enter a parse tree produced by the {@code routineComment} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void enterRoutineComment(MySqlParser.RoutineCommentContext ctx); + /** + * Exit a parse tree produced by the {@code routineComment} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void exitRoutineComment(MySqlParser.RoutineCommentContext ctx); + /** + * Enter a parse tree produced by the {@code routineLanguage} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void enterRoutineLanguage(MySqlParser.RoutineLanguageContext ctx); + /** + * Exit a parse tree produced by the {@code routineLanguage} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void exitRoutineLanguage(MySqlParser.RoutineLanguageContext ctx); + /** + * Enter a parse tree produced by the {@code routineBehavior} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void enterRoutineBehavior(MySqlParser.RoutineBehaviorContext ctx); + /** + * Exit a parse tree produced by the {@code routineBehavior} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void exitRoutineBehavior(MySqlParser.RoutineBehaviorContext ctx); + /** + * Enter a parse tree produced by the {@code routineData} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void enterRoutineData(MySqlParser.RoutineDataContext ctx); + /** + * Exit a parse tree produced by the {@code routineData} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void exitRoutineData(MySqlParser.RoutineDataContext ctx); + /** + * Enter a parse tree produced by the {@code routineSecurity} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void enterRoutineSecurity(MySqlParser.RoutineSecurityContext ctx); + /** + * Exit a parse tree produced by the {@code routineSecurity} + * labeled alternative in {@link MySqlParser#routineOption}. + * @param ctx the parse tree + */ + void exitRoutineSecurity(MySqlParser.RoutineSecurityContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#serverOption}. + * @param ctx the parse tree + */ + void enterServerOption(MySqlParser.ServerOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#serverOption}. + * @param ctx the parse tree + */ + void exitServerOption(MySqlParser.ServerOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createDefinitions}. + * @param ctx the parse tree + */ + void enterCreateDefinitions(MySqlParser.CreateDefinitionsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createDefinitions}. + * @param ctx the parse tree + */ + void exitCreateDefinitions(MySqlParser.CreateDefinitionsContext ctx); + /** + * Enter a parse tree produced by the {@code columnDeclaration} + * labeled alternative in {@link MySqlParser#createDefinition}. + * @param ctx the parse tree + */ + void enterColumnDeclaration(MySqlParser.ColumnDeclarationContext ctx); + /** + * Exit a parse tree produced by the {@code columnDeclaration} + * labeled alternative in {@link MySqlParser#createDefinition}. + * @param ctx the parse tree + */ + void exitColumnDeclaration(MySqlParser.ColumnDeclarationContext ctx); + /** + * Enter a parse tree produced by the {@code constraintDeclaration} + * labeled alternative in {@link MySqlParser#createDefinition}. + * @param ctx the parse tree + */ + void enterConstraintDeclaration(MySqlParser.ConstraintDeclarationContext ctx); + /** + * Exit a parse tree produced by the {@code constraintDeclaration} + * labeled alternative in {@link MySqlParser#createDefinition}. + * @param ctx the parse tree + */ + void exitConstraintDeclaration(MySqlParser.ConstraintDeclarationContext ctx); + /** + * Enter a parse tree produced by the {@code indexDeclaration} + * labeled alternative in {@link MySqlParser#createDefinition}. + * @param ctx the parse tree + */ + void enterIndexDeclaration(MySqlParser.IndexDeclarationContext ctx); + /** + * Exit a parse tree produced by the {@code indexDeclaration} + * labeled alternative in {@link MySqlParser#createDefinition}. + * @param ctx the parse tree + */ + void exitIndexDeclaration(MySqlParser.IndexDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#columnDefinition}. + * @param ctx the parse tree + */ + void enterColumnDefinition(MySqlParser.ColumnDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#columnDefinition}. + * @param ctx the parse tree + */ + void exitColumnDefinition(MySqlParser.ColumnDefinitionContext ctx); + /** + * Enter a parse tree produced by the {@code nullColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterNullColumnConstraint(MySqlParser.NullColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code nullColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitNullColumnConstraint(MySqlParser.NullColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code defaultColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterDefaultColumnConstraint(MySqlParser.DefaultColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code defaultColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitDefaultColumnConstraint(MySqlParser.DefaultColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code visibilityColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterVisibilityColumnConstraint(MySqlParser.VisibilityColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code visibilityColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitVisibilityColumnConstraint(MySqlParser.VisibilityColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code invisibilityColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterInvisibilityColumnConstraint(MySqlParser.InvisibilityColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code invisibilityColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitInvisibilityColumnConstraint(MySqlParser.InvisibilityColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code autoIncrementColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterAutoIncrementColumnConstraint(MySqlParser.AutoIncrementColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code autoIncrementColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitAutoIncrementColumnConstraint(MySqlParser.AutoIncrementColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code primaryKeyColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterPrimaryKeyColumnConstraint(MySqlParser.PrimaryKeyColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code primaryKeyColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitPrimaryKeyColumnConstraint(MySqlParser.PrimaryKeyColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code uniqueKeyColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterUniqueKeyColumnConstraint(MySqlParser.UniqueKeyColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code uniqueKeyColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitUniqueKeyColumnConstraint(MySqlParser.UniqueKeyColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code commentColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterCommentColumnConstraint(MySqlParser.CommentColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code commentColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitCommentColumnConstraint(MySqlParser.CommentColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code formatColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterFormatColumnConstraint(MySqlParser.FormatColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code formatColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitFormatColumnConstraint(MySqlParser.FormatColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code storageColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterStorageColumnConstraint(MySqlParser.StorageColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code storageColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitStorageColumnConstraint(MySqlParser.StorageColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code referenceColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterReferenceColumnConstraint(MySqlParser.ReferenceColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code referenceColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitReferenceColumnConstraint(MySqlParser.ReferenceColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code collateColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterCollateColumnConstraint(MySqlParser.CollateColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code collateColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitCollateColumnConstraint(MySqlParser.CollateColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code generatedColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterGeneratedColumnConstraint(MySqlParser.GeneratedColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code generatedColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitGeneratedColumnConstraint(MySqlParser.GeneratedColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code serialDefaultColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterSerialDefaultColumnConstraint(MySqlParser.SerialDefaultColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code serialDefaultColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitSerialDefaultColumnConstraint(MySqlParser.SerialDefaultColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code checkColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void enterCheckColumnConstraint(MySqlParser.CheckColumnConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code checkColumnConstraint} + * labeled alternative in {@link MySqlParser#columnConstraint}. + * @param ctx the parse tree + */ + void exitCheckColumnConstraint(MySqlParser.CheckColumnConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code primaryKeyTableConstraint} + * labeled alternative in {@link MySqlParser#tableConstraint}. + * @param ctx the parse tree + */ + void enterPrimaryKeyTableConstraint(MySqlParser.PrimaryKeyTableConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code primaryKeyTableConstraint} + * labeled alternative in {@link MySqlParser#tableConstraint}. + * @param ctx the parse tree + */ + void exitPrimaryKeyTableConstraint(MySqlParser.PrimaryKeyTableConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code uniqueKeyTableConstraint} + * labeled alternative in {@link MySqlParser#tableConstraint}. + * @param ctx the parse tree + */ + void enterUniqueKeyTableConstraint(MySqlParser.UniqueKeyTableConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code uniqueKeyTableConstraint} + * labeled alternative in {@link MySqlParser#tableConstraint}. + * @param ctx the parse tree + */ + void exitUniqueKeyTableConstraint(MySqlParser.UniqueKeyTableConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code foreignKeyTableConstraint} + * labeled alternative in {@link MySqlParser#tableConstraint}. + * @param ctx the parse tree + */ + void enterForeignKeyTableConstraint(MySqlParser.ForeignKeyTableConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code foreignKeyTableConstraint} + * labeled alternative in {@link MySqlParser#tableConstraint}. + * @param ctx the parse tree + */ + void exitForeignKeyTableConstraint(MySqlParser.ForeignKeyTableConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code checkTableConstraint} + * labeled alternative in {@link MySqlParser#tableConstraint}. + * @param ctx the parse tree + */ + void enterCheckTableConstraint(MySqlParser.CheckTableConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code checkTableConstraint} + * labeled alternative in {@link MySqlParser#tableConstraint}. + * @param ctx the parse tree + */ + void exitCheckTableConstraint(MySqlParser.CheckTableConstraintContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#referenceDefinition}. + * @param ctx the parse tree + */ + void enterReferenceDefinition(MySqlParser.ReferenceDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#referenceDefinition}. + * @param ctx the parse tree + */ + void exitReferenceDefinition(MySqlParser.ReferenceDefinitionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#referenceAction}. + * @param ctx the parse tree + */ + void enterReferenceAction(MySqlParser.ReferenceActionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#referenceAction}. + * @param ctx the parse tree + */ + void exitReferenceAction(MySqlParser.ReferenceActionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#referenceControlType}. + * @param ctx the parse tree + */ + void enterReferenceControlType(MySqlParser.ReferenceControlTypeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#referenceControlType}. + * @param ctx the parse tree + */ + void exitReferenceControlType(MySqlParser.ReferenceControlTypeContext ctx); + /** + * Enter a parse tree produced by the {@code simpleIndexDeclaration} + * labeled alternative in {@link MySqlParser#indexColumnDefinition}. + * @param ctx the parse tree + */ + void enterSimpleIndexDeclaration(MySqlParser.SimpleIndexDeclarationContext ctx); + /** + * Exit a parse tree produced by the {@code simpleIndexDeclaration} + * labeled alternative in {@link MySqlParser#indexColumnDefinition}. + * @param ctx the parse tree + */ + void exitSimpleIndexDeclaration(MySqlParser.SimpleIndexDeclarationContext ctx); + /** + * Enter a parse tree produced by the {@code specialIndexDeclaration} + * labeled alternative in {@link MySqlParser#indexColumnDefinition}. + * @param ctx the parse tree + */ + void enterSpecialIndexDeclaration(MySqlParser.SpecialIndexDeclarationContext ctx); + /** + * Exit a parse tree produced by the {@code specialIndexDeclaration} + * labeled alternative in {@link MySqlParser#indexColumnDefinition}. + * @param ctx the parse tree + */ + void exitSpecialIndexDeclaration(MySqlParser.SpecialIndexDeclarationContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionEngine} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionEngine(MySqlParser.TableOptionEngineContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionEngine} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionEngine(MySqlParser.TableOptionEngineContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionEngineAttribute} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionEngineAttribute(MySqlParser.TableOptionEngineAttributeContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionEngineAttribute} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionEngineAttribute(MySqlParser.TableOptionEngineAttributeContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionAutoextendSize} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionAutoextendSize(MySqlParser.TableOptionAutoextendSizeContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionAutoextendSize} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionAutoextendSize(MySqlParser.TableOptionAutoextendSizeContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionAutoIncrement} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionAutoIncrement(MySqlParser.TableOptionAutoIncrementContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionAutoIncrement} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionAutoIncrement(MySqlParser.TableOptionAutoIncrementContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionAverage} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionAverage(MySqlParser.TableOptionAverageContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionAverage} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionAverage(MySqlParser.TableOptionAverageContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionCharset} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionCharset(MySqlParser.TableOptionCharsetContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionCharset} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionCharset(MySqlParser.TableOptionCharsetContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionChecksum} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionChecksum(MySqlParser.TableOptionChecksumContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionChecksum} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionChecksum(MySqlParser.TableOptionChecksumContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionCollate} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionCollate(MySqlParser.TableOptionCollateContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionCollate} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionCollate(MySqlParser.TableOptionCollateContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionComment} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionComment(MySqlParser.TableOptionCommentContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionComment} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionComment(MySqlParser.TableOptionCommentContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionCompression} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionCompression(MySqlParser.TableOptionCompressionContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionCompression} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionCompression(MySqlParser.TableOptionCompressionContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionConnection} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionConnection(MySqlParser.TableOptionConnectionContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionConnection} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionConnection(MySqlParser.TableOptionConnectionContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionDataDirectory} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionDataDirectory(MySqlParser.TableOptionDataDirectoryContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionDataDirectory} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionDataDirectory(MySqlParser.TableOptionDataDirectoryContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionDelay} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionDelay(MySqlParser.TableOptionDelayContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionDelay} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionDelay(MySqlParser.TableOptionDelayContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionEncryption} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionEncryption(MySqlParser.TableOptionEncryptionContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionEncryption} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionEncryption(MySqlParser.TableOptionEncryptionContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionPageCompressed} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionPageCompressed(MySqlParser.TableOptionPageCompressedContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionPageCompressed} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionPageCompressed(MySqlParser.TableOptionPageCompressedContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionPageCompressionLevel} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionPageCompressionLevel(MySqlParser.TableOptionPageCompressionLevelContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionPageCompressionLevel} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionPageCompressionLevel(MySqlParser.TableOptionPageCompressionLevelContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionEncryptionKeyId} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionEncryptionKeyId(MySqlParser.TableOptionEncryptionKeyIdContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionEncryptionKeyId} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionEncryptionKeyId(MySqlParser.TableOptionEncryptionKeyIdContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionIndexDirectory} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionIndexDirectory(MySqlParser.TableOptionIndexDirectoryContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionIndexDirectory} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionIndexDirectory(MySqlParser.TableOptionIndexDirectoryContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionInsertMethod} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionInsertMethod(MySqlParser.TableOptionInsertMethodContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionInsertMethod} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionInsertMethod(MySqlParser.TableOptionInsertMethodContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionKeyBlockSize} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionKeyBlockSize(MySqlParser.TableOptionKeyBlockSizeContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionKeyBlockSize} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionKeyBlockSize(MySqlParser.TableOptionKeyBlockSizeContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionMaxRows} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionMaxRows(MySqlParser.TableOptionMaxRowsContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionMaxRows} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionMaxRows(MySqlParser.TableOptionMaxRowsContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionMinRows} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionMinRows(MySqlParser.TableOptionMinRowsContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionMinRows} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionMinRows(MySqlParser.TableOptionMinRowsContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionPackKeys} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionPackKeys(MySqlParser.TableOptionPackKeysContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionPackKeys} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionPackKeys(MySqlParser.TableOptionPackKeysContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionPassword} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionPassword(MySqlParser.TableOptionPasswordContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionPassword} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionPassword(MySqlParser.TableOptionPasswordContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionRowFormat} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionRowFormat(MySqlParser.TableOptionRowFormatContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionRowFormat} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionRowFormat(MySqlParser.TableOptionRowFormatContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionStartTransaction} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionStartTransaction(MySqlParser.TableOptionStartTransactionContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionStartTransaction} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionStartTransaction(MySqlParser.TableOptionStartTransactionContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionSecondaryEngineAttribute} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionSecondaryEngineAttribute(MySqlParser.TableOptionSecondaryEngineAttributeContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionSecondaryEngineAttribute} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionSecondaryEngineAttribute(MySqlParser.TableOptionSecondaryEngineAttributeContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionRecalculation} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionRecalculation(MySqlParser.TableOptionRecalculationContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionRecalculation} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionRecalculation(MySqlParser.TableOptionRecalculationContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionPersistent} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionPersistent(MySqlParser.TableOptionPersistentContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionPersistent} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionPersistent(MySqlParser.TableOptionPersistentContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionSamplePage} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionSamplePage(MySqlParser.TableOptionSamplePageContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionSamplePage} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionSamplePage(MySqlParser.TableOptionSamplePageContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionTablespace} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionTablespace(MySqlParser.TableOptionTablespaceContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionTablespace} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionTablespace(MySqlParser.TableOptionTablespaceContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionTableType} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionTableType(MySqlParser.TableOptionTableTypeContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionTableType} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionTableType(MySqlParser.TableOptionTableTypeContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionTransactional} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionTransactional(MySqlParser.TableOptionTransactionalContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionTransactional} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionTransactional(MySqlParser.TableOptionTransactionalContext ctx); + /** + * Enter a parse tree produced by the {@code tableOptionUnion} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void enterTableOptionUnion(MySqlParser.TableOptionUnionContext ctx); + /** + * Exit a parse tree produced by the {@code tableOptionUnion} + * labeled alternative in {@link MySqlParser#tableOption}. + * @param ctx the parse tree + */ + void exitTableOptionUnion(MySqlParser.TableOptionUnionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#tableType}. + * @param ctx the parse tree + */ + void enterTableType(MySqlParser.TableTypeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#tableType}. + * @param ctx the parse tree + */ + void exitTableType(MySqlParser.TableTypeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#tablespaceStorage}. + * @param ctx the parse tree + */ + void enterTablespaceStorage(MySqlParser.TablespaceStorageContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#tablespaceStorage}. + * @param ctx the parse tree + */ + void exitTablespaceStorage(MySqlParser.TablespaceStorageContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#partitionDefinitions}. + * @param ctx the parse tree + */ + void enterPartitionDefinitions(MySqlParser.PartitionDefinitionsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#partitionDefinitions}. + * @param ctx the parse tree + */ + void exitPartitionDefinitions(MySqlParser.PartitionDefinitionsContext ctx); + /** + * Enter a parse tree produced by the {@code partitionFunctionHash} + * labeled alternative in {@link MySqlParser#partitionFunctionDefinition}. + * @param ctx the parse tree + */ + void enterPartitionFunctionHash(MySqlParser.PartitionFunctionHashContext ctx); + /** + * Exit a parse tree produced by the {@code partitionFunctionHash} + * labeled alternative in {@link MySqlParser#partitionFunctionDefinition}. + * @param ctx the parse tree + */ + void exitPartitionFunctionHash(MySqlParser.PartitionFunctionHashContext ctx); + /** + * Enter a parse tree produced by the {@code partitionFunctionKey} + * labeled alternative in {@link MySqlParser#partitionFunctionDefinition}. + * @param ctx the parse tree + */ + void enterPartitionFunctionKey(MySqlParser.PartitionFunctionKeyContext ctx); + /** + * Exit a parse tree produced by the {@code partitionFunctionKey} + * labeled alternative in {@link MySqlParser#partitionFunctionDefinition}. + * @param ctx the parse tree + */ + void exitPartitionFunctionKey(MySqlParser.PartitionFunctionKeyContext ctx); + /** + * Enter a parse tree produced by the {@code partitionFunctionRange} + * labeled alternative in {@link MySqlParser#partitionFunctionDefinition}. + * @param ctx the parse tree + */ + void enterPartitionFunctionRange(MySqlParser.PartitionFunctionRangeContext ctx); + /** + * Exit a parse tree produced by the {@code partitionFunctionRange} + * labeled alternative in {@link MySqlParser#partitionFunctionDefinition}. + * @param ctx the parse tree + */ + void exitPartitionFunctionRange(MySqlParser.PartitionFunctionRangeContext ctx); + /** + * Enter a parse tree produced by the {@code partitionFunctionList} + * labeled alternative in {@link MySqlParser#partitionFunctionDefinition}. + * @param ctx the parse tree + */ + void enterPartitionFunctionList(MySqlParser.PartitionFunctionListContext ctx); + /** + * Exit a parse tree produced by the {@code partitionFunctionList} + * labeled alternative in {@link MySqlParser#partitionFunctionDefinition}. + * @param ctx the parse tree + */ + void exitPartitionFunctionList(MySqlParser.PartitionFunctionListContext ctx); + /** + * Enter a parse tree produced by the {@code subPartitionFunctionHash} + * labeled alternative in {@link MySqlParser#subpartitionFunctionDefinition}. + * @param ctx the parse tree + */ + void enterSubPartitionFunctionHash(MySqlParser.SubPartitionFunctionHashContext ctx); + /** + * Exit a parse tree produced by the {@code subPartitionFunctionHash} + * labeled alternative in {@link MySqlParser#subpartitionFunctionDefinition}. + * @param ctx the parse tree + */ + void exitSubPartitionFunctionHash(MySqlParser.SubPartitionFunctionHashContext ctx); + /** + * Enter a parse tree produced by the {@code subPartitionFunctionKey} + * labeled alternative in {@link MySqlParser#subpartitionFunctionDefinition}. + * @param ctx the parse tree + */ + void enterSubPartitionFunctionKey(MySqlParser.SubPartitionFunctionKeyContext ctx); + /** + * Exit a parse tree produced by the {@code subPartitionFunctionKey} + * labeled alternative in {@link MySqlParser#subpartitionFunctionDefinition}. + * @param ctx the parse tree + */ + void exitSubPartitionFunctionKey(MySqlParser.SubPartitionFunctionKeyContext ctx); + /** + * Enter a parse tree produced by the {@code partitionComparison} + * labeled alternative in {@link MySqlParser#partitionDefinition}. + * @param ctx the parse tree + */ + void enterPartitionComparison(MySqlParser.PartitionComparisonContext ctx); + /** + * Exit a parse tree produced by the {@code partitionComparison} + * labeled alternative in {@link MySqlParser#partitionDefinition}. + * @param ctx the parse tree + */ + void exitPartitionComparison(MySqlParser.PartitionComparisonContext ctx); + /** + * Enter a parse tree produced by the {@code partitionListAtom} + * labeled alternative in {@link MySqlParser#partitionDefinition}. + * @param ctx the parse tree + */ + void enterPartitionListAtom(MySqlParser.PartitionListAtomContext ctx); + /** + * Exit a parse tree produced by the {@code partitionListAtom} + * labeled alternative in {@link MySqlParser#partitionDefinition}. + * @param ctx the parse tree + */ + void exitPartitionListAtom(MySqlParser.PartitionListAtomContext ctx); + /** + * Enter a parse tree produced by the {@code partitionListVector} + * labeled alternative in {@link MySqlParser#partitionDefinition}. + * @param ctx the parse tree + */ + void enterPartitionListVector(MySqlParser.PartitionListVectorContext ctx); + /** + * Exit a parse tree produced by the {@code partitionListVector} + * labeled alternative in {@link MySqlParser#partitionDefinition}. + * @param ctx the parse tree + */ + void exitPartitionListVector(MySqlParser.PartitionListVectorContext ctx); + /** + * Enter a parse tree produced by the {@code partitionSimple} + * labeled alternative in {@link MySqlParser#partitionDefinition}. + * @param ctx the parse tree + */ + void enterPartitionSimple(MySqlParser.PartitionSimpleContext ctx); + /** + * Exit a parse tree produced by the {@code partitionSimple} + * labeled alternative in {@link MySqlParser#partitionDefinition}. + * @param ctx the parse tree + */ + void exitPartitionSimple(MySqlParser.PartitionSimpleContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#partitionDefinerAtom}. + * @param ctx the parse tree + */ + void enterPartitionDefinerAtom(MySqlParser.PartitionDefinerAtomContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#partitionDefinerAtom}. + * @param ctx the parse tree + */ + void exitPartitionDefinerAtom(MySqlParser.PartitionDefinerAtomContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#partitionDefinerVector}. + * @param ctx the parse tree + */ + void enterPartitionDefinerVector(MySqlParser.PartitionDefinerVectorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#partitionDefinerVector}. + * @param ctx the parse tree + */ + void exitPartitionDefinerVector(MySqlParser.PartitionDefinerVectorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#subpartitionDefinition}. + * @param ctx the parse tree + */ + void enterSubpartitionDefinition(MySqlParser.SubpartitionDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#subpartitionDefinition}. + * @param ctx the parse tree + */ + void exitSubpartitionDefinition(MySqlParser.SubpartitionDefinitionContext ctx); + /** + * Enter a parse tree produced by the {@code partitionOptionEngine} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void enterPartitionOptionEngine(MySqlParser.PartitionOptionEngineContext ctx); + /** + * Exit a parse tree produced by the {@code partitionOptionEngine} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void exitPartitionOptionEngine(MySqlParser.PartitionOptionEngineContext ctx); + /** + * Enter a parse tree produced by the {@code partitionOptionComment} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void enterPartitionOptionComment(MySqlParser.PartitionOptionCommentContext ctx); + /** + * Exit a parse tree produced by the {@code partitionOptionComment} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void exitPartitionOptionComment(MySqlParser.PartitionOptionCommentContext ctx); + /** + * Enter a parse tree produced by the {@code partitionOptionDataDirectory} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void enterPartitionOptionDataDirectory(MySqlParser.PartitionOptionDataDirectoryContext ctx); + /** + * Exit a parse tree produced by the {@code partitionOptionDataDirectory} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void exitPartitionOptionDataDirectory(MySqlParser.PartitionOptionDataDirectoryContext ctx); + /** + * Enter a parse tree produced by the {@code partitionOptionIndexDirectory} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void enterPartitionOptionIndexDirectory(MySqlParser.PartitionOptionIndexDirectoryContext ctx); + /** + * Exit a parse tree produced by the {@code partitionOptionIndexDirectory} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void exitPartitionOptionIndexDirectory(MySqlParser.PartitionOptionIndexDirectoryContext ctx); + /** + * Enter a parse tree produced by the {@code partitionOptionMaxRows} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void enterPartitionOptionMaxRows(MySqlParser.PartitionOptionMaxRowsContext ctx); + /** + * Exit a parse tree produced by the {@code partitionOptionMaxRows} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void exitPartitionOptionMaxRows(MySqlParser.PartitionOptionMaxRowsContext ctx); + /** + * Enter a parse tree produced by the {@code partitionOptionMinRows} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void enterPartitionOptionMinRows(MySqlParser.PartitionOptionMinRowsContext ctx); + /** + * Exit a parse tree produced by the {@code partitionOptionMinRows} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void exitPartitionOptionMinRows(MySqlParser.PartitionOptionMinRowsContext ctx); + /** + * Enter a parse tree produced by the {@code partitionOptionTablespace} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void enterPartitionOptionTablespace(MySqlParser.PartitionOptionTablespaceContext ctx); + /** + * Exit a parse tree produced by the {@code partitionOptionTablespace} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void exitPartitionOptionTablespace(MySqlParser.PartitionOptionTablespaceContext ctx); + /** + * Enter a parse tree produced by the {@code partitionOptionNodeGroup} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void enterPartitionOptionNodeGroup(MySqlParser.PartitionOptionNodeGroupContext ctx); + /** + * Exit a parse tree produced by the {@code partitionOptionNodeGroup} + * labeled alternative in {@link MySqlParser#partitionOption}. + * @param ctx the parse tree + */ + void exitPartitionOptionNodeGroup(MySqlParser.PartitionOptionNodeGroupContext ctx); + /** + * Enter a parse tree produced by the {@code alterSimpleDatabase} + * labeled alternative in {@link MySqlParser#alterDatabase}. + * @param ctx the parse tree + */ + void enterAlterSimpleDatabase(MySqlParser.AlterSimpleDatabaseContext ctx); + /** + * Exit a parse tree produced by the {@code alterSimpleDatabase} + * labeled alternative in {@link MySqlParser#alterDatabase}. + * @param ctx the parse tree + */ + void exitAlterSimpleDatabase(MySqlParser.AlterSimpleDatabaseContext ctx); + /** + * Enter a parse tree produced by the {@code alterUpgradeName} + * labeled alternative in {@link MySqlParser#alterDatabase}. + * @param ctx the parse tree + */ + void enterAlterUpgradeName(MySqlParser.AlterUpgradeNameContext ctx); + /** + * Exit a parse tree produced by the {@code alterUpgradeName} + * labeled alternative in {@link MySqlParser#alterDatabase}. + * @param ctx the parse tree + */ + void exitAlterUpgradeName(MySqlParser.AlterUpgradeNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#alterEvent}. + * @param ctx the parse tree + */ + void enterAlterEvent(MySqlParser.AlterEventContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#alterEvent}. + * @param ctx the parse tree + */ + void exitAlterEvent(MySqlParser.AlterEventContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#alterFunction}. + * @param ctx the parse tree + */ + void enterAlterFunction(MySqlParser.AlterFunctionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#alterFunction}. + * @param ctx the parse tree + */ + void exitAlterFunction(MySqlParser.AlterFunctionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#alterInstance}. + * @param ctx the parse tree + */ + void enterAlterInstance(MySqlParser.AlterInstanceContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#alterInstance}. + * @param ctx the parse tree + */ + void exitAlterInstance(MySqlParser.AlterInstanceContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#alterLogfileGroup}. + * @param ctx the parse tree + */ + void enterAlterLogfileGroup(MySqlParser.AlterLogfileGroupContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#alterLogfileGroup}. + * @param ctx the parse tree + */ + void exitAlterLogfileGroup(MySqlParser.AlterLogfileGroupContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#alterProcedure}. + * @param ctx the parse tree + */ + void enterAlterProcedure(MySqlParser.AlterProcedureContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#alterProcedure}. + * @param ctx the parse tree + */ + void exitAlterProcedure(MySqlParser.AlterProcedureContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#alterServer}. + * @param ctx the parse tree + */ + void enterAlterServer(MySqlParser.AlterServerContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#alterServer}. + * @param ctx the parse tree + */ + void exitAlterServer(MySqlParser.AlterServerContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#alterTable}. + * @param ctx the parse tree + */ + void enterAlterTable(MySqlParser.AlterTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#alterTable}. + * @param ctx the parse tree + */ + void exitAlterTable(MySqlParser.AlterTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#alterTablespace}. + * @param ctx the parse tree + */ + void enterAlterTablespace(MySqlParser.AlterTablespaceContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#alterTablespace}. + * @param ctx the parse tree + */ + void exitAlterTablespace(MySqlParser.AlterTablespaceContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#alterView}. + * @param ctx the parse tree + */ + void enterAlterView(MySqlParser.AlterViewContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#alterView}. + * @param ctx the parse tree + */ + void exitAlterView(MySqlParser.AlterViewContext ctx); + /** + * Enter a parse tree produced by the {@code alterByTableOption} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByTableOption(MySqlParser.AlterByTableOptionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByTableOption} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByTableOption(MySqlParser.AlterByTableOptionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddColumn(MySqlParser.AlterByAddColumnContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddColumn(MySqlParser.AlterByAddColumnContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddColumns} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddColumns} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddIndex} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddIndex(MySqlParser.AlterByAddIndexContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddIndex} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddIndex(MySqlParser.AlterByAddIndexContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddPrimaryKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddPrimaryKey(MySqlParser.AlterByAddPrimaryKeyContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddPrimaryKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddPrimaryKey(MySqlParser.AlterByAddPrimaryKeyContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddUniqueKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddUniqueKey(MySqlParser.AlterByAddUniqueKeyContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddUniqueKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddUniqueKey(MySqlParser.AlterByAddUniqueKeyContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddSpecialIndex} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddSpecialIndex(MySqlParser.AlterByAddSpecialIndexContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddSpecialIndex} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddSpecialIndex(MySqlParser.AlterByAddSpecialIndexContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddForeignKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddForeignKey(MySqlParser.AlterByAddForeignKeyContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddForeignKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddForeignKey(MySqlParser.AlterByAddForeignKeyContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddCheckTableConstraint} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddCheckTableConstraint(MySqlParser.AlterByAddCheckTableConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddCheckTableConstraint} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddCheckTableConstraint(MySqlParser.AlterByAddCheckTableConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAlterCheckTableConstraint} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAlterCheckTableConstraint(MySqlParser.AlterByAlterCheckTableConstraintContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAlterCheckTableConstraint} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAlterCheckTableConstraint(MySqlParser.AlterByAlterCheckTableConstraintContext ctx); + /** + * Enter a parse tree produced by the {@code alterBySetAlgorithm} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterBySetAlgorithm(MySqlParser.AlterBySetAlgorithmContext ctx); + /** + * Exit a parse tree produced by the {@code alterBySetAlgorithm} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterBySetAlgorithm(MySqlParser.AlterBySetAlgorithmContext ctx); + /** + * Enter a parse tree produced by the {@code alterByChangeDefault} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByChangeDefault(MySqlParser.AlterByChangeDefaultContext ctx); + /** + * Exit a parse tree produced by the {@code alterByChangeDefault} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByChangeDefault(MySqlParser.AlterByChangeDefaultContext ctx); + /** + * Enter a parse tree produced by the {@code alterByChangeColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByChangeColumn(MySqlParser.AlterByChangeColumnContext ctx); + /** + * Exit a parse tree produced by the {@code alterByChangeColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByChangeColumn(MySqlParser.AlterByChangeColumnContext ctx); + /** + * Enter a parse tree produced by the {@code alterByRenameColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByRenameColumn(MySqlParser.AlterByRenameColumnContext ctx); + /** + * Exit a parse tree produced by the {@code alterByRenameColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByRenameColumn(MySqlParser.AlterByRenameColumnContext ctx); + /** + * Enter a parse tree produced by the {@code alterByLock} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByLock(MySqlParser.AlterByLockContext ctx); + /** + * Exit a parse tree produced by the {@code alterByLock} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByLock(MySqlParser.AlterByLockContext ctx); + /** + * Enter a parse tree produced by the {@code alterByModifyColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByModifyColumn(MySqlParser.AlterByModifyColumnContext ctx); + /** + * Exit a parse tree produced by the {@code alterByModifyColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByModifyColumn(MySqlParser.AlterByModifyColumnContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDropColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDropColumn(MySqlParser.AlterByDropColumnContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDropColumn} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDropColumn(MySqlParser.AlterByDropColumnContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDropConstraintCheck} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDropConstraintCheck(MySqlParser.AlterByDropConstraintCheckContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDropConstraintCheck} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDropConstraintCheck(MySqlParser.AlterByDropConstraintCheckContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDropPrimaryKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDropPrimaryKey(MySqlParser.AlterByDropPrimaryKeyContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDropPrimaryKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDropPrimaryKey(MySqlParser.AlterByDropPrimaryKeyContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDropIndex} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDropIndex(MySqlParser.AlterByDropIndexContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDropIndex} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDropIndex(MySqlParser.AlterByDropIndexContext ctx); + /** + * Enter a parse tree produced by the {@code alterByRenameIndex} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByRenameIndex(MySqlParser.AlterByRenameIndexContext ctx); + /** + * Exit a parse tree produced by the {@code alterByRenameIndex} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByRenameIndex(MySqlParser.AlterByRenameIndexContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAlterColumnDefault} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAlterColumnDefault(MySqlParser.AlterByAlterColumnDefaultContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAlterColumnDefault} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAlterColumnDefault(MySqlParser.AlterByAlterColumnDefaultContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAlterIndexVisibility} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAlterIndexVisibility(MySqlParser.AlterByAlterIndexVisibilityContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAlterIndexVisibility} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAlterIndexVisibility(MySqlParser.AlterByAlterIndexVisibilityContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDropForeignKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDropForeignKey(MySqlParser.AlterByDropForeignKeyContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDropForeignKey} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDropForeignKey(MySqlParser.AlterByDropForeignKeyContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDisableKeys} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDisableKeys(MySqlParser.AlterByDisableKeysContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDisableKeys} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDisableKeys(MySqlParser.AlterByDisableKeysContext ctx); + /** + * Enter a parse tree produced by the {@code alterByEnableKeys} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByEnableKeys(MySqlParser.AlterByEnableKeysContext ctx); + /** + * Exit a parse tree produced by the {@code alterByEnableKeys} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByEnableKeys(MySqlParser.AlterByEnableKeysContext ctx); + /** + * Enter a parse tree produced by the {@code alterByRename} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByRename(MySqlParser.AlterByRenameContext ctx); + /** + * Exit a parse tree produced by the {@code alterByRename} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByRename(MySqlParser.AlterByRenameContext ctx); + /** + * Enter a parse tree produced by the {@code alterByOrder} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByOrder(MySqlParser.AlterByOrderContext ctx); + /** + * Exit a parse tree produced by the {@code alterByOrder} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByOrder(MySqlParser.AlterByOrderContext ctx); + /** + * Enter a parse tree produced by the {@code alterByConvertCharset} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByConvertCharset(MySqlParser.AlterByConvertCharsetContext ctx); + /** + * Exit a parse tree produced by the {@code alterByConvertCharset} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByConvertCharset(MySqlParser.AlterByConvertCharsetContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDefaultCharset} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDefaultCharset(MySqlParser.AlterByDefaultCharsetContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDefaultCharset} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDefaultCharset(MySqlParser.AlterByDefaultCharsetContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDiscardTablespace} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDiscardTablespace(MySqlParser.AlterByDiscardTablespaceContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDiscardTablespace} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDiscardTablespace(MySqlParser.AlterByDiscardTablespaceContext ctx); + /** + * Enter a parse tree produced by the {@code alterByImportTablespace} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByImportTablespace(MySqlParser.AlterByImportTablespaceContext ctx); + /** + * Exit a parse tree produced by the {@code alterByImportTablespace} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByImportTablespace(MySqlParser.AlterByImportTablespaceContext ctx); + /** + * Enter a parse tree produced by the {@code alterByForce} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByForce(MySqlParser.AlterByForceContext ctx); + /** + * Exit a parse tree produced by the {@code alterByForce} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByForce(MySqlParser.AlterByForceContext ctx); + /** + * Enter a parse tree produced by the {@code alterByValidate} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByValidate(MySqlParser.AlterByValidateContext ctx); + /** + * Exit a parse tree produced by the {@code alterByValidate} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByValidate(MySqlParser.AlterByValidateContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddDefinitions} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddDefinitions(MySqlParser.AlterByAddDefinitionsContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddDefinitions} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddDefinitions(MySqlParser.AlterByAddDefinitionsContext ctx); + /** + * Enter a parse tree produced by the {@code alterPartition} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void enterAlterPartition(MySqlParser.AlterPartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterPartition} + * labeled alternative in {@link MySqlParser#alterSpecification}. + * @param ctx the parse tree + */ + void exitAlterPartition(MySqlParser.AlterPartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAddPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAddPartition(MySqlParser.AlterByAddPartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAddPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAddPartition(MySqlParser.AlterByAddPartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDropPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDropPartition(MySqlParser.AlterByDropPartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDropPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDropPartition(MySqlParser.AlterByDropPartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByDiscardPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByDiscardPartition(MySqlParser.AlterByDiscardPartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByDiscardPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByDiscardPartition(MySqlParser.AlterByDiscardPartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByImportPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByImportPartition(MySqlParser.AlterByImportPartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByImportPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByImportPartition(MySqlParser.AlterByImportPartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByTruncatePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByTruncatePartition(MySqlParser.AlterByTruncatePartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByTruncatePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByTruncatePartition(MySqlParser.AlterByTruncatePartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByCoalescePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByCoalescePartition(MySqlParser.AlterByCoalescePartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByCoalescePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByCoalescePartition(MySqlParser.AlterByCoalescePartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByReorganizePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByReorganizePartition(MySqlParser.AlterByReorganizePartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByReorganizePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByReorganizePartition(MySqlParser.AlterByReorganizePartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByExchangePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByExchangePartition(MySqlParser.AlterByExchangePartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByExchangePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByExchangePartition(MySqlParser.AlterByExchangePartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByAnalyzePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByAnalyzePartition(MySqlParser.AlterByAnalyzePartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByAnalyzePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByAnalyzePartition(MySqlParser.AlterByAnalyzePartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByCheckPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByCheckPartition(MySqlParser.AlterByCheckPartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByCheckPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByCheckPartition(MySqlParser.AlterByCheckPartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByOptimizePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByOptimizePartition(MySqlParser.AlterByOptimizePartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByOptimizePartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByOptimizePartition(MySqlParser.AlterByOptimizePartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByRebuildPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByRebuildPartition(MySqlParser.AlterByRebuildPartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByRebuildPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByRebuildPartition(MySqlParser.AlterByRebuildPartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByRepairPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByRepairPartition(MySqlParser.AlterByRepairPartitionContext ctx); + /** + * Exit a parse tree produced by the {@code alterByRepairPartition} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByRepairPartition(MySqlParser.AlterByRepairPartitionContext ctx); + /** + * Enter a parse tree produced by the {@code alterByRemovePartitioning} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByRemovePartitioning(MySqlParser.AlterByRemovePartitioningContext ctx); + /** + * Exit a parse tree produced by the {@code alterByRemovePartitioning} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByRemovePartitioning(MySqlParser.AlterByRemovePartitioningContext ctx); + /** + * Enter a parse tree produced by the {@code alterByUpgradePartitioning} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void enterAlterByUpgradePartitioning(MySqlParser.AlterByUpgradePartitioningContext ctx); + /** + * Exit a parse tree produced by the {@code alterByUpgradePartitioning} + * labeled alternative in {@link MySqlParser#alterPartitionSpecification}. + * @param ctx the parse tree + */ + void exitAlterByUpgradePartitioning(MySqlParser.AlterByUpgradePartitioningContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropDatabase}. + * @param ctx the parse tree + */ + void enterDropDatabase(MySqlParser.DropDatabaseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropDatabase}. + * @param ctx the parse tree + */ + void exitDropDatabase(MySqlParser.DropDatabaseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropEvent}. + * @param ctx the parse tree + */ + void enterDropEvent(MySqlParser.DropEventContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropEvent}. + * @param ctx the parse tree + */ + void exitDropEvent(MySqlParser.DropEventContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropIndex}. + * @param ctx the parse tree + */ + void enterDropIndex(MySqlParser.DropIndexContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropIndex}. + * @param ctx the parse tree + */ + void exitDropIndex(MySqlParser.DropIndexContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropLogfileGroup}. + * @param ctx the parse tree + */ + void enterDropLogfileGroup(MySqlParser.DropLogfileGroupContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropLogfileGroup}. + * @param ctx the parse tree + */ + void exitDropLogfileGroup(MySqlParser.DropLogfileGroupContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropProcedure}. + * @param ctx the parse tree + */ + void enterDropProcedure(MySqlParser.DropProcedureContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropProcedure}. + * @param ctx the parse tree + */ + void exitDropProcedure(MySqlParser.DropProcedureContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropFunction}. + * @param ctx the parse tree + */ + void enterDropFunction(MySqlParser.DropFunctionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropFunction}. + * @param ctx the parse tree + */ + void exitDropFunction(MySqlParser.DropFunctionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropServer}. + * @param ctx the parse tree + */ + void enterDropServer(MySqlParser.DropServerContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropServer}. + * @param ctx the parse tree + */ + void exitDropServer(MySqlParser.DropServerContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropTable}. + * @param ctx the parse tree + */ + void enterDropTable(MySqlParser.DropTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropTable}. + * @param ctx the parse tree + */ + void exitDropTable(MySqlParser.DropTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropTablespace}. + * @param ctx the parse tree + */ + void enterDropTablespace(MySqlParser.DropTablespaceContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropTablespace}. + * @param ctx the parse tree + */ + void exitDropTablespace(MySqlParser.DropTablespaceContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropTrigger}. + * @param ctx the parse tree + */ + void enterDropTrigger(MySqlParser.DropTriggerContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropTrigger}. + * @param ctx the parse tree + */ + void exitDropTrigger(MySqlParser.DropTriggerContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropView}. + * @param ctx the parse tree + */ + void enterDropView(MySqlParser.DropViewContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropView}. + * @param ctx the parse tree + */ + void exitDropView(MySqlParser.DropViewContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropRole}. + * @param ctx the parse tree + */ + void enterDropRole(MySqlParser.DropRoleContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropRole}. + * @param ctx the parse tree + */ + void exitDropRole(MySqlParser.DropRoleContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#setRole}. + * @param ctx the parse tree + */ + void enterSetRole(MySqlParser.SetRoleContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#setRole}. + * @param ctx the parse tree + */ + void exitSetRole(MySqlParser.SetRoleContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#renameTable}. + * @param ctx the parse tree + */ + void enterRenameTable(MySqlParser.RenameTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#renameTable}. + * @param ctx the parse tree + */ + void exitRenameTable(MySqlParser.RenameTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#renameTableClause}. + * @param ctx the parse tree + */ + void enterRenameTableClause(MySqlParser.RenameTableClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#renameTableClause}. + * @param ctx the parse tree + */ + void exitRenameTableClause(MySqlParser.RenameTableClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#truncateTable}. + * @param ctx the parse tree + */ + void enterTruncateTable(MySqlParser.TruncateTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#truncateTable}. + * @param ctx the parse tree + */ + void exitTruncateTable(MySqlParser.TruncateTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#callStatement}. + * @param ctx the parse tree + */ + void enterCallStatement(MySqlParser.CallStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#callStatement}. + * @param ctx the parse tree + */ + void exitCallStatement(MySqlParser.CallStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#deleteStatement}. + * @param ctx the parse tree + */ + void enterDeleteStatement(MySqlParser.DeleteStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#deleteStatement}. + * @param ctx the parse tree + */ + void exitDeleteStatement(MySqlParser.DeleteStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#doStatement}. + * @param ctx the parse tree + */ + void enterDoStatement(MySqlParser.DoStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#doStatement}. + * @param ctx the parse tree + */ + void exitDoStatement(MySqlParser.DoStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#handlerStatement}. + * @param ctx the parse tree + */ + void enterHandlerStatement(MySqlParser.HandlerStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#handlerStatement}. + * @param ctx the parse tree + */ + void exitHandlerStatement(MySqlParser.HandlerStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#insertStatement}. + * @param ctx the parse tree + */ + void enterInsertStatement(MySqlParser.InsertStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#insertStatement}. + * @param ctx the parse tree + */ + void exitInsertStatement(MySqlParser.InsertStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#loadDataStatement}. + * @param ctx the parse tree + */ + void enterLoadDataStatement(MySqlParser.LoadDataStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#loadDataStatement}. + * @param ctx the parse tree + */ + void exitLoadDataStatement(MySqlParser.LoadDataStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#loadXmlStatement}. + * @param ctx the parse tree + */ + void enterLoadXmlStatement(MySqlParser.LoadXmlStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#loadXmlStatement}. + * @param ctx the parse tree + */ + void exitLoadXmlStatement(MySqlParser.LoadXmlStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#replaceStatement}. + * @param ctx the parse tree + */ + void enterReplaceStatement(MySqlParser.ReplaceStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#replaceStatement}. + * @param ctx the parse tree + */ + void exitReplaceStatement(MySqlParser.ReplaceStatementContext ctx); + /** + * Enter a parse tree produced by the {@code simpleSelect} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void enterSimpleSelect(MySqlParser.SimpleSelectContext ctx); + /** + * Exit a parse tree produced by the {@code simpleSelect} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void exitSimpleSelect(MySqlParser.SimpleSelectContext ctx); + /** + * Enter a parse tree produced by the {@code parenthesisSelect} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void enterParenthesisSelect(MySqlParser.ParenthesisSelectContext ctx); + /** + * Exit a parse tree produced by the {@code parenthesisSelect} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void exitParenthesisSelect(MySqlParser.ParenthesisSelectContext ctx); + /** + * Enter a parse tree produced by the {@code unionSelect} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void enterUnionSelect(MySqlParser.UnionSelectContext ctx); + /** + * Exit a parse tree produced by the {@code unionSelect} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void exitUnionSelect(MySqlParser.UnionSelectContext ctx); + /** + * Enter a parse tree produced by the {@code unionParenthesisSelect} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void enterUnionParenthesisSelect(MySqlParser.UnionParenthesisSelectContext ctx); + /** + * Exit a parse tree produced by the {@code unionParenthesisSelect} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void exitUnionParenthesisSelect(MySqlParser.UnionParenthesisSelectContext ctx); + /** + * Enter a parse tree produced by the {@code withLateralStatement} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void enterWithLateralStatement(MySqlParser.WithLateralStatementContext ctx); + /** + * Exit a parse tree produced by the {@code withLateralStatement} + * labeled alternative in {@link MySqlParser#selectStatement}. + * @param ctx the parse tree + */ + void exitWithLateralStatement(MySqlParser.WithLateralStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#updateStatement}. + * @param ctx the parse tree + */ + void enterUpdateStatement(MySqlParser.UpdateStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#updateStatement}. + * @param ctx the parse tree + */ + void exitUpdateStatement(MySqlParser.UpdateStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#valuesStatement}. + * @param ctx the parse tree + */ + void enterValuesStatement(MySqlParser.ValuesStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#valuesStatement}. + * @param ctx the parse tree + */ + void exitValuesStatement(MySqlParser.ValuesStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#insertStatementValue}. + * @param ctx the parse tree + */ + void enterInsertStatementValue(MySqlParser.InsertStatementValueContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#insertStatementValue}. + * @param ctx the parse tree + */ + void exitInsertStatementValue(MySqlParser.InsertStatementValueContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#updatedElement}. + * @param ctx the parse tree + */ + void enterUpdatedElement(MySqlParser.UpdatedElementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#updatedElement}. + * @param ctx the parse tree + */ + void exitUpdatedElement(MySqlParser.UpdatedElementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#assignmentField}. + * @param ctx the parse tree + */ + void enterAssignmentField(MySqlParser.AssignmentFieldContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#assignmentField}. + * @param ctx the parse tree + */ + void exitAssignmentField(MySqlParser.AssignmentFieldContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#lockClause}. + * @param ctx the parse tree + */ + void enterLockClause(MySqlParser.LockClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#lockClause}. + * @param ctx the parse tree + */ + void exitLockClause(MySqlParser.LockClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#singleDeleteStatement}. + * @param ctx the parse tree + */ + void enterSingleDeleteStatement(MySqlParser.SingleDeleteStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#singleDeleteStatement}. + * @param ctx the parse tree + */ + void exitSingleDeleteStatement(MySqlParser.SingleDeleteStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#multipleDeleteStatement}. + * @param ctx the parse tree + */ + void enterMultipleDeleteStatement(MySqlParser.MultipleDeleteStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#multipleDeleteStatement}. + * @param ctx the parse tree + */ + void exitMultipleDeleteStatement(MySqlParser.MultipleDeleteStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#handlerOpenStatement}. + * @param ctx the parse tree + */ + void enterHandlerOpenStatement(MySqlParser.HandlerOpenStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#handlerOpenStatement}. + * @param ctx the parse tree + */ + void exitHandlerOpenStatement(MySqlParser.HandlerOpenStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#handlerReadIndexStatement}. + * @param ctx the parse tree + */ + void enterHandlerReadIndexStatement(MySqlParser.HandlerReadIndexStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#handlerReadIndexStatement}. + * @param ctx the parse tree + */ + void exitHandlerReadIndexStatement(MySqlParser.HandlerReadIndexStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#handlerReadStatement}. + * @param ctx the parse tree + */ + void enterHandlerReadStatement(MySqlParser.HandlerReadStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#handlerReadStatement}. + * @param ctx the parse tree + */ + void exitHandlerReadStatement(MySqlParser.HandlerReadStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#handlerCloseStatement}. + * @param ctx the parse tree + */ + void enterHandlerCloseStatement(MySqlParser.HandlerCloseStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#handlerCloseStatement}. + * @param ctx the parse tree + */ + void exitHandlerCloseStatement(MySqlParser.HandlerCloseStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#singleUpdateStatement}. + * @param ctx the parse tree + */ + void enterSingleUpdateStatement(MySqlParser.SingleUpdateStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#singleUpdateStatement}. + * @param ctx the parse tree + */ + void exitSingleUpdateStatement(MySqlParser.SingleUpdateStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#multipleUpdateStatement}. + * @param ctx the parse tree + */ + void enterMultipleUpdateStatement(MySqlParser.MultipleUpdateStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#multipleUpdateStatement}. + * @param ctx the parse tree + */ + void exitMultipleUpdateStatement(MySqlParser.MultipleUpdateStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#orderByClause}. + * @param ctx the parse tree + */ + void enterOrderByClause(MySqlParser.OrderByClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#orderByClause}. + * @param ctx the parse tree + */ + void exitOrderByClause(MySqlParser.OrderByClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#orderByExpression}. + * @param ctx the parse tree + */ + void enterOrderByExpression(MySqlParser.OrderByExpressionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#orderByExpression}. + * @param ctx the parse tree + */ + void exitOrderByExpression(MySqlParser.OrderByExpressionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#tableSources}. + * @param ctx the parse tree + */ + void enterTableSources(MySqlParser.TableSourcesContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#tableSources}. + * @param ctx the parse tree + */ + void exitTableSources(MySqlParser.TableSourcesContext ctx); + /** + * Enter a parse tree produced by the {@code tableSourceBase} + * labeled alternative in {@link MySqlParser#tableSource}. + * @param ctx the parse tree + */ + void enterTableSourceBase(MySqlParser.TableSourceBaseContext ctx); + /** + * Exit a parse tree produced by the {@code tableSourceBase} + * labeled alternative in {@link MySqlParser#tableSource}. + * @param ctx the parse tree + */ + void exitTableSourceBase(MySqlParser.TableSourceBaseContext ctx); + /** + * Enter a parse tree produced by the {@code tableSourceNested} + * labeled alternative in {@link MySqlParser#tableSource}. + * @param ctx the parse tree + */ + void enterTableSourceNested(MySqlParser.TableSourceNestedContext ctx); + /** + * Exit a parse tree produced by the {@code tableSourceNested} + * labeled alternative in {@link MySqlParser#tableSource}. + * @param ctx the parse tree + */ + void exitTableSourceNested(MySqlParser.TableSourceNestedContext ctx); + /** + * Enter a parse tree produced by the {@code tableJson} + * labeled alternative in {@link MySqlParser#tableSource}. + * @param ctx the parse tree + */ + void enterTableJson(MySqlParser.TableJsonContext ctx); + /** + * Exit a parse tree produced by the {@code tableJson} + * labeled alternative in {@link MySqlParser#tableSource}. + * @param ctx the parse tree + */ + void exitTableJson(MySqlParser.TableJsonContext ctx); + /** + * Enter a parse tree produced by the {@code atomTableItem} + * labeled alternative in {@link MySqlParser#tableSourceItem}. + * @param ctx the parse tree + */ + void enterAtomTableItem(MySqlParser.AtomTableItemContext ctx); + /** + * Exit a parse tree produced by the {@code atomTableItem} + * labeled alternative in {@link MySqlParser#tableSourceItem}. + * @param ctx the parse tree + */ + void exitAtomTableItem(MySqlParser.AtomTableItemContext ctx); + /** + * Enter a parse tree produced by the {@code subqueryTableItem} + * labeled alternative in {@link MySqlParser#tableSourceItem}. + * @param ctx the parse tree + */ + void enterSubqueryTableItem(MySqlParser.SubqueryTableItemContext ctx); + /** + * Exit a parse tree produced by the {@code subqueryTableItem} + * labeled alternative in {@link MySqlParser#tableSourceItem}. + * @param ctx the parse tree + */ + void exitSubqueryTableItem(MySqlParser.SubqueryTableItemContext ctx); + /** + * Enter a parse tree produced by the {@code tableSourcesItem} + * labeled alternative in {@link MySqlParser#tableSourceItem}. + * @param ctx the parse tree + */ + void enterTableSourcesItem(MySqlParser.TableSourcesItemContext ctx); + /** + * Exit a parse tree produced by the {@code tableSourcesItem} + * labeled alternative in {@link MySqlParser#tableSourceItem}. + * @param ctx the parse tree + */ + void exitTableSourcesItem(MySqlParser.TableSourcesItemContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#indexHint}. + * @param ctx the parse tree + */ + void enterIndexHint(MySqlParser.IndexHintContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#indexHint}. + * @param ctx the parse tree + */ + void exitIndexHint(MySqlParser.IndexHintContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#indexHintType}. + * @param ctx the parse tree + */ + void enterIndexHintType(MySqlParser.IndexHintTypeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#indexHintType}. + * @param ctx the parse tree + */ + void exitIndexHintType(MySqlParser.IndexHintTypeContext ctx); + /** + * Enter a parse tree produced by the {@code innerJoin} + * labeled alternative in {@link MySqlParser#joinPart}. + * @param ctx the parse tree + */ + void enterInnerJoin(MySqlParser.InnerJoinContext ctx); + /** + * Exit a parse tree produced by the {@code innerJoin} + * labeled alternative in {@link MySqlParser#joinPart}. + * @param ctx the parse tree + */ + void exitInnerJoin(MySqlParser.InnerJoinContext ctx); + /** + * Enter a parse tree produced by the {@code straightJoin} + * labeled alternative in {@link MySqlParser#joinPart}. + * @param ctx the parse tree + */ + void enterStraightJoin(MySqlParser.StraightJoinContext ctx); + /** + * Exit a parse tree produced by the {@code straightJoin} + * labeled alternative in {@link MySqlParser#joinPart}. + * @param ctx the parse tree + */ + void exitStraightJoin(MySqlParser.StraightJoinContext ctx); + /** + * Enter a parse tree produced by the {@code outerJoin} + * labeled alternative in {@link MySqlParser#joinPart}. + * @param ctx the parse tree + */ + void enterOuterJoin(MySqlParser.OuterJoinContext ctx); + /** + * Exit a parse tree produced by the {@code outerJoin} + * labeled alternative in {@link MySqlParser#joinPart}. + * @param ctx the parse tree + */ + void exitOuterJoin(MySqlParser.OuterJoinContext ctx); + /** + * Enter a parse tree produced by the {@code naturalJoin} + * labeled alternative in {@link MySqlParser#joinPart}. + * @param ctx the parse tree + */ + void enterNaturalJoin(MySqlParser.NaturalJoinContext ctx); + /** + * Exit a parse tree produced by the {@code naturalJoin} + * labeled alternative in {@link MySqlParser#joinPart}. + * @param ctx the parse tree + */ + void exitNaturalJoin(MySqlParser.NaturalJoinContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#joinSpec}. + * @param ctx the parse tree + */ + void enterJoinSpec(MySqlParser.JoinSpecContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#joinSpec}. + * @param ctx the parse tree + */ + void exitJoinSpec(MySqlParser.JoinSpecContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#queryExpression}. + * @param ctx the parse tree + */ + void enterQueryExpression(MySqlParser.QueryExpressionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#queryExpression}. + * @param ctx the parse tree + */ + void exitQueryExpression(MySqlParser.QueryExpressionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#queryExpressionNointo}. + * @param ctx the parse tree + */ + void enterQueryExpressionNointo(MySqlParser.QueryExpressionNointoContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#queryExpressionNointo}. + * @param ctx the parse tree + */ + void exitQueryExpressionNointo(MySqlParser.QueryExpressionNointoContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#querySpecification}. + * @param ctx the parse tree + */ + void enterQuerySpecification(MySqlParser.QuerySpecificationContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#querySpecification}. + * @param ctx the parse tree + */ + void exitQuerySpecification(MySqlParser.QuerySpecificationContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#querySpecificationNointo}. + * @param ctx the parse tree + */ + void enterQuerySpecificationNointo(MySqlParser.QuerySpecificationNointoContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#querySpecificationNointo}. + * @param ctx the parse tree + */ + void exitQuerySpecificationNointo(MySqlParser.QuerySpecificationNointoContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#unionParenthesis}. + * @param ctx the parse tree + */ + void enterUnionParenthesis(MySqlParser.UnionParenthesisContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#unionParenthesis}. + * @param ctx the parse tree + */ + void exitUnionParenthesis(MySqlParser.UnionParenthesisContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#unionStatement}. + * @param ctx the parse tree + */ + void enterUnionStatement(MySqlParser.UnionStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#unionStatement}. + * @param ctx the parse tree + */ + void exitUnionStatement(MySqlParser.UnionStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#lateralStatement}. + * @param ctx the parse tree + */ + void enterLateralStatement(MySqlParser.LateralStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#lateralStatement}. + * @param ctx the parse tree + */ + void exitLateralStatement(MySqlParser.LateralStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#jsonTable}. + * @param ctx the parse tree + */ + void enterJsonTable(MySqlParser.JsonTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#jsonTable}. + * @param ctx the parse tree + */ + void exitJsonTable(MySqlParser.JsonTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#jsonColumnList}. + * @param ctx the parse tree + */ + void enterJsonColumnList(MySqlParser.JsonColumnListContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#jsonColumnList}. + * @param ctx the parse tree + */ + void exitJsonColumnList(MySqlParser.JsonColumnListContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#jsonColumn}. + * @param ctx the parse tree + */ + void enterJsonColumn(MySqlParser.JsonColumnContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#jsonColumn}. + * @param ctx the parse tree + */ + void exitJsonColumn(MySqlParser.JsonColumnContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#jsonOnEmpty}. + * @param ctx the parse tree + */ + void enterJsonOnEmpty(MySqlParser.JsonOnEmptyContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#jsonOnEmpty}. + * @param ctx the parse tree + */ + void exitJsonOnEmpty(MySqlParser.JsonOnEmptyContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#jsonOnError}. + * @param ctx the parse tree + */ + void enterJsonOnError(MySqlParser.JsonOnErrorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#jsonOnError}. + * @param ctx the parse tree + */ + void exitJsonOnError(MySqlParser.JsonOnErrorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#selectSpec}. + * @param ctx the parse tree + */ + void enterSelectSpec(MySqlParser.SelectSpecContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#selectSpec}. + * @param ctx the parse tree + */ + void exitSelectSpec(MySqlParser.SelectSpecContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#selectElements}. + * @param ctx the parse tree + */ + void enterSelectElements(MySqlParser.SelectElementsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#selectElements}. + * @param ctx the parse tree + */ + void exitSelectElements(MySqlParser.SelectElementsContext ctx); + /** + * Enter a parse tree produced by the {@code selectStarElement} + * labeled alternative in {@link MySqlParser#selectElement}. + * @param ctx the parse tree + */ + void enterSelectStarElement(MySqlParser.SelectStarElementContext ctx); + /** + * Exit a parse tree produced by the {@code selectStarElement} + * labeled alternative in {@link MySqlParser#selectElement}. + * @param ctx the parse tree + */ + void exitSelectStarElement(MySqlParser.SelectStarElementContext ctx); + /** + * Enter a parse tree produced by the {@code selectColumnElement} + * labeled alternative in {@link MySqlParser#selectElement}. + * @param ctx the parse tree + */ + void enterSelectColumnElement(MySqlParser.SelectColumnElementContext ctx); + /** + * Exit a parse tree produced by the {@code selectColumnElement} + * labeled alternative in {@link MySqlParser#selectElement}. + * @param ctx the parse tree + */ + void exitSelectColumnElement(MySqlParser.SelectColumnElementContext ctx); + /** + * Enter a parse tree produced by the {@code selectFunctionElement} + * labeled alternative in {@link MySqlParser#selectElement}. + * @param ctx the parse tree + */ + void enterSelectFunctionElement(MySqlParser.SelectFunctionElementContext ctx); + /** + * Exit a parse tree produced by the {@code selectFunctionElement} + * labeled alternative in {@link MySqlParser#selectElement}. + * @param ctx the parse tree + */ + void exitSelectFunctionElement(MySqlParser.SelectFunctionElementContext ctx); + /** + * Enter a parse tree produced by the {@code selectExpressionElement} + * labeled alternative in {@link MySqlParser#selectElement}. + * @param ctx the parse tree + */ + void enterSelectExpressionElement(MySqlParser.SelectExpressionElementContext ctx); + /** + * Exit a parse tree produced by the {@code selectExpressionElement} + * labeled alternative in {@link MySqlParser#selectElement}. + * @param ctx the parse tree + */ + void exitSelectExpressionElement(MySqlParser.SelectExpressionElementContext ctx); + /** + * Enter a parse tree produced by the {@code selectIntoVariables} + * labeled alternative in {@link MySqlParser#selectIntoExpression}. + * @param ctx the parse tree + */ + void enterSelectIntoVariables(MySqlParser.SelectIntoVariablesContext ctx); + /** + * Exit a parse tree produced by the {@code selectIntoVariables} + * labeled alternative in {@link MySqlParser#selectIntoExpression}. + * @param ctx the parse tree + */ + void exitSelectIntoVariables(MySqlParser.SelectIntoVariablesContext ctx); + /** + * Enter a parse tree produced by the {@code selectIntoDumpFile} + * labeled alternative in {@link MySqlParser#selectIntoExpression}. + * @param ctx the parse tree + */ + void enterSelectIntoDumpFile(MySqlParser.SelectIntoDumpFileContext ctx); + /** + * Exit a parse tree produced by the {@code selectIntoDumpFile} + * labeled alternative in {@link MySqlParser#selectIntoExpression}. + * @param ctx the parse tree + */ + void exitSelectIntoDumpFile(MySqlParser.SelectIntoDumpFileContext ctx); + /** + * Enter a parse tree produced by the {@code selectIntoTextFile} + * labeled alternative in {@link MySqlParser#selectIntoExpression}. + * @param ctx the parse tree + */ + void enterSelectIntoTextFile(MySqlParser.SelectIntoTextFileContext ctx); + /** + * Exit a parse tree produced by the {@code selectIntoTextFile} + * labeled alternative in {@link MySqlParser#selectIntoExpression}. + * @param ctx the parse tree + */ + void exitSelectIntoTextFile(MySqlParser.SelectIntoTextFileContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#selectFieldsInto}. + * @param ctx the parse tree + */ + void enterSelectFieldsInto(MySqlParser.SelectFieldsIntoContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#selectFieldsInto}. + * @param ctx the parse tree + */ + void exitSelectFieldsInto(MySqlParser.SelectFieldsIntoContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#selectLinesInto}. + * @param ctx the parse tree + */ + void enterSelectLinesInto(MySqlParser.SelectLinesIntoContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#selectLinesInto}. + * @param ctx the parse tree + */ + void exitSelectLinesInto(MySqlParser.SelectLinesIntoContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#fromClause}. + * @param ctx the parse tree + */ + void enterFromClause(MySqlParser.FromClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#fromClause}. + * @param ctx the parse tree + */ + void exitFromClause(MySqlParser.FromClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#groupByClause}. + * @param ctx the parse tree + */ + void enterGroupByClause(MySqlParser.GroupByClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#groupByClause}. + * @param ctx the parse tree + */ + void exitGroupByClause(MySqlParser.GroupByClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#havingClause}. + * @param ctx the parse tree + */ + void enterHavingClause(MySqlParser.HavingClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#havingClause}. + * @param ctx the parse tree + */ + void exitHavingClause(MySqlParser.HavingClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#windowClause}. + * @param ctx the parse tree + */ + void enterWindowClause(MySqlParser.WindowClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#windowClause}. + * @param ctx the parse tree + */ + void exitWindowClause(MySqlParser.WindowClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#groupByItem}. + * @param ctx the parse tree + */ + void enterGroupByItem(MySqlParser.GroupByItemContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#groupByItem}. + * @param ctx the parse tree + */ + void exitGroupByItem(MySqlParser.GroupByItemContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#limitClause}. + * @param ctx the parse tree + */ + void enterLimitClause(MySqlParser.LimitClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#limitClause}. + * @param ctx the parse tree + */ + void exitLimitClause(MySqlParser.LimitClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#limitClauseAtom}. + * @param ctx the parse tree + */ + void enterLimitClauseAtom(MySqlParser.LimitClauseAtomContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#limitClauseAtom}. + * @param ctx the parse tree + */ + void exitLimitClauseAtom(MySqlParser.LimitClauseAtomContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#startTransaction}. + * @param ctx the parse tree + */ + void enterStartTransaction(MySqlParser.StartTransactionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#startTransaction}. + * @param ctx the parse tree + */ + void exitStartTransaction(MySqlParser.StartTransactionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#beginWork}. + * @param ctx the parse tree + */ + void enterBeginWork(MySqlParser.BeginWorkContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#beginWork}. + * @param ctx the parse tree + */ + void exitBeginWork(MySqlParser.BeginWorkContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#commitWork}. + * @param ctx the parse tree + */ + void enterCommitWork(MySqlParser.CommitWorkContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#commitWork}. + * @param ctx the parse tree + */ + void exitCommitWork(MySqlParser.CommitWorkContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#rollbackWork}. + * @param ctx the parse tree + */ + void enterRollbackWork(MySqlParser.RollbackWorkContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#rollbackWork}. + * @param ctx the parse tree + */ + void exitRollbackWork(MySqlParser.RollbackWorkContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#savepointStatement}. + * @param ctx the parse tree + */ + void enterSavepointStatement(MySqlParser.SavepointStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#savepointStatement}. + * @param ctx the parse tree + */ + void exitSavepointStatement(MySqlParser.SavepointStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#rollbackStatement}. + * @param ctx the parse tree + */ + void enterRollbackStatement(MySqlParser.RollbackStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#rollbackStatement}. + * @param ctx the parse tree + */ + void exitRollbackStatement(MySqlParser.RollbackStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#releaseStatement}. + * @param ctx the parse tree + */ + void enterReleaseStatement(MySqlParser.ReleaseStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#releaseStatement}. + * @param ctx the parse tree + */ + void exitReleaseStatement(MySqlParser.ReleaseStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#lockTables}. + * @param ctx the parse tree + */ + void enterLockTables(MySqlParser.LockTablesContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#lockTables}. + * @param ctx the parse tree + */ + void exitLockTables(MySqlParser.LockTablesContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#unlockTables}. + * @param ctx the parse tree + */ + void enterUnlockTables(MySqlParser.UnlockTablesContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#unlockTables}. + * @param ctx the parse tree + */ + void exitUnlockTables(MySqlParser.UnlockTablesContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#setAutocommitStatement}. + * @param ctx the parse tree + */ + void enterSetAutocommitStatement(MySqlParser.SetAutocommitStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#setAutocommitStatement}. + * @param ctx the parse tree + */ + void exitSetAutocommitStatement(MySqlParser.SetAutocommitStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#setTransactionStatement}. + * @param ctx the parse tree + */ + void enterSetTransactionStatement(MySqlParser.SetTransactionStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#setTransactionStatement}. + * @param ctx the parse tree + */ + void exitSetTransactionStatement(MySqlParser.SetTransactionStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#transactionMode}. + * @param ctx the parse tree + */ + void enterTransactionMode(MySqlParser.TransactionModeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#transactionMode}. + * @param ctx the parse tree + */ + void exitTransactionMode(MySqlParser.TransactionModeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#lockTableElement}. + * @param ctx the parse tree + */ + void enterLockTableElement(MySqlParser.LockTableElementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#lockTableElement}. + * @param ctx the parse tree + */ + void exitLockTableElement(MySqlParser.LockTableElementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#lockAction}. + * @param ctx the parse tree + */ + void enterLockAction(MySqlParser.LockActionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#lockAction}. + * @param ctx the parse tree + */ + void exitLockAction(MySqlParser.LockActionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#transactionOption}. + * @param ctx the parse tree + */ + void enterTransactionOption(MySqlParser.TransactionOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#transactionOption}. + * @param ctx the parse tree + */ + void exitTransactionOption(MySqlParser.TransactionOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#transactionLevel}. + * @param ctx the parse tree + */ + void enterTransactionLevel(MySqlParser.TransactionLevelContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#transactionLevel}. + * @param ctx the parse tree + */ + void exitTransactionLevel(MySqlParser.TransactionLevelContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#changeMaster}. + * @param ctx the parse tree + */ + void enterChangeMaster(MySqlParser.ChangeMasterContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#changeMaster}. + * @param ctx the parse tree + */ + void exitChangeMaster(MySqlParser.ChangeMasterContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#changeReplicationFilter}. + * @param ctx the parse tree + */ + void enterChangeReplicationFilter(MySqlParser.ChangeReplicationFilterContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#changeReplicationFilter}. + * @param ctx the parse tree + */ + void exitChangeReplicationFilter(MySqlParser.ChangeReplicationFilterContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#purgeBinaryLogs}. + * @param ctx the parse tree + */ + void enterPurgeBinaryLogs(MySqlParser.PurgeBinaryLogsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#purgeBinaryLogs}. + * @param ctx the parse tree + */ + void exitPurgeBinaryLogs(MySqlParser.PurgeBinaryLogsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#resetMaster}. + * @param ctx the parse tree + */ + void enterResetMaster(MySqlParser.ResetMasterContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#resetMaster}. + * @param ctx the parse tree + */ + void exitResetMaster(MySqlParser.ResetMasterContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#resetSlave}. + * @param ctx the parse tree + */ + void enterResetSlave(MySqlParser.ResetSlaveContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#resetSlave}. + * @param ctx the parse tree + */ + void exitResetSlave(MySqlParser.ResetSlaveContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#startSlave}. + * @param ctx the parse tree + */ + void enterStartSlave(MySqlParser.StartSlaveContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#startSlave}. + * @param ctx the parse tree + */ + void exitStartSlave(MySqlParser.StartSlaveContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#stopSlave}. + * @param ctx the parse tree + */ + void enterStopSlave(MySqlParser.StopSlaveContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#stopSlave}. + * @param ctx the parse tree + */ + void exitStopSlave(MySqlParser.StopSlaveContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#startGroupReplication}. + * @param ctx the parse tree + */ + void enterStartGroupReplication(MySqlParser.StartGroupReplicationContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#startGroupReplication}. + * @param ctx the parse tree + */ + void exitStartGroupReplication(MySqlParser.StartGroupReplicationContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#stopGroupReplication}. + * @param ctx the parse tree + */ + void enterStopGroupReplication(MySqlParser.StopGroupReplicationContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#stopGroupReplication}. + * @param ctx the parse tree + */ + void exitStopGroupReplication(MySqlParser.StopGroupReplicationContext ctx); + /** + * Enter a parse tree produced by the {@code masterStringOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void enterMasterStringOption(MySqlParser.MasterStringOptionContext ctx); + /** + * Exit a parse tree produced by the {@code masterStringOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void exitMasterStringOption(MySqlParser.MasterStringOptionContext ctx); + /** + * Enter a parse tree produced by the {@code masterDecimalOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void enterMasterDecimalOption(MySqlParser.MasterDecimalOptionContext ctx); + /** + * Exit a parse tree produced by the {@code masterDecimalOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void exitMasterDecimalOption(MySqlParser.MasterDecimalOptionContext ctx); + /** + * Enter a parse tree produced by the {@code masterBoolOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void enterMasterBoolOption(MySqlParser.MasterBoolOptionContext ctx); + /** + * Exit a parse tree produced by the {@code masterBoolOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void exitMasterBoolOption(MySqlParser.MasterBoolOptionContext ctx); + /** + * Enter a parse tree produced by the {@code masterRealOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void enterMasterRealOption(MySqlParser.MasterRealOptionContext ctx); + /** + * Exit a parse tree produced by the {@code masterRealOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void exitMasterRealOption(MySqlParser.MasterRealOptionContext ctx); + /** + * Enter a parse tree produced by the {@code masterUidListOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void enterMasterUidListOption(MySqlParser.MasterUidListOptionContext ctx); + /** + * Exit a parse tree produced by the {@code masterUidListOption} + * labeled alternative in {@link MySqlParser#masterOption}. + * @param ctx the parse tree + */ + void exitMasterUidListOption(MySqlParser.MasterUidListOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#stringMasterOption}. + * @param ctx the parse tree + */ + void enterStringMasterOption(MySqlParser.StringMasterOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#stringMasterOption}. + * @param ctx the parse tree + */ + void exitStringMasterOption(MySqlParser.StringMasterOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#decimalMasterOption}. + * @param ctx the parse tree + */ + void enterDecimalMasterOption(MySqlParser.DecimalMasterOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#decimalMasterOption}. + * @param ctx the parse tree + */ + void exitDecimalMasterOption(MySqlParser.DecimalMasterOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#boolMasterOption}. + * @param ctx the parse tree + */ + void enterBoolMasterOption(MySqlParser.BoolMasterOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#boolMasterOption}. + * @param ctx the parse tree + */ + void exitBoolMasterOption(MySqlParser.BoolMasterOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#channelOption}. + * @param ctx the parse tree + */ + void enterChannelOption(MySqlParser.ChannelOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#channelOption}. + * @param ctx the parse tree + */ + void exitChannelOption(MySqlParser.ChannelOptionContext ctx); + /** + * Enter a parse tree produced by the {@code doDbReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void enterDoDbReplication(MySqlParser.DoDbReplicationContext ctx); + /** + * Exit a parse tree produced by the {@code doDbReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void exitDoDbReplication(MySqlParser.DoDbReplicationContext ctx); + /** + * Enter a parse tree produced by the {@code ignoreDbReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void enterIgnoreDbReplication(MySqlParser.IgnoreDbReplicationContext ctx); + /** + * Exit a parse tree produced by the {@code ignoreDbReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void exitIgnoreDbReplication(MySqlParser.IgnoreDbReplicationContext ctx); + /** + * Enter a parse tree produced by the {@code doTableReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void enterDoTableReplication(MySqlParser.DoTableReplicationContext ctx); + /** + * Exit a parse tree produced by the {@code doTableReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void exitDoTableReplication(MySqlParser.DoTableReplicationContext ctx); + /** + * Enter a parse tree produced by the {@code ignoreTableReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void enterIgnoreTableReplication(MySqlParser.IgnoreTableReplicationContext ctx); + /** + * Exit a parse tree produced by the {@code ignoreTableReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void exitIgnoreTableReplication(MySqlParser.IgnoreTableReplicationContext ctx); + /** + * Enter a parse tree produced by the {@code wildDoTableReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void enterWildDoTableReplication(MySqlParser.WildDoTableReplicationContext ctx); + /** + * Exit a parse tree produced by the {@code wildDoTableReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void exitWildDoTableReplication(MySqlParser.WildDoTableReplicationContext ctx); + /** + * Enter a parse tree produced by the {@code wildIgnoreTableReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void enterWildIgnoreTableReplication(MySqlParser.WildIgnoreTableReplicationContext ctx); + /** + * Exit a parse tree produced by the {@code wildIgnoreTableReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void exitWildIgnoreTableReplication(MySqlParser.WildIgnoreTableReplicationContext ctx); + /** + * Enter a parse tree produced by the {@code rewriteDbReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void enterRewriteDbReplication(MySqlParser.RewriteDbReplicationContext ctx); + /** + * Exit a parse tree produced by the {@code rewriteDbReplication} + * labeled alternative in {@link MySqlParser#replicationFilter}. + * @param ctx the parse tree + */ + void exitRewriteDbReplication(MySqlParser.RewriteDbReplicationContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#tablePair}. + * @param ctx the parse tree + */ + void enterTablePair(MySqlParser.TablePairContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#tablePair}. + * @param ctx the parse tree + */ + void exitTablePair(MySqlParser.TablePairContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#threadType}. + * @param ctx the parse tree + */ + void enterThreadType(MySqlParser.ThreadTypeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#threadType}. + * @param ctx the parse tree + */ + void exitThreadType(MySqlParser.ThreadTypeContext ctx); + /** + * Enter a parse tree produced by the {@code gtidsUntilOption} + * labeled alternative in {@link MySqlParser#untilOption}. + * @param ctx the parse tree + */ + void enterGtidsUntilOption(MySqlParser.GtidsUntilOptionContext ctx); + /** + * Exit a parse tree produced by the {@code gtidsUntilOption} + * labeled alternative in {@link MySqlParser#untilOption}. + * @param ctx the parse tree + */ + void exitGtidsUntilOption(MySqlParser.GtidsUntilOptionContext ctx); + /** + * Enter a parse tree produced by the {@code masterLogUntilOption} + * labeled alternative in {@link MySqlParser#untilOption}. + * @param ctx the parse tree + */ + void enterMasterLogUntilOption(MySqlParser.MasterLogUntilOptionContext ctx); + /** + * Exit a parse tree produced by the {@code masterLogUntilOption} + * labeled alternative in {@link MySqlParser#untilOption}. + * @param ctx the parse tree + */ + void exitMasterLogUntilOption(MySqlParser.MasterLogUntilOptionContext ctx); + /** + * Enter a parse tree produced by the {@code relayLogUntilOption} + * labeled alternative in {@link MySqlParser#untilOption}. + * @param ctx the parse tree + */ + void enterRelayLogUntilOption(MySqlParser.RelayLogUntilOptionContext ctx); + /** + * Exit a parse tree produced by the {@code relayLogUntilOption} + * labeled alternative in {@link MySqlParser#untilOption}. + * @param ctx the parse tree + */ + void exitRelayLogUntilOption(MySqlParser.RelayLogUntilOptionContext ctx); + /** + * Enter a parse tree produced by the {@code sqlGapsUntilOption} + * labeled alternative in {@link MySqlParser#untilOption}. + * @param ctx the parse tree + */ + void enterSqlGapsUntilOption(MySqlParser.SqlGapsUntilOptionContext ctx); + /** + * Exit a parse tree produced by the {@code sqlGapsUntilOption} + * labeled alternative in {@link MySqlParser#untilOption}. + * @param ctx the parse tree + */ + void exitSqlGapsUntilOption(MySqlParser.SqlGapsUntilOptionContext ctx); + /** + * Enter a parse tree produced by the {@code userConnectionOption} + * labeled alternative in {@link MySqlParser#connectionOption}. + * @param ctx the parse tree + */ + void enterUserConnectionOption(MySqlParser.UserConnectionOptionContext ctx); + /** + * Exit a parse tree produced by the {@code userConnectionOption} + * labeled alternative in {@link MySqlParser#connectionOption}. + * @param ctx the parse tree + */ + void exitUserConnectionOption(MySqlParser.UserConnectionOptionContext ctx); + /** + * Enter a parse tree produced by the {@code passwordConnectionOption} + * labeled alternative in {@link MySqlParser#connectionOption}. + * @param ctx the parse tree + */ + void enterPasswordConnectionOption(MySqlParser.PasswordConnectionOptionContext ctx); + /** + * Exit a parse tree produced by the {@code passwordConnectionOption} + * labeled alternative in {@link MySqlParser#connectionOption}. + * @param ctx the parse tree + */ + void exitPasswordConnectionOption(MySqlParser.PasswordConnectionOptionContext ctx); + /** + * Enter a parse tree produced by the {@code defaultAuthConnectionOption} + * labeled alternative in {@link MySqlParser#connectionOption}. + * @param ctx the parse tree + */ + void enterDefaultAuthConnectionOption(MySqlParser.DefaultAuthConnectionOptionContext ctx); + /** + * Exit a parse tree produced by the {@code defaultAuthConnectionOption} + * labeled alternative in {@link MySqlParser#connectionOption}. + * @param ctx the parse tree + */ + void exitDefaultAuthConnectionOption(MySqlParser.DefaultAuthConnectionOptionContext ctx); + /** + * Enter a parse tree produced by the {@code pluginDirConnectionOption} + * labeled alternative in {@link MySqlParser#connectionOption}. + * @param ctx the parse tree + */ + void enterPluginDirConnectionOption(MySqlParser.PluginDirConnectionOptionContext ctx); + /** + * Exit a parse tree produced by the {@code pluginDirConnectionOption} + * labeled alternative in {@link MySqlParser#connectionOption}. + * @param ctx the parse tree + */ + void exitPluginDirConnectionOption(MySqlParser.PluginDirConnectionOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#gtuidSet}. + * @param ctx the parse tree + */ + void enterGtuidSet(MySqlParser.GtuidSetContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#gtuidSet}. + * @param ctx the parse tree + */ + void exitGtuidSet(MySqlParser.GtuidSetContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#xaStartTransaction}. + * @param ctx the parse tree + */ + void enterXaStartTransaction(MySqlParser.XaStartTransactionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#xaStartTransaction}. + * @param ctx the parse tree + */ + void exitXaStartTransaction(MySqlParser.XaStartTransactionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#xaEndTransaction}. + * @param ctx the parse tree + */ + void enterXaEndTransaction(MySqlParser.XaEndTransactionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#xaEndTransaction}. + * @param ctx the parse tree + */ + void exitXaEndTransaction(MySqlParser.XaEndTransactionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#xaPrepareStatement}. + * @param ctx the parse tree + */ + void enterXaPrepareStatement(MySqlParser.XaPrepareStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#xaPrepareStatement}. + * @param ctx the parse tree + */ + void exitXaPrepareStatement(MySqlParser.XaPrepareStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#xaCommitWork}. + * @param ctx the parse tree + */ + void enterXaCommitWork(MySqlParser.XaCommitWorkContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#xaCommitWork}. + * @param ctx the parse tree + */ + void exitXaCommitWork(MySqlParser.XaCommitWorkContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#xaRollbackWork}. + * @param ctx the parse tree + */ + void enterXaRollbackWork(MySqlParser.XaRollbackWorkContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#xaRollbackWork}. + * @param ctx the parse tree + */ + void exitXaRollbackWork(MySqlParser.XaRollbackWorkContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#xaRecoverWork}. + * @param ctx the parse tree + */ + void enterXaRecoverWork(MySqlParser.XaRecoverWorkContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#xaRecoverWork}. + * @param ctx the parse tree + */ + void exitXaRecoverWork(MySqlParser.XaRecoverWorkContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#prepareStatement}. + * @param ctx the parse tree + */ + void enterPrepareStatement(MySqlParser.PrepareStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#prepareStatement}. + * @param ctx the parse tree + */ + void exitPrepareStatement(MySqlParser.PrepareStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#executeStatement}. + * @param ctx the parse tree + */ + void enterExecuteStatement(MySqlParser.ExecuteStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#executeStatement}. + * @param ctx the parse tree + */ + void exitExecuteStatement(MySqlParser.ExecuteStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#deallocatePrepare}. + * @param ctx the parse tree + */ + void enterDeallocatePrepare(MySqlParser.DeallocatePrepareContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#deallocatePrepare}. + * @param ctx the parse tree + */ + void exitDeallocatePrepare(MySqlParser.DeallocatePrepareContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#routineBody}. + * @param ctx the parse tree + */ + void enterRoutineBody(MySqlParser.RoutineBodyContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#routineBody}. + * @param ctx the parse tree + */ + void exitRoutineBody(MySqlParser.RoutineBodyContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#blockStatement}. + * @param ctx the parse tree + */ + void enterBlockStatement(MySqlParser.BlockStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#blockStatement}. + * @param ctx the parse tree + */ + void exitBlockStatement(MySqlParser.BlockStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#caseStatement}. + * @param ctx the parse tree + */ + void enterCaseStatement(MySqlParser.CaseStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#caseStatement}. + * @param ctx the parse tree + */ + void exitCaseStatement(MySqlParser.CaseStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#ifStatement}. + * @param ctx the parse tree + */ + void enterIfStatement(MySqlParser.IfStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#ifStatement}. + * @param ctx the parse tree + */ + void exitIfStatement(MySqlParser.IfStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#iterateStatement}. + * @param ctx the parse tree + */ + void enterIterateStatement(MySqlParser.IterateStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#iterateStatement}. + * @param ctx the parse tree + */ + void exitIterateStatement(MySqlParser.IterateStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#leaveStatement}. + * @param ctx the parse tree + */ + void enterLeaveStatement(MySqlParser.LeaveStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#leaveStatement}. + * @param ctx the parse tree + */ + void exitLeaveStatement(MySqlParser.LeaveStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#loopStatement}. + * @param ctx the parse tree + */ + void enterLoopStatement(MySqlParser.LoopStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#loopStatement}. + * @param ctx the parse tree + */ + void exitLoopStatement(MySqlParser.LoopStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#repeatStatement}. + * @param ctx the parse tree + */ + void enterRepeatStatement(MySqlParser.RepeatStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#repeatStatement}. + * @param ctx the parse tree + */ + void exitRepeatStatement(MySqlParser.RepeatStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#returnStatement}. + * @param ctx the parse tree + */ + void enterReturnStatement(MySqlParser.ReturnStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#returnStatement}. + * @param ctx the parse tree + */ + void exitReturnStatement(MySqlParser.ReturnStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#whileStatement}. + * @param ctx the parse tree + */ + void enterWhileStatement(MySqlParser.WhileStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#whileStatement}. + * @param ctx the parse tree + */ + void exitWhileStatement(MySqlParser.WhileStatementContext ctx); + /** + * Enter a parse tree produced by the {@code CloseCursor} + * labeled alternative in {@link MySqlParser#cursorStatement}. + * @param ctx the parse tree + */ + void enterCloseCursor(MySqlParser.CloseCursorContext ctx); + /** + * Exit a parse tree produced by the {@code CloseCursor} + * labeled alternative in {@link MySqlParser#cursorStatement}. + * @param ctx the parse tree + */ + void exitCloseCursor(MySqlParser.CloseCursorContext ctx); + /** + * Enter a parse tree produced by the {@code FetchCursor} + * labeled alternative in {@link MySqlParser#cursorStatement}. + * @param ctx the parse tree + */ + void enterFetchCursor(MySqlParser.FetchCursorContext ctx); + /** + * Exit a parse tree produced by the {@code FetchCursor} + * labeled alternative in {@link MySqlParser#cursorStatement}. + * @param ctx the parse tree + */ + void exitFetchCursor(MySqlParser.FetchCursorContext ctx); + /** + * Enter a parse tree produced by the {@code OpenCursor} + * labeled alternative in {@link MySqlParser#cursorStatement}. + * @param ctx the parse tree + */ + void enterOpenCursor(MySqlParser.OpenCursorContext ctx); + /** + * Exit a parse tree produced by the {@code OpenCursor} + * labeled alternative in {@link MySqlParser#cursorStatement}. + * @param ctx the parse tree + */ + void exitOpenCursor(MySqlParser.OpenCursorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#declareVariable}. + * @param ctx the parse tree + */ + void enterDeclareVariable(MySqlParser.DeclareVariableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#declareVariable}. + * @param ctx the parse tree + */ + void exitDeclareVariable(MySqlParser.DeclareVariableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#declareCondition}. + * @param ctx the parse tree + */ + void enterDeclareCondition(MySqlParser.DeclareConditionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#declareCondition}. + * @param ctx the parse tree + */ + void exitDeclareCondition(MySqlParser.DeclareConditionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#declareCursor}. + * @param ctx the parse tree + */ + void enterDeclareCursor(MySqlParser.DeclareCursorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#declareCursor}. + * @param ctx the parse tree + */ + void exitDeclareCursor(MySqlParser.DeclareCursorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#declareHandler}. + * @param ctx the parse tree + */ + void enterDeclareHandler(MySqlParser.DeclareHandlerContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#declareHandler}. + * @param ctx the parse tree + */ + void exitDeclareHandler(MySqlParser.DeclareHandlerContext ctx); + /** + * Enter a parse tree produced by the {@code handlerConditionCode} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void enterHandlerConditionCode(MySqlParser.HandlerConditionCodeContext ctx); + /** + * Exit a parse tree produced by the {@code handlerConditionCode} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void exitHandlerConditionCode(MySqlParser.HandlerConditionCodeContext ctx); + /** + * Enter a parse tree produced by the {@code handlerConditionState} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void enterHandlerConditionState(MySqlParser.HandlerConditionStateContext ctx); + /** + * Exit a parse tree produced by the {@code handlerConditionState} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void exitHandlerConditionState(MySqlParser.HandlerConditionStateContext ctx); + /** + * Enter a parse tree produced by the {@code handlerConditionName} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void enterHandlerConditionName(MySqlParser.HandlerConditionNameContext ctx); + /** + * Exit a parse tree produced by the {@code handlerConditionName} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void exitHandlerConditionName(MySqlParser.HandlerConditionNameContext ctx); + /** + * Enter a parse tree produced by the {@code handlerConditionWarning} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void enterHandlerConditionWarning(MySqlParser.HandlerConditionWarningContext ctx); + /** + * Exit a parse tree produced by the {@code handlerConditionWarning} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void exitHandlerConditionWarning(MySqlParser.HandlerConditionWarningContext ctx); + /** + * Enter a parse tree produced by the {@code handlerConditionNotfound} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void enterHandlerConditionNotfound(MySqlParser.HandlerConditionNotfoundContext ctx); + /** + * Exit a parse tree produced by the {@code handlerConditionNotfound} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void exitHandlerConditionNotfound(MySqlParser.HandlerConditionNotfoundContext ctx); + /** + * Enter a parse tree produced by the {@code handlerConditionException} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void enterHandlerConditionException(MySqlParser.HandlerConditionExceptionContext ctx); + /** + * Exit a parse tree produced by the {@code handlerConditionException} + * labeled alternative in {@link MySqlParser#handlerConditionValue}. + * @param ctx the parse tree + */ + void exitHandlerConditionException(MySqlParser.HandlerConditionExceptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#procedureSqlStatement}. + * @param ctx the parse tree + */ + void enterProcedureSqlStatement(MySqlParser.ProcedureSqlStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#procedureSqlStatement}. + * @param ctx the parse tree + */ + void exitProcedureSqlStatement(MySqlParser.ProcedureSqlStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#caseAlternative}. + * @param ctx the parse tree + */ + void enterCaseAlternative(MySqlParser.CaseAlternativeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#caseAlternative}. + * @param ctx the parse tree + */ + void exitCaseAlternative(MySqlParser.CaseAlternativeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#elifAlternative}. + * @param ctx the parse tree + */ + void enterElifAlternative(MySqlParser.ElifAlternativeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#elifAlternative}. + * @param ctx the parse tree + */ + void exitElifAlternative(MySqlParser.ElifAlternativeContext ctx); + /** + * Enter a parse tree produced by the {@code alterUserMysqlV56} + * labeled alternative in {@link MySqlParser#alterUser}. + * @param ctx the parse tree + */ + void enterAlterUserMysqlV56(MySqlParser.AlterUserMysqlV56Context ctx); + /** + * Exit a parse tree produced by the {@code alterUserMysqlV56} + * labeled alternative in {@link MySqlParser#alterUser}. + * @param ctx the parse tree + */ + void exitAlterUserMysqlV56(MySqlParser.AlterUserMysqlV56Context ctx); + /** + * Enter a parse tree produced by the {@code alterUserMysqlV80} + * labeled alternative in {@link MySqlParser#alterUser}. + * @param ctx the parse tree + */ + void enterAlterUserMysqlV80(MySqlParser.AlterUserMysqlV80Context ctx); + /** + * Exit a parse tree produced by the {@code alterUserMysqlV80} + * labeled alternative in {@link MySqlParser#alterUser}. + * @param ctx the parse tree + */ + void exitAlterUserMysqlV80(MySqlParser.AlterUserMysqlV80Context ctx); + /** + * Enter a parse tree produced by the {@code createUserMysqlV56} + * labeled alternative in {@link MySqlParser#createUser}. + * @param ctx the parse tree + */ + void enterCreateUserMysqlV56(MySqlParser.CreateUserMysqlV56Context ctx); + /** + * Exit a parse tree produced by the {@code createUserMysqlV56} + * labeled alternative in {@link MySqlParser#createUser}. + * @param ctx the parse tree + */ + void exitCreateUserMysqlV56(MySqlParser.CreateUserMysqlV56Context ctx); + /** + * Enter a parse tree produced by the {@code createUserMysqlV80} + * labeled alternative in {@link MySqlParser#createUser}. + * @param ctx the parse tree + */ + void enterCreateUserMysqlV80(MySqlParser.CreateUserMysqlV80Context ctx); + /** + * Exit a parse tree produced by the {@code createUserMysqlV80} + * labeled alternative in {@link MySqlParser#createUser}. + * @param ctx the parse tree + */ + void exitCreateUserMysqlV80(MySqlParser.CreateUserMysqlV80Context ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dropUser}. + * @param ctx the parse tree + */ + void enterDropUser(MySqlParser.DropUserContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dropUser}. + * @param ctx the parse tree + */ + void exitDropUser(MySqlParser.DropUserContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#grantStatement}. + * @param ctx the parse tree + */ + void enterGrantStatement(MySqlParser.GrantStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#grantStatement}. + * @param ctx the parse tree + */ + void exitGrantStatement(MySqlParser.GrantStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#roleOption}. + * @param ctx the parse tree + */ + void enterRoleOption(MySqlParser.RoleOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#roleOption}. + * @param ctx the parse tree + */ + void exitRoleOption(MySqlParser.RoleOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#grantProxy}. + * @param ctx the parse tree + */ + void enterGrantProxy(MySqlParser.GrantProxyContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#grantProxy}. + * @param ctx the parse tree + */ + void exitGrantProxy(MySqlParser.GrantProxyContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#renameUser}. + * @param ctx the parse tree + */ + void enterRenameUser(MySqlParser.RenameUserContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#renameUser}. + * @param ctx the parse tree + */ + void exitRenameUser(MySqlParser.RenameUserContext ctx); + /** + * Enter a parse tree produced by the {@code detailRevoke} + * labeled alternative in {@link MySqlParser#revokeStatement}. + * @param ctx the parse tree + */ + void enterDetailRevoke(MySqlParser.DetailRevokeContext ctx); + /** + * Exit a parse tree produced by the {@code detailRevoke} + * labeled alternative in {@link MySqlParser#revokeStatement}. + * @param ctx the parse tree + */ + void exitDetailRevoke(MySqlParser.DetailRevokeContext ctx); + /** + * Enter a parse tree produced by the {@code shortRevoke} + * labeled alternative in {@link MySqlParser#revokeStatement}. + * @param ctx the parse tree + */ + void enterShortRevoke(MySqlParser.ShortRevokeContext ctx); + /** + * Exit a parse tree produced by the {@code shortRevoke} + * labeled alternative in {@link MySqlParser#revokeStatement}. + * @param ctx the parse tree + */ + void exitShortRevoke(MySqlParser.ShortRevokeContext ctx); + /** + * Enter a parse tree produced by the {@code roleRevoke} + * labeled alternative in {@link MySqlParser#revokeStatement}. + * @param ctx the parse tree + */ + void enterRoleRevoke(MySqlParser.RoleRevokeContext ctx); + /** + * Exit a parse tree produced by the {@code roleRevoke} + * labeled alternative in {@link MySqlParser#revokeStatement}. + * @param ctx the parse tree + */ + void exitRoleRevoke(MySqlParser.RoleRevokeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#revokeProxy}. + * @param ctx the parse tree + */ + void enterRevokeProxy(MySqlParser.RevokeProxyContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#revokeProxy}. + * @param ctx the parse tree + */ + void exitRevokeProxy(MySqlParser.RevokeProxyContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#setPasswordStatement}. + * @param ctx the parse tree + */ + void enterSetPasswordStatement(MySqlParser.SetPasswordStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#setPasswordStatement}. + * @param ctx the parse tree + */ + void exitSetPasswordStatement(MySqlParser.SetPasswordStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#userSpecification}. + * @param ctx the parse tree + */ + void enterUserSpecification(MySqlParser.UserSpecificationContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#userSpecification}. + * @param ctx the parse tree + */ + void exitUserSpecification(MySqlParser.UserSpecificationContext ctx); + /** + * Enter a parse tree produced by the {@code hashAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void enterHashAuthOption(MySqlParser.HashAuthOptionContext ctx); + /** + * Exit a parse tree produced by the {@code hashAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void exitHashAuthOption(MySqlParser.HashAuthOptionContext ctx); + /** + * Enter a parse tree produced by the {@code randomAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void enterRandomAuthOption(MySqlParser.RandomAuthOptionContext ctx); + /** + * Exit a parse tree produced by the {@code randomAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void exitRandomAuthOption(MySqlParser.RandomAuthOptionContext ctx); + /** + * Enter a parse tree produced by the {@code stringAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void enterStringAuthOption(MySqlParser.StringAuthOptionContext ctx); + /** + * Exit a parse tree produced by the {@code stringAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void exitStringAuthOption(MySqlParser.StringAuthOptionContext ctx); + /** + * Enter a parse tree produced by the {@code moduleAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void enterModuleAuthOption(MySqlParser.ModuleAuthOptionContext ctx); + /** + * Exit a parse tree produced by the {@code moduleAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void exitModuleAuthOption(MySqlParser.ModuleAuthOptionContext ctx); + /** + * Enter a parse tree produced by the {@code simpleAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void enterSimpleAuthOption(MySqlParser.SimpleAuthOptionContext ctx); + /** + * Exit a parse tree produced by the {@code simpleAuthOption} + * labeled alternative in {@link MySqlParser#userAuthOption}. + * @param ctx the parse tree + */ + void exitSimpleAuthOption(MySqlParser.SimpleAuthOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#authOptionClause}. + * @param ctx the parse tree + */ + void enterAuthOptionClause(MySqlParser.AuthOptionClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#authOptionClause}. + * @param ctx the parse tree + */ + void exitAuthOptionClause(MySqlParser.AuthOptionClauseContext ctx); + /** + * Enter a parse tree produced by the {@code module} + * labeled alternative in {@link MySqlParser#authenticationRule}. + * @param ctx the parse tree + */ + void enterModule(MySqlParser.ModuleContext ctx); + /** + * Exit a parse tree produced by the {@code module} + * labeled alternative in {@link MySqlParser#authenticationRule}. + * @param ctx the parse tree + */ + void exitModule(MySqlParser.ModuleContext ctx); + /** + * Enter a parse tree produced by the {@code passwordModuleOption} + * labeled alternative in {@link MySqlParser#authenticationRule}. + * @param ctx the parse tree + */ + void enterPasswordModuleOption(MySqlParser.PasswordModuleOptionContext ctx); + /** + * Exit a parse tree produced by the {@code passwordModuleOption} + * labeled alternative in {@link MySqlParser#authenticationRule}. + * @param ctx the parse tree + */ + void exitPasswordModuleOption(MySqlParser.PasswordModuleOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#tlsOption}. + * @param ctx the parse tree + */ + void enterTlsOption(MySqlParser.TlsOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#tlsOption}. + * @param ctx the parse tree + */ + void exitTlsOption(MySqlParser.TlsOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#userResourceOption}. + * @param ctx the parse tree + */ + void enterUserResourceOption(MySqlParser.UserResourceOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#userResourceOption}. + * @param ctx the parse tree + */ + void exitUserResourceOption(MySqlParser.UserResourceOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#userPasswordOption}. + * @param ctx the parse tree + */ + void enterUserPasswordOption(MySqlParser.UserPasswordOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#userPasswordOption}. + * @param ctx the parse tree + */ + void exitUserPasswordOption(MySqlParser.UserPasswordOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#userLockOption}. + * @param ctx the parse tree + */ + void enterUserLockOption(MySqlParser.UserLockOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#userLockOption}. + * @param ctx the parse tree + */ + void exitUserLockOption(MySqlParser.UserLockOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#privelegeClause}. + * @param ctx the parse tree + */ + void enterPrivelegeClause(MySqlParser.PrivelegeClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#privelegeClause}. + * @param ctx the parse tree + */ + void exitPrivelegeClause(MySqlParser.PrivelegeClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#privilege}. + * @param ctx the parse tree + */ + void enterPrivilege(MySqlParser.PrivilegeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#privilege}. + * @param ctx the parse tree + */ + void exitPrivilege(MySqlParser.PrivilegeContext ctx); + /** + * Enter a parse tree produced by the {@code currentSchemaPriviLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void enterCurrentSchemaPriviLevel(MySqlParser.CurrentSchemaPriviLevelContext ctx); + /** + * Exit a parse tree produced by the {@code currentSchemaPriviLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void exitCurrentSchemaPriviLevel(MySqlParser.CurrentSchemaPriviLevelContext ctx); + /** + * Enter a parse tree produced by the {@code globalPrivLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void enterGlobalPrivLevel(MySqlParser.GlobalPrivLevelContext ctx); + /** + * Exit a parse tree produced by the {@code globalPrivLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void exitGlobalPrivLevel(MySqlParser.GlobalPrivLevelContext ctx); + /** + * Enter a parse tree produced by the {@code definiteSchemaPrivLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void enterDefiniteSchemaPrivLevel(MySqlParser.DefiniteSchemaPrivLevelContext ctx); + /** + * Exit a parse tree produced by the {@code definiteSchemaPrivLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void exitDefiniteSchemaPrivLevel(MySqlParser.DefiniteSchemaPrivLevelContext ctx); + /** + * Enter a parse tree produced by the {@code definiteFullTablePrivLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void enterDefiniteFullTablePrivLevel(MySqlParser.DefiniteFullTablePrivLevelContext ctx); + /** + * Exit a parse tree produced by the {@code definiteFullTablePrivLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void exitDefiniteFullTablePrivLevel(MySqlParser.DefiniteFullTablePrivLevelContext ctx); + /** + * Enter a parse tree produced by the {@code definiteFullTablePrivLevel2} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void enterDefiniteFullTablePrivLevel2(MySqlParser.DefiniteFullTablePrivLevel2Context ctx); + /** + * Exit a parse tree produced by the {@code definiteFullTablePrivLevel2} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void exitDefiniteFullTablePrivLevel2(MySqlParser.DefiniteFullTablePrivLevel2Context ctx); + /** + * Enter a parse tree produced by the {@code definiteTablePrivLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void enterDefiniteTablePrivLevel(MySqlParser.DefiniteTablePrivLevelContext ctx); + /** + * Exit a parse tree produced by the {@code definiteTablePrivLevel} + * labeled alternative in {@link MySqlParser#privilegeLevel}. + * @param ctx the parse tree + */ + void exitDefiniteTablePrivLevel(MySqlParser.DefiniteTablePrivLevelContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#renameUserClause}. + * @param ctx the parse tree + */ + void enterRenameUserClause(MySqlParser.RenameUserClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#renameUserClause}. + * @param ctx the parse tree + */ + void exitRenameUserClause(MySqlParser.RenameUserClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#analyzeTable}. + * @param ctx the parse tree + */ + void enterAnalyzeTable(MySqlParser.AnalyzeTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#analyzeTable}. + * @param ctx the parse tree + */ + void exitAnalyzeTable(MySqlParser.AnalyzeTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#checkTable}. + * @param ctx the parse tree + */ + void enterCheckTable(MySqlParser.CheckTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#checkTable}. + * @param ctx the parse tree + */ + void exitCheckTable(MySqlParser.CheckTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#checksumTable}. + * @param ctx the parse tree + */ + void enterChecksumTable(MySqlParser.ChecksumTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#checksumTable}. + * @param ctx the parse tree + */ + void exitChecksumTable(MySqlParser.ChecksumTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#optimizeTable}. + * @param ctx the parse tree + */ + void enterOptimizeTable(MySqlParser.OptimizeTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#optimizeTable}. + * @param ctx the parse tree + */ + void exitOptimizeTable(MySqlParser.OptimizeTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#repairTable}. + * @param ctx the parse tree + */ + void enterRepairTable(MySqlParser.RepairTableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#repairTable}. + * @param ctx the parse tree + */ + void exitRepairTable(MySqlParser.RepairTableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#checkTableOption}. + * @param ctx the parse tree + */ + void enterCheckTableOption(MySqlParser.CheckTableOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#checkTableOption}. + * @param ctx the parse tree + */ + void exitCheckTableOption(MySqlParser.CheckTableOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#createUdfunction}. + * @param ctx the parse tree + */ + void enterCreateUdfunction(MySqlParser.CreateUdfunctionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#createUdfunction}. + * @param ctx the parse tree + */ + void exitCreateUdfunction(MySqlParser.CreateUdfunctionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#installPlugin}. + * @param ctx the parse tree + */ + void enterInstallPlugin(MySqlParser.InstallPluginContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#installPlugin}. + * @param ctx the parse tree + */ + void exitInstallPlugin(MySqlParser.InstallPluginContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#uninstallPlugin}. + * @param ctx the parse tree + */ + void enterUninstallPlugin(MySqlParser.UninstallPluginContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#uninstallPlugin}. + * @param ctx the parse tree + */ + void exitUninstallPlugin(MySqlParser.UninstallPluginContext ctx); + /** + * Enter a parse tree produced by the {@code setVariable} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void enterSetVariable(MySqlParser.SetVariableContext ctx); + /** + * Exit a parse tree produced by the {@code setVariable} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void exitSetVariable(MySqlParser.SetVariableContext ctx); + /** + * Enter a parse tree produced by the {@code setCharset} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void enterSetCharset(MySqlParser.SetCharsetContext ctx); + /** + * Exit a parse tree produced by the {@code setCharset} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void exitSetCharset(MySqlParser.SetCharsetContext ctx); + /** + * Enter a parse tree produced by the {@code setNames} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void enterSetNames(MySqlParser.SetNamesContext ctx); + /** + * Exit a parse tree produced by the {@code setNames} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void exitSetNames(MySqlParser.SetNamesContext ctx); + /** + * Enter a parse tree produced by the {@code setPassword} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void enterSetPassword(MySqlParser.SetPasswordContext ctx); + /** + * Exit a parse tree produced by the {@code setPassword} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void exitSetPassword(MySqlParser.SetPasswordContext ctx); + /** + * Enter a parse tree produced by the {@code setTransaction} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void enterSetTransaction(MySqlParser.SetTransactionContext ctx); + /** + * Exit a parse tree produced by the {@code setTransaction} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void exitSetTransaction(MySqlParser.SetTransactionContext ctx); + /** + * Enter a parse tree produced by the {@code setAutocommit} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void enterSetAutocommit(MySqlParser.SetAutocommitContext ctx); + /** + * Exit a parse tree produced by the {@code setAutocommit} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void exitSetAutocommit(MySqlParser.SetAutocommitContext ctx); + /** + * Enter a parse tree produced by the {@code setNewValueInsideTrigger} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void enterSetNewValueInsideTrigger(MySqlParser.SetNewValueInsideTriggerContext ctx); + /** + * Exit a parse tree produced by the {@code setNewValueInsideTrigger} + * labeled alternative in {@link MySqlParser#setStatement}. + * @param ctx the parse tree + */ + void exitSetNewValueInsideTrigger(MySqlParser.SetNewValueInsideTriggerContext ctx); + /** + * Enter a parse tree produced by the {@code showMasterLogs} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowMasterLogs(MySqlParser.ShowMasterLogsContext ctx); + /** + * Exit a parse tree produced by the {@code showMasterLogs} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowMasterLogs(MySqlParser.ShowMasterLogsContext ctx); + /** + * Enter a parse tree produced by the {@code showLogEvents} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowLogEvents(MySqlParser.ShowLogEventsContext ctx); + /** + * Exit a parse tree produced by the {@code showLogEvents} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowLogEvents(MySqlParser.ShowLogEventsContext ctx); + /** + * Enter a parse tree produced by the {@code showObjectFilter} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowObjectFilter(MySqlParser.ShowObjectFilterContext ctx); + /** + * Exit a parse tree produced by the {@code showObjectFilter} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowObjectFilter(MySqlParser.ShowObjectFilterContext ctx); + /** + * Enter a parse tree produced by the {@code showColumns} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowColumns(MySqlParser.ShowColumnsContext ctx); + /** + * Exit a parse tree produced by the {@code showColumns} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowColumns(MySqlParser.ShowColumnsContext ctx); + /** + * Enter a parse tree produced by the {@code showCreateDb} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowCreateDb(MySqlParser.ShowCreateDbContext ctx); + /** + * Exit a parse tree produced by the {@code showCreateDb} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowCreateDb(MySqlParser.ShowCreateDbContext ctx); + /** + * Enter a parse tree produced by the {@code showCreateFullIdObject} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowCreateFullIdObject(MySqlParser.ShowCreateFullIdObjectContext ctx); + /** + * Exit a parse tree produced by the {@code showCreateFullIdObject} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowCreateFullIdObject(MySqlParser.ShowCreateFullIdObjectContext ctx); + /** + * Enter a parse tree produced by the {@code showCreateUser} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowCreateUser(MySqlParser.ShowCreateUserContext ctx); + /** + * Exit a parse tree produced by the {@code showCreateUser} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowCreateUser(MySqlParser.ShowCreateUserContext ctx); + /** + * Enter a parse tree produced by the {@code showEngine} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowEngine(MySqlParser.ShowEngineContext ctx); + /** + * Exit a parse tree produced by the {@code showEngine} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowEngine(MySqlParser.ShowEngineContext ctx); + /** + * Enter a parse tree produced by the {@code showGlobalInfo} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowGlobalInfo(MySqlParser.ShowGlobalInfoContext ctx); + /** + * Exit a parse tree produced by the {@code showGlobalInfo} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowGlobalInfo(MySqlParser.ShowGlobalInfoContext ctx); + /** + * Enter a parse tree produced by the {@code showErrors} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowErrors(MySqlParser.ShowErrorsContext ctx); + /** + * Exit a parse tree produced by the {@code showErrors} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowErrors(MySqlParser.ShowErrorsContext ctx); + /** + * Enter a parse tree produced by the {@code showCountErrors} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowCountErrors(MySqlParser.ShowCountErrorsContext ctx); + /** + * Exit a parse tree produced by the {@code showCountErrors} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowCountErrors(MySqlParser.ShowCountErrorsContext ctx); + /** + * Enter a parse tree produced by the {@code showSchemaFilter} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowSchemaFilter(MySqlParser.ShowSchemaFilterContext ctx); + /** + * Exit a parse tree produced by the {@code showSchemaFilter} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowSchemaFilter(MySqlParser.ShowSchemaFilterContext ctx); + /** + * Enter a parse tree produced by the {@code showRoutine} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowRoutine(MySqlParser.ShowRoutineContext ctx); + /** + * Exit a parse tree produced by the {@code showRoutine} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowRoutine(MySqlParser.ShowRoutineContext ctx); + /** + * Enter a parse tree produced by the {@code showGrants} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowGrants(MySqlParser.ShowGrantsContext ctx); + /** + * Exit a parse tree produced by the {@code showGrants} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowGrants(MySqlParser.ShowGrantsContext ctx); + /** + * Enter a parse tree produced by the {@code showIndexes} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowIndexes(MySqlParser.ShowIndexesContext ctx); + /** + * Exit a parse tree produced by the {@code showIndexes} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowIndexes(MySqlParser.ShowIndexesContext ctx); + /** + * Enter a parse tree produced by the {@code showOpenTables} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowOpenTables(MySqlParser.ShowOpenTablesContext ctx); + /** + * Exit a parse tree produced by the {@code showOpenTables} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowOpenTables(MySqlParser.ShowOpenTablesContext ctx); + /** + * Enter a parse tree produced by the {@code showProfile} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowProfile(MySqlParser.ShowProfileContext ctx); + /** + * Exit a parse tree produced by the {@code showProfile} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowProfile(MySqlParser.ShowProfileContext ctx); + /** + * Enter a parse tree produced by the {@code showSlaveStatus} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void enterShowSlaveStatus(MySqlParser.ShowSlaveStatusContext ctx); + /** + * Exit a parse tree produced by the {@code showSlaveStatus} + * labeled alternative in {@link MySqlParser#showStatement}. + * @param ctx the parse tree + */ + void exitShowSlaveStatus(MySqlParser.ShowSlaveStatusContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#variableClause}. + * @param ctx the parse tree + */ + void enterVariableClause(MySqlParser.VariableClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#variableClause}. + * @param ctx the parse tree + */ + void exitVariableClause(MySqlParser.VariableClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#showCommonEntity}. + * @param ctx the parse tree + */ + void enterShowCommonEntity(MySqlParser.ShowCommonEntityContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#showCommonEntity}. + * @param ctx the parse tree + */ + void exitShowCommonEntity(MySqlParser.ShowCommonEntityContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#showFilter}. + * @param ctx the parse tree + */ + void enterShowFilter(MySqlParser.ShowFilterContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#showFilter}. + * @param ctx the parse tree + */ + void exitShowFilter(MySqlParser.ShowFilterContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#showGlobalInfoClause}. + * @param ctx the parse tree + */ + void enterShowGlobalInfoClause(MySqlParser.ShowGlobalInfoClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#showGlobalInfoClause}. + * @param ctx the parse tree + */ + void exitShowGlobalInfoClause(MySqlParser.ShowGlobalInfoClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#showSchemaEntity}. + * @param ctx the parse tree + */ + void enterShowSchemaEntity(MySqlParser.ShowSchemaEntityContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#showSchemaEntity}. + * @param ctx the parse tree + */ + void exitShowSchemaEntity(MySqlParser.ShowSchemaEntityContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#showProfileType}. + * @param ctx the parse tree + */ + void enterShowProfileType(MySqlParser.ShowProfileTypeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#showProfileType}. + * @param ctx the parse tree + */ + void exitShowProfileType(MySqlParser.ShowProfileTypeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#binlogStatement}. + * @param ctx the parse tree + */ + void enterBinlogStatement(MySqlParser.BinlogStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#binlogStatement}. + * @param ctx the parse tree + */ + void exitBinlogStatement(MySqlParser.BinlogStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#cacheIndexStatement}. + * @param ctx the parse tree + */ + void enterCacheIndexStatement(MySqlParser.CacheIndexStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#cacheIndexStatement}. + * @param ctx the parse tree + */ + void exitCacheIndexStatement(MySqlParser.CacheIndexStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#flushStatement}. + * @param ctx the parse tree + */ + void enterFlushStatement(MySqlParser.FlushStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#flushStatement}. + * @param ctx the parse tree + */ + void exitFlushStatement(MySqlParser.FlushStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#killStatement}. + * @param ctx the parse tree + */ + void enterKillStatement(MySqlParser.KillStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#killStatement}. + * @param ctx the parse tree + */ + void exitKillStatement(MySqlParser.KillStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#loadIndexIntoCache}. + * @param ctx the parse tree + */ + void enterLoadIndexIntoCache(MySqlParser.LoadIndexIntoCacheContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#loadIndexIntoCache}. + * @param ctx the parse tree + */ + void exitLoadIndexIntoCache(MySqlParser.LoadIndexIntoCacheContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#resetStatement}. + * @param ctx the parse tree + */ + void enterResetStatement(MySqlParser.ResetStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#resetStatement}. + * @param ctx the parse tree + */ + void exitResetStatement(MySqlParser.ResetStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#shutdownStatement}. + * @param ctx the parse tree + */ + void enterShutdownStatement(MySqlParser.ShutdownStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#shutdownStatement}. + * @param ctx the parse tree + */ + void exitShutdownStatement(MySqlParser.ShutdownStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#tableIndexes}. + * @param ctx the parse tree + */ + void enterTableIndexes(MySqlParser.TableIndexesContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#tableIndexes}. + * @param ctx the parse tree + */ + void exitTableIndexes(MySqlParser.TableIndexesContext ctx); + /** + * Enter a parse tree produced by the {@code simpleFlushOption} + * labeled alternative in {@link MySqlParser#flushOption}. + * @param ctx the parse tree + */ + void enterSimpleFlushOption(MySqlParser.SimpleFlushOptionContext ctx); + /** + * Exit a parse tree produced by the {@code simpleFlushOption} + * labeled alternative in {@link MySqlParser#flushOption}. + * @param ctx the parse tree + */ + void exitSimpleFlushOption(MySqlParser.SimpleFlushOptionContext ctx); + /** + * Enter a parse tree produced by the {@code channelFlushOption} + * labeled alternative in {@link MySqlParser#flushOption}. + * @param ctx the parse tree + */ + void enterChannelFlushOption(MySqlParser.ChannelFlushOptionContext ctx); + /** + * Exit a parse tree produced by the {@code channelFlushOption} + * labeled alternative in {@link MySqlParser#flushOption}. + * @param ctx the parse tree + */ + void exitChannelFlushOption(MySqlParser.ChannelFlushOptionContext ctx); + /** + * Enter a parse tree produced by the {@code tableFlushOption} + * labeled alternative in {@link MySqlParser#flushOption}. + * @param ctx the parse tree + */ + void enterTableFlushOption(MySqlParser.TableFlushOptionContext ctx); + /** + * Exit a parse tree produced by the {@code tableFlushOption} + * labeled alternative in {@link MySqlParser#flushOption}. + * @param ctx the parse tree + */ + void exitTableFlushOption(MySqlParser.TableFlushOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#flushTableOption}. + * @param ctx the parse tree + */ + void enterFlushTableOption(MySqlParser.FlushTableOptionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#flushTableOption}. + * @param ctx the parse tree + */ + void exitFlushTableOption(MySqlParser.FlushTableOptionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#loadedTableIndexes}. + * @param ctx the parse tree + */ + void enterLoadedTableIndexes(MySqlParser.LoadedTableIndexesContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#loadedTableIndexes}. + * @param ctx the parse tree + */ + void exitLoadedTableIndexes(MySqlParser.LoadedTableIndexesContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#simpleDescribeStatement}. + * @param ctx the parse tree + */ + void enterSimpleDescribeStatement(MySqlParser.SimpleDescribeStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#simpleDescribeStatement}. + * @param ctx the parse tree + */ + void exitSimpleDescribeStatement(MySqlParser.SimpleDescribeStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#fullDescribeStatement}. + * @param ctx the parse tree + */ + void enterFullDescribeStatement(MySqlParser.FullDescribeStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#fullDescribeStatement}. + * @param ctx the parse tree + */ + void exitFullDescribeStatement(MySqlParser.FullDescribeStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#helpStatement}. + * @param ctx the parse tree + */ + void enterHelpStatement(MySqlParser.HelpStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#helpStatement}. + * @param ctx the parse tree + */ + void exitHelpStatement(MySqlParser.HelpStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#useStatement}. + * @param ctx the parse tree + */ + void enterUseStatement(MySqlParser.UseStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#useStatement}. + * @param ctx the parse tree + */ + void exitUseStatement(MySqlParser.UseStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#signalStatement}. + * @param ctx the parse tree + */ + void enterSignalStatement(MySqlParser.SignalStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#signalStatement}. + * @param ctx the parse tree + */ + void exitSignalStatement(MySqlParser.SignalStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#resignalStatement}. + * @param ctx the parse tree + */ + void enterResignalStatement(MySqlParser.ResignalStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#resignalStatement}. + * @param ctx the parse tree + */ + void exitResignalStatement(MySqlParser.ResignalStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#signalConditionInformation}. + * @param ctx the parse tree + */ + void enterSignalConditionInformation(MySqlParser.SignalConditionInformationContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#signalConditionInformation}. + * @param ctx the parse tree + */ + void exitSignalConditionInformation(MySqlParser.SignalConditionInformationContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#withStatement}. + * @param ctx the parse tree + */ + void enterWithStatement(MySqlParser.WithStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#withStatement}. + * @param ctx the parse tree + */ + void exitWithStatement(MySqlParser.WithStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#tableStatement}. + * @param ctx the parse tree + */ + void enterTableStatement(MySqlParser.TableStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#tableStatement}. + * @param ctx the parse tree + */ + void exitTableStatement(MySqlParser.TableStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#diagnosticsStatement}. + * @param ctx the parse tree + */ + void enterDiagnosticsStatement(MySqlParser.DiagnosticsStatementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#diagnosticsStatement}. + * @param ctx the parse tree + */ + void exitDiagnosticsStatement(MySqlParser.DiagnosticsStatementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#diagnosticsConditionInformationName}. + * @param ctx the parse tree + */ + void enterDiagnosticsConditionInformationName(MySqlParser.DiagnosticsConditionInformationNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#diagnosticsConditionInformationName}. + * @param ctx the parse tree + */ + void exitDiagnosticsConditionInformationName(MySqlParser.DiagnosticsConditionInformationNameContext ctx); + /** + * Enter a parse tree produced by the {@code describeStatements} + * labeled alternative in {@link MySqlParser#describeObjectClause}. + * @param ctx the parse tree + */ + void enterDescribeStatements(MySqlParser.DescribeStatementsContext ctx); + /** + * Exit a parse tree produced by the {@code describeStatements} + * labeled alternative in {@link MySqlParser#describeObjectClause}. + * @param ctx the parse tree + */ + void exitDescribeStatements(MySqlParser.DescribeStatementsContext ctx); + /** + * Enter a parse tree produced by the {@code describeConnection} + * labeled alternative in {@link MySqlParser#describeObjectClause}. + * @param ctx the parse tree + */ + void enterDescribeConnection(MySqlParser.DescribeConnectionContext ctx); + /** + * Exit a parse tree produced by the {@code describeConnection} + * labeled alternative in {@link MySqlParser#describeObjectClause}. + * @param ctx the parse tree + */ + void exitDescribeConnection(MySqlParser.DescribeConnectionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#fullId}. + * @param ctx the parse tree + */ + void enterFullId(MySqlParser.FullIdContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#fullId}. + * @param ctx the parse tree + */ + void exitFullId(MySqlParser.FullIdContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#tableName}. + * @param ctx the parse tree + */ + void enterTableName(MySqlParser.TableNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#tableName}. + * @param ctx the parse tree + */ + void exitTableName(MySqlParser.TableNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#roleName}. + * @param ctx the parse tree + */ + void enterRoleName(MySqlParser.RoleNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#roleName}. + * @param ctx the parse tree + */ + void exitRoleName(MySqlParser.RoleNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#fullColumnName}. + * @param ctx the parse tree + */ + void enterFullColumnName(MySqlParser.FullColumnNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#fullColumnName}. + * @param ctx the parse tree + */ + void exitFullColumnName(MySqlParser.FullColumnNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#indexColumnName}. + * @param ctx the parse tree + */ + void enterIndexColumnName(MySqlParser.IndexColumnNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#indexColumnName}. + * @param ctx the parse tree + */ + void exitIndexColumnName(MySqlParser.IndexColumnNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#simpleUserName}. + * @param ctx the parse tree + */ + void enterSimpleUserName(MySqlParser.SimpleUserNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#simpleUserName}. + * @param ctx the parse tree + */ + void exitSimpleUserName(MySqlParser.SimpleUserNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#hostName}. + * @param ctx the parse tree + */ + void enterHostName(MySqlParser.HostNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#hostName}. + * @param ctx the parse tree + */ + void exitHostName(MySqlParser.HostNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#userName}. + * @param ctx the parse tree + */ + void enterUserName(MySqlParser.UserNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#userName}. + * @param ctx the parse tree + */ + void exitUserName(MySqlParser.UserNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#mysqlVariable}. + * @param ctx the parse tree + */ + void enterMysqlVariable(MySqlParser.MysqlVariableContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#mysqlVariable}. + * @param ctx the parse tree + */ + void exitMysqlVariable(MySqlParser.MysqlVariableContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#charsetName}. + * @param ctx the parse tree + */ + void enterCharsetName(MySqlParser.CharsetNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#charsetName}. + * @param ctx the parse tree + */ + void exitCharsetName(MySqlParser.CharsetNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#collationName}. + * @param ctx the parse tree + */ + void enterCollationName(MySqlParser.CollationNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#collationName}. + * @param ctx the parse tree + */ + void exitCollationName(MySqlParser.CollationNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#engineName}. + * @param ctx the parse tree + */ + void enterEngineName(MySqlParser.EngineNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#engineName}. + * @param ctx the parse tree + */ + void exitEngineName(MySqlParser.EngineNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#engineNameBase}. + * @param ctx the parse tree + */ + void enterEngineNameBase(MySqlParser.EngineNameBaseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#engineNameBase}. + * @param ctx the parse tree + */ + void exitEngineNameBase(MySqlParser.EngineNameBaseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#uuidSet}. + * @param ctx the parse tree + */ + void enterUuidSet(MySqlParser.UuidSetContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#uuidSet}. + * @param ctx the parse tree + */ + void exitUuidSet(MySqlParser.UuidSetContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#xid}. + * @param ctx the parse tree + */ + void enterXid(MySqlParser.XidContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#xid}. + * @param ctx the parse tree + */ + void exitXid(MySqlParser.XidContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#xuidStringId}. + * @param ctx the parse tree + */ + void enterXuidStringId(MySqlParser.XuidStringIdContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#xuidStringId}. + * @param ctx the parse tree + */ + void exitXuidStringId(MySqlParser.XuidStringIdContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#authPlugin}. + * @param ctx the parse tree + */ + void enterAuthPlugin(MySqlParser.AuthPluginContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#authPlugin}. + * @param ctx the parse tree + */ + void exitAuthPlugin(MySqlParser.AuthPluginContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#uid}. + * @param ctx the parse tree + */ + void enterUid(MySqlParser.UidContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#uid}. + * @param ctx the parse tree + */ + void exitUid(MySqlParser.UidContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#simpleId}. + * @param ctx the parse tree + */ + void enterSimpleId(MySqlParser.SimpleIdContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#simpleId}. + * @param ctx the parse tree + */ + void exitSimpleId(MySqlParser.SimpleIdContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dottedId}. + * @param ctx the parse tree + */ + void enterDottedId(MySqlParser.DottedIdContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dottedId}. + * @param ctx the parse tree + */ + void exitDottedId(MySqlParser.DottedIdContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#decimalLiteral}. + * @param ctx the parse tree + */ + void enterDecimalLiteral(MySqlParser.DecimalLiteralContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#decimalLiteral}. + * @param ctx the parse tree + */ + void exitDecimalLiteral(MySqlParser.DecimalLiteralContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#fileSizeLiteral}. + * @param ctx the parse tree + */ + void enterFileSizeLiteral(MySqlParser.FileSizeLiteralContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#fileSizeLiteral}. + * @param ctx the parse tree + */ + void exitFileSizeLiteral(MySqlParser.FileSizeLiteralContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#stringLiteral}. + * @param ctx the parse tree + */ + void enterStringLiteral(MySqlParser.StringLiteralContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#stringLiteral}. + * @param ctx the parse tree + */ + void exitStringLiteral(MySqlParser.StringLiteralContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#booleanLiteral}. + * @param ctx the parse tree + */ + void enterBooleanLiteral(MySqlParser.BooleanLiteralContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#booleanLiteral}. + * @param ctx the parse tree + */ + void exitBooleanLiteral(MySqlParser.BooleanLiteralContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#hexadecimalLiteral}. + * @param ctx the parse tree + */ + void enterHexadecimalLiteral(MySqlParser.HexadecimalLiteralContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#hexadecimalLiteral}. + * @param ctx the parse tree + */ + void exitHexadecimalLiteral(MySqlParser.HexadecimalLiteralContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#nullNotnull}. + * @param ctx the parse tree + */ + void enterNullNotnull(MySqlParser.NullNotnullContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#nullNotnull}. + * @param ctx the parse tree + */ + void exitNullNotnull(MySqlParser.NullNotnullContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#constant}. + * @param ctx the parse tree + */ + void enterConstant(MySqlParser.ConstantContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#constant}. + * @param ctx the parse tree + */ + void exitConstant(MySqlParser.ConstantContext ctx); + /** + * Enter a parse tree produced by the {@code stringDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void enterStringDataType(MySqlParser.StringDataTypeContext ctx); + /** + * Exit a parse tree produced by the {@code stringDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void exitStringDataType(MySqlParser.StringDataTypeContext ctx); + /** + * Enter a parse tree produced by the {@code nationalVaryingStringDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void enterNationalVaryingStringDataType(MySqlParser.NationalVaryingStringDataTypeContext ctx); + /** + * Exit a parse tree produced by the {@code nationalVaryingStringDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void exitNationalVaryingStringDataType(MySqlParser.NationalVaryingStringDataTypeContext ctx); + /** + * Enter a parse tree produced by the {@code nationalStringDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void enterNationalStringDataType(MySqlParser.NationalStringDataTypeContext ctx); + /** + * Exit a parse tree produced by the {@code nationalStringDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void exitNationalStringDataType(MySqlParser.NationalStringDataTypeContext ctx); + /** + * Enter a parse tree produced by the {@code dimensionDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void enterDimensionDataType(MySqlParser.DimensionDataTypeContext ctx); + /** + * Exit a parse tree produced by the {@code dimensionDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void exitDimensionDataType(MySqlParser.DimensionDataTypeContext ctx); + /** + * Enter a parse tree produced by the {@code simpleDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void enterSimpleDataType(MySqlParser.SimpleDataTypeContext ctx); + /** + * Exit a parse tree produced by the {@code simpleDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void exitSimpleDataType(MySqlParser.SimpleDataTypeContext ctx); + /** + * Enter a parse tree produced by the {@code collectionDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void enterCollectionDataType(MySqlParser.CollectionDataTypeContext ctx); + /** + * Exit a parse tree produced by the {@code collectionDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void exitCollectionDataType(MySqlParser.CollectionDataTypeContext ctx); + /** + * Enter a parse tree produced by the {@code spatialDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void enterSpatialDataType(MySqlParser.SpatialDataTypeContext ctx); + /** + * Exit a parse tree produced by the {@code spatialDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void exitSpatialDataType(MySqlParser.SpatialDataTypeContext ctx); + /** + * Enter a parse tree produced by the {@code longVarcharDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void enterLongVarcharDataType(MySqlParser.LongVarcharDataTypeContext ctx); + /** + * Exit a parse tree produced by the {@code longVarcharDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void exitLongVarcharDataType(MySqlParser.LongVarcharDataTypeContext ctx); + /** + * Enter a parse tree produced by the {@code longVarbinaryDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void enterLongVarbinaryDataType(MySqlParser.LongVarbinaryDataTypeContext ctx); + /** + * Exit a parse tree produced by the {@code longVarbinaryDataType} + * labeled alternative in {@link MySqlParser#dataType}. + * @param ctx the parse tree + */ + void exitLongVarbinaryDataType(MySqlParser.LongVarbinaryDataTypeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#collectionOptions}. + * @param ctx the parse tree + */ + void enterCollectionOptions(MySqlParser.CollectionOptionsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#collectionOptions}. + * @param ctx the parse tree + */ + void exitCollectionOptions(MySqlParser.CollectionOptionsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#convertedDataType}. + * @param ctx the parse tree + */ + void enterConvertedDataType(MySqlParser.ConvertedDataTypeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#convertedDataType}. + * @param ctx the parse tree + */ + void exitConvertedDataType(MySqlParser.ConvertedDataTypeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#lengthOneDimension}. + * @param ctx the parse tree + */ + void enterLengthOneDimension(MySqlParser.LengthOneDimensionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#lengthOneDimension}. + * @param ctx the parse tree + */ + void exitLengthOneDimension(MySqlParser.LengthOneDimensionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#lengthTwoDimension}. + * @param ctx the parse tree + */ + void enterLengthTwoDimension(MySqlParser.LengthTwoDimensionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#lengthTwoDimension}. + * @param ctx the parse tree + */ + void exitLengthTwoDimension(MySqlParser.LengthTwoDimensionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#lengthTwoOptionalDimension}. + * @param ctx the parse tree + */ + void enterLengthTwoOptionalDimension(MySqlParser.LengthTwoOptionalDimensionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#lengthTwoOptionalDimension}. + * @param ctx the parse tree + */ + void exitLengthTwoOptionalDimension(MySqlParser.LengthTwoOptionalDimensionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#uidList}. + * @param ctx the parse tree + */ + void enterUidList(MySqlParser.UidListContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#uidList}. + * @param ctx the parse tree + */ + void exitUidList(MySqlParser.UidListContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#fullColumnNameList}. + * @param ctx the parse tree + */ + void enterFullColumnNameList(MySqlParser.FullColumnNameListContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#fullColumnNameList}. + * @param ctx the parse tree + */ + void exitFullColumnNameList(MySqlParser.FullColumnNameListContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#tables}. + * @param ctx the parse tree + */ + void enterTables(MySqlParser.TablesContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#tables}. + * @param ctx the parse tree + */ + void exitTables(MySqlParser.TablesContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#indexColumnNames}. + * @param ctx the parse tree + */ + void enterIndexColumnNames(MySqlParser.IndexColumnNamesContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#indexColumnNames}. + * @param ctx the parse tree + */ + void exitIndexColumnNames(MySqlParser.IndexColumnNamesContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#expressions}. + * @param ctx the parse tree + */ + void enterExpressions(MySqlParser.ExpressionsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#expressions}. + * @param ctx the parse tree + */ + void exitExpressions(MySqlParser.ExpressionsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#expressionsWithDefaults}. + * @param ctx the parse tree + */ + void enterExpressionsWithDefaults(MySqlParser.ExpressionsWithDefaultsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#expressionsWithDefaults}. + * @param ctx the parse tree + */ + void exitExpressionsWithDefaults(MySqlParser.ExpressionsWithDefaultsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#constants}. + * @param ctx the parse tree + */ + void enterConstants(MySqlParser.ConstantsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#constants}. + * @param ctx the parse tree + */ + void exitConstants(MySqlParser.ConstantsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#simpleStrings}. + * @param ctx the parse tree + */ + void enterSimpleStrings(MySqlParser.SimpleStringsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#simpleStrings}. + * @param ctx the parse tree + */ + void exitSimpleStrings(MySqlParser.SimpleStringsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#userVariables}. + * @param ctx the parse tree + */ + void enterUserVariables(MySqlParser.UserVariablesContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#userVariables}. + * @param ctx the parse tree + */ + void exitUserVariables(MySqlParser.UserVariablesContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#defaultValue}. + * @param ctx the parse tree + */ + void enterDefaultValue(MySqlParser.DefaultValueContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#defaultValue}. + * @param ctx the parse tree + */ + void exitDefaultValue(MySqlParser.DefaultValueContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#currentTimestamp}. + * @param ctx the parse tree + */ + void enterCurrentTimestamp(MySqlParser.CurrentTimestampContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#currentTimestamp}. + * @param ctx the parse tree + */ + void exitCurrentTimestamp(MySqlParser.CurrentTimestampContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#expressionOrDefault}. + * @param ctx the parse tree + */ + void enterExpressionOrDefault(MySqlParser.ExpressionOrDefaultContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#expressionOrDefault}. + * @param ctx the parse tree + */ + void exitExpressionOrDefault(MySqlParser.ExpressionOrDefaultContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#ifExists}. + * @param ctx the parse tree + */ + void enterIfExists(MySqlParser.IfExistsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#ifExists}. + * @param ctx the parse tree + */ + void exitIfExists(MySqlParser.IfExistsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#ifNotExists}. + * @param ctx the parse tree + */ + void enterIfNotExists(MySqlParser.IfNotExistsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#ifNotExists}. + * @param ctx the parse tree + */ + void exitIfNotExists(MySqlParser.IfNotExistsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#orReplace}. + * @param ctx the parse tree + */ + void enterOrReplace(MySqlParser.OrReplaceContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#orReplace}. + * @param ctx the parse tree + */ + void exitOrReplace(MySqlParser.OrReplaceContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#waitNowaitClause}. + * @param ctx the parse tree + */ + void enterWaitNowaitClause(MySqlParser.WaitNowaitClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#waitNowaitClause}. + * @param ctx the parse tree + */ + void exitWaitNowaitClause(MySqlParser.WaitNowaitClauseContext ctx); + /** + * Enter a parse tree produced by the {@code specificFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void enterSpecificFunctionCall(MySqlParser.SpecificFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code specificFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void exitSpecificFunctionCall(MySqlParser.SpecificFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code aggregateFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void enterAggregateFunctionCall(MySqlParser.AggregateFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code aggregateFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void exitAggregateFunctionCall(MySqlParser.AggregateFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code nonAggregateFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void enterNonAggregateFunctionCall(MySqlParser.NonAggregateFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code nonAggregateFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void exitNonAggregateFunctionCall(MySqlParser.NonAggregateFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code scalarFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void enterScalarFunctionCall(MySqlParser.ScalarFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code scalarFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void exitScalarFunctionCall(MySqlParser.ScalarFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code udfFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void enterUdfFunctionCall(MySqlParser.UdfFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code udfFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void exitUdfFunctionCall(MySqlParser.UdfFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code passwordFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void enterPasswordFunctionCall(MySqlParser.PasswordFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code passwordFunctionCall} + * labeled alternative in {@link MySqlParser#functionCall}. + * @param ctx the parse tree + */ + void exitPasswordFunctionCall(MySqlParser.PasswordFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code simpleFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterSimpleFunctionCall(MySqlParser.SimpleFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code simpleFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitSimpleFunctionCall(MySqlParser.SimpleFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code currentUser} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterCurrentUser(MySqlParser.CurrentUserContext ctx); + /** + * Exit a parse tree produced by the {@code currentUser} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitCurrentUser(MySqlParser.CurrentUserContext ctx); + /** + * Enter a parse tree produced by the {@code dataTypeFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterDataTypeFunctionCall(MySqlParser.DataTypeFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code dataTypeFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitDataTypeFunctionCall(MySqlParser.DataTypeFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code valuesFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterValuesFunctionCall(MySqlParser.ValuesFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code valuesFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitValuesFunctionCall(MySqlParser.ValuesFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code caseExpressionFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterCaseExpressionFunctionCall(MySqlParser.CaseExpressionFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code caseExpressionFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitCaseExpressionFunctionCall(MySqlParser.CaseExpressionFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code caseFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterCaseFunctionCall(MySqlParser.CaseFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code caseFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitCaseFunctionCall(MySqlParser.CaseFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code charFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterCharFunctionCall(MySqlParser.CharFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code charFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitCharFunctionCall(MySqlParser.CharFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code positionFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterPositionFunctionCall(MySqlParser.PositionFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code positionFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitPositionFunctionCall(MySqlParser.PositionFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code substrFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterSubstrFunctionCall(MySqlParser.SubstrFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code substrFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitSubstrFunctionCall(MySqlParser.SubstrFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code trimFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterTrimFunctionCall(MySqlParser.TrimFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code trimFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitTrimFunctionCall(MySqlParser.TrimFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code weightFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterWeightFunctionCall(MySqlParser.WeightFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code weightFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitWeightFunctionCall(MySqlParser.WeightFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code extractFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterExtractFunctionCall(MySqlParser.ExtractFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code extractFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitExtractFunctionCall(MySqlParser.ExtractFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code getFormatFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterGetFormatFunctionCall(MySqlParser.GetFormatFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code getFormatFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitGetFormatFunctionCall(MySqlParser.GetFormatFunctionCallContext ctx); + /** + * Enter a parse tree produced by the {@code jsonValueFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void enterJsonValueFunctionCall(MySqlParser.JsonValueFunctionCallContext ctx); + /** + * Exit a parse tree produced by the {@code jsonValueFunctionCall} + * labeled alternative in {@link MySqlParser#specificFunction}. + * @param ctx the parse tree + */ + void exitJsonValueFunctionCall(MySqlParser.JsonValueFunctionCallContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#caseFuncAlternative}. + * @param ctx the parse tree + */ + void enterCaseFuncAlternative(MySqlParser.CaseFuncAlternativeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#caseFuncAlternative}. + * @param ctx the parse tree + */ + void exitCaseFuncAlternative(MySqlParser.CaseFuncAlternativeContext ctx); + /** + * Enter a parse tree produced by the {@code levelWeightList} + * labeled alternative in {@link MySqlParser#levelsInWeightString}. + * @param ctx the parse tree + */ + void enterLevelWeightList(MySqlParser.LevelWeightListContext ctx); + /** + * Exit a parse tree produced by the {@code levelWeightList} + * labeled alternative in {@link MySqlParser#levelsInWeightString}. + * @param ctx the parse tree + */ + void exitLevelWeightList(MySqlParser.LevelWeightListContext ctx); + /** + * Enter a parse tree produced by the {@code levelWeightRange} + * labeled alternative in {@link MySqlParser#levelsInWeightString}. + * @param ctx the parse tree + */ + void enterLevelWeightRange(MySqlParser.LevelWeightRangeContext ctx); + /** + * Exit a parse tree produced by the {@code levelWeightRange} + * labeled alternative in {@link MySqlParser#levelsInWeightString}. + * @param ctx the parse tree + */ + void exitLevelWeightRange(MySqlParser.LevelWeightRangeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#levelInWeightListElement}. + * @param ctx the parse tree + */ + void enterLevelInWeightListElement(MySqlParser.LevelInWeightListElementContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#levelInWeightListElement}. + * @param ctx the parse tree + */ + void exitLevelInWeightListElement(MySqlParser.LevelInWeightListElementContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#aggregateWindowedFunction}. + * @param ctx the parse tree + */ + void enterAggregateWindowedFunction(MySqlParser.AggregateWindowedFunctionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#aggregateWindowedFunction}. + * @param ctx the parse tree + */ + void exitAggregateWindowedFunction(MySqlParser.AggregateWindowedFunctionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#nonAggregateWindowedFunction}. + * @param ctx the parse tree + */ + void enterNonAggregateWindowedFunction(MySqlParser.NonAggregateWindowedFunctionContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#nonAggregateWindowedFunction}. + * @param ctx the parse tree + */ + void exitNonAggregateWindowedFunction(MySqlParser.NonAggregateWindowedFunctionContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#overClause}. + * @param ctx the parse tree + */ + void enterOverClause(MySqlParser.OverClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#overClause}. + * @param ctx the parse tree + */ + void exitOverClause(MySqlParser.OverClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#windowSpec}. + * @param ctx the parse tree + */ + void enterWindowSpec(MySqlParser.WindowSpecContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#windowSpec}. + * @param ctx the parse tree + */ + void exitWindowSpec(MySqlParser.WindowSpecContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#windowName}. + * @param ctx the parse tree + */ + void enterWindowName(MySqlParser.WindowNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#windowName}. + * @param ctx the parse tree + */ + void exitWindowName(MySqlParser.WindowNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#frameClause}. + * @param ctx the parse tree + */ + void enterFrameClause(MySqlParser.FrameClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#frameClause}. + * @param ctx the parse tree + */ + void exitFrameClause(MySqlParser.FrameClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#frameUnits}. + * @param ctx the parse tree + */ + void enterFrameUnits(MySqlParser.FrameUnitsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#frameUnits}. + * @param ctx the parse tree + */ + void exitFrameUnits(MySqlParser.FrameUnitsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#frameExtent}. + * @param ctx the parse tree + */ + void enterFrameExtent(MySqlParser.FrameExtentContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#frameExtent}. + * @param ctx the parse tree + */ + void exitFrameExtent(MySqlParser.FrameExtentContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#frameBetween}. + * @param ctx the parse tree + */ + void enterFrameBetween(MySqlParser.FrameBetweenContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#frameBetween}. + * @param ctx the parse tree + */ + void exitFrameBetween(MySqlParser.FrameBetweenContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#frameRange}. + * @param ctx the parse tree + */ + void enterFrameRange(MySqlParser.FrameRangeContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#frameRange}. + * @param ctx the parse tree + */ + void exitFrameRange(MySqlParser.FrameRangeContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#partitionClause}. + * @param ctx the parse tree + */ + void enterPartitionClause(MySqlParser.PartitionClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#partitionClause}. + * @param ctx the parse tree + */ + void exitPartitionClause(MySqlParser.PartitionClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#scalarFunctionName}. + * @param ctx the parse tree + */ + void enterScalarFunctionName(MySqlParser.ScalarFunctionNameContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#scalarFunctionName}. + * @param ctx the parse tree + */ + void exitScalarFunctionName(MySqlParser.ScalarFunctionNameContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#passwordFunctionClause}. + * @param ctx the parse tree + */ + void enterPasswordFunctionClause(MySqlParser.PasswordFunctionClauseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#passwordFunctionClause}. + * @param ctx the parse tree + */ + void exitPasswordFunctionClause(MySqlParser.PasswordFunctionClauseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#functionArgs}. + * @param ctx the parse tree + */ + void enterFunctionArgs(MySqlParser.FunctionArgsContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#functionArgs}. + * @param ctx the parse tree + */ + void exitFunctionArgs(MySqlParser.FunctionArgsContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#functionArg}. + * @param ctx the parse tree + */ + void enterFunctionArg(MySqlParser.FunctionArgContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#functionArg}. + * @param ctx the parse tree + */ + void exitFunctionArg(MySqlParser.FunctionArgContext ctx); + /** + * Enter a parse tree produced by the {@code isExpression} + * labeled alternative in {@link MySqlParser#expression}. + * @param ctx the parse tree + */ + void enterIsExpression(MySqlParser.IsExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code isExpression} + * labeled alternative in {@link MySqlParser#expression}. + * @param ctx the parse tree + */ + void exitIsExpression(MySqlParser.IsExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code notExpression} + * labeled alternative in {@link MySqlParser#expression}. + * @param ctx the parse tree + */ + void enterNotExpression(MySqlParser.NotExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code notExpression} + * labeled alternative in {@link MySqlParser#expression}. + * @param ctx the parse tree + */ + void exitNotExpression(MySqlParser.NotExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code logicalExpression} + * labeled alternative in {@link MySqlParser#expression}. + * @param ctx the parse tree + */ + void enterLogicalExpression(MySqlParser.LogicalExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code logicalExpression} + * labeled alternative in {@link MySqlParser#expression}. + * @param ctx the parse tree + */ + void exitLogicalExpression(MySqlParser.LogicalExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code predicateExpression} + * labeled alternative in {@link MySqlParser#expression}. + * @param ctx the parse tree + */ + void enterPredicateExpression(MySqlParser.PredicateExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code predicateExpression} + * labeled alternative in {@link MySqlParser#expression}. + * @param ctx the parse tree + */ + void exitPredicateExpression(MySqlParser.PredicateExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code soundsLikePredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterSoundsLikePredicate(MySqlParser.SoundsLikePredicateContext ctx); + /** + * Exit a parse tree produced by the {@code soundsLikePredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitSoundsLikePredicate(MySqlParser.SoundsLikePredicateContext ctx); + /** + * Enter a parse tree produced by the {@code expressionAtomPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterExpressionAtomPredicate(MySqlParser.ExpressionAtomPredicateContext ctx); + /** + * Exit a parse tree produced by the {@code expressionAtomPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitExpressionAtomPredicate(MySqlParser.ExpressionAtomPredicateContext ctx); + /** + * Enter a parse tree produced by the {@code subqueryComparisonPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterSubqueryComparisonPredicate(MySqlParser.SubqueryComparisonPredicateContext ctx); + /** + * Exit a parse tree produced by the {@code subqueryComparisonPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitSubqueryComparisonPredicate(MySqlParser.SubqueryComparisonPredicateContext ctx); + /** + * Enter a parse tree produced by the {@code jsonMemberOfPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterJsonMemberOfPredicate(MySqlParser.JsonMemberOfPredicateContext ctx); + /** + * Exit a parse tree produced by the {@code jsonMemberOfPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitJsonMemberOfPredicate(MySqlParser.JsonMemberOfPredicateContext ctx); + /** + * Enter a parse tree produced by the {@code binaryComparisonPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterBinaryComparisonPredicate(MySqlParser.BinaryComparisonPredicateContext ctx); + /** + * Exit a parse tree produced by the {@code binaryComparisonPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitBinaryComparisonPredicate(MySqlParser.BinaryComparisonPredicateContext ctx); + /** + * Enter a parse tree produced by the {@code inPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterInPredicate(MySqlParser.InPredicateContext ctx); + /** + * Exit a parse tree produced by the {@code inPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitInPredicate(MySqlParser.InPredicateContext ctx); + /** + * Enter a parse tree produced by the {@code betweenPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterBetweenPredicate(MySqlParser.BetweenPredicateContext ctx); + /** + * Exit a parse tree produced by the {@code betweenPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitBetweenPredicate(MySqlParser.BetweenPredicateContext ctx); + /** + * Enter a parse tree produced by the {@code isNullPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterIsNullPredicate(MySqlParser.IsNullPredicateContext ctx); + /** + * Exit a parse tree produced by the {@code isNullPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitIsNullPredicate(MySqlParser.IsNullPredicateContext ctx); + /** + * Enter a parse tree produced by the {@code likePredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterLikePredicate(MySqlParser.LikePredicateContext ctx); + /** + * Exit a parse tree produced by the {@code likePredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitLikePredicate(MySqlParser.LikePredicateContext ctx); + /** + * Enter a parse tree produced by the {@code regexpPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void enterRegexpPredicate(MySqlParser.RegexpPredicateContext ctx); + /** + * Exit a parse tree produced by the {@code regexpPredicate} + * labeled alternative in {@link MySqlParser#predicate}. + * @param ctx the parse tree + */ + void exitRegexpPredicate(MySqlParser.RegexpPredicateContext ctx); + /** + * Enter a parse tree produced by the {@code unaryExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterUnaryExpressionAtom(MySqlParser.UnaryExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code unaryExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitUnaryExpressionAtom(MySqlParser.UnaryExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code collateExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterCollateExpressionAtom(MySqlParser.CollateExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code collateExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitCollateExpressionAtom(MySqlParser.CollateExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code variableAssignExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterVariableAssignExpressionAtom(MySqlParser.VariableAssignExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code variableAssignExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitVariableAssignExpressionAtom(MySqlParser.VariableAssignExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code mysqlVariableExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterMysqlVariableExpressionAtom(MySqlParser.MysqlVariableExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code mysqlVariableExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitMysqlVariableExpressionAtom(MySqlParser.MysqlVariableExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code nestedExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterNestedExpressionAtom(MySqlParser.NestedExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code nestedExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitNestedExpressionAtom(MySqlParser.NestedExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code nestedRowExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterNestedRowExpressionAtom(MySqlParser.NestedRowExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code nestedRowExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitNestedRowExpressionAtom(MySqlParser.NestedRowExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code mathExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterMathExpressionAtom(MySqlParser.MathExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code mathExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitMathExpressionAtom(MySqlParser.MathExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code existsExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterExistsExpressionAtom(MySqlParser.ExistsExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code existsExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitExistsExpressionAtom(MySqlParser.ExistsExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code intervalExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterIntervalExpressionAtom(MySqlParser.IntervalExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code intervalExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitIntervalExpressionAtom(MySqlParser.IntervalExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code spelExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterSpelExpressionAtom(MySqlParser.SpelExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code spelExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitSpelExpressionAtom(MySqlParser.SpelExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code jsonExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterJsonExpressionAtom(MySqlParser.JsonExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code jsonExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitJsonExpressionAtom(MySqlParser.JsonExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code subqueryExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterSubqueryExpressionAtom(MySqlParser.SubqueryExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code subqueryExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitSubqueryExpressionAtom(MySqlParser.SubqueryExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code constantExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterConstantExpressionAtom(MySqlParser.ConstantExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code constantExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitConstantExpressionAtom(MySqlParser.ConstantExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code functionCallExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterFunctionCallExpressionAtom(MySqlParser.FunctionCallExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code functionCallExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitFunctionCallExpressionAtom(MySqlParser.FunctionCallExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code binaryExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterBinaryExpressionAtom(MySqlParser.BinaryExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code binaryExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitBinaryExpressionAtom(MySqlParser.BinaryExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code fullColumnNameExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterFullColumnNameExpressionAtom(MySqlParser.FullColumnNameExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code fullColumnNameExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitFullColumnNameExpressionAtom(MySqlParser.FullColumnNameExpressionAtomContext ctx); + /** + * Enter a parse tree produced by the {@code bitExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void enterBitExpressionAtom(MySqlParser.BitExpressionAtomContext ctx); + /** + * Exit a parse tree produced by the {@code bitExpressionAtom} + * labeled alternative in {@link MySqlParser#expressionAtom}. + * @param ctx the parse tree + */ + void exitBitExpressionAtom(MySqlParser.BitExpressionAtomContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#unaryOperator}. + * @param ctx the parse tree + */ + void enterUnaryOperator(MySqlParser.UnaryOperatorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#unaryOperator}. + * @param ctx the parse tree + */ + void exitUnaryOperator(MySqlParser.UnaryOperatorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#comparisonOperator}. + * @param ctx the parse tree + */ + void enterComparisonOperator(MySqlParser.ComparisonOperatorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#comparisonOperator}. + * @param ctx the parse tree + */ + void exitComparisonOperator(MySqlParser.ComparisonOperatorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#logicalOperator}. + * @param ctx the parse tree + */ + void enterLogicalOperator(MySqlParser.LogicalOperatorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#logicalOperator}. + * @param ctx the parse tree + */ + void exitLogicalOperator(MySqlParser.LogicalOperatorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#bitOperator}. + * @param ctx the parse tree + */ + void enterBitOperator(MySqlParser.BitOperatorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#bitOperator}. + * @param ctx the parse tree + */ + void exitBitOperator(MySqlParser.BitOperatorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#multOperator}. + * @param ctx the parse tree + */ + void enterMultOperator(MySqlParser.MultOperatorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#multOperator}. + * @param ctx the parse tree + */ + void exitMultOperator(MySqlParser.MultOperatorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#addOperator}. + * @param ctx the parse tree + */ + void enterAddOperator(MySqlParser.AddOperatorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#addOperator}. + * @param ctx the parse tree + */ + void exitAddOperator(MySqlParser.AddOperatorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#jsonOperator}. + * @param ctx the parse tree + */ + void enterJsonOperator(MySqlParser.JsonOperatorContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#jsonOperator}. + * @param ctx the parse tree + */ + void exitJsonOperator(MySqlParser.JsonOperatorContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#charsetNameBase}. + * @param ctx the parse tree + */ + void enterCharsetNameBase(MySqlParser.CharsetNameBaseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#charsetNameBase}. + * @param ctx the parse tree + */ + void exitCharsetNameBase(MySqlParser.CharsetNameBaseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#transactionLevelBase}. + * @param ctx the parse tree + */ + void enterTransactionLevelBase(MySqlParser.TransactionLevelBaseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#transactionLevelBase}. + * @param ctx the parse tree + */ + void exitTransactionLevelBase(MySqlParser.TransactionLevelBaseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#privilegesBase}. + * @param ctx the parse tree + */ + void enterPrivilegesBase(MySqlParser.PrivilegesBaseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#privilegesBase}. + * @param ctx the parse tree + */ + void exitPrivilegesBase(MySqlParser.PrivilegesBaseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#intervalTypeBase}. + * @param ctx the parse tree + */ + void enterIntervalTypeBase(MySqlParser.IntervalTypeBaseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#intervalTypeBase}. + * @param ctx the parse tree + */ + void exitIntervalTypeBase(MySqlParser.IntervalTypeBaseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#dataTypeBase}. + * @param ctx the parse tree + */ + void enterDataTypeBase(MySqlParser.DataTypeBaseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#dataTypeBase}. + * @param ctx the parse tree + */ + void exitDataTypeBase(MySqlParser.DataTypeBaseContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#keywordsCanBeId}. + * @param ctx the parse tree + */ + void enterKeywordsCanBeId(MySqlParser.KeywordsCanBeIdContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#keywordsCanBeId}. + * @param ctx the parse tree + */ + void exitKeywordsCanBeId(MySqlParser.KeywordsCanBeIdContext ctx); + /** + * Enter a parse tree produced by {@link MySqlParser#functionNameBase}. + * @param ctx the parse tree + */ + void enterFunctionNameBase(MySqlParser.FunctionNameBaseContext ctx); + /** + * Exit a parse tree produced by {@link MySqlParser#functionNameBase}. + * @param ctx the parse tree + */ + void exitFunctionNameBase(MySqlParser.FunctionNameBaseContext ctx); +} \ No newline at end of file diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/BootLanguageServerInitializer.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/BootLanguageServerInitializer.java index b2beb92c0..b74cda9af 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/BootLanguageServerInitializer.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/BootLanguageServerInitializer.java @@ -25,8 +25,10 @@ import org.springframework.context.ApplicationContext; import org.springframework.ide.vscode.boot.factories.SpringFactoriesLanguageServerComponents; import org.springframework.ide.vscode.boot.index.cache.IndexCache; import org.springframework.ide.vscode.boot.java.BootJavaLanguageServerComponents; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.HqlReconciler; import org.springframework.ide.vscode.boot.java.data.jpa.queries.HqlSemanticTokens; import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpaQueryPropertiesLanguageServerComponents; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpqlReconciler; import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpqlSemanticTokens; import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpqlSupportState; import org.springframework.ide.vscode.boot.java.links.JavaElementLocationProvider; @@ -128,7 +130,7 @@ public class BootLanguageServerInitializer implements InitializingBean { new SpringFactoriesLanguageServerComponents(projectFinder, springIndexer, config), new PomLanguageServerComponents(server, projectFinder, params.projectObserver, appContext.getBean(SpringProjectsProvider.class)), new JpaQueryPropertiesLanguageServerComponents(server.getTextDocumentService(), projectFinder, appContext.getBean(JpqlSemanticTokens.class), - appContext.getBean(HqlSemanticTokens.class), appContext.getBean(JpqlSupportState.class)) + appContext.getBean(HqlSemanticTokens.class), appContext.getBean(JpqlSupportState.class), appContext.getBean(HqlReconciler.class), appContext.getBean(JpqlReconciler.class)) ); for (LanguageServerComponents c : componentsList) { diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/JdtConfig.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/JdtConfig.java index f1df8cb78..dbacf022f 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/JdtConfig.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/JdtConfig.java @@ -12,11 +12,15 @@ package org.springframework.ide.vscode.boot.app; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.HqlReconciler; import org.springframework.ide.vscode.boot.java.data.jpa.queries.HqlSemanticTokens; import org.springframework.ide.vscode.boot.java.data.jpa.queries.JdtDataQuerySemanticTokensProvider; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpqlReconciler; import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpqlSemanticTokens; import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpqlSupportState; import org.springframework.ide.vscode.boot.java.data.jpa.queries.QueryJdtAstReconciler; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.SqlReconciler; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.SqlSemanticTokens; import org.springframework.ide.vscode.boot.java.reconcilers.AddConfigurationIfBeansPresentReconciler; import org.springframework.ide.vscode.boot.java.reconcilers.AnnotationNodeReconciler; import org.springframework.ide.vscode.boot.java.reconcilers.AuthorizeHttpRequestsReconciler; @@ -117,12 +121,12 @@ public class JdtConfig { return new JavaSemanticTokensProvider(); } - @Bean JdtDataQuerySemanticTokensProvider jpqlJdtSemanticTokensProvider(JpqlSemanticTokens jpqlProvider, HqlSemanticTokens hqlProvider, JpqlSupportState supportState) { - return new JdtDataQuerySemanticTokensProvider(jpqlProvider, hqlProvider, supportState); + @Bean JdtDataQuerySemanticTokensProvider jpqlJdtSemanticTokensProvider(JpqlSemanticTokens jpqlProvider, HqlSemanticTokens hqlProvider, SqlSemanticTokens sqlSemanticTokens, JpqlSupportState supportState) { + return new JdtDataQuerySemanticTokensProvider(jpqlProvider, hqlProvider, sqlSemanticTokens, supportState); } - @Bean QueryJdtAstReconciler dataQueryReconciler() { - return new QueryJdtAstReconciler(); + @Bean QueryJdtAstReconciler dataQueryReconciler(HqlReconciler hqlReconciler, JpqlReconciler jpqlReconciler, SqlReconciler sqlReconciler) { + return new QueryJdtAstReconciler(hqlReconciler, jpqlReconciler, sqlReconciler); } } diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/SpringDataConfig.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/SpringDataConfig.java index b52c8a8f2..e4dcd0cb6 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/SpringDataConfig.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/app/SpringDataConfig.java @@ -12,9 +12,13 @@ package org.springframework.ide.vscode.boot.app; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.HqlReconciler; import org.springframework.ide.vscode.boot.java.data.jpa.queries.HqlSemanticTokens; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpqlReconciler; import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpqlSemanticTokens; import org.springframework.ide.vscode.boot.java.data.jpa.queries.JpqlSupportState; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.SqlReconciler; +import org.springframework.ide.vscode.boot.java.data.jpa.queries.SqlSemanticTokens; import org.springframework.ide.vscode.commons.languageserver.java.ProjectObserver; import org.springframework.ide.vscode.commons.languageserver.util.SimpleLanguageServer; @@ -30,6 +34,26 @@ public class SpringDataConfig { HqlSemanticTokens hqlSemanticTokens() { return new HqlSemanticTokens(); } + + @Bean + SqlSemanticTokens sqlSemanticTokens() { + return new SqlSemanticTokens(); + } + + @Bean + HqlReconciler hqlReconciler() { + return new HqlReconciler(); + } + + @Bean + JpqlReconciler jpqlReconciler() { + return new JpqlReconciler(); + } + + @Bean + SqlReconciler sqlReconciler() { + return new SqlReconciler(); + } @Bean JpqlSupportState jpqlSupportState(SimpleLanguageServer server, ProjectObserver projectObserver, BootJavaConfig config) { diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlReconciler.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlReconciler.java index a47e437ec..009983b37 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlReconciler.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlReconciler.java @@ -50,7 +50,7 @@ public class HqlReconciler implements Reconciler { offset = token.getStartIndex() - token.getCharPositionInLine(); length = token.getCharPositionInLine() + 1; } - problemCollector.accept(new ReconcileProblemImpl(QueryProblemType.EXPRESSION_SYNTAX, msg, startPosition + offset, length)); + problemCollector.accept(new ReconcileProblemImpl(QueryProblemType.EXPRESSION_SYNTAX, "HQL: " + msg, startPosition + offset, length)); } @Override diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProvider.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProvider.java index 65094bcd5..4e7f3b4c9 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProvider.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProvider.java @@ -40,11 +40,13 @@ public class JdtDataQuerySemanticTokensProvider implements JdtSemanticTokensProv private final JpqlSemanticTokens jpqlProvider; private final HqlSemanticTokens hqlProvider; + private final SqlSemanticTokens sqlProvider; private final JpqlSupportState supportState; - public JdtDataQuerySemanticTokensProvider(JpqlSemanticTokens jpqlProvider, HqlSemanticTokens hqlProvider, JpqlSupportState supportState) { + public JdtDataQuerySemanticTokensProvider(JpqlSemanticTokens jpqlProvider, HqlSemanticTokens hqlProvider, SqlSemanticTokens sqlSemanticTokens, JpqlSupportState supportState) { this.jpqlProvider = jpqlProvider; this.hqlProvider = hqlProvider; + this.sqlProvider = sqlSemanticTokens; this.supportState = supportState; } @@ -94,7 +96,7 @@ public class JdtDataQuerySemanticTokensProvider implements JdtSemanticTokensProv if (queryExpression != null) { if (isNative) { - //TODO: SQL semantic tokens + computeTokensForQueryExpression(sqlProvider, queryExpression).forEach(tokensData::accept); } else { computeTokensForQueryExpression(provider, queryExpression).forEach(tokensData::accept); } diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpaQueryPropertiesLanguageServerComponents.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpaQueryPropertiesLanguageServerComponents.java index 03a3239f3..31ee8a527 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpaQueryPropertiesLanguageServerComponents.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpaQueryPropertiesLanguageServerComponents.java @@ -26,9 +26,10 @@ public class JpaQueryPropertiesLanguageServerComponents implements LanguageServe private final NamedQueryPropertiesReconcileEngine reconcileEngine; public JpaQueryPropertiesLanguageServerComponents(SimpleTextDocumentService documents, JavaProjectFinder projectsFinder, - JpqlSemanticTokens jpqlSemanticTokensProvider, HqlSemanticTokens hqlSematicTokensProvider, JpqlSupportState supportState) { + JpqlSemanticTokens jpqlSemanticTokensProvider, HqlSemanticTokens hqlSematicTokensProvider, JpqlSupportState supportState, + HqlReconciler hqlReconciler, JpqlReconciler jpqlReconciler) { this.semanticTokensHandler = new QueryPropertiesSemanticTokensHandler(projectsFinder, jpqlSemanticTokensProvider, hqlSematicTokensProvider, supportState); - this.reconcileEngine = new NamedQueryPropertiesReconcileEngine(projectsFinder); + this.reconcileEngine = new NamedQueryPropertiesReconcileEngine(projectsFinder, hqlReconciler, jpqlReconciler); } @Override diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlReconciler.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlReconciler.java index cd85f8601..3231bc640 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlReconciler.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlReconciler.java @@ -50,7 +50,7 @@ public class JpqlReconciler implements Reconciler { offset = token.getStartIndex() - token.getCharPositionInLine(); length = token.getCharPositionInLine() + 1; } - problemCollector.accept(new ReconcileProblemImpl(QueryProblemType.EXPRESSION_SYNTAX, msg, startPosition + offset, length)); + problemCollector.accept(new ReconcileProblemImpl(QueryProblemType.EXPRESSION_SYNTAX, "JPQL: " + msg, startPosition + offset, length)); } @Override diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/NamedQueryPropertiesReconcileEngine.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/NamedQueryPropertiesReconcileEngine.java index 5f907d95d..ea52b89dd 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/NamedQueryPropertiesReconcileEngine.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/NamedQueryPropertiesReconcileEngine.java @@ -25,16 +25,20 @@ import org.springframework.ide.vscode.java.properties.parser.PropertiesAst.Value public class NamedQueryPropertiesReconcileEngine implements IReconcileEngine { private final JavaProjectFinder projectFinder; + private final HqlReconciler hqlReconciler; + private final JpqlReconciler jpqlReconciler; - public NamedQueryPropertiesReconcileEngine(JavaProjectFinder projectFinder) { + public NamedQueryPropertiesReconcileEngine(JavaProjectFinder projectFinder, HqlReconciler hqlReconciler, JpqlReconciler jpqlReconciler) { this.projectFinder = projectFinder; + this.hqlReconciler = hqlReconciler; + this.jpqlReconciler = jpqlReconciler; } @Override public void reconcile(IDocument doc, IProblemCollector problemCollector) { try { Reconciler reconciler = projectFinder.find(new TextDocumentIdentifier(doc.getUri())) - .map(p -> SpringProjectUtil.hasDependencyStartingWith(p, "spring-data-jpa", null) ? new HqlReconciler() : new JpqlReconciler()) + .map(p -> SpringProjectUtil.hasDependencyStartingWith(p, "spring-data-jpa", null) ? hqlReconciler : jpqlReconciler) .orElse(new JpqlReconciler()); AntlrParser parser = new AntlrParser(); diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryJdtAstReconciler.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryJdtAstReconciler.java index c86873178..e9053be59 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryJdtAstReconciler.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryJdtAstReconciler.java @@ -34,6 +34,18 @@ import org.springframework.ide.vscode.commons.languageserver.reconcile.IProblemC import org.springframework.ide.vscode.commons.languageserver.reconcile.ProblemType; public class QueryJdtAstReconciler implements JdtAstReconciler { + + private final HqlReconciler hqlReconciler; + private final JpqlReconciler jpqlReconciler; + private final SqlReconciler sqlReconciler; + + + public QueryJdtAstReconciler(HqlReconciler hqlReconciler, JpqlReconciler jpqlReconciler, + SqlReconciler sqlReconciler) { + this.hqlReconciler = hqlReconciler; + this.jpqlReconciler = jpqlReconciler; + this.sqlReconciler = sqlReconciler; + } @Override public ASTVisitor createVisitor(IJavaProject project, URI docURI, CompilationUnit cu, IProblemCollector problemCollector, boolean isCompleteAst) throws RequiredCompleteAstException { @@ -75,7 +87,7 @@ public class QueryJdtAstReconciler implements JdtAstReconciler { if (queryExpression != null) { if (isNative) { - //TODO: SQL syntax validation + reconcileExpression(sqlReconciler, queryExpression, problemCollector); } else { reconcileExpression(getQueryReconciler(project), queryExpression, problemCollector); } @@ -113,8 +125,8 @@ public class QueryJdtAstReconciler implements JdtAstReconciler { /* * Gets either HQL or JPQL reconciler */ - private static Reconciler getQueryReconciler(IJavaProject project) { - return SpringProjectUtil.hasDependencyStartingWith(project, "hibernate-core", null) ? new HqlReconciler() : new JpqlReconciler(); + private Reconciler getQueryReconciler(IJavaProject project) { + return SpringProjectUtil.hasDependencyStartingWith(project, "hibernate-core", null) ? hqlReconciler : jpqlReconciler; } private void reconcileExpression(Reconciler reconciler, Expression valueExp, IProblemCollector problemCollector) { diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlReconciler.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlReconciler.java new file mode 100644 index 000000000..6642fd538 --- /dev/null +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlReconciler.java @@ -0,0 +1,76 @@ +/******************************************************************************* + * Copyright (c) 2024 Broadcom, Inc. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Broadcom, Inc. - initial API and implementation + *******************************************************************************/ +package org.springframework.ide.vscode.boot.java.data.jpa.queries; + +import java.util.BitSet; + +import org.antlr.v4.runtime.ANTLRErrorListener; +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.ConsoleErrorListener; +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.Recognizer; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.atn.ATNConfigSet; +import org.antlr.v4.runtime.dfa.DFA; +import org.springframework.ide.vscode.boot.java.handlers.Reconciler; +import org.springframework.ide.vscode.commons.languageserver.reconcile.IProblemCollector; +import org.springframework.ide.vscode.commons.languageserver.reconcile.ReconcileProblemImpl; +import org.springframework.ide.vscode.parser.sql.MySqlLexer; +import org.springframework.ide.vscode.parser.sql.MySqlParser; + +public class SqlReconciler implements Reconciler { + + @Override + public void reconcile(String text, int startPosition, IProblemCollector problemCollector) { + MySqlLexer lexer = new MySqlLexer(CharStreams.fromString(text)); + CommonTokenStream antlrTokens = new CommonTokenStream(lexer); + MySqlParser parser = new MySqlParser(antlrTokens); + + parser.removeErrorListener(ConsoleErrorListener.INSTANCE); + + parser.addErrorListener(new ANTLRErrorListener() { + + @Override + public void syntaxError(Recognizer recognizer, Object offendingSymbol, int line, int charPositionInLine, + String msg, RecognitionException e) { + Token token = (Token) offendingSymbol; + int offset = token.getStartIndex(); + int length = token.getStopIndex() - token.getStartIndex() + 1; + if (token.getStartIndex() >= token.getStopIndex()) { + offset = token.getStartIndex() - token.getCharPositionInLine(); + length = token.getCharPositionInLine() + 1; + } + problemCollector.accept(new ReconcileProblemImpl(QueryProblemType.EXPRESSION_SYNTAX, "SQL: " + msg, startPosition + offset, length)); + } + + @Override + public void reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, + ATNConfigSet configs) { + } + + @Override + public void reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, + BitSet conflictingAlts, ATNConfigSet configs) { + } + + @Override + public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, + BitSet ambigAlts, ATNConfigSet configs) { + } + }); + + parser.sqlStatements(); + + } + +} diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlSemanticTokens.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlSemanticTokens.java new file mode 100644 index 000000000..248813c49 --- /dev/null +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlSemanticTokens.java @@ -0,0 +1,179 @@ +/******************************************************************************* + * Copyright (c) 2024 Broadcom, Inc. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Broadcom, Inc. - initial API and implementation + *******************************************************************************/ +package org.springframework.ide.vscode.boot.java.data.jpa.queries; + +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.ConsoleErrorListener; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; +import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.SemanticTokenData; +import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.SemanticTokensDataProvider; +import org.springframework.ide.vscode.parser.sql.MySqlLexer; +import org.springframework.ide.vscode.parser.sql.MySqlParser; +import org.springframework.ide.vscode.parser.sql.MySqlParserBaseListener; + +public class SqlSemanticTokens implements SemanticTokensDataProvider { + + private static List TOKEN_TYPES = List.of("keyword", "type", "string", "number", "operator", + "variable", "regexp", "comment"); + + @Override + public List getTokenTypes() { + return TOKEN_TYPES; + } + + + @Override + public List computeTokens(String text, int initialOffset) { + MySqlLexer lexer = new MySqlLexer(CharStreams.fromString(text)); + CommonTokenStream antlrTokens = new CommonTokenStream(lexer); + MySqlParser parser = new MySqlParser(antlrTokens); + + Map semantics = new HashMap<>(); + + parser.removeErrorListener(ConsoleErrorListener.INSTANCE); + + parser.addParseListener(new MySqlParserBaseListener() { + + private void processTerminalNode(TerminalNode node) { + int type = node.getSymbol().getType(); + switch (type) { + case MySqlParser.SPEL: + semantics.put(node.getSymbol(), "regexp"); + break; + case MySqlParser.ID: + semantics.put(node.getSymbol(), "variable"); + break; + case MySqlParser.DOT_ID: + semantics.put(node.getSymbol(), "variable"); + break; + case MySqlParser.DOT: + semantics.put(node.getSymbol(), "operator"); + break; + case MySqlParser.NULL_LITERAL: + semantics.put(node.getSymbol(), "number"); + break; + case MySqlParser.FILESIZE_LITERAL: + semantics.put(node.getSymbol(), "number"); + break; + case MySqlParser.ZERO_DECIMAL: + case MySqlParser.ONE_DECIMAL: + case MySqlParser.TWO_DECIMAL: + semantics.put(node.getSymbol(), "number"); + break; + case MySqlParser.START_NATIONAL_STRING_LITERAL: + case MySqlParser.STRING_LITERAL: + semantics.put(node.getSymbol(), "string"); + break; + case MySqlParser.STRING_CHARSET_NAME: + semantics.put(node.getSymbol(), "type"); + break; + case MySqlParser.HOST_IP_ADDRESS: + case MySqlParser.LOCAL_ID: + case MySqlParser.GLOBAL_ID: + semantics.put(node.getSymbol(), "string"); + break; + case MySqlParser.SPEC_MYSQL_COMMENT: + case MySqlParser.COMMENT_INPUT: + case MySqlParser.LINE_COMMENT: + semantics.put(node.getSymbol(), "comment"); + break; + default: + if (MySqlParser.VAR_ASSIGN <= type && type <= MySqlParser.COLON_SYMB) { + semantics.put(node.getSymbol(), "operator"); + } else if (MySqlParser.DECIMAL_LITERAL <= type && type <= MySqlParser.BIT_STRING) { + semantics.put(node.getSymbol(), "number"); + } else if (MySqlParser.ABS <= type && type <= MySqlParser.X_FUNCTION) { + // Common function names + semantics.put(node.getSymbol(), "keyword"); + } else if (MySqlParser.ADD <= type && type <= MySqlParser.ZEROFILL) { + // Keywords + // Common Keywords + semantics.put(node.getSymbol(), "keyword"); + } else if (MySqlParser.TINYINT <= type && type <= MySqlParser.SERIAL) { + // DATA TYPE Keywords + semantics.put(node.getSymbol(), "type"); + } else if (MySqlParser.YEAR_MONTH <= type && type <= MySqlParser.DAY_MICROSECOND) { + // Interval type Keywords + semantics.put(node.getSymbol(), "type"); + } else if (MySqlParser.JSON_ARRAY <= type && type <= MySqlParser.PATH) { + // JSON keywords + semantics.put(node.getSymbol(), "keyword"); + } else if (MySqlParser.JSON_ARRAY <= type && type <= MySqlParser.PATH) { + // Group function Keywords + semantics.put(node.getSymbol(), "keyword"); + } else if (MySqlParser.CURRENT_DATE <= type && type <= MySqlParser.UTC_TIMESTAMP) { + // Common function Keywords + semantics.put(node.getSymbol(), "keyword"); + } else if (MySqlParser.ACCOUNT <= type && type <= MySqlParser.YES) { + // Keywords, but can be ID + // Common Keywords, but can be ID + semantics.put(node.getSymbol(), "type"); + } else if (MySqlParser.EUR <= type && type <= MySqlParser.INTERNAL) { + // Date format Keywords + semantics.put(node.getSymbol(), "type"); + } else if (MySqlParser.QUARTER <= type && type <= MySqlParser.MICROSECOND) { + // Date format Keywords + semantics.put(node.getSymbol(), "type"); + } else if (MySqlParser.ADMIN <= type && type <= MySqlParser.XA_RECOVER_ADMIN) { + // PRIVILEGES + semantics.put(node.getSymbol(), "type"); + } else if (MySqlParser.ARMSCII8 <= type && type <= MySqlParser.UTF8MB4) { + // Charsets + semantics.put(node.getSymbol(), "type"); + } else if (MySqlParser.ARCHIVE <= type && type <= MySqlParser.TOKUDB) { + // DB Engines + semantics.put(node.getSymbol(), "type"); + } else if (MySqlParser.REPEATABLE <= type && type <= MySqlParser.SERIALIZABLE) { + // Transaction Levels + semantics.put(node.getSymbol(), "type"); + } else if (MySqlParser.GEOMETRYCOLLECTION <= type && type <= MySqlParser.POLYGON) { + // Spatial data types + semantics.put(node.getSymbol(), "type"); + } + } + } + + @Override + public void visitTerminal(TerminalNode node) { + processTerminalNode(node); + } + + @Override + public void visitErrorNode(ErrorNode node) { + processTerminalNode(node); + } + + }); + + parser.sqlStatements(); + + List tokens = semantics.entrySet().stream() + .map(e -> new SemanticTokenData(e.getKey().getStartIndex() + initialOffset, + e.getKey().getStartIndex() + e.getKey().getText().length() + initialOffset, e.getValue(), + new String[0])) + .collect(Collectors.toList()); + + Collections.sort(tokens); + + return tokens; + + } + +} diff --git a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProviderTest.java b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProviderTest.java index 4e6a77b25..4c1af30f7 100644 --- a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProviderTest.java +++ b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProviderTest.java @@ -300,7 +300,7 @@ public class JdtDataQuerySemanticTokensProviderTest { public interface OwnerRepository { - @Query(value = "SELECT DISTINCT owner FROM Owner owner", nativeQuery = true) + @Query(value = "SELECT * FROM USERS u WHERE u.status = 1", nativeQuery = true) void findByLastName(); } """; @@ -312,7 +312,45 @@ public class JdtDataQuerySemanticTokensProviderTest { List tokens = computeTokens(cu); - assertThat(tokens.size()).isZero(); + SemanticTokenData token = tokens.get(0); + assertThat(source.substring(token.start(), token.end())).isEqualTo("SELECT"); + assertThat(token).isEqualTo(new SemanticTokenData(128, 134, "keyword", new String[0])); + + token = tokens.get(1); + assertThat(source.substring(token.start(), token.end())).isEqualTo("*"); + assertThat(token).isEqualTo(new SemanticTokenData(135, 136, "operator", new String[0])); + + token = tokens.get(2); + assertThat(source.substring(token.start(), token.end())).isEqualTo("FROM"); + assertThat(token).isEqualTo(new SemanticTokenData(137, 141, "keyword", new String[0])); + + token = tokens.get(3); + assertThat(source.substring(token.start(), token.end())).isEqualTo("USERS"); + assertThat(token).isEqualTo(new SemanticTokenData(142, 147, "variable", new String[0])); + + token = tokens.get(4); + assertThat(source.substring(token.start(), token.end())).isEqualTo("u"); + assertThat(token).isEqualTo(new SemanticTokenData(148, 149, "variable", new String[0])); + + token = tokens.get(5); + assertThat(source.substring(token.start(), token.end())).isEqualTo("WHERE"); + assertThat(token).isEqualTo(new SemanticTokenData(150, 155, "keyword", new String[0])); + + token = tokens.get(6); + assertThat(source.substring(token.start(), token.end())).isEqualTo("u"); + assertThat(token).isEqualTo(new SemanticTokenData(156, 157, "variable", new String[0])); + + token = tokens.get(7); + assertThat(source.substring(token.start(), token.end())).isEqualTo(".status"); + assertThat(token).isEqualTo(new SemanticTokenData(157, 164, "variable", new String[0])); + + token = tokens.get(8); + assertThat(source.substring(token.start(), token.end())).isEqualTo("="); + assertThat(token).isEqualTo(new SemanticTokenData(165, 166, "operator", new String[0])); + + token = tokens.get(9); + assertThat(source.substring(token.start(), token.end())).isEqualTo("1"); + assertThat(token).isEqualTo(new SemanticTokenData(167, 168, "number", new String[0])); } diff --git a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryReconcilerTest.java b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryReconcilerTest.java index 28463492c..7771975a4 100644 --- a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryReconcilerTest.java +++ b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryReconcilerTest.java @@ -71,7 +71,7 @@ public class QueryReconcilerTest { String docUri = directory.toPath().resolve("src/main/resources/jpa-named-queries.properties").toUri() .toString(); Editor editor = harness.newEditor(LanguageId.JPA_QUERY_PROPERTIES, source, docUri); - editor.assertProblems("SELECTX|mismatched input 'SELECTX'"); + editor.assertProblems("SELECTX|HQL: mismatched input 'SELECTX'"); } @Test @@ -99,7 +99,7 @@ public class QueryReconcilerTest { String docUri = directory.toPath().resolve("src/main/resources/jpa-named-queries.properties").toUri() .toString(); Editor editor = harness.newEditor(LanguageId.JPA_QUERY_PROPERTIES, source, docUri); - editor.assertProblems("WHERE|no viable alternative"); + editor.assertProblems("WHERE|JPQL: no viable alternative"); } @Test @@ -141,7 +141,7 @@ public class QueryReconcilerTest { String docUri = directory.toPath().resolve("src/main/java/example/demo/OwnerRepository.java").toUri() .toString(); Editor editor = harness.newEditor(LanguageId.JAVA, source, docUri); - editor.assertProblems("SELECTX|mismatched input 'SELECTX'"); + editor.assertProblems("SELECTX|HQL: mismatched input 'SELECTX'"); } @Test @@ -164,7 +164,7 @@ public class QueryReconcilerTest { String docUri = directory.toPath().resolve("src/main/java/example/demo/OwnerRepository.java").toUri() .toString(); Editor editor = harness.newEditor(LanguageId.JAVA, source, docUri); - editor.assertProblems("SELECTX|mismatched input 'SELECTX'"); + editor.assertProblems("SELECTX|HQL: mismatched input 'SELECTX'"); } @Test @@ -185,7 +185,7 @@ public class QueryReconcilerTest { String docUri = directory.toPath().resolve("src/main/java/example/demo/OwnerRepository.java").toUri() .toString(); Editor editor = harness.newEditor(LanguageId.JAVA, source, docUri); - editor.assertProblems("SELECTX|mismatched input 'SELECTX'"); + editor.assertProblems("SELECTX|HQL: mismatched input 'SELECTX'"); } @Test @@ -206,7 +206,7 @@ public class QueryReconcilerTest { String docUri = directory.toPath().resolve("src/main/java/example/demo/OwnerRepository.java").toUri() .toString(); Editor editor = harness.newEditor(LanguageId.JAVA, source, docUri); - editor.assertProblems(); + editor.assertProblems("SELECTX|SQL: mismatched input 'SELECTX' expecting {'ALTER',"); } @Test